#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stddef.h>
#include <time.h>
#include <pthread.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/time.h>
#include <errno.h>
#include <sys/mman.h>
#include <dlfcn.h>

Data Structures
struct	sqlite3_file

struct	sqlite3_io_methods

struct	sqlite3_vfs

struct	sqlite3_mem_methods

struct	sqlite3_module

struct	sqlite3_index_info

struct	sqlite3_index_info::sqlite3_index_constraint

struct	sqlite3_index_info::sqlite3_index_orderby

struct	sqlite3_index_info::sqlite3_index_constraint_usage

struct	sqlite3_vtab

struct	sqlite3_vtab_cursor

struct	sqlite3_mutex_methods

struct	sqlite3_pcache_page

struct	sqlite3_pcache_methods2

struct	sqlite3_pcache_methods

struct	sqlite3_snapshot

struct	sqlite3_rtree_geometry

struct	sqlite3_rtree_query_info

struct	Fts5PhraseIter

struct	Fts5ExtensionApi

struct	fts5_tokenizer

struct	fts5_api

struct	Hash

struct	Hash::_ht

struct	HashElem

struct	BusyHandler

struct	BtreePayload

struct	VdbeOp

union	VdbeOp::p4union

struct	SubProgram

struct	VdbeOpList

struct	PgHdr

struct	Db

struct	Schema

struct	Lookaside

struct	LookasideSlot

struct	FuncDefHash

struct	sqlite3

struct	sqlite3::sqlite3InitInfo

struct	FuncDef

struct	FuncDestructor

struct	Savepoint

struct	Module

struct	Column

struct	CollSeq

struct	VTable

struct	Table

struct	FKey

struct	FKey::sColMap

struct	KeyInfo

struct	UnpackedRecord

struct	Index

struct	IndexSample

struct	Token

struct	AggInfo

struct	AggInfo::AggInfo_col

struct	AggInfo::AggInfo_func

struct	Expr

struct	ExprList

struct	ExprList::ExprList_item

struct	IdList

struct	IdList::IdList_item

struct	SrcList

struct	SrcList::SrcList_item

struct	NameContext

struct	Upsert

struct	Select

struct	SelectDest

struct	AutoincInfo

struct	TriggerPrg

struct	Parse

struct	AuthContext

struct	Trigger

struct	TriggerStep

struct	DbFixer

struct	sqlite3_str

struct	InitData

struct	Sqlite3Config

struct	Walker

struct	With

struct	With::Cte

struct	Window

struct	PrintfArguments

struct	VdbeCursor

struct	VdbeFrame

struct	sqlite3_value

union	sqlite3_value::MemValue

struct	AuxData

struct	sqlite3_context

struct	ScanStatus

struct	DblquoteStr

struct	Vdbe

struct	PreUpdate

struct	sqlite3StatType

struct	DateTime

struct	BenignMallocHooks

struct	sqlite3_mutex

struct	Mem0Global

struct	et_info

struct	sqlite3PrngType

struct	SQLiteThread

struct	UnixUnusedFd

struct	unixFile

struct	unix_syscall

struct	vxworksFileId

struct	unixFileId

struct	unixInodeInfo

struct	unixShmNode

struct	unixShm

struct	Bitvec

struct	PCache

struct	PgHdr1

struct	PGroup

struct	PCache1

struct	PgFreeslot

struct	PCacheGlobal

struct	RowSetEntry

struct	RowSetChunk

struct	RowSet

struct	PagerSavepoint

struct	Pager

struct	WalIndexHdr

struct	WalCkptInfo

struct	Wal

struct	WalIterator

struct	WalIterator::WalSegment

struct	WalHashLoc

struct	WalWriter

struct	MemPage

struct	BtLock

struct	Btree

struct	BtShared

struct	CellInfo

struct	BtCursor

struct	IntegrityCk

struct	CellArray

struct	sqlite3_backup

struct	ValueNewStat4Ctx

struct	ReusableSpace

struct	Incrblob

struct	SorterFile

struct	SorterList

struct	MergeEngine

struct	SortSubtask

struct	VdbeSorter

struct	PmaReader

struct	IncrMerger

struct	PmaWriter

struct	SorterRecord

struct	FileChunk

struct	FilePoint

struct	MemJournal

struct	IdxCover

struct	SrcCount

struct	RenameToken

struct	RenameCtx

struct	StatSample

struct	StatAccum

struct	analysisInfo

struct	TableLock

struct	compareInfo

struct	SumCtx

struct	CountCtx

struct	sqlite3_api_routines

struct	sqlite3AutoExtList

struct	PragmaName

struct	PragmaVtab

struct	PragmaVtabCursor

struct	DistinctCtx

struct	SortCtx

struct	RowLoadInfo

struct	SubstContext

struct	WhereConst

struct	TabResult

struct	VtabCtx

struct	WhereLevel

struct	WhereLoop

struct	WhereOrCost

struct	WhereOrSet

struct	WherePath

struct	WhereTerm

struct	WhereScan

struct	WhereClause

struct	WhereOrInfo

struct	WhereAndInfo

struct	WhereMaskSet

struct	WhereLoopBuilder

struct	WhereExprMod

struct	WhereInfo

struct	IdxExprTrans

struct	HiddenIndexInfo

struct	CallCount

struct	NthValueCtx

struct	NtileCtx

struct	LastValueCtx

struct	WindowRewrite

struct	WindowCsrAndReg

struct	WindowCodeArg

struct	TrigEvent

struct	FrameBound

union	YYMINORTYPE

struct	yyStackEntry

struct	yyParser

Macros
#define	SQLITE_CORE 1

#define	SQLITE_AMALGAMATION 1

#define	SQLITE_PRIVATE static

#define	CTIMEOPT_VAL_(opt) #opt

#define	CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)

#define	CTIMEOPT_VAL2_(opt1, opt2) #opt1 "," #opt2

#define	CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt)

#define	SQLITEINT_H

#define	SQLITE_TCLAPI

#define	SQLITE_MSVC_H

#define	OS_VXWORKS 0

#define	HAVE_FCHOWN 1

#define	HAVE_READLINK 1

#define	HAVE_LSTAT 1

#define	_LARGE_FILE 1

#define	_FILE_OFFSET_BITS 64

#define	_LARGEFILE_SOURCE 1

#define	GCC_VERSION 0

#define	MSVC_VERSION 0

#define	deliberate_fall_through

#define	SQLITE3_H

#define	SQLITE_EXTERN extern

#define	SQLITE_API

#define	SQLITE_CDECL

#define	SQLITE_APICALL

#define	SQLITE_STDCALL SQLITE_APICALL

#define	SQLITE_CALLBACK

#define	SQLITE_SYSAPI

#define	SQLITE_DEPRECATED

#define	SQLITE_EXPERIMENTAL

#define	SQLITE_VERSION "3.33.0"

#define	SQLITE_VERSION_NUMBER 3033000

#define	SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f"

#define	SQLITE_OK 0 /* Successful result */

#define	SQLITE_ERROR 1 /* Generic error */

#define	SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

#define	SQLITE_PERM 3 /* Access permission denied */

#define	SQLITE_ABORT 4 /* Callback routine requested an abort */

#define	SQLITE_BUSY 5 /* The database file is locked */

#define	SQLITE_LOCKED 6 /* A table in the database is locked */

#define	SQLITE_NOMEM 7 /* A malloc() failed */

#define	SQLITE_READONLY 8 /* Attempt to write a readonly database */

#define	SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

#define	SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

#define	SQLITE_CORRUPT 11 /* The database disk image is malformed */

#define	SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

#define	SQLITE_FULL 13 /* Insertion failed because database is full */

#define	SQLITE_CANTOPEN 14 /* Unable to open the database file */

#define	SQLITE_PROTOCOL 15 /* Database lock protocol error */

#define	SQLITE_EMPTY 16 /* Internal use only */

#define	SQLITE_SCHEMA 17 /* The database schema changed */

#define	SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

#define	SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

#define	SQLITE_MISMATCH 20 /* Data type mismatch */

#define	SQLITE_MISUSE 21 /* Library used incorrectly */

#define	SQLITE_NOLFS 22 /* Uses OS features not supported on host */

#define	SQLITE_AUTH 23 /* Authorization denied */

#define	SQLITE_FORMAT 24 /* Not used */

#define	SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

#define	SQLITE_NOTADB 26 /* File opened that is not a database file */

#define	SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */

#define	SQLITE_WARNING 28 /* Warnings from sqlite3_log() */

#define	SQLITE_ROW 100 /* sqlite3_step() has another row ready */

#define	SQLITE_DONE 101 /* sqlite3_step() has finished executing */

#define	SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR \| (1<<8))

#define	SQLITE_ERROR_RETRY (SQLITE_ERROR \| (2<<8))

#define	SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR \| (3<<8))

#define	SQLITE_IOERR_READ (SQLITE_IOERR \| (1<<8))

#define	SQLITE_IOERR_SHORT_READ (SQLITE_IOERR \| (2<<8))

#define	SQLITE_IOERR_WRITE (SQLITE_IOERR \| (3<<8))

#define	SQLITE_IOERR_FSYNC (SQLITE_IOERR \| (4<<8))

#define	SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR \| (5<<8))

#define	SQLITE_IOERR_TRUNCATE (SQLITE_IOERR \| (6<<8))

#define	SQLITE_IOERR_FSTAT (SQLITE_IOERR \| (7<<8))

#define	SQLITE_IOERR_UNLOCK (SQLITE_IOERR \| (8<<8))

#define	SQLITE_IOERR_RDLOCK (SQLITE_IOERR \| (9<<8))

#define	SQLITE_IOERR_DELETE (SQLITE_IOERR \| (10<<8))

#define	SQLITE_IOERR_BLOCKED (SQLITE_IOERR \| (11<<8))

#define	SQLITE_IOERR_NOMEM (SQLITE_IOERR \| (12<<8))

#define	SQLITE_IOERR_ACCESS (SQLITE_IOERR \| (13<<8))

#define	SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR \| (14<<8))

#define	SQLITE_IOERR_LOCK (SQLITE_IOERR \| (15<<8))

#define	SQLITE_IOERR_CLOSE (SQLITE_IOERR \| (16<<8))

#define	SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR \| (17<<8))

#define	SQLITE_IOERR_SHMOPEN (SQLITE_IOERR \| (18<<8))

#define	SQLITE_IOERR_SHMSIZE (SQLITE_IOERR \| (19<<8))

#define	SQLITE_IOERR_SHMLOCK (SQLITE_IOERR \| (20<<8))

#define	SQLITE_IOERR_SHMMAP (SQLITE_IOERR \| (21<<8))

#define	SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))

#define	SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))

#define	SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))

#define	SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR \| (25<<8))

#define	SQLITE_IOERR_CONVPATH (SQLITE_IOERR \| (26<<8))

#define	SQLITE_IOERR_VNODE (SQLITE_IOERR \| (27<<8))

#define	SQLITE_IOERR_AUTH (SQLITE_IOERR \| (28<<8))

#define	SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR \| (29<<8))

#define	SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR \| (30<<8))

#define	SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR \| (31<<8))

#define	SQLITE_IOERR_DATA (SQLITE_IOERR \| (32<<8))

#define	SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))

#define	SQLITE_LOCKED_VTAB (SQLITE_LOCKED \| (2<<8))

#define	SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))

#define	SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))

#define	SQLITE_BUSY_TIMEOUT (SQLITE_BUSY \| (3<<8))

#define	SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))

#define	SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))

#define	SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))

#define	SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN \| (4<<8))

#define	SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN \| (5<<8)) /* Not Used */

#define	SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN \| (6<<8))

#define	SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))

#define	SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT \| (2<<8))

#define	SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT \| (3<<8))

#define	SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))

#define	SQLITE_READONLY_CANTLOCK (SQLITE_READONLY \| (2<<8))

#define	SQLITE_READONLY_ROLLBACK (SQLITE_READONLY \| (3<<8))

#define	SQLITE_READONLY_DBMOVED (SQLITE_READONLY \| (4<<8))

#define	SQLITE_READONLY_CANTINIT (SQLITE_READONLY \| (5<<8))

#define	SQLITE_READONLY_DIRECTORY (SQLITE_READONLY \| (6<<8))

#define	SQLITE_ABORT_ROLLBACK (SQLITE_ABORT \| (2<<8))

#define	SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT \| (1<<8))

#define	SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT \| (2<<8))

#define	SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT \| (3<<8))

#define	SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT \| (4<<8))

#define	SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT \| (5<<8))

#define	SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT \| (6<<8))

#define	SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))

#define	SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))

#define	SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))

#define	SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT \|(10<<8))

#define	SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT \|(11<<8))

#define	SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))

#define	SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))

#define	SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))

#define	SQLITE_AUTH_USER (SQLITE_AUTH \| (1<<8))

#define	SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK \| (1<<8))

#define	SQLITE_OK_SYMLINK (SQLITE_OK \| (2<<8))

#define	SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

#define	SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

#define	SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

#define	SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

#define	SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

#define	SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

#define	SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

#define	SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

#define	SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

#define	SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */

#define	SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_WAL 0x00080000 /* VFS only */

#define	SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */

#define	SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

#define	SQLITE_IOCAP_ATOMIC 0x00000001

#define	SQLITE_IOCAP_ATOMIC512 0x00000002

#define	SQLITE_IOCAP_ATOMIC1K 0x00000004

#define	SQLITE_IOCAP_ATOMIC2K 0x00000008

#define	SQLITE_IOCAP_ATOMIC4K 0x00000010

#define	SQLITE_IOCAP_ATOMIC8K 0x00000020

#define	SQLITE_IOCAP_ATOMIC16K 0x00000040

#define	SQLITE_IOCAP_ATOMIC32K 0x00000080

#define	SQLITE_IOCAP_ATOMIC64K 0x00000100

#define	SQLITE_IOCAP_SAFE_APPEND 0x00000200

#define	SQLITE_IOCAP_SEQUENTIAL 0x00000400

#define	SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

#define	SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

#define	SQLITE_IOCAP_IMMUTABLE 0x00002000

#define	SQLITE_IOCAP_BATCH_ATOMIC 0x00004000

#define	SQLITE_LOCK_NONE 0

#define	SQLITE_LOCK_SHARED 1

#define	SQLITE_LOCK_RESERVED 2

#define	SQLITE_LOCK_PENDING 3

#define	SQLITE_LOCK_EXCLUSIVE 4

#define	SQLITE_SYNC_NORMAL 0x00002

#define	SQLITE_SYNC_FULL 0x00003

#define	SQLITE_SYNC_DATAONLY 0x00010

#define	SQLITE_FCNTL_LOCKSTATE 1

#define	SQLITE_FCNTL_GET_LOCKPROXYFILE 2

#define	SQLITE_FCNTL_SET_LOCKPROXYFILE 3

#define	SQLITE_FCNTL_LAST_ERRNO 4

#define	SQLITE_FCNTL_SIZE_HINT 5

#define	SQLITE_FCNTL_CHUNK_SIZE 6

#define	SQLITE_FCNTL_FILE_POINTER 7

#define	SQLITE_FCNTL_SYNC_OMITTED 8

#define	SQLITE_FCNTL_WIN32_AV_RETRY 9

#define	SQLITE_FCNTL_PERSIST_WAL 10

#define	SQLITE_FCNTL_OVERWRITE 11

#define	SQLITE_FCNTL_VFSNAME 12

#define	SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

#define	SQLITE_FCNTL_PRAGMA 14

#define	SQLITE_FCNTL_BUSYHANDLER 15

#define	SQLITE_FCNTL_TEMPFILENAME 16

#define	SQLITE_FCNTL_MMAP_SIZE 18

#define	SQLITE_FCNTL_TRACE 19

#define	SQLITE_FCNTL_HAS_MOVED 20

#define	SQLITE_FCNTL_SYNC 21

#define	SQLITE_FCNTL_COMMIT_PHASETWO 22

#define	SQLITE_FCNTL_WIN32_SET_HANDLE 23

#define	SQLITE_FCNTL_WAL_BLOCK 24

#define	SQLITE_FCNTL_ZIPVFS 25

#define	SQLITE_FCNTL_RBU 26

#define	SQLITE_FCNTL_VFS_POINTER 27

#define	SQLITE_FCNTL_JOURNAL_POINTER 28

#define	SQLITE_FCNTL_WIN32_GET_HANDLE 29

#define	SQLITE_FCNTL_PDB 30

#define	SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31

#define	SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32

#define	SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33

#define	SQLITE_FCNTL_LOCK_TIMEOUT 34

#define	SQLITE_FCNTL_DATA_VERSION 35

#define	SQLITE_FCNTL_SIZE_LIMIT 36

#define	SQLITE_FCNTL_CKPT_DONE 37

#define	SQLITE_FCNTL_RESERVE_BYTES 38

#define	SQLITE_FCNTL_CKPT_START 39

#define	SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

#define	SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

#define	SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

#define	SQLITE_ACCESS_EXISTS 0

#define	SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

#define	SQLITE_ACCESS_READ 2 /* Unused */

#define	SQLITE_SHM_UNLOCK 1

#define	SQLITE_SHM_LOCK 2

#define	SQLITE_SHM_SHARED 4

#define	SQLITE_SHM_EXCLUSIVE 8

#define	SQLITE_SHM_NLOCK 8

#define	SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

#define	SQLITE_CONFIG_MULTITHREAD 2 /* nil */

#define	SQLITE_CONFIG_SERIALIZED 3 /* nil */

#define	SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

#define	SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

#define	SQLITE_CONFIG_SCRATCH 6 /* No longer used */

#define	SQLITE_CONFIG_PAGECACHE 7 /* void, int sz, int N /

#define	SQLITE_CONFIG_HEAP 8 /* void, int nByte, int min /

#define	SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

#define	SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

#define	SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

#define	SQLITE_CONFIG_LOOKASIDE 13 /* int int */

#define	SQLITE_CONFIG_PCACHE 14 /* no-op */

#define	SQLITE_CONFIG_GETPCACHE 15 /* no-op */

#define	SQLITE_CONFIG_LOG 16 /* xFunc, void* */

#define	SQLITE_CONFIG_URI 17 /* int */

#define	SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

#define	SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

#define	SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

#define	SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */

#define	SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

#define	SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

#define	SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int psz /

#define	SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

#define	SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */

#define	SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */

#define	SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */

#define	SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */

#define	SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */

#define	SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */

#define	SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */

#define	SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */

#define	SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */

#define	SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */

#define	SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */

#define	SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */

#define	SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */

#define	SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */

#define	SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */

#define	SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */

#define	SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */

#define	SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */

#define	SQLITE_DBCONFIG_MAX 1017 /* Largest DBCONFIG */

#define	SQLITE_DENY 1 /* Abort the SQL statement with an error */

#define	SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */

#define	SQLITE_CREATE_INDEX 1 /* Index Name Table Name */

#define	SQLITE_CREATE_TABLE 2 /* Table Name NULL */

#define	SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */

#define	SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

#define	SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */

#define	SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

#define	SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */

#define	SQLITE_CREATE_VIEW 8 /* View Name NULL */

#define	SQLITE_DELETE 9 /* Table Name NULL */

#define	SQLITE_DROP_INDEX 10 /* Index Name Table Name */

#define	SQLITE_DROP_TABLE 11 /* Table Name NULL */

#define	SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */

#define	SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

#define	SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */

#define	SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

#define	SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */

#define	SQLITE_DROP_VIEW 17 /* View Name NULL */

#define	SQLITE_INSERT 18 /* Table Name NULL */

#define	SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */

#define	SQLITE_READ 20 /* Table Name Column Name */

#define	SQLITE_SELECT 21 /* NULL NULL */

#define	SQLITE_TRANSACTION 22 /* Operation NULL */

#define	SQLITE_UPDATE 23 /* Table Name Column Name */

#define	SQLITE_ATTACH 24 /* Filename NULL */

#define	SQLITE_DETACH 25 /* Database Name NULL */

#define	SQLITE_ALTER_TABLE 26 /* Database Name Table Name */

#define	SQLITE_REINDEX 27 /* Index Name NULL */

#define	SQLITE_ANALYZE 28 /* Table Name NULL */

#define	SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */

#define	SQLITE_DROP_VTABLE 30 /* Table Name Module Name */

#define	SQLITE_FUNCTION 31 /* NULL Function Name */

#define	SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

#define	SQLITE_COPY 0 /* No longer used */

#define	SQLITE_RECURSIVE 33 /* NULL NULL */

#define	SQLITE_TRACE_STMT 0x01

#define	SQLITE_TRACE_PROFILE 0x02

#define	SQLITE_TRACE_ROW 0x04

#define	SQLITE_TRACE_CLOSE 0x08

#define	SQLITE_LIMIT_LENGTH 0

#define	SQLITE_LIMIT_SQL_LENGTH 1

#define	SQLITE_LIMIT_COLUMN 2

#define	SQLITE_LIMIT_EXPR_DEPTH 3

#define	SQLITE_LIMIT_COMPOUND_SELECT 4

#define	SQLITE_LIMIT_VDBE_OP 5

#define	SQLITE_LIMIT_FUNCTION_ARG 6

#define	SQLITE_LIMIT_ATTACHED 7

#define	SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

#define	SQLITE_LIMIT_VARIABLE_NUMBER 9

#define	SQLITE_LIMIT_TRIGGER_DEPTH 10

#define	SQLITE_LIMIT_WORKER_THREADS 11

#define	SQLITE_PREPARE_PERSISTENT 0x01

#define	SQLITE_PREPARE_NORMALIZE 0x02

#define	SQLITE_PREPARE_NO_VTAB 0x04

#define	SQLITE_INTEGER 1

#define	SQLITE_FLOAT 2

#define	SQLITE_BLOB 4

#define	SQLITE_NULL 5

#define	SQLITE_TEXT 3

#define	SQLITE3_TEXT 3

#define	SQLITE_UTF8 1 /* IMP: R-37514-35566 */

#define	SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */

#define	SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */

#define	SQLITE_UTF16 4 /* Use native byte order */

#define	SQLITE_ANY 5 /* Deprecated */

#define	SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

#define	SQLITE_DETERMINISTIC 0x000000800

#define	SQLITE_DIRECTONLY 0x000080000

#define	SQLITE_SUBTYPE 0x000100000

#define	SQLITE_INNOCUOUS 0x000200000

#define	SQLITE_STATIC ((sqlite3_destructor_type)0)

#define	SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

#define	SQLITE_WIN32_DATA_DIRECTORY_TYPE 1

#define	SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2

#define	SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */

#define	SQLITE_INDEX_CONSTRAINT_EQ 2

#define	SQLITE_INDEX_CONSTRAINT_GT 4

#define	SQLITE_INDEX_CONSTRAINT_LE 8

#define	SQLITE_INDEX_CONSTRAINT_LT 16

#define	SQLITE_INDEX_CONSTRAINT_GE 32

#define	SQLITE_INDEX_CONSTRAINT_MATCH 64

#define	SQLITE_INDEX_CONSTRAINT_LIKE 65

#define	SQLITE_INDEX_CONSTRAINT_GLOB 66

#define	SQLITE_INDEX_CONSTRAINT_REGEXP 67

#define	SQLITE_INDEX_CONSTRAINT_NE 68

#define	SQLITE_INDEX_CONSTRAINT_ISNOT 69

#define	SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70

#define	SQLITE_INDEX_CONSTRAINT_ISNULL 71

#define	SQLITE_INDEX_CONSTRAINT_IS 72

#define	SQLITE_INDEX_CONSTRAINT_FUNCTION 150

#define	SQLITE_MUTEX_FAST 0

#define	SQLITE_MUTEX_RECURSIVE 1

#define	SQLITE_MUTEX_STATIC_MAIN 2

#define	SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

#define	SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

#define	SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

#define	SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */

#define	SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

#define	SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

#define	SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

#define	SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */

#define	SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */

#define	SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */

#define	SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */

#define	SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */

#define	SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */

#define	SQLITE_MUTEX_STATIC_MASTER 2

#define	SQLITE_TESTCTRL_FIRST 5

#define	SQLITE_TESTCTRL_PRNG_SAVE 5

#define	SQLITE_TESTCTRL_PRNG_RESTORE 6

#define	SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */

#define	SQLITE_TESTCTRL_BITVEC_TEST 8

#define	SQLITE_TESTCTRL_FAULT_INSTALL 9

#define	SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

#define	SQLITE_TESTCTRL_PENDING_BYTE 11

#define	SQLITE_TESTCTRL_ASSERT 12

#define	SQLITE_TESTCTRL_ALWAYS 13

#define	SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */

#define	SQLITE_TESTCTRL_OPTIMIZATIONS 15

#define	SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */

#define	SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */

#define	SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17

#define	SQLITE_TESTCTRL_LOCALTIME_FAULT 18

#define	SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

#define	SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19

#define	SQLITE_TESTCTRL_NEVER_CORRUPT 20

#define	SQLITE_TESTCTRL_VDBE_COVERAGE 21

#define	SQLITE_TESTCTRL_BYTEORDER 22

#define	SQLITE_TESTCTRL_ISINIT 23

#define	SQLITE_TESTCTRL_SORTER_MMAP 24

#define	SQLITE_TESTCTRL_IMPOSTER 25

#define	SQLITE_TESTCTRL_PARSER_COVERAGE 26

#define	SQLITE_TESTCTRL_RESULT_INTREAL 27

#define	SQLITE_TESTCTRL_PRNG_SEED 28

#define	SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29

#define	SQLITE_TESTCTRL_LAST 29 /* Largest TESTCTRL */

#define	SQLITE_STATUS_MEMORY_USED 0

#define	SQLITE_STATUS_PAGECACHE_USED 1

#define	SQLITE_STATUS_PAGECACHE_OVERFLOW 2

#define	SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */

#define	SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */

#define	SQLITE_STATUS_MALLOC_SIZE 5

#define	SQLITE_STATUS_PARSER_STACK 6

#define	SQLITE_STATUS_PAGECACHE_SIZE 7

#define	SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */

#define	SQLITE_STATUS_MALLOC_COUNT 9

#define	SQLITE_DBSTATUS_LOOKASIDE_USED 0

#define	SQLITE_DBSTATUS_CACHE_USED 1

#define	SQLITE_DBSTATUS_SCHEMA_USED 2

#define	SQLITE_DBSTATUS_STMT_USED 3

#define	SQLITE_DBSTATUS_LOOKASIDE_HIT 4

#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

#define	SQLITE_DBSTATUS_CACHE_HIT 7

#define	SQLITE_DBSTATUS_CACHE_MISS 8

#define	SQLITE_DBSTATUS_CACHE_WRITE 9

#define	SQLITE_DBSTATUS_DEFERRED_FKS 10

#define	SQLITE_DBSTATUS_CACHE_USED_SHARED 11

#define	SQLITE_DBSTATUS_CACHE_SPILL 12

#define	SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */

#define	SQLITE_STMTSTATUS_FULLSCAN_STEP 1

#define	SQLITE_STMTSTATUS_SORT 2

#define	SQLITE_STMTSTATUS_AUTOINDEX 3

#define	SQLITE_STMTSTATUS_VM_STEP 4

#define	SQLITE_STMTSTATUS_REPREPARE 5

#define	SQLITE_STMTSTATUS_RUN 6

#define	SQLITE_STMTSTATUS_MEMUSED 99

#define	SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */

#define	SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */

#define	SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */

#define	SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */

#define	SQLITE_VTAB_CONSTRAINT_SUPPORT 1

#define	SQLITE_VTAB_INNOCUOUS 2

#define	SQLITE_VTAB_DIRECTONLY 3

#define	SQLITE_ROLLBACK 1

#define	SQLITE_FAIL 3

#define	SQLITE_REPLACE 5

#define	SQLITE_SCANSTAT_NLOOP 0

#define	SQLITE_SCANSTAT_NVISIT 1

#define	SQLITE_SCANSTAT_EST 2

#define	SQLITE_SCANSTAT_NAME 3

#define	SQLITE_SCANSTAT_EXPLAIN 4

#define	SQLITE_SCANSTAT_SELECTID 5

#define	SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */

#define	SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */

#define	SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */

#define	SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */

#define	_SQLITE3RTREE_H_

#define	NOT_WITHIN 0 /* Object completely outside of query region */

#define	PARTLY_WITHIN 1 /* Object partially overlaps query region */

#define	FULLY_WITHIN 2 /* Object fully contained within query region */

#define	_FTS5_H

#define	FTS5_TOKENIZE_QUERY 0x0001

#define	FTS5_TOKENIZE_PREFIX 0x0002

#define	FTS5_TOKENIZE_DOCUMENT 0x0004

#define	FTS5_TOKENIZE_AUX 0x0008

#define	FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */

#define	SQLITE_MAX_LENGTH 1000000000

#define	SQLITE_MAX_COLUMN 2000

#define	SQLITE_MAX_SQL_LENGTH 1000000000

#define	SQLITE_MAX_EXPR_DEPTH 1000

#define	SQLITE_MAX_COMPOUND_SELECT 500

#define	SQLITE_MAX_VDBE_OP 250000000

#define	SQLITE_MAX_FUNCTION_ARG 127

#define	SQLITE_DEFAULT_CACHE_SIZE -2000

#define	SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000

#define	SQLITE_MAX_ATTACHED 10

#define	SQLITE_MAX_VARIABLE_NUMBER 32766

#define	SQLITE_MAX_PAGE_SIZE 65536

#define	SQLITE_DEFAULT_PAGE_SIZE 4096

#define	SQLITE_MAX_DEFAULT_PAGE_SIZE 8192

#define	SQLITE_MAX_PAGE_COUNT 1073741823

#define	SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

#define	SQLITE_MAX_TRIGGER_DEPTH 1000

#define	__has_extension(x) 0 /* compatibility with non-clang compilers */

#define	AtomicLoad(PTR) (*(PTR))

#define	AtomicStore(PTR, VAL) (*(PTR) = (VAL))

#define	SQLITE_INT_TO_PTR(X) ((void)&((char)0)[X])

#define	SQLITE_PTR_TO_INT(X) ((int)(((char)X)-(char)0))

#define	SQLITE_NOINLINE

#define	SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

#define	SQLITE_POWERSAFE_OVERWRITE 1

#define	SQLITE_DEFAULT_MEMSTATUS 1

#define	SQLITE_SYSTEM_MALLOC 1

#define	SQLITE_MALLOC_SOFT_LIMIT 1024

#define	_XOPEN_SOURCE 600

#define	NDEBUG 1

#define	testcase(X)

#define	TESTONLY(X)

#define	VVA_ONLY(X)

#define	ALWAYS(X) (X)

#define	NEVER(X) (X)

#define	harmless(X)

#define	OK_IF_ALWAYS_TRUE(X) (X)

#define	OK_IF_ALWAYS_FALSE(X) (X)

#define	ONLY_IF_REALLOC_STRESS(X) (0)

#define	OSTRACE(X)

#define	IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

#define	likely(X) (X)

#define	unlikely(X) (X)

#define	SQLITE_HASH_H

#define	sqliteHashFirst(H) ((H)->first)

#define	sqliteHashNext(E) ((E)->next)

#define	sqliteHashData(E) ((E)->data)

#define	TK_SEMI 1

#define	TK_EXPLAIN 2

#define	TK_QUERY 3

#define	TK_PLAN 4

#define	TK_BEGIN 5

#define	TK_TRANSACTION 6

#define	TK_DEFERRED 7

#define	TK_IMMEDIATE 8

#define	TK_EXCLUSIVE 9

#define	TK_COMMIT 10

#define	TK_END 11

#define	TK_ROLLBACK 12

#define	TK_SAVEPOINT 13

#define	TK_RELEASE 14

#define	TK_TO 15

#define	TK_TABLE 16

#define	TK_CREATE 17

#define	TK_IF 18

#define	TK_NOT 19

#define	TK_EXISTS 20

#define	TK_TEMP 21

#define	TK_LP 22

#define	TK_RP 23

#define	TK_AS 24

#define	TK_WITHOUT 25

#define	TK_COMMA 26

#define	TK_ABORT 27

#define	TK_ACTION 28

#define	TK_AFTER 29

#define	TK_ANALYZE 30

#define	TK_ASC 31

#define	TK_ATTACH 32

#define	TK_BEFORE 33

#define	TK_BY 34

#define	TK_CASCADE 35

#define	TK_CAST 36

#define	TK_CONFLICT 37

#define	TK_DATABASE 38

#define	TK_DESC 39

#define	TK_DETACH 40

#define	TK_EACH 41

#define	TK_FAIL 42

#define	TK_OR 43

#define	TK_AND 44

#define	TK_IS 45

#define	TK_MATCH 46

#define	TK_LIKE_KW 47

#define	TK_BETWEEN 48

#define	TK_IN 49

#define	TK_ISNULL 50

#define	TK_NOTNULL 51

#define	TK_NE 52

#define	TK_EQ 53

#define	TK_GT 54

#define	TK_LE 55

#define	TK_LT 56

#define	TK_GE 57

#define	TK_ESCAPE 58

#define	TK_ID 59

#define	TK_COLUMNKW 60

#define	TK_DO 61

#define	TK_FOR 62

#define	TK_IGNORE 63

#define	TK_INITIALLY 64

#define	TK_INSTEAD 65

#define	TK_NO 66

#define	TK_KEY 67

#define	TK_OF 68

#define	TK_OFFSET 69

#define	TK_PRAGMA 70

#define	TK_RAISE 71

#define	TK_RECURSIVE 72

#define	TK_REPLACE 73

#define	TK_RESTRICT 74

#define	TK_ROW 75

#define	TK_ROWS 76

#define	TK_TRIGGER 77

#define	TK_VACUUM 78

#define	TK_VIEW 79

#define	TK_VIRTUAL 80

#define	TK_WITH 81

#define	TK_NULLS 82

#define	TK_FIRST 83

#define	TK_LAST 84

#define	TK_CURRENT 85

#define	TK_FOLLOWING 86

#define	TK_PARTITION 87

#define	TK_PRECEDING 88

#define	TK_RANGE 89

#define	TK_UNBOUNDED 90

#define	TK_EXCLUDE 91

#define	TK_GROUPS 92

#define	TK_OTHERS 93

#define	TK_TIES 94

#define	TK_GENERATED 95

#define	TK_ALWAYS 96

#define	TK_REINDEX 97

#define	TK_RENAME 98

#define	TK_CTIME_KW 99

#define	TK_ANY 100

#define	TK_BITAND 101

#define	TK_BITOR 102

#define	TK_LSHIFT 103

#define	TK_RSHIFT 104

#define	TK_PLUS 105

#define	TK_MINUS 106

#define	TK_STAR 107

#define	TK_SLASH 108

#define	TK_REM 109

#define	TK_CONCAT 110

#define	TK_COLLATE 111

#define	TK_BITNOT 112

#define	TK_ON 113

#define	TK_INDEXED 114

#define	TK_STRING 115

#define	TK_JOIN_KW 116

#define	TK_CONSTRAINT 117

#define	TK_DEFAULT 118

#define	TK_NULL 119

#define	TK_PRIMARY 120

#define	TK_UNIQUE 121

#define	TK_CHECK 122

#define	TK_REFERENCES 123

#define	TK_AUTOINCR 124

#define	TK_INSERT 125

#define	TK_DELETE 126

#define	TK_UPDATE 127

#define	TK_SET 128

#define	TK_DEFERRABLE 129

#define	TK_FOREIGN 130

#define	TK_DROP 131

#define	TK_UNION 132

#define	TK_ALL 133

#define	TK_EXCEPT 134

#define	TK_INTERSECT 135

#define	TK_SELECT 136

#define	TK_VALUES 137

#define	TK_DISTINCT 138

#define	TK_DOT 139

#define	TK_FROM 140

#define	TK_JOIN 141

#define	TK_USING 142

#define	TK_ORDER 143

#define	TK_GROUP 144

#define	TK_HAVING 145

#define	TK_LIMIT 146

#define	TK_WHERE 147

#define	TK_INTO 148

#define	TK_NOTHING 149

#define	TK_FLOAT 150

#define	TK_BLOB 151

#define	TK_INTEGER 152

#define	TK_VARIABLE 153

#define	TK_CASE 154

#define	TK_WHEN 155

#define	TK_THEN 156

#define	TK_ELSE 157

#define	TK_INDEX 158

#define	TK_ALTER 159

#define	TK_ADD 160

#define	TK_WINDOW 161

#define	TK_OVER 162

#define	TK_FILTER 163

#define	TK_COLUMN 164

#define	TK_AGG_FUNCTION 165

#define	TK_AGG_COLUMN 166

#define	TK_TRUEFALSE 167

#define	TK_ISNOT 168

#define	TK_FUNCTION 169

#define	TK_UMINUS 170

#define	TK_UPLUS 171

#define	TK_TRUTH 172

#define	TK_REGISTER 173

#define	TK_VECTOR 174

#define	TK_SELECT_COLUMN 175

#define	TK_IF_NULL_ROW 176

#define	TK_ASTERISK 177

#define	TK_SPAN 178

#define	TK_SPACE 179

#define	TK_ILLEGAL 180

#define	SQLITE_BIG_DBL (1e99)

#define	OMIT_TEMPDB 0

#define	SQLITE_MAX_FILE_FORMAT 4

#define	SQLITE_DEFAULT_FILE_FORMAT 4

#define	SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

#define	SQLITE_TEMP_STORE 1

#define	SQLITE_MAX_WORKER_THREADS 8

#define	SQLITE_DEFAULT_WORKER_THREADS 0

#define	SQLITE_DEFAULT_PCACHE_INITSZ 20

#define	SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff

#define	offsetof(STRUCTURE, FIELD) ((int)((char)&((STRUCTURE)0)->FIELD))

#define	MIN(A, B) ((A)<(B)?(A):(B))

#define	MAX(A, B) ((A)>(B)?(A):(B))

#define	SWAP(TYPE, A, B) {TYPE t=A; A=B; B=t;}

#define	SQLITE_ASCII 1

#define	UINT32_TYPE unsigned int

#define	UINT16_TYPE unsigned short int

#define	INT16_TYPE short int

#define	UINT8_TYPE unsigned char

#define	INT8_TYPE signed char

#define	LONGDOUBLE_TYPE long double

#define	SQLITE_MAX_U32 ((((u64)1)<<32)-1)

#define	SQLITE_PTRSIZE 8

#define	SQLITE_WITHIN(P, S, E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))

#define	SQLITE_BYTEORDER 0

#define	SQLITE_BIGENDIAN ((char )(&sqlite3one)==0)

#define	SQLITE_LITTLEENDIAN ((char )(&sqlite3one)==1)

#define	SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#define	LARGEST_INT64 (0xffffffff\|(((i64)0x7fffffff)<<32))

#define	LARGEST_UINT64 (0xffffffff\|(((u64)0xffffffff)<<32))

#define	SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

#define	ROUND8(x) (((x)+7)&~7)

#define	ROUNDDOWN8(x) ((x)&~7)

#define	EIGHT_BYTE_ALIGNMENT(X) ((((char)(X) - (char)0)&7)==0)

#define	SQLITE_MAX_MMAP_SIZE 0

#define	SQLITE_DEFAULT_MMAP_SIZE 0

#define	SELECTTRACE_ENABLED 0

#define	SELECTTRACE(K, P, S, X)

#define	SELECTTRACE_ENABLED 0

#define	DFLT_SCHEMA_TABLE "sqlite_master"

#define	DFLT_TEMP_SCHEMA_TABLE "sqlite_temp_master"

#define	ALT_SCHEMA_TABLE "sqlite_schema"

#define	ALT_TEMP_SCHEMA_TABLE "sqlite_temp_schema"

#define	SCHEMA_ROOT 1

#define	SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE)

#define	ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))

#define	IsPowerOfTwo(X) (((X)&((X)-1))==0)

#define	SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3OomFault)

#define	SQLITE_WSD

#define	GLOBAL(t, v) v

#define	sqlite3GlobalConfig sqlite3Config

#define	UNUSED_PARAMETER(x) (void)(x)

#define	UNUSED_PARAMETER2(x, y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

#define	BMS ((int)(sizeof(Bitmask)*8))

#define	MASKBIT(n) (((Bitmask)1)<<(n))

#define	MASKBIT64(n) (((u64)1)<<(n))

#define	MASKBIT32(n) (((unsigned int)1)<<(n))

#define	ALLBITS ((Bitmask)-1)

#define	SQLITE_PAGER_H

#define	SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1

#define	PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))

#define	PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */

#define	PAGER_MEMORY 0x0002 /* In-memory database */

#define	PAGER_LOCKINGMODE_QUERY -1

#define	PAGER_LOCKINGMODE_NORMAL 0

#define	PAGER_LOCKINGMODE_EXCLUSIVE 1

#define	PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */

#define	PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */

#define	PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */

#define	PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */

#define	PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */

#define	PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */

#define	PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */

#define	PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */

#define	PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */

#define	PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */

#define	PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */

#define	PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */

#define	PAGER_SYNCHRONOUS_EXTRA 0x04 /* PRAGMA synchronous=EXTRA */

#define	PAGER_SYNCHRONOUS_MASK 0x07 /* Mask for four values above */

#define	PAGER_FULLFSYNC 0x08 /* PRAGMA fullfsync=ON */

#define	PAGER_CKPT_FULLFSYNC 0x10 /* PRAGMA checkpoint_fullfsync=ON */

#define	PAGER_CACHESPILL 0x20 /* PRAGMA cache_spill=ON */

#define	PAGER_FLAGS_MASK 0x38 /* All above except SYNCHRONOUS */

#define	sqlite3PagerWalWriteLock(y, z) SQLITE_OK

#define	sqlite3PagerWalDb(x, y)

#define	disable_simulated_io_errors()

#define	enable_simulated_io_errors()

#define	SQLITE_BTREE_H

#define	SQLITE_N_BTREE_META 16

#define	SQLITE_DEFAULT_AUTOVACUUM 0

#define	BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */

#define	BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */

#define	BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */

#define	BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */

#define	BTREE_MEMORY 2 /* This is an in-memory DB */

#define	BTREE_SINGLE 4 /* The file contains at most 1 b-tree */

#define	BTREE_UNORDERED 8 /* Use of a hash implementation is OK */

#define	BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */

#define	BTREE_BLOBKEY 2 /* Table has keys only - no data */

#define	BTREE_FREE_PAGE_COUNT 0

#define	BTREE_SCHEMA_VERSION 1

#define	BTREE_FILE_FORMAT 2

#define	BTREE_DEFAULT_CACHE_SIZE 3

#define	BTREE_LARGEST_ROOT_PAGE 4

#define	BTREE_TEXT_ENCODING 5

#define	BTREE_USER_VERSION 6

#define	BTREE_INCR_VACUUM 7

#define	BTREE_APPLICATION_ID 8

#define	BTREE_DATA_VERSION 15 /* A virtual meta-value */

#define	BTREE_HINT_RANGE 0 /* Range constraints on queries */

#define	BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */

#define	BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */

#define	BTREE_WRCSR 0x00000004 /* read-write cursor */

#define	BTREE_FORDELETE 0x00000008 /* Cursor is for seek/delete only */

#define	BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */

#define	BTREE_AUXDELETE 0x04 /* not the primary delete operation */

#define	BTREE_APPEND 0x08 /* Insert is likely an append */

#define	SQLITE_VDBE_H

#define	P4_NOTUSED 0 /* The P4 parameter is not used */

#define	P4_TRANSIENT 0 /* P4 is a pointer to a transient string */

#define	P4_STATIC (-1) /* Pointer to a static string */

#define	P4_COLLSEQ (-2) /* P4 is a pointer to a CollSeq structure */

#define	P4_INT32 (-3) /* P4 is a 32-bit signed integer */

#define	P4_SUBPROGRAM (-4) /* P4 is a pointer to a SubProgram structure */

#define	P4_ADVANCE (-5) /* P4 is a pointer to BtreeNext() or BtreePrev() */

#define	P4_TABLE (-6) /* P4 is a pointer to a Table structure */

#define	P4_FREE_IF_LE (-7)

#define	P4_DYNAMIC (-7) /* Pointer to memory from sqliteMalloc() */

#define	P4_FUNCDEF (-8) /* P4 is a pointer to a FuncDef structure */

#define	P4_KEYINFO (-9) /* P4 is a pointer to a KeyInfo structure */

#define	P4_EXPR (-10) /* P4 is a pointer to an Expr tree */

#define	P4_MEM (-11) /* P4 is a pointer to a Mem* structure */

#define	P4_VTAB (-12) /* P4 is a pointer to an sqlite3_vtab structure */

#define	P4_REAL (-13) /* P4 is a 64-bit floating point value */

#define	P4_INT64 (-14) /* P4 is a 64-bit signed integer */

#define	P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */

#define	P4_FUNCCTX (-16) /* P4 is a pointer to an sqlite3_context object */

#define	P4_DYNBLOB (-17) /* Pointer to memory from sqliteMalloc() */

#define	P5_ConstraintNotNull 1

#define	P5_ConstraintUnique 2

#define	P5_ConstraintCheck 3

#define	P5_ConstraintFK 4

#define	COLNAME_NAME 0

#define	COLNAME_DECLTYPE 1

#define	COLNAME_DATABASE 2

#define	COLNAME_TABLE 3

#define	COLNAME_COLUMN 4

#define	COLNAME_N 2 /* Store the name and decltype */

#define	ADDR(X) (~(X))

#define	OP_Savepoint 0

#define	OP_AutoCommit 1

#define	OP_Transaction 2

#define	OP_SorterNext 3 /* jump */

#define	OP_Prev 4 /* jump */

#define	OP_Next 5 /* jump */

#define	OP_Checkpoint 6

#define	OP_JournalMode 7

#define	OP_Vacuum 8

#define	OP_VFilter 9 /* jump, synopsis: iplan=r[P3] zplan='P4' */

#define	OP_VUpdate 10 /* synopsis: data=r[P3@P2] */

#define	OP_Goto 11 /* jump */

#define	OP_Gosub 12 /* jump */

#define	OP_InitCoroutine 13 /* jump */

#define	OP_Yield 14 /* jump */

#define	OP_MustBeInt 15 /* jump */

#define	OP_Jump 16 /* jump */

#define	OP_Once 17 /* jump */

#define	OP_If 18 /* jump */

#define	OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */

#define	OP_IfNot 20 /* jump */

#define	OP_IfNullRow 21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */

#define	OP_SeekLT 22 /* jump, synopsis: key=r[P3@P4] */

#define	OP_SeekLE 23 /* jump, synopsis: key=r[P3@P4] */

#define	OP_SeekGE 24 /* jump, synopsis: key=r[P3@P4] */

#define	OP_SeekGT 25 /* jump, synopsis: key=r[P3@P4] */

#define	OP_IfNotOpen 26 /* jump, synopsis: if( !csr[P1] ) goto P2 */

#define	OP_IfNoHope 27 /* jump, synopsis: key=r[P3@P4] */

#define	OP_NoConflict 28 /* jump, synopsis: key=r[P3@P4] */

#define	OP_NotFound 29 /* jump, synopsis: key=r[P3@P4] */

#define	OP_Found 30 /* jump, synopsis: key=r[P3@P4] */

#define	OP_SeekRowid 31 /* jump, synopsis: intkey=r[P3] */

#define	OP_NotExists 32 /* jump, synopsis: intkey=r[P3] */

#define	OP_Last 33 /* jump */

#define	OP_IfSmaller 34 /* jump */

#define	OP_SorterSort 35 /* jump */

#define	OP_Sort 36 /* jump */

#define	OP_Rewind 37 /* jump */

#define	OP_IdxLE 38 /* jump, synopsis: key=r[P3@P4] */

#define	OP_IdxGT 39 /* jump, synopsis: key=r[P3@P4] */

#define	OP_IdxLT 40 /* jump, synopsis: key=r[P3@P4] */

#define	OP_IdxGE 41 /* jump, synopsis: key=r[P3@P4] */

#define	OP_RowSetRead 42 /* jump, synopsis: r[P3]=rowset(P1) */

#define	OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] \|\| r[P2]) */

#define	OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */

#define	OP_RowSetTest 45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */

#define	OP_Program 46 /* jump */

#define	OP_FkIfZero 47 /* jump, synopsis: if fkctr[P1]==0 goto P2 */

#define	OP_IfPos 48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */

#define	OP_IfNotZero 49 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */

#define	OP_IsNull 50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */

#define	OP_NotNull 51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */

#define	OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */

#define	OP_Eq 53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */

#define	OP_Gt 54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */

#define	OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */

#define	OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */

#define	OP_Ge 57 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */

#define	OP_ElseNotEq 58 /* jump, same as TK_ESCAPE */

#define	OP_DecrJumpZero 59 /* jump, synopsis: if (--r[P1])==0 goto P2 */

#define	OP_IncrVacuum 60 /* jump */

#define	OP_VNext 61 /* jump */

#define	OP_Init 62 /* jump, synopsis: Start at P2 */

#define	OP_PureFunc 63 /* synopsis: r[P3]=func(r[P2@NP]) */

#define	OP_Function 64 /* synopsis: r[P3]=func(r[P2@NP]) */

#define	OP_Return 65

#define	OP_EndCoroutine 66

#define	OP_HaltIfNull 67 /* synopsis: if r[P3]=null halt */

#define	OP_Halt 68

#define	OP_Integer 69 /* synopsis: r[P2]=P1 */

#define	OP_Int64 70 /* synopsis: r[P2]=P4 */

#define	OP_String 71 /* synopsis: r[P2]='P4' (len=P1) */

#define	OP_Null 72 /* synopsis: r[P2..P3]=NULL */

#define	OP_SoftNull 73 /* synopsis: r[P1]=NULL */

#define	OP_Blob 74 /* synopsis: r[P2]=P4 (len=P1) */

#define	OP_Variable 75 /* synopsis: r[P2]=parameter(P1,P4) */

#define	OP_Move 76 /* synopsis: r[P2@P3]=r[P1@P3] */

#define	OP_Copy 77 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */

#define	OP_SCopy 78 /* synopsis: r[P2]=r[P1] */

#define	OP_IntCopy 79 /* synopsis: r[P2]=r[P1] */

#define	OP_ResultRow 80 /* synopsis: output=r[P1@P2] */

#define	OP_CollSeq 81

#define	OP_AddImm 82 /* synopsis: r[P1]=r[P1]+P2 */

#define	OP_RealAffinity 83

#define	OP_Cast 84 /* synopsis: affinity(r[P1]) */

#define	OP_Permutation 85

#define	OP_Compare 86 /* synopsis: r[P1@P3] <-> r[P2@P3] */

#define	OP_IsTrue 87 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */

#define	OP_Offset 88 /* synopsis: r[P3] = sqlite_offset(P1) */

#define	OP_Column 89 /* synopsis: r[P3]=PX */

#define	OP_Affinity 90 /* synopsis: affinity(r[P1@P2]) */

#define	OP_MakeRecord 91 /* synopsis: r[P3]=mkrec(r[P1@P2]) */

#define	OP_Count 92 /* synopsis: r[P2]=count() */

#define	OP_ReadCookie 93

#define	OP_SetCookie 94

#define	OP_ReopenIdx 95 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenRead 96 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenWrite 97 /* synopsis: root=P2 iDb=P3 */

#define	OP_OpenDup 98

#define	OP_OpenAutoindex 99 /* synopsis: nColumn=P2 */

#define	OP_OpenEphemeral 100 /* synopsis: nColumn=P2 */

#define	OP_BitAnd 101 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */

#define	OP_BitOr 102 /* same as TK_BITOR, synopsis: r[P3]=r[P1]\|r[P2] */

#define	OP_ShiftLeft 103 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */

#define	OP_ShiftRight 104 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */

#define	OP_Add 105 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */

#define	OP_Subtract 106 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */

#define	OP_Multiply 107 /* same as TK_STAR, synopsis: r[P3]=r[P1]r[P2] /

#define	OP_Divide 108 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */

#define	OP_Remainder 109 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */

#define	OP_Concat 110 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */

#define	OP_SorterOpen 111

#define	OP_BitNot 112 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */

#define	OP_SequenceTest 113 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */

#define	OP_OpenPseudo 114 /* synopsis: P3 columns in r[P2] */

#define	OP_String8 115 /* same as TK_STRING, synopsis: r[P2]='P4' */

#define	OP_Close 116

#define	OP_ColumnsUsed 117

#define	OP_SeekHit 118 /* synopsis: seekHit=P2 */

#define	OP_Sequence 119 /* synopsis: r[P2]=cursor[P1].ctr++ */

#define	OP_NewRowid 120 /* synopsis: r[P2]=rowid */

#define	OP_Insert 121 /* synopsis: intkey=r[P3] data=r[P2] */

#define	OP_Delete 122

#define	OP_ResetCount 123

#define	OP_SorterCompare 124 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */

#define	OP_SorterData 125 /* synopsis: r[P2]=data */

#define	OP_RowData 126 /* synopsis: r[P2]=data */

#define	OP_Rowid 127 /* synopsis: r[P2]=rowid */

#define	OP_NullRow 128

#define	OP_SeekEnd 129

#define	OP_IdxInsert 130 /* synopsis: key=r[P2] */

#define	OP_SorterInsert 131 /* synopsis: key=r[P2] */

#define	OP_IdxDelete 132 /* synopsis: key=r[P2@P3] */

#define	OP_DeferredSeek 133 /* synopsis: Move P3 to P1.rowid if needed */

#define	OP_IdxRowid 134 /* synopsis: r[P2]=rowid */

#define	OP_FinishSeek 135

#define	OP_Destroy 136

#define	OP_Clear 137

#define	OP_ResetSorter 138

#define	OP_CreateBtree 139 /* synopsis: r[P2]=root iDb=P1 flags=P3 */

#define	OP_SqlExec 140

#define	OP_ParseSchema 141

#define	OP_LoadAnalysis 142

#define	OP_DropTable 143

#define	OP_DropIndex 144

#define	OP_DropTrigger 145

#define	OP_IntegrityCk 146

#define	OP_RowSetAdd 147 /* synopsis: rowset(P1)=r[P2] */

#define	OP_Param 148

#define	OP_FkCounter 149 /* synopsis: fkctr[P1]+=P2 */

#define	OP_Real 150 /* same as TK_FLOAT, synopsis: r[P2]=P4 */

#define	OP_MemMax 151 /* synopsis: r[P1]=max(r[P1],r[P2]) */

#define	OP_OffsetLimit 152 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */

#define	OP_AggInverse 153 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */

#define	OP_AggStep 154 /* synopsis: accum=r[P3] step(r[P2@P5]) */

#define	OP_AggStep1 155 /* synopsis: accum=r[P3] step(r[P2@P5]) */

#define	OP_AggValue 156 /* synopsis: r[P3]=value N=P2 */

#define	OP_AggFinal 157 /* synopsis: accum=r[P1] N=P2 */

#define	OP_Expire 158

#define	OP_CursorLock 159

#define	OP_CursorUnlock 160

#define	OP_TableLock 161 /* synopsis: iDb=P1 root=P2 write=P3 */

#define	OP_VBegin 162

#define	OP_VCreate 163

#define	OP_VDestroy 164

#define	OP_VOpen 165

#define	OP_VColumn 166 /* synopsis: r[P3]=vcolumn(P2) */

#define	OP_VRename 167

#define	OP_Pagecount 168

#define	OP_MaxPgcnt 169

#define	OP_Trace 170

#define	OP_CursorHint 171

#define	OP_ReleaseReg 172 /* synopsis: release r[P1@P2] mask P3 */

#define	OP_Noop 173

#define	OP_Explain 174

#define	OP_Abortable 175

#define	OPFLG_JUMP 0x01 /* jump: P2 holds jmp target */

#define	OPFLG_IN1 0x02 /* in1: P1 is an input */

#define	OPFLG_IN2 0x04 /* in2: P2 is an input */

#define	OPFLG_IN3 0x08 /* in3: P3 is an input */

#define	OPFLG_OUT2 0x10 /* out2: P2 is an output */

#define	OPFLG_OUT3 0x20 /* out3: P3 is an output */

#define	OPFLG_INITIALIZER

#define	SQLITE_MX_JUMP_OPCODE 62 /* Maximum JUMP opcode */

#define	SQLITE_PREPARE_SAVESQL 0x80 /* Preserve SQL text */

#define	SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */

#define	sqlite3VdbeVerifyNoMallocRequired(A, B)

#define	sqlite3VdbeVerifyNoResultRow(A)

#define	sqlite3VdbeVerifyAbortable(A, B)

#define	ExplainQueryPlan(P) sqlite3VdbeExplain P

#define	ExplainQueryPlanPop(P) sqlite3VdbeExplainPop(P)

#define	ExplainQueryPlanParent(P) sqlite3VdbeExplainParent(P)

#define	sqlite3ExplainBreakpoint(A, B) /no-op/

#define	sqlite3VdbeReleaseRegisters(P, A, N, M, F)

#define	VdbeComment(X)

#define	VdbeNoopComment(X)

#define	VdbeModuleComment(X)

#define	VdbeCoverage(v)

#define	VdbeCoverageIf(v, x)

#define	VdbeCoverageAlwaysTaken(v)

#define	VdbeCoverageNeverTaken(v)

#define	VdbeCoverageNeverNull(v)

#define	VdbeCoverageNeverNullIf(v, x)

#define	VdbeCoverageEqNe(v)

#define	VDBE_OFFSET_LINENO(x) 0

#define	sqlite3VdbeScanStatus(a, b, c, d, e)

#define	PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */

#define	PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */

#define	PGHDR_WRITEABLE 0x004 /* Journaled and ready to modify */

#define	PGHDR_NEED_SYNC

#define	PGHDR_DONT_WRITE 0x010 /* Do not write content to disk */

#define	PGHDR_MMAP 0x020 /* This is an mmap page object */

#define	PGHDR_WAL_APPEND 0x040 /* Appended to wal file */

#define	_SQLITE_OS_H_

#define	SQLITE_OS_SETUP_H

#define	SQLITE_OS_OTHER 0

#define	SQLITE_OS_WIN 0

#define	SQLITE_OS_UNIX 1

#define	SET_FULLSYNC(x, y)

#define	SQLITE_DEFAULT_SECTOR_SIZE 4096

#define	SQLITE_TEMP_FILE_PREFIX "etilqs_"

#define	NO_LOCK 0

#define	SHARED_LOCK 1

#define	RESERVED_LOCK 2

#define	PENDING_LOCK 3

#define	EXCLUSIVE_LOCK 4

#define	PENDING_BYTE sqlite3PendingByte

#define	RESERVED_BYTE (PENDING_BYTE+1)

#define	SHARED_FIRST (PENDING_BYTE+2)

#define	SHARED_SIZE 510

#define	SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0

#define	SQLITE_MUTEX_PTHREADS

#define	MUTEX_LOGIC(X) X

#define	SQLITE_DEFAULT_SYNCHRONOUS 2

#define	SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS

#define	DbHasProperty(D, I, P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))

#define	DbHasAnyProperty(D, I, P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)

#define	DbSetProperty(D, I, P) (D)->aDb[I].pSchema->schemaFlags\|=(P)

#define	DbClearProperty(D, I, P) (D)->aDb[I].pSchema->schemaFlags&=~(P)

#define	DB_SchemaLoaded 0x0001 /* The schema has been loaded */

#define	DB_UnresetViews 0x0002 /* Some views have defined column names */

#define	DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */

#define	SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)

#define	DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0

#define	EnableLookaside

#define	LOOKASIDE_SMALL 128

#define	SQLITE_FUNC_HASH_SZ 23

#define	SQLITE_FUNC_HASH(C, L) (((C)+(L))%SQLITE_FUNC_HASH_SZ)

#define	SQLITE_TRACE_LEGACY 0x40 /* Use the legacy xTrace */

#define	SQLITE_TRACE_XPROFILE 0x80 /* Use the legacy xProfile */

#define	SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */

#define	SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)

#define	ENC(db) ((db)->enc)

#define	HI(X) ((u64)(X)<<32)

#define	SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_SCHEMA */

#define	SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */

#define	SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */

#define	SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */

#define	SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */

#define	SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */

#define	SQLITE_ShortColNames 0x00000040 /* Show short columns names */

#define	SQLITE_TrustedSchema

#define	SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */

#define	SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */

#define	SQLITE_ReadUncommit 0x00000400 /* READ UNCOMMITTED in shared-cache */

#define	SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */

#define	SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */

#define	SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */

#define	SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */

#define	SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */

#define	SQLITE_LoadExtension 0x00010000 /* Enable load_extension */

#define	SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */

#define	SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */

#define	SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */

#define	SQLITE_QueryOnly 0x00100000 /* Disable database changes */

#define	SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */

#define	SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */

#define	SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/

#define	SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */

#define	SQLITE_ResetDatabase 0x02000000 /* Reset the database */

#define	SQLITE_LegacyAlter 0x04000000 /* Legacy ALTER TABLE behaviour */

#define	SQLITE_NoSchemaError 0x08000000 /* Do not report schema parse errors*/

#define	SQLITE_Defensive 0x10000000 /* Input SQL is likely hostile */

#define	SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/

#define	SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/

#define	SQLITE_EnableView 0x80000000 /* Enable the use of views */

#define	SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */

#define	DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */

#define	DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */

#define	DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */

#define	DBFLAG_VacuumInto 0x0008 /* Currently running VACUUM INTO */

#define	DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */

#define	DBFLAG_InternalFunc 0x0020 /* Allow use of internal functions */

#define	DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */

#define	SQLITE_QueryFlattener 0x0001 /* Query flattening */

#define	SQLITE_WindowFunc 0x0002 /* Use xInverse for window functions */

#define	SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */

#define	SQLITE_FactorOutConst 0x0008 /* Constant factoring */

#define	SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */

#define	SQLITE_CoverIdxScan 0x0020 /* Covering index scans */

#define	SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */

#define	SQLITE_Transitive 0x0080 /* Transitive constraints */

#define	SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */

#define	SQLITE_CountOfView 0x0200 /* The count-of-view optimization */

#define	SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */

#define	SQLITE_Stat4 0x0800 /* Use STAT4 data */

#define	SQLITE_PushDown 0x1000 /* The push-down optimization */

#define	SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */

#define	SQLITE_SkipScan 0x4000 /* Skip-scans */

#define	SQLITE_PropagateConst 0x8000 /* The constant propagation opt */

#define	SQLITE_AllOpts 0xffff /* All optimizations */

#define	OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)

#define	OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)

#define	ConstFactorOk(P) ((P)->okConstFactor)

#define	SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */

#define	SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */

#define	SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */

#define	SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */

#define	SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */

#define	SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */

#define	SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */

#define	SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */

#define	SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */

#define	SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */

#define	SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/

#define	SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */

#define	SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */

#define	SQLITE_FUNC_COUNT 0x0100 /* Built-in count() aggregate /

#define	SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */

#define	SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */

#define	SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */

#define	SQLITE_FUNC_SLOCHNG

#define	SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */

#define	SQLITE_FUNC_OFFSET 0x8000 /* Built-in sqlite_offset() function */

#define	SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */

#define	SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */

#define	SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */

#define	SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */

#define	SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */

#define	SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */

#define	INLINEFUNC_coalesce 0

#define	INLINEFUNC_implies_nonnull_row 1

#define	INLINEFUNC_expr_implies_expr 2

#define	INLINEFUNC_expr_compare 3

#define	INLINEFUNC_affinity 4

#define	INLINEFUNC_iif 5

#define	INLINEFUNC_unlikely 99 /* Default case */

#define	FUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	VFUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	SFUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	INLINE_FUNC(zName, nArg, iArg, mFlags)

#define	TEST_FUNC(zName, nArg, iArg, mFlags)

#define	DFUNCTION(zName, nArg, iArg, bNC, xFunc)

#define	PURE_DATE(zName, nArg, iArg, bNC, xFunc)

#define	FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags)

#define	STR_FUNCTION(zName, nArg, pArg, bNC, xFunc)

#define	LIKEFUNC(zName, nArg, arg, flags)

#define	WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f)

#define	INTERNAL_FUNCTION(zName, nArg, xFunc)

#define	SAVEPOINT_BEGIN 0

#define	SAVEPOINT_RELEASE 1

#define	SAVEPOINT_ROLLBACK 2

#define	COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */

#define	COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */

#define	COLFLAG_HASTYPE 0x0004 /* Type name follows column name */

#define	COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */

#define	COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */

#define	COLFLAG_VIRTUAL 0x0020 /* GENERATED ALWAYS AS ... VIRTUAL */

#define	COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */

#define	COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */

#define	COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */

#define	COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */

#define	COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */

#define	SQLITE_SO_ASC 0 /* Sort in ascending order */

#define	SQLITE_SO_DESC 1 /* Sort in ascending order */

#define	SQLITE_SO_UNDEFINED -1 /* No sort order specified */

#define	SQLITE_AFF_NONE 0x40 /* '@' */

#define	SQLITE_AFF_BLOB 0x41 /* 'A' */

#define	SQLITE_AFF_TEXT 0x42 /* 'B' */

#define	SQLITE_AFF_NUMERIC 0x43 /* 'C' */

#define	SQLITE_AFF_INTEGER 0x44 /* 'D' */

#define	SQLITE_AFF_REAL 0x45 /* 'E' */

#define	sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)

#define	SQLITE_AFF_MASK 0x47

#define	SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */

#define	SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */

#define	SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */

#define	SQLITE_NULLEQ 0x80 /* NULL=NULL */

#define	SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */

#define	SQLITE_VTABRISK_Low 0

#define	SQLITE_VTABRISK_Normal 1

#define	SQLITE_VTABRISK_High 2

#define	TF_Readonly 0x0001 /* Read-only system table */

#define	TF_Ephemeral 0x0002 /* An ephemeral table */

#define	TF_HasPrimaryKey 0x0004 /* Table has a primary key */

#define	TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */

#define	TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */

#define	TF_HasVirtual 0x0020 /* Has one or more VIRTUAL columns */

#define	TF_HasStored 0x0040 /* Has one or more STORED columns */

#define	TF_HasGenerated 0x0060 /* Combo: HasVirtual + HasStored */

#define	TF_WithoutRowid 0x0080 /* No rowid. PRIMARY KEY is the key */

#define	TF_StatsUsed

#define	TF_NoVisibleRowid 0x0200 /* No user-visible "rowid" column */

#define	TF_OOOHidden 0x0400 /* Out-of-Order hidden columns */

#define	TF_HasNotNull 0x0800 /* Contains NOT NULL constraints */

#define	TF_Shadow 0x1000 /* True for a shadow table */

#define	IsVirtual(X) ((X)->nModuleArg)

#define	ExprIsVtab(X) ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)

#define	IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)

#define	IsOrdinaryHiddenColumn(X) 0

#define	HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)

#define	VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)

#define	OE_None 0 /* There is no constraint to check */

#define	OE_Rollback 1 /* Fail the operation and rollback the transaction */

#define	OE_Abort 2 /* Back out changes but do no rollback transaction */

#define	OE_Fail 3 /* Stop the operation but leave all prior changes */

#define	OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */

#define	OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */

#define	OE_Update 6 /* Process as a DO UPDATE in an upsert */

#define	OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */

#define	OE_SetNull 8 /* Set the foreign key value to NULL */

#define	OE_SetDflt 9 /* Set the foreign key value to its default */

#define	OE_Cascade 10 /* Cascade the changes */

#define	OE_Default 11 /* Do whatever the default action is */

#define	KEYINFO_ORDER_DESC 0x01 /* DESC sort order */

#define	KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */

#define	SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */

#define	SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */

#define	SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */

#define	SQLITE_IDXTYPE_IPK 3 /* INTEGER PRIMARY KEY index */

#define	IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)

#define	IsUniqueIndex(X) ((X)->onError!=OE_None)

#define	XN_ROWID (-1) /* Indexed column is the rowid */

#define	XN_EXPR (-2) /* Indexed column is an expression */

#define	SQLITE_TOKEN_QUOTED 0x1 /* Token is a quoted identifier. */

#define	SQLITE_TOKEN_KEYWORD 0x2 /* Token is a keyword. */

#define	EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */

#define	EP_Distinct 0x000002 /* Aggregate function with DISTINCT keyword */

#define	EP_HasFunc 0x000004 /* Contains one or more functions of any kind */

#define	EP_FixedCol 0x000008 /* TK_Column with a known fixed value */

#define	EP_Agg 0x000010 /* Contains one or more aggregate functions */

#define	EP_VarSelect 0x000020 /* pSelect is correlated, not constant */

#define	EP_DblQuoted 0x000040 /* token.z was originally in "..." */

#define	EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */

#define	EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */

#define	EP_Commuted 0x000200 /* Comparison operator has been commuted */

#define	EP_IntValue 0x000400 /* Integer value contained in u.iValue */

#define	EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */

#define	EP_Skip 0x001000 /* Operator does not contribute to affinity */

#define	EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */

#define	EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */

#define	EP_Win 0x008000 /* Contains window functions */

#define	EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */

#define	EP_Unlikely 0x040000 /* unlikely() or likelihood() function */

#define	EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */

#define	EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */

#define	EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */

#define	EP_Alias 0x400000 /* Is an alias for a result set column */

#define	EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */

#define	EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */

#define	EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */

#define	EP_Quoted 0x4000000 /* TK_ID was originally quoted */

#define	EP_Static 0x8000000 /* Held in memory not obtained from malloc() */

#define	EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */

#define	EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */

#define	EP_FromDDL 0x40000000 /* Originates from sqlite_schema */

#define	EP_Propagate (EP_Collate\|EP_Subquery\|EP_HasFunc)

#define	ExprHasProperty(E, P) (((E)->flags&(P))!=0)

#define	ExprHasAllProperty(E, P) (((E)->flags&(P))==(P))

#define	ExprSetProperty(E, P) (E)->flags\|=(P)

#define	ExprClearProperty(E, P) (E)->flags&=~(P)

#define	ExprAlwaysTrue(E) (((E)->flags&(EP_FromJoin\|EP_IsTrue))==EP_IsTrue)

#define	ExprAlwaysFalse(E) (((E)->flags&(EP_FromJoin\|EP_IsFalse))==EP_IsFalse)

#define	EP_NoReduce 0x01 /* Cannot EXPRDUP_REDUCE this Expr */

#define	EP_Immutable 0x02 /* Do not change this Expr node */

#define	ExprSetVVAProperty(E, P)

#define	ExprHasVVAProperty(E, P) 0

#define	ExprClearVVAProperties(E)

#define	EXPR_FULLSIZE sizeof(Expr) /* Full size */

#define	EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */

#define	EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */

#define	EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */

#define	IsWindowFunc(p)

#define	ENAME_NAME 0 /* The AS clause of a result set */

#define	ENAME_SPAN 1 /* Complete text of the result set expression */

#define	ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */

#define	JT_INNER 0x0001 /* Any kind of inner or cross join */

#define	JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */

#define	JT_NATURAL 0x0004 /* True for a "natural" join */

#define	JT_LEFT 0x0008 /* Left outer join */

#define	JT_RIGHT 0x0010 /* Right outer join */

#define	JT_OUTER 0x0020 /* The "OUTER" keyword is present */

#define	JT_ERROR 0x0040 /* unknown or unsupported join type */

#define	WHERE_ORDERBY_NORMAL 0x0000 /* No-op */

#define	WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */

#define	WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */

#define	WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */

#define	WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */

#define	WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */

#define	WHERE_OR_SUBCLAUSE

#define	WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */

#define	WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */

#define	WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */

#define	WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */

#define	WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */

#define	WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */

#define	WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */

#define	WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */

#define	WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */

#define	WHERE_DISTINCT_UNIQUE 1 /* No duplicates */

#define	WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */

#define	WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */

#define	NC_AllowAgg 0x00001 /* Aggregate functions are allowed here */

#define	NC_PartIdx 0x00002 /* True if resolving a partial index WHERE */

#define	NC_IsCheck 0x00004 /* True if resolving a CHECK constraint */

#define	NC_GenCol 0x00008 /* True for a GENERATED ALWAYS AS clause */

#define	NC_HasAgg 0x00010 /* One or more aggregate functions seen */

#define	NC_IdxExpr 0x00020 /* True if resolving columns of CREATE INDEX */

#define	NC_SelfRef 0x0002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */

#define	NC_VarSelect 0x00040 /* A correlated subquery has been seen */

#define	NC_UEList 0x00080 /* True if uNC.pEList is used */

#define	NC_UAggInfo 0x00100 /* True if uNC.pAggInfo is used */

#define	NC_UUpsert 0x00200 /* True if uNC.pUpsert is used */

#define	NC_MinMaxAgg 0x01000 /* min/max aggregates seen. See note above */

#define	NC_Complex 0x02000 /* True if a function or subquery seen */

#define	NC_AllowWin 0x04000 /* Window functions are allowed here */

#define	NC_HasWin 0x08000 /* One or more window functions seen */

#define	NC_IsDDL 0x10000 /* Resolving names in a CREATE statement */

#define	NC_InAggFunc 0x20000 /* True if analyzing arguments to an agg func */

#define	NC_FromDDL 0x40000 /* SQL text comes from sqlite_schema */

#define	SF_Distinct 0x0000001 /* Output should be DISTINCT */

#define	SF_All 0x0000002 /* Includes the ALL keyword */

#define	SF_Resolved 0x0000004 /* Identifiers have been resolved */

#define	SF_Aggregate 0x0000008 /* Contains agg functions or a GROUP BY */

#define	SF_HasAgg 0x0000010 /* Contains aggregate functions */

#define	SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */

#define	SF_Expanded 0x0000040 /* sqlite3SelectExpand() called on this */

#define	SF_HasTypeInfo 0x0000080 /* FROM subqueries have Table metadata */

#define	SF_Compound 0x0000100 /* Part of a compound query */

#define	SF_Values 0x0000200 /* Synthesized from VALUES clause */

#define	SF_MultiValue 0x0000400 /* Single VALUES term with multiple rows */

#define	SF_NestedFrom 0x0000800 /* Part of a parenthesized FROM clause */

#define	SF_MinMaxAgg 0x0001000 /* Aggregate containing min() or max() */

#define	SF_Recursive 0x0002000 /* The recursive part of a recursive CTE */

#define	SF_FixedLimit 0x0004000 /* nSelectRow set by a constant LIMIT */

#define	SF_MaybeConvert 0x0008000 /* Need convertCompoundSelectToSubquery() */

#define	SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */

#define	SF_IncludeHidden 0x0020000 /* Include hidden columns in output */

#define	SF_ComplexResult 0x0040000 /* Result contains subquery or function */

#define	SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */

#define	SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */

#define	SF_View 0x0200000 /* SELECT statement is a view */

#define	SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */

#define	SF_UpdateFrom 0x0800000 /* Statement is an UPDATE...FROM */

#define	SRT_Union 1 /* Store result as keys in an index */

#define	SRT_Except 2 /* Remove result from a UNION index */

#define	SRT_Exists 3 /* Store 1 if the result is not empty */

#define	SRT_Discard 4 /* Do not save the results anywhere */

#define	SRT_Fifo 5 /* Store result as data with an automatic rowid */

#define	SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */

#define	SRT_Queue 7 /* Store result in an queue */

#define	SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */

#define	IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)

#define	SRT_Output 9 /* Output each row of result */

#define	SRT_Mem 10 /* Store result in a memory cell */

#define	SRT_Set 11 /* Store results as keys in an index */

#define	SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */

#define	SRT_Coroutine 13 /* Generate a single row of result */

#define	SRT_Table 14 /* Store result as data with an automatic rowid */

#define	SRT_Upfrom 15 /* Store result as data with rowid */

#define	DbMaskTest(M, I) (((M)&(((yDbMask)1)<<(I)))!=0)

#define	DbMaskZero(M) (M)=0

#define	DbMaskSet(M, I) (M)\|=(((yDbMask)1)<<(I))

#define	DbMaskAllZero(M) (M)==0

#define	DbMaskNonZero(M) (M)!=0

#define	PARSE_MODE_NORMAL 0

#define	PARSE_MODE_DECLARE_VTAB 1

#define	PARSE_MODE_RENAME 2

#define	PARSE_MODE_UNMAP 3

#define	PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/

#define	PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */

#define	PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */

#define	PARSE_TAIL(X) (((char)(X))+PARSE_RECURSE_SZ) / Pointer to tail */

#define	IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)

#define	IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)

#define	IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)

#define	OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */

#define	OPFLAG_NOCHNG 0x01 /* OP_VColumn nochange for UPDATE */

#define	OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */

#define	OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */

#define	OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */

#define	OPFLAG_APPEND 0x08 /* This is likely to be an append */

#define	OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */

#define	OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */

#define	OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */

#define	OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */

#define	OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */

#define	OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */

#define	OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */

#define	OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */

#define	OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */

#define	OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */

#define	OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */

#define	OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */

#define	TRIGGER_BEFORE 1

#define	TRIGGER_AFTER 2

#define	SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */

#define	SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */

#define	SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */

#define	isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)

#define	INITFLAG_AlterTable 0x0001 /* This is a reparse after ALTER TABLE */

#define	CORRUPT_DB (sqlite3Config.neverCorrupt==0)

#define	WRC_Continue 0 /* Continue down into children */

#define	WRC_Prune 1 /* Omit children but continue walking siblings */

#define	WRC_Abort 2 /* Abandon the tree walk */

#define	SQLITE_SKIP_UTF8(zIn)

#define	SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)

#define	SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)

#define	SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)

#define	SQLITE_NOMEM_BKPT SQLITE_NOMEM

#define	SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM

#define	SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__)

#define	sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))

#define	sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)

#define	sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)

#define	sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)

#define	sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)

#define	sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)

#define	sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])

#define	sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)

#define	sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff)

#define	sqlite3StrNICmp sqlite3_strnicmp

#define	sqlite3StackAllocRaw(D, N) sqlite3DbMallocRaw(D,N)

#define	sqlite3StackAllocZero(D, N) sqlite3DbMallocZero(D,N)

#define	sqlite3StackFree(D, P) sqlite3DbFree(D,P)

#define	sqlite3MutexWarnOnContention(x)

#define	EXP754 (((u64)0x7ff)<<52)

#define	MAN754 ((((u64)1)<<52)-1)

#define	IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)

#define	sqlite3ColumnPropertiesFromName(T, C) /* no-op */

#define	sqlite3CodecQueryParameters(A, B, C) 0

#define	ONEPASS_OFF 0 /* Use of ONEPASS not allowed */

#define	ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */

#define	ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */

#define	SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */

#define	SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */

#define	SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */

#define	SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */

#define	LOCATE_VIEW 0x01

#define	LOCATE_NOERR 0x02

#define	sqlite3SetMakeRecordP5(A, B)

#define	sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))

#define	sqlite3IsToplevel(p) ((p)->pToplevel==0)

#define	getVarint32(A, B) (u8)(((A)<(u8)0x80)?((B)=(u32)(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))

#define	getVarint32NR(A, B) B=(u32)(A);if(B>=0x80)sqlite3GetVarint32((A),(u32)&(B))

#define	putVarint32(A, B)

#define	getVarint sqlite3GetVarint

#define	putVarint sqlite3PutVarint

#define	sqlite3FileSuffix3(X, Y)

#define	sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)

#define	SQLITE_FAULTINJECTOR_MALLOC 0

#define	SQLITE_FAULTINJECTOR_COUNT 1

#define	IN_INDEX_ROWID 1 /* Search the rowid of the table */

#define	IN_INDEX_EPH 2 /* Search an ephemeral b-tree */

#define	IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */

#define	IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */

#define	IN_INDEX_NOOP 5 /* No table available. Use comparisons */

#define	IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */

#define	IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */

#define	IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */

#define	sqlite3ConnectionBlocked(x, y)

#define	sqlite3ConnectionUnlocked(x)

#define	sqlite3ConnectionClosed(x)

#define	IOTRACE(A)

#define	sqlite3VdbeIOTraceSql(X)

#define	sqlite3MemdebugSetType(X, Y) /* no-op */

#define	sqlite3MemdebugHasType(X, Y) 1

#define	sqlite3MemdebugNoType(X, Y) 1

#define	MEMTYPE_HEAP 0x01 /* General heap allocations */

#define	MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */

#define	MEMTYPE_PCACHE 0x04 /* Page cache allocations */

#define	SQLITE_USE_URI 0

#define	SQLITE_ALLOW_COVERING_INDEX_SCAN 1

#define	SQLITE_SORTER_PMASZ 250

#define	SQLITE_STMTJRNL_SPILL (64*1024)

#define	SQLITE_DEFAULT_LOOKASIDE 1200,40 /* 48KB of memory */

#define	SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824

#define	SQLITE_VDBEINT_H

#define	SQLITE_MAX_SCHEMA_RETRY 50

#define	VDBE_DISPLAY_P4 1

#define	CURTYPE_BTREE 0

#define	CURTYPE_SORTER 1

#define	CURTYPE_VTAB 2

#define	CURTYPE_PSEUDO 3

#define	CACHE_STALE 0

#define	SQLITE_FRAME_MAGIC 0x879fb71e

#define	VdbeFrameMem(p) ((Mem )&((u8 )p)[ROUND8(sizeof(VdbeFrame))])

#define	MEMCELLSIZE offsetof(Mem,zMalloc)

#define	MEM_Null 0x0001 /* Value is NULL (or a pointer) */

#define	MEM_Str 0x0002 /* Value is a string */

#define	MEM_Int 0x0004 /* Value is an integer */

#define	MEM_Real 0x0008 /* Value is a real number */

#define	MEM_Blob 0x0010 /* Value is a BLOB */

#define	MEM_IntReal 0x0020 /* MEM_Int that stringifies like MEM_Real */

#define	MEM_AffMask 0x003f /* Mask of affinity bits */

#define	MEM_FromBind 0x0040 /* Value originates from sqlite3_bind() */

#define	MEM_Undefined 0x0080 /* Value is undefined */

#define	MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */

#define	MEM_TypeMask 0xc1bf /* Mask of type bits */

#define	MEM_Term 0x0200 /* String in Mem.z is zero terminated */

#define	MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */

#define	MEM_Static 0x0800 /* Mem.z points to a static string */

#define	MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */

#define	MEM_Agg 0x2000 /* Mem.z points to an agg function context */

#define	MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */

#define	MEM_Subtype 0x8000 /* Mem.eSubtype is valid */

#define	VdbeMemDynamic(X) (((X)->flags&(MEM_Agg\|MEM_Dyn))!=0)

#define	MemSetTypeFlag(p, f) ((p)->flags = ((p)->flags&~(MEM_TypeMask\|MEM_Zero))\|f)

#define	MemNullNochng(X)

#define	VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */

#define	VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */

#define	VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */

#define	VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */

#define	VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */

#define	sqlite3VdbeIncrWriteCounter(V, C)

#define	sqlite3VdbeAssertAbortable(V)

#define	ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)

#define	wsdStatInit

#define	wsdStat sqlite3Stat

#define	INT_464269060799999 ((((i64)0x1a640)<<32)\|0x1072fdff)

#define	DO_OS_MALLOC_TEST(x)

#define	vfsList GLOBAL(sqlite3_vfs *, vfsList)

#define	wsdHooksInit

#define	wsdHooks sqlite3Hooks

#define	SQLITE_MALLOC(x) malloc(x)

#define	SQLITE_FREE(x) free(x)

#define	SQLITE_REALLOC(x, y) realloc((x),(y))

#define	SQLITE_MUTEX_NREF 0

#define	SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER }

#define	SQLITE_MAX_MEMORY 0

#define	mem0 GLOBAL(struct Mem0Global, mem0)

#define	etRADIX 0 /* non-decimal integer types. %x %o */

#define	etFLOAT 1 /* Floating point. %f */

#define	etEXP 2 /* Exponentional notation. %e and %E */

#define	etGENERIC 3 /* Floating or exponential, depending on exponent. %g */

#define	etSIZE 4 /* Return number of characters processed so far. %n */

#define	etSTRING 5 /* Strings. %s */

#define	etDYNSTRING 6 /* Dynamically allocated strings. %z */

#define	etPERCENT 7 /* Percent symbol. %% */

#define	etCHARX 8 /* Characters. %c */

#define	etSQLESCAPE 9 /* Strings with '\'' doubled. %q */

#define	etSQLESCAPE2

#define	etTOKEN 11 /* a pointer to a Token structure */

#define	etSRCLIST 12 /* a pointer to a SrcList */

#define	etPOINTER 13 /* The %p conversion */

#define	etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */

#define	etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */

#define	etDECIMAL 16 /* %d or %u, but not %x, %o */

#define	etINVALID 17 /* Any unrecognized conversion type */

#define	FLAG_SIGNED 1 /* True if the value to convert is signed */

#define	FLAG_STRING 4 /* Allow infinite precision */

#define	SQLITE_PRINT_BUF_SIZE 70

#define	etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */

#define	SQLITE_FP_PRECISION_LIMIT 100000000

#define	wsdPrng sqlite3Prng

#define	SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */

#define	WRITE_UTF8(zOut, c)

#define	WRITE_UTF16LE(zOut, c)

#define	WRITE_UTF16BE(zOut, c)

#define	READ_UTF8(zIn, zTerm, c)

#define	UpperToLower sqlite3UpperToLower

#define	SLOT_2_0 0x001fc07f

#define	SLOT_4_2_0 0xf01fc07f

#define	OpHelp(X)

#define	SQLITE_ENABLE_LOCKING_STYLE 0

#define	HAVE_GETHOSTUUID 0

#define	SQLITE_FSFLAGS_IS_MSDOS 0x1

#define	SQLITE_DEFAULT_FILE_PERMISSIONS 0644

#define	SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

#define	MAX_PATHNAME 512

#define	SQLITE_MAX_SYMLINKS 100

#define	osGetpid(X) (pid_t)getpid()

#define	IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))

#define	UNIXFILE_EXCL 0x01 /* Connections from one process only */

#define	UNIXFILE_RDONLY 0x02 /* Connection is read only */

#define	UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

#define	UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */

#define	UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

#define	UNIXFILE_DELETE 0x20 /* Delete on close */

#define	UNIXFILE_URI 0x40 /* Filename might have query parameters */

#define	UNIXFILE_NOLOCK 0x80 /* Do no file locking */

#define	_OS_COMMON_H_

#define	TIMER_START

#define	TIMER_END

#define	TIMER_ELAPSED ((sqlite_uint64)0)

#define	SimulateIOErrorBenign(X)

#define	SimulateIOError(A)

#define	SimulateDiskfullError(A)

#define	OpenCounter(X)

#define	O_LARGEFILE 0

#define	O_NOFOLLOW 0

#define	O_BINARY 0

#define	threadid pthread_self()

#define	HAVE_MREMAP 0

#define	osOpen ((int()(const char,int,int))aSyscall[0].pCurrent)

#define	osClose ((int(*)(int))aSyscall[1].pCurrent)

#define	osAccess ((int()(const char,int))aSyscall[2].pCurrent)

#define	osGetcwd ((char()(char*,size_t))aSyscall[3].pCurrent)

#define	osStat ((int()(const char,struct stat*))aSyscall[4].pCurrent)

#define	osFstat ((int()(int,struct stat))aSyscall[5].pCurrent)

#define	osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)

#define	osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)

#define	osRead ((ssize_t()(int,void,size_t))aSyscall[8].pCurrent)

#define	osPread ((ssize_t()(int,void,size_t,off_t))aSyscall[9].pCurrent)

#define	osPread64 ((ssize_t()(int,void,size_t,off64_t))aSyscall[10].pCurrent)

#define	osWrite ((ssize_t()(int,const void,size_t))aSyscall[11].pCurrent)

#define	osPwrite

#define	osPwrite64

#define	osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)

#define	osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)

#define	osUnlink ((int()(const char))aSyscall[16].pCurrent)

#define	osOpenDirectory ((int()(const char,int*))aSyscall[17].pCurrent)

#define	osMkdir ((int()(const char,mode_t))aSyscall[18].pCurrent)

#define	osRmdir ((int()(const char))aSyscall[19].pCurrent)

#define	osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

#define	osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent)

#define	osMmap ((void()(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)

#define	osMunmap ((int()(void,size_t))aSyscall[23].pCurrent)

#define	osMremap ((void()(void*,size_t,size_t,int,...))aSyscall[24].pCurrent)

#define	osGetpagesize ((int(*)(void))aSyscall[25].pCurrent)

#define	osReadlink ((ssize_t()(const char,char*,size_t))aSyscall[26].pCurrent)

#define	osLstat ((int()(const char,struct stat*))aSyscall[27].pCurrent)

#define	SQLITE_MINIMUM_FILE_DESCRIPTOR 3

#define	unixLogError(a, b, c) unixLogErrorAtLine(a,b,c,__LINE__)

#define	osSetPosixAdvisoryLock(h, x, t) osFcntl(h,F_SETLK,x)

#define	DOTLOCK_SUFFIX ".lock"

#define	fdatasync fsync

#define	HAVE_FULLFSYNC 0

#define	UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)4) / first lock byte */

#define	UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */

#define	IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK, SHMMAP)

#define	UNIXVFS(VFSNAME, FINDER)

#define	BITVEC_SZ 512

#define	BITVEC_USIZE (((BITVEC_SZ-(3sizeof(u32)))/sizeof(Bitvec))sizeof(Bitvec))

#define	BITVEC_TELEM u8

#define	BITVEC_SZELEM 8

#define	BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))

#define	BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM)

#define	BITVEC_NINT (BITVEC_USIZE/sizeof(u32))

#define	BITVEC_MXHASH (BITVEC_NINT/2)

#define	BITVEC_HASH(X) (((X)*1)%BITVEC_NINT)

#define	BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))

#define	SETBIT(V, I) V[I>>3] \|= (1<<(I&7))

#define	CLEARBIT(V, I) V[I>>3] &= ~(1<<(I&7))

#define	TESTBIT(V, I) (V[I>>3]&(1<<(I&7)))!=0

#define	pcacheTrace(X)

#define	pcacheDump(X)

#define	PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */

#define	PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */

#define	PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */

#define	N_SORT_BUCKET 32

#define	PAGE_IS_PINNED(p) ((p)->pLruNext==0)

#define	PAGE_IS_UNPINNED(p) ((p)->pLruNext!=0)

#define	pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))

#define	pcache1EnterMutex(X) assert((X)->mutex==0)

#define	pcache1LeaveMutex(X) assert((X)->mutex==0)

#define	PCACHE1_MIGHT_USE_GROUP_MUTEX 0

#define	ROWSET_ALLOCATION_SIZE 1024

#define	ROWSET_ENTRY_PER_CHUNK ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))

#define	ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */

#define	ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */

#define	SQLITE_WAL_H

#define	WAL_SYNC_FLAGS(X) ((X)&0x03)

#define	CKPT_SYNC_FLAGS(X) (((X)>>2)&0x03)

#define	WAL_SAVEPOINT_NDATA 4

#define	PAGERTRACE(X)

#define	PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))

#define	FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd))

#define	PAGER_OPEN 0

#define	PAGER_READER 1

#define	PAGER_WRITER_LOCKED 2

#define	PAGER_WRITER_CACHEMOD 3

#define	PAGER_WRITER_DBMOD 4

#define	PAGER_WRITER_FINISHED 5

#define	PAGER_ERROR 6

#define	UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)

#define	MAX_SECTOR_SIZE 0x10000

#define	SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */

#define	SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */

#define	SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */

#define	PAGER_STAT_HIT 0

#define	PAGER_STAT_MISS 1

#define	PAGER_STAT_WRITE 2

#define	PAGER_STAT_SPILL 3

#define	PAGER_INCR(v)

#define	JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)

#define	JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)

#define	MEMDB pPager->memDb

#define	USEFETCH(x) 0

#define	isOpen(pFd) ((pFd)->pMethods!=0)

#define	pagerUseWal(x) ((x)->pWal!=0)

#define	put32bits(A, B) sqlite3Put4byte((u8*)A,B)

#define	pager_datahash(X, Y) 0

#define	pager_pagehash(X) 0

#define	pager_set_pagehash(X)

#define	CHECK_PAGE(x)

#define	disable_simulated_io_errors()

#define	enable_simulated_io_errors()

#define	assertTruncateConstraint(pPager)

#define	memJM 0

#define	DIRECT_MODE 0

#define	bBatch 0

#define	WALTRACE(X)

#define	WAL_MAX_VERSION 3007000

#define	WALINDEX_MAX_VERSION 3007000

#define	WAL_WRITE_LOCK 0

#define	WAL_ALL_BUT_WRITE 1

#define	WAL_CKPT_LOCK 1

#define	WAL_RECOVER_LOCK 2

#define	WAL_READ_LOCK(I) (3+(I))

#define	WAL_NREADER (SQLITE_SHM_NLOCK-3)

#define	READMARK_NOT_USED 0xffffffff

#define	WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock))

#define	WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))

#define	WAL_FRAME_HDRSIZE 24

#define	WAL_HDRSIZE 32

#define	WAL_MAGIC 0x377f0682

#define	walFrameOffset(iFrame, szPage)

#define	WAL_NORMAL_MODE 0

#define	WAL_EXCLUSIVE_MODE 1

#define	WAL_HEAPMEMORY_MODE 2

#define	WAL_RDWR 0 /* Normal read/write connection */

#define	WAL_RDONLY 1 /* The WAL file is readonly */

#define	WAL_SHM_RDONLY 2 /* The SHM file is readonly */

#define	HASHTABLE_NPAGE 4096 /* Must be power of 2 */

#define	HASHTABLE_HASH_1 383 /* Should be prime */

#define	HASHTABLE_NSLOT (HASHTABLE_NPAGE2) / Must be a power of 2 */

#define	HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))

#define	WALINDEX_PGSZ

#define	BYTESWAP32(x)

#define	SQLITE_NO_TSAN

#define	walEnableBlocking(x) 0

#define	walDisableBlocking(x)

#define	walLockWriter(pWal) walLockExclusive((pWal), WAL_WRITE_LOCK, 1)

#define	sqlite3WalDb(pWal, db)

#define	WAL_RETRY (-1)

#define	MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))

#define	MX_CELL(pBt) ((pBt->pageSize-8)/6)

#define	SQLITE_FILE_HEADER "SQLite format 3"

#define	PTF_INTKEY 0x01

#define	PTF_ZERODATA 0x02

#define	PTF_LEAFDATA 0x04

#define	PTF_LEAF 0x08

#define	READ_LOCK 1

#define	WRITE_LOCK 2

#define	TRANS_NONE 0

#define	TRANS_READ 1

#define	TRANS_WRITE 2

#define	BTS_READ_ONLY 0x0001 /* Underlying file is readonly */

#define	BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */

#define	BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */

#define	BTS_OVERWRITE 0x0008 /* Overwrite deleted content with zeros */

#define	BTS_FAST_SECURE 0x000c /* Combination of the previous two */

#define	BTS_INITIALLY_EMPTY 0x0010 /* Database was empty at trans start */

#define	BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */

#define	BTS_EXCLUSIVE 0x0040 /* pWriter has an exclusive lock */

#define	BTS_PENDING 0x0080 /* Waiting for read-locks to clear */

#define	BTCURSOR_MAX_DEPTH 20

#define	BTCURSOR_FIRST_UNINIT pBt /* Name of first uninitialized field */

#define	BTCF_WriteFlag 0x01 /* True if a write cursor */

#define	BTCF_ValidNKey 0x02 /* True if info.nKey is valid */

#define	BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */

#define	BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */

#define	BTCF_Incrblob 0x10 /* True if an incremental I/O handle */

#define	BTCF_Multiple 0x20 /* Maybe another cursor on the same btree */

#define	BTCF_Pinned 0x40 /* Cursor is busy and cannot be moved */

#define	CURSOR_VALID 0

#define	CURSOR_INVALID 1

#define	CURSOR_SKIPNEXT 2

#define	CURSOR_REQUIRESEEK 3

#define	CURSOR_FAULT 4

#define	PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)

#define	PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)

#define	PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))

#define	PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))

#define	PTRMAP_ROOTPAGE 1

#define	PTRMAP_FREEPAGE 2

#define	PTRMAP_OVERFLOW1 3

#define	PTRMAP_OVERFLOW2 4

#define	PTRMAP_BTREE 5

#define	btreeIntegrity(p)

#define	ISAUTOVACUUM (pBt->autoVacuum)

#define	get2byte(x) ((x)[0]<<8 \| (x)[1])

#define	put2byte(p, v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))

#define	get4byte sqlite3Get4byte

#define	put4byte sqlite3Put4byte

#define	get2byteAligned(x) ((x)[0]<<8 \| (x)[1])

#define	TRACE(X)

#define	get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)

#define	BTALLOC_ANY 0 /* Allocate any page */

#define	BTALLOC_EXACT 1 /* Allocate exact page if possible */

#define	BTALLOC_LE 2 /* Allocate any page <= the parameter */

#define	IfNotOmitAV(expr) (expr)

#define	SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)

#define	invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)

#define	restoreCursorPosition(p)

#define	findCell(P, I) ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))

#define	findCellPastPtr(P, I) ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))

#define	setDefaultSyncFlag(pBt, safety_level)

#define	assertCellInfo(x)

#define	assertParentIndex(x, y, z)

#define	NN 1 /* Number of neighbors on either side of pPage */

#define	NB 3 /* (NN2+1): Total pages involved in the balance /

#define	ISPOWEROF2(X) (((X)&((X)-1))==0)

#define	valueFromFunction(a, b, c, d, e, f) SQLITE_OK

#define	checkActiveVdbeCnt(x)

#define	vdbeInvokeSqllog(x)

#define	swapMixedEndianFloat(X)

#define	ONE_BYTE_INT(x) ((i8)(x)[0])

#define	TWO_BYTE_INT(x) (256*(i8)((x)[0])\|(x)[1])

#define	THREE_BYTE_INT(x) (65536*(i8)((x)[0])\|((x)[1]<<8)\|(x)[2])

#define	FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)\|((x)[1]<<16)\|((x)[2]<<8)\|(x)[3])

#define	FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])\|((x)[1]<<16)\|((x)[2]<<8)\|(x)[3])

#define	vdbeAssertFieldCountWithinLimits(A, B, C)

#define	checkProfileCallback(DB, P) if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); }

#define	memAboutToChange(P, M)

#define	HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback)

#define	UPDATE_MAX_BLOBSIZE(P)

#define	VdbeBranchTaken(I, M)

#define	Deephemeralize(P)

#define	isSorter(x) ((x)->eCurType==CURTYPE_SORTER)

#define	REGISTER_TRACE(R, M)

#define	MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) \| (u64)0xffffffff )

#define	SQLITE_MAX_PMASZ (1<<29)

#define	SORTER_TYPE_INTEGER 0x01

#define	SORTER_TYPE_TEXT 0x02

#define	SRVAL(p) ((void)((SorterRecord)(p) + 1))

#define	SORTER_MAX_MERGE_COUNT 16

#define	vdbeSorterWorkDebug(x, y)

#define	vdbeSorterRewindDebug(y)

#define	vdbeSorterPopulateDebug(x, y)

#define	vdbeSorterBlockDebug(x, y, z)

#define	vdbeSorterExtendFile(x, y, z)

#define	INCRINIT_NORMAL 0

#define	INCRINIT_TASK 1

#define	INCRINIT_ROOT 2

#define	MEMJOURNAL_DFLT_FILECHUNKSIZE 1024

#define	fileChunkSize(nChunkSize) (sizeof(FileChunk) + ((nChunkSize)-8))

#define	EXCLUDED_TABLE_NUMBER 2

#define	sqlite3ResolveNotValid(P, N, M, X, E)

#define	renameTokenCheckAll(x, y)

#define	IsStat4 0

#define	SQLITE_STAT4_SAMPLES 1

#define	STAT_GET_STAT1 0 /* "stat" column of stat1 table */

#define	STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */

#define	STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */

#define	STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */

#define	STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */

#define	analyzeVdbeCommentIndexWithColumnName(a, b, c)

#define	REOPEN_AS_MEMDB(db) (0)

#define	markExprListImmutable(X) /* no-op */

#define	SQLITE_MAX_SRCLIST 200

#define	FUNC_PERFECT_MATCH 6 /* The score for a perfect match */

#define	noopFunc versionFunc /* Substitute function - never called */

#define	Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))

#define	SQLITE_MATCH 0

#define	SQLITE_NOMATCH 1

#define	SQLITE_NOWILDCARDMATCH 2

#define	COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))

#define	CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */

#define	CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */

#define	SQLITE3EXT_H

#define	SQLITE_EXTENSION_INIT1 /no-op/

#define	SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */

#define	SQLITE_EXTENSION_INIT3 /no-op/

#define	sqlite3_column_database_name 0

#define	sqlite3_column_database_name16 0

#define	sqlite3_column_table_name 0

#define	sqlite3_column_table_name16 0

#define	sqlite3_column_origin_name 0

#define	sqlite3_column_origin_name16 0

#define	DirSep(X) ((X)=='/')

#define	wsdAutoextInit

#define	wsdAutoext sqlite3Autoext

#define	PragTyp_ACTIVATE_EXTENSIONS 0

#define	PragTyp_ANALYSIS_LIMIT 1

#define	PragTyp_HEADER_VALUE 2

#define	PragTyp_AUTO_VACUUM 3

#define	PragTyp_FLAG 4

#define	PragTyp_BUSY_TIMEOUT 5

#define	PragTyp_CACHE_SIZE 6

#define	PragTyp_CACHE_SPILL 7

#define	PragTyp_CASE_SENSITIVE_LIKE 8

#define	PragTyp_COLLATION_LIST 9

#define	PragTyp_COMPILE_OPTIONS 10

#define	PragTyp_DATA_STORE_DIRECTORY 11

#define	PragTyp_DATABASE_LIST 12

#define	PragTyp_DEFAULT_CACHE_SIZE 13

#define	PragTyp_ENCODING 14

#define	PragTyp_FOREIGN_KEY_CHECK 15

#define	PragTyp_FOREIGN_KEY_LIST 16

#define	PragTyp_FUNCTION_LIST 17

#define	PragTyp_HARD_HEAP_LIMIT 18

#define	PragTyp_INCREMENTAL_VACUUM 19

#define	PragTyp_INDEX_INFO 20

#define	PragTyp_INDEX_LIST 21

#define	PragTyp_INTEGRITY_CHECK 22

#define	PragTyp_JOURNAL_MODE 23

#define	PragTyp_JOURNAL_SIZE_LIMIT 24

#define	PragTyp_LOCK_PROXY_FILE 25

#define	PragTyp_LOCKING_MODE 26

#define	PragTyp_PAGE_COUNT 27

#define	PragTyp_MMAP_SIZE 28

#define	PragTyp_MODULE_LIST 29

#define	PragTyp_OPTIMIZE 30

#define	PragTyp_PAGE_SIZE 31

#define	PragTyp_PRAGMA_LIST 32

#define	PragTyp_SECURE_DELETE 33

#define	PragTyp_SHRINK_MEMORY 34

#define	PragTyp_SOFT_HEAP_LIMIT 35

#define	PragTyp_SYNCHRONOUS 36

#define	PragTyp_TABLE_INFO 37

#define	PragTyp_TEMP_STORE 38

#define	PragTyp_TEMP_STORE_DIRECTORY 39

#define	PragTyp_THREADS 40

#define	PragTyp_WAL_AUTOCHECKPOINT 41

#define	PragTyp_WAL_CHECKPOINT 42

#define	PragTyp_LOCK_STATUS 43

#define	PragTyp_STATS 44

#define	PragFlg_NeedSchema 0x01 /* Force schema load before running */

#define	PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */

#define	PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */

#define	PragFlg_ReadOnly 0x08 /* Read-only HEADER_VALUE */

#define	PragFlg_Result0 0x10 /* Acts as query when no argument */

#define	PragFlg_Result1 0x20 /* Acts as query when has one argument */

#define	PragFlg_SchemaOpt 0x40 /* Schema restricts name search if present */

#define	PragFlg_SchemaReq 0x80 /* Schema required - "main" is default */

#define	SQLITE_INTEGRITY_CHECK_ERROR_MAX 100

#define	SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */

#define	explainSetInteger(a, b) a = b

#define	columnType(A, B, C, D, E) columnTypeImpl(A,B)

#define	SQLITE_WHEREINT_H

#define	WHERETRACE(K, X)

#define	WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)

#define	N_OR_COST 3

#define	TERM_DYNAMIC 0x0001 /* Need to call sqlite3ExprDelete(db, pExpr) */

#define	TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */

#define	TERM_CODED 0x0004 /* This term is already coded */

#define	TERM_COPIED 0x0008 /* Has a child */

#define	TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */

#define	TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */

#define	TERM_OR_OK 0x0040 /* Used during OR-clause processing */

#define	TERM_VNULL 0x0000 /* Disabled if not using stat4 */

#define	TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */

#define	TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */

#define	TERM_LIKE 0x0400 /* The original LIKE operator */

#define	TERM_IS 0x0800 /* Term.pExpr is an IS operator */

#define	TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */

#define	TERM_HEURTRUTH 0x2000 /* Heuristic truthProb used */

#define	TERM_HIGHTRUTH 0 /* Only used with STAT4 */

#define	initMaskSet(P) (P)->n=0

#define	SQLITE_BLDF1_INDEXED 0x0001 /* An index is used */

#define	SQLITE_BLDF1_UNIQUE 0x0002 /* All keys of a UNIQUE index used */

#define	SQLITE_BLDF2_2NDPASS 0x0004 /* Second builder pass needed */

#define	SQLITE_QUERY_PLANNER_LIMIT 20000

#define	SQLITE_QUERY_PLANNER_LIMIT_INCR 1000

#define	sqlite3WhereAddScanStatus(a, b, c, d) ((void)d)

#define	WO_IN 0x0001

#define	WO_EQ 0x0002

#define	WO_LT (WO_EQ<<(TK_LT-TK_EQ))

#define	WO_LE (WO_EQ<<(TK_LE-TK_EQ))

#define	WO_GT (WO_EQ<<(TK_GT-TK_EQ))

#define	WO_GE (WO_EQ<<(TK_GE-TK_EQ))

#define	WO_AUX 0x0040 /* Op useful to virtual tables only */

#define	WO_IS 0x0080

#define	WO_ISNULL 0x0100

#define	WO_OR 0x0200 /* Two or more OR-connected terms */

#define	WO_AND 0x0400 /* Two or more AND-connected terms */

#define	WO_EQUIV 0x0800 /* Of the form A==B, both columns */

#define	WO_NOOP 0x1000 /* This term does not restrict search space */

#define	WO_ALL 0x1fff /* Mask of all possible WO_* values */

#define	WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */

#define	WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */

#define	WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */

#define	WHERE_COLUMN_IN 0x00000004 /* x IN (...) */

#define	WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */

#define	WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */

#define	WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */

#define	WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */

#define	WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */

#define	WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */

#define	WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */

#define	WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */

#define	WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */

#define	WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */

#define	WHERE_ONEROW 0x00001000 /* Selects no more than one row */

#define	WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */

#define	WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */

#define	WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */

#define	WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/

#define	WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */

#define	WHERE_IN_EARLYOUT 0x00040000 /* Perhaps quit IN loops early */

#define	WHERE_BIGNULL_SORT 0x00080000 /* Column nEq of index is BIGNULL */

#define	codeCursorHint(A, B, C, D) /* No-op */

#define	whereTraceIndexInfoInputs(A)

#define	whereTraceIndexInfoOutputs(A)

#define	ApplyCostMultiplier(C, T)

#define	WHERETRACE_ALL_LOOPS(W, C)

#define	OpcodeRewriteTrace(D, K, P) /* no-op */

#define	nth_valueInvFunc noopStepFunc

#define	nth_valueValueFunc noopValueFunc

#define	first_valueInvFunc noopStepFunc

#define	first_valueValueFunc noopValueFunc

#define	percent_rankFinalizeFunc percent_rankValueFunc

#define	cume_distFinalizeFunc cume_distValueFunc

#define	ntileFinalizeFunc ntileValueFunc

#define	WINDOWFUNCALL(name, nArg, extra)

#define	WINDOWFUNCNOOP(name, nArg, extra)

#define	WINDOWFUNCX(name, nArg, extra)

#define	WINDOW_STARTING_INT 0

#define	WINDOW_ENDING_INT 1

#define	WINDOW_NTH_VALUE_INT 2

#define	WINDOW_STARTING_NUM 3

#define	WINDOW_ENDING_NUM 4

#define	WINDOW_RETURN_ROW 1

#define	WINDOW_AGGINVERSE 2

#define	WINDOW_AGGSTEP 3

#define	YYNOERRORRECOVERY 1

#define	yytestcase(X) testcase(X)

#define	YYPARSEFREENEVERNULL 1

#define	sqlite3Parser_ENGINEALWAYSONSTACK 1

#define	YYMALLOCARGTYPE u64

#define	INTERFACE 1

#define	YYCODETYPE unsigned short int

#define	YYNOCODE 310

#define	YYACTIONTYPE unsigned short int

#define	YYWILDCARD 100

#define	sqlite3ParserTOKENTYPE Token

#define	YYSTACKDEPTH 100

#define	sqlite3ParserARG_SDECL

#define	sqlite3ParserARG_PDECL

#define	sqlite3ParserARG_PARAM

#define	sqlite3ParserARG_FETCH

#define	sqlite3ParserARG_STORE

#define	sqlite3ParserCTX_SDECL Parse *pParse;

#define	sqlite3ParserCTX_PDECL ,Parse *pParse

#define	sqlite3ParserCTX_PARAM ,pParse

#define	sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;

#define	sqlite3ParserCTX_STORE yypParser->pParse=pParse;

#define	YYFALLBACK 1

#define	YYNSTATE 553

#define	YYNRULE 385

#define	YYNRULE_WITH_ACTION 325

#define	YYNTOKEN 181

#define	YY_MAX_SHIFT 552

#define	YY_MIN_SHIFTREDUCE 803

#define	YY_MAX_SHIFTREDUCE 1187

#define	YY_ERROR_ACTION 1188

#define	YY_ACCEPT_ACTION 1189

#define	YY_NO_ACTION 1190

#define	YY_MIN_REDUCE 1191

#define	YY_MAX_REDUCE 1575

#define	YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

#define	YY_ACTTAB_COUNT (1962)

#define	YY_SHIFT_COUNT (552)

#define	YY_SHIFT_MIN (0)

#define	YY_SHIFT_MAX (1951)

#define	YY_REDUCE_COUNT (391)

#define	YY_REDUCE_MIN (-262)

#define	YY_REDUCE_MAX (1625)

#define	yyTraceShift(X, Y, Z)

#define	TOKEN yyminor

#define	CC_X 0 /* The letter 'x', or start of BLOB literal */

#define	CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */

#define	CC_ID 2 /* unicode characters usable in IDs */

#define	CC_DIGIT 3 /* Digits */

#define	CC_DOLLAR 4 /* '$' */

#define	CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */

#define	CC_VARNUM 6 /* '?'. Numeric SQL variables */

#define	CC_SPACE 7 /* Space characters */

#define	CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */

#define	CC_QUOTE2 9 /* '['. [...] style quoted ids */

#define	CC_PIPE 10 /* '\|'. Bitwise OR or concatenate */

#define	CC_MINUS 11 /* '-'. Minus or SQL-style comment */

#define	CC_LT 12 /* '<'. Part of < or <= or <> */

#define	CC_GT 13 /* '>'. Part of > or >= */

#define	CC_EQ 14 /* '='. Part of = or == */

#define	CC_BANG 15 /* '!'. Part of != */

#define	CC_SLASH 16 /* '/'. / or c-style comment */

#define	CC_LP 17 /* '(' */

#define	CC_RP 18 /* ')' */

#define	CC_SEMI 19 /* ';' */

#define	CC_PLUS 20 /* '+' */

#define	CC_STAR 21 /* '' /

#define	CC_PERCENT 22 /* '%' */

#define	CC_COMMA 23 /* ',' */

#define	CC_AND 24 /* '&' */

#define	CC_TILDA 25 /* '~' */

#define	CC_DOT 26 /* '.' */

#define	CC_ILLEGAL 27 /* Illegal character */

#define	CC_NUL 28 /* 0x00 */

#define	charMap(X) sqlite3UpperToLower[(unsigned char)X]

#define	SQLITE_N_KEYWORD 145

#define	IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)

#define	tkSEMI 0

#define	tkWS 1

#define	tkOTHER 2

#define	tkEXPLAIN 3

#define	tkCREATE 4

#define	tkTEMP 5

#define	tkTRIGGER 6

#define	tkEND 7

#define	SQLITE_DQS 3

#define	_FTSINT_H

#define	SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0alt2"

Typedefs
typedef struct sqlite3	sqlite3

typedef long long int	sqlite_int64

typedef unsigned long long int	sqlite_uint64

typedef sqlite_int64	sqlite3_int64

typedef sqlite_uint64	sqlite3_uint64

typedef int(*	sqlite3_callback) (void , int, char , char *)

typedef struct sqlite3_file	sqlite3_file

typedef struct sqlite3_io_methods	sqlite3_io_methods

typedef struct sqlite3_mutex	sqlite3_mutex

typedef struct sqlite3_api_routines	sqlite3_api_routines

typedef struct sqlite3_vfs	sqlite3_vfs

typedef void(*	sqlite3_syscall_ptr) (void)

typedef struct sqlite3_mem_methods	sqlite3_mem_methods

typedef struct sqlite3_stmt	sqlite3_stmt

typedef struct sqlite3_value	sqlite3_value

typedef struct sqlite3_context	sqlite3_context

typedef void(*	sqlite3_destructor_type) (void *)

typedef struct sqlite3_vtab	sqlite3_vtab

typedef struct sqlite3_index_info	sqlite3_index_info

typedef struct sqlite3_vtab_cursor	sqlite3_vtab_cursor

typedef struct sqlite3_module	sqlite3_module

typedef struct sqlite3_blob	sqlite3_blob

typedef struct sqlite3_mutex_methods	sqlite3_mutex_methods

typedef struct sqlite3_str	sqlite3_str

typedef struct sqlite3_pcache	sqlite3_pcache

typedef struct sqlite3_pcache_page	sqlite3_pcache_page

typedef struct sqlite3_pcache_methods2	sqlite3_pcache_methods2

typedef struct sqlite3_pcache_methods	sqlite3_pcache_methods

typedef struct sqlite3_backup	sqlite3_backup

typedef struct sqlite3_snapshot	sqlite3_snapshot

typedef struct sqlite3_rtree_geometry	sqlite3_rtree_geometry

typedef struct sqlite3_rtree_query_info	sqlite3_rtree_query_info

typedef double	sqlite3_rtree_dbl

typedef struct Fts5ExtensionApi	Fts5ExtensionApi

typedef struct Fts5Context	Fts5Context

typedef struct Fts5PhraseIter	Fts5PhraseIter

typedef void(*	fts5_extension_function) (const Fts5ExtensionApi pApi, Fts5Context pFts, sqlite3_context pCtx, int nVal, sqlite3_value *apVal)

typedef struct Fts5Tokenizer	Fts5Tokenizer

typedef struct fts5_tokenizer	fts5_tokenizer

typedef struct fts5_api	fts5_api

typedef struct Hash	Hash

typedef struct HashElem	HashElem

typedef sqlite_int64	i64

typedef sqlite_uint64	u64

typedef UINT32_TYPE	u32

typedef UINT16_TYPE	u16

typedef INT16_TYPE	i16

typedef UINT8_TYPE	u8

typedef INT8_TYPE	i8

typedef u32	tRowcnt

typedef INT16_TYPE	LogEst

typedef u64	uptr

typedef struct BusyHandler	BusyHandler

typedef struct AggInfo	AggInfo

typedef struct AuthContext	AuthContext

typedef struct AutoincInfo	AutoincInfo

typedef struct Bitvec	Bitvec

typedef struct CollSeq	CollSeq

typedef struct Column	Column

typedef struct Db	Db

typedef struct Schema	Schema

typedef struct Expr	Expr

typedef struct ExprList	ExprList

typedef struct FKey	FKey

typedef struct FuncDestructor	FuncDestructor

typedef struct FuncDef	FuncDef

typedef struct FuncDefHash	FuncDefHash

typedef struct IdList	IdList

typedef struct Index	Index

typedef struct IndexSample	IndexSample

typedef struct KeyClass	KeyClass

typedef struct KeyInfo	KeyInfo

typedef struct Lookaside	Lookaside

typedef struct LookasideSlot	LookasideSlot

typedef struct Module	Module

typedef struct NameContext	NameContext

typedef struct Parse	Parse

typedef struct PreUpdate	PreUpdate

typedef struct PrintfArguments	PrintfArguments

typedef struct RenameToken	RenameToken

typedef struct RowSet	RowSet

typedef struct Savepoint	Savepoint

typedef struct Select	Select

typedef struct SQLiteThread	SQLiteThread

typedef struct SelectDest	SelectDest

typedef struct SrcList	SrcList

typedef struct sqlite3_str	StrAccum

typedef struct Table	Table

typedef struct TableLock	TableLock

typedef struct Token	Token

typedef struct TreeView	TreeView

typedef struct Trigger	Trigger

typedef struct TriggerPrg	TriggerPrg

typedef struct TriggerStep	TriggerStep

typedef struct UnpackedRecord	UnpackedRecord

typedef struct Upsert	Upsert

typedef struct VTable	VTable

typedef struct VtabCtx	VtabCtx

typedef struct Walker	Walker

typedef struct WhereInfo	WhereInfo

typedef struct Window	Window

typedef struct With	With

typedef u64	Bitmask

typedef int	VList

typedef u32	Pgno

typedef struct Pager	Pager

typedef struct PgHdr	DbPage

typedef struct Btree	Btree

typedef struct BtCursor	BtCursor

typedef struct BtShared	BtShared

typedef struct BtreePayload	BtreePayload

typedef struct Vdbe	Vdbe

typedef struct sqlite3_value	Mem

typedef struct SubProgram	SubProgram

typedef struct VdbeOp	VdbeOp

typedef struct VdbeOpList	VdbeOpList

typedef int(*	RecordCompare) (int, const void , UnpackedRecord )

typedef struct PgHdr	PgHdr

typedef struct PCache	PCache

typedef int(*	sqlite3_xauth) (void , int, const char , const char , const char , const char *)

typedef i16	ynVar

typedef unsigned int	yDbMask

typedef struct DbFixer	DbFixer

typedef struct VdbeOp	Op

typedef unsigned	Bool

typedef struct VdbeSorter	VdbeSorter

typedef struct AuxData	AuxData

typedef struct VdbeCursor	VdbeCursor

typedef struct VdbeFrame	VdbeFrame

typedef unsigned	bft

typedef struct ScanStatus	ScanStatus

typedef struct DblquoteStr	DblquoteStr

typedef sqlite3_int64	sqlite3StatValueType

typedef struct sqlite3StatType	sqlite3StatType

typedef struct DateTime	DateTime

typedef struct BenignMallocHooks	BenignMallocHooks

typedef unsigned char	etByte

typedef struct et_info	et_info

typedef struct unixShm	unixShm

typedef struct unixShmNode	unixShmNode

typedef struct unixInodeInfo	unixInodeInfo

typedef struct UnixUnusedFd	UnixUnusedFd

typedef struct unixFile	unixFile

typedef struct PCache1	PCache1

typedef struct PgHdr1	PgHdr1

typedef struct PgFreeslot	PgFreeslot

typedef struct PGroup	PGroup

typedef struct Wal	Wal

typedef struct PagerSavepoint	PagerSavepoint

typedef struct WalIndexHdr	WalIndexHdr

typedef struct WalIterator	WalIterator

typedef struct WalCkptInfo	WalCkptInfo

typedef u16	ht_slot

typedef struct WalHashLoc	WalHashLoc

typedef struct WalWriter	WalWriter

typedef struct MemPage	MemPage

typedef struct BtLock	BtLock

typedef struct CellInfo	CellInfo

typedef struct IntegrityCk	IntegrityCk

typedef struct CellArray	CellArray

typedef struct Incrblob	Incrblob

typedef struct MergeEngine	MergeEngine

typedef struct PmaReader	PmaReader

typedef struct PmaWriter	PmaWriter

typedef struct SorterRecord	SorterRecord

typedef struct SortSubtask	SortSubtask

typedef struct SorterFile	SorterFile

typedef struct SorterList	SorterList

typedef struct IncrMerger	IncrMerger

typedef int(*	SorterCompare) (SortSubtask , int , const void , int, const void , int)

typedef struct MemJournal	MemJournal

typedef struct FilePoint	FilePoint

typedef struct FileChunk	FileChunk

typedef struct RenameCtx	RenameCtx

typedef struct StatAccum	StatAccum

typedef struct StatSample	StatSample

typedef struct analysisInfo	analysisInfo

typedef struct SumCtx	SumCtx

typedef struct CountCtx	CountCtx

typedef int(*	sqlite3_loadext_entry) (sqlite3 db, char pzErrMsg, const sqlite3_api_routines pThunk)

typedef struct sqlite3AutoExtList	sqlite3AutoExtList

typedef struct PragmaName	PragmaName

typedef struct PragmaVtab	PragmaVtab

typedef struct PragmaVtabCursor	PragmaVtabCursor

typedef struct DistinctCtx	DistinctCtx

typedef struct SortCtx	SortCtx

typedef struct RowLoadInfo	RowLoadInfo

typedef struct SubstContext	SubstContext

typedef struct WhereConst	WhereConst

typedef struct TabResult	TabResult

typedef struct WhereClause	WhereClause

typedef struct WhereMaskSet	WhereMaskSet

typedef struct WhereOrInfo	WhereOrInfo

typedef struct WhereAndInfo	WhereAndInfo

typedef struct WhereLevel	WhereLevel

typedef struct WhereLoop	WhereLoop

typedef struct WherePath	WherePath

typedef struct WhereTerm	WhereTerm

typedef struct WhereLoopBuilder	WhereLoopBuilder

typedef struct WhereScan	WhereScan

typedef struct WhereOrCost	WhereOrCost

typedef struct WhereOrSet	WhereOrSet

typedef struct WhereExprMod	WhereExprMod

typedef struct IdxExprTrans	IdxExprTrans

typedef struct HiddenIndexInfo	HiddenIndexInfo

typedef struct WindowRewrite	WindowRewrite

typedef struct WindowCodeArg	WindowCodeArg

typedef struct WindowCsrAndReg	WindowCsrAndReg

typedef struct yyStackEntry	yyStackEntry

typedef struct yyParser	yyParser

Functions
SQLITE_PRIVATE const char **	sqlite3CompileOptions (int *pnOpt)

SQLITE_API const char *	sqlite3_libversion (void)

SQLITE_API const char *	sqlite3_sourceid (void)

SQLITE_API int	sqlite3_libversion_number (void)

SQLITE_API int	sqlite3_compileoption_used (const char *zOptName)

SQLITE_API const char *	sqlite3_compileoption_get (int N)

SQLITE_API int	sqlite3_threadsafe (void)

SQLITE_API int	sqlite3_close (sqlite3 *)

SQLITE_API int	sqlite3_close_v2 (sqlite3 *)

SQLITE_API int	sqlite3_exec (sqlite3 , const char sql, int(callback)(void , int, char , char ), void , char *errmsg)

SQLITE_API int	sqlite3_initialize (void)

SQLITE_API int	sqlite3_shutdown (void)

SQLITE_API int	sqlite3_os_init (void)

SQLITE_API int	sqlite3_os_end (void)

SQLITE_API int	sqlite3_config (int,...)

SQLITE_API int	sqlite3_db_config (sqlite3 *, int op,...)

SQLITE_API int	sqlite3_extended_result_codes (sqlite3 *, int onoff)

SQLITE_API sqlite3_int64	sqlite3_last_insert_rowid (sqlite3 *)

SQLITE_API void	sqlite3_set_last_insert_rowid (sqlite3 *, sqlite3_int64)

SQLITE_API int	sqlite3_changes (sqlite3 *)

SQLITE_API int	sqlite3_total_changes (sqlite3 *)

SQLITE_API void	sqlite3_interrupt (sqlite3 *)

SQLITE_API int	sqlite3_complete (const char *sql)

SQLITE_API int	sqlite3_complete16 (const void *sql)

SQLITE_API int	sqlite3_busy_handler (sqlite3 , int()(void , int), void )

SQLITE_API int	sqlite3_busy_timeout (sqlite3 *, int ms)

SQLITE_API int	sqlite3_get_table (sqlite3 db, const char zSql, char **pazResult, int pnRow, int pnColumn, char *pzErrmsg)

SQLITE_API void	sqlite3_free_table (char **result)

SQLITE_API char *	sqlite3_mprintf (const char *,...)

SQLITE_API char *	sqlite3_vmprintf (const char *, va_list)

SQLITE_API char *	sqlite3_snprintf (int, char , const char ,...)

SQLITE_API char *	sqlite3_vsnprintf (int, char , const char , va_list)

SQLITE_API void *	sqlite3_malloc (int)

SQLITE_API void *	sqlite3_malloc64 (sqlite3_uint64)

SQLITE_API void *	sqlite3_realloc (void *, int)

SQLITE_API void *	sqlite3_realloc64 (void *, sqlite3_uint64)

SQLITE_API void	sqlite3_free (void *)

SQLITE_API sqlite3_uint64	sqlite3_msize (void *)

SQLITE_API sqlite3_int64	sqlite3_memory_used (void)

SQLITE_API sqlite3_int64	sqlite3_memory_highwater (int resetFlag)

SQLITE_API void	sqlite3_randomness (int N, void *P)

SQLITE_API int	sqlite3_set_authorizer (sqlite3 , int(xAuth)(void , int, const char , const char , const char , const char ), void pUserData)

SQLITE_API SQLITE_DEPRECATED void *	sqlite3_trace (sqlite3 , void(xTrace)(void , const char ), void *)

SQLITE_API SQLITE_DEPRECATED void *	sqlite3_profile (sqlite3 , void(xProfile)(void , const char , sqlite3_uint64), void *)

SQLITE_API int	sqlite3_trace_v2 (sqlite3 , unsigned uMask, int(xCallback)(unsigned, void , void , void ), void pCtx)

SQLITE_API void	sqlite3_progress_handler (sqlite3 , int, int()(void ), void )

SQLITE_API int	sqlite3_open (const char filename, sqlite3 *ppDb)

SQLITE_API int	sqlite3_open16 (const void filename, sqlite3 *ppDb)

SQLITE_API int	sqlite3_open_v2 (const char filename, sqlite3 ppDb, int flags, const char zVfs)

SQLITE_API const char *	sqlite3_uri_parameter (const char zFilename, const char zParam)

SQLITE_API int	sqlite3_uri_boolean (const char zFile, const char zParam, int bDefault)

SQLITE_API sqlite3_int64	sqlite3_uri_int64 (const char , const char , sqlite3_int64)

SQLITE_API const char *	sqlite3_uri_key (const char *zFilename, int N)

SQLITE_API const char *	sqlite3_filename_database (const char *)

SQLITE_API const char *	sqlite3_filename_journal (const char *)

SQLITE_API const char *	sqlite3_filename_wal (const char *)

SQLITE_API sqlite3_file *	sqlite3_database_file_object (const char *)

SQLITE_API char *	sqlite3_create_filename (const char zDatabase, const char zJournal, const char zWal, int nParam, const char *azParam)

SQLITE_API void	sqlite3_free_filename (char *)

SQLITE_API int	sqlite3_errcode (sqlite3 *db)

SQLITE_API int	sqlite3_extended_errcode (sqlite3 *db)

SQLITE_API const char *	sqlite3_errmsg (sqlite3 *)

SQLITE_API const void *	sqlite3_errmsg16 (sqlite3 *)

SQLITE_API const char *	sqlite3_errstr (int)

SQLITE_API int	sqlite3_limit (sqlite3 *, int id, int newVal)

SQLITE_API int	sqlite3_prepare (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)

SQLITE_API int	sqlite3_prepare_v2 (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)

SQLITE_API int	sqlite3_prepare_v3 (sqlite3 db, const char zSql, int nByte, unsigned int prepFlags, sqlite3_stmt ppStmt, const char pzTail)

SQLITE_API int	sqlite3_prepare16 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)

SQLITE_API int	sqlite3_prepare16_v2 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)

SQLITE_API int	sqlite3_prepare16_v3 (sqlite3 db, const void zSql, int nByte, unsigned int prepFlags, sqlite3_stmt ppStmt, const void pzTail)

SQLITE_API const char *	sqlite3_sql (sqlite3_stmt *pStmt)

SQLITE_API char *	sqlite3_expanded_sql (sqlite3_stmt *pStmt)

SQLITE_API const char *	sqlite3_normalized_sql (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_readonly (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_isexplain (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_busy (sqlite3_stmt *)

SQLITE_API int	sqlite3_bind_blob (sqlite3_stmt , int, const void , int n, void()(void ))

SQLITE_API int	sqlite3_bind_blob64 (sqlite3_stmt , int, const void , sqlite3_uint64, void()(void ))

SQLITE_API int	sqlite3_bind_double (sqlite3_stmt *, int, double)

SQLITE_API int	sqlite3_bind_int (sqlite3_stmt *, int, int)

SQLITE_API int	sqlite3_bind_int64 (sqlite3_stmt *, int, sqlite3_int64)

SQLITE_API int	sqlite3_bind_null (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_bind_text (sqlite3_stmt , int, const char , int, void()(void ))

SQLITE_API int	sqlite3_bind_text16 (sqlite3_stmt , int, const void , int, void()(void ))

SQLITE_API int	sqlite3_bind_text64 (sqlite3_stmt , int, const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API int	sqlite3_bind_value (sqlite3_stmt , int, const sqlite3_value )

SQLITE_API int	sqlite3_bind_pointer (sqlite3_stmt , int, void , const char , void()(void *))

SQLITE_API int	sqlite3_bind_zeroblob (sqlite3_stmt *, int, int n)

SQLITE_API int	sqlite3_bind_zeroblob64 (sqlite3_stmt *, int, sqlite3_uint64)

SQLITE_API int	sqlite3_bind_parameter_count (sqlite3_stmt *)

SQLITE_API const char *	sqlite3_bind_parameter_name (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_bind_parameter_index (sqlite3_stmt , const char zName)

SQLITE_API int	sqlite3_clear_bindings (sqlite3_stmt *)

SQLITE_API int	sqlite3_column_count (sqlite3_stmt *pStmt)

SQLITE_API const char *	sqlite3_column_name (sqlite3_stmt *, int N)

SQLITE_API const void *	sqlite3_column_name16 (sqlite3_stmt *, int N)

SQLITE_API const char *	sqlite3_column_database_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_database_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_table_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_table_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_origin_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_origin_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_decltype (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_decltype16 (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_step (sqlite3_stmt *)

SQLITE_API int	sqlite3_data_count (sqlite3_stmt *pStmt)

SQLITE_API const void *	sqlite3_column_blob (sqlite3_stmt *, int iCol)

SQLITE_API double	sqlite3_column_double (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_int (sqlite3_stmt *, int iCol)

SQLITE_API sqlite3_int64	sqlite3_column_int64 (sqlite3_stmt *, int iCol)

SQLITE_API const unsigned char *	sqlite3_column_text (sqlite3_stmt *, int iCol)

SQLITE_API const void *	sqlite3_column_text16 (sqlite3_stmt *, int iCol)

SQLITE_API sqlite3_value *	sqlite3_column_value (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_bytes (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_bytes16 (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_type (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_finalize (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_reset (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_create_function (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

SQLITE_API int	sqlite3_create_function16 (sqlite3 db, const void zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

SQLITE_API int	sqlite3_create_function_v2 (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context ), void(xDestroy)(void *))

SQLITE_API int	sqlite3_create_window_function (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context ), void(xValue)(sqlite3_context ), void(xInverse)(sqlite3_context , int, sqlite3_value ), void(xDestroy)(void *))

SQLITE_API SQLITE_DEPRECATED int	sqlite3_aggregate_count (sqlite3_context *)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_expired (sqlite3_stmt *)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_transfer_bindings (sqlite3_stmt , sqlite3_stmt )

SQLITE_API SQLITE_DEPRECATED int	sqlite3_global_recover (void)

SQLITE_API SQLITE_DEPRECATED void	sqlite3_thread_cleanup (void)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_memory_alarm (void()(void , sqlite3_int64, int), void *, sqlite3_int64)

SQLITE_API const void *	sqlite3_value_blob (sqlite3_value *)

SQLITE_API double	sqlite3_value_double (sqlite3_value *)

SQLITE_API int	sqlite3_value_int (sqlite3_value *)

SQLITE_API sqlite3_int64	sqlite3_value_int64 (sqlite3_value *)

SQLITE_API void *	sqlite3_value_pointer (sqlite3_value , const char )

SQLITE_API const unsigned char *	sqlite3_value_text (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16 (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16le (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16be (sqlite3_value *)

SQLITE_API int	sqlite3_value_bytes (sqlite3_value *)

SQLITE_API int	sqlite3_value_bytes16 (sqlite3_value *)

SQLITE_API int	sqlite3_value_type (sqlite3_value *)

SQLITE_API int	sqlite3_value_numeric_type (sqlite3_value *)

SQLITE_API int	sqlite3_value_nochange (sqlite3_value *)

SQLITE_API int	sqlite3_value_frombind (sqlite3_value *)

SQLITE_API unsigned int	sqlite3_value_subtype (sqlite3_value *)

SQLITE_API sqlite3_value *	sqlite3_value_dup (const sqlite3_value *)

SQLITE_API void	sqlite3_value_free (sqlite3_value *)

SQLITE_API void *	sqlite3_aggregate_context (sqlite3_context *, int nBytes)

SQLITE_API void *	sqlite3_user_data (sqlite3_context *)

SQLITE_API sqlite3 *	sqlite3_context_db_handle (sqlite3_context *)

SQLITE_API void *	sqlite3_get_auxdata (sqlite3_context *, int N)

SQLITE_API void	sqlite3_set_auxdata (sqlite3_context , int N, void , void()(void ))

SQLITE_API void	sqlite3_result_blob (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_blob64 (sqlite3_context , const void , sqlite3_uint64, void()(void ))

SQLITE_API void	sqlite3_result_double (sqlite3_context *, double)

SQLITE_API void	sqlite3_result_error (sqlite3_context , const char , int)

SQLITE_API void	sqlite3_result_error16 (sqlite3_context , const void , int)

SQLITE_API void	sqlite3_result_error_toobig (sqlite3_context *)

SQLITE_API void	sqlite3_result_error_nomem (sqlite3_context *)

SQLITE_API void	sqlite3_result_error_code (sqlite3_context *, int)

SQLITE_API void	sqlite3_result_int (sqlite3_context *, int)

SQLITE_API void	sqlite3_result_int64 (sqlite3_context *, sqlite3_int64)

SQLITE_API void	sqlite3_result_null (sqlite3_context *)

SQLITE_API void	sqlite3_result_text (sqlite3_context , const char , int, void()(void ))

SQLITE_API void	sqlite3_result_text64 (sqlite3_context , const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API void	sqlite3_result_text16 (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_text16le (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_text16be (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_value (sqlite3_context , sqlite3_value )

SQLITE_API void	sqlite3_result_pointer (sqlite3_context , void , const char , void()(void *))

SQLITE_API void	sqlite3_result_zeroblob (sqlite3_context *, int n)

SQLITE_API int	sqlite3_result_zeroblob64 (sqlite3_context *, sqlite3_uint64 n)

SQLITE_API void	sqlite3_result_subtype (sqlite3_context *, unsigned int)

SQLITE_API int	sqlite3_create_collation (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))

SQLITE_API int	sqlite3_create_collation_v2 (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void ), void(xDestroy)(void *))

SQLITE_API int	sqlite3_create_collation16 (sqlite3 , const void zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))

SQLITE_API int	sqlite3_collation_needed (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const char ))

SQLITE_API int	sqlite3_collation_needed16 (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const void ))

SQLITE_API int	sqlite3_sleep (int)

SQLITE_API int	sqlite3_win32_set_directory (unsigned long type, void *zValue)

SQLITE_API int	sqlite3_win32_set_directory8 (unsigned long type, const char *zValue)

SQLITE_API int	sqlite3_win32_set_directory16 (unsigned long type, const void *zValue)

SQLITE_API int	sqlite3_get_autocommit (sqlite3 *)

SQLITE_API sqlite3 *	sqlite3_db_handle (sqlite3_stmt *)

SQLITE_API const char *	sqlite3_db_filename (sqlite3 db, const char zDbName)

SQLITE_API int	sqlite3_db_readonly (sqlite3 db, const char zDbName)

SQLITE_API sqlite3_stmt *	sqlite3_next_stmt (sqlite3 pDb, sqlite3_stmt pStmt)

SQLITE_API void *	sqlite3_commit_hook (sqlite3 , int()(void ), void )

SQLITE_API void *	sqlite3_rollback_hook (sqlite3 , void()(void ), void )

SQLITE_API void *	sqlite3_update_hook (sqlite3 , void()(void , int, char const , char const , sqlite3_int64), void )

SQLITE_API int	sqlite3_enable_shared_cache (int)

SQLITE_API int	sqlite3_release_memory (int)

SQLITE_API int	sqlite3_db_release_memory (sqlite3 *)

SQLITE_API sqlite3_int64	sqlite3_soft_heap_limit64 (sqlite3_int64 N)

SQLITE_API sqlite3_int64	sqlite3_hard_heap_limit64 (sqlite3_int64 N)

SQLITE_API SQLITE_DEPRECATED void	sqlite3_soft_heap_limit (int N)

SQLITE_API int	sqlite3_table_column_metadata (sqlite3 db, const char zDbName, const char zTableName, const char zColumnName, char const pzDataType, char const pzCollSeq, int pNotNull, int pPrimaryKey, int *pAutoinc)

SQLITE_API int	sqlite3_load_extension (sqlite3 db, const char zFile, const char zProc, char *pzErrMsg)

SQLITE_API int	sqlite3_enable_load_extension (sqlite3 *db, int onoff)

SQLITE_API int	sqlite3_auto_extension (void(*xEntryPoint)(void))

SQLITE_API int	sqlite3_cancel_auto_extension (void(*xEntryPoint)(void))

SQLITE_API void	sqlite3_reset_auto_extension (void)

SQLITE_API int	sqlite3_create_module (sqlite3 db, const char zName, const sqlite3_module p, void pClientData)

SQLITE_API int	sqlite3_create_module_v2 (sqlite3 db, const char zName, const sqlite3_module p, void pClientData, void(xDestroy)(void ))

SQLITE_API int	sqlite3_drop_modules (sqlite3 db, const char *azKeep)

SQLITE_API int	sqlite3_declare_vtab (sqlite3 , const char zSQL)

SQLITE_API int	sqlite3_overload_function (sqlite3 , const char zFuncName, int nArg)

SQLITE_API int	sqlite3_blob_open (sqlite3 , const char zDb, const char zTable, const char zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob)

SQLITE_API int	sqlite3_blob_reopen (sqlite3_blob *, sqlite3_int64)

SQLITE_API int	sqlite3_blob_close (sqlite3_blob *)

SQLITE_API int	sqlite3_blob_bytes (sqlite3_blob *)

SQLITE_API int	sqlite3_blob_read (sqlite3_blob , void Z, int N, int iOffset)

SQLITE_API int	sqlite3_blob_write (sqlite3_blob , const void z, int n, int iOffset)

SQLITE_API sqlite3_vfs *	sqlite3_vfs_find (const char *zVfsName)

SQLITE_API int	sqlite3_vfs_register (sqlite3_vfs *, int makeDflt)

SQLITE_API int	sqlite3_vfs_unregister (sqlite3_vfs *)

SQLITE_API sqlite3_mutex *	sqlite3_mutex_alloc (int)

SQLITE_API void	sqlite3_mutex_free (sqlite3_mutex *)

SQLITE_API void	sqlite3_mutex_enter (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_try (sqlite3_mutex *)

SQLITE_API void	sqlite3_mutex_leave (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_held (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_notheld (sqlite3_mutex *)

SQLITE_API sqlite3_mutex *	sqlite3_db_mutex (sqlite3 *)

SQLITE_API int	sqlite3_file_control (sqlite3 , const char zDbName, int op, void *)

SQLITE_API int	sqlite3_test_control (int op,...)

SQLITE_API int	sqlite3_keyword_count (void)

SQLITE_API int	sqlite3_keyword_name (int, const char *, int )

SQLITE_API int	sqlite3_keyword_check (const char *, int)

SQLITE_API sqlite3_str *	sqlite3_str_new (sqlite3 *)

SQLITE_API char *	sqlite3_str_finish (sqlite3_str *)

SQLITE_API void	sqlite3_str_appendf (sqlite3_str , const char zFormat,...)

SQLITE_API void	sqlite3_str_vappendf (sqlite3_str , const char zFormat, va_list)

SQLITE_API void	sqlite3_str_append (sqlite3_str , const char zIn, int N)

SQLITE_API void	sqlite3_str_appendall (sqlite3_str , const char zIn)

SQLITE_API void	sqlite3_str_appendchar (sqlite3_str *, int N, char C)

SQLITE_API void	sqlite3_str_reset (sqlite3_str *)

SQLITE_API int	sqlite3_str_errcode (sqlite3_str *)

SQLITE_API int	sqlite3_str_length (sqlite3_str *)

SQLITE_API char *	sqlite3_str_value (sqlite3_str *)

SQLITE_API int	sqlite3_status (int op, int pCurrent, int pHighwater, int resetFlag)

SQLITE_API int	sqlite3_status64 (int op, sqlite3_int64 pCurrent, sqlite3_int64 pHighwater, int resetFlag)

SQLITE_API int	sqlite3_db_status (sqlite3 , int op, int pCur, int *pHiwtr, int resetFlg)

SQLITE_API int	sqlite3_stmt_status (sqlite3_stmt *, int op, int resetFlg)

SQLITE_API sqlite3_backup *	sqlite3_backup_init (sqlite3 pDest, const char zDestName, sqlite3 pSource, const char zSourceName)

SQLITE_API int	sqlite3_backup_step (sqlite3_backup *p, int nPage)

SQLITE_API int	sqlite3_backup_finish (sqlite3_backup *p)

SQLITE_API int	sqlite3_backup_remaining (sqlite3_backup *p)

SQLITE_API int	sqlite3_backup_pagecount (sqlite3_backup *p)

SQLITE_API int	sqlite3_unlock_notify (sqlite3 pBlocked, void(xNotify)(void *apArg, int nArg), void pNotifyArg)

SQLITE_API int	sqlite3_stricmp (const char , const char )

SQLITE_API int	sqlite3_strnicmp (const char , const char , int)

SQLITE_API int	sqlite3_strglob (const char zGlob, const char zStr)

SQLITE_API int	sqlite3_strlike (const char zGlob, const char zStr, unsigned int cEsc)

SQLITE_API void	sqlite3_log (int iErrCode, const char *zFormat,...)

SQLITE_API void *	sqlite3_wal_hook (sqlite3 , int()(void , sqlite3 , const char , int), void )

SQLITE_API int	sqlite3_wal_autocheckpoint (sqlite3 *db, int N)

SQLITE_API int	sqlite3_wal_checkpoint (sqlite3 db, const char zDb)

SQLITE_API int	sqlite3_wal_checkpoint_v2 (sqlite3 db, const char zDb, int eMode, int pnLog, int pnCkpt)

SQLITE_API int	sqlite3_vtab_config (sqlite3 *, int op,...)

SQLITE_API int	sqlite3_vtab_on_conflict (sqlite3 *)

SQLITE_API int	sqlite3_vtab_nochange (sqlite3_context *)

SQLITE_API SQLITE_EXPERIMENTAL const char *	sqlite3_vtab_collation (sqlite3_index_info *, int)

SQLITE_API int	sqlite3_stmt_scanstatus (sqlite3_stmt pStmt, int idx, int iScanStatusOp, void pOut)

SQLITE_API void	sqlite3_stmt_scanstatus_reset (sqlite3_stmt *)

SQLITE_API int	sqlite3_db_cacheflush (sqlite3 *)

SQLITE_API int	sqlite3_system_errno (sqlite3 *)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_get (sqlite3 db, const char zSchema, sqlite3_snapshot **ppSnapshot)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_open (sqlite3 db, const char zSchema, sqlite3_snapshot *pSnapshot)

SQLITE_API SQLITE_EXPERIMENTAL void	sqlite3_snapshot_free (sqlite3_snapshot *)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_cmp (sqlite3_snapshot p1, sqlite3_snapshot p2)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_recover (sqlite3 db, const char zDb)

SQLITE_API unsigned char *	sqlite3_serialize (sqlite3 db, const char zSchema, sqlite3_int64 *piSize, unsigned int mFlags)

SQLITE_API int	sqlite3_deserialize (sqlite3 db, const char zSchema, unsigned char *pData, sqlite3_int64 szDb, sqlite3_int64 szBuf, unsigned mFlags)

SQLITE_API int	sqlite3_rtree_geometry_callback (sqlite3 db, const char zGeom, int(xGeom)(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int ), void *pContext)

SQLITE_API int	sqlite3_rtree_query_callback (sqlite3 db, const char zQueryFunc, int(xQueryFunc)(sqlite3_rtree_query_info ), void pContext, void(xDestructor)(void *))

SQLITE_PRIVATE void	sqlite3HashInit (Hash *)

SQLITE_PRIVATE void *	sqlite3HashInsert (Hash , const char pKey, void *pData)

SQLITE_PRIVATE void *	sqlite3HashFind (const Hash , const char pKey)

SQLITE_PRIVATE void	sqlite3HashClear (Hash *)

SQLITE_PRIVATE int	sqlite3PagerOpen (sqlite3_vfs , Pager ppPager, const char , int, int, int, void()(DbPage ))

SQLITE_PRIVATE int	sqlite3PagerClose (Pager pPager, sqlite3 )

SQLITE_PRIVATE int	sqlite3PagerReadFileheader (Pager , int, unsigned char )

SQLITE_PRIVATE void	sqlite3PagerSetBusyHandler (Pager , int()(void ), void )

SQLITE_PRIVATE int	sqlite3PagerSetPagesize (Pager , u32 , int)

SQLITE_PRIVATE Pgno	sqlite3PagerMaxPageCount (Pager *, Pgno)

SQLITE_PRIVATE void	sqlite3PagerSetCachesize (Pager *, int)

SQLITE_PRIVATE int	sqlite3PagerSetSpillsize (Pager *, int)

SQLITE_PRIVATE void	sqlite3PagerSetMmapLimit (Pager *, sqlite3_int64)

SQLITE_PRIVATE void	sqlite3PagerShrink (Pager *)

SQLITE_PRIVATE void	sqlite3PagerSetFlags (Pager *, unsigned)

SQLITE_PRIVATE int	sqlite3PagerLockingMode (Pager *, int)

SQLITE_PRIVATE int	sqlite3PagerSetJournalMode (Pager *, int)

SQLITE_PRIVATE int	sqlite3PagerGetJournalMode (Pager *)

SQLITE_PRIVATE int	sqlite3PagerOkToChangeJournalMode (Pager *)

SQLITE_PRIVATE i64	sqlite3PagerJournalSizeLimit (Pager *, i64)

SQLITE_PRIVATE sqlite3_backup **	sqlite3PagerBackupPtr (Pager *)

SQLITE_PRIVATE int	sqlite3PagerFlush (Pager *)

SQLITE_PRIVATE int	sqlite3PagerGet (Pager pPager, Pgno pgno, DbPage *ppPage, int clrFlag)

SQLITE_PRIVATE DbPage *	sqlite3PagerLookup (Pager *pPager, Pgno pgno)

SQLITE_PRIVATE void	sqlite3PagerRef (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerUnref (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerUnrefNotNull (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerUnrefPageOne (DbPage *)

SQLITE_PRIVATE int	sqlite3PagerWrite (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerDontWrite (DbPage *)

SQLITE_PRIVATE int	sqlite3PagerMovepage (Pager , DbPage , Pgno, int)

SQLITE_PRIVATE int	sqlite3PagerPageRefcount (DbPage *)

SQLITE_PRIVATE void *	sqlite3PagerGetData (DbPage *)

SQLITE_PRIVATE void *	sqlite3PagerGetExtra (DbPage *)

SQLITE_PRIVATE void	sqlite3PagerPagecount (Pager , int )

SQLITE_PRIVATE int	sqlite3PagerBegin (Pager *, int exFlag, int)

SQLITE_PRIVATE int	sqlite3PagerCommitPhaseOne (Pager , const char zSuper, int)

SQLITE_PRIVATE int	sqlite3PagerExclusiveLock (Pager *)

SQLITE_PRIVATE int	sqlite3PagerSync (Pager pPager, const char zSuper)

SQLITE_PRIVATE int	sqlite3PagerCommitPhaseTwo (Pager *)

SQLITE_PRIVATE int	sqlite3PagerRollback (Pager *)

SQLITE_PRIVATE int	sqlite3PagerOpenSavepoint (Pager *pPager, int n)

SQLITE_PRIVATE int	sqlite3PagerSavepoint (Pager *pPager, int op, int iSavepoint)

SQLITE_PRIVATE int	sqlite3PagerSharedLock (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerCheckpoint (Pager pPager, sqlite3 , int, int , int )

SQLITE_PRIVATE int	sqlite3PagerWalSupported (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerWalCallback (Pager *pPager)

SQLITE_PRIVATE int	sqlite3PagerOpenWal (Pager pPager, int pisOpen)

SQLITE_PRIVATE int	sqlite3PagerCloseWal (Pager pPager, sqlite3 )

SQLITE_PRIVATE u8	sqlite3PagerIsreadonly (Pager *)

SQLITE_PRIVATE u32	sqlite3PagerDataVersion (Pager *)

SQLITE_PRIVATE int	sqlite3PagerMemUsed (Pager *)

SQLITE_PRIVATE const char *	sqlite3PagerFilename (const Pager *, int)

SQLITE_PRIVATE sqlite3_vfs *	sqlite3PagerVfs (Pager *)

SQLITE_PRIVATE sqlite3_file *	sqlite3PagerFile (Pager *)

SQLITE_PRIVATE sqlite3_file *	sqlite3PagerJrnlFile (Pager *)

SQLITE_PRIVATE const char *	sqlite3PagerJournalname (Pager *)

SQLITE_PRIVATE void *	sqlite3PagerTempSpace (Pager *)

SQLITE_PRIVATE int	sqlite3PagerIsMemdb (Pager *)

SQLITE_PRIVATE void	sqlite3PagerCacheStat (Pager , int, int, int )

SQLITE_PRIVATE void	sqlite3PagerClearCache (Pager *)

SQLITE_PRIVATE int	sqlite3SectorSize (sqlite3_file *)

SQLITE_PRIVATE void	sqlite3PagerTruncateImage (Pager *, Pgno)

SQLITE_PRIVATE void	sqlite3PagerRekey (DbPage *, Pgno, u16)

SQLITE_PRIVATE int	sqlite3BtreeOpen (sqlite3_vfs pVfs, const char zFilename, sqlite3 db, Btree *ppBtree, int flags, int vfsFlags)

SQLITE_PRIVATE int	sqlite3BtreeClose (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeSetCacheSize (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeSetSpillSize (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeSetPagerFlags (Btree *, unsigned)

SQLITE_PRIVATE int	sqlite3BtreeSetPageSize (Btree *p, int nPagesize, int nReserve, int eFix)

SQLITE_PRIVATE int	sqlite3BtreeGetPageSize (Btree *)

SQLITE_PRIVATE Pgno	sqlite3BtreeMaxPageCount (Btree *, Pgno)

SQLITE_PRIVATE Pgno	sqlite3BtreeLastPage (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeSecureDelete (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeGetRequestedReserve (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeGetReserveNoMutex (Btree *p)

SQLITE_PRIVATE int	sqlite3BtreeSetAutoVacuum (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeGetAutoVacuum (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeBeginTrans (Btree , int, int )

SQLITE_PRIVATE int	sqlite3BtreeCommitPhaseOne (Btree , const char )

SQLITE_PRIVATE int	sqlite3BtreeCommitPhaseTwo (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeCommit (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeRollback (Btree *, int, int)

SQLITE_PRIVATE int	sqlite3BtreeBeginStmt (Btree *, int)

SQLITE_PRIVATE int	sqlite3BtreeCreateTable (Btree , Pgno , int flags)

SQLITE_PRIVATE int	sqlite3BtreeIsInTrans (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeIsInReadTrans (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeIsInBackup (Btree *)

SQLITE_PRIVATE void *	sqlite3BtreeSchema (Btree , int, void()(void *))

SQLITE_PRIVATE int	sqlite3BtreeSchemaLocked (Btree *pBtree)

SQLITE_PRIVATE int	sqlite3BtreeLockTable (Btree *pBtree, int iTab, u8 isWriteLock)

SQLITE_PRIVATE int	sqlite3BtreeSavepoint (Btree *, int, int)

SQLITE_PRIVATE const char *	sqlite3BtreeGetFilename (Btree *)

SQLITE_PRIVATE const char *	sqlite3BtreeGetJournalname (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeCopyFile (Btree , Btree )

SQLITE_PRIVATE int	sqlite3BtreeIncrVacuum (Btree *)

SQLITE_PRIVATE int	sqlite3BtreeDropTable (Btree , int, int )

SQLITE_PRIVATE int	sqlite3BtreeClearTable (Btree , int, int )

SQLITE_PRIVATE int	sqlite3BtreeClearTableOfCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeTripAllCursors (Btree *, int, int)

SQLITE_PRIVATE void	sqlite3BtreeGetMeta (Btree pBtree, int idx, u32 pValue)

SQLITE_PRIVATE int	sqlite3BtreeUpdateMeta (Btree *, int idx, u32 value)

SQLITE_PRIVATE int	sqlite3BtreeNewDb (Btree *p)

SQLITE_PRIVATE int	sqlite3BtreeCursor (Btree , Pgno iTable, int wrFlag, struct KeyInfo , BtCursor *pCursor)

SQLITE_PRIVATE BtCursor *	sqlite3BtreeFakeValidCursor (void)

SQLITE_PRIVATE int	sqlite3BtreeCursorSize (void)

SQLITE_PRIVATE void	sqlite3BtreeCursorZero (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeCursorHintFlags (BtCursor *, unsigned)

SQLITE_PRIVATE int	sqlite3BtreeCloseCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeMovetoUnpacked (BtCursor , UnpackedRecord pUnKey, i64 intKey, int bias, int *pRes)

SQLITE_PRIVATE int	sqlite3BtreeCursorHasMoved (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeCursorRestore (BtCursor , int )

SQLITE_PRIVATE int	sqlite3BtreeDelete (BtCursor *, u8 flags)

SQLITE_PRIVATE int	sqlite3BtreeInsert (BtCursor , const BtreePayload pPayload, int flags, int seekResult)

SQLITE_PRIVATE int	sqlite3BtreeFirst (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeLast (BtCursor , int pRes)

SQLITE_PRIVATE int	sqlite3BtreeNext (BtCursor *, int flags)

SQLITE_PRIVATE int	sqlite3BtreeEof (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreePrevious (BtCursor *, int flags)

SQLITE_PRIVATE i64	sqlite3BtreeIntegerKey (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeCursorPin (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeCursorUnpin (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreePayload (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE const void *	sqlite3BtreePayloadFetch (BtCursor , u32 pAmt)

SQLITE_PRIVATE u32	sqlite3BtreePayloadSize (BtCursor *)

SQLITE_PRIVATE sqlite3_int64	sqlite3BtreeMaxRecordSize (BtCursor *)

SQLITE_PRIVATE char *	sqlite3BtreeIntegrityCheck (sqlite3 , Btree , Pgno aRoot, int nRoot, int, int )

SQLITE_PRIVATE struct Pager *	sqlite3BtreePager (Btree *)

SQLITE_PRIVATE i64	sqlite3BtreeRowCountEst (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreePayloadChecked (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE int	sqlite3BtreePutData (BtCursor , u32 offset, u32 amt, void )

SQLITE_PRIVATE void	sqlite3BtreeIncrblobCursor (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeClearCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeSetVersion (Btree *pBt, int iVersion)

SQLITE_PRIVATE int	sqlite3BtreeCursorHasHint (BtCursor *, unsigned int mask)

SQLITE_PRIVATE int	sqlite3BtreeIsReadonly (Btree *pBt)

SQLITE_PRIVATE int	sqlite3HeaderSizeBtree (void)

SQLITE_PRIVATE int	sqlite3BtreeCursorIsValidNN (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeCount (sqlite3 , BtCursor , i64 *)

SQLITE_PRIVATE int	sqlite3BtreeCheckpoint (Btree , int, int , int *)

SQLITE_PRIVATE void	sqlite3BtreeEnter (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeEnterAll (sqlite3 *)

SQLITE_PRIVATE int	sqlite3BtreeSharable (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeEnterCursor (BtCursor *)

SQLITE_PRIVATE int	sqlite3BtreeConnectionCount (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeLeave (Btree *)

SQLITE_PRIVATE void	sqlite3BtreeLeaveCursor (BtCursor *)

SQLITE_PRIVATE void	sqlite3BtreeLeaveAll (sqlite3 *)

SQLITE_PRIVATE Vdbe *	sqlite3VdbeCreate (Parse *)

SQLITE_PRIVATE Parse *	sqlite3VdbeParser (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeAddOp0 (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp1 (Vdbe *, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp2 (Vdbe *, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeGoto (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeLoadString (Vdbe , int, const char )

SQLITE_PRIVATE void	sqlite3VdbeMultiLoad (Vdbe , int, const char ,...)

SQLITE_PRIVATE int	sqlite3VdbeAddOp3 (Vdbe *, int, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp4 (Vdbe , int, int, int, int, const char zP4, int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp4Dup8 (Vdbe , int, int, int, int, const u8 , int)

SQLITE_PRIVATE int	sqlite3VdbeAddOp4Int (Vdbe *, int, int, int, int, int)

SQLITE_PRIVATE int	sqlite3VdbeAddFunctionCall (Parse , int, int, int, int, const FuncDef , int)

SQLITE_PRIVATE void	sqlite3VdbeEndCoroutine (Vdbe *, int)

SQLITE_PRIVATE VdbeOp *	sqlite3VdbeAddOpList (Vdbe , int nOp, VdbeOpList const aOp, int iLineno)

SQLITE_PRIVATE void	sqlite3VdbeExplain (Parse , u8, const char ,...)

SQLITE_PRIVATE void	sqlite3VdbeExplainPop (Parse *)

SQLITE_PRIVATE int	sqlite3VdbeExplainParent (Parse *)

SQLITE_PRIVATE void	sqlite3VdbeAddParseSchemaOp (Vdbe , int, char )

SQLITE_PRIVATE void	sqlite3VdbeChangeOpcode (Vdbe *, int addr, u8)

SQLITE_PRIVATE void	sqlite3VdbeChangeP1 (Vdbe *, int addr, int P1)

SQLITE_PRIVATE void	sqlite3VdbeChangeP2 (Vdbe *, int addr, int P2)

SQLITE_PRIVATE void	sqlite3VdbeChangeP3 (Vdbe *, int addr, int P3)

SQLITE_PRIVATE void	sqlite3VdbeChangeP5 (Vdbe *, u16 P5)

SQLITE_PRIVATE void	sqlite3VdbeJumpHere (Vdbe *, int addr)

SQLITE_PRIVATE void	sqlite3VdbeJumpHereOrPopInst (Vdbe *, int addr)

SQLITE_PRIVATE int	sqlite3VdbeChangeToNoop (Vdbe *, int addr)

SQLITE_PRIVATE int	sqlite3VdbeDeletePriorOpcode (Vdbe *, u8 op)

SQLITE_PRIVATE void	sqlite3VdbeChangeP4 (Vdbe , int addr, const char zP4, int N)

SQLITE_PRIVATE void	sqlite3VdbeAppendP4 (Vdbe , void pP4, int p4type)

SQLITE_PRIVATE void	sqlite3VdbeSetP4KeyInfo (Parse , Index )

SQLITE_PRIVATE void	sqlite3VdbeUsesBtree (Vdbe *, int)

SQLITE_PRIVATE VdbeOp *	sqlite3VdbeGetOp (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeMakeLabel (Parse *)

SQLITE_PRIVATE void	sqlite3VdbeRunOnlyOnce (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeReusable (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeDelete (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeClearObject (sqlite3 , Vdbe )

SQLITE_PRIVATE void	sqlite3VdbeMakeReady (Vdbe , Parse )

SQLITE_PRIVATE int	sqlite3VdbeFinalize (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeResolveLabel (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeCurrentAddr (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeResetStepResult (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeRewind (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeReset (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeSetNumCols (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeSetColName (Vdbe , int, int, const char , void()(void ))

SQLITE_PRIVATE void	sqlite3VdbeCountChanges (Vdbe *)

SQLITE_PRIVATE sqlite3 *	sqlite3VdbeDb (Vdbe *)

SQLITE_PRIVATE u8	sqlite3VdbePrepareFlags (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeSetSql (Vdbe , const char z, int n, u8)

SQLITE_PRIVATE void	sqlite3VdbeSwap (Vdbe , Vdbe )

SQLITE_PRIVATE VdbeOp *	sqlite3VdbeTakeOpArray (Vdbe , int , int *)

SQLITE_PRIVATE sqlite3_value *	sqlite3VdbeGetBoundValue (Vdbe *, int, u8)

SQLITE_PRIVATE void	sqlite3VdbeSetVarmask (Vdbe *, int)

SQLITE_PRIVATE char *	sqlite3VdbeExpandSql (Vdbe , const char )

SQLITE_PRIVATE int	sqlite3MemCompare (const Mem , const Mem , const CollSeq *)

SQLITE_PRIVATE int	sqlite3BlobCompare (const Mem , const Mem )

SQLITE_PRIVATE void	sqlite3VdbeRecordUnpack (KeyInfo , int, const void , UnpackedRecord *)

SQLITE_PRIVATE int	sqlite3VdbeRecordCompare (int, const void , UnpackedRecord )

SQLITE_PRIVATE int	sqlite3VdbeRecordCompareWithSkip (int, const void , UnpackedRecord , int)

SQLITE_PRIVATE UnpackedRecord *	sqlite3VdbeAllocUnpackedRecord (KeyInfo *)

SQLITE_PRIVATE RecordCompare	sqlite3VdbeFindCompare (UnpackedRecord *)

SQLITE_PRIVATE void	sqlite3VdbeLinkSubProgram (Vdbe , SubProgram )

SQLITE_PRIVATE int	sqlite3VdbeHasSubProgram (Vdbe *)

SQLITE_PRIVATE int	sqlite3NotPureFunc (sqlite3_context *)

SQLITE_PRIVATE int	sqlite3PcacheInitialize (void)

SQLITE_PRIVATE void	sqlite3PcacheShutdown (void)

SQLITE_PRIVATE void	sqlite3PCacheBufferSetup (void *, int sz, int n)

SQLITE_PRIVATE int	sqlite3PcacheOpen (int szPage, int szExtra, int bPurgeable, int(xStress)(void , PgHdr ), void pStress, PCache *pToInit)

SQLITE_PRIVATE int	sqlite3PcacheSetPageSize (PCache *, int)

SQLITE_PRIVATE int	sqlite3PcacheSize (void)

SQLITE_PRIVATE sqlite3_pcache_page *	sqlite3PcacheFetch (PCache *, Pgno, int createFlag)

SQLITE_PRIVATE int	sqlite3PcacheFetchStress (PCache , Pgno, sqlite3_pcache_page *)

SQLITE_PRIVATE PgHdr *	sqlite3PcacheFetchFinish (PCache , Pgno, sqlite3_pcache_page pPage)

SQLITE_PRIVATE void	sqlite3PcacheRelease (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheDrop (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheMakeDirty (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheMakeClean (PgHdr *)

SQLITE_PRIVATE void	sqlite3PcacheCleanAll (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClearWritable (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheMove (PgHdr *, Pgno)

SQLITE_PRIVATE void	sqlite3PcacheTruncate (PCache *, Pgno x)

SQLITE_PRIVATE PgHdr *	sqlite3PcacheDirtyList (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClose (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClearSyncFlags (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheClear (PCache *)

SQLITE_PRIVATE int	sqlite3PcacheRefCount (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheRef (PgHdr *)

SQLITE_PRIVATE int	sqlite3PcachePageRefcount (PgHdr *)

SQLITE_PRIVATE int	sqlite3PcachePagecount (PCache *)

SQLITE_PRIVATE void	sqlite3PcacheSetCachesize (PCache *, int)

SQLITE_PRIVATE int	sqlite3PcacheSetSpillsize (PCache *, int)

SQLITE_PRIVATE void	sqlite3PcacheShrink (PCache *)

SQLITE_PRIVATE void	sqlite3PCacheSetDefault (void)

SQLITE_PRIVATE int	sqlite3HeaderSizePcache (void)

SQLITE_PRIVATE int	sqlite3HeaderSizePcache1 (void)

SQLITE_PRIVATE int	sqlite3PCachePercentDirty (PCache *)

SQLITE_PRIVATE int	sqlite3OsInit (void)

SQLITE_PRIVATE void	sqlite3OsClose (sqlite3_file *)

SQLITE_PRIVATE int	sqlite3OsRead (sqlite3_file , void , int amt, i64 offset)

SQLITE_PRIVATE int	sqlite3OsWrite (sqlite3_file , const void , int amt, i64 offset)

SQLITE_PRIVATE int	sqlite3OsTruncate (sqlite3_file *, i64 size)

SQLITE_PRIVATE int	sqlite3OsSync (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsFileSize (sqlite3_file , i64 pSize)

SQLITE_PRIVATE int	sqlite3OsLock (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsUnlock (sqlite3_file *, int)

SQLITE_PRIVATE int	sqlite3OsCheckReservedLock (sqlite3_file id, int pResOut)

SQLITE_PRIVATE int	sqlite3OsFileControl (sqlite3_file , int, void )

SQLITE_PRIVATE void	sqlite3OsFileControlHint (sqlite3_file , int, void )

SQLITE_PRIVATE int	sqlite3OsSectorSize (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsDeviceCharacteristics (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsShmMap (sqlite3_file , int, int, int, void volatile *)

SQLITE_PRIVATE int	sqlite3OsShmLock (sqlite3_file *id, int, int, int)

SQLITE_PRIVATE void	sqlite3OsShmBarrier (sqlite3_file *id)

SQLITE_PRIVATE int	sqlite3OsShmUnmap (sqlite3_file *id, int)

SQLITE_PRIVATE int	sqlite3OsFetch (sqlite3_file id, i64, int, void *)

SQLITE_PRIVATE int	sqlite3OsUnfetch (sqlite3_file , i64, void )

SQLITE_PRIVATE int	sqlite3OsOpen (sqlite3_vfs , const char , sqlite3_file , int, int )

SQLITE_PRIVATE int	sqlite3OsDelete (sqlite3_vfs , const char , int)

SQLITE_PRIVATE int	sqlite3OsAccess (sqlite3_vfs , const char , int, int *pResOut)

SQLITE_PRIVATE int	sqlite3OsFullPathname (sqlite3_vfs , const char , int, char *)

SQLITE_PRIVATE void *	sqlite3OsDlOpen (sqlite3_vfs , const char )

SQLITE_PRIVATE void	sqlite3OsDlError (sqlite3_vfs , int, char )

SQLITE_PRIVATE void	sqlite3OsDlClose (sqlite3_vfs , void )

SQLITE_PRIVATE int	sqlite3OsRandomness (sqlite3_vfs , int, char )

SQLITE_PRIVATE int	sqlite3OsSleep (sqlite3_vfs *, int)

SQLITE_PRIVATE int	sqlite3OsGetLastError (sqlite3_vfs *)

SQLITE_PRIVATE int	sqlite3OsCurrentTimeInt64 (sqlite3_vfs , sqlite3_int64 )

SQLITE_PRIVATE int	sqlite3OsOpenMalloc (sqlite3_vfs , const char , sqlite3_file *, int, int )

SQLITE_PRIVATE void	sqlite3OsCloseFree (sqlite3_file *)

SQLITE_PRIVATE int	sqlite3WalkExpr (Walker , Expr )

SQLITE_PRIVATE int	sqlite3WalkExprList (Walker , ExprList )

SQLITE_PRIVATE int	sqlite3WalkSelect (Walker , Select )

SQLITE_PRIVATE int	sqlite3WalkSelectExpr (Walker , Select )

SQLITE_PRIVATE int	sqlite3WalkSelectFrom (Walker , Select )

SQLITE_PRIVATE int	sqlite3ExprWalkNoop (Walker , Expr )

SQLITE_PRIVATE int	sqlite3SelectWalkNoop (Walker , Select )

SQLITE_PRIVATE int	sqlite3SelectWalkFail (Walker , Select )

SQLITE_PRIVATE int	sqlite3WalkerDepthIncrease (Walker , Select )

SQLITE_PRIVATE void	sqlite3WalkerDepthDecrease (Walker , Select )

SQLITE_PRIVATE void	sqlite3WindowDelete (sqlite3 , Window )

SQLITE_PRIVATE void	sqlite3WindowUnlinkFromSelect (Window *)

SQLITE_PRIVATE void	sqlite3WindowListDelete (sqlite3 db, Window p)

SQLITE_PRIVATE Window *	sqlite3WindowAlloc (Parse , int, int, Expr , int, Expr *, u8)

SQLITE_PRIVATE void	sqlite3WindowAttach (Parse , Expr , Window *)

SQLITE_PRIVATE void	sqlite3WindowLink (Select pSel, Window pWin)

SQLITE_PRIVATE int	sqlite3WindowCompare (Parse , Window , Window *, int)

SQLITE_PRIVATE void	sqlite3WindowCodeInit (Parse , Select )

SQLITE_PRIVATE void	sqlite3WindowCodeStep (Parse , Select , WhereInfo *, int, int)

SQLITE_PRIVATE int	sqlite3WindowRewrite (Parse , Select )

SQLITE_PRIVATE int	sqlite3ExpandSubquery (Parse , struct SrcList_item )

SQLITE_PRIVATE void	sqlite3WindowUpdate (Parse , Window , Window , FuncDef )

SQLITE_PRIVATE Window *	sqlite3WindowDup (sqlite3 db, Expr pOwner, Window *p)

SQLITE_PRIVATE Window *	sqlite3WindowListDup (sqlite3 db, Window p)

SQLITE_PRIVATE void	sqlite3WindowFunctions (void)

SQLITE_PRIVATE void	sqlite3WindowChain (Parse , Window , Window *)

SQLITE_PRIVATE Window *	sqlite3WindowAssemble (Parse , Window , ExprList , ExprList , Token *)

SQLITE_PRIVATE int	sqlite3ReportError (int iErr, int lineno, const char *zType)

SQLITE_PRIVATE int	sqlite3CorruptError (int)

SQLITE_PRIVATE int	sqlite3MisuseError (int)

SQLITE_PRIVATE int	sqlite3CantopenError (int)

SQLITE_PRIVATE int	sqlite3IsIdChar (u8)

SQLITE_PRIVATE int	sqlite3StrICmp (const char , const char )

SQLITE_PRIVATE int	sqlite3Strlen30 (const char *)

SQLITE_PRIVATE char *	sqlite3ColumnType (Column , char )

SQLITE_PRIVATE int	sqlite3MallocInit (void)

SQLITE_PRIVATE void	sqlite3MallocEnd (void)

SQLITE_PRIVATE void *	sqlite3Malloc (u64)

SQLITE_PRIVATE void *	sqlite3MallocZero (u64)

SQLITE_PRIVATE void *	sqlite3DbMallocZero (sqlite3 *, u64)

SQLITE_PRIVATE void *	sqlite3DbMallocRaw (sqlite3 *, u64)

SQLITE_PRIVATE void *	sqlite3DbMallocRawNN (sqlite3 *, u64)

SQLITE_PRIVATE char *	sqlite3DbStrDup (sqlite3 , const char )

SQLITE_PRIVATE char *	sqlite3DbStrNDup (sqlite3 , const char , u64)

SQLITE_PRIVATE char *	sqlite3DbSpanDup (sqlite3 , const char , const char *)

SQLITE_PRIVATE void *	sqlite3Realloc (void *, u64)

SQLITE_PRIVATE void *	sqlite3DbReallocOrFree (sqlite3 , void , u64)

SQLITE_PRIVATE void *	sqlite3DbRealloc (sqlite3 , void , u64)

SQLITE_PRIVATE void	sqlite3DbFree (sqlite3 , void )

SQLITE_PRIVATE void	sqlite3DbFreeNN (sqlite3 , void )

SQLITE_PRIVATE int	sqlite3MallocSize (void *)

SQLITE_PRIVATE int	sqlite3DbMallocSize (sqlite3 , void )

SQLITE_PRIVATE void *	sqlite3PageMalloc (int)

SQLITE_PRIVATE void	sqlite3PageFree (void *)

SQLITE_PRIVATE void	sqlite3MemSetDefault (void)

SQLITE_PRIVATE void	sqlite3BenignMallocHooks (void()(void), void()(void))

SQLITE_PRIVATE int	sqlite3HeapNearlyFull (void)

SQLITE_PRIVATE sqlite3_mutex_methods const *	sqlite3DefaultMutex (void)

SQLITE_PRIVATE sqlite3_mutex_methods const *	sqlite3NoopMutex (void)

SQLITE_PRIVATE sqlite3_mutex *	sqlite3MutexAlloc (int)

SQLITE_PRIVATE int	sqlite3MutexInit (void)

SQLITE_PRIVATE int	sqlite3MutexEnd (void)

SQLITE_PRIVATE void	sqlite3MemoryBarrier (void)

SQLITE_PRIVATE sqlite3_int64	sqlite3StatusValue (int)

SQLITE_PRIVATE void	sqlite3StatusUp (int, int)

SQLITE_PRIVATE void	sqlite3StatusDown (int, int)

SQLITE_PRIVATE void	sqlite3StatusHighwater (int, int)

SQLITE_PRIVATE int	sqlite3LookasideUsed (sqlite3 , int )

SQLITE_PRIVATE sqlite3_mutex *	sqlite3Pcache1Mutex (void)

SQLITE_PRIVATE sqlite3_mutex *	sqlite3MallocMutex (void)

SQLITE_PRIVATE int	sqlite3IsNaN (double)

SQLITE_PRIVATE char *	sqlite3MPrintf (sqlite3 , const char ,...)

SQLITE_PRIVATE char *	sqlite3VMPrintf (sqlite3 , const char , va_list)

SQLITE_PRIVATE void	sqlite3SetString (char *, sqlite3 , const char *)

SQLITE_PRIVATE void	sqlite3ErrorMsg (Parse , const char ,...)

SQLITE_PRIVATE int	sqlite3ErrorToParser (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3Dequote (char *)

SQLITE_PRIVATE void	sqlite3DequoteExpr (Expr *)

SQLITE_PRIVATE void	sqlite3TokenInit (Token , char )

SQLITE_PRIVATE int	sqlite3KeywordCode (const unsigned char *, int)

SQLITE_PRIVATE int	sqlite3RunParser (Parse , const char , char **)

SQLITE_PRIVATE void	sqlite3FinishCoding (Parse *)

SQLITE_PRIVATE int	sqlite3GetTempReg (Parse *)

SQLITE_PRIVATE void	sqlite3ReleaseTempReg (Parse *, int)

SQLITE_PRIVATE int	sqlite3GetTempRange (Parse *, int)

SQLITE_PRIVATE void	sqlite3ReleaseTempRange (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3ClearTempRegCache (Parse *)

SQLITE_PRIVATE Expr *	sqlite3ExprAlloc (sqlite3 , int, const Token , int)

SQLITE_PRIVATE Expr *	sqlite3Expr (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3ExprAttachSubtrees (sqlite3 , Expr , Expr , Expr )

SQLITE_PRIVATE Expr *	sqlite3PExpr (Parse , int, Expr , Expr *)

SQLITE_PRIVATE void	sqlite3PExprAddSelect (Parse , Expr , Select *)

SQLITE_PRIVATE Expr *	sqlite3ExprAnd (Parse , Expr , Expr *)

SQLITE_PRIVATE Expr *	sqlite3ExprSimplifiedAndOr (Expr *)

SQLITE_PRIVATE Expr *	sqlite3ExprFunction (Parse , ExprList , Token *, int)

SQLITE_PRIVATE void	sqlite3ExprFunctionUsable (Parse , Expr , FuncDef *)

SQLITE_PRIVATE void	sqlite3ExprAssignVarNumber (Parse , Expr , u32)

SQLITE_PRIVATE void	sqlite3ExprDelete (sqlite3 , Expr )

SQLITE_PRIVATE void	sqlite3ExprUnmapAndDelete (Parse , Expr )

SQLITE_PRIVATE ExprList *	sqlite3ExprListAppend (Parse , ExprList , Expr *)

SQLITE_PRIVATE ExprList *	sqlite3ExprListAppendVector (Parse , ExprList , IdList , Expr )

SQLITE_PRIVATE void	sqlite3ExprListSetSortOrder (ExprList *, int, int)

SQLITE_PRIVATE void	sqlite3ExprListSetName (Parse , ExprList , Token *, int)

SQLITE_PRIVATE void	sqlite3ExprListSetSpan (Parse , ExprList , const char , const char )

SQLITE_PRIVATE void	sqlite3ExprListDelete (sqlite3 , ExprList )

SQLITE_PRIVATE u32	sqlite3ExprListFlags (const ExprList *)

SQLITE_PRIVATE int	sqlite3IndexHasDuplicateRootPage (Index *)

SQLITE_PRIVATE int	sqlite3Init (sqlite3 , char *)

SQLITE_PRIVATE int	sqlite3InitCallback (void , int, char , char *)

SQLITE_PRIVATE int	sqlite3InitOne (sqlite3 , int, char *, u32)

SQLITE_PRIVATE void	sqlite3Pragma (Parse , Token , Token , Token , int)

SQLITE_PRIVATE Module *	sqlite3PragmaVtabRegister (sqlite3 , const char zName)

SQLITE_PRIVATE void	sqlite3ResetAllSchemasOfConnection (sqlite3 *)

SQLITE_PRIVATE void	sqlite3ResetOneSchema (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3CollapseDatabaseArray (sqlite3 *)

SQLITE_PRIVATE void	sqlite3CommitInternalChanges (sqlite3 *)

SQLITE_PRIVATE void	sqlite3DeleteColumnNames (sqlite3 , Table )

SQLITE_PRIVATE int	sqlite3ColumnsFromExprList (Parse , ExprList , i16 , Column *)

SQLITE_PRIVATE void	sqlite3SelectAddColumnTypeAndCollation (Parse , Table , Select *, char)

SQLITE_PRIVATE Table *	sqlite3ResultSetOfSelect (Parse , Select , char)

SQLITE_PRIVATE void	sqlite3OpenSchemaTable (Parse *, int)

SQLITE_PRIVATE Index *	sqlite3PrimaryKeyIndex (Table *)

SQLITE_PRIVATE i16	sqlite3TableColumnToIndex (Index *, i16)

SQLITE_PRIVATE i16	sqlite3TableColumnToStorage (Table *, i16)

SQLITE_PRIVATE i16	sqlite3StorageColumnToTable (Table *, i16)

SQLITE_PRIVATE void	sqlite3StartTable (Parse , Token , Token *, int, int, int, int)

SQLITE_PRIVATE void	sqlite3AddColumn (Parse , Token , Token *)

SQLITE_PRIVATE void	sqlite3AddNotNull (Parse *, int)

SQLITE_PRIVATE void	sqlite3AddPrimaryKey (Parse , ExprList , int, int, int)

SQLITE_PRIVATE void	sqlite3AddCheckConstraint (Parse , Expr )

SQLITE_PRIVATE void	sqlite3AddDefaultValue (Parse , Expr , const char , const char )

SQLITE_PRIVATE void	sqlite3AddCollateType (Parse , Token )

SQLITE_PRIVATE void	sqlite3AddGenerated (Parse , Expr , Token *)

SQLITE_PRIVATE void	sqlite3EndTable (Parse , Token , Token , u8, Select )

SQLITE_PRIVATE int	sqlite3ParseUri (const char , const char , unsigned int , sqlite3_vfs , char , char *)

SQLITE_PRIVATE Btree *	sqlite3DbNameToBtree (sqlite3 , const char )

SQLITE_PRIVATE int	sqlite3FaultSim (int)

SQLITE_PRIVATE Bitvec *	sqlite3BitvecCreate (u32)

SQLITE_PRIVATE int	sqlite3BitvecTest (Bitvec *, u32)

SQLITE_PRIVATE int	sqlite3BitvecTestNotNull (Bitvec *, u32)

SQLITE_PRIVATE int	sqlite3BitvecSet (Bitvec *, u32)

SQLITE_PRIVATE void	sqlite3BitvecClear (Bitvec , u32, void )

SQLITE_PRIVATE void	sqlite3BitvecDestroy (Bitvec *)

SQLITE_PRIVATE u32	sqlite3BitvecSize (Bitvec *)

SQLITE_PRIVATE int	sqlite3BitvecBuiltinTest (int, int *)

SQLITE_PRIVATE RowSet *	sqlite3RowSetInit (sqlite3 *)

SQLITE_PRIVATE void	sqlite3RowSetDelete (void *)

SQLITE_PRIVATE void	sqlite3RowSetClear (void *)

SQLITE_PRIVATE void	sqlite3RowSetInsert (RowSet *, i64)

SQLITE_PRIVATE int	sqlite3RowSetTest (RowSet *, int iBatch, i64)

SQLITE_PRIVATE int	sqlite3RowSetNext (RowSet , i64 )

SQLITE_PRIVATE void	sqlite3CreateView (Parse , Token , Token , Token , ExprList , Select , int, int)

SQLITE_PRIVATE int	sqlite3ViewGetColumnNames (Parse , Table )

SQLITE_PRIVATE void	sqlite3DropTable (Parse , SrcList , int, int)

SQLITE_PRIVATE void	sqlite3CodeDropTable (Parse , Table , int, int)

SQLITE_PRIVATE void	sqlite3DeleteTable (sqlite3 , Table )

SQLITE_PRIVATE void	sqlite3FreeIndex (sqlite3 , Index )

SQLITE_PRIVATE void	sqlite3AutoincrementBegin (Parse *pParse)

SQLITE_PRIVATE void	sqlite3AutoincrementEnd (Parse *pParse)

SQLITE_PRIVATE void	sqlite3Insert (Parse , SrcList , Select , IdList , int, Upsert *)

SQLITE_PRIVATE void	sqlite3ComputeGeneratedColumns (Parse , int, Table )

SQLITE_PRIVATE void *	sqlite3ArrayAllocate (sqlite3 , void , int, int , int )

SQLITE_PRIVATE IdList *	sqlite3IdListAppend (Parse , IdList , Token *)

SQLITE_PRIVATE int	sqlite3IdListIndex (IdList , const char )

SQLITE_PRIVATE SrcList *	sqlite3SrcListEnlarge (Parse , SrcList , int, int)

SQLITE_PRIVATE SrcList *	sqlite3SrcListAppendList (Parse pParse, SrcList p1, SrcList *p2)

SQLITE_PRIVATE SrcList *	sqlite3SrcListAppend (Parse , SrcList , Token , Token )

SQLITE_PRIVATE SrcList *	sqlite3SrcListAppendFromTerm (Parse , SrcList , Token , Token , Token , Select , Expr , IdList )

SQLITE_PRIVATE void	sqlite3SrcListIndexedBy (Parse , SrcList , Token *)

SQLITE_PRIVATE void	sqlite3SrcListFuncArgs (Parse , SrcList , ExprList *)

SQLITE_PRIVATE int	sqlite3IndexedByLookup (Parse , struct SrcList_item )

SQLITE_PRIVATE void	sqlite3SrcListShiftJoinType (SrcList *)

SQLITE_PRIVATE void	sqlite3SrcListAssignCursors (Parse , SrcList )

SQLITE_PRIVATE void	sqlite3IdListDelete (sqlite3 , IdList )

SQLITE_PRIVATE void	sqlite3SrcListDelete (sqlite3 , SrcList )

SQLITE_PRIVATE Index *	sqlite3AllocateIndexObject (sqlite3 , i16, int, char *)

SQLITE_PRIVATE void	sqlite3CreateIndex (Parse , Token , Token , SrcList , ExprList , int, Token , Expr *, int, int, u8)

SQLITE_PRIVATE void	sqlite3DropIndex (Parse , SrcList , int)

SQLITE_PRIVATE int	sqlite3Select (Parse , Select , SelectDest *)

SQLITE_PRIVATE Select *	sqlite3SelectNew (Parse , ExprList , SrcList , Expr , ExprList , Expr , ExprList , u32, Expr )

SQLITE_PRIVATE void	sqlite3SelectDelete (sqlite3 , Select )

SQLITE_PRIVATE Table *	sqlite3SrcListLookup (Parse , SrcList )

SQLITE_PRIVATE int	sqlite3IsReadOnly (Parse , Table , int)

SQLITE_PRIVATE void	sqlite3OpenTable (Parse , int iCur, int iDb, Table , int)

SQLITE_PRIVATE void	sqlite3DeleteFrom (Parse , SrcList , Expr , ExprList , Expr *)

SQLITE_PRIVATE void	sqlite3Update (Parse , SrcList , ExprList , Expr , int, ExprList , Expr , Upsert *)

SQLITE_PRIVATE WhereInfo *	sqlite3WhereBegin (Parse , SrcList , Expr , ExprList , ExprList *, u16, int)

SQLITE_PRIVATE void	sqlite3WhereEnd (WhereInfo *)

SQLITE_PRIVATE LogEst	sqlite3WhereOutputRowCount (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsDistinct (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsOrdered (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereOrderByLimitOptLabel (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereIsSorted (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereContinueLabel (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereBreakLabel (WhereInfo *)

SQLITE_PRIVATE int	sqlite3WhereOkOnePass (WhereInfo , int )

SQLITE_PRIVATE int	sqlite3WhereUsesDeferredSeek (WhereInfo *)

SQLITE_PRIVATE void	sqlite3ExprCodeLoadIndexColumn (Parse , Index , int, int, int)

SQLITE_PRIVATE int	sqlite3ExprCodeGetColumn (Parse , Table , int, int, int, u8)

SQLITE_PRIVATE void	sqlite3ExprCodeGetColumnOfTable (Vdbe , Table , int, int, int)

SQLITE_PRIVATE void	sqlite3ExprCodeMove (Parse *, int, int, int)

SQLITE_PRIVATE void	sqlite3ExprCode (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprCodeGeneratedColumn (Parse , Column , int)

SQLITE_PRIVATE void	sqlite3ExprCodeCopy (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3ExprCodeFactorable (Parse , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprCodeRunJustOnce (Parse , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprCodeTemp (Parse , Expr , int *)

SQLITE_PRIVATE int	sqlite3ExprCodeTarget (Parse , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprCodeExprList (Parse , ExprList , int, int, u8)

SQLITE_PRIVATE void	sqlite3ExprIfTrue (Parse , Expr , int, int)

SQLITE_PRIVATE void	sqlite3ExprIfFalse (Parse , Expr , int, int)

SQLITE_PRIVATE void	sqlite3ExprIfFalseDup (Parse , Expr , int, int)

SQLITE_PRIVATE Table *	sqlite3FindTable (sqlite3 , const char , const char *)

SQLITE_PRIVATE Table *	sqlite3LocateTable (Parse , u32 flags, const char , const char *)

SQLITE_PRIVATE Table *	sqlite3LocateTableItem (Parse , u32 flags, struct SrcList_item )

SQLITE_PRIVATE Index *	sqlite3FindIndex (sqlite3 , const char , const char *)

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteTable (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteIndex (sqlite3 , int, const char )

SQLITE_PRIVATE void	sqlite3Vacuum (Parse , Token , Expr *)

SQLITE_PRIVATE int	sqlite3RunVacuum (char *, sqlite3 , int, sqlite3_value *)

SQLITE_PRIVATE char *	sqlite3NameFromToken (sqlite3 , Token )

SQLITE_PRIVATE int	sqlite3ExprCompare (Parse , Expr , Expr *, int)

SQLITE_PRIVATE int	sqlite3ExprCompareSkip (Expr , Expr , int)

SQLITE_PRIVATE int	sqlite3ExprListCompare (ExprList , ExprList , int)

SQLITE_PRIVATE int	sqlite3ExprImpliesExpr (Parse , Expr , Expr *, int)

SQLITE_PRIVATE int	sqlite3ExprImpliesNonNullRow (Expr *, int)

SQLITE_PRIVATE void	sqlite3AggInfoPersistWalkerInit (Walker , Parse )

SQLITE_PRIVATE void	sqlite3ExprAnalyzeAggregates (NameContext , Expr )

SQLITE_PRIVATE void	sqlite3ExprAnalyzeAggList (NameContext , ExprList )

SQLITE_PRIVATE int	sqlite3ExprCoveredByIndex (Expr , int iCur, Index pIdx)

SQLITE_PRIVATE int	sqlite3FunctionUsesThisSrc (Expr , SrcList )

SQLITE_PRIVATE Vdbe *	sqlite3GetVdbe (Parse *)

SQLITE_PRIVATE void	sqlite3PrngSaveState (void)

SQLITE_PRIVATE void	sqlite3PrngRestoreState (void)

SQLITE_PRIVATE void	sqlite3RollbackAll (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3CodeVerifySchema (Parse *, int)

SQLITE_PRIVATE void	sqlite3CodeVerifyNamedSchema (Parse , const char zDb)

SQLITE_PRIVATE void	sqlite3BeginTransaction (Parse *, int)

SQLITE_PRIVATE void	sqlite3EndTransaction (Parse *, int)

SQLITE_PRIVATE void	sqlite3Savepoint (Parse , int, Token )

SQLITE_PRIVATE void	sqlite3CloseSavepoints (sqlite3 *)

SQLITE_PRIVATE void	sqlite3LeaveMutexAndCloseZombie (sqlite3 *)

SQLITE_PRIVATE u32	sqlite3IsTrueOrFalse (const char *)

SQLITE_PRIVATE int	sqlite3ExprIdToTrueFalse (Expr *)

SQLITE_PRIVATE int	sqlite3ExprTruthValue (const Expr *)

SQLITE_PRIVATE int	sqlite3ExprIsConstant (Expr *)

SQLITE_PRIVATE int	sqlite3ExprIsConstantNotJoin (Expr *)

SQLITE_PRIVATE int	sqlite3ExprIsConstantOrFunction (Expr *, u8)

SQLITE_PRIVATE int	sqlite3ExprIsConstantOrGroupBy (Parse , Expr , ExprList *)

SQLITE_PRIVATE int	sqlite3ExprIsTableConstant (Expr *, int)

SQLITE_PRIVATE int	sqlite3ExprIsInteger (Expr , int )

SQLITE_PRIVATE int	sqlite3ExprCanBeNull (const Expr *)

SQLITE_PRIVATE int	sqlite3ExprNeedsNoAffinityChange (const Expr *, char)

SQLITE_PRIVATE int	sqlite3IsRowid (const char *)

SQLITE_PRIVATE void	sqlite3GenerateRowDelete (Parse , Table , Trigger *, int, int, int, i16, u8, u8, u8, int)

SQLITE_PRIVATE void	sqlite3GenerateRowIndexDelete (Parse , Table , int, int, int *, int)

SQLITE_PRIVATE int	sqlite3GenerateIndexKey (Parse , Index , int, int, int, int , Index , int)

SQLITE_PRIVATE void	sqlite3ResolvePartIdxLabel (Parse *, int)

SQLITE_PRIVATE int	sqlite3ExprReferencesUpdatedColumn (Expr , int , int)

SQLITE_PRIVATE void	sqlite3GenerateConstraintChecks (Parse , Table , int , int, int, int, int, u8, u8, int, int , int , Upsert )

SQLITE_PRIVATE void	sqlite3CompleteInsertion (Parse , Table , int, int, int, int *, int, int, int)

SQLITE_PRIVATE int	sqlite3OpenTableAndIndices (Parse , Table , int, u8, int, u8 , int , int *)

SQLITE_PRIVATE void	sqlite3BeginWriteOperation (Parse *, int, int)

SQLITE_PRIVATE void	sqlite3MultiWrite (Parse *)

SQLITE_PRIVATE void	sqlite3MayAbort (Parse *)

SQLITE_PRIVATE void	sqlite3HaltConstraint (Parse , int, int, char , i8, u8)

SQLITE_PRIVATE void	sqlite3UniqueConstraint (Parse , int, Index )

SQLITE_PRIVATE void	sqlite3RowidConstraint (Parse , int, Table )

SQLITE_PRIVATE Expr *	sqlite3ExprDup (sqlite3 , Expr , int)

SQLITE_PRIVATE ExprList *	sqlite3ExprListDup (sqlite3 , ExprList , int)

SQLITE_PRIVATE SrcList *	sqlite3SrcListDup (sqlite3 , SrcList , int)

SQLITE_PRIVATE IdList *	sqlite3IdListDup (sqlite3 , IdList )

SQLITE_PRIVATE Select *	sqlite3SelectDup (sqlite3 , Select , int)

SQLITE_PRIVATE FuncDef *	sqlite3FunctionSearch (int, const char *)

SQLITE_PRIVATE void	sqlite3InsertBuiltinFuncs (FuncDef *, int)

SQLITE_PRIVATE FuncDef *	sqlite3FindFunction (sqlite3 , const char , int, u8, u8)

SQLITE_PRIVATE void	sqlite3RegisterBuiltinFunctions (void)

SQLITE_PRIVATE void	sqlite3RegisterDateTimeFunctions (void)

SQLITE_PRIVATE void	sqlite3RegisterPerConnectionBuiltinFunctions (sqlite3 *)

SQLITE_PRIVATE int	sqlite3SafetyCheckOk (sqlite3 *)

SQLITE_PRIVATE int	sqlite3SafetyCheckSickOrOk (sqlite3 *)

SQLITE_PRIVATE void	sqlite3ChangeCookie (Parse *, int)

SQLITE_PRIVATE void	sqlite3MaterializeView (Parse , Table , Expr , ExprList , Expr *, int)

SQLITE_PRIVATE void	sqlite3BeginTrigger (Parse , Token , Token , int, int, IdList , SrcList , Expr , int, int)

SQLITE_PRIVATE void	sqlite3FinishTrigger (Parse , TriggerStep , Token *)

SQLITE_PRIVATE void	sqlite3DropTrigger (Parse , SrcList , int)

SQLITE_PRIVATE void	sqlite3DropTriggerPtr (Parse , Trigger )

SQLITE_PRIVATE Trigger *	sqlite3TriggersExist (Parse , Table , int, ExprList , int pMask)

SQLITE_PRIVATE Trigger *	sqlite3TriggerList (Parse , Table )

SQLITE_PRIVATE void	sqlite3CodeRowTrigger (Parse , Trigger , int, ExprList , int, Table , int, int, int)

SQLITE_PRIVATE void	sqlite3CodeRowTriggerDirect (Parse , Trigger , Table *, int, int, int)

void	sqliteViewTriggers (Parse , Table , Expr , int, ExprList )

SQLITE_PRIVATE void	sqlite3DeleteTriggerStep (sqlite3 , TriggerStep )

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerSelectStep (sqlite3 , Select , const char , const char )

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerInsertStep (Parse , Token , IdList , Select , u8, Upsert , const char , const char *)

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerUpdateStep (Parse , Token , SrcList , ExprList , Expr , u8, const char , const char *)

SQLITE_PRIVATE TriggerStep *	sqlite3TriggerDeleteStep (Parse , Token , Expr , const char , const char *)

SQLITE_PRIVATE void	sqlite3DeleteTrigger (sqlite3 , Trigger )

SQLITE_PRIVATE void	sqlite3UnlinkAndDeleteTrigger (sqlite3 , int, const char )

SQLITE_PRIVATE u32	sqlite3TriggerColmask (Parse , Trigger , ExprList , int, int, Table , int)

SQLITE_PRIVATE SrcList *	sqlite3TriggerStepSrc (Parse , TriggerStep )

SQLITE_PRIVATE int	sqlite3JoinType (Parse , Token , Token , Token )

SQLITE_PRIVATE void	sqlite3SetJoinExpr (Expr *, int)

SQLITE_PRIVATE void	sqlite3CreateForeignKey (Parse , ExprList , Token , ExprList , int)

SQLITE_PRIVATE void	sqlite3DeferForeignKey (Parse *, int)

SQLITE_PRIVATE void	sqlite3AuthRead (Parse , Expr , Schema , SrcList )

SQLITE_PRIVATE int	sqlite3AuthCheck (Parse , int, const char , const char , const char )

SQLITE_PRIVATE void	sqlite3AuthContextPush (Parse , AuthContext , const char *)

SQLITE_PRIVATE void	sqlite3AuthContextPop (AuthContext *)

SQLITE_PRIVATE int	sqlite3AuthReadCol (Parse , const char , const char *, int)

SQLITE_PRIVATE int	sqlite3DbIsNamed (sqlite3 db, int iDb, const char zName)

SQLITE_PRIVATE void	sqlite3Attach (Parse , Expr , Expr , Expr )

SQLITE_PRIVATE void	sqlite3Detach (Parse , Expr )

SQLITE_PRIVATE void	sqlite3FixInit (DbFixer , Parse , int, const char , const Token )

SQLITE_PRIVATE int	sqlite3FixSrcList (DbFixer , SrcList )

SQLITE_PRIVATE int	sqlite3FixSelect (DbFixer , Select )

SQLITE_PRIVATE int	sqlite3FixExpr (DbFixer , Expr )

SQLITE_PRIVATE int	sqlite3FixExprList (DbFixer , ExprList )

SQLITE_PRIVATE int	sqlite3FixTriggerStep (DbFixer , TriggerStep )

SQLITE_PRIVATE int	sqlite3RealSameAsInt (double, sqlite3_int64)

SQLITE_PRIVATE void	sqlite3Int64ToText (i64, char *)

SQLITE_PRIVATE int	sqlite3AtoF (const char z, double , int, u8)

SQLITE_PRIVATE int	sqlite3GetInt32 (const char , int )

SQLITE_PRIVATE int	sqlite3GetUInt32 (const char , u32 )

SQLITE_PRIVATE int	sqlite3Atoi (const char *)

SQLITE_PRIVATE int	sqlite3Utf16ByteLen (const void *pData, int nChar)

SQLITE_PRIVATE int	sqlite3Utf8CharLen (const char *pData, int nByte)

SQLITE_PRIVATE u32	sqlite3Utf8Read (const u8 **)

SQLITE_PRIVATE LogEst	sqlite3LogEst (u64)

SQLITE_PRIVATE LogEst	sqlite3LogEstAdd (LogEst, LogEst)

SQLITE_PRIVATE LogEst	sqlite3LogEstFromDouble (double)

SQLITE_PRIVATE VList *	sqlite3VListAdd (sqlite3 , VList , const char *, int, int)

SQLITE_PRIVATE const char *	sqlite3VListNumToName (VList *, int)

SQLITE_PRIVATE int	sqlite3VListNameToNum (VList , const char , int)

SQLITE_PRIVATE int	sqlite3PutVarint (unsigned char *, u64)

SQLITE_PRIVATE u8	sqlite3GetVarint (const unsigned char , u64 )

SQLITE_PRIVATE u8	sqlite3GetVarint32 (const unsigned char , u32 )

SQLITE_PRIVATE int	sqlite3VarintLen (u64 v)

SQLITE_PRIVATE const char *	sqlite3IndexAffinityStr (sqlite3 , Index )

SQLITE_PRIVATE void	sqlite3TableAffinity (Vdbe , Table , int)

SQLITE_PRIVATE char	sqlite3CompareAffinity (const Expr *pExpr, char aff2)

SQLITE_PRIVATE int	sqlite3IndexAffinityOk (const Expr *pExpr, char idx_affinity)

SQLITE_PRIVATE char	sqlite3TableColumnAffinity (Table *, int)

SQLITE_PRIVATE char	sqlite3ExprAffinity (const Expr *pExpr)

SQLITE_PRIVATE int	sqlite3Atoi64 (const char , i64 , int, u8)

SQLITE_PRIVATE int	sqlite3DecOrHexToI64 (const char , i64 )

SQLITE_PRIVATE void	sqlite3ErrorWithMsg (sqlite3 , int, const char ,...)

SQLITE_PRIVATE void	sqlite3Error (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3SystemError (sqlite3 *, int)

SQLITE_PRIVATE void *	sqlite3HexToBlob (sqlite3 , const char z, int n)

SQLITE_PRIVATE u8	sqlite3HexToInt (int h)

SQLITE_PRIVATE int	sqlite3TwoPartName (Parse , Token , Token , Token *)

SQLITE_PRIVATE const char *	sqlite3ErrStr (int)

SQLITE_PRIVATE int	sqlite3ReadSchema (Parse *pParse)

SQLITE_PRIVATE CollSeq *	sqlite3FindCollSeq (sqlite3 , u8 enc, const char , int)

SQLITE_PRIVATE int	sqlite3IsBinary (const CollSeq *)

SQLITE_PRIVATE CollSeq *	sqlite3LocateCollSeq (Parse pParse, const char zName)

SQLITE_PRIVATE void	sqlite3SetTextEncoding (sqlite3 *db, u8)

SQLITE_PRIVATE CollSeq *	sqlite3ExprCollSeq (Parse pParse, const Expr pExpr)

SQLITE_PRIVATE CollSeq *	sqlite3ExprNNCollSeq (Parse pParse, const Expr pExpr)

SQLITE_PRIVATE int	sqlite3ExprCollSeqMatch (Parse , const Expr , const Expr *)

SQLITE_PRIVATE Expr *	sqlite3ExprAddCollateToken (Parse pParse, Expr , const Token *, int)

SQLITE_PRIVATE Expr *	sqlite3ExprAddCollateString (Parse , Expr , const char *)

SQLITE_PRIVATE Expr *	sqlite3ExprSkipCollate (Expr *)

SQLITE_PRIVATE Expr *	sqlite3ExprSkipCollateAndLikely (Expr *)

SQLITE_PRIVATE int	sqlite3CheckCollSeq (Parse , CollSeq )

SQLITE_PRIVATE int	sqlite3WritableSchema (sqlite3 *)

SQLITE_PRIVATE int	sqlite3CheckObjectName (Parse , const char , const char , const char )

SQLITE_PRIVATE void	sqlite3VdbeSetChanges (sqlite3 *, int)

SQLITE_PRIVATE int	sqlite3AddInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3SubInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3MulInt64 (i64 *, i64)

SQLITE_PRIVATE int	sqlite3AbsInt32 (int)

SQLITE_PRIVATE u8	sqlite3GetBoolean (const char *z, u8)

SQLITE_PRIVATE const void *	sqlite3ValueText (sqlite3_value *, u8)

SQLITE_PRIVATE int	sqlite3ValueBytes (sqlite3_value *, u8)

SQLITE_PRIVATE void	sqlite3ValueSetStr (sqlite3_value , int, const void , u8, void()(void ))

SQLITE_PRIVATE void	sqlite3ValueSetNull (sqlite3_value *)

SQLITE_PRIVATE void	sqlite3ValueFree (sqlite3_value *)

SQLITE_PRIVATE void	sqlite3ResultIntReal (sqlite3_context *)

SQLITE_PRIVATE sqlite3_value *	sqlite3ValueNew (sqlite3 *)

SQLITE_PRIVATE char *	sqlite3Utf16to8 (sqlite3 , const void , int, u8)

SQLITE_PRIVATE int	sqlite3ValueFromExpr (sqlite3 , Expr , u8, u8, sqlite3_value **)

SQLITE_PRIVATE void	sqlite3ValueApplyAffinity (sqlite3_value *, u8, u8)

SQLITE_PRIVATE void	sqlite3RootPageMoved (sqlite3 *, int, Pgno, Pgno)

SQLITE_PRIVATE void	sqlite3Reindex (Parse , Token , Token *)

SQLITE_PRIVATE void	sqlite3AlterFunctions (void)

SQLITE_PRIVATE void	sqlite3AlterRenameTable (Parse , SrcList , Token *)

SQLITE_PRIVATE void	sqlite3AlterRenameColumn (Parse , SrcList , Token , Token )

SQLITE_PRIVATE int	sqlite3GetToken (const unsigned char , int )

SQLITE_PRIVATE void	sqlite3NestedParse (Parse , const char ,...)

SQLITE_PRIVATE void	sqlite3ExpirePreparedStatements (sqlite3 *, int)

SQLITE_PRIVATE void	sqlite3CodeRhsOfIN (Parse , Expr , int)

SQLITE_PRIVATE int	sqlite3CodeSubselect (Parse , Expr )

SQLITE_PRIVATE void	sqlite3SelectPrep (Parse , Select , NameContext *)

SQLITE_PRIVATE void	sqlite3SelectWrongNumTermsError (Parse pParse, Select p)

SQLITE_PRIVATE int	sqlite3MatchEName (const struct ExprList_item , const char , const char , const char )

SQLITE_PRIVATE Bitmask	sqlite3ExprColUsed (Expr *)

SQLITE_PRIVATE u8	sqlite3StrIHash (const char *)

SQLITE_PRIVATE int	sqlite3ResolveExprNames (NameContext , Expr )

SQLITE_PRIVATE int	sqlite3ResolveExprListNames (NameContext , ExprList )

SQLITE_PRIVATE void	sqlite3ResolveSelectNames (Parse , Select , NameContext *)

SQLITE_PRIVATE int	sqlite3ResolveSelfReference (Parse , Table , int, Expr , ExprList )

SQLITE_PRIVATE int	sqlite3ResolveOrderGroupBy (Parse , Select , ExprList , const char )

SQLITE_PRIVATE void	sqlite3ColumnDefault (Vdbe , Table , int, int)

SQLITE_PRIVATE void	sqlite3AlterFinishAddColumn (Parse , Token )

SQLITE_PRIVATE void	sqlite3AlterBeginAddColumn (Parse , SrcList )

SQLITE_PRIVATE void *	sqlite3RenameTokenMap (Parse , void , Token *)

SQLITE_PRIVATE void	sqlite3RenameTokenRemap (Parse , void pTo, void *pFrom)

SQLITE_PRIVATE void	sqlite3RenameExprUnmap (Parse , Expr )

SQLITE_PRIVATE void	sqlite3RenameExprlistUnmap (Parse , ExprList )

SQLITE_PRIVATE CollSeq *	sqlite3GetCollSeq (Parse , u8, CollSeq , const char *)

SQLITE_PRIVATE char	sqlite3AffinityType (const char , Column )

SQLITE_PRIVATE void	sqlite3Analyze (Parse , Token , Token *)

SQLITE_PRIVATE int	sqlite3InvokeBusyHandler (BusyHandler *)

SQLITE_PRIVATE int	sqlite3FindDb (sqlite3 , Token )

SQLITE_PRIVATE int	sqlite3FindDbName (sqlite3 , const char )

SQLITE_PRIVATE int	sqlite3AnalysisLoad (sqlite3 *, int iDB)

SQLITE_PRIVATE void	sqlite3DeleteIndexSamples (sqlite3 , Index )

SQLITE_PRIVATE void	sqlite3DefaultRowEst (Index *)

SQLITE_PRIVATE void	sqlite3RegisterLikeFunctions (sqlite3 *, int)

SQLITE_PRIVATE int	sqlite3IsLikeFunction (sqlite3 , Expr , int , char )

SQLITE_PRIVATE void	sqlite3SchemaClear (void *)

SQLITE_PRIVATE Schema *	sqlite3SchemaGet (sqlite3 , Btree )

SQLITE_PRIVATE int	sqlite3SchemaToIndex (sqlite3 db, Schema )

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoAlloc (sqlite3 *, int, int)

SQLITE_PRIVATE void	sqlite3KeyInfoUnref (KeyInfo *)

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoRef (KeyInfo *)

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoOfIndex (Parse , Index )

SQLITE_PRIVATE KeyInfo *	sqlite3KeyInfoFromExprList (Parse , ExprList , int, int)

SQLITE_PRIVATE int	sqlite3HasExplicitNulls (Parse , ExprList )

SQLITE_PRIVATE int	sqlite3CreateFunc (sqlite3 , const char , int, int, void , void()(sqlite3_context , int, sqlite3_value ), void()(sqlite3_context , int, sqlite3_value ), void()(sqlite3_context ), void()(sqlite3_context ), void()(sqlite3_context , int, sqlite3_value ), FuncDestructor pDestructor)

SQLITE_PRIVATE void	sqlite3NoopDestructor (void *)

SQLITE_PRIVATE void	sqlite3OomFault (sqlite3 *)

SQLITE_PRIVATE void	sqlite3OomClear (sqlite3 *)

SQLITE_PRIVATE int	sqlite3ApiExit (sqlite3 *db, int)

SQLITE_PRIVATE int	sqlite3OpenTempDatabase (Parse *)

SQLITE_PRIVATE void	sqlite3StrAccumInit (StrAccum , sqlite3 , char *, int, int)

SQLITE_PRIVATE char *	sqlite3StrAccumFinish (StrAccum *)

SQLITE_PRIVATE void	sqlite3SelectDestInit (SelectDest *, int, int)

SQLITE_PRIVATE Expr *	sqlite3CreateColumnExpr (sqlite3 , SrcList , int, int)

SQLITE_PRIVATE void	sqlite3BackupRestart (sqlite3_backup *)

SQLITE_PRIVATE void	sqlite3BackupUpdate (sqlite3_backup , Pgno, const u8 )

SQLITE_PRIVATE int	sqlite3ExprCheckIN (Parse , Expr )

SQLITE_PRIVATE void	sqlite3Parser (void *, int, Token)

SQLITE_PRIVATE int	sqlite3ParserFallback (int)

SQLITE_PRIVATE void	sqlite3AutoLoadExtensions (sqlite3 *)

SQLITE_PRIVATE void	sqlite3CloseExtensions (sqlite3 *)

SQLITE_PRIVATE void	sqlite3TableLock (Parse , int, Pgno, u8, const char )

SQLITE_PRIVATE void	sqlite3VtabClear (sqlite3 db, Table )

SQLITE_PRIVATE void	sqlite3VtabDisconnect (sqlite3 db, Table p)

SQLITE_PRIVATE int	sqlite3VtabSync (sqlite3 db, Vdbe )

SQLITE_PRIVATE int	sqlite3VtabRollback (sqlite3 *db)

SQLITE_PRIVATE int	sqlite3VtabCommit (sqlite3 *db)

SQLITE_PRIVATE void	sqlite3VtabLock (VTable *)

SQLITE_PRIVATE void	sqlite3VtabUnlock (VTable *)

SQLITE_PRIVATE void	sqlite3VtabModuleUnref (sqlite3 , Module )

SQLITE_PRIVATE void	sqlite3VtabUnlockList (sqlite3 *)

SQLITE_PRIVATE int	sqlite3VtabSavepoint (sqlite3 *, int, int)

SQLITE_PRIVATE void	sqlite3VtabImportErrmsg (Vdbe , sqlite3_vtab )

SQLITE_PRIVATE VTable *	sqlite3GetVTable (sqlite3 , Table )

SQLITE_PRIVATE Module *	sqlite3VtabCreateModule (sqlite3 , const char , const sqlite3_module , void , void()(void ))

SQLITE_PRIVATE int	sqlite3ReadOnlyShadowTables (sqlite3 *db)

SQLITE_PRIVATE int	sqlite3ShadowTableName (sqlite3 db, const char zName)

SQLITE_PRIVATE int	sqlite3IsShadowTableOf (sqlite3 , Table , const char *)

SQLITE_PRIVATE int	sqlite3VtabEponymousTableInit (Parse , Module )

SQLITE_PRIVATE void	sqlite3VtabEponymousTableClear (sqlite3 , Module )

SQLITE_PRIVATE void	sqlite3VtabMakeWritable (Parse , Table )

SQLITE_PRIVATE void	sqlite3VtabBeginParse (Parse , Token , Token , Token , int)

SQLITE_PRIVATE void	sqlite3VtabFinishParse (Parse , Token )

SQLITE_PRIVATE void	sqlite3VtabArgInit (Parse *)

SQLITE_PRIVATE void	sqlite3VtabArgExtend (Parse , Token )

SQLITE_PRIVATE int	sqlite3VtabCallCreate (sqlite3 , int, const char , char **)

SQLITE_PRIVATE int	sqlite3VtabCallConnect (Parse , Table )

SQLITE_PRIVATE int	sqlite3VtabCallDestroy (sqlite3 , int, const char )

SQLITE_PRIVATE int	sqlite3VtabBegin (sqlite3 , VTable )

SQLITE_PRIVATE FuncDef *	sqlite3VtabOverloadFunction (sqlite3 , FuncDef , int nArg, Expr *)

SQLITE_PRIVATE sqlite3_int64	sqlite3StmtCurrentTime (sqlite3_context *)

SQLITE_PRIVATE int	sqlite3VdbeParameterIndex (Vdbe , const char , int)

SQLITE_PRIVATE int	sqlite3TransferBindings (sqlite3_stmt , sqlite3_stmt )

SQLITE_PRIVATE void	sqlite3ParserReset (Parse *)

SQLITE_PRIVATE int	sqlite3Reprepare (Vdbe *)

SQLITE_PRIVATE void	sqlite3ExprListCheckLength (Parse , ExprList , const char *)

SQLITE_PRIVATE CollSeq *	sqlite3ExprCompareCollSeq (Parse , const Expr )

SQLITE_PRIVATE CollSeq *	sqlite3BinaryCompareCollSeq (Parse , const Expr , const Expr *)

SQLITE_PRIVATE int	sqlite3TempInMemory (const sqlite3 *)

SQLITE_PRIVATE const char *	sqlite3JournalModename (int)

SQLITE_PRIVATE int	sqlite3Checkpoint (sqlite3 , int, int, int , int *)

SQLITE_PRIVATE int	sqlite3WalDefaultHook (void , sqlite3 , const char *, int)

SQLITE_PRIVATE With *	sqlite3WithAdd (Parse , With , Token , ExprList , Select *)

SQLITE_PRIVATE void	sqlite3WithDelete (sqlite3 , With )

SQLITE_PRIVATE void	sqlite3WithPush (Parse , With , u8)

SQLITE_PRIVATE Upsert *	sqlite3UpsertNew (sqlite3 , ExprList , Expr , ExprList , Expr *)

SQLITE_PRIVATE void	sqlite3UpsertDelete (sqlite3 , Upsert )

SQLITE_PRIVATE Upsert *	sqlite3UpsertDup (sqlite3 , Upsert )

SQLITE_PRIVATE int	sqlite3UpsertAnalyzeTarget (Parse , SrcList , Upsert *)

SQLITE_PRIVATE void	sqlite3UpsertDoUpdate (Parse , Upsert , Table , Index , int)

SQLITE_PRIVATE void	sqlite3FkCheck (Parse , Table , int, int, int *, int)

SQLITE_PRIVATE void	sqlite3FkDropTable (Parse , SrcList , Table *)

SQLITE_PRIVATE void	sqlite3FkActions (Parse , Table , ExprList , int, int , int)

SQLITE_PRIVATE int	sqlite3FkRequired (Parse , Table , int *, int)

SQLITE_PRIVATE u32	sqlite3FkOldmask (Parse , Table )

SQLITE_PRIVATE FKey *	sqlite3FkReferences (Table *)

SQLITE_PRIVATE void	sqlite3FkDelete (sqlite3 , Table )

SQLITE_PRIVATE int	sqlite3FkLocateIndex (Parse , Table , FKey , Index , int *)

SQLITE_PRIVATE void	sqlite3BeginBenignMalloc (void)

SQLITE_PRIVATE void	sqlite3EndBenignMalloc (void)

SQLITE_PRIVATE int	sqlite3FindInIndex (Parse , Expr , u32, int , int , int *)

SQLITE_PRIVATE int	sqlite3JournalOpen (sqlite3_vfs , const char , sqlite3_file *, int, int)

SQLITE_PRIVATE int	sqlite3JournalSize (sqlite3_vfs *)

SQLITE_PRIVATE int	sqlite3JournalIsInMemory (sqlite3_file *p)

SQLITE_PRIVATE void	sqlite3MemJournalOpen (sqlite3_file *)

SQLITE_PRIVATE void	sqlite3ExprSetHeightAndFlags (Parse pParse, Expr p)

SQLITE_PRIVATE int	sqlite3SelectExprHeight (Select *)

SQLITE_PRIVATE int	sqlite3ExprCheckHeight (Parse *, int)

SQLITE_PRIVATE u32	sqlite3Get4byte (const u8 *)

SQLITE_PRIVATE void	sqlite3Put4byte (u8 *, u32)

SQLITE_PRIVATE int	sqlite3ThreadCreate (SQLiteThread *, void ()(void ), void *)

SQLITE_PRIVATE int	sqlite3ThreadJoin (SQLiteThread , void *)

SQLITE_PRIVATE int	sqlite3ExprVectorSize (Expr *pExpr)

SQLITE_PRIVATE int	sqlite3ExprIsVector (Expr *pExpr)

SQLITE_PRIVATE Expr *	sqlite3VectorFieldSubexpr (Expr *, int)

SQLITE_PRIVATE Expr *	sqlite3ExprForVectorField (Parse , Expr , int)

SQLITE_PRIVATE void	sqlite3VectorErrorMsg (Parse , Expr )

SQLITE_PRIVATE void	sqlite3VdbeError (Vdbe , const char ,...)

SQLITE_PRIVATE void	sqlite3VdbeFreeCursor (Vdbe , VdbeCursor )

void	sqliteVdbePopStack (Vdbe *, int)

SQLITE_PRIVATE int SQLITE_NOINLINE	sqlite3VdbeFinishMoveto (VdbeCursor *)

SQLITE_PRIVATE int	sqlite3VdbeCursorMoveto (VdbeCursor *, u32 )

SQLITE_PRIVATE int	sqlite3VdbeCursorRestore (VdbeCursor *)

SQLITE_PRIVATE u32	sqlite3VdbeSerialTypeLen (u32)

SQLITE_PRIVATE u8	sqlite3VdbeOneByteSerialTypeLen (u8)

SQLITE_PRIVATE u32	sqlite3VdbeSerialPut (unsigned char , Mem , u32)

SQLITE_PRIVATE u32	sqlite3VdbeSerialGet (const unsigned char , u32, Mem )

SQLITE_PRIVATE void	sqlite3VdbeDeleteAuxData (sqlite3 , AuxData *, int, int)

int	sqlite2BtreeKeyCompare (BtCursor , const void , int, int, int *)

SQLITE_PRIVATE int	sqlite3VdbeIdxKeyCompare (sqlite3 , VdbeCursor , UnpackedRecord , int )

SQLITE_PRIVATE int	sqlite3VdbeIdxRowid (sqlite3 , BtCursor , i64 *)

SQLITE_PRIVATE int	sqlite3VdbeExec (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeNextOpcode (Vdbe , Mem , int, int , int , Op **)

SQLITE_PRIVATE char *	sqlite3VdbeDisplayP4 (sqlite3 , Op )

SQLITE_PRIVATE int	sqlite3VdbeList (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeHalt (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeChangeEncoding (Mem *, int)

SQLITE_PRIVATE int	sqlite3VdbeMemTooBig (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemCopy (Mem , const Mem )

SQLITE_PRIVATE void	sqlite3VdbeMemShallowCopy (Mem , const Mem , int)

SQLITE_PRIVATE void	sqlite3VdbeMemMove (Mem , Mem )

SQLITE_PRIVATE int	sqlite3VdbeMemNulTerminate (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemSetStr (Mem , const char , int, u8, void()(void ))

SQLITE_PRIVATE void	sqlite3VdbeMemSetInt64 (Mem *, i64)

SQLITE_PRIVATE void	sqlite3VdbeMemSetDouble (Mem *, double)

SQLITE_PRIVATE void	sqlite3VdbeMemSetPointer (Mem , void , const char , void()(void *))

SQLITE_PRIVATE void	sqlite3VdbeMemInit (Mem , sqlite3 , u16)

SQLITE_PRIVATE void	sqlite3VdbeMemSetNull (Mem *)

SQLITE_PRIVATE void	sqlite3VdbeMemSetZeroBlob (Mem *, int)

SQLITE_PRIVATE int	sqlite3VdbeMemSetRowSet (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemMakeWriteable (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemStringify (Mem *, u8, u8)

SQLITE_PRIVATE i64	sqlite3VdbeIntValue (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemIntegerify (Mem *)

SQLITE_PRIVATE double	sqlite3VdbeRealValue (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeBooleanValue (Mem *, int ifNull)

SQLITE_PRIVATE void	sqlite3VdbeIntegerAffinity (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemRealify (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemNumerify (Mem *)

SQLITE_PRIVATE int	sqlite3VdbeMemCast (Mem *, u8, u8)

SQLITE_PRIVATE int	sqlite3VdbeMemFromBtree (BtCursor , u32, u32, Mem )

SQLITE_PRIVATE int	sqlite3VdbeMemFromBtreeZeroOffset (BtCursor , u32, Mem )

SQLITE_PRIVATE void	sqlite3VdbeMemRelease (Mem *p)

SQLITE_PRIVATE int	sqlite3VdbeMemFinalize (Mem , FuncDef )

SQLITE_PRIVATE int	sqlite3VdbeMemAggValue (Mem , Mem , FuncDef *)

SQLITE_PRIVATE const char *	sqlite3OpcodeName (int)

SQLITE_PRIVATE int	sqlite3VdbeMemGrow (Mem *pMem, int n, int preserve)

SQLITE_PRIVATE int	sqlite3VdbeMemClearAndResize (Mem *pMem, int n)

SQLITE_PRIVATE int	sqlite3VdbeCloseStatement (Vdbe *, int)

SQLITE_PRIVATE void	sqlite3VdbeFrameMemDel (void *)

SQLITE_PRIVATE void	sqlite3VdbeFrameDelete (VdbeFrame *)

SQLITE_PRIVATE int	sqlite3VdbeFrameRestore (VdbeFrame *)

SQLITE_PRIVATE int	sqlite3VdbeTransferError (Vdbe *p)

SQLITE_PRIVATE int	sqlite3VdbeSorterInit (sqlite3 , int, VdbeCursor )

SQLITE_PRIVATE void	sqlite3VdbeSorterReset (sqlite3 , VdbeSorter )

SQLITE_PRIVATE void	sqlite3VdbeSorterClose (sqlite3 , VdbeCursor )

SQLITE_PRIVATE int	sqlite3VdbeSorterRowkey (const VdbeCursor , Mem )

SQLITE_PRIVATE int	sqlite3VdbeSorterNext (sqlite3 , const VdbeCursor )

SQLITE_PRIVATE int	sqlite3VdbeSorterRewind (const VdbeCursor , int )

SQLITE_PRIVATE int	sqlite3VdbeSorterWrite (const VdbeCursor , Mem )

SQLITE_PRIVATE int	sqlite3VdbeSorterCompare (const VdbeCursor , Mem , int, int *)

SQLITE_PRIVATE void	sqlite3VdbeEnter (Vdbe *)

SQLITE_PRIVATE void	sqlite3VdbeLeave (Vdbe *)

SQLITE_PRIVATE int	sqlite3VdbeCheckFk (Vdbe *, int)

SQLITE_PRIVATE int	sqlite3VdbeMemTranslate (Mem *, u8)

SQLITE_PRIVATE int	sqlite3VdbeMemHandleBom (Mem *pMem)

SQLITE_PRIVATE int	sqlite3VdbeMemExpandBlob (Mem *)

static u32	countLookasideSlots (LookasideSlot *p)

static int	getDigits (const char zDate, const char zFormat,...)

static int	parseTimezone (const char zDate, DateTime p)

static int	parseHhMmSs (const char zDate, DateTime p)

static void	datetimeError (DateTime *p)

static void	computeJD (DateTime *p)

static int	parseYyyyMmDd (const char zDate, DateTime p)

static int	setDateTimeToCurrent (sqlite3_context context, DateTime p)

static void	setRawDateNumber (DateTime *p, double r)

static int	parseDateOrTime (sqlite3_context context, const char zDate, DateTime *p)

static int	validJulianDay (sqlite3_int64 iJD)

static void	computeYMD (DateTime *p)

static void	computeHMS (DateTime *p)

static void	computeYMD_HMS (DateTime *p)

static void	clearYMD_HMS_TZ (DateTime *p)

static int	osLocaltime (time_t t, struct tm pTm)

static sqlite3_int64	localtimeOffset (DateTime p, sqlite3_context pCtx, int *pRc)

static int	parseModifier (sqlite3_context pCtx, const char z, int n, DateTime *p)

static int	isDate (sqlite3_context context, int argc, sqlite3_value argv, DateTime p)

static void	juliandayFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	datetimeFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	timeFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	dateFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	strftimeFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	ctimeFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	cdateFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	ctimestampFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	vfsUnlink (sqlite3_vfs *pVfs)

static void *	sqlite3MemMalloc (int nByte)

static void	sqlite3MemFree (void *pPrior)

static int	sqlite3MemSize (void *pPrior)

static void *	sqlite3MemRealloc (void *pPrior, int nByte)

static int	sqlite3MemRoundup (int n)

static int	sqlite3MemInit (void *NotUsed)

static void	sqlite3MemShutdown (void *NotUsed)

static int	noopMutexInit (void)

static int	noopMutexEnd (void)

static sqlite3_mutex *	noopMutexAlloc (int id)

static void	noopMutexFree (sqlite3_mutex *p)

static void	noopMutexEnter (sqlite3_mutex *p)

static int	noopMutexTry (sqlite3_mutex *p)

static void	noopMutexLeave (sqlite3_mutex *p)

static int	pthreadMutexInit (void)

static int	pthreadMutexEnd (void)

static sqlite3_mutex *	pthreadMutexAlloc (int iType)

static void	pthreadMutexFree (sqlite3_mutex *p)

static void	pthreadMutexEnter (sqlite3_mutex *p)

static int	pthreadMutexTry (sqlite3_mutex *p)

static void	pthreadMutexLeave (sqlite3_mutex *p)

SQLITE_API int	sqlite3_memory_alarm (void(xCallback)(void pArg, sqlite3_int64 used, int N), void *pArg, sqlite3_int64 iThreshold)

static void	sqlite3MallocAlarm (int nByte)

static void	mallocWithAlarm (int n, void **pp)

static int	isLookaside (sqlite3 db, void p)

static int	lookasideMallocSize (sqlite3 db, void p)

static SQLITE_NOINLINE void	measureAllocationSize (sqlite3 db, void p)

static SQLITE_NOINLINE void *	dbMallocRawFinish (sqlite3 *db, u64 n)

static SQLITE_NOINLINE void *	dbReallocFinish (sqlite3 db, void p, u64 n)

static SQLITE_NOINLINE int	apiOomError (sqlite3 *db)

static char	et_getdigit (LONGDOUBLE_TYPE val, int cnt)

static void	setStrAccumError (StrAccum *p, u8 eError)

static sqlite3_int64	getIntArg (PrintfArguments *p)

static double	getDoubleArg (PrintfArguments *p)

static char *	getTextArg (PrintfArguments *p)

static char *	printfTempBuf (sqlite3_str *pAccum, sqlite3_int64 n)

static int	sqlite3StrAccumEnlarge (StrAccum *p, int N)

static void SQLITE_NOINLINE	enlargeAndAppend (StrAccum p, const char z, int N)

static SQLITE_NOINLINE char *	strAccumFinishRealloc (StrAccum *p)

static void	renderLogMsg (int iErrCode, const char *zFormat, va_list ap)

SQLITE_PRIVATE int	sqlite3ThreadCreate (SQLiteThread *ppThread, void (xTask)(void ), void *pIn)

SQLITE_PRIVATE u32	sqlite3Utf8Read (const unsigned char **pz)

static SQLITE_NOINLINE void	sqlite3ErrorFinish (sqlite3 *db, int err_code)

static LONGDOUBLE_TYPE	sqlite3Pow10 (int E)

static int	compare2pow63 (const char *zNum, int incr)

static int SQLITE_NOINLINE	putVarint64 (unsigned char *p, u64 v)

SQLITE_PRIVATE void	sqlite3Put4byte (unsigned char *p, u32 v)

static void	logBadConnection (const char *zType)

static unsigned int	strHash (const char *z)

static void	insertElement (Hash pH, struct _ht pEntry, HashElem *pNew)

static int	rehash (Hash *pH, unsigned int new_size)

static HashElem *	findElementWithHash (const Hash pH, const char pKey, unsigned int *pHash)

static void	removeElementGivenHash (Hash pH, HashElem elem, unsigned int h)

static int	posixOpen (const char *zFile, int flags, int mode)

static int	openDirectory (const char , int )

static int	unixGetpagesize (void)

static int	robustFchown (int fd, uid_t uid, gid_t gid)

static int	unixSetSystemCall (sqlite3_vfs pNotUsed, const char zName, sqlite3_syscall_ptr pNewFunc)

static sqlite3_syscall_ptr	unixGetSystemCall (sqlite3_vfs pNotUsed, const char zName)

static const char *	unixNextSystemCall (sqlite3_vfs p, const char zName)

static int	robust_open (const char *z, int f, mode_t m)

static void	unixEnterMutex (void)

static void	unixLeaveMutex (void)

static int	robust_ftruncate (int h, sqlite3_int64 sz)

static int	sqliteErrorFromPosixError (int posixError, int sqliteIOErr)

static int	unixLogErrorAtLine (int errcode, const char zFunc, const char zPath, int iLine)

static void	robust_close (unixFile *pFile, int h, int lineno)

static void	storeLastErrno (unixFile *pFile, int error)

static void	closePendingFds (unixFile *pFile)

static void	releaseInodeInfo (unixFile *pFile)

static int	findInodeInfo (unixFile pFile, unixInodeInfo *ppInode)

static int	fileHasMoved (unixFile *pFile)

static void	verifyDbFile (unixFile *pFile)

static int	unixCheckReservedLock (sqlite3_file id, int pResOut)

static int	unixFileLock (unixFile pFile, struct flock pLock)

static int	unixLock (sqlite3_file *id, int eFileLock)

static void	setPendingFd (unixFile *pFile)

static int	posixUnlock (sqlite3_file *id, int eFileLock, int handleNFSUnlock)

static int	unixUnlock (sqlite3_file *id, int eFileLock)

static int	closeUnixFile (sqlite3_file *id)

static int	unixClose (sqlite3_file *id)

static int	nolockCheckReservedLock (sqlite3_file NotUsed, int pResOut)

static int	nolockLock (sqlite3_file *NotUsed, int NotUsed2)

static int	nolockUnlock (sqlite3_file *NotUsed, int NotUsed2)

static int	nolockClose (sqlite3_file *id)

static int	dotlockCheckReservedLock (sqlite3_file id, int pResOut)

static int	dotlockLock (sqlite3_file *id, int eFileLock)

static int	dotlockUnlock (sqlite3_file *id, int eFileLock)

static int	dotlockClose (sqlite3_file *id)

static int	seekAndRead (unixFile id, sqlite3_int64 offset, void pBuf, int cnt)

static int	unixRead (sqlite3_file id, void pBuf, int amt, sqlite3_int64 offset)

static int	seekAndWriteFd (int fd, i64 iOff, const void pBuf, int nBuf, int piErrno)

static int	seekAndWrite (unixFile id, i64 offset, const void pBuf, int cnt)

static int	unixWrite (sqlite3_file id, const void pBuf, int amt, sqlite3_int64 offset)

static int	full_fsync (int fd, int fullSync, int dataOnly)

static int	unixSync (sqlite3_file *id, int flags)

static int	unixTruncate (sqlite3_file *id, i64 nByte)

static int	unixFileSize (sqlite3_file id, i64 pSize)

static int	fcntlSizeHint (unixFile *pFile, i64 nByte)

static void	unixModeBit (unixFile pFile, unsigned char mask, int pArg)

static int	unixGetTempname (int nBuf, char *zBuf)

static int	unixFileControl (sqlite3_file id, int op, void pArg)

static void	setDeviceCharacteristics (unixFile *pFd)

static int	unixSectorSize (sqlite3_file *id)

static int	unixDeviceCharacteristics (sqlite3_file *id)

static int	unixShmSystemLock (unixFile *pFile, int lockType, int ofst, int n)

static int	unixShmRegionPerMap (void)

static void	unixShmPurge (unixFile *pFd)

static int	unixLockSharedMemory (unixFile pDbFd, unixShmNode pShmNode)

static int	unixOpenSharedMemory (unixFile *pDbFd)

static int	unixShmMap (sqlite3_file fd, int iRegion, int szRegion, int bExtend, void volatile *pp)

static int	unixShmLock (sqlite3_file *fd, int ofst, int n, int flags)

static void	unixShmBarrier (sqlite3_file *fd)

static int	unixShmUnmap (sqlite3_file *fd, int deleteFlag)

static int	unixFetch (sqlite3_file fd, i64 iOff, int nAmt, void *pp)

static int	unixUnfetch (sqlite3_file fd, i64 iOff, void p)

	IOMETHODS (posixIoFinder, posixIoMethods, IOMETHODS(3, unixClose, unixLock, unixUnlock, unixCheckReservedLock, unixShmMap)

static const char *	unixTempFileDir (void)

static UnixUnusedFd *	findReusableFd (const char *zPath, int flags)

static int	getFileMode (const char zFile, mode_t pMode, uid_t pUid, gid_t pGid)

static int	findCreateFileMode (const char zPath, int flags, mode_t pMode, uid_t pUid, gid_t pGid)

static int	unixOpen (sqlite3_vfs pVfs, const char zPath, sqlite3_file pFile, int flags, int pOutFlags)

static int	unixDelete (sqlite3_vfs NotUsed, const char zPath, int dirSync)

static int	unixAccess (sqlite3_vfs NotUsed, const char zPath, int flags, int *pResOut)

static int	mkFullPathname (const char zPath, char zOut, int nOut)

static int	unixFullPathname (sqlite3_vfs pVfs, const char zPath, int nOut, char *zOut)

static void *	unixDlOpen (sqlite3_vfs NotUsed, const char zFilename)

static void	unixDlError (sqlite3_vfs NotUsed, int nBuf, char zBufOut)

static void	unixDlClose (sqlite3_vfs NotUsed, void pHandle)

static int	unixRandomness (sqlite3_vfs NotUsed, int nBuf, char zBuf)

static int	unixSleep (sqlite3_vfs *NotUsed, int microseconds)

static int	unixCurrentTimeInt64 (sqlite3_vfs NotUsed, sqlite3_int64 piNow)

static int	unixCurrentTime (sqlite3_vfs NotUsed, double prNow)

static int	unixGetLastError (sqlite3_vfs NotUsed, int NotUsed2, char NotUsed3)

static void	pcacheManageDirtyList (PgHdr *pPage, u8 addRemove)

static void	pcacheUnpin (PgHdr *p)

static int	numberOfCachePages (PCache *p)

static SQLITE_NOINLINE PgHdr *	pcacheFetchFinishWithInit (PCache pCache, Pgno pgno, sqlite3_pcache_page pPage)

static PgHdr *	pcacheMergeDirtyList (PgHdr pA, PgHdr pB)

static PgHdr *	pcacheSortDirtyList (PgHdr *pIn)

static int	pcache1InitBulk (PCache1 *pCache)

static void *	pcache1Alloc (int nByte)

static void	pcache1Free (void *p)

static PgHdr1 *	pcache1AllocPage (PCache1 *pCache, int benignMalloc)

static void	pcache1FreePage (PgHdr1 *p)

static int	pcache1UnderMemoryPressure (PCache1 *pCache)

static void	pcache1ResizeHash (PCache1 *p)

static PgHdr1 *	pcache1PinPage (PgHdr1 *pPage)

static void	pcache1RemoveFromHash (PgHdr1 *pPage, int freeFlag)

static void	pcache1EnforceMaxPage (PCache1 *pCache)

static void	pcache1TruncateUnsafe (PCache1 *pCache, unsigned int iLimit)

static int	pcache1Init (void *NotUsed)

static void	pcache1Shutdown (void *NotUsed)

static void	pcache1Destroy (sqlite3_pcache *p)

static sqlite3_pcache *	pcache1Create (int szPage, int szExtra, int bPurgeable)

static void	pcache1Cachesize (sqlite3_pcache *p, int nMax)

static void	pcache1Shrink (sqlite3_pcache *p)

static int	pcache1Pagecount (sqlite3_pcache *p)

static SQLITE_NOINLINE PgHdr1 *	pcache1FetchStage2 (PCache1 *pCache, unsigned int iKey, int createFlag)

static PgHdr1 *	pcache1FetchNoMutex (sqlite3_pcache *p, unsigned int iKey, int createFlag)

static sqlite3_pcache_page *	pcache1Fetch (sqlite3_pcache *p, unsigned int iKey, int createFlag)

static void	pcache1Unpin (sqlite3_pcache p, sqlite3_pcache_page pPg, int reuseUnlikely)

static void	pcache1Rekey (sqlite3_pcache p, sqlite3_pcache_page pPg, unsigned int iOld, unsigned int iNew)

static void	pcache1Truncate (sqlite3_pcache *p, unsigned int iLimit)

static struct RowSetEntry *	rowSetEntryAlloc (RowSet *p)

static struct RowSetEntry *	rowSetEntryMerge (struct RowSetEntry pA, struct RowSetEntry pB)

static struct RowSetEntry *	rowSetEntrySort (struct RowSetEntry *pIn)

static void	rowSetTreeToList (struct RowSetEntry pIn, struct RowSetEntry ppFirst, struct RowSetEntry *ppLast)

static struct RowSetEntry *	rowSetNDeepTree (struct RowSetEntry **ppList, int iDepth)

static struct RowSetEntry *	rowSetListToTree (struct RowSetEntry *pList)

SQLITE_PRIVATE int	sqlite3WalOpen (sqlite3_vfs , sqlite3_file , const char , int, i64, Wal *)

SQLITE_PRIVATE int	sqlite3WalClose (Wal pWal, sqlite3 , int sync_flags, int, u8 *)

SQLITE_PRIVATE void	sqlite3WalLimit (Wal *, i64)

SQLITE_PRIVATE int	sqlite3WalBeginReadTransaction (Wal pWal, int )

SQLITE_PRIVATE void	sqlite3WalEndReadTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalFindFrame (Wal , Pgno, u32 )

SQLITE_PRIVATE int	sqlite3WalReadFrame (Wal , u32, int, u8 )

SQLITE_PRIVATE Pgno	sqlite3WalDbsize (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalBeginWriteTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalEndWriteTransaction (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalUndo (Wal pWal, int(xUndo)(void , Pgno), void pUndoCtx)

SQLITE_PRIVATE void	sqlite3WalSavepoint (Wal pWal, u32 aWalData)

SQLITE_PRIVATE int	sqlite3WalSavepointUndo (Wal pWal, u32 aWalData)

SQLITE_PRIVATE int	sqlite3WalFrames (Wal pWal, int, PgHdr , Pgno, int, int)

SQLITE_PRIVATE int	sqlite3WalCheckpoint (Wal pWal, sqlite3 db, int eMode, int(xBusy)(void ), void pBusyArg, int sync_flags, int nBuf, u8 zBuf, int pnLog, int pnCkpt)

SQLITE_PRIVATE int	sqlite3WalCallback (Wal *pWal)

SQLITE_PRIVATE int	sqlite3WalExclusiveMode (Wal *pWal, int op)

SQLITE_PRIVATE int	sqlite3WalHeapMemory (Wal *pWal)

SQLITE_PRIVATE sqlite3_file *	sqlite3WalFile (Wal *pWal)

static int	getPageNormal (Pager , Pgno, DbPage *, int)

static int	getPageError (Pager , Pgno, DbPage *, int)

static void	setGetterMethod (Pager *pPager)

static int	subjRequiresPage (PgHdr *pPg)

static int	read32bits (sqlite3_file fd, i64 offset, u32 pRes)

static int	write32bits (sqlite3_file *fd, i64 offset, u32 val)

static int	pagerUnlockDb (Pager *pPager, int eLock)

static int	pagerLockDb (Pager *pPager, int eLock)

static int	jrnlBufferSize (Pager *pPager)

static int	readSuperJournal (sqlite3_file pJrnl, char zSuper, u32 nSuper)

static i64	journalHdrOffset (Pager *pPager)

static int	zeroJournalHdr (Pager *pPager, int doTruncate)

static int	writeJournalHdr (Pager *pPager)

static int	readJournalHdr (Pager pPager, int isHot, i64 journalSize, u32 pNRec, u32 *pDbSize)

static int	writeSuperJournal (Pager pPager, const char zSuper)

static void	pager_reset (Pager *pPager)

static void	releaseAllSavepoints (Pager *pPager)

static int	addToSavepointBitvecs (Pager *pPager, Pgno pgno)

static void	pager_unlock (Pager *pPager)

static int	pager_error (Pager *pPager, int rc)

static int	pager_truncate (Pager *pPager, Pgno nPage)

static int	pagerFlushOnCommit (Pager *pPager, int bCommit)

static int	pager_end_transaction (Pager *pPager, int hasSuper, int bCommit)

static void	pagerUnlockAndRollback (Pager *pPager)

static u32	pager_cksum (Pager pPager, const u8 aData)

static int	pager_playback_one_page (Pager pPager, i64 pOffset, Bitvec *pDone, int isMainJrnl, int isSavepnt)

static int	pager_delsuper (Pager pPager, const char zSuper)

static void	setSectorSize (Pager *pPager)

static int	pager_playback (Pager *pPager, int isHot)

static int	readDbPage (PgHdr *pPg)

static void	pager_write_changecounter (PgHdr *pPg)

static int	pagerUndoCallback (void *pCtx, Pgno iPg)

static int	pagerRollbackWal (Pager *pPager)

static int	pagerWalFrames (Pager pPager, PgHdr pList, Pgno nTruncate, int isCommit)

static int	pagerBeginReadTransaction (Pager *pPager)

static int	pagerPagecount (Pager pPager, Pgno pnPage)

static int	pagerOpenWalIfPresent (Pager *pPager)

static int	pagerPlaybackSavepoint (Pager pPager, PagerSavepoint pSavepoint)

static void	pagerFixMaplimit (Pager *pPager)

static int	pagerOpentemp (Pager pPager, sqlite3_file pFile, int vfsFlags)

static int	pager_wait_on_lock (Pager *pPager, int locktype)

static int	pagerSyncHotJournal (Pager *pPager)

static void	pagerReleaseMapPage (PgHdr *pPg)

static void	pagerFreeMapHdrs (Pager *pPager)

static int	databaseIsUnmoved (Pager *pPager)

static int	syncJournal (Pager *pPager, int newHdr)

static int	pager_write_pagelist (Pager pPager, PgHdr pList)

static int	openSubJournal (Pager *pPager)

static int	subjournalPage (PgHdr *pPg)

static int	subjournalPageIfRequired (PgHdr *pPg)

static int	pagerStress (void p, PgHdr pPg)

static int	hasHotJournal (Pager pPager, int pExists)

static void	pagerUnlockIfUnused (Pager *pPager)

static int	pager_open_journal (Pager *pPager)

static SQLITE_NOINLINE int	pagerAddPageToRollbackJournal (PgHdr *pPg)

static int	pager_write (PgHdr *pPg)

static SQLITE_NOINLINE int	pagerWriteLargeSector (PgHdr *pPg)

static int	pager_incr_changecounter (Pager *pPager, int isDirectMode)

static SQLITE_NOINLINE int	pagerOpenSavepoint (Pager *pPager, int nSavepoint)

static int	pagerExclusiveLock (Pager *pPager)

static int	pagerOpenWal (Pager *pPager)

static SQLITE_NOINLINE int	walIndexPageRealloc (Wal pWal, int iPage, volatile u32 *ppPage)

static int	walIndexPage (Wal pWal, int iPage, volatile u32 *ppPage)

static volatile WalCkptInfo *	walCkptInfo (Wal *pWal)

static volatile WalIndexHdr *	walIndexHdr (Wal *pWal)

static void	walChecksumBytes (int nativeCksum, u8 a, int nByte, const u32 aIn, u32 *aOut)

static void	walShmBarrier (Wal *pWal)

static SQLITE_NO_TSAN void	walIndexWriteHdr (Wal *pWal)

static void	walEncodeFrame (Wal pWal, u32 iPage, u32 nTruncate, u8 aData, u8 *aFrame)

static int	walDecodeFrame (Wal pWal, u32 piPage, u32 pnTruncate, u8 aData, u8 *aFrame)

static int	walLockShared (Wal *pWal, int lockIdx)

static void	walUnlockShared (Wal *pWal, int lockIdx)

static int	walLockExclusive (Wal *pWal, int lockIdx, int n)

static void	walUnlockExclusive (Wal *pWal, int lockIdx, int n)

static int	walHash (u32 iPage)

static int	walNextHash (int iPriorHash)

static int	walHashGet (Wal pWal, int iHash, WalHashLoc pLoc)

static int	walFramePage (u32 iFrame)

static u32	walFramePgno (Wal *pWal, u32 iFrame)

static void	walCleanupHash (Wal *pWal)

static int	walIndexAppend (Wal *pWal, u32 iFrame, u32 iPage)

static int	walIndexRecover (Wal *pWal)

static void	walIndexClose (Wal *pWal, int isDelete)

static int	walIteratorNext (WalIterator p, u32 piPage, u32 *piFrame)

static void	walMerge (const u32 aContent, ht_slot aLeft, int nLeft, ht_slot *paRight, int pnRight, ht_slot *aTmp)

static void	walMergesort (const u32 aContent, ht_slot aBuffer, ht_slot aList, int pnList)

static void	walIteratorFree (WalIterator *p)

static int	walIteratorInit (Wal pWal, u32 nBackfill, WalIterator *pp)

static int	walBusyLock (Wal pWal, int(xBusy)(void ), void pBusyArg, int lockIdx, int n)

static int	walPagesize (Wal *pWal)

static void	walRestartHdr (Wal *pWal, u32 salt1)

static int	walCheckpoint (Wal pWal, sqlite3 db, int eMode, int(xBusy)(void ), void pBusyArg, int sync_flags, u8 zBuf)

static void	walLimitSize (Wal *pWal, i64 nMax)

static SQLITE_NO_TSAN int	walIndexTryHdr (Wal pWal, int pChanged)

static int	walIndexReadHdr (Wal pWal, int pChanged)

static int	walBeginShmUnreliable (Wal pWal, int pChanged)

static int	walTryBeginRead (Wal pWal, int pChanged, int useWal, int cnt)

static int	walRestartLog (Wal *pWal)

static int	walWriteToLog (WalWriter p, void pContent, int iAmt, sqlite3_int64 iOffset)

static int	walWriteOneFrame (WalWriter p, PgHdr pPage, int nTruncate, sqlite3_int64 iOffset)

static int	walRewriteChecksums (Wal *pWal, u32 iLast)

static void	lockBtreeMutex (Btree *p)

static void SQLITE_NOINLINE	unlockBtreeMutex (Btree *p)

static void SQLITE_NOINLINE	btreeLockCarefully (Btree *p)

static void SQLITE_NOINLINE	btreeEnterAll (sqlite3 *db)

static void SQLITE_NOINLINE	btreeLeaveAll (sqlite3 *db)

static int	querySharedCacheTableLock (Btree *p, Pgno iTab, u8 eLock)

static int	setSharedCacheTableLock (Btree *p, Pgno iTable, u8 eLock)

static void	clearAllSharedCacheTableLocks (Btree *p)

static void	downgradeAllSharedCacheTableLocks (Btree *p)

static void	releasePage (MemPage *pPage)

static void	releasePageOne (MemPage *pPage)

static void	releasePageNotNull (MemPage *pPage)

static void	invalidateAllOverflowCache (BtShared *pBt)

static void	invalidateIncrblobCursors (Btree *pBtree, Pgno pgnoRoot, i64 iRow, int isClearTable)

static int	btreeSetHasContent (BtShared *pBt, Pgno pgno)

static int	btreeGetHasContent (BtShared *pBt, Pgno pgno)

static void	btreeClearHasContent (BtShared *pBt)

static void	btreeReleaseAllCursorPages (BtCursor *pCur)

static int	saveCursorKey (BtCursor *pCur)

static int	saveCursorPosition (BtCursor *pCur)

static int SQLITE_NOINLINE	saveCursorsOnList (BtCursor , Pgno, BtCursor )

static int	saveAllCursors (BtShared pBt, Pgno iRoot, BtCursor pExcept)

static int	btreeMoveto (BtCursor pCur, const void pKey, i64 nKey, int bias, int *pRes)

static int	btreeRestoreCursorPosition (BtCursor *pCur)

static Pgno	ptrmapPageno (BtShared *pBt, Pgno pgno)

static void	ptrmapPut (BtShared pBt, Pgno key, u8 eType, Pgno parent, int pRC)

static int	ptrmapGet (BtShared pBt, Pgno key, u8 pEType, Pgno *pPgno)

static SQLITE_NOINLINE void	btreeParseCellAdjustSizeForOverflow (MemPage pPage, u8 pCell, CellInfo *pInfo)

static void	btreeParseCellPtrNoPayload (MemPage pPage, u8 pCell, CellInfo *pInfo)

static void	btreeParseCellPtr (MemPage pPage, u8 pCell, CellInfo *pInfo)

static void	btreeParseCellPtrIndex (MemPage pPage, u8 pCell, CellInfo *pInfo)

static void	btreeParseCell (MemPage pPage, int iCell, CellInfo pInfo)

static u16	cellSizePtr (MemPage pPage, u8 pCell)

static u16	cellSizePtrNoPayload (MemPage pPage, u8 pCell)

static void	ptrmapPutOvflPtr (MemPage pPage, MemPage pSrc, u8 pCell, int pRC)

static int	defragmentPage (MemPage *pPage, int nMaxFrag)

static u8 *	pageFindSlot (MemPage pPg, int nByte, int pRc)

static int	allocateSpace (MemPage pPage, int nByte, int pIdx)

static int	freeSpace (MemPage *pPage, u16 iStart, u16 iSize)

static int	decodeFlags (MemPage *pPage, int flagByte)

static int	btreeComputeFreeSpace (MemPage *pPage)

static SQLITE_NOINLINE int	btreeCellSizeCheck (MemPage *pPage)

static int	btreeInitPage (MemPage *pPage)

static void	zeroPage (MemPage *pPage, int flags)

static MemPage *	btreePageFromDbPage (DbPage pDbPage, Pgno pgno, BtShared pBt)

static int	btreeGetPage (BtShared pBt, Pgno pgno, MemPage *ppPage, int flags)

static MemPage *	btreePageLookup (BtShared *pBt, Pgno pgno)

static Pgno	btreePagecount (BtShared *pBt)

static int	getAndInitPage (BtShared pBt, Pgno pgno, MemPage ppPage, BtCursor pCur, int bReadOnly)

static int	btreeGetUnusedPage (BtShared pBt, Pgno pgno, MemPage *ppPage, int flags)

static void	pageReinit (DbPage *pData)

static int	btreeInvokeBusyHandler (void *pArg)

static int	removeFromSharingList (BtShared *pBt)

static void	allocateTempSpace (BtShared *pBt)

static void	freeTempSpace (BtShared *pBt)

static int	newDatabase (BtShared *)

static int	lockBtree (BtShared *pBt)

static void	unlockBtreeIfUnused (BtShared *pBt)

static int	setChildPtrmaps (MemPage *pPage)

static int	modifyPagePointer (MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType)

static int	relocatePage (BtShared pBt, MemPage pDbPage, u8 eType, Pgno iPtrPage, Pgno iFreePage, int isCommit)

static int	allocateBtreePage (BtShared , MemPage , Pgno , Pgno, u8)

static int	incrVacuumStep (BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit)

static Pgno	finalDbSize (BtShared *pBt, Pgno nOrig, Pgno nFree)

static int	autoVacuumCommit (BtShared *pBt)

static void	btreeEndTransaction (Btree *p)

static void	btreeSetNPage (BtShared pBt, MemPage pPage1)

static int	btreeCursor (Btree p, Pgno iTable, int wrFlag, struct KeyInfo pKeyInfo, BtCursor *pCur)

static int	btreeCursorWithLock (Btree p, Pgno iTable, int wrFlag, struct KeyInfo pKeyInfo, BtCursor *pCur)

static SQLITE_NOINLINE void	getCellInfo (BtCursor *pCur)

static int	getOverflowPage (BtShared pBt, Pgno ovfl, MemPage ppPage, Pgno pPgnoNext)

static int	copyPayload (void pPayload, void pBuf, int nByte, int eOp, DbPage *pDbPage)

static int	accessPayload (BtCursor pCur, u32 offset, u32 amt, unsigned char pBuf, int eOp)

static SQLITE_NOINLINE int	accessPayloadChecked (BtCursor pCur, u32 offset, u32 amt, void pBuf)

static const void *	fetchPayload (BtCursor pCur, u32 pAmt)

static int	moveToChild (BtCursor *pCur, u32 newPgno)

static void	moveToParent (BtCursor *pCur)

static int	moveToRoot (BtCursor *pCur)

static int	moveToLeftmost (BtCursor *pCur)

static int	moveToRightmost (BtCursor *pCur)

static SQLITE_NOINLINE int	btreeNext (BtCursor *pCur)

static SQLITE_NOINLINE int	btreePrevious (BtCursor *pCur)

static int	freePage2 (BtShared pBt, MemPage pMemPage, Pgno iPage)

static void	freePage (MemPage pPage, int pRC)

static int	clearCell (MemPage pPage, unsigned char pCell, CellInfo *pInfo)

static int	fillInCell (MemPage pPage, unsigned char pCell, const BtreePayload pX, int pnSize)

static void	dropCell (MemPage pPage, int idx, int sz, int pRC)

static void	insertCell (MemPage pPage, int i, u8 pCell, int sz, u8 pTemp, Pgno iChild, int pRC)

static void	populateCellCache (CellArray *p, int idx, int N)

static SQLITE_NOINLINE u16	computeCellSize (CellArray *p, int N)

static u16	cachedCellSize (CellArray *p, int N)

static int	rebuildPage (CellArray pCArray, int iFirst, int nCell, MemPage pPg)

static int	pageInsertArray (MemPage pPg, u8 pBegin, u8 *ppData, u8 pCellptr, int iFirst, int nCell, CellArray *pCArray)

static int	pageFreeArray (MemPage pPg, int iFirst, int nCell, CellArray pCArray)

static int	editPage (MemPage pPg, int iOld, int iNew, int nNew, CellArray pCArray)

static int	balance_quick (MemPage pParent, MemPage pPage, u8 *pSpace)

static void	copyNodeContent (MemPage pFrom, MemPage pTo, int *pRC)

static int	balance_nonroot (MemPage pParent, int iParentIdx, u8 aOvflSpace, int isRoot, int bBulk)

static int	balance_deeper (MemPage pRoot, MemPage *ppChild)

static int	anotherValidCursor (BtCursor *pCur)

static int	balance (BtCursor *pCur)

static int	btreeOverwriteContent (MemPage pPage, u8 pDest, const BtreePayload *pX, int iOffset, int iAmt)

static int	btreeOverwriteCell (BtCursor pCur, const BtreePayload pX)

static int	btreeCreateTable (Btree p, Pgno piTable, int createTabFlags)

static int	clearDatabasePage (BtShared pBt, Pgno pgno, int freePageFlag, int pnChange)

static int	btreeDropTable (Btree p, Pgno iTable, int piMoved)

static void	checkAppendMsg (IntegrityCk pCheck, const char zFormat,...)

static int	getPageReferenced (IntegrityCk *pCheck, Pgno iPg)

static void	setPageReferenced (IntegrityCk *pCheck, Pgno iPg)

static int	checkRef (IntegrityCk *pCheck, Pgno iPage)

static void	checkPtrmap (IntegrityCk *pCheck, Pgno iChild, u8 eType, Pgno iParent)

static void	checkList (IntegrityCk *pCheck, int isFreeList, Pgno iPage, u32 N)

static void	btreeHeapInsert (u32 *aHeap, u32 x)

static int	btreeHeapPull (u32 aHeap, u32 pOut)

static int	checkTreePage (IntegrityCk pCheck, Pgno iPage, i64 piMinKey, i64 maxKey)

static Btree *	findBtree (sqlite3 pErrorDb, sqlite3 pDb, const char *zDb)

static int	setDestPgsz (sqlite3_backup *p)

static int	checkReadTransaction (sqlite3 db, Btree p)

static int	isFatalError (int rc)

static int	backupOnePage (sqlite3_backup p, Pgno iSrcPg, const u8 zSrcData, int bUpdate)

static int	backupTruncateFile (sqlite3_file *pFile, i64 iSize)

static void	attachBackupObject (sqlite3_backup *p)

static SQLITE_NOINLINE void	backupUpdate (sqlite3_backup p, Pgno iPage, const u8 aData)

static void	vdbeMemRenderNum (int sz, char zBuf, Mem p)

static SQLITE_NOINLINE int	vdbeMemAddTerminator (Mem *pMem)

static SQLITE_NOINLINE void	vdbeMemClearExternAndSetNull (Mem *p)

static SQLITE_NOINLINE void	vdbeMemClear (Mem *p)

static SQLITE_NOINLINE i64	doubleToInt64 (double r)

static SQLITE_NOINLINE i64	memIntValue (Mem *pMem)

static SQLITE_NOINLINE double	memRealValue (Mem *pMem)

static SQLITE_NOINLINE void	vdbeReleaseAndSetInt64 (Mem *pMem, i64 val)

static SQLITE_NOINLINE void	vdbeClrCopy (Mem pTo, const Mem pFrom, int eType)

static SQLITE_NOINLINE const void *	valueToText (sqlite3_value *pVal, u8 enc)

static sqlite3_value *	valueNew (sqlite3 db, struct ValueNewStat4Ctx p)

static int	valueFromExpr (sqlite3 db, Expr pExpr, u8 enc, u8 affinity, sqlite3_value *ppVal, struct ValueNewStat4Ctx pCtx)

static SQLITE_NOINLINE int	valueBytes (sqlite3_value *pVal, u8 enc)

static void	freeEphemeralFunction (sqlite3 db, FuncDef pDef)

static void	vdbeFreeOpArray (sqlite3 , Op , int)

static int	growOpArray (Vdbe *v, int nOp)

static SQLITE_NOINLINE int	growOp3 (Vdbe *p, int op, int p1, int p2, int p3)

static SQLITE_NOINLINE void	resizeResolveLabel (Parse p, Vdbe v, int j)

static void	resolveP2Values (Vdbe p, int pMaxFuncArgs)

static SQLITE_NOINLINE void	freeP4Mem (sqlite3 db, Mem p)

static SQLITE_NOINLINE void	freeP4FuncCtx (sqlite3 db, sqlite3_context p)

static void	freeP4 (sqlite3 db, int p4type, void p4)

static void SQLITE_NOINLINE	vdbeChangeP4Full (Vdbe p, Op pOp, const char *zP4, int n)

static SQLITE_NOINLINE void	vdbeLeave (Vdbe *p)

static void	initMemArray (Mem p, int N, sqlite3 db, u16 flags)

static void	releaseMemArray (Mem *p, int N)

static void *	allocSpace (struct ReusableSpace p, void pBuf, sqlite3_int64 nByte)

static void	closeCursorsInFrame (Vdbe *p)

static void	closeAllCursors (Vdbe *p)

static int	vdbeCommit (sqlite3 db, Vdbe p)

static SQLITE_NOINLINE int	vdbeCloseStatement (Vdbe *p, int eOp)

static int SQLITE_NOINLINE	handleMovedCursor (VdbeCursor *p)

SQLITE_PRIVATE u32	sqlite3VdbeSerialPut (u8 buf, Mem pMem, u32 serial_type)

static u32	serialGet (const unsigned char buf, u32 serial_type, Mem pMem)

static int	vdbeCompareMemString (const Mem pMem1, const Mem pMem2, const CollSeq pColl, u8 prcErr)

static int	isAllZero (const char *z, int n)

static int	sqlite3IntFloatCompare (i64 i, double r)

static i64	vdbeRecordDecodeInt (u32 serial_type, const u8 *aKey)

static int	vdbeRecordCompareInt (int nKey1, const void pKey1, UnpackedRecord pPKey2)

static int	vdbeRecordCompareString (int nKey1, const void pKey1, UnpackedRecord pPKey2)

static int	vdbeSafety (Vdbe *p)

static int	vdbeSafetyNotNull (Vdbe *p)

static SQLITE_NOINLINE void	invokeProfileCallback (sqlite3 db, Vdbe p)

static void	setResultStrOrError (sqlite3_context pCtx, const char z, int n, u8 enc, void(xDel)(void ))

static int	invokeValueDestructor (const void p, void(xDel)(void ), sqlite3_context pCtx)

static int	doWalCallbacks (sqlite3 *db)

static int	sqlite3Step (Vdbe *p)

static SQLITE_NOINLINE void *	createAggContext (sqlite3_context *p, int nByte)

static const Mem *	columnNullValue (void)

static Mem *	columnMem (sqlite3_stmt *pStmt, int i)

static void	columnMallocFailure (sqlite3_stmt *pStmt)

static const void *	columnName (sqlite3_stmt *pStmt, int N, int useUtf16, int useType)

static int	vdbeUnbind (Vdbe *p, int i)

static int	bindText (sqlite3_stmt pStmt, int i, const void zData, int nData, void(xDel)(void ), u8 encoding)

static int	findNextHostParameter (const char zSql, int pnToken)

static VdbeCursor *	allocateCursor (Vdbe *p, int iCur, int nField, int iDb, u8 eCurType)

static int	alsoAnInt (Mem pRec, double rValue, i64 piValue)

static void	applyNumericAffinity (Mem *pRec, int bTryForInt)

static void	applyAffinity (Mem *pRec, char affinity, u8 enc)

static u16 SQLITE_NOINLINE	computeNumericType (Mem *pMem)

static u16	numericType (Mem *pMem)

static SQLITE_NOINLINE Mem *	out2PrereleaseWithClear (Mem *pOut)

static Mem *	out2Prerelease (Vdbe p, VdbeOp pOp)

static int	blobSeekToRow (Incrblob p, sqlite3_int64 iRow, char *pzErr)

static int	blobReadWrite (sqlite3_blob pBlob, void z, int n, int iOffset, int(xCall)(BtCursor , u32, u32, void *))

static int	vdbeIncrSwap (IncrMerger *)

static void	vdbeIncrFree (IncrMerger *)

static void	vdbePmaReaderClear (PmaReader *pReadr)

static int	vdbePmaReadBlob (PmaReader p, int nByte, u8 *ppOut)

static int	vdbePmaReadVarint (PmaReader p, u64 pnOut)

static int	vdbeSorterMapFile (SortSubtask pTask, SorterFile pFile, u8 **pp)

static int	vdbePmaReaderSeek (SortSubtask pTask, PmaReader pReadr, SorterFile *pFile, i64 iOff)

static int	vdbePmaReaderNext (PmaReader *pReadr)

static int	vdbePmaReaderInit (SortSubtask pTask, SorterFile pFile, i64 iStart, PmaReader pReadr, i64 pnByte)

static int	vdbeSorterCompareTail (SortSubtask pTask, int pbKey2Cached, const void pKey1, int nKey1, const void pKey2, int nKey2)

static int	vdbeSorterCompare (SortSubtask pTask, int pbKey2Cached, const void pKey1, int nKey1, const void pKey2, int nKey2)

static int	vdbeSorterCompareText (SortSubtask pTask, int pbKey2Cached, const void pKey1, int nKey1, const void pKey2, int nKey2)

static int	vdbeSorterCompareInt (SortSubtask pTask, int pbKey2Cached, const void pKey1, int nKey1, const void pKey2, int nKey2)

static void	vdbeSorterRecordFree (sqlite3 db, SorterRecord pRecord)

static void	vdbeSortSubtaskCleanup (sqlite3 db, SortSubtask pTask)

static int	vdbeSorterJoinThread (SortSubtask *pTask)

static int	vdbeSorterCreateThread (SortSubtask pTask, void (xTask)(void ), void *pIn)

static int	vdbeSorterJoinAll (VdbeSorter *pSorter, int rcin)

static MergeEngine *	vdbeMergeEngineNew (int nReader)

static void	vdbeMergeEngineFree (MergeEngine *pMerger)

static int	vdbeSorterOpenTempFile (sqlite3 db, i64 nExtend, sqlite3_file *ppFd)

static int	vdbeSortAllocUnpacked (SortSubtask *pTask)

static SorterRecord *	vdbeSorterMerge (SortSubtask pTask, SorterRecord p1, SorterRecord *p2)

static SorterCompare	vdbeSorterGetCompare (VdbeSorter *p)

static int	vdbeSorterSort (SortSubtask pTask, SorterList pList)

static void	vdbePmaWriterInit (sqlite3_file pFd, PmaWriter p, int nBuf, i64 iStart)

static void	vdbePmaWriteBlob (PmaWriter p, u8 pData, int nData)

static int	vdbePmaWriterFinish (PmaWriter p, i64 piEof)

static void	vdbePmaWriteVarint (PmaWriter *p, u64 iVal)

static int	vdbeSorterListToPMA (SortSubtask pTask, SorterList pList)

static int	vdbeMergeEngineStep (MergeEngine pMerger, int pbEof)

static void *	vdbeSorterFlushThread (void *pCtx)

static int	vdbeSorterFlushPMA (VdbeSorter *pSorter)

static int	vdbeIncrPopulate (IncrMerger *pIncr)

static void *	vdbeIncrPopulateThread (void *pCtx)

static int	vdbeIncrBgPopulate (IncrMerger *pIncr)

static int	vdbeIncrMergerNew (SortSubtask pTask, MergeEngine pMerger, IncrMerger **ppOut)

static void	vdbeIncrMergerSetThreads (IncrMerger *pIncr)

static void	vdbeMergeEngineCompare (MergeEngine *pMerger, int iOut)

static int	vdbePmaReaderIncrInit (PmaReader *pReadr, int eMode)

static int	vdbeMergeEngineInit (SortSubtask pTask, MergeEngine pMerger, int eMode)

static int	vdbePmaReaderIncrMergeInit (PmaReader *pReadr, int eMode)

static void *	vdbePmaReaderBgIncrInit (void *pCtx)

static int	vdbeMergeEngineLevel0 (SortSubtask pTask, int nPMA, i64 piOffset, MergeEngine **ppOut)

static int	vdbeSorterTreeDepth (int nPMA)

static int	vdbeSorterAddToTree (SortSubtask pTask, int nDepth, int iSeq, MergeEngine pRoot, MergeEngine *pLeaf)

static int	vdbeSorterMergeTreeBuild (VdbeSorter pSorter, MergeEngine *ppOut)

static int	vdbeSorterSetupMerge (VdbeSorter *pSorter)

static void *	vdbeSorterRowkey (const VdbeSorter pSorter, int pnKey)

static int	memjrnlRead (sqlite3_file pJfd, void zBuf, int iAmt, sqlite_int64 iOfst)

static void	memjrnlFreeChunks (MemJournal *p)

static int	memjrnlCreateFile (MemJournal *p)

static int	memjrnlWrite (sqlite3_file pJfd, const void zBuf, int iAmt, sqlite_int64 iOfst)

static int	memjrnlTruncate (sqlite3_file *pJfd, sqlite_int64 size)

static int	memjrnlClose (sqlite3_file *pJfd)

static int	memjrnlSync (sqlite3_file *pJfd, int flags)

static int	memjrnlFileSize (sqlite3_file pJfd, sqlite_int64 pSize)

static int	walkWindowList (Walker pWalker, Window pList)

static SQLITE_NOINLINE int	walkExpr (Walker pWalker, Expr pExpr)

static int	incrAggDepth (Walker pWalker, Expr pExpr)

static void	incrAggFunctionDepth (Expr *pExpr, int N)

static void	resolveAlias (Parse pParse, ExprList pEList, int iCol, Expr pExpr, const char zType, int nSubquery)

static int	nameInUsingClause (IdList pUsing, const char zCol)

static int	areDoubleQuotedStringsEnabled (sqlite3 db, NameContext pTopNC)

static int	lookupName (Parse pParse, const char zDb, const char zTab, const char zCol, NameContext pNC, Expr pExpr)

static void	notValidImpl (Parse pParse, NameContext pNC, const char zMsg, Expr pExpr)

static int	exprProbability (Expr *p)

static int	resolveExprStep (Walker pWalker, Expr pExpr)

static int	resolveAsName (Parse pParse, ExprList pEList, Expr *pE)

static int	resolveOrderByTermToExprList (Parse pParse, Select pSelect, Expr *pE)

static void	resolveOutOfRangeError (Parse pParse, const char zType, int i, int mx)

static int	resolveCompoundOrderBy (Parse pParse, Select pSelect)

static int	resolveRemoveWindowsCb (Walker pWalker, Expr pExpr)

static void	windowRemoveExprFromSelect (Select pSelect, Expr pExpr)

static int	resolveOrderGroupBy (NameContext pNC, Select pSelect, ExprList pOrderBy, const char zType)

static int	resolveSelectStep (Walker pWalker, Select p)

static void	exprCodeBetween (Parse , Expr , int, void()(Parse , Expr *, int, int), int)

static int	exprCodeVector (Parse pParse, Expr p, int *piToFree)

static char	comparisonAffinity (const Expr *pExpr)

static u8	binaryCompareP5 (const Expr pExpr1, const Expr pExpr2, int jumpIfNull)

static int	codeCompare (Parse pParse, Expr pLeft, Expr *pRight, int opcode, int in1, int in2, int dest, int jumpIfNull, int isCommuted)

static int	exprCodeSubselect (Parse pParse, Expr pExpr)

static int	exprVectorRegister (Parse pParse, Expr pVector, int iField, int regSelect, Expr *ppExpr, int pRegFree)

static void	codeVectorCompare (Parse pParse, Expr pExpr, int dest, u8 op, u8 p5)

static void	heightOfExpr (Expr p, int pnHeight)

static void	heightOfExprList (ExprList p, int pnHeight)

static void	heightOfSelect (Select pSelect, int pnHeight)

static void	exprSetHeight (Expr *p)

static SQLITE_NOINLINE void	sqlite3ExprDeleteNN (sqlite3 db, Expr p)

static int	exprStructSize (Expr *p)

static int	dupedExprStructSize (Expr *p, int flags)

static int	dupedExprNodeSize (Expr *p, int flags)

static int	dupedExprSize (Expr *p, int flags)

static Expr *	exprDup (sqlite3 db, Expr p, int dupFlags, u8 **pzBuffer)

static With *	withDup (sqlite3 db, With p)

static int	gatherSelectWindowsCallback (Walker pWalker, Expr pExpr)

static int	gatherSelectWindowsSelectCallback (Walker pWalker, Select p)

static void	gatherSelectWindows (Select *p)

static SQLITE_NOINLINE void	exprListDeleteNN (sqlite3 db, ExprList pList)

static int	exprNodeIsConstant (Walker pWalker, Expr pExpr)

static int	exprIsConst (Expr *p, int initFlag, int iCur)

static int	exprNodeIsConstantOrGroupBy (Walker pWalker, Expr pExpr)

static Select *	isCandidateForInOpt (Expr *pX)

static void	sqlite3SetHasNullFlag (Vdbe *v, int iCur, int regHasNull)

static int	sqlite3InRhsIsConstant (Expr *pIn)

static char *	exprINAffinity (Parse pParse, Expr pExpr)

SQLITE_PRIVATE void	sqlite3SubselectError (Parse *pParse, int nActual, int nExpect)

static void	sqlite3ExprCodeIN (Parse pParse, Expr pExpr, int destIfFalse, int destIfNull)

static void	codeReal (Vdbe v, const char z, int negateFlag, int iMem)

static void	codeInteger (Parse pParse, Expr pExpr, int negFlag, int iMem)

static void	exprToRegister (Expr *pExpr, int iReg)

static void	setDoNotMergeFlagOnCopy (Vdbe *v)

static int	exprCodeInlineFunction (Parse pParse, ExprList pFarg, int iFuncId, int target)

static int	exprCompareVariable (Parse pParse, Expr pVar, Expr *pExpr)

static int	exprImpliesNotNull (Parse pParse, Expr p, Expr *pNN, int iTab, int seenNot)

static int	impliesNotNullRow (Walker pWalker, Expr pExpr)

static int	exprIdxCover (Walker pWalker, Expr pExpr)

static int	selectSrcCount (Walker pWalker, Select pSel)

static int	exprSrcCount (Walker pWalker, Expr pExpr)

static int	agginfoPersistExprCb (Walker pWalker, Expr pExpr)

static int	addAggInfoColumn (sqlite3 db, AggInfo pInfo)

static int	addAggInfoFunc (sqlite3 db, AggInfo pInfo)

static int	analyzeAggregate (Walker pWalker, Expr pExpr)

static int	isAlterableTable (Parse pParse, Table pTab)

static void	renameTestSchema (Parse pParse, const char zDb, int bTemp)

static void	renameReloadSchema (Parse *pParse, int iDb)

static void	sqlite3ErrorIfNotEmpty (Parse pParse, const char zDb, const char zTab, const char zErr)

static int	isRealTable (Parse pParse, Table pTab)

static int	renameUnmapExprCb (Walker pWalker, Expr pExpr)

static void	renameWalkWith (Walker pWalker, Select pSelect)

static void	unmapColumnIdlistNames (Parse pParse, IdList pIdList)

static int	renameUnmapSelectCb (Walker pWalker, Select p)

static void	renameTokenFree (sqlite3 db, RenameToken pToken)

static void	renameTokenFind (Parse pParse, struct RenameCtx pCtx, void *pPtr)

static int	renameColumnSelectCb (Walker pWalker, Select p)

static int	renameColumnExprCb (Walker pWalker, Expr pExpr)

static RenameToken *	renameColumnTokenNext (RenameCtx *pCtx)

static void	renameColumnParseError (sqlite3_context pCtx, int bPost, sqlite3_value pType, sqlite3_value pObject, Parse pParse)

static void	renameColumnElistNames (Parse pParse, RenameCtx pCtx, ExprList pEList, const char zOld)

static void	renameColumnIdlistNames (Parse pParse, RenameCtx pCtx, IdList pIdList, const char zOld)

static int	renameParseSql (Parse p, const char zDb, sqlite3 db, const char zSql, int bTemp)

static int	renameEditSql (sqlite3_context pCtx, RenameCtx pRename, const char zSql, const char zNew, int bQuote)

static int	renameResolveTrigger (Parse *pParse)

static void	renameWalkTrigger (Walker pWalker, Trigger pTrigger)

static void	renameParseCleanup (Parse *pParse)

static void	renameColumnFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static int	renameTableExprCb (Walker pWalker, Expr pExpr)

static int	renameTableSelectCb (Walker pWalker, Select pSelect)

static void	renameTableFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	renameTableTest (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	openStatTable (Parse pParse, int iDb, int iStatCur, const char zWhere, const char *zWhereType)

static void	statAccumDestructor (void *pOld)

static void	statInit (sqlite3_context context, int argc, sqlite3_value *argv)

static void	statPush (sqlite3_context context, int argc, sqlite3_value *argv)

static void	statGet (sqlite3_context context, int argc, sqlite3_value *argv)

static void	callStatGet (Parse *pParse, int regStat, int iParam, int regOut)

static void	analyzeOneTable (Parse pParse, Table pTab, Index *pOnlyIdx, int iStatCur, int iMem, int iTab)

static void	loadAnalysis (Parse *pParse, int iDb)

static void	analyzeDatabase (Parse *pParse, int iDb)

static void	analyzeTable (Parse pParse, Table pTab, Index *pOnlyIdx)

static void	decodeIntArray (char zIntArray, int nOut, tRowcnt aOut, LogEst aLog, Index pIndex)

static int	analysisLoader (void pData, int argc, char argv, char *NotUsed)

static int	resolveAttachExpr (NameContext pName, Expr pExpr)

static void	attachFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	detachFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	codeAttach (Parse pParse, int type, FuncDef const pFunc, Expr pAuthArg, Expr pFilename, Expr pDbname, Expr pKey)

static void	sqliteAuthBadReturnCode (Parse *pParse)

static void	codeTableLocks (Parse *pParse)

static void SQLITE_NOINLINE	deleteTable (sqlite3 db, Table pTable)

static void	sqlite3StringToId (Expr *p)

static void	makeColumnPartOfPrimaryKey (Parse pParse, Column pCol)

static int	identLength (const char *z)

static void	identPut (char z, int pIdx, char *zSignedIdent)

static char *	createTableStmt (sqlite3 db, Table p)

static int	resizeIndexObject (sqlite3 db, Index pIdx, int N)

static void	estimateTableWidth (Table *pTab)

static void	estimateIndexWidth (Index *pIdx)

static int	hasColumn (const i16 *aiCol, int nCol, int x)

static int	isDupColumn (Index pIdx, int nKey, Index pPk, int iCol)

static void	recomputeColumnsNotIndexed (Index *pIdx)

static void	convertToWithoutRowidTable (Parse pParse, Table pTab)

static void	sqliteViewResetAll (sqlite3 *db, int idx)

static void	destroyRootPage (Parse *pParse, int iTable, int iDb)

static void	destroyTable (Parse pParse, Table pTab)

static void	sqlite3ClearStatTables (Parse pParse, int iDb, const char zType, const char *zName)

static int	tableMayNotBeDropped (sqlite3 db, Table pTab)

static void	sqlite3RefillIndex (Parse pParse, Index pIndex, int memRootPage)

static int	collationMatch (const char zColl, Index pIndex)

static void	reindexTable (Parse pParse, Table pTab, char const *zColl)

static void	reindexDatabases (Parse pParse, char const zColl)

static void	callCollNeeded (sqlite3 db, int enc, const char zName)

static int	synthCollSeq (sqlite3 db, CollSeq pColl)

static CollSeq *	findCollSeqEntry (sqlite3 db, const char zName, int create)

static int	matchQuality (FuncDef *p, int nArg, u8 enc)

static int	tabIsReadOnly (Parse pParse, Table pTab)

static CollSeq *	sqlite3GetFuncCollSeq (sqlite3_context *context)

static void	sqlite3SkipAccumulatorLoad (sqlite3_context *context)

static void	minmaxFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	typeofFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	lengthFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	absFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	instrFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	printfFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	substrFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	roundFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void *	contextMalloc (sqlite3_context *context, i64 nByte)

static void	upperFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	lowerFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	randomFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	randomBlob (sqlite3_context context, int argc, sqlite3_value *argv)

static void	last_insert_rowid (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	changes (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	total_changes (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static int	patternCompare (const u8 zPattern, const u8 zString, const struct compareInfo *pInfo, u32 matchOther)

static void	likeFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	nullifFunc (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	versionFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	sourceidFunc (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static void	errlogFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	compileoptionusedFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	compileoptiongetFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	quoteFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	unicodeFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	charFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	hexFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	zeroblobFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	replaceFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	trimFunc (sqlite3_context context, int argc, sqlite3_value *argv)

static void	loadExt (sqlite3_context context, int argc, sqlite3_value *argv)

static void	sumStep (sqlite3_context context, int argc, sqlite3_value *argv)

static void	sumInverse (sqlite3_context context, int argc, sqlite3_value *argv)

static void	sumFinalize (sqlite3_context *context)

static void	avgFinalize (sqlite3_context *context)

static void	totalFinalize (sqlite3_context *context)

static void	countStep (sqlite3_context context, int argc, sqlite3_value *argv)

static void	countFinalize (sqlite3_context *context)

static void	countInverse (sqlite3_context ctx, int argc, sqlite3_value *argv)

static void	minmaxStep (sqlite3_context context, int NotUsed, sqlite3_value *argv)

static void	minMaxValueFinalize (sqlite3_context *context, int bValue)

static void	minMaxValue (sqlite3_context *context)

static void	minMaxFinalize (sqlite3_context *context)

static void	groupConcatStep (sqlite3_context context, int argc, sqlite3_value *argv)

static void	groupConcatInverse (sqlite3_context context, int argc, sqlite3_value *argv)

static void	groupConcatFinalize (sqlite3_context *context)

static void	groupConcatValue (sqlite3_context *context)

static void	fkLookupParent (Parse pParse, int iDb, Table pTab, Index pIdx, FKey pFKey, int *aiCol, int regData, int nIncr, int isIgnore)

static Expr *	exprTableRegister (Parse pParse, Table pTab, int regBase, i16 iCol)

static Expr *	exprTableColumn (sqlite3 db, Table pTab, int iCursor, i16 iCol)

static void	fkScanChildren (Parse pParse, SrcList pSrc, Table pTab, Index pIdx, FKey pFKey, int aiCol, int regData, int nIncr)

static void	fkTriggerDelete (sqlite3 dbMem, Trigger p)

static int	fkChildIsModified (Table pTab, FKey p, int *aChange, int bChngRowid)

static int	fkParentIsModified (Table pTab, FKey p, int *aChange, int bChngRowid)

static int	isSetNullAction (Parse pParse, FKey pFKey)

static Trigger *	fkActionTrigger (Parse pParse, Table pTab, FKey pFKey, ExprList pChanges)

static int	readsTable (Parse p, int iDb, Table pTab)

static int	exprColumnFlagUnion (Walker pWalker, Expr pExpr)

static int	autoIncBegin (Parse pParse, int iDb, Table pTab)

static void	autoIncStep (Parse *pParse, int memId, int regRowid)

static SQLITE_NOINLINE void	autoIncrementEnd (Parse *pParse)

static int	xferOptimization (Parse pParse, Table pDest, Select *pSelect, int onError, int iDbDest)

static int	checkConstraintExprNode (Walker pWalker, Expr pExpr)

static int	xferCompatibleIndex (Index pDest, Index pSrc)

static int	sqlite3LoadExtension (sqlite3 db, const char zFile, const char zProc, char *pzErrMsg)

static u8	getSafetyLevel (const char *z, int omitFull, u8 dflt)

static int	getLockingMode (const char *z)

static int	getAutoVacuum (const char *z)

static int	getTempStore (const char *z)

static int	invalidateTempStorage (Parse *pParse)

static int	changeTempStorage (Parse pParse, const char zStorageType)

static void	setPragmaResultColumnNames (Vdbe v, const PragmaName pPragma)

static void	returnSingleInt (Vdbe *v, i64 value)

static void	returnSingleText (Vdbe v, const char zValue)

static void	setAllPagerFlags (sqlite3 *db)

static const char *	actionName (u8 action)

static const PragmaName *	pragmaLocate (const char *zName)

static void	pragmaFunclistLine (Vdbe v, FuncDef p, int isBuiltin, int showInternFuncs)

static int	integrityCheckResultRow (Vdbe *v)

static int	pragmaVtabConnect (sqlite3 db, void pAux, int argc, const char const argv, sqlite3_vtab ppVtab, char pzErr)

static int	pragmaVtabDisconnect (sqlite3_vtab *pVtab)

static int	pragmaVtabBestIndex (sqlite3_vtab tab, sqlite3_index_info pIdxInfo)

static int	pragmaVtabOpen (sqlite3_vtab pVtab, sqlite3_vtab_cursor *ppCursor)

static void	pragmaVtabCursorClear (PragmaVtabCursor *pCsr)

static int	pragmaVtabClose (sqlite3_vtab_cursor *cur)

static int	pragmaVtabNext (sqlite3_vtab_cursor *pVtabCursor)

static int	pragmaVtabFilter (sqlite3_vtab_cursor pVtabCursor, int idxNum, const char idxStr, int argc, sqlite3_value **argv)

static int	pragmaVtabEof (sqlite3_vtab_cursor *pVtabCursor)

static int	pragmaVtabColumn (sqlite3_vtab_cursor pVtabCursor, sqlite3_context ctx, int i)

static int	pragmaVtabRowid (sqlite3_vtab_cursor pVtabCursor, sqlite_int64 p)

static void	corruptSchema (InitData pData, const char zObj, const char *zExtra)

static int	sqlite3Prepare (sqlite3 db, const char zSql, int nBytes, u32 prepFlags, Vdbe pReprepare, sqlite3_stmt ppStmt, const char *pzTail)

static void	schemaIsValid (Parse *pParse)

static void	agginfoFree (sqlite3 db, AggInfo p)

static int	sqlite3LockAndPrepare (sqlite3 db, const char zSql, int nBytes, u32 prepFlags, Vdbe pOld, sqlite3_stmt ppStmt, const char *pzTail)

static int	sqlite3Prepare16 (sqlite3 db, const void zSql, int nBytes, u32 prepFlags, sqlite3_stmt ppStmt, const void pzTail)

static void	clearSelect (sqlite3 db, Select p, int bFree)

static Select *	findRightmost (Select *p)

static int	columnIndex (Table pTab, const char zCol)

static int	tableAndColumnIndex (SrcList pSrc, int N, const char zCol, int piTab, int piCol, int bIgnoreHidden)

static void	addWhereTerm (Parse pParse, SrcList pSrc, int iLeft, int iColLeft, int iRight, int iColRight, int isOuterJoin, Expr **ppWhere)

static void	unsetJoinExpr (Expr *p, int iTable)

static int	sqliteProcessJoin (Parse pParse, Select p)

static void	innerLoopLoadRow (Parse pParse, Select pSelect, RowLoadInfo *pInfo)

static int	makeSorterRecord (Parse pParse, SortCtx pSort, Select *pSelect, int regBase, int nBase)

static void	pushOntoSorter (Parse pParse, SortCtx pSort, Select *pSelect, int regData, int regOrigData, int nData, int nPrefixReg)

static void	codeOffset (Vdbe *v, int iOffset, int iContinue)

static void	codeDistinct (Parse *pParse, int iTab, int addrRepeat, int N, int iMem)

static void	selectInnerLoop (Parse pParse, Select p, int srcTab, SortCtx pSort, DistinctCtx pDistinct, SelectDest *pDest, int iContinue, int iBreak)

static const char *	selectOpName (int id)

static void	explainTempTable (Parse pParse, const char zUsage)

static void	generateSortTail (Parse pParse, Select p, SortCtx pSort, int nColumn, SelectDest pDest)

static const char *	columnTypeImpl (NameContext pNC, Expr pExpr)

static void	generateColumnTypes (Parse pParse, SrcList pTabList, ExprList *pEList)

static void	generateColumnNames (Parse pParse, Select pSelect)

static void	computeLimitRegisters (Parse pParse, Select p, int iBreak)

static CollSeq *	multiSelectCollSeq (Parse pParse, Select p, int iCol)

static KeyInfo *	multiSelectOrderByKeyInfo (Parse pParse, Select p, int nExtra)

static void	generateWithRecursiveQuery (Parse pParse, Select p, SelectDest *pDest)

static int	multiSelectOrderBy (Parse pParse, Select p, SelectDest *pDest)

static int	multiSelectValues (Parse pParse, Select p, SelectDest *pDest)

static int	multiSelect (Parse pParse, Select p, SelectDest *pDest)

static int	generateOutputSubroutine (Parse pParse, Select p, SelectDest pIn, SelectDest pDest, int regReturn, int regPrev, KeyInfo *pKeyInfo, int iBreak)

static void	substExprList (SubstContext , ExprList )

static void	substSelect (SubstContext , Select , int)

static Expr *	substExpr (SubstContext pSubst, Expr pExpr)

static int	recomputeColumnsUsedExpr (Walker pWalker, Expr pExpr)

static void	recomputeColumnsUsed (Select pSelect, struct SrcList_item pSrcItem)

static int	flattenSubquery (Parse pParse, Select p, int iFrom, int isAgg)

static void	constInsert (WhereConst pConst, Expr pColumn, Expr pValue, Expr pExpr)

static void	findConstInWhere (WhereConst pConst, Expr pExpr)

static int	propagateConstantExprRewrite (Walker pWalker, Expr pExpr)

static int	propagateConstants (Parse pParse, Select p)

static int	pushDownWhereTerms (Parse pParse, Select pSubq, Expr *pWhere, int iCursor, int isLeftJoin)

static u8	minMaxQuery (sqlite3 db, Expr pFunc, ExprList **ppMinMax)

static Table *	isSimpleCount (Select p, AggInfo pAggInfo)

static int	convertCompoundSelectToSubquery (Walker pWalker, Select p)

static int	cannotBeFunction (Parse pParse, struct SrcList_item pFrom)

static struct Cte *	searchWith (With pWith, struct SrcList_item pItem, With **ppContext)

static int	withExpand (Walker pWalker, struct SrcList_item pFrom)

static void	selectPopWith (Walker pWalker, Select p)

static int	selectExpander (Walker pWalker, Select p)

static void	sqlite3SelectExpand (Parse pParse, Select pSelect)

static void	selectAddSubqueryTypeInfo (Walker pWalker, Select p)

static void	sqlite3SelectAddTypeInfo (Parse pParse, Select pSelect)

static void	resetAccumulator (Parse pParse, AggInfo pAggInfo)

static void	finalizeAggFunctions (Parse pParse, AggInfo pAggInfo)

static void	updateAccumulator (Parse pParse, int regAcc, AggInfo pAggInfo)

static void	explainSimpleCount (Parse pParse, Table pTab, Index *pIdx)

static int	havingToWhereExprCb (Walker pWalker, Expr pExpr)

static void	havingToWhere (Parse pParse, Select p)

static struct SrcList_item *	isSelfJoinView (SrcList pTabList, struct SrcList_item pThis)

static int	sqlite3_get_table_cb (void pArg, int nCol, char argv, char *colv)

static char *	triggerSpanDup (sqlite3 db, const char zStart, const char *zEnd)

static TriggerStep *	triggerStepAllocate (Parse pParse, u8 op, Token pName, const char zStart, const char zEnd)

static Table *	tableOfTrigger (Trigger *pTrigger)

static int	checkColumnOverlap (IdList pIdList, ExprList pEList)

static int	codeTriggerProgram (Parse pParse, TriggerStep pStepList, int orconf)

static void	transferParseError (Parse pTo, Parse pFrom)

static TriggerPrg *	codeRowTrigger (Parse pParse, Trigger pTrigger, Table *pTab, int orconf)

static TriggerPrg *	getRowTrigger (Parse pParse, Trigger pTrigger, Table *pTab, int orconf)

static void	updateVirtualTable (Parse pParse, SrcList pSrc, Table pTab, ExprList pChanges, Expr pRowidExpr, int aXRef, Expr *pWhere, int onError)

static int	indexColumnIsBeingUpdated (Index pIdx, int iCol, int aXRef, int chngRowid)

static int	indexWhereClauseMightChange (Index pIdx, int aXRef, int chngRowid)

static Expr *	exprRowColumn (Parse *pParse, int iCol)

static void	updateFromSelect (Parse pParse, int iEph, Index pPk, ExprList pChanges, SrcList pTabList, Expr pWhere, ExprList pOrderBy, Expr *pLimit)

static int	execSql (sqlite3 db, char pzErrMsg, const char zSql)

static int	execSqlF (sqlite3 db, char pzErrMsg, const char zSql,...)

static int	createModule (sqlite3 db, const char zName, const sqlite3_module pModule, void pAux, void(xDestroy)(void ))

static VTable *	vtabDisconnectAll (sqlite3 db, Table p)

static void	addModuleArgument (Parse pParse, Table pTable, char *zArg)

static void	addArgumentToVtab (Parse *pParse)

static int	vtabCallConstructor (sqlite3 db, Table pTab, Module pMod, int(xConstruct)(sqlite3 , void , int, const char const , sqlite3_vtab , char ), char **pzErr)

static int	growVTrans (sqlite3 *db)

static void	addToVTrans (sqlite3 db, VTable pVTab)

static void	callFinaliser (sqlite3 *db, int offset)

SQLITE_PRIVATE Bitmask	sqlite3WhereGetMask (WhereMaskSet *, int)

SQLITE_PRIVATE WhereTerm *	sqlite3WhereFindTerm (WhereClause pWC, int iCur, int iColumn, Bitmask notReady, u32 op, Index pIdx)

SQLITE_PRIVATE int	sqlite3WhereExplainOneScan (Parse pParse, SrcList pTabList, WhereLevel *pLevel, u16 wctrlFlags)

SQLITE_PRIVATE Bitmask	sqlite3WhereCodeOneLoopStart (Parse pParse, Vdbe v, WhereInfo pWInfo, int iLevel, WhereLevel pLevel, Bitmask notReady)

SQLITE_PRIVATE void	sqlite3WhereClauseInit (WhereClause , WhereInfo )

SQLITE_PRIVATE void	sqlite3WhereClauseClear (WhereClause *)

SQLITE_PRIVATE void	sqlite3WhereSplit (WhereClause , Expr , u8)

SQLITE_PRIVATE Bitmask	sqlite3WhereExprUsage (WhereMaskSet , Expr )

SQLITE_PRIVATE Bitmask	sqlite3WhereExprUsageNN (WhereMaskSet , Expr )

SQLITE_PRIVATE Bitmask	sqlite3WhereExprListUsage (WhereMaskSet , ExprList )

SQLITE_PRIVATE void	sqlite3WhereExprAnalyze (SrcList , WhereClause )

SQLITE_PRIVATE void	sqlite3WhereTabFuncArgs (Parse , struct SrcList_item , WhereClause *)

static const char *	explainIndexColumnName (Index *pIdx, int i)

static void	explainAppendTerm (StrAccum pStr, Index pIdx, int nTerm, int iTerm, int bAnd, const char *zOp)

static void	explainIndexRange (StrAccum pStr, WhereLoop pLoop)

static void	disableTerm (WhereLevel pLevel, WhereTerm pTerm)

static void	codeApplyAffinity (Parse pParse, int base, int n, char zAff)

static void	updateRangeAffinityStr (Expr pRight, int n, char zAff)

static Expr *	removeUnindexableInClauseTerms (Parse pParse, int iEq, WhereLoop pLoop, Expr *pX)

static int	codeEqualityTerm (Parse pParse, WhereTerm pTerm, WhereLevel *pLevel, int iEq, int bRev, int iTarget)

static int	codeAllEqualityTerms (Parse pParse, WhereLevel pLevel, int bRev, int nExtraReg, char **pzAff)

static void	whereLikeOptimizationStringFixup (Vdbe v, WhereLevel pLevel, WhereTerm *pTerm)

static void	codeDeferredSeek (WhereInfo pWInfo, Index pIdx, int iCur, int iIdxCur)

static void	codeExprOrVector (Parse pParse, Expr p, int iReg, int nReg)

static void	preserveExpr (IdxExprTrans pTrans, Expr pExpr)

static int	whereIndexExprTransNode (Walker p, Expr pExpr)

static int	whereIndexExprTransColumn (Walker p, Expr pExpr)

static void	whereIndexExprTrans (Index pIdx, int iTabCur, int iIdxCur, WhereInfo pWInfo)

static void	whereApplyPartialIndexConstraints (Expr pTruth, int iTabCur, WhereClause pWC)

static void	exprAnalyze (SrcList , WhereClause , int)

static void	whereOrInfoDelete (sqlite3 db, WhereOrInfo p)

static void	whereAndInfoDelete (sqlite3 db, WhereAndInfo p)

static int	whereClauseInsert (WhereClause pWC, Expr p, u16 wtFlags)

static int	allowedOp (int op)

static u16	exprCommute (Parse pParse, Expr pExpr)

static u16	operatorMask (int op)

static int	isLikeOrGlob (Parse pParse, Expr pExpr, Expr *ppPrefix, int pisComplete, int *pnoCase)

static int	isAuxiliaryVtabOperator (sqlite3 db, Expr pExpr, unsigned char peOp2, Expr ppLeft, Expr *ppRight)

static void	transferJoinMarkings (Expr pDerived, Expr pBase)

static void	markTermAsChild (WhereClause *pWC, int iChild, int iParent)

static WhereTerm *	whereNthSubterm (WhereTerm *pTerm, int N)

static void	whereCombineDisjuncts (SrcList pSrc, WhereClause pWC, WhereTerm pOne, WhereTerm pTwo)

static void	exprAnalyzeOrTerm (SrcList pSrc, WhereClause pWC, int idxTerm)

static int	termIsEquivalence (Parse pParse, Expr pExpr)

static Bitmask	exprSelectUsage (WhereMaskSet pMaskSet, Select pS)

static SQLITE_NOINLINE int	exprMightBeIndexed2 (SrcList pFrom, Bitmask mPrereq, int aiCurCol, Expr *pExpr)

static int	exprMightBeIndexed (SrcList pFrom, Bitmask mPrereq, int aiCurCol, Expr *pExpr, int op)

static int	whereLoopResize (sqlite3 , WhereLoop , int)

static void	whereOrMove (WhereOrSet pDest, WhereOrSet pSrc)

static int	whereOrInsert (WhereOrSet *pSet, Bitmask prereq, LogEst rRun, LogEst nOut)

static void	createMask (WhereMaskSet *pMaskSet, int iCursor)

static WhereTerm *	whereScanNext (WhereScan *pScan)

static SQLITE_NOINLINE WhereTerm *	whereScanInitIndexExpr (WhereScan *pScan)

static WhereTerm *	whereScanInit (WhereScan pScan, WhereClause pWC, int iCur, int iColumn, u32 opMask, Index *pIdx)

static int	findIndexCol (Parse pParse, ExprList pList, int iBase, Index *pIdx, int iCol)

static int	indexColumnNotNull (Index *pIdx, int iCol)

static int	isDistinctRedundant (Parse pParse, SrcList pTabList, WhereClause pWC, ExprList pDistinct)

static LogEst	estLog (LogEst N)

static void	translateColumnToCopy (Parse *pParse, int iStart, int iTabCur, int iRegister, int iAutoidxCur)

static int	termCanDriveIndex (WhereTerm pTerm, struct SrcList_item pSrc, Bitmask notReady)

static void	constructAutomaticIndex (Parse pParse, WhereClause pWC, struct SrcList_item pSrc, Bitmask notReady, WhereLevel pLevel)

static sqlite3_index_info *	allocateIndexInfo (Parse pParse, WhereClause pWC, Bitmask mUnusable, struct SrcList_item pSrc, ExprList pOrderBy, u16 *pmNoOmit)

static int	vtabBestIndex (Parse pParse, Table pTab, sqlite3_index_info *p)

static LogEst	whereRangeAdjust (WhereTerm *pTerm, LogEst nNew)

static int	whereRangeScanEst (Parse pParse, WhereLoopBuilder pBuilder, WhereTerm pLower, WhereTerm pUpper, WhereLoop *pLoop)

static void	whereLoopInit (WhereLoop *p)

static void	whereLoopClearUnion (sqlite3 db, WhereLoop p)

static void	whereLoopClear (sqlite3 db, WhereLoop p)

static int	whereLoopXfer (sqlite3 db, WhereLoop pTo, WhereLoop *pFrom)

static void	whereLoopDelete (sqlite3 db, WhereLoop p)

static void	whereInfoFree (sqlite3 db, WhereInfo pWInfo)

static int	whereLoopCheaperProperSubset (const WhereLoop pX, const WhereLoop pY)

static void	whereLoopAdjustCost (const WhereLoop p, WhereLoop pTemplate)

static WhereLoop **	whereLoopFindLesser (WhereLoop *ppPrev, const WhereLoop pTemplate)

static int	whereLoopInsert (WhereLoopBuilder pBuilder, WhereLoop pTemplate)

static void	whereLoopOutputAdjust (WhereClause pWC, WhereLoop pLoop, LogEst nRow)

static int	whereRangeVectorLen (Parse pParse, int iCur, Index pIdx, int nEq, WhereTerm *pTerm)

static int	whereLoopAddBtreeIndex (WhereLoopBuilder pBuilder, struct SrcList_item pSrc, Index *pProbe, LogEst nInMul)

static int	indexMightHelpWithOrderBy (WhereLoopBuilder pBuilder, Index pIndex, int iCursor)

static int	whereUsablePartialIndex (int iTab, int isLeft, WhereClause pWC, Expr pWhere)

static int	whereLoopAddBtree (WhereLoopBuilder *pBuilder, Bitmask mPrereq)

static int	whereLoopAddVirtualOne (WhereLoopBuilder pBuilder, Bitmask mPrereq, Bitmask mUsable, u16 mExclude, sqlite3_index_info pIdxInfo, u16 mNoOmit, int *pbIn)

static int	whereLoopAddVirtual (WhereLoopBuilder *pBuilder, Bitmask mPrereq, Bitmask mUnusable)

static int	whereLoopAddOr (WhereLoopBuilder *pBuilder, Bitmask mPrereq, Bitmask mUnusable)

static int	whereLoopAddAll (WhereLoopBuilder *pBuilder)

static i8	wherePathSatisfiesOrderBy (WhereInfo pWInfo, ExprList pOrderBy, WherePath pPath, u16 wctrlFlags, u16 nLoop, WhereLoop pLast, Bitmask *pRevMask)

static LogEst	whereSortingCost (WhereInfo *pWInfo, LogEst nRow, int nOrderBy, int nSorted)

static int	wherePathSolver (WhereInfo *pWInfo, LogEst nRowEst)

static int	whereShortCut (WhereLoopBuilder *pBuilder)

static int	exprNodeIsDeterministic (Walker pWalker, Expr pExpr)

static int	exprIsDeterministic (Expr *p)

static void	row_numberStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	row_numberValueFunc (sqlite3_context *pCtx)

static void	dense_rankStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	dense_rankValueFunc (sqlite3_context *pCtx)

static void	nth_valueStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	nth_valueFinalizeFunc (sqlite3_context *pCtx)

static void	first_valueStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	first_valueFinalizeFunc (sqlite3_context *pCtx)

static void	rankStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	rankValueFunc (sqlite3_context *pCtx)

static void	percent_rankStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	percent_rankInvFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	percent_rankValueFunc (sqlite3_context *pCtx)

static void	cume_distStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	cume_distInvFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	cume_distValueFunc (sqlite3_context *pCtx)

static void	ntileStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	ntileInvFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	ntileValueFunc (sqlite3_context *pCtx)

static void	last_valueStepFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	last_valueInvFunc (sqlite3_context pCtx, int nArg, sqlite3_value *apArg)

static void	last_valueValueFunc (sqlite3_context *pCtx)

static void	last_valueFinalizeFunc (sqlite3_context *pCtx)

static void	noopStepFunc (sqlite3_context p, int n, sqlite3_value *a)

static void	noopValueFunc (sqlite3_context *p)

static Window *	windowFind (Parse pParse, Window pList, const char *zName)

static int	selectWindowRewriteExprCb (Walker pWalker, Expr pExpr)

static int	selectWindowRewriteSelectCb (Walker pWalker, Select pSelect)

static void	selectWindowRewriteEList (Parse pParse, Window pWin, SrcList pSrc, ExprList pEList, Table pTab, ExprList *ppSub)

static ExprList *	exprListAppendList (Parse pParse, ExprList pList, ExprList *pAppend, int bIntToNull)

static int	sqlite3WindowExtraAggFuncDepth (Walker pWalker, Expr pExpr)

static Expr *	sqlite3WindowOffsetExpr (Parse pParse, Expr pExpr)

static void	windowCheckValue (Parse *pParse, int reg, int eCond)

static int	windowArgCount (Window *pWin)

static void	windowReadPeerValues (WindowCodeArg *p, int csr, int reg)

static void	windowAggStep (WindowCodeArg p, Window pMWin, int csr, int bInverse, int reg)

static void	windowAggFinal (WindowCodeArg *p, int bFin)

static void	windowFullScan (WindowCodeArg *p)

static void	windowReturnOneRow (WindowCodeArg *p)

static int	windowInitAccum (Parse pParse, Window pMWin)

static int	windowCacheFrame (Window *pMWin)

static void	windowIfNewPeer (Parse pParse, ExprList pOrderBy, int regNew, int regOld, int addr)

static void	windowCodeRangeTest (WindowCodeArg *p, int op, int csr1, int regVal, int csr2, int lbl)

static int	windowCodeOp (WindowCodeArg *p, int op, int regCountdown, int jumpOnEof)

static int	windowExprGtZero (Parse pParse, Expr pExpr)

static void	disableLookaside (Parse *pParse)

static void	parserDoubleLinkSelect (Parse pParse, Select p)

static Expr *	tokenExpr (Parse *pParse, int op, Token t)

static void	binaryToUnaryIfNull (Parse pParse, Expr pY, Expr *pA, int op)

static ExprList *	parserAddExprIdListTerm (Parse pParse, ExprList pPrior, Token *pIdToken, int hasCollate, int sortOrder)

SQLITE_PRIVATE void	sqlite3ParserInit (void *yypRawParser sqlite3ParserCTX_PDECL)

static void	yy_destructor (yyParser yypParser, YYCODETYPE yymajor, YYMINORTYPE yypminor)

static void	yy_pop_parser_stack (yyParser *pParser)

SQLITE_PRIVATE void	sqlite3ParserFinalize (void *p)

static YYACTIONTYPE	yy_find_shift_action (YYCODETYPE iLookAhead, YYACTIONTYPE stateno)

static YYACTIONTYPE	yy_find_reduce_action (YYACTIONTYPE stateno, YYCODETYPE iLookAhead)

static void	yyStackOverflow (yyParser *yypParser)

static void	yy_shift (yyParser *yypParser, YYACTIONTYPE yyNewState, YYCODETYPE yyMajor, sqlite3ParserTOKENTYPE yyMinor)

static void	yy_accept (yyParser *)

static YYACTIONTYPE	yy_reduce (yyParser *yypParser, unsigned int yyruleno, int yyLookahead, sqlite3ParserTOKENTYPE yyLookaheadToken sqlite3ParserCTX_PDECL)

static void	yy_syntax_error (yyParser *yypParser, int yymajor, sqlite3ParserTOKENTYPE yyminor)

SQLITE_PRIVATE void	sqlite3Parser (void *yyp, int yymajor, sqlite3ParserTOKENTYPE yyminor sqlite3ParserARG_PDECL)

static int	keywordCode (const char z, int n, int pType)

static int	getToken (const unsigned char **pz)

static int	analyzeWindowKeyword (const unsigned char *z)

static int	analyzeOverKeyword (const unsigned char *z, int lastToken)

static int	analyzeFilterKeyword (const unsigned char *z, int lastToken)

static int	sqlite3TestExtInit (sqlite3 *db)

static int	setupLookaside (sqlite3 db, void pBuf, int sz, int cnt)

static int	binCollFunc (void NotUsed, int nKey1, const void pKey1, int nKey2, const void *pKey2)

static int	rtrimCollFunc (void pUser, int nKey1, const void pKey1, int nKey2, const void *pKey2)

static int	nocaseCollatingFunc (void NotUsed, int nKey1, const void pKey1, int nKey2, const void *pKey2)

static void	functionDestroy (sqlite3 db, FuncDef p)

static void	disconnectAllVtab (sqlite3 *db)

static int	connectionIsBusy (sqlite3 *db)

static int	sqlite3Close (sqlite3 *db, int forceZombie)

static int	sqliteDefaultBusyCallback (void *ptr, int count)

static int	createFunctionApi (sqlite3 db, const char zFunc, int nArg, int enc, void p, void(xSFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context ), void(xValue)(sqlite3_context ), void(xInverse)(sqlite3_context , int, sqlite3_value ), void(xDestroy)(void *))

static void	sqlite3InvalidFunction (sqlite3_context context, int NotUsed, sqlite3_value *NotUsed2)

static int	createCollation (sqlite3 db, const char zName, u8 enc, void pCtx, int(xCompare)(void , int, const void , int, const void ), void(xDel)(void *))

static const char *	uriParameter (const char zFilename, const char zParam)

static int	openDatabase (const char zFilename, sqlite3 ppDb, unsigned int flags, const char zVfs)

static const char *	databaseName (const char *zName)

static char *	appendText (char p, const char z)

Variables
static const char *const	sqlite3azCompileOpt []

SQLITE_API const char	sqlite3_version [] = SQLITE_VERSION

SQLITE_API char *	sqlite3_temp_directory = 0

SQLITE_API char *	sqlite3_data_directory = 0

const int	sqlite3one = 1

SQLITE_PRIVATE void(*)(void)	sqlite3OsDlSym (sqlite3_vfs , void , const char *)

SQLITE_PRIVATE const unsigned char	sqlite3UpperToLower []

SQLITE_PRIVATE const unsigned char	sqlite3CtypeMap [256]

SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config	sqlite3Config

SQLITE_PRIVATE FuncDefHash	sqlite3BuiltinFunctions

SQLITE_PRIVATE int	sqlite3PendingByte = 0x40000000

SQLITE_API u32	sqlite3_unsupported_selecttrace = 0

SQLITE_PRIVATE const unsigned char	sqlite3OpcodeProperty [] = OPFLG_INITIALIZER

SQLITE_PRIVATE const char	sqlite3StrBINARY [] = "BINARY"

static SQLITE_WSD struct sqlite3StatType	sqlite3Stat = { {0,}, {0,} }

static const char	statMutex []

struct {

u8 eType

u8 nName

char * zName

double rLimit

double rXform

}	aXformType []

static sqlite3_vfs *SQLITE_WSD	vfsList = 0

static SQLITE_WSD struct BenignMallocHooks	sqlite3Hooks = { 0, 0 }

static SQLITE_WSD struct Mem0Global	mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 }

static const char	aDigits [] = "0123456789ABCDEF0123456789abcdef"

static const char	aPrefix [] = "-x0\000X0"

static const et_info	fmtinfo []

static const double	arRound []

static sqlite3_str	sqlite3OomStr

static SQLITE_WSD struct sqlite3PrngType	sqlite3Prng

static SQLITE_WSD struct sqlite3PrngType	sqlite3SavedPrng

static const unsigned char	sqlite3Utf8Trans1 []

static pid_t	randomnessPid = 0

static struct unix_syscall	aSyscall []

static sqlite3_mutex *	unixBigLock = 0

static unixInodeInfo *	inodeList = 0

static void(*)(void)	unixDlSym (sqlite3_vfs NotUsed, void p, const char *zSym)

static SQLITE_WSD struct PCacheGlobal	pcache1_g

static const unsigned char	aJournalMagic []

static const char	zMagicHeader [] = SQLITE_FILE_HEADER

static BtShared *SQLITE_WSD	sqlite3SharedCacheList = 0

static const u8	sqlite3SmallTypeSizes []

static const struct sqlite3_io_methods	MemJournalMethods

static const FuncDef	statInitFuncdef

static const FuncDef	statPushFuncdef

static const FuncDef	statGetFuncdef

static const struct compareInfo	globInfo = { '*', '?', '[', 0 }

static const struct compareInfo	likeInfoNorm = { '%', '_', 0, 1 }

static const struct compareInfo	likeInfoAlt = { '%', '_', 0, 0 }

static const char	hexdigits []

static const sqlite3_api_routines	sqlite3Apis

static SQLITE_WSD struct sqlite3AutoExtList	sqlite3Autoext = { 0, 0 }

static const char *const	pragCName []

static const PragmaName	aPragmaName []

static const sqlite3_module	pragmaVtabModule

static const char	row_numberName [] = "row_number"

static const char	dense_rankName [] = "dense_rank"

static const char	rankName [] = "rank"

static const char	percent_rankName [] = "percent_rank"

static const char	cume_distName [] = "cume_dist"

static const char	ntileName [] = "ntile"

static const char	last_valueName [] = "last_value"

static const char	nth_valueName [] = "nth_value"

static const char	first_valueName [] = "first_value"

static const char	leadName [] = "lead"

static const char	lagName [] = "lag"

static const YYACTIONTYPE	yy_action []

static const YYCODETYPE	yy_lookahead []

static const unsigned short int	yy_shift_ofst []

static const short	yy_reduce_ofst []

static const YYACTIONTYPE	yy_default []

static const YYCODETYPE	yyFallback []

static const YYCODETYPE	yyRuleInfoLhs []

static const signed char	yyRuleInfoNRhs []

static const unsigned char	aiClass []

static const char	zKWText [647]

static const unsigned char	aKWHash [127]

static const unsigned char	aKWNext [145]

static const unsigned char	aKWLen [145]

static const unsigned short int	aKWOffset [145]

static const unsigned char	aKWCode [145]

static int(*const	sqlite3BuiltinExtensions [])(sqlite3 *)

static const int	aHardLimit []

Macro Definition Documentation

◆ __has_extension

#define __has_extension ( x ) 0 /* compatibility with non-clang compilers */

Definition at line 13470 of file sqlite3.c.

◆ _FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS 64

Definition at line 964 of file sqlite3.c.

◆ _FTS5_H

#define _FTS5_H

Definition at line 12668 of file sqlite3.c.

◆ _FTSINT_H

#define _FTSINT_H

Definition at line 166240 of file sqlite3.c.

◆ _LARGE_FILE

#define _LARGE_FILE 1

Definition at line 962 of file sqlite3.c.

◆ _LARGEFILE_SOURCE

#define _LARGEFILE_SOURCE 1

Definition at line 966 of file sqlite3.c.

◆ _OS_COMMON_H_

#define _OS_COMMON_H_

Definition at line 33665 of file sqlite3.c.

◆ _SQLITE3RTREE_H_

#define _SQLITE3RTREE_H_

Definition at line 10880 of file sqlite3.c.

◆ _SQLITE_OS_H_

#define _SQLITE_OS_H_

Definition at line 16234 of file sqlite3.c.

◆ _XOPEN_SOURCE

#define _XOPEN_SOURCE 600

Definition at line 13640 of file sqlite3.c.

◆ ADDR

#define ADDR ( X ) (~(X))

Definition at line 15556 of file sqlite3.c.

Referenced by resolveP2Values().

◆ ALLBITS

#define ALLBITS ((Bitmask)-1)

Definition at line 14734 of file sqlite3.c.

Referenced by sqlite3Update(), sqlite3WhereBegin(), and whereLoopAddVirtual().

◆ ALT_SCHEMA_TABLE

#define ALT_SCHEMA_TABLE "sqlite_schema"

Definition at line 14575 of file sqlite3.c.

Referenced by sqlite3FindTable().

◆ ALT_TEMP_SCHEMA_TABLE

#define ALT_TEMP_SCHEMA_TABLE "sqlite_temp_schema"

Definition at line 14576 of file sqlite3.c.

Referenced by sqlite3FindTable().

◆ ALWAYS

#define ALWAYS ( X ) (X)

Definition at line 13736 of file sqlite3.c.

Referenced by agginfoPersistExprCb(), analyzeAggregate(), codeReal(), exprSelectUsage(), flattenSubquery(), generateWithRecursiveQuery(), impliesNotNullRow(), isFatalError(), memjrnlTruncate(), multiSelectCollSeq(), pageInsertArray(), pager_incr_changecounter(), pagerPagecount(), pcacheSortDirtyList(), rebuildPage(), releaseInodeInfo(), removeFromSharingList(), renameColumnElistNames(), renameResolveTrigger(), selectExpander(), selectSrcCount(), sqlite3AuthRead(), sqlite3CodeRhsOfIN(), sqlite3DbSpanDup(), sqlite3ErrStr(), sqlite3ExprCanBeNull(), sqlite3ExprCollSeq(), sqlite3ExprCompare(), sqlite3ExprListAppendVector(), sqlite3MatchEName(), sqlite3PagerBegin(), sqlite3PagerCommitPhaseOne(), sqlite3PcacheTruncate(), sqlite3Pragma(), sqlite3RenameTokenMap(), sqlite3SrcListAppendFromTerm(), sqlite3UnlinkAndDeleteIndex(), sqlite3VdbeEnter(), sqlite3VdbeExec(), sqlite3VdbeLeave(), sqlite3VtabCallCreate(), sqlite3VtabCallDestroy(), sqlite3WalUndo(), sqlite3WhereBegin(), sqlite3WindowDup(), unixShmPurge(), updateFromSelect(), vdbePmaWriterFinish(), vtabCallConstructor(), whereLoopAddBtreeIndex(), wherePathSatisfiesOrderBy(), whereRangeScanEst(), xferOptimization(), and yy_reduce().

◆ analyzeVdbeCommentIndexWithColumnName

#define analyzeVdbeCommentIndexWithColumnName	(	a,
		b,
		c )

Definition at line 108518 of file sqlite3.c.

Referenced by analyzeOneTable().

◆ ApplyCostMultiplier

#define ApplyCostMultiplier	(		C,
			T )

Definition at line 148005 of file sqlite3.c.

Referenced by whereLoopAddBtree(), and whereLoopAddBtreeIndex().

◆ ArraySize

#define ArraySize ( X ) ((int)(sizeof(X)/sizeof(X[0])))

◆ assertCellInfo

#define assertCellInfo ( x )

Definition at line 69021 of file sqlite3.c.

◆ assertParentIndex

#define assertParentIndex	(	x,
		y,
		z )

Definition at line 69609 of file sqlite3.c.

Referenced by moveToParent().

◆ assertTruncateConstraint

#define assertTruncateConstraint ( pPager )

Definition at line 55613 of file sqlite3.c.

◆ AtomicLoad

#define AtomicLoad ( PTR ) (*(PTR))

Definition at line 13476 of file sqlite3.c.

Referenced by checkRef(), sqlite3BtreeCount(), sqlite3HeapNearlyFull(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3WalFindFrame(), walCheckpoint(), and walTryBeginRead().

◆ AtomicStore

#define AtomicStore	(		PTR,
			VAL ) (*(PTR) = (VAL))

Definition at line 13477 of file sqlite3.c.

Referenced by mallocWithAlarm(), sqlite3_soft_heap_limit64(), sqlite3OomClear(), sqlite3OomFault(), sqlite3RunParser(), sqlite3Step(), walCheckpoint(), walIndexAppend(), walRestartHdr(), and walTryBeginRead().

◆ bBatch

#define bBatch 0

◆ BITVEC_HASH

#define BITVEC_HASH ( X ) (((X)*1)%BITVEC_NINT)

Definition at line 48527 of file sqlite3.c.

Referenced by sqlite3BitvecClear(), sqlite3BitvecSet(), and sqlite3BitvecTestNotNull().

◆ BITVEC_MXHASH

#define BITVEC_MXHASH (BITVEC_NINT/2)

Definition at line 48522 of file sqlite3.c.

Referenced by sqlite3BitvecSet().

◆ BITVEC_NBIT

#define BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM)

Definition at line 48516 of file sqlite3.c.

Referenced by sqlite3BitvecClear(), sqlite3BitvecSet(), and sqlite3BitvecTestNotNull().

◆ BITVEC_NELEM

#define BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))

Definition at line 48514 of file sqlite3.c.

◆ BITVEC_NINT

#define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))

Definition at line 48519 of file sqlite3.c.

Referenced by sqlite3BitvecClear(), and sqlite3BitvecSet().

◆ BITVEC_NPTR

#define BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))

Definition at line 48529 of file sqlite3.c.

Referenced by sqlite3BitvecSet().

◆ BITVEC_SZ

#define BITVEC_SZ 512

Definition at line 48499 of file sqlite3.c.

Referenced by sqlite3BitvecBuiltinTest(), and sqlite3BitvecCreate().

◆ BITVEC_SZELEM

#define BITVEC_SZELEM 8

Definition at line 48512 of file sqlite3.c.

Referenced by sqlite3BitvecClear(), sqlite3BitvecSet(), and sqlite3BitvecTestNotNull().

◆ BITVEC_TELEM

#define BITVEC_TELEM u8

Definition at line 48510 of file sqlite3.c.

◆ BITVEC_USIZE

#define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))

Definition at line 48503 of file sqlite3.c.

48503

48504/* Size of the Bitvec structure in bytes. */

◆ BMS

#define BMS ((int)(sizeof(Bitmask)*8))

Definition at line 14726 of file sqlite3.c.

Referenced by constructAutomaticIndex(), recomputeColumnsNotIndexed(), sqlite3FindInIndex(), sqlite3WhereBegin(), and wherePathSatisfiesOrderBy().

◆ BTALLOC_ANY

#define BTALLOC_ANY 0 /* Allocate any page */

Definition at line 64526 of file sqlite3.c.

Referenced by allocateBtreePage(), and incrVacuumStep().

◆ BTALLOC_EXACT

#define BTALLOC_EXACT 1 /* Allocate exact page if possible */

Definition at line 64527 of file sqlite3.c.

Referenced by allocateBtreePage(), btreeCreateTable(), and incrVacuumStep().

◆ BTALLOC_LE

#define BTALLOC_LE 2 /* Allocate any page <= the parameter */

Definition at line 64528 of file sqlite3.c.

Referenced by allocateBtreePage(), and incrVacuumStep().

◆ BTCF_AtLast

#define BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */

Definition at line 64009 of file sqlite3.c.

Referenced by btreePrevious(), moveToRoot(), saveCursorPosition(), and sqlite3BtreeMovetoUnpacked().

◆ BTCF_Incrblob

#define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */

Definition at line 64010 of file sqlite3.c.

Referenced by invalidateIncrblobCursors(), and sqlite3BtreePutData().

◆ BTCF_Multiple

#define BTCF_Multiple 0x20 /* Maybe another cursor on the same btree */

Definition at line 64011 of file sqlite3.c.

Referenced by btreeCursor(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ BTCF_Pinned

#define BTCF_Pinned 0x40 /* Cursor is busy and cannot be moved */

Definition at line 64012 of file sqlite3.c.

Referenced by saveCursorPosition(), and sqlite3BtreeCursorUnpin().

◆ BTCF_ValidNKey

#define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */

Definition at line 64007 of file sqlite3.c.

Referenced by btreePrevious(), moveToChild(), moveToParent(), moveToRightmost(), moveToRoot(), saveCursorPosition(), sqlite3BtreeInsert(), and sqlite3BtreeMovetoUnpacked().

◆ BTCF_ValidOvfl

#define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */

Definition at line 64008 of file sqlite3.c.

Referenced by accessPayload(), btreeNext(), btreePrevious(), moveToChild(), moveToParent(), moveToRoot(), saveCursorPosition(), sqlite3BtreeInsert(), and sqlite3BtreeMovetoUnpacked().

◆ BTCF_WriteFlag

#define BTCF_WriteFlag 0x01 /* True if a write cursor */

Definition at line 64006 of file sqlite3.c.

Referenced by btreeCursor(), sqlite3BtreeDelete(), sqlite3BtreeInsert(), sqlite3BtreePutData(), and sqlite3BtreeTripAllCursors().

◆ BTCURSOR_FIRST_UNINIT

#define BTCURSOR_FIRST_UNINIT pBt /* Name of first uninitialized field */

Definition at line 63988 of file sqlite3.c.

Referenced by sqlite3BtreeCursorZero().

◆ BTCURSOR_MAX_DEPTH

#define BTCURSOR_MAX_DEPTH 20

Definition at line 63947 of file sqlite3.c.

Referenced by moveToChild().

◆ BTREE_APPEND

#define BTREE_APPEND 0x08 /* Insert is likely an append */

Definition at line 15253 of file sqlite3.c.

Referenced by sqlite3BtreeInsert().

◆ BTREE_APPLICATION_ID

#define BTREE_APPLICATION_ID 8

Definition at line 15149 of file sqlite3.c.

◆ BTREE_AUTOVACUUM_FULL

#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */

Definition at line 15030 of file sqlite3.c.

Referenced by getAutoVacuum().

◆ BTREE_AUTOVACUUM_INCR

#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */

Definition at line 15031 of file sqlite3.c.

Referenced by getAutoVacuum().

◆ BTREE_AUTOVACUUM_NONE

#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */

Definition at line 15029 of file sqlite3.c.

Referenced by getAutoVacuum().

◆ BTREE_AUXDELETE

#define BTREE_AUXDELETE 0x04 /* not the primary delete operation */

Definition at line 15252 of file sqlite3.c.

Referenced by sqlite3BtreeDelete(), and sqlite3VdbeExec().

◆ BTREE_BLOBKEY

#define BTREE_BLOBKEY 2 /* Table has keys only - no data */

Definition at line 15112 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), sqlite3CreateIndex(), and sqlite3VdbeExec().

◆ BTREE_BULKLOAD

#define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */

Definition at line 15194 of file sqlite3.c.

Referenced by balance(), and sqlite3VdbeExec().

◆ BTREE_DATA_VERSION

#define BTREE_DATA_VERSION 15 /* A virtual meta-value */

Definition at line 15150 of file sqlite3.c.

Referenced by sqlite3BtreeGetMeta().

◆ BTREE_DEFAULT_CACHE_SIZE

#define BTREE_DEFAULT_CACHE_SIZE 3

Definition at line 15144 of file sqlite3.c.

Referenced by sqlite3InitOne(), and sqlite3Pragma().

◆ BTREE_FILE_FORMAT

#define BTREE_FILE_FORMAT 2

Definition at line 15143 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), sqlite3InitOne(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ BTREE_FORDELETE

#define BTREE_FORDELETE 0x00000008 /* Cursor is for seek/delete only */

Definition at line 15221 of file sqlite3.c.

Referenced by btreeCursor(), and sqlite3VdbeExec().

◆ BTREE_FREE_PAGE_COUNT

#define BTREE_FREE_PAGE_COUNT 0

Definition at line 15141 of file sqlite3.c.

◆ BTREE_HINT_RANGE

#define BTREE_HINT_RANGE 0 /* Range constraints on queries */

Definition at line 15179 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ BTREE_INCR_VACUUM

#define BTREE_INCR_VACUUM 7

Definition at line 15148 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ BTREE_INTKEY

#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */

Definition at line 15111 of file sqlite3.c.

Referenced by btreeCreateTable(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ BTREE_LARGEST_ROOT_PAGE

#define BTREE_LARGEST_ROOT_PAGE 4

Definition at line 15145 of file sqlite3.c.

Referenced by btreeCreateTable(), btreeDropTable(), sqlite3BtreeGetMeta(), and sqlite3Pragma().

◆ BTREE_MEMORY

#define BTREE_MEMORY 2 /* This is an in-memory DB */

Definition at line 15058 of file sqlite3.c.

Referenced by sqlite3BtreeOpen().

◆ BTREE_OMIT_JOURNAL

#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */

Definition at line 15057 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ BTREE_SAVEPOSITION

#define BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */

Definition at line 15251 of file sqlite3.c.

Referenced by sqlite3BtreeDelete(), sqlite3BtreeInsert(), and sqlite3VdbeExec().

◆ BTREE_SCHEMA_VERSION

#define BTREE_SCHEMA_VERSION 1

Definition at line 15142 of file sqlite3.c.

Referenced by schemaIsValid(), sqlite3ChangeCookie(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ BTREE_SEEK_EQ

#define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */

Definition at line 15195 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ BTREE_SINGLE

#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */

Definition at line 15059 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), and sqlite3VdbeExec().

◆ BTREE_TEXT_ENCODING

#define BTREE_TEXT_ENCODING 5

Definition at line 15146 of file sqlite3.c.

Referenced by sqlite3InitOne(), and sqlite3StartTable().

◆ BTREE_UNORDERED

#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */

Definition at line 15060 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), sqlite3Select(), and sqlite3VdbeExec().

◆ BTREE_USER_VERSION

#define BTREE_USER_VERSION 6

Definition at line 15147 of file sqlite3.c.

◆ BTREE_WRCSR

#define BTREE_WRCSR 0x00000004 /* read-write cursor */

Definition at line 15220 of file sqlite3.c.

Referenced by btreeCursor(), and sqlite3VdbeExec().

◆ btreeIntegrity

#define btreeIntegrity ( p )

Value:

assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \

assert( p->pBt->inTransaction>=p->inTrans );

TRANS_NONE

#define TRANS_NONE

Definition sqlite3.c:63837

Definition at line 64114 of file sqlite3.c.

#define PTRMAP_OVERFLOW2 4
#define PTRMAP_BTREE 5
 

Referenced by sqlite3BtreeBeginTrans(), sqlite3BtreeCommitPhaseTwo(), and sqlite3BtreeRollback().

◆ BTS_EXCLUSIVE

#define BTS_EXCLUSIVE 0x0040 /* pWriter has an exclusive lock */

Definition at line 63922 of file sqlite3.c.

Referenced by clearAllSharedCacheTableLocks(), querySharedCacheTableLock(), and sqlite3BtreeBeginTrans().

◆ BTS_FAST_SECURE

#define BTS_FAST_SECURE 0x000c /* Combination of the previous two */

Definition at line 63919 of file sqlite3.c.

Referenced by balance_nonroot(), freeSpace(), and sqlite3BtreeSecureDelete().

◆ BTS_INITIALLY_EMPTY

#define BTS_INITIALLY_EMPTY 0x0010 /* Database was empty at trans start */

Definition at line 63920 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), and sqlite3BtreeSavepoint().

◆ BTS_NO_WAL

#define BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */

Definition at line 63921 of file sqlite3.c.

Referenced by lockBtree(), and sqlite3BtreeSetVersion().

◆ BTS_OVERWRITE

#define BTS_OVERWRITE 0x0008 /* Overwrite deleted content with zeros */

Definition at line 63918 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), and sqlite3BtreeSecureDelete().

◆ BTS_PAGESIZE_FIXED

#define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */

Definition at line 63916 of file sqlite3.c.

Referenced by lockBtree(), newDatabase(), sqlite3BtreeOpen(), sqlite3BtreeSetAutoVacuum(), and sqlite3BtreeSetPageSize().

◆ BTS_PENDING

#define BTS_PENDING 0x0080 /* Waiting for read-locks to clear */

Definition at line 63923 of file sqlite3.c.

Referenced by clearAllSharedCacheTableLocks(), querySharedCacheTableLock(), and sqlite3BtreeBeginTrans().

◆ BTS_READ_ONLY

#define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */

Definition at line 63915 of file sqlite3.c.

Referenced by btreeCreateTable(), btreeCursor(), lockBtree(), sqlite3BtreeBeginStmt(), sqlite3BtreeBeginTrans(), sqlite3BtreeDelete(), sqlite3BtreeGetMeta(), sqlite3BtreeInsert(), sqlite3BtreeOpen(), and sqlite3BtreePutData().

◆ BTS_SECURE_DELETE

#define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */

Definition at line 63917 of file sqlite3.c.

Referenced by freePage2(), sqlite3BtreeOpen(), and sqlite3BtreeSecureDelete().

◆ BYTESWAP32

#define BYTESWAP32 ( x )

Value:

    ( \
    (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8)  \
  + (((x)&0x00FF0000)>>8)  + (((x)&0xFF000000)>>24) \
)

Definition at line 60038 of file sqlite3.c.

** The argument to this macro must be of type u32. On a little-endian
** architecture, it returns the u32 value that results from interpreting
** the 4 bytes as a big-endian value. On a big-endian architecture, it
** returns the value that would be produced by interpreting the 4 bytes

Referenced by walChecksumBytes().

◆ CACHE_STALE

#define CACHE_STALE 0

Definition at line 20842 of file sqlite3.c.

Referenced by handleMovedCursor(), sqlite3VdbeExec(), and sqlite3VdbeFinishMoveto().

◆ CC_AND

#define CC_AND 24 /* '&' */

Definition at line 159309 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_BANG

#define CC_BANG 15 /* '!'. Part of != */

Definition at line 159300 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_COMMA

#define CC_COMMA 23 /* ',' */

Definition at line 159308 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_DIGIT

#define CC_DIGIT 3 /* Digits */

Definition at line 159288 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_DOLLAR

#define CC_DOLLAR 4 /* '$' */

Definition at line 159289 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_DOT

#define CC_DOT 26 /* '.' */

Definition at line 159311 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_EQ

#define CC_EQ 14 /* '='. Part of = or == */

Definition at line 159299 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_GT

#define CC_GT 13 /* '>'. Part of > or >= */

Definition at line 159298 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_ID

#define CC_ID 2 /* unicode characters usable in IDs */

Definition at line 159287 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_ILLEGAL

#define CC_ILLEGAL 27 /* Illegal character */

Definition at line 159312 of file sqlite3.c.

◆ CC_KYWD

#define CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */

Definition at line 159286 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_LP

#define CC_LP 17 /* '(' */

Definition at line 159302 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_LT

#define CC_LT 12 /* '<'. Part of < or <= or <> */

Definition at line 159297 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_MINUS

#define CC_MINUS 11 /* '-'. Minus or SQL-style comment */

Definition at line 159296 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_NUL

#define CC_NUL 28 /* 0x00 */

Definition at line 159313 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_PERCENT

#define CC_PERCENT 22 /* '%' */

Definition at line 159307 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_PIPE

#define CC_PIPE 10 /* '|'. Bitwise OR or concatenate */

Definition at line 159295 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_PLUS

#define CC_PLUS 20 /* '+' */

Definition at line 159305 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_QUOTE

#define CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */

Definition at line 159293 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_QUOTE2

#define CC_QUOTE2 9 /* '['. [...] style quoted ids */

Definition at line 159294 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_RP

#define CC_RP 18 /* ')' */

Definition at line 159303 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_SEMI

#define CC_SEMI 19 /* ';' */

Definition at line 159304 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_SLASH

#define CC_SLASH 16 /* '/'. / or c-style comment */

Definition at line 159301 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_SPACE

#define CC_SPACE 7 /* Space characters */

Definition at line 159292 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_STAR

#define CC_STAR 21 /* '*' */

Definition at line 159306 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_TILDA

#define CC_TILDA 25 /* '~' */

Definition at line 159310 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_VARALPHA

#define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */

Definition at line 159290 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_VARNUM

#define CC_VARNUM 6 /* '?'. Numeric SQL variables */

Definition at line 159291 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ CC_X

#define CC_X 0 /* The letter 'x', or start of BLOB literal */

Definition at line 159285 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ charMap

#define charMap ( X ) sqlite3UpperToLower[(unsigned char)X]

Definition at line 159366 of file sqlite3.c.

Referenced by keywordCode().

◆ CHECK_PAGE

#define CHECK_PAGE ( x )

Definition at line 52969 of file sqlite3.c.

Referenced by pager_write().

◆ checkActiveVdbeCnt

#define checkActiveVdbeCnt ( x )

Definition at line 80650 of file sqlite3.c.

Referenced by sqlite3VdbeHalt().

◆ checkProfileCallback

#define checkProfileCallback	(		DB,
			P ) if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); }

Definition at line 83065 of file sqlite3.c.

83065 p->startTime = 0;

83066}

Referenced by sqlite3_finalize(), sqlite3_reset(), and sqlite3Step().

◆ CKCNSTRNT_COLUMN

#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */

Definition at line 121889 of file sqlite3.c.

Referenced by checkConstraintExprNode(), and sqlite3ExprReferencesUpdatedColumn().

◆ CKCNSTRNT_ROWID

#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */

Definition at line 121890 of file sqlite3.c.

Referenced by checkConstraintExprNode(), and sqlite3ExprReferencesUpdatedColumn().

◆ CKPT_SYNC_FLAGS

#define CKPT_SYNC_FLAGS ( X ) (((X)>>2)&0x03)

Definition at line 51593 of file sqlite3.c.

Referenced by walCheckpoint().

◆ CLEARBIT

#define CLEARBIT	(		V,
			I ) V[I>>3] &= ~(1<<(I&7))

Definition at line 48763 of file sqlite3.c.

Referenced by sqlite3BitvecBuiltinTest().

◆ codeCursorHint

#define codeCursorHint	(	A,
		B,
		C,
		D ) /* No-op */

Definition at line 142531 of file sqlite3.c.

◆ COLFLAG_BUSY

#define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */

Definition at line 17352 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), and sqlite3ExprCodeTarget().

◆ COLFLAG_GENERATED

#define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */

Definition at line 17353 of file sqlite3.c.

Referenced by fkActionTrigger(), sqlite3AddDefaultValue(), sqlite3AlterFinishAddColumn(), sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Update(), updateVirtualTable(), and xferOptimization().

◆ COLFLAG_HASTYPE

#define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */

Definition at line 17346 of file sqlite3.c.

Referenced by sqlite3AddColumn(), sqlite3ColumnType(), and sqlite3SelectAddColumnTypeAndCollation().

◆ COLFLAG_HIDDEN

#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */

Definition at line 17345 of file sqlite3.c.

Referenced by sqlite3Pragma(), sqlite3WhereTabFuncArgs(), vtabCallConstructor(), and xferOptimization().

◆ COLFLAG_NOINSERT

#define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */

Definition at line 17354 of file sqlite3.c.

Referenced by sqlite3Insert(), and sqlite3Pragma().

◆ COLFLAG_NOTAVAIL

#define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */

Definition at line 17351 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), and sqlite3ExprCodeTarget().

◆ COLFLAG_PRIMKEY

#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */

Definition at line 17344 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), fkParentIsModified(), sqlite3_table_column_metadata(), sqlite3AlterFinishAddColumn(), sqlite3Pragma(), and sqlite3Update().

◆ COLFLAG_SORTERREF

#define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */

Definition at line 17348 of file sqlite3.c.

Referenced by sqlite3AddColumn(), and sqlite3AffinityType().

◆ COLFLAG_STORED

#define COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */

Definition at line 17350 of file sqlite3.c.

Referenced by fkActionTrigger(), sqlite3AddDefaultValue(), sqlite3AlterFinishAddColumn(), sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), and xferOptimization().

◆ COLFLAG_UNIQUE

#define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */

Definition at line 17347 of file sqlite3.c.

Referenced by sqlite3AddNotNull(), and sqlite3CreateIndex().

◆ COLFLAG_VIRTUAL

#define COLFLAG_VIRTUAL 0x0020 /* GENERATED ALWAYS AS ... VIRTUAL */

Definition at line 17349 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), fkActionTrigger(), recomputeColumnsNotIndexed(), sqlite3AddDefaultValue(), sqlite3ComputeGeneratedColumns(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3StorageColumnToTable(), sqlite3TableAffinity(), sqlite3TableColumnToStorage(), sqlite3Update(), whereIndexExprTrans(), and xferOptimization().

◆ COLNAME_COLUMN

#define COLNAME_COLUMN 4

Definition at line 15540 of file sqlite3.c.

◆ COLNAME_DATABASE

#define COLNAME_DATABASE 2

Definition at line 15538 of file sqlite3.c.

◆ COLNAME_DECLTYPE

#define COLNAME_DECLTYPE 1

Definition at line 15537 of file sqlite3.c.

Referenced by sqlite3_column_decltype16().

◆ COLNAME_N

#define COLNAME_N 2 /* Store the name and decltype */

Definition at line 15547 of file sqlite3.c.

Referenced by sqlite3VdbeClearObject(), sqlite3VdbeSetColName(), and sqlite3VdbeSetNumCols().

◆ COLNAME_NAME

#define COLNAME_NAME 0

Definition at line 15536 of file sqlite3.c.

Referenced by generateColumnNames(), sqlite3_column_name16(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), and sqlite3VdbeMakeReady().

◆ COLNAME_TABLE

#define COLNAME_TABLE 3

Definition at line 15539 of file sqlite3.c.

◆ COLUMN_MASK

#define COLUMN_MASK ( x ) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))

Definition at line 120162 of file sqlite3.c.

Referenced by sqlite3FkOldmask().

◆ columnType

#define columnType	(	A,
		B,
		C,
		D,
		E ) columnTypeImpl(A,B)

Definition at line 130950 of file sqlite3.c.

Referenced by columnTypeImpl(), and sqlite3SelectAddColumnTypeAndCollation().

◆ ConstFactorOk

#define ConstFactorOk ( P ) ((P)->okConstFactor)

Definition at line 17070 of file sqlite3.c.

Referenced by sqlite3ExprCodeExprList(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), and sqlite3ExprCodeTemp().

◆ CORRUPT_DB

#define CORRUPT_DB (sqlite3Config.neverCorrupt==0)

◆ CTIMEOPT_VAL

#define CTIMEOPT_VAL ( opt ) CTIMEOPT_VAL_(opt)

Definition at line 56 of file sqlite3.c.

◆ CTIMEOPT_VAL2

#define CTIMEOPT_VAL2 ( opt ) CTIMEOPT_VAL2_(opt)

Definition at line 62 of file sqlite3.c.

◆ CTIMEOPT_VAL2_

#define CTIMEOPT_VAL2_	(		opt1,
			opt2 ) #opt1 "," #opt2

Definition at line 61 of file sqlite3.c.

◆ CTIMEOPT_VAL_

#define CTIMEOPT_VAL_ ( opt ) #opt

Definition at line 55 of file sqlite3.c.

◆ cume_distFinalizeFunc

#define cume_distFinalizeFunc cume_distValueFunc

Definition at line 151564 of file sqlite3.c.

◆ CURSOR_FAULT

#define CURSOR_FAULT 4

Definition at line 64048 of file sqlite3.c.

Referenced by btreeRestoreCursorPosition(), moveToRoot(), sqlite3BtreeInsert(), and sqlite3BtreeTripAllCursors().

◆ CURSOR_INVALID

#define CURSOR_INVALID 1

Definition at line 64045 of file sqlite3.c.

Referenced by accessPayloadChecked(), btreeNext(), btreePrevious(), btreeRestoreCursorPosition(), invalidateIncrblobCursors(), moveToRoot(), and sqlite3BtreeInsert().

◆ CURSOR_REQUIRESEEK

#define CURSOR_REQUIRESEEK 3

Definition at line 64047 of file sqlite3.c.

Referenced by btreeRestoreCursorPosition(), moveToRoot(), saveCursorPosition(), sqlite3BtreeDelete(), sqlite3BtreeInsert(), and sqlite3BtreePutData().

◆ CURSOR_SKIPNEXT

#define CURSOR_SKIPNEXT 2

Definition at line 64046 of file sqlite3.c.

Referenced by btreeNext(), btreePrevious(), saveCursorPosition(), saveCursorsOnList(), sqlite3BtreeDelete(), and sqlite3BtreeTripAllCursors().

◆ CURSOR_VALID

◆ CURTYPE_BTREE

#define CURTYPE_BTREE 0

Definition at line 20764 of file sqlite3.c.

Referenced by allocateCursor(), handleMovedCursor(), sqlite3VdbeCursorMoveto(), sqlite3VdbeExec(), sqlite3VdbeFinishMoveto(), and sqlite3VdbeIdxKeyCompare().

◆ CURTYPE_PSEUDO

#define CURTYPE_PSEUDO 3

Definition at line 20767 of file sqlite3.c.

Referenced by sqlite3VdbeCursorMoveto(), and sqlite3VdbeExec().

◆ CURTYPE_SORTER

#define CURTYPE_SORTER 1

Definition at line 20765 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeSorterCompare(), sqlite3VdbeSorterInit(), sqlite3VdbeSorterNext(), and sqlite3VdbeSorterRewind().

◆ CURTYPE_VTAB

#define CURTYPE_VTAB 2

Definition at line 20766 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ DB_ResetWanted

#define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */

Definition at line 16665 of file sqlite3.c.

Referenced by sqlite3ResetOneSchema(), and sqlite3SchemaClear().

◆ DB_SchemaLoaded

#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */

Definition at line 16663 of file sqlite3.c.

Referenced by sqlite3Init(), sqlite3InitOne(), sqlite3SchemaClear(), and sqlite3VdbeExec().

◆ DB_UnresetViews

#define DB_UnresetViews 0x0002 /* Some views have defined column names */

Definition at line 16664 of file sqlite3.c.

Referenced by sqlite3ViewGetColumnNames(), and sqliteViewResetAll().

◆ DbClearProperty

#define DbClearProperty	(	D,
		I,
		P ) (D)->aDb[I].pSchema->schemaFlags&=~(P)

Definition at line 16651 of file sqlite3.c.

Referenced by sqliteViewResetAll().

◆ DBFLAG_EncodingFixed

#define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */

Definition at line 17034 of file sqlite3.c.

Referenced by sqlite3InitCallback(), sqlite3InitOne(), and sqlite3Pragma().

◆ DBFLAG_InternalFunc

#define DBFLAG_InternalFunc 0x0020 /* Allow use of internal functions */

Definition at line 17033 of file sqlite3.c.

Referenced by openDatabase(), resolveExprStep(), and sqlite3Pragma().

◆ DBFLAG_PreferBuiltin

#define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */

Definition at line 17029 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), and sqlite3FindFunction().

◆ DBFLAG_SchemaChange

#define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */

Definition at line 17028 of file sqlite3.c.

Referenced by sqlite3CreateIndex(), sqlite3EndTable(), sqlite3Init(), sqlite3RollbackAll(), sqlite3UnlinkAndDeleteIndex(), sqlite3UnlinkAndDeleteTable(), and sqlite3VdbeExec().

◆ DBFLAG_SchemaKnownOk

#define DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */

Definition at line 17032 of file sqlite3.c.

Referenced by attachFunc(), sqlite3InitOne(), and sqlite3LocateTable().

◆ DBFLAG_Vacuum

#define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */

Definition at line 17030 of file sqlite3.c.

Referenced by autoIncBegin(), sqlite3TwoPartName(), and xferOptimization().

◆ DBFLAG_VacuumInto

#define DBFLAG_VacuumInto 0x0008 /* Currently running VACUUM INTO */

Definition at line 17031 of file sqlite3.c.

Referenced by xferOptimization().

◆ DbHasAnyProperty

#define DbHasAnyProperty	(	D,
		I,
		P ) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)

Definition at line 16649 of file sqlite3.c.

◆ DbHasProperty

#define DbHasProperty	(	D,
		I,
		P ) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))

Definition at line 16648 of file sqlite3.c.

Referenced by sqlite3Init(), sqlite3ResetOneSchema(), sqlite3VdbeExec(), and sqliteViewResetAll().

◆ DbMaskAllZero

#define DbMaskAllZero ( M ) (M)==0

Definition at line 18659 of file sqlite3.c.

Referenced by codeDeferredSeek(), sqlite3VdbeEnter(), and sqlite3VdbeTakeOpArray().

◆ DbMaskNonZero

#define DbMaskNonZero ( M ) (M)!=0

Definition at line 18660 of file sqlite3.c.

Referenced by sqlite3FinishCoding().

◆ DbMaskSet

#define DbMaskSet	(		M,
			I ) (M)\|=(((yDbMask)1)<<(I))

Definition at line 18658 of file sqlite3.c.

Referenced by sqlite3BeginWriteOperation(), sqlite3CodeVerifySchema(), and sqlite3VdbeUsesBtree().

◆ DbMaskTest

#define DbMaskTest	(		M,
			I ) (((M)&(((yDbMask)1)<<(I)))!=0)

Definition at line 18656 of file sqlite3.c.

Referenced by sqlite3CodeVerifySchema(), sqlite3FinishCoding(), sqlite3VdbeEnter(), sqlite3VdbeExec(), and sqlite3VdbeLeave().

◆ DbMaskZero

#define DbMaskZero ( M ) (M)=0

Definition at line 18657 of file sqlite3.c.

◆ DbSetProperty

#define DbSetProperty	(	D,
		I,
		P ) (D)->aDb[I].pSchema->schemaFlags\|=(P)

Definition at line 16650 of file sqlite3.c.

Referenced by sqlite3InitOne(), and sqlite3ResetOneSchema().

◆ Deephemeralize

#define Deephemeralize ( P )

Value:

if( ((P)->flags&MEM_Ephem)!=0 \

&& sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}

MEM_Ephem

#define MEM_Ephem

Definition sqlite3.c:20969

sqlite3VdbeMemMakeWriteable

SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *)

Definition sqlite3.c:76154

Definition at line 85461 of file sqlite3.c.

** knowing it.
**
** This routine converts an ephemeral string into a dynamically allocated

Referenced by sqlite3VdbeExec().

◆ deliberate_fall_through

#define deliberate_fall_through

Definition at line 1008 of file sqlite3.c.

Referenced by exprImpliesNotNull(), exprNodeIsConstant(), fkActionTrigger(), impliesNotNullRow(), resolveExprStep(), resolveP2Values(), selectWindowRewriteExprCb(), sqlite3_str_vappendf(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3GetToken(), and sqlite3VdbeExec().

◆ DFLT_SCHEMA_TABLE

#define DFLT_SCHEMA_TABLE "sqlite_master"

Definition at line 14573 of file sqlite3.c.

Referenced by destroyRootPage(), renameTestSchema(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3FindTable(), and sqlite3VdbeExec().

◆ DFLT_TEMP_SCHEMA_TABLE

#define DFLT_TEMP_SCHEMA_TABLE "sqlite_temp_master"

Definition at line 14574 of file sqlite3.c.

Referenced by sqlite3FindTable().

◆ DFUNCTION

#define DFUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \

0, 0, xFunc, 0, 0, 0, #zName, {0} }

SQLITE_FUNC_SLOCHNG

#define SQLITE_FUNC_SLOCHNG

Definition sqlite3.c:17157

zName

char * zName

Definition sqlite3.c:22329

SQLITE_UTF8

#define SQLITE_UTF8

Definition sqlite3.c:6252

Definition at line 17255 of file sqlite3.c.

  {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
         SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
   SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterDateTimeFunctions().

◆ DIRECT_MODE

#define DIRECT_MODE 0

◆ DirSep

#define DirSep ( X ) ((X)=='/')

Definition at line 124720 of file sqlite3.c.

Referenced by sqlite3LoadExtension().

◆ disable_simulated_io_errors [1/2]

#define disable_simulated_io_errors ( )

Definition at line 14988 of file sqlite3.c.

Referenced by sqlite3PagerClose(), and vdbeCommit().

◆ disable_simulated_io_errors [2/2]

#define disable_simulated_io_errors ( )

Definition at line 14988 of file sqlite3.c.

◆ DisableLookaside

#define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0

Definition at line 16740 of file sqlite3.c.

Referenced by fkActionTrigger(), sqlite3AnalysisLoad(), sqlite3OomFault(), and sqlite3ViewGetColumnNames().

◆ DO_OS_MALLOC_TEST

#define DO_OS_MALLOC_TEST ( x )

Definition at line 23034 of file sqlite3.c.

Referenced by sqlite3OsAccess(), sqlite3OsFullPathname(), and sqlite3OsOpen().

◆ DOTLOCK_SUFFIX

#define DOTLOCK_SUFFIX ".lock"

Definition at line 35764 of file sqlite3.c.

◆ EIGHT_BYTE_ALIGNMENT

#define EIGHT_BYTE_ALIGNMENT ( X ) ((((char*)(X) - (char*)0)&7)==0)

Definition at line 14491 of file sqlite3.c.

Referenced by allocSpace(), balance_nonroot(), sqlite3BtreeCursorHasMoved(), sqlite3CreateIndex(), sqlite3Malloc(), sqlite3PagerOpen(), sqlite3VdbeMakeReady(), sqlite3VdbeMemStringify(), sqlite3VdbeRecordUnpack(), and sqlite3WhereBegin().

◆ enable_simulated_io_errors [1/2]

#define enable_simulated_io_errors ( )

Definition at line 14989 of file sqlite3.c.

Referenced by sqlite3PagerClose(), and vdbeCommit().

◆ enable_simulated_io_errors [2/2]

#define enable_simulated_io_errors ( )

Definition at line 14989 of file sqlite3.c.

◆ EnableLookaside

#define EnableLookaside

Value:

db->lookaside.bDisable--;\

db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue

Definition at line 16741 of file sqlite3.c.

16741#define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0

16742#define EnableLookaside db->lookaside.bDisable--;\

Referenced by fkActionTrigger(), sqlite3AnalysisLoad(), sqlite3OomClear(), and sqlite3ViewGetColumnNames().

◆ ENAME_NAME

#define ENAME_NAME 0 /* The AS clause of a result set */

Definition at line 18203 of file sqlite3.c.

Referenced by generateColumnNames(), lookupName(), renameColumnElistNames(), resolveAsName(), sqlite3ColumnsFromExprList(), and sqlite3ExprListSetName().

◆ ENAME_SPAN

#define ENAME_SPAN 1 /* Complete text of the result set expression */

Definition at line 18204 of file sqlite3.c.

Referenced by sqlite3ExprListSetSpan().

◆ ENAME_TAB

#define ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */

Definition at line 18205 of file sqlite3.c.

Referenced by selectExpander(), and sqlite3MatchEName().

◆ ENC

#define ENC ( db ) ((db)->enc)

Definition at line 16961 of file sqlite3.c.

Referenced by analyzeAggregate(), attachFunc(), callCollNeeded(), resolveExprStep(), sqlite3CheckCollSeq(), sqlite3ColumnDefault(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3Init(), sqlite3InitOne(), sqlite3LocateCollSeq(), sqlite3Pragma(), sqlite3Reindex(), sqlite3StartTable(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeMemSetStr(), and valueNew().

◆ EP_Agg

#define EP_Agg 0x000010 /* Contains one or more aggregate functions */

Definition at line 18064 of file sqlite3.c.

Referenced by lookupName(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ EP_Alias

#define EP_Alias 0x400000 /* Is an alias for a result set column */

Definition at line 18082 of file sqlite3.c.

Referenced by lookupName(), and resolveAlias().

◆ EP_CanBeNull

#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */

Definition at line 18080 of file sqlite3.c.

Referenced by lookupName(), sqlite3ExprCanBeNull(), and substExpr().

◆ EP_Collate

#define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */

Definition at line 18068 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery(), multiSelectOrderByKeyInfo(), selectWindowRewriteExprCb(), sqlite3BinaryCompareCollSeq(), sqlite3ExprCollSeq(), and substExpr().

◆ EP_Commuted

#define EP_Commuted 0x000200 /* Comparison operator has been commuted */

Definition at line 18069 of file sqlite3.c.

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprCompareCollSeq(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ EP_ConstFunc

#define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */

Definition at line 18079 of file sqlite3.c.

Referenced by exprNodeIsConstant(), and resolveExprStep().

◆ EP_DblQuoted

#define EP_DblQuoted 0x000040 /* token.z was originally in "..." */

Definition at line 18066 of file sqlite3.c.

Referenced by lookupName().

◆ EP_Distinct

#define EP_Distinct 0x000002 /* Aggregate function with DISTINCT keyword */

Definition at line 18061 of file sqlite3.c.

Referenced by analyzeAggregate(), isSimpleCount(), and sqlite3ExprCompare().

◆ EP_FixedCol

#define EP_FixedCol 0x000008 /* TK_Column with a known fixed value */

Definition at line 18063 of file sqlite3.c.

Referenced by constInsert(), exprNodeIsConstant(), propagateConstantExprRewrite(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3WhereExprUsageNN(), and substExpr().

◆ EP_FromDDL

#define EP_FromDDL 0x40000000 /* Originates from sqlite_schema */

Definition at line 18090 of file sqlite3.c.

Referenced by exprNodeIsConstant(), resolveExprStep(), and sqlite3ExprFunctionUsable().

◆ EP_FromJoin

#define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */

◆ EP_HasFunc

#define EP_HasFunc 0x000004 /* Contains one or more functions of any kind */

Definition at line 18062 of file sqlite3.c.

Referenced by selectExpander(), and sqlite3ExprCodeRunJustOnce().

◆ EP_Immutable

#define EP_Immutable 0x02 /* Do not change this Expr node */

Definition at line 18114 of file sqlite3.c.

Referenced by codeVectorCompare(), exprDup(), sqlite3ExprCode(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ EP_InfixFunc

#define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */

Definition at line 18067 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and yy_reduce().

◆ EP_IntValue

#define EP_IntValue 0x000400 /* Integer value contained in u.iValue */

Definition at line 18070 of file sqlite3.c.

Referenced by analyzeAggregate(), codeInteger(), dupedExprNodeSize(), exprDup(), multiSelectOrderBy(), resolveAlias(), resolveCompoundOrderBy(), selectExpander(), sqlite3ColumnsFromExprList(), sqlite3ExprAffinity(), sqlite3ExprAlloc(), sqlite3ExprAssignVarNumber(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprIsInteger(), and valueFromExpr().

◆ EP_IsFalse

#define EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */

Definition at line 18089 of file sqlite3.c.

Referenced by sqlite3ExprAlloc(), and sqlite3IsTrueOrFalse().

◆ EP_IsTrue

#define EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */

Definition at line 18088 of file sqlite3.c.

Referenced by sqlite3ExprAlloc(), and sqlite3IsTrueOrFalse().

◆ EP_Leaf

#define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */

Definition at line 18083 of file sqlite3.c.

Referenced by exprDup(), lookupName(), propagateConstantExprRewrite(), sqlite3ExprAlloc(), sqlite3WhereExprUsageNN(), tokenExpr(), and walkExpr().

◆ EP_MemToken

#define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */

Definition at line 18076 of file sqlite3.c.

Referenced by dupedExprStructSize(), exprDup(), and resolveAlias().

◆ EP_NoReduce

#define EP_NoReduce 0x01 /* Cannot EXPRDUP_REDUCE this Expr */

Definition at line 18113 of file sqlite3.c.

Referenced by addWhereTerm(), analyzeAggregate(), dupedExprStructSize(), lookupName(), sqlite3CodeSubselect(), and sqlite3SetJoinExpr().

◆ EP_Propagate

#define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)

Definition at line 18097 of file sqlite3.c.

Referenced by exprSetHeight(), sqlite3ExprAttachSubtrees(), and yy_reduce().

◆ EP_Quoted

#define EP_Quoted 0x4000000 /* TK_ID was originally quoted */

Definition at line 18086 of file sqlite3.c.

Referenced by sqlite3ExprIdToTrueFalse().

◆ EP_Reduced

#define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */

Definition at line 18073 of file sqlite3.c.

Referenced by addWhereTerm(), agginfoPersistExprCb(), analyzeAggregate(), dupedExprStructSize(), exprDup(), exprStructSize(), lookupName(), resolveAlias(), resolveExprStep(), sqlite3CodeRhsOfIN(), sqlite3ExprAssignVarNumber(), sqlite3ExprCompare(), sqlite3SetJoinExpr(), and walkExpr().

◆ EP_Skip

#define EP_Skip 0x001000 /* Operator does not contribute to affinity */

Definition at line 18072 of file sqlite3.c.

Referenced by exprToRegister(), sqlite3AddDefaultValue(), sqlite3ExprAffinity(), sqlite3ExprSkipCollateAndLikely(), substExpr(), and whereIndexExprTransNode().

◆ EP_Static

#define EP_Static 0x8000000 /* Held in memory not obtained from malloc() */

Definition at line 18087 of file sqlite3.c.

Referenced by exprDup(), resolveAlias(), and selectWindowRewriteExprCb().

◆ EP_Subquery

#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */

Definition at line 18081 of file sqlite3.c.

Referenced by selectExpander(), sqlite3ExprCode(), and substExpr().

◆ EP_Subrtn

#define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */

Definition at line 18085 of file sqlite3.c.

Referenced by sqlite3CodeRhsOfIN(), and sqlite3CodeSubselect().

◆ EP_TokenOnly

#define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */

Definition at line 18074 of file sqlite3.c.

Referenced by addWhereTerm(), agginfoPersistExprCb(), analyzeAggregate(), dupedExprStructSize(), exprDup(), exprStructSize(), lookupName(), resolveAlias(), sqlite3CodeRhsOfIN(), sqlite3ExprAssignVarNumber(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3SetJoinExpr(), sqlite3WhereExprUsageNN(), valueFromExpr(), and walkExpr().

◆ EP_Unlikely

#define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */

Definition at line 18078 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3ExprSkipCollateAndLikely(), whereClauseInsert(), and whereIndexExprTransNode().

◆ EP_VarSelect

#define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */

Definition at line 18065 of file sqlite3.c.

Referenced by isCandidateForInOpt(), resolveExprStep(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), and sqlite3WhereExprUsageNN().

◆ EP_Win

#define EP_Win 0x008000 /* Contains window functions */

Definition at line 18075 of file sqlite3.c.

Referenced by lookupName(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ EP_WinFunc

#define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */

Definition at line 18084 of file sqlite3.c.

Referenced by dupedExprStructSize(), exprDup(), exprNodeIsConstant(), gatherSelectWindowsCallback(), isSimpleCount(), minMaxQuery(), resolveAlias(), resolveExprStep(), selectWindowRewriteExprCb(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3FunctionUsesThisSrc(), sqlite3Select(), substExpr(), updateAccumulator(), and walkExpr().

◆ EP_xIsSelect

#define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */

◆ etBUFSIZE

#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */

Definition at line 28329 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etCHARX

#define etCHARX 8 /* Characters. %c */

Definition at line 28161 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etDECIMAL

#define etDECIMAL 16 /* %d or %u, but not %x, %o */

Definition at line 28170 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etDYNSTRING

#define etDYNSTRING 6 /* Dynamically allocated strings. %z */

Definition at line 28159 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etEXP

#define etEXP 2 /* Exponentional notation. %e and %E */

Definition at line 28155 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etFLOAT

#define etFLOAT 1 /* Floating point. %f */

Definition at line 28154 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etGENERIC

#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */

Definition at line 28156 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etINVALID

#define etINVALID 17 /* Any unrecognized conversion type */

Definition at line 28172 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etORDINAL

#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */

Definition at line 28169 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etPERCENT

#define etPERCENT 7 /* Percent symbol. %% */

Definition at line 28160 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etPOINTER

#define etPOINTER 13 /* The %p conversion */

Definition at line 28167 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etRADIX

#define etRADIX 0 /* non-decimal integer types. %x %o */

Definition at line 28153 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSIZE

#define etSIZE 4 /* Return number of characters processed so far. %n */

Definition at line 28157 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSQLESCAPE

#define etSQLESCAPE 9 /* Strings with '\'' doubled. %q */

Definition at line 28163 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSQLESCAPE2

#define etSQLESCAPE2

Value:

10 /* Strings with '\'' doubled and enclosed in '',

NULL pointers replaced by SQL NULL. %Q */

Definition at line 28164 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSQLESCAPE3

#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */

Definition at line 28168 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSRCLIST

#define etSRCLIST 12 /* a pointer to a SrcList */

Definition at line 28166 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etSTRING

#define etSTRING 5 /* Strings. %s */

Definition at line 28158 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ etTOKEN

#define etTOKEN 11 /* a pointer to a Token structure */

Definition at line 28165 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ EXCLUDED_TABLE_NUMBER

#define EXCLUDED_TABLE_NUMBER 2

Definition at line 97771 of file sqlite3.c.

Referenced by lookupName().

◆ EXCLUSIVE_LOCK

#define EXCLUSIVE_LOCK 4

Definition at line 16363 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_playback_one_page(), pager_truncate(), pager_wait_on_lock(), pager_write_pagelist(), pagerLockDb(), pagerOpenWal(), sqlite3PagerBegin(), sqlite3PagerExclusiveLock(), sqlite3PagerOpen(), sqlite3PagerSharedLock(), and unixLock().

◆ EXP754

#define EXP754 (((u64)0x7ff)<<52)

Definition at line 19432 of file sqlite3.c.

◆ ExpandBlob

#define ExpandBlob ( P ) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)

Definition at line 21321 of file sqlite3.c.

Referenced by computeNumericType(), sqlite3_value_blob(), sqlite3VdbeExec(), sqlite3VdbeMemMakeWriteable(), and valueToText().

◆ ExplainQueryPlan

#define ExplainQueryPlan ( P ) sqlite3VdbeExplain P

Definition at line 15830 of file sqlite3.c.

Referenced by explainTempTable(), generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), multiSelectValues(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3FindInIndex(), sqlite3Select(), and sqlite3WhereBegin().

◆ ExplainQueryPlanParent

#define ExplainQueryPlanParent ( P ) sqlite3VdbeExplainParent(P)

Definition at line 15832 of file sqlite3.c.

Referenced by sqlite3Select().

◆ ExplainQueryPlanPop

#define ExplainQueryPlanPop ( P ) sqlite3VdbeExplainPop(P)

Definition at line 15831 of file sqlite3.c.

Referenced by multiSelect(), multiSelectOrderBy(), and sqlite3Select().

◆ explainSetInteger

#define explainSetInteger	(		a,
			b ) a = b

Definition at line 130712 of file sqlite3.c.

◆ EXPR_FULLSIZE

#define EXPR_FULLSIZE sizeof(Expr) /* Full size */

Definition at line 18135 of file sqlite3.c.

Referenced by dupedExprStructSize(), exprDup(), and exprStructSize().

◆ EXPR_REDUCEDSIZE

#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */

Definition at line 18136 of file sqlite3.c.

Referenced by dupedExprStructSize(), and exprStructSize().

◆ EXPR_TOKENONLYSIZE

#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */

Definition at line 18137 of file sqlite3.c.

Referenced by dupedExprStructSize(), and exprStructSize().

◆ ExprAlwaysFalse

#define ExprAlwaysFalse ( E ) (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse)

Definition at line 18108 of file sqlite3.c.

Referenced by sqlite3ExprAnd(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3ExprSimplifiedAndOr().

◆ ExprAlwaysTrue

#define ExprAlwaysTrue ( E ) (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue)

Definition at line 18107 of file sqlite3.c.

Referenced by sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3ExprSimplifiedAndOr().

◆ ExprClearProperty

#define ExprClearProperty	(		E,
			P ) (E)->flags&=~(P)

Definition at line 18106 of file sqlite3.c.

Referenced by exprToRegister(), propagateConstantExprRewrite(), selectWindowRewriteExprCb(), sqlite3CodeRhsOfIN(), substExpr(), unsetJoinExpr(), and whereIndexExprTransNode().

◆ ExprClearVVAProperties

#define ExprClearVVAProperties ( E )

Definition at line 18127 of file sqlite3.c.

Referenced by exprDup(), sqlite3ExprCodeTarget(), and tokenExpr().

◆ EXPRDUP_REDUCE

#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */

Definition at line 18143 of file sqlite3.c.

Referenced by dupedExprSize(), dupedExprStructSize(), exprDup(), fkActionTrigger(), sqlite3AddDefaultValue(), sqlite3BeginTrigger(), sqlite3ExprListDup(), sqlite3TriggerDeleteStep(), sqlite3TriggerInsertStep(), and sqlite3TriggerUpdateStep().

◆ ExprHasAllProperty

#define ExprHasAllProperty	(		E,
			P ) (((E)->flags&(P))==(P))

Definition at line 18104 of file sqlite3.c.

◆ ExprHasProperty

#define ExprHasProperty	(		E,
			P ) (((E)->flags&(P))!=0)

Definition at line 18103 of file sqlite3.c.

Referenced by addWhereTerm(), agginfoPersistExprCb(), allocateIndexInfo(), analyzeAggregate(), codeVectorCompare(), columnTypeImpl(), constInsert(), constructAutomaticIndex(), disableTerm(), dupedExprNodeSize(), dupedExprStructSize(), exprAnalyze(), exprAnalyzeOrTerm(), exprCodeBetween(), exprDup(), exprImpliesNotNull(), exprNodeIsConstant(), exprSetHeight(), exprStructSize(), findConstInWhere(), gatherSelectWindowsCallback(), impliesNotNullRow(), isCandidateForInOpt(), isSimpleCount(), lookupName(), minMaxQuery(), propagateConstantExprRewrite(), pushDownWhereTerms(), resetAccumulator(), resolveAlias(), resolveExprStep(), selectExpander(), selectWindowRewriteExprCb(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3ColumnsFromExprList(), sqlite3ExprAffinity(), sqlite3ExprAssignVarNumber(), sqlite3ExprCanBeNull(), sqlite3ExprCode(), sqlite3ExprCodeIN(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3ExprCompare(), sqlite3ExprCompareCollSeq(), sqlite3ExprFunctionUsable(), sqlite3ExprIdToTrueFalse(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprSkipCollateAndLikely(), sqlite3FindInIndex(), sqlite3FunctionUsesThisSrc(), sqlite3InRhsIsConstant(), sqlite3IsLikeFunction(), sqlite3Select(), sqlite3SetJoinExpr(), sqlite3WhereBegin(), sqlite3WhereExprUsageNN(), substExpr(), termCanDriveIndex(), termIsEquivalence(), unsetJoinExpr(), updateAccumulator(), valueFromExpr(), walkExpr(), whereClauseInsert(), whereIndexExprTransNode(), whereLoopAddBtreeIndex(), and whereScanNext().

◆ ExprHasVVAProperty

#define ExprHasVVAProperty	(		E,
			P ) 0

Definition at line 18126 of file sqlite3.c.

Referenced by codeVectorCompare(), dupedExprStructSize(), sqlite3ExprCode(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ ExprIsVtab

#define ExprIsVtab ( X ) ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)

Definition at line 17557 of file sqlite3.c.

17557** table support is omitted from the build.

17558*/

is

Referenced by isAuxiliaryVtabOperator().

◆ ExprSetProperty

#define ExprSetProperty	(		E,
			P ) (E)->flags\|=(P)

Definition at line 18105 of file sqlite3.c.

Referenced by addWhereTerm(), exprAnalyze(), exprNodeIsConstant(), lookupName(), propagateConstantExprRewrite(), resolveAlias(), resolveExprStep(), selectWindowRewriteExprCb(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3ExprIdToTrueFalse(), sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), sqlite3SetJoinExpr(), and substExpr().

◆ ExprSetVVAProperty

#define ExprSetVVAProperty	(		E,
			P )

Definition at line 18125 of file sqlite3.c.

Referenced by addWhereTerm(), analyzeAggregate(), exprDup(), lookupName(), sqlite3CodeSubselect(), and sqlite3SetJoinExpr().

◆ fdatasync

#define fdatasync fsync

Definition at line 37083 of file sqlite3.c.

Referenced by full_fsync().

◆ fileChunkSize

#define fileChunkSize ( nChunkSize ) (sizeof(FileChunk) + ((nChunkSize)-8))

Definition at line 97121 of file sqlite3.c.

Referenced by sqlite3JournalOpen().

◆ FILEHANDLEID

#define FILEHANDLEID ( fd ) (SQLITE_PTR_TO_INT(fd))

Definition at line 51834 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ findCell

#define findCell	(		P,
			I ) ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))

Definition at line 65569 of file sqlite3.c.

65569**

65570** findCellPastPtr() does the same except it skips past the initial

findCellPastPtr

#define findCellPastPtr(P, I)

Definition sqlite3.c:65571

Referenced by balance_nonroot(), balance_quick(), btreePrevious(), modifyPagePointer(), moveToLeftmost(), setChildPtrmaps(), sqlite3BtreeCount(), sqlite3BtreeDelete(), sqlite3BtreeInsert(), and sqlite3BtreeMovetoUnpacked().

◆ findCellPastPtr

#define findCellPastPtr	(		P,
			I ) ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))

Definition at line 65571 of file sqlite3.c.

65571** 4-byte child pointer found on interior pages, if there is one.

65572**

Referenced by sqlite3BtreeMovetoUnpacked().

◆ first_valueInvFunc

#define first_valueInvFunc noopStepFunc

Definition at line 151447 of file sqlite3.c.

◆ first_valueValueFunc

#define first_valueValueFunc noopValueFunc

Definition at line 151448 of file sqlite3.c.

◆ FLAG_SIGNED

#define FLAG_SIGNED 1 /* True if the value to convert is signed */

Definition at line 28196 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ FLAG_STRING

#define FLAG_STRING 4 /* Allow infinite precision */

Definition at line 28197 of file sqlite3.c.

◆ FOUR_BYTE_INT

#define FOUR_BYTE_INT ( x ) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])

Definition at line 81576 of file sqlite3.c.

◆ FOUR_BYTE_UINT

#define FOUR_BYTE_UINT ( x ) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])

Definition at line 81575 of file sqlite3.c.

Referenced by serialGet(), vdbeRecordCompareInt(), and vdbeRecordDecodeInt().

◆ FTS5_TOKEN_COLOCATED

#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */

Definition at line 13172 of file sqlite3.c.

◆ FTS5_TOKENIZE_AUX

#define FTS5_TOKENIZE_AUX 0x0008

Definition at line 13168 of file sqlite3.c.

◆ FTS5_TOKENIZE_DOCUMENT

#define FTS5_TOKENIZE_DOCUMENT 0x0004

Definition at line 13167 of file sqlite3.c.

◆ FTS5_TOKENIZE_PREFIX

#define FTS5_TOKENIZE_PREFIX 0x0002

Definition at line 13166 of file sqlite3.c.

◆ FTS5_TOKENIZE_QUERY

#define FTS5_TOKENIZE_QUERY 0x0001

Definition at line 13165 of file sqlite3.c.

◆ FULLY_WITHIN

#define FULLY_WITHIN 2 /* Object fully contained within query region */

Definition at line 10974 of file sqlite3.c.

◆ FUNC_PERFECT_MATCH

#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */

Definition at line 115833 of file sqlite3.c.

Referenced by matchQuality(), and sqlite3FindFunction().

◆ FUNCTION

#define FUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL

Definition sqlite3.c:17149

Definition at line 17239 of file sqlite3.c.

**     FuncDef.flags variable is set to the value passed as the flags
**     parameter.
*/

Referenced by sqlite3RegisterBuiltinFunctions().

◆ FUNCTION2

#define FUNCTION2	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc,
		extraFlags )

Value:

{nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Definition at line 17261 of file sqlite3.c.

#define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
   (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ GCC_VERSION

#define GCC_VERSION 0

Definition at line 985 of file sqlite3.c.

◆ get2byte

#define get2byte ( x ) ((x)[0]<<8 | (x)[1])

Definition at line 64163 of file sqlite3.c.

Referenced by allocateSpace(), btreeInitPage(), checkTreePage(), copyNodeContent(), defragmentPage(), dropCell(), freeSpace(), insertCell(), pageFindSlot(), and rebuildPage().

◆ get2byteAligned

#define get2byteAligned ( x ) ((x)[0]<<8 | (x)[1])

Definition at line 64180 of file sqlite3.c.

Referenced by balance_nonroot(), checkTreePage(), and editPage().

◆ get2byteNotZero

#define get2byteNotZero ( X ) (((((int)get2byte(X))-1)&0xffff)+1)

Definition at line 64521 of file sqlite3.c.

Referenced by allocateSpace(), balance_nonroot(), btreeInitPage(), checkTreePage(), and editPage().

◆ get4byte

◆ getVarint

#define getVarint sqlite3GetVarint

Definition at line 19875 of file sqlite3.c.

Referenced by sqlite3BtreeMovetoUnpacked().

◆ getVarint32

#define getVarint32	(		A,
			B ) (u8)(((A)<(u8)0x80)?((B)=(u32)(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))

Definition at line 19868 of file sqlite3.c.

19868/*

19869** The common case is for a varint to be a single byte. They following

Referenced by sqlite3VdbeExec(), sqlite3VdbeRecordCompareWithSkip(), and sqlite3VdbeRecordUnpack().

◆ getVarint32NR

#define getVarint32NR	(		A,
			B ) B=(u32)(A);if(B>=0x80)sqlite3GetVarint32((A),(u32)&(B))

Definition at line 19870 of file sqlite3.c.

19870** macros handle the common case without a procedure call, but then call

19871** the procedure for larger varints.

Referenced by sqlite3VdbeIdxRowid(), sqlite3VdbeRecordCompareWithSkip(), and vdbeSorterCompareText().

◆ GLOBAL

#define GLOBAL	(		t,
			v ) v

Definition at line 14633 of file sqlite3.c.

Referenced by removeFromSharingList(), sqlite3BtreeOpen(), sqlite3MutexEnd(), and sqlite3MutexInit().

◆ harmless

#define harmless ( X )

Definition at line 13757 of file sqlite3.c.

Referenced by btreeNext().

◆ HAS_UPDATE_HOOK

#define HAS_UPDATE_HOOK ( DB ) ((DB)->xUpdateCallback)

Definition at line 85328 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ HASHTABLE_HASH_1

#define HASHTABLE_HASH_1 383 /* Should be prime */

Definition at line 59928 of file sqlite3.c.

Referenced by walNextHash().

◆ HASHTABLE_NPAGE

#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */

Definition at line 59927 of file sqlite3.c.

Referenced by walFramePage(), walHashGet(), walIndexRecover(), walIteratorInit(), and walMergesort().

◆ HASHTABLE_NPAGE_ONE

#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))

Definition at line 59936 of file sqlite3.c.

Referenced by walCleanupHash(), walFramePage(), walHashGet(), and walIndexRecover().

◆ HASHTABLE_NSLOT

#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */

Definition at line 59929 of file sqlite3.c.

Referenced by sqlite3WalFindFrame(), walCleanupHash(), walIndexAppend(), and walNextHash().

◆ HasRowid

#define HasRowid ( X ) (((X)->tabFlags & TF_WithoutRowid)==0)

◆ HAVE_FCHOWN

#define HAVE_FCHOWN 1

Definition at line 929 of file sqlite3.c.

◆ HAVE_FULLFSYNC

#define HAVE_FULLFSYNC 0

Definition at line 37094 of file sqlite3.c.

Referenced by unixSync().

◆ HAVE_GETHOSTUUID

#define HAVE_GETHOSTUUID 0

Definition at line 33465 of file sqlite3.c.

◆ HAVE_LSTAT

#define HAVE_LSTAT 1

Definition at line 931 of file sqlite3.c.

◆ HAVE_MREMAP

#define HAVE_MREMAP 0

Definition at line 33877 of file sqlite3.c.

◆ HAVE_READLINK

#define HAVE_READLINK 1

Definition at line 930 of file sqlite3.c.

◆ HI

#define HI ( X ) ((u64)(X)<<32)

Definition at line 16968 of file sqlite3.c.

◆ IdChar

#define IdChar ( C ) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)

Definition at line 159903 of file sqlite3.c.

Referenced by sqlite3_complete(), and sqlite3GetToken().

◆ IfNotOmitAV

#define IfNotOmitAV ( expr ) (expr)

Definition at line 64537 of file sqlite3.c.

Referenced by allocateBtreePage(), and sqlite3BtreeBeginTrans().

◆ IgnorableOrderby

#define IgnorableOrderby ( X ) ((X->eDest)<=SRT_DistQueue)

Definition at line 18578 of file sqlite3.c.

Referenced by sqlite3Select().

◆ IN_DECLARE_VTAB

#define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)

Definition at line 18800 of file sqlite3.c.

Referenced by sqlite3CreateForeignKey(), and sqlite3CreateIndex().

◆ IN_INDEX_EPH

#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */

Definition at line 20229 of file sqlite3.c.

Referenced by sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_INDEX_INDEX_ASC

#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */

Definition at line 20230 of file sqlite3.c.

Referenced by sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_INDEX_INDEX_DESC

#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */

Definition at line 20231 of file sqlite3.c.

Referenced by codeEqualityTerm(), sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_INDEX_LOOP

#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */

Definition at line 20238 of file sqlite3.c.

Referenced by codeEqualityTerm(), and sqlite3FindInIndex().

◆ IN_INDEX_MEMBERSHIP

#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */

Definition at line 20237 of file sqlite3.c.

Referenced by sqlite3ExprCodeIN().

◆ IN_INDEX_NOOP

#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */

Definition at line 20232 of file sqlite3.c.

Referenced by codeEqualityTerm(), sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_INDEX_NOOP_OK

#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */

Definition at line 20236 of file sqlite3.c.

Referenced by sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_INDEX_ROWID

#define IN_INDEX_ROWID 1 /* Search the rowid of the table */

Definition at line 20228 of file sqlite3.c.

Referenced by codeEqualityTerm(), sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ IN_RENAME_OBJECT

#define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)

◆ IN_SPECIAL_PARSE

#define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)

Definition at line 18812 of file sqlite3.c.

Referenced by sqlite3AuthCheck(), sqlite3CreateIndex(), sqlite3RunParser(), and sqlite3StartTable().

◆ INCRINIT_NORMAL

#define INCRINIT_NORMAL 0

Definition at line 95957 of file sqlite3.c.

Referenced by vdbeMergeEngineInit(), vdbePmaReaderIncrMergeInit(), and vdbeSorterSetupMerge().

◆ INCRINIT_ROOT

#define INCRINIT_ROOT 2

Definition at line 95959 of file sqlite3.c.

Referenced by vdbeMergeEngineInit(), vdbePmaReaderIncrMergeInit(), and vdbeSorterSetupMerge().

◆ INCRINIT_TASK

#define INCRINIT_TASK 1

Definition at line 95958 of file sqlite3.c.

Referenced by vdbePmaReaderBgIncrInit(), vdbePmaReaderIncrInit(), vdbePmaReaderIncrMergeInit(), and vdbeSorterSetupMerge().

◆ INITFLAG_AlterTable

#define INITFLAG_AlterTable 0x0001 /* This is a reparse after ALTER TABLE */

Definition at line 19001 of file sqlite3.c.

Referenced by corruptSchema(), and sqlite3VdbeExec().

◆ initMaskSet

#define initMaskSet ( P ) (P)->n=0

Definition at line 141312 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ INLINE_FUNC

#define INLINE_FUNC	(	zName,
		nArg,
		iArg,
		mFlags )

Value:

{nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \

SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }

Definition at line 17248 of file sqlite3.c.

#define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_affinity

#define INLINEFUNC_affinity 4

Definition at line 17172 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_coalesce

#define INLINEFUNC_coalesce 0

Definition at line 17168 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_expr_compare

#define INLINEFUNC_expr_compare 3

Definition at line 17171 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_expr_implies_expr

#define INLINEFUNC_expr_implies_expr 2

Definition at line 17170 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_iif

#define INLINEFUNC_iif 5

Definition at line 17173 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_implies_nonnull_row

#define INLINEFUNC_implies_nonnull_row 1

Definition at line 17169 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INLINEFUNC_unlikely

#define INLINEFUNC_unlikely 99 /* Default case */

Definition at line 17174 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ INT16_TYPE

#define INT16_TYPE short int

Definition at line 14309 of file sqlite3.c.

◆ INT8_TYPE

#define INT8_TYPE signed char

Definition at line 14323 of file sqlite3.c.

◆ INT_464269060799999

#define INT_464269060799999 ((((i64)0x1a640)<<32)|0x1072fdff)

Definition at line 22114 of file sqlite3.c.

Referenced by validJulianDay().

◆ INTERFACE

#define INTERFACE 1

Definition at line 154473 of file sqlite3.c.

◆ INTERNAL_FUNCTION

#define INTERNAL_FUNCTION	(	zName,
		nArg,
		xFunc )

Value:

{nArg, SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \

0, 0, xFunc, 0, 0, 0, #zName, {0} }

Definition at line 17273 of file sqlite3.c.

#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}

◆ invalidateOverflowCache

#define invalidateOverflowCache ( pCur ) (pCur->curFlags &= ~BTCF_ValidOvfl)

Definition at line 64981 of file sqlite3.c.

Referenced by invalidateAllOverflowCache(), and sqlite3BtreeInsert().

◆ IOMETHODS

#define IOMETHODS	(	FINDER,
		METHOD,
		VERSION,
		CLOSE,
		LOCK,
		UNLOCK,
		CKLOCK,
		SHMMAP )

Value:

static const sqlite3_io_methods METHOD = {                                   \
   VERSION,                    /* iVersion */                                \
   CLOSE,                      /* xClose */                                  \
   unixRead,                   /* xRead */                                   \
   unixWrite,                  /* xWrite */                                  \
   unixTruncate,               /* xTruncate */                               \
   unixSync,                   /* xSync */                                   \
   unixFileSize,               /* xFileSize */                               \
   LOCK,                       /* xLock */                                   \
   UNLOCK,                     /* xUnlock */                                 \
   CKLOCK,                     /* xCheckReservedLock */                      \
   unixFileControl,            /* xFileControl */                            \
   unixSectorSize,             /* xSectorSize */                             \
   unixDeviceCharacteristics,  /* xDeviceCapabilities */                     \
   SHMMAP,                     /* xShmMap */                                 \
   unixShmLock,                /* xShmLock */                                \
   unixShmBarrier,             /* xShmBarrier */                             \
   unixShmUnmap,               /* xShmUnmap */                               \
   unixFetch,                  /* xFetch */                                  \
   unixUnfetch,                /* xUnfetch */                                \
};                                                                           \
static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){   \
  UNUSED_PARAMETER(z); UNUSED_PARAMETER(p);                                  \
  return &METHOD;                                                            \
}                                                                            \
static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p)    \
    = FINDER##Impl;

Definition at line 38810 of file sqlite3.c.

**   *  A constant sqlite3_io_methods object call METHOD that has locking
**      methods CLOSE, LOCK, UNLOCK, CKRESLOCK.
**
**   *  An I/O method finder function called FINDER that returns a pointer
**      to the METHOD object in the previous bullet.
*/
#define IOMETHODS(FINDER,METHOD,VERSION,CLOSE,LOCK,UNLOCK,CKLOCK,SHMMAP)     \
static const sqlite3_io_methods METHOD = {                                   \
   VERSION,                    /* iVersion */                                \
   CLOSE,                      /* xClose */                                  \
   unixRead,                   /* xRead */                                   \
   unixWrite,                  /* xWrite */                                  \
   unixTruncate,               /* xTruncate */                               \
   unixSync,                   /* xSync */                                   \
   unixFileSize,               /* xFileSize */                               \
   LOCK,                       /* xLock */                                   \
   UNLOCK,                     /* xUnlock */                                 \
   CKLOCK,                     /* xCheckReservedLock */                      \
   unixFileControl,            /* xFileControl */                            \
   unixSectorSize,             /* xSectorSize */                             \
   unixDeviceCharacteristics,  /* xDeviceCapabilities */                     \
   SHMMAP,                     /* xShmMap */                                 \
   unixShmLock,                /* xShmLock */                                \
   unixShmBarrier,             /* xShmBarrier */                             \
   unixShmUnmap,               /* xShmUnmap */                               \
   unixFetch,                  /* xFetch */                                  \
   unixUnfetch,                /* xUnfetch */                                \
};                                                                           \

◆ IOTRACE

#define IOTRACE ( A )

Definition at line 20290 of file sqlite3.c.

Referenced by getPageNormal(), pager_write_pagelist(), pagerLockDb(), pagerUnlockDb(), readDbPage(), sqlite3PagerClose(), sqlite3PagerCommitPhaseOne(), sqlite3PagerDontWrite(), sqlite3PagerMovepage(), sqlite3PagerOpen(), sqlite3PagerReadFileheader(), sqlite3PagerSharedLock(), syncJournal(), writeJournalHdr(), and zeroJournalHdr().

◆ IS_BIG_INT

#define IS_BIG_INT ( X ) (((X)&~(i64)0xffffffff)!=0)

Definition at line 13828 of file sqlite3.c.

Referenced by walCheckpoint().

◆ IS_LOCK_ERROR

#define IS_LOCK_ERROR ( x ) ((x != SQLITE_OK) && (x != SQLITE_BUSY))

Definition at line 33537 of file sqlite3.c.

Referenced by posixUnlock().

◆ ISAUTOVACUUM

#define ISAUTOVACUUM (pBt->autoVacuum)

Definition at line 64127 of file sqlite3.c.

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), copyNodeContent(), freePage2(), and sqlite3BtreeInsert().

◆ IsHiddenColumn

#define IsHiddenColumn ( X ) (((X)->colFlags & COLFLAG_HIDDEN)!=0)

Definition at line 17574 of file sqlite3.c.

Referenced by selectExpander(), sqliteProcessJoin(), and tableAndColumnIndex().

◆ isMalloced

#define isMalloced ( X ) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)

Definition at line 18981 of file sqlite3.c.

Referenced by sqlite3StrAccumEnlarge(), and strAccumFinishRealloc().

◆ IsNaN

#define IsNaN ( X ) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)

Definition at line 19434 of file sqlite3.c.

Referenced by sqlite3IsNaN().

◆ isOpen

#define isOpen ( pFd ) ((pFd)->pMethods!=0)

Definition at line 52503 of file sqlite3.c.

Referenced by getPageNormal(), hasHotJournal(), jrnlBufferSize(), lockBtree(), openSubJournal(), pager_delsuper(), pager_end_transaction(), pager_incr_changecounter(), pager_open_journal(), pager_playback(), pager_playback_one_page(), pager_truncate(), pager_unlock(), pager_write(), pager_write_pagelist(), pagerFlushOnCommit(), pagerOpenSavepoint(), pagerOpentemp(), pagerPagecount(), pagerUnlockDb(), readDbPage(), readJournalHdr(), setSectorSize(), sqlite3PagerClose(), sqlite3PagerCommitPhaseOne(), sqlite3PagerOkToChangeJournalMode(), sqlite3PagerOpen(), sqlite3PagerReadFileheader(), sqlite3PagerRollback(), sqlite3PagerSavepoint(), sqlite3PagerSetJournalMode(), sqlite3PagerSetPagesize(), sqlite3PagerSharedLock(), subjournalPage(), syncJournal(), writeJournalHdr(), writeSuperJournal(), and zeroJournalHdr().

◆ IsOrdinaryHiddenColumn

#define IsOrdinaryHiddenColumn ( X ) 0

Definition at line 17575 of file sqlite3.c.

◆ ISPOWEROF2

#define ISPOWEROF2 ( X ) (((X)&((X)-1))==0)

Definition at line 75848 of file sqlite3.c.

◆ IsPowerOfTwo

#define IsPowerOfTwo ( X ) (((X)&((X)-1))==0)

Definition at line 14599 of file sqlite3.c.

Referenced by allocateIndexInfo(), and exprAnalyzeOrTerm().

◆ IsPrimaryKeyIndex

#define IsPrimaryKeyIndex ( X ) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)

Definition at line 17823 of file sqlite3.c.

Referenced by analyzeOneTable(), convertToWithoutRowidTable(), explainSimpleCount(), sqlite3CompleteInsertion(), sqlite3FkLocateIndex(), sqlite3GenerateConstraintChecks(), sqlite3OpenTableAndIndices(), sqlite3WhereBegin(), and sqlite3WhereExplainOneScan().

◆ isSorter

#define isSorter ( x ) ((x)->eCurType==CURTYPE_SORTER)

Definition at line 85466 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ IsStat4

#define IsStat4 0

Definition at line 107691 of file sqlite3.c.

Referenced by analyzeOneTable().

◆ IsUniqueIndex

#define IsUniqueIndex ( X ) ((X)->onError!=OE_None)

Definition at line 17826 of file sqlite3.c.

Referenced by analyzeOneTable(), isDistinctRedundant(), sqlite3CreateIndex(), sqlite3DefaultRowEst(), sqlite3FindInIndex(), sqlite3FkLocateIndex(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3UpsertAnalyzeTarget(), whereLoopAddBtreeIndex(), wherePathSatisfiesOrderBy(), whereShortCut(), and xferOptimization().

◆ IsVirtual

#define IsVirtual ( X ) ((X)->nModuleArg)

Definition at line 17556 of file sqlite3.c.

Referenced by autoIncBegin(), deleteTable(), flattenSubquery(), impliesNotNullRow(), isCandidateForInOpt(), isLikeOrGlob(), isRealTable(), isSimpleCount(), readsTable(), reindexTable(), selectExpander(), sqlite3_declare_vtab(), sqlite3_vtab_config(), sqlite3AlterBeginAddColumn(), sqlite3BeginTrigger(), sqlite3ColumnDefault(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3FkDelete(), sqlite3FkDropTable(), sqlite3GetVTable(), sqlite3Insert(), sqlite3IsShadowTableOf(), sqlite3LocateTable(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3ShadowTableName(), sqlite3TriggersExist(), sqlite3Update(), sqlite3ViewGetColumnNames(), sqlite3VtabCallConnect(), sqlite3VtabCallCreate(), sqlite3VtabDisconnect(), sqlite3VtabMakeWritable(), sqlite3VtabOverloadFunction(), sqlite3WhereBegin(), tabIsReadOnly(), updateFromSelect(), whereLoopAddBtree(), whereLoopAddOr(), whereLoopAddVirtual(), whereShortCut(), and xferOptimization().

◆ IsWindowFunc

#define IsWindowFunc ( p )

Value:

    ( \
    ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \
 )

Definition at line 18152 of file sqlite3.c.

*/
#ifdef SQLITE_OMIT_WINDOWFUNC
# define IsWindowFunc(p) 0

Referenced by minMaxQuery(), resolveExprStep(), sqlite3Select(), and updateAccumulator().

◆ JOURNAL_HDR_SZ

#define JOURNAL_HDR_SZ ( pPager ) (pPager->sectorSize)

Definition at line 52467 of file sqlite3.c.

Referenced by journalHdrOffset(), jrnlBufferSize(), pager_playback(), pagerOpenSavepoint(), pagerPlaybackSavepoint(), readJournalHdr(), sqlite3PagerCommitPhaseTwo(), and writeJournalHdr().

◆ JOURNAL_PG_SZ

#define JOURNAL_PG_SZ ( pPager ) ((pPager->pageSize) + 8)

Definition at line 52461 of file sqlite3.c.

Referenced by jrnlBufferSize(), pager_playback(), and pagerPlaybackSavepoint().

◆ JT_CROSS

#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */

Definition at line 18288 of file sqlite3.c.

Referenced by sqlite3JoinType(), and sqlite3Select().

◆ JT_ERROR

#define JT_ERROR 0x0040 /* unknown or unsupported join type */

Definition at line 18293 of file sqlite3.c.

Referenced by sqlite3JoinType().

◆ JT_INNER

#define JT_INNER 0x0001 /* Any kind of inner or cross join */

Definition at line 18287 of file sqlite3.c.

Referenced by sqlite3JoinType(), and yy_reduce().

◆ JT_LEFT

#define JT_LEFT 0x0008 /* Left outer join */

Definition at line 18290 of file sqlite3.c.

Referenced by allocateIndexInfo(), lookupName(), sqlite3JoinType(), sqlite3Select(), sqlite3WhereBegin(), sqlite3WhereTabFuncArgs(), termCanDriveIndex(), and whereLoopAddBtreeIndex().

◆ JT_NATURAL

#define JT_NATURAL 0x0004 /* True for a "natural" join */

Definition at line 18289 of file sqlite3.c.

Referenced by lookupName(), selectExpander(), sqlite3JoinType(), and sqliteProcessJoin().

◆ JT_OUTER

#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */

Definition at line 18292 of file sqlite3.c.

Referenced by flattenSubquery(), sqlite3JoinType(), sqlite3Select(), sqliteProcessJoin(), and whereLoopAddBtree().

◆ JT_RIGHT

#define JT_RIGHT 0x0010 /* Right outer join */

Definition at line 18291 of file sqlite3.c.

Referenced by lookupName(), and sqlite3JoinType().

◆ KEYINFO_ORDER_BIGNULL

#define KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */

Definition at line 17693 of file sqlite3.c.

Referenced by allocateIndexInfo(), minMaxQuery(), sqlite3KeyInfoOfIndex(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeFindCompare(), sqlite3VdbeRecordCompareWithSkip(), sqlite3VdbeSorterInit(), vdbeSorterCompareText(), wherePathSatisfiesOrderBy(), and windowCodeRangeTest().

◆ KEYINFO_ORDER_DESC

#define KEYINFO_ORDER_DESC 0x01 /* DESC sort order */

Definition at line 17692 of file sqlite3.c.

Referenced by allocateIndexInfo(), minMaxQuery(), sqlite3Select(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeRecordCompareWithSkip(), sqlite3WindowCodeInit(), wherePathSatisfiesOrderBy(), and windowCodeRangeTest().

◆ LARGEST_INT64

#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))

Definition at line 14464 of file sqlite3.c.

Referenced by doubleToInt64(), randomFunc(), sqlite3AddInt64(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3BtreeIntegrityCheck(), and valueFromExpr().

◆ LARGEST_UINT64

#define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32))

Definition at line 14465 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ LIKEFUNC

#define LIKEFUNC	(	zName,
		nArg,
		arg,
		flags )

Value:

{nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \

(void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }

arg

CURL_EXTERN int void * arg

Definition curl.h:2622

likeFunc

static void likeFunc(sqlite3_context *context, int argc, sqlite3_value **argv)

Definition sqlite3.c:117890

Definition at line 17267 of file sqlite3.c.

#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
   pArg, 0, xFunc, 0, 0, 0, #zName, }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ likely

#define likely ( X ) (X)

Definition at line 13837 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ LOCATE_NOERR

#define LOCATE_NOERR 0x02

Definition at line 19674 of file sqlite3.c.

Referenced by sqlite3LocateTable(), and sqlite3Pragma().

◆ LOCATE_VIEW

#define LOCATE_VIEW 0x01

Definition at line 19673 of file sqlite3.c.

Referenced by sqlite3LocateTable().

◆ LONGDOUBLE_TYPE

#define LONGDOUBLE_TYPE long double

Definition at line 14327 of file sqlite3.c.

Referenced by et_getdigit(), sqlite3_str_vappendf(), sqlite3AtoF(), sqlite3IntFloatCompare(), and sqlite3Pow10().

◆ LOOKASIDE_SMALL

#define LOOKASIDE_SMALL 128

Definition at line 16748 of file sqlite3.c.

Referenced by setupLookaside(), sqlite3DbFreeNN(), and sqlite3DbRealloc().

◆ MAN754

#define MAN754 ((((u64)1)<<52)-1)

Definition at line 19433 of file sqlite3.c.

◆ markExprListImmutable

#define markExprListImmutable ( X ) /* no-op */

Definition at line 112636 of file sqlite3.c.

Referenced by sqlite3EndTable().

◆ MASKBIT

#define MASKBIT ( n ) (((Bitmask)1)<<(n))

Definition at line 14731 of file sqlite3.c.

Referenced by constructAutomaticIndex(), recomputeColumnsNotIndexed(), sqlite3FindInIndex(), sqlite3WhereBegin(), and wherePathSatisfiesOrderBy().

◆ MASKBIT32

#define MASKBIT32 ( n ) (((unsigned int)1)<<(n))

Definition at line 14733 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3VdbeDeleteAuxData(), and sqlite3VdbeExec().

◆ MASKBIT64

#define MASKBIT64 ( n ) (((u64)1)<<(n))

Definition at line 14732 of file sqlite3.c.

◆ MAX

#define MAX	(		A,
			B ) ((A)>(B)?(A):(B))

Definition at line 14266 of file sqlite3.c.

Referenced by analyzeOneTable(), fetchPayload(), generateSortTail(), isDupColumn(), sqlite3_str_vappendf(), sqlite3BtreeOpen(), sqlite3Pragma(), sqlite3VdbeMemSetStr(), sqlite3VdbeSorterInit(), vdbeIncrMergerNew(), vdbePmaReadBlob(), and windowInitAccum().

◆ MAX_PATHNAME

#define MAX_PATHNAME 512

Definition at line 33522 of file sqlite3.c.

Referenced by findCreateFileMode(), openDirectory(), unixFullPathname(), and unixOpen().

◆ MAX_ROWID

#define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )

◆ MAX_SECTOR_SIZE

#define MAX_SECTOR_SIZE 0x10000

Definition at line 52117 of file sqlite3.c.

Referenced by readJournalHdr().

◆ mem0

#define mem0 GLOBAL(struct Mem0Global, mem0)

Definition at line 27369 of file sqlite3.c.

Referenced by mallocWithAlarm(), sqlite3_hard_heap_limit64(), sqlite3_soft_heap_limit64(), sqlite3HeapNearlyFull(), sqlite3Malloc(), sqlite3MallocInit(), and sqlite3MallocMutex().

◆ MEM_AffMask

#define MEM_AffMask 0x003f /* Mask of affinity bits */

Definition at line 20954 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeMemTranslate().

◆ MEM_Agg

#define MEM_Agg 0x2000 /* Mem.z points to an agg function context */

Definition at line 20970 of file sqlite3.c.

Referenced by sqlite3_aggregate_context(), sqlite3VdbeExec(), and vdbeMemClearExternAndSetNull().

◆ MEM_Blob

#define MEM_Blob 0x0010 /* Value is a BLOB */

◆ MEM_Cleared

#define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */

Definition at line 20957 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ MEM_Dyn

#define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */

Definition at line 20967 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemFinalize(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetRowSet(), sqlite3VdbeMemSetStr(), and vdbeMemClearExternAndSetNull().

◆ MEM_Ephem

#define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */

Definition at line 20969 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemGrow(), valueToText(), and vdbeCompareMemString().

◆ MEM_FromBind

#define MEM_FromBind 0x0040 /* Value originates from sqlite3_bind() */

Definition at line 20955 of file sqlite3.c.

Referenced by sqlite3_value_dup(), and sqlite3VdbeExec().

◆ MEM_Int

#define MEM_Int 0x0004 /* Value is an integer */

◆ MEM_IntReal

#define MEM_IntReal 0x0020 /* MEM_Int that stringifies like MEM_Real */

Definition at line 20953 of file sqlite3.c.

Referenced by applyAffinity(), applyNumericAffinity(), computeNumericType(), numericType(), sqlite3MemCompare(), sqlite3ResultIntReal(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeFindCompare(), sqlite3VdbeMemCast(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemStringify(), sqlite3VdbeRecordCompareWithSkip(), valueFromExpr(), and vdbeMemRenderNum().

◆ MEM_Null

#define MEM_Null 0x0001 /* Value is NULL (or a pointer) */

◆ MEM_Real

#define MEM_Real 0x0008 /* Value is a real number */

Definition at line 20951 of file sqlite3.c.

Referenced by applyAffinity(), applyNumericAffinity(), computeNumericType(), numericType(), sqlite3MemCompare(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeFindCompare(), sqlite3VdbeMemCast(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemSetDouble(), sqlite3VdbeMemStringify(), sqlite3VdbeRecordCompareWithSkip(), valueFromExpr(), and vdbeMemRenderNum().

◆ MEM_Static

#define MEM_Static 0x0800 /* Mem.z points to a static string */

Definition at line 20968 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetStr(), and valueToText().

◆ MEM_Str

#define MEM_Str 0x0002 /* Value is a string */

◆ MEM_Subtype

#define MEM_Subtype 0x8000 /* Mem.eSubtype is valid */

Definition at line 20972 of file sqlite3.c.

Referenced by sqlite3_result_text(), and sqlite3VdbeMemTranslate().

◆ MEM_Term

#define MEM_Term 0x0200 /* String in Mem.z is zero terminated */

Definition at line 20966 of file sqlite3.c.

Referenced by sqlite3Utf16to8(), sqlite3ValueText(), sqlite3VdbeExec(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemHandleBom(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTranslate(), sqlite3VdbeSetColName(), and vdbeMemAddTerminator().

◆ MEM_TypeMask

#define MEM_TypeMask 0xc1bf /* Mask of type bits */

Definition at line 20958 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemCast(), and sqlite3VdbeMemInit().

◆ MEM_Undefined

#define MEM_Undefined 0x0080 /* Value is undefined */

Definition at line 20956 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMakeReady(), and sqlite3VdbeReset().

◆ MEM_Zero

#define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */

Definition at line 20971 of file sqlite3.c.

Referenced by sqlite3_value_frombind(), sqlite3BlobCompare(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeMemCast(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemStringify(), sqlite3VdbeRecordCompareWithSkip(), and sqlite3VdbeSerialPut().

◆ memAboutToChange

#define memAboutToChange	(		P,
			M )

Definition at line 85268 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ MEMCELLSIZE

#define MEMCELLSIZE offsetof(Mem,zMalloc)

Definition at line 20933 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ MEMDB

#define MEMDB pPager->memDb

Definition at line 52478 of file sqlite3.c.

Referenced by getPageNormal(), jrnlBufferSize(), pager_end_transaction(), pager_error(), pager_playback_one_page(), pager_unlock(), pagerWriteLargeSector(), readDbPage(), sqlite3PagerClose(), sqlite3PagerCommitPhaseOne(), sqlite3PagerMovepage(), sqlite3PagerRollback(), sqlite3PagerSetJournalMode(), sqlite3PagerSharedLock(), and sqlite3PagerSync().

◆ memJM

#define memJM 0

◆ MEMJOURNAL_DFLT_FILECHUNKSIZE

#define MEMJOURNAL_DFLT_FILECHUNKSIZE 1024

Definition at line 97115 of file sqlite3.c.

Referenced by sqlite3JournalOpen().

◆ MemNullNochng

#define MemNullNochng ( X )

Value:

(((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \

&& (X)->n==0 && (X)->u.nZero==0)

MEM_Zero

#define MEM_Zero

Definition sqlite3.c:20971

MEM_TypeMask

#define MEM_TypeMask

Definition sqlite3.c:20958

MEM_Null

#define MEM_Null

Definition sqlite3.c:20948

Definition at line 20993 of file sqlite3.c.

   ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
 
/*

Referenced by sqlite3VdbeMemExpandBlob().

◆ MemSetTypeFlag

#define MemSetTypeFlag	(		p,
			f ) ((p)->flags = ((p)->flags&~(MEM_TypeMask\|MEM_Zero))\|f)

Definition at line 20987 of file sqlite3.c.

20987 (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)

20988

MEM_Agg

#define MEM_Agg

Definition sqlite3.c:20970

MEM_Dyn

#define MEM_Dyn

Definition sqlite3.c:20967

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemCast(), sqlite3VdbeMemNumerify(), sqlite3VdbeNextOpcode(), and valueFromExpr().

◆ MEMTYPE_HEAP

#define MEMTYPE_HEAP 0x01 /* General heap allocations */

Definition at line 20331 of file sqlite3.c.

Referenced by dbMallocRawFinish(), lookasideMallocSize(), and sqlite3DbFreeNN().

◆ MEMTYPE_LOOKASIDE

#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */

Definition at line 20332 of file sqlite3.c.

Referenced by dbMallocRawFinish(), and sqlite3DbFreeNN().

◆ MEMTYPE_PCACHE

#define MEMTYPE_PCACHE 0x04 /* Page cache allocations */

Definition at line 20333 of file sqlite3.c.

Referenced by pcache1Alloc().

◆ MIN

#define MIN	(		A,
			B ) ((A)<(B)?(A):(B))

Definition at line 14263 of file sqlite3.c.

Referenced by allocateSpace(), backupOnePage(), constructAutomaticIndex(), editPage(), g_string_truncate_inline(), sqlite3DefaultRowEst(), sqlite3VdbeRecordCompareWithSkip(), sqlite3VdbeSorterInit(), vdbeRecordCompareString(), vdbeSorterCompareText(), vdbeSorterMergeTreeBuild(), walIndexRecover(), wherePathSolver(), and whereRangeVectorLen().

◆ MSVC_VERSION

#define MSVC_VERSION 0

Definition at line 990 of file sqlite3.c.

◆ MUTEX_LOGIC

#define MUTEX_LOGIC ( X ) X

Definition at line 16560 of file sqlite3.c.

Referenced by removeFromSharingList(), sqlite3_initialize(), sqlite3_vfs_register(), and sqlite3BtreeOpen().

◆ MX_CELL

#define MX_CELL ( pBt ) ((pBt->pageSize-8)/6)

Definition at line 63698 of file sqlite3.c.

Referenced by balance_nonroot(), btreeInitPage(), and insertCell().

◆ MX_CELL_SIZE

#define MX_CELL_SIZE ( pBt ) ((int)(pBt->pageSize-8))

Definition at line 63691 of file sqlite3.c.

Referenced by lockBtree(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ N_OR_COST

#define N_OR_COST 3

Definition at line 141083 of file sqlite3.c.

Referenced by whereOrInsert().

◆ N_SORT_BUCKET

#define N_SORT_BUCKET 32

Definition at line 49601 of file sqlite3.c.

Referenced by pcacheSortDirtyList().

◆ NB

#define NB 3 /* (NN*2+1): Total pages involved in the balance */

Definition at line 71294 of file sqlite3.c.

Referenced by balance_nonroot(), pageInsertArray(), and rebuildPage().

◆ NC_AllowAgg

#define NC_AllowAgg 0x00001 /* Aggregate functions are allowed here */

Definition at line 18373 of file sqlite3.c.

Referenced by lookupName(), resolveExprStep(), and resolveOrderByTermToExprList().

◆ NC_AllowWin

#define NC_AllowWin 0x04000 /* Window functions are allowed here */

Definition at line 18386 of file sqlite3.c.

Referenced by lookupName(), and resolveExprStep().

◆ NC_Complex

#define NC_Complex 0x02000 /* True if a function or subquery seen */

Definition at line 18385 of file sqlite3.c.

◆ NC_FromDDL

#define NC_FromDDL 0x40000 /* SQL text comes from sqlite_schema */

Definition at line 18390 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3ResolveSelfReference().

◆ NC_GenCol

#define NC_GenCol 0x00008 /* True for a GENERATED ALWAYS AS clause */

Definition at line 18376 of file sqlite3.c.

Referenced by lookupName(), resolveExprStep(), sqlite3EndTable(), sqlite3NotPureFunc(), and sqlite3ResolveSelfReference().

◆ NC_HasAgg

#define NC_HasAgg 0x00010 /* One or more aggregate functions seen */

Definition at line 18377 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ NC_HasWin

#define NC_HasWin 0x08000 /* One or more window functions seen */

Definition at line 18387 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ NC_IdxExpr

#define NC_IdxExpr 0x00020 /* True if resolving columns of CREATE INDEX */

Definition at line 18378 of file sqlite3.c.

Referenced by lookupName(), notValidImpl(), resolveExprStep(), sqlite3CreateIndex(), and sqlite3ResolveSelfReference().

◆ NC_InAggFunc

#define NC_InAggFunc 0x20000 /* True if analyzing arguments to an agg func */

Definition at line 18389 of file sqlite3.c.

Referenced by analyzeAggregate(), and sqlite3Select().

◆ NC_IsCheck

#define NC_IsCheck 0x00004 /* True if resolving a CHECK constraint */

Definition at line 18375 of file sqlite3.c.

Referenced by lookupName(), notValidImpl(), resolveExprStep(), sqlite3EndTable(), sqlite3NotPureFunc(), and sqlite3ResolveSelfReference().

◆ NC_IsDDL

#define NC_IsDDL 0x10000 /* Resolving names in a CREATE statement */

Definition at line 18388 of file sqlite3.c.

Referenced by sqlite3ResolveSelfReference().

◆ NC_MinMaxAgg

#define NC_MinMaxAgg 0x01000 /* min/max aggregates seen. See note above */

Definition at line 18384 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ NC_PartIdx

#define NC_PartIdx 0x00002 /* True if resolving a partial index WHERE */

Definition at line 18374 of file sqlite3.c.

Referenced by lookupName(), resolveExprStep(), sqlite3CreateIndex(), and sqlite3ResolveSelfReference().

◆ NC_SelfRef

#define NC_SelfRef 0x0002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */

Definition at line 18379 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3VdbeAddFunctionCall().

◆ NC_UAggInfo

#define NC_UAggInfo 0x00100 /* True if uNC.pAggInfo is used */

Definition at line 18382 of file sqlite3.c.

Referenced by analyzeAggregate(), and sqlite3Select().

◆ NC_UEList

#define NC_UEList 0x00080 /* True if uNC.pEList is used */

Definition at line 18381 of file sqlite3.c.

Referenced by lookupName(), and resolveOrderByTermToExprList().

◆ NC_UUpsert

#define NC_UUpsert 0x00200 /* True if uNC.pUpsert is used */

Definition at line 18383 of file sqlite3.c.

Referenced by lookupName(), renameResolveTrigger(), and sqlite3Update().

◆ NC_VarSelect

#define NC_VarSelect 0x00040 /* A correlated subquery has been seen */

Definition at line 18380 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3DeleteFrom().

◆ NDEBUG

#define NDEBUG 1

Definition at line 13655 of file sqlite3.c.

◆ NEVER

#define NEVER ( X ) (X)

Definition at line 13737 of file sqlite3.c.

Referenced by allocateSpace(), analyzeOneTable(), balance(), balance_nonroot(), balance_quick(), btreeCreateTable(), checkColumnOverlap(), defragmentPage(), editPage(), isSimpleCount(), pager_open_journal(), pagerStress(), pcacheSortDirtyList(), rebuildPage(), sqlite3AddNotNull(), sqlite3AuthRead(), sqlite3BtreeRowCountEst(), sqlite3CreateForeignKey(), sqlite3EndTable(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprIsInteger(), sqlite3ExprListAppendVector(), sqlite3FixSrcList(), sqlite3IsLikeFunction(), sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerOkToChangeJournalMode(), sqlite3Reindex(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VtabOverloadFunction(), sqlite3WhereBegin(), sqlite3WindowCompare(), sqliteProcessJoin(), valueFromExpr(), walCleanupHash(), walIndexRecover(), and walkWindowList().

◆ NN

#define NN 1 /* Number of neighbors on either side of pPage */

Definition at line 71293 of file sqlite3.c.

◆ NO_LOCK

#define NO_LOCK 0

Definition at line 16359 of file sqlite3.c.

Referenced by dotlockLock(), dotlockUnlock(), pager_unlock(), pager_wait_on_lock(), pagerUnlockDb(), posixUnlock(), sqlite3PagerSharedLock(), and unixLock().

◆ noopFunc

#define noopFunc versionFunc /* Substitute function - never called */

Definition at line 117547 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ NOT_WITHIN

#define NOT_WITHIN 0 /* Object completely outside of query region */

Definition at line 10972 of file sqlite3.c.

◆ nth_valueInvFunc

#define nth_valueInvFunc noopStepFunc

Definition at line 151419 of file sqlite3.c.

◆ nth_valueValueFunc

#define nth_valueValueFunc noopValueFunc

Definition at line 151420 of file sqlite3.c.

◆ ntileFinalizeFunc

#define ntileFinalizeFunc ntileValueFunc

Definition at line 151634 of file sqlite3.c.

◆ O_BINARY

#define O_BINARY 0

Definition at line 33857 of file sqlite3.c.

Referenced by openDirectory(), and unixOpen().

◆ O_LARGEFILE

#define O_LARGEFILE 0

Definition at line 33847 of file sqlite3.c.

Referenced by unixOpen().

◆ O_NOFOLLOW

#define O_NOFOLLOW 0

Definition at line 33854 of file sqlite3.c.

Referenced by unixOpen(), and unixOpenSharedMemory().

◆ OE_Abort

#define OE_Abort 2 /* Back out changes but do no rollback transaction */

◆ OE_Cascade

#define OE_Cascade 10 /* Cascade the changes */

Definition at line 17666 of file sqlite3.c.

Referenced by actionName(), fkActionTrigger(), sqlite3FkCheck(), and yy_reduce().

◆ OE_Default

#define OE_Default 11 /* Do whatever the default action is */

Definition at line 17667 of file sqlite3.c.

Referenced by sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3TriggerDeleteStep(), sqlite3TriggerSelectStep(), sqlite3Update(), updateVirtualTable(), xferOptimization(), and yy_reduce().

◆ OE_Fail

#define OE_Fail 3 /* Stop the operation but leave all prior changes */

Definition at line 17659 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3VdbeExec(), sqlite3VdbeHalt(), and yy_reduce().

◆ OE_Ignore

#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */

Definition at line 17660 of file sqlite3.c.

Referenced by fkLookupParent(), sqlite3_vtab_on_conflict(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3VdbeExec(), and yy_reduce().

◆ OE_None

#define OE_None 0 /* There is no constraint to check */

Definition at line 17656 of file sqlite3.c.

Referenced by actionName(), fkActionTrigger(), sqlite3AddNotNull(), sqlite3CreateIndex(), sqlite3FkRequired(), sqlite3GenerateConstraintChecks(), and yy_reduce().

◆ OE_Replace

#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */

Definition at line 17661 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict(), sqlite3CompleteInsertion(), sqlite3CreateIndex(), sqlite3GenerateConstraintChecks(), sqlite3Update(), sqlite3VdbeExec(), whereLoopAddBtree(), and yy_reduce().

◆ OE_Restrict

#define OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */

Definition at line 17663 of file sqlite3.c.

Referenced by actionName(), fkActionTrigger(), and yy_reduce().

◆ OE_Rollback

#define OE_Rollback 1 /* Fail the operation and rollback the transaction */

Definition at line 17657 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3VdbeExec(), xferOptimization(), and yy_reduce().

◆ OE_SetDflt

#define OE_SetDflt 9 /* Set the foreign key value to its default */

Definition at line 17665 of file sqlite3.c.

Referenced by actionName(), fkActionTrigger(), and yy_reduce().

◆ OE_SetNull

#define OE_SetNull 8 /* Set the foreign key value to NULL */

Definition at line 17664 of file sqlite3.c.

Referenced by actionName(), isSetNullAction(), sqlite3FkCheck(), and yy_reduce().

◆ OE_Update

#define OE_Update 6 /* Process as a DO UPDATE in an upsert */

Definition at line 17662 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ offsetof

#define offsetof	(		STRUCTURE,
			FIELD ) ((int)((char)&((STRUCTURE)0)->FIELD))

Definition at line 14256 of file sqlite3.c.

Referenced by allocateCursor(), lua_newthread(), pcacheFetchFinishWithInit(), sqlite3BtreeCursorHasMoved(), sqlite3BtreeCursorZero(), sqlite3BtreeFakeValidCursor(), sqlite3ExprListAppend(), sqlite3WhereBegin(), walIndexWriteHdr(), and whereClauseInsert().

◆ OK_IF_ALWAYS_FALSE

#define OK_IF_ALWAYS_FALSE ( X ) (X)

Definition at line 13772 of file sqlite3.c.

◆ OK_IF_ALWAYS_TRUE

#define OK_IF_ALWAYS_TRUE ( X ) (X)

Definition at line 13771 of file sqlite3.c.

Referenced by clearSelect(), selectPopWith(), and sqlite3SelectExpand().

◆ OMIT_TEMPDB

#define OMIT_TEMPDB 0

Definition at line 14172 of file sqlite3.c.

Referenced by sqlite3CodeVerifySchema(), sqlite3CreateIndex(), sqlite3DropTrigger(), sqlite3FindIndex(), sqlite3Pragma(), and sqlite3StartTable().

◆ ONE_BYTE_INT

#define ONE_BYTE_INT ( x ) ((i8)(x)[0])

Definition at line 81572 of file sqlite3.c.

Referenced by vdbeRecordCompareInt(), and vdbeRecordDecodeInt().

◆ ONEPASS_MULTI

#define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */

Definition at line 19649 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateRowDelete(), sqlite3Update(), and sqlite3WhereBegin().

◆ ONEPASS_OFF

#define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */

Definition at line 19647 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereOkOnePass(), and updateVirtualTable().

◆ ONEPASS_SINGLE

#define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */

Definition at line 19648 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3Update(), sqlite3WhereBegin(), sqlite3WhereOkOnePass(), and updateVirtualTable().

◆ ONLY_IF_REALLOC_STRESS

#define ONLY_IF_REALLOC_STRESS ( X ) (0)

Definition at line 13787 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ OP_Abortable

#define OP_Abortable 175

Definition at line 15741 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Add

#define OP_Add 105 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */

Definition at line 15671 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3VdbeExec(), windowCodeRangeTest(), and windowReturnOneRow().

◆ OP_AddImm

#define OP_AddImm 82 /* synopsis: r[P1]=r[P1]+P2 */

Definition at line 15648 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), sqlite3DeleteFrom(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), sqlite3VdbeExec(), windowAggStep(), windowCodeOp(), and windowReturnOneRow().

◆ OP_Affinity

#define OP_Affinity 90 /* synopsis: affinity(r[P1@P2]) */

Definition at line 15656 of file sqlite3.c.

Referenced by codeApplyAffinity(), sqlite3ComputeGeneratedColumns(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3TableAffinity(), and sqlite3VdbeExec().

◆ OP_AggFinal

#define OP_AggFinal 157 /* synopsis: accum=r[P1] N=P2 */

Definition at line 15723 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and windowAggFinal().

◆ OP_AggInverse

#define OP_AggInverse 153 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */

Definition at line 15719 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and windowAggStep().

◆ OP_AggStep

#define OP_AggStep 154 /* synopsis: accum=r[P3] step(r[P2@P5]) */

Definition at line 15720 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), updateAccumulator(), and windowAggStep().

◆ OP_AggStep1

#define OP_AggStep1 155 /* synopsis: accum=r[P3] step(r[P2@P5]) */

Definition at line 15721 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_AggValue

#define OP_AggValue 156 /* synopsis: r[P3]=value N=P2 */

Definition at line 15722 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and windowAggFinal().

◆ OP_And

#define OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */

Definition at line 15610 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_AutoCommit

#define OP_AutoCommit 1

Definition at line 15567 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3EndTransaction(), and sqlite3VdbeExec().

◆ OP_BitAnd

#define OP_BitAnd 101 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */

Definition at line 15667 of file sqlite3.c.

Referenced by sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_BitNot

#define OP_BitNot 112 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */

Definition at line 15678 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_BitOr

#define OP_BitOr 102 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */

Definition at line 15668 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_Blob

#define OP_Blob 74 /* synopsis: r[P2]=P4 (len=P1) */

Definition at line 15640 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ OP_Cast

#define OP_Cast 84 /* synopsis: affinity(r[P1]) */

Definition at line 15650 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_Checkpoint

#define OP_Checkpoint 6

Definition at line 15572 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Clear

#define OP_Clear 137

Definition at line 15703 of file sqlite3.c.

Referenced by openStatTable(), sqlite3DeleteFrom(), sqlite3RefillIndex(), and sqlite3VdbeExec().

◆ OP_Close

#define OP_Close 116

Definition at line 15682 of file sqlite3.c.

Referenced by autoIncrementEnd(), fkLookupParent(), multiSelect(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3Insert(), sqlite3RefillIndex(), sqlite3Select(), sqlite3StartTable(), sqlite3VdbeExec(), sqlite3WhereEnd(), updateVirtualTable(), and xferOptimization().

◆ OP_CollSeq

#define OP_CollSeq 81

Definition at line 15647 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3GetFuncCollSeq(), sqlite3VdbeExec(), updateAccumulator(), and windowAggStep().

◆ OP_Column

#define OP_Column 89 /* synopsis: r[P3]=PX */

◆ OP_ColumnsUsed

#define OP_ColumnsUsed 117

Definition at line 15683 of file sqlite3.c.

Referenced by sqlite3FindInIndex(), sqlite3VdbeExec(), and sqlite3WhereBegin().

◆ OP_Compare

#define OP_Compare 86 /* synopsis: r[P1@P3] <-> r[P2@P3] */

Definition at line 15652 of file sqlite3.c.

Referenced by generateOutputSubroutine(), multiSelectOrderBy(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), windowFullScan(), and windowIfNewPeer().

◆ OP_Concat

#define OP_Concat 110 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */

Definition at line 15676 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Copy

#define OP_Copy 77 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */

Definition at line 15643 of file sqlite3.c.

Referenced by codeExprOrVector(), fkLookupParent(), generateOutputSubroutine(), multiSelectOrderBy(), selectInnerLoop(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeIN(), sqlite3GenerateRowDelete(), sqlite3Insert(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), translateColumnToCopy(), updateAccumulator(), windowAggFinal(), and windowIfNewPeer().

◆ OP_Count

#define OP_Count 92 /* synopsis: r[P2]=count() */

Definition at line 15658 of file sqlite3.c.

Referenced by analyzeOneTable(), sqlite3Pragma(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_CreateBtree

#define OP_CreateBtree 139 /* synopsis: r[P2]=root iDb=P1 flags=P3 */

Definition at line 15705 of file sqlite3.c.

Referenced by sqlite3CreateIndex(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ OP_CursorHint

#define OP_CursorHint 171

Definition at line 15737 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_CursorLock

#define OP_CursorLock 159

Definition at line 15725 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3VdbeExec().

◆ OP_CursorUnlock

#define OP_CursorUnlock 160

Definition at line 15726 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3VdbeExec().

◆ OP_DecrJumpZero

#define OP_DecrJumpZero 59 /* jump, synopsis: if (--r[P1])==0 goto P2 */

Definition at line 15625 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateWithRecursiveQuery(), selectInnerLoop(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_DeferredSeek

#define OP_DeferredSeek 133 /* synopsis: Move P3 to P1.rowid if needed */

Definition at line 15699 of file sqlite3.c.

Referenced by codeDeferredSeek(), and sqlite3VdbeExec().

◆ OP_Delete

#define OP_Delete 122

Definition at line 15688 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3VdbeExec(), windowAggStep(), and windowCodeOp().

◆ OP_Destroy

#define OP_Destroy 136

Definition at line 15702 of file sqlite3.c.

Referenced by destroyRootPage(), and sqlite3VdbeExec().

◆ OP_Divide

#define OP_Divide 108 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */

Definition at line 15674 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_DropIndex

#define OP_DropIndex 144

Definition at line 15710 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_DropTable

#define OP_DropTable 143

Definition at line 15709 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_DropTrigger

#define OP_DropTrigger 145

Definition at line 15711 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_ElseNotEq

#define OP_ElseNotEq 58 /* jump, same as TK_ESCAPE */

Definition at line 15624 of file sqlite3.c.

Referenced by codeVectorCompare(), and sqlite3VdbeExec().

◆ OP_EndCoroutine

#define OP_EndCoroutine 66

Definition at line 15632 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Eq

#define OP_Eq 53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */

Definition at line 15619 of file sqlite3.c.

Referenced by codeVectorCompare(), fkLookupParent(), selectInnerLoop(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3Pragma(), sqlite3VdbeExec(), and windowFullScan().

◆ OP_Expire

#define OP_Expire 158

Definition at line 15724 of file sqlite3.c.

Referenced by sqlite3Analyze(), sqlite3CreateIndex(), sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Explain

#define OP_Explain 174

Definition at line 15740 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeExplain(), sqlite3VdbeNextOpcode(), and sqlite3WhereExplainOneScan().

◆ OP_FinishSeek

#define OP_FinishSeek 135

Definition at line 15701 of file sqlite3.c.

Referenced by sqlite3Update(), and sqlite3VdbeExec().

◆ OP_FkCounter

#define OP_FkCounter 149 /* synopsis: fkctr[P1]+=P2 */

Definition at line 15715 of file sqlite3.c.

Referenced by fkLookupParent(), fkScanChildren(), sqlite3FkCheck(), and sqlite3VdbeExec().

◆ OP_FkIfZero

#define OP_FkIfZero 47 /* jump, synopsis: if fkctr[P1]==0 goto P2 */

Definition at line 15613 of file sqlite3.c.

Referenced by fkLookupParent(), fkScanChildren(), sqlite3FkDropTable(), sqlite3VdbeExec(), and sqlite3VdbeJumpHereOrPopInst().

◆ OP_Found

#define OP_Found 30 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15596 of file sqlite3.c.

Referenced by codeDistinct(), fkLookupParent(), selectInnerLoop(), sqlite3ExprCodeIN(), sqlite3Pragma(), sqlite3UpsertDoUpdate(), and sqlite3VdbeExec().

◆ OP_Function

#define OP_Function 64 /* synopsis: r[P3]=func(r[P2@NP]) */

Definition at line 15630 of file sqlite3.c.

Referenced by sqlite3VdbeAddFunctionCall(), and sqlite3VdbeExec().

◆ OP_Ge

#define OP_Ge 57 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */

Definition at line 15623 of file sqlite3.c.

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), windowCheckValue(), windowCodeOp(), and windowCodeRangeTest().

◆ OP_Gosub

#define OP_Gosub 12 /* jump */

Definition at line 15578 of file sqlite3.c.

Referenced by generateSortTail(), multiSelectOrderBy(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), and windowReturnOneRow().

◆ OP_Goto

#define OP_Goto 11 /* jump */

Definition at line 15577 of file sqlite3.c.

Referenced by analyzeOneTable(), codeAllEqualityTerms(), convertToWithoutRowidTable(), sqlite3ExprCodeIN(), sqlite3GenerateConstraintChecks(), sqlite3Pragma(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), windowIfNewPeer(), and xferOptimization().

◆ OP_Gt

#define OP_Gt 54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */

Definition at line 15620 of file sqlite3.c.

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VdbeExec(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), and windowReturnOneRow().

◆ OP_Halt

#define OP_Halt 68

Definition at line 15634 of file sqlite3.c.

Referenced by integrityCheckResultRow(), sqlite3ExprCodeTarget(), sqlite3FinishCoding(), sqlite3HaltConstraint(), sqlite3Pragma(), sqlite3UpsertDoUpdate(), sqlite3VdbeExec(), windowCheckValue(), and xferOptimization().

◆ OP_HaltIfNull

#define OP_HaltIfNull 67 /* synopsis: if r[P3]=null halt */

Definition at line 15633 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3VdbeExec().

◆ OP_IdxDelete

#define OP_IdxDelete 132 /* synopsis: key=r[P2@P3] */

Definition at line 15698 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3GenerateRowIndexDelete(), and sqlite3VdbeExec().

◆ OP_IdxGE

#define OP_IdxGE 41 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15607 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_IdxGT

#define OP_IdxGT 39 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15605 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_IdxInsert

#define OP_IdxInsert 130 /* synopsis: key=r[P2] */

Definition at line 15696 of file sqlite3.c.

Referenced by codeDistinct(), constructAutomaticIndex(), generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3CompleteInsertion(), sqlite3DeleteFrom(), sqlite3RefillIndex(), sqlite3Update(), sqlite3VdbeExec(), windowAggStep(), and xferOptimization().

◆ OP_IdxLE

#define OP_IdxLE 38 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15604 of file sqlite3.c.

Referenced by generateSortTail(), and sqlite3VdbeExec().

◆ OP_IdxLT

#define OP_IdxLT 40 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15606 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_IdxRowid

#define OP_IdxRowid 134 /* synopsis: r[P2]=rowid */

Definition at line 15700 of file sqlite3.c.

Referenced by analyzeOneTable(), sqlite3GenerateConstraintChecks(), sqlite3UpsertDoUpdate(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_If

#define OP_If 18 /* jump */

Definition at line 15584 of file sqlite3.c.

Referenced by analyzeOneTable(), codeVectorCompare(), sqlite3ExprIfTrue(), sqlite3Pragma(), sqlite3StartTable(), sqlite3VdbeExec(), sqlite3VdbeJumpHereOrPopInst(), and updateAccumulator().

◆ OP_IfNoHope

#define OP_IfNoHope 27 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15593 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_IfNot

#define OP_IfNot 20 /* jump */

Definition at line 15586 of file sqlite3.c.

Referenced by analyzeOneTable(), codeVectorCompare(), computeLimitRegisters(), generateOutputSubroutine(), multiSelect(), sqlite3ExprIfFalse(), sqlite3GenerateConstraintChecks(), sqlite3VdbeExec(), and windowAggStep().

◆ OP_IfNotOpen

#define OP_IfNotOpen 26 /* jump, synopsis: if( !csr[P1] ) goto P2 */

Definition at line 15592 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_IfNotZero

#define OP_IfNotZero 49 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */

Definition at line 15615 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_IfNullRow

#define OP_IfNullRow 21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */

Definition at line 15587 of file sqlite3.c.

Referenced by sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeTarget(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_IfPos

#define OP_IfPos 48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */

Definition at line 15614 of file sqlite3.c.

Referenced by integrityCheckResultRow(), sqlite3AlterFinishAddColumn(), sqlite3Pragma(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), and windowCodeOp().

◆ OP_IfSmaller

#define OP_IfSmaller 34 /* jump */

Definition at line 15600 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_IncrVacuum

#define OP_IncrVacuum 60 /* jump */

Definition at line 15626 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Init

#define OP_Init 62 /* jump, synopsis: Start at P2 */

Definition at line 15628 of file sqlite3.c.

Referenced by sqlite3FinishCoding(), sqlite3VdbeExec(), and sqlite3VdbeNextOpcode().

◆ OP_InitCoroutine

#define OP_InitCoroutine 13 /* jump */

Definition at line 15579 of file sqlite3.c.

Referenced by constructAutomaticIndex(), multiSelectOrderBy(), sqlite3EndTable(), sqlite3Insert(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_Insert

#define OP_Insert 121 /* synopsis: intkey=r[P3] data=r[P2] */

Definition at line 15687 of file sqlite3.c.

Referenced by analyzeOneTable(), autoIncrementEnd(), generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3CompleteInsertion(), sqlite3EndTable(), sqlite3Insert(), sqlite3StartTable(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), updateVirtualTable(), and xferOptimization().

◆ OP_Int64

#define OP_Int64 70 /* synopsis: r[P2]=P4 */

Definition at line 15636 of file sqlite3.c.

Referenced by codeInteger(), and sqlite3VdbeExec().

◆ OP_IntCopy

#define OP_IntCopy 79 /* synopsis: r[P2]=r[P1] */

Definition at line 15645 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3VdbeExec().

◆ OP_Integer

#define OP_Integer 69 /* synopsis: r[P2]=P1 */

◆ OP_IntegrityCk

#define OP_IntegrityCk 146

Definition at line 15712 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_IsNull

#define OP_IsNull 50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */

◆ OP_IsTrue

#define OP_IsTrue 87 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */

Definition at line 15653 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_JournalMode

#define OP_JournalMode 7

Definition at line 15573 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Jump

#define OP_Jump 16 /* jump */

Definition at line 15582 of file sqlite3.c.

Referenced by generateOutputSubroutine(), multiSelectOrderBy(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), windowFullScan(), and windowIfNewPeer().

◆ OP_Last

#define OP_Last 33 /* jump */

Definition at line 15599 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), codeEqualityTerm(), sqlite3VdbeExec(), and windowAggFinal().

◆ OP_Le

#define OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */

Definition at line 15621 of file sqlite3.c.

Referenced by autoIncrementEnd(), codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), windowCodeOp(), and windowCodeRangeTest().

◆ OP_LoadAnalysis

#define OP_LoadAnalysis 142

Definition at line 15708 of file sqlite3.c.

Referenced by loadAnalysis(), and sqlite3VdbeExec().

◆ OP_Lt

#define OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */

Definition at line 15622 of file sqlite3.c.

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VdbeExec(), and windowCodeRangeTest().

◆ OP_MakeRecord

#define OP_MakeRecord 91 /* synopsis: r[P3]=mkrec(r[P1@P2]) */

◆ OP_MaxPgcnt

#define OP_MaxPgcnt 169

Definition at line 15735 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_MemMax

#define OP_MemMax 151 /* synopsis: r[P1]=max(r[P1],r[P2]) */

Definition at line 15717 of file sqlite3.c.

Referenced by autoIncStep(), and sqlite3VdbeExec().

◆ OP_Move

#define OP_Move 76 /* synopsis: r[P2@P3]=r[P1@P3] */

Definition at line 15642 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Multiply

#define OP_Multiply 107 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */

Definition at line 15673 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_MustBeInt

#define OP_MustBeInt 15 /* jump */

Definition at line 15581 of file sqlite3.c.

Referenced by computeLimitRegisters(), fkLookupParent(), sqlite3Insert(), sqlite3Update(), sqlite3VdbeExec(), and windowCheckValue().

◆ OP_Ne

#define OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */

Definition at line 15618 of file sqlite3.c.

Referenced by analyzeOneTable(), codeVectorCompare(), fkLookupParent(), selectInnerLoop(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3VdbeExec(), and sqlite3WindowCodeStep().

◆ OP_NewRowid

#define OP_NewRowid 120 /* synopsis: r[P2]=rowid */

Definition at line 15686 of file sqlite3.c.

Referenced by analyzeOneTable(), autoIncrementEnd(), generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3EndTable(), sqlite3Insert(), sqlite3StartTable(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), updateVirtualTable(), and xferOptimization().

◆ OP_Next

#define OP_Next 5 /* jump */

Definition at line 15571 of file sqlite3.c.

Referenced by analyzeOneTable(), codeEqualityTerm(), constructAutomaticIndex(), generateSortTail(), multiSelect(), resolveP2Values(), sqlite3DeleteFrom(), sqlite3ExprCodeIN(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WhereEnd(), updateVirtualTable(), windowCodeOp(), windowFullScan(), and xferOptimization().

◆ OP_NoConflict

#define OP_NoConflict 28 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15594 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3VdbeExec().

◆ OP_Noop

#define OP_Noop 173

Definition at line 15739 of file sqlite3.c.

Referenced by analyzeOneTable(), codeEqualityTerm(), sqlite3CreateIndex(), sqlite3Pragma(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_Not

#define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */

Definition at line 15585 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_NotExists

#define OP_NotExists 32 /* jump, synopsis: intkey=r[P3] */

Definition at line 15598 of file sqlite3.c.

Referenced by analyzeOneTable(), blobSeekToRow(), fkLookupParent(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3VdbeExec(), and xferOptimization().

◆ OP_NotFound

#define OP_NotFound 29 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15595 of file sqlite3.c.

Referenced by analyzeOneTable(), multiSelect(), sqlite3DeleteFrom(), sqlite3ExprCodeIN(), sqlite3GenerateRowDelete(), sqlite3Update(), and sqlite3VdbeExec().

◆ OP_NotNull

#define OP_NotNull 51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */

Definition at line 15617 of file sqlite3.c.

Referenced by analyzeOneTable(), autoIncrementEnd(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3VdbeExec(), and windowCodeRangeTest().

◆ OP_Null

#define OP_Null 72 /* synopsis: r[P2..P3]=NULL */

◆ OP_NullRow

#define OP_NullRow 128

Definition at line 15694 of file sqlite3.c.

Referenced by generateSortTail(), generateWithRecursiveQuery(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_Offset

#define OP_Offset 88 /* synopsis: r[P3] = sqlite_offset(P1) */

Definition at line 15654 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_OffsetLimit

#define OP_OffsetLimit 152 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */

Definition at line 15718 of file sqlite3.c.

Referenced by computeLimitRegisters(), multiSelect(), and sqlite3VdbeExec().

◆ OP_Once

#define OP_Once 17 /* jump */

Definition at line 15583 of file sqlite3.c.

Referenced by constructAutomaticIndex(), generateSortTail(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3DeleteFrom(), sqlite3ExprCodeRunJustOnce(), sqlite3FindInIndex(), sqlite3Select(), sqlite3Update(), sqlite3VdbeExec(), and sqlite3VdbeJumpHereOrPopInst().

◆ OP_OpenAutoindex

#define OP_OpenAutoindex 99 /* synopsis: nColumn=P2 */

Definition at line 15665 of file sqlite3.c.

Referenced by constructAutomaticIndex(), and sqlite3VdbeExec().

◆ OP_OpenDup

#define OP_OpenDup 98

Definition at line 15664 of file sqlite3.c.

Referenced by sqlite3CodeRhsOfIN(), sqlite3Select(), sqlite3VdbeExec(), and sqlite3WindowCodeInit().

◆ OP_OpenEphemeral

#define OP_OpenEphemeral 100 /* synopsis: nColumn=P2 */

Definition at line 15666 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), multiSelect(), resetAccumulator(), sqlite3CodeRhsOfIN(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Select(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WindowCodeInit(), and updateVirtualTable().

◆ OP_OpenPseudo

#define OP_OpenPseudo 114 /* synopsis: P3 columns in r[P2] */

Definition at line 15680 of file sqlite3.c.

Referenced by generateSortTail(), generateWithRecursiveQuery(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_OpenRead

#define OP_OpenRead 96 /* synopsis: root=P2 iDb=P3 */

Definition at line 15662 of file sqlite3.c.

Referenced by analyzeOneTable(), fkLookupParent(), generateSortTail(), readsTable(), sqlite3FindInIndex(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3VdbeExec(), sqlite3VdbeNextOpcode(), sqlite3WhereBegin(), and xferOptimization().

◆ OP_OpenWrite

#define OP_OpenWrite 97 /* synopsis: root=P2 iDb=P3 */

Definition at line 15663 of file sqlite3.c.

Referenced by autoIncrementEnd(), openStatTable(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3Insert(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3RefillIndex(), sqlite3Update(), sqlite3VdbeExec(), sqlite3VdbeNextOpcode(), sqlite3WhereBegin(), and xferOptimization().

◆ OP_Or

#define OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */

Definition at line 15609 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_Pagecount

#define OP_Pagecount 168

Definition at line 15734 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Param

#define OP_Param 148

Definition at line 15714 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_ParseSchema

#define OP_ParseSchema 141

Definition at line 15707 of file sqlite3.c.

Referenced by sqlite3VdbeAddParseSchemaOp(), and sqlite3VdbeExec().

◆ OP_Permutation

#define OP_Permutation 85

Definition at line 15651 of file sqlite3.c.

Referenced by multiSelectOrderBy(), and sqlite3VdbeExec().

◆ OP_Prev

#define OP_Prev 4 /* jump */

Definition at line 15570 of file sqlite3.c.

Referenced by codeEqualityTerm(), resolveP2Values(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_Program

#define OP_Program 46 /* jump */

Definition at line 15612 of file sqlite3.c.

Referenced by sqlite3CodeRowTriggerDirect(), and sqlite3VdbeExec().

◆ OP_PureFunc

#define OP_PureFunc 63 /* synopsis: r[P3]=func(r[P2@NP]) */

Definition at line 15629 of file sqlite3.c.

Referenced by sqlite3NotPureFunc(), sqlite3VdbeAddFunctionCall(), and sqlite3VdbeExec().

◆ OP_ReadCookie

#define OP_ReadCookie 93

Definition at line 15659 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), sqlite3Pragma(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ OP_Real

#define OP_Real 150 /* same as TK_FLOAT, synopsis: r[P2]=P4 */

Definition at line 15716 of file sqlite3.c.

Referenced by codeReal(), and sqlite3VdbeExec().

◆ OP_RealAffinity

#define OP_RealAffinity 83

Definition at line 15649 of file sqlite3.c.

Referenced by sqlite3ColumnDefault(), sqlite3ExprCodeTarget(), sqlite3GenerateIndexKey(), sqlite3UpsertDoUpdate(), and sqlite3VdbeExec().

◆ OP_ReleaseReg

#define OP_ReleaseReg 172 /* synopsis: release r[P1@P2] mask P3 */

Definition at line 15738 of file sqlite3.c.

Referenced by sqlite3Insert(), and sqlite3VdbeExec().

◆ OP_Remainder

#define OP_Remainder 109 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */

Definition at line 15675 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_ReopenIdx

#define OP_ReopenIdx 95 /* synopsis: root=P2 iDb=P3 */

Definition at line 15661 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeNextOpcode(), and sqlite3WhereBegin().

◆ OP_ResetCount

#define OP_ResetCount 123

Definition at line 15689 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_ResetSorter

#define OP_ResetSorter 138

Definition at line 15704 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3WindowCodeStep(), and windowInitAccum().

◆ OP_ResultRow

#define OP_ResultRow 80 /* synopsis: output=r[P1@P2] */

Definition at line 15646 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), integrityCheckResultRow(), selectInnerLoop(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), sqlite3VdbeExec(), and sqlite3VdbeMultiLoad().

◆ OP_Return

#define OP_Return 65

Definition at line 15631 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3Select(), sqlite3VdbeExec(), sqlite3WhereEnd(), and sqlite3WindowCodeStep().

◆ OP_Rewind

#define OP_Rewind 37 /* jump */

Definition at line 15603 of file sqlite3.c.

Referenced by analyzeOneTable(), codeAllEqualityTerms(), codeEqualityTerm(), constructAutomaticIndex(), generateWithRecursiveQuery(), multiSelect(), sqlite3DeleteFrom(), sqlite3ExprCodeIN(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3SetHasNullFlag(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), updateVirtualTable(), and xferOptimization().

◆ OP_RowData

#define OP_RowData 126 /* synopsis: r[P2]=data */

Definition at line 15692 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), multiSelect(), sqlite3DeleteFrom(), sqlite3Update(), sqlite3VdbeExec(), and xferOptimization().

◆ OP_Rowid

#define OP_Rowid 127 /* synopsis: r[P2]=rowid */

Definition at line 15693 of file sqlite3.c.

Referenced by codeEqualityTerm(), sqlite3Pragma(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WhereEnd(), translateColumnToCopy(), updateVirtualTable(), windowCodeOp(), windowFullScan(), windowReturnOneRow(), and xferOptimization().

◆ OP_RowSetAdd

#define OP_RowSetAdd 147 /* synopsis: rowset(P1)=r[P2] */

Definition at line 15713 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Update(), and sqlite3VdbeExec().

◆ OP_RowSetRead

#define OP_RowSetRead 42 /* jump, synopsis: r[P3]=rowset(P1) */

Definition at line 15608 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Update(), and sqlite3VdbeExec().

◆ OP_RowSetTest

#define OP_RowSetTest 45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */

Definition at line 15611 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Savepoint

#define OP_Savepoint 0

Definition at line 15566 of file sqlite3.c.

Referenced by resolveP2Values(), and sqlite3VdbeExec().

◆ OP_SCopy

#define OP_SCopy 78 /* synopsis: r[P2]=r[P1] */

Definition at line 15644 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), fkLookupParent(), selectInnerLoop(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3VdbeExec(), updateVirtualTable(), and windowAggStep().

◆ OP_SeekEnd

#define OP_SeekEnd 129

Definition at line 15695 of file sqlite3.c.

Referenced by sqlite3RefillIndex(), sqlite3VdbeExec(), and xferOptimization().

◆ OP_SeekGE

#define OP_SeekGE 24 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15590 of file sqlite3.c.

Referenced by generateSortTail(), sqlite3VdbeExec(), windowAggStep(), and windowFullScan().

◆ OP_SeekGT

#define OP_SeekGT 25 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15591 of file sqlite3.c.

Referenced by analyzeOneTable(), codeAllEqualityTerms(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_SeekHit

#define OP_SeekHit 118 /* synopsis: seekHit=P2 */

Definition at line 15684 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_SeekLE

#define OP_SeekLE 23 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15589 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_SeekLT

#define OP_SeekLT 22 /* jump, synopsis: key=r[P3@P4] */

Definition at line 15588 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_SeekRowid

#define OP_SeekRowid 31 /* jump, synopsis: intkey=r[P3] */

Definition at line 15597 of file sqlite3.c.

Referenced by generateSortTail(), sqlite3ExprCodeIN(), sqlite3Pragma(), sqlite3UpsertDoUpdate(), sqlite3VdbeExec(), and windowReturnOneRow().

◆ OP_Sequence

#define OP_Sequence 119 /* synopsis: r[P2]=cursor[P1].ctr++ */

Definition at line 15685 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3VdbeExec(), and translateColumnToCopy().

◆ OP_SequenceTest

#define OP_SequenceTest 113 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */

Definition at line 15679 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_SetCookie

#define OP_SetCookie 94

Definition at line 15660 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), sqlite3ChangeCookie(), sqlite3Pragma(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ OP_ShiftLeft

#define OP_ShiftLeft 103 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */

Definition at line 15669 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_ShiftRight

#define OP_ShiftRight 104 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */

Definition at line 15670 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_SoftNull

#define OP_SoftNull 73 /* synopsis: r[P1]=NULL */

Definition at line 15639 of file sqlite3.c.

Referenced by sqlite3Insert(), and sqlite3VdbeExec().

◆ OP_Sort

#define OP_Sort 36 /* jump */

Definition at line 15602 of file sqlite3.c.

Referenced by generateSortTail(), and sqlite3VdbeExec().

◆ OP_SorterCompare

#define OP_SorterCompare 124 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */

Definition at line 15690 of file sqlite3.c.

Referenced by sqlite3RefillIndex(), and sqlite3VdbeExec().

◆ OP_SorterData

#define OP_SorterData 125 /* synopsis: r[P2]=data */

Definition at line 15691 of file sqlite3.c.

Referenced by generateSortTail(), sqlite3RefillIndex(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_SorterInsert

#define OP_SorterInsert 131 /* synopsis: key=r[P2] */

Definition at line 15697 of file sqlite3.c.

Referenced by sqlite3RefillIndex(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_SorterNext

#define OP_SorterNext 3 /* jump */

Definition at line 15569 of file sqlite3.c.

Referenced by generateSortTail(), resolveP2Values(), sqlite3RefillIndex(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_SorterOpen

#define OP_SorterOpen 111

Definition at line 15677 of file sqlite3.c.

Referenced by sqlite3RefillIndex(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_SorterSort

#define OP_SorterSort 35 /* jump */

Definition at line 15601 of file sqlite3.c.

Referenced by generateSortTail(), sqlite3RefillIndex(), sqlite3Select(), and sqlite3VdbeExec().

◆ OP_SqlExec

#define OP_SqlExec 140

Definition at line 15706 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_String

#define OP_String 71 /* synopsis: r[P2]='P4' (len=P1) */

Definition at line 15637 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_String8

#define OP_String8 115 /* same as TK_STRING, synopsis: r[P2]='P4' */

Definition at line 15681 of file sqlite3.c.

Referenced by sqlite3Pragma(), sqlite3VdbeExec(), sqlite3VdbeMultiLoad(), whereLikeOptimizationStringFixup(), windowCheckValue(), and windowCodeRangeTest().

◆ OP_Subtract

#define OP_Subtract 106 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */

Definition at line 15672 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3Pragma(), sqlite3VdbeExec(), sqlite3WindowCodeStep(), windowCodeRangeTest(), and windowReturnOneRow().

◆ OP_TableLock

#define OP_TableLock 161 /* synopsis: iDb=P1 root=P2 write=P3 */

Definition at line 15727 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Trace

#define OP_Trace 170

Definition at line 15736 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_Transaction

#define OP_Transaction 2

Definition at line 15568 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3FinishCoding(), sqlite3Pragma(), and sqlite3VdbeExec().

◆ OP_Vacuum

#define OP_Vacuum 8

Definition at line 15574 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3Vacuum(), and sqlite3VdbeExec().

◆ OP_Variable

#define OP_Variable 75 /* synopsis: r[P2]=parameter(P1,P4) */

Definition at line 15641 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OP_VBegin

#define OP_VBegin 162

Definition at line 15728 of file sqlite3.c.

Referenced by sqlite3FinishCoding(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ OP_VColumn

#define OP_VColumn 166 /* synopsis: r[P3]=vcolumn(P2) */

Definition at line 15732 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and updateVirtualTable().

◆ OP_VCreate

#define OP_VCreate 163

Definition at line 15729 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_VDestroy

#define OP_VDestroy 164

Definition at line 15730 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_VFilter

#define OP_VFilter 9 /* jump, synopsis: iplan=r[P3] zplan='P4' */

Definition at line 15575 of file sqlite3.c.

Referenced by resolveP2Values(), and sqlite3VdbeExec().

◆ OP_VNext

#define OP_VNext 61 /* jump */

Definition at line 15627 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3WhereEnd().

◆ OP_VOpen

#define OP_VOpen 165

Definition at line 15731 of file sqlite3.c.

Referenced by readsTable(), sqlite3VdbeExec(), and sqlite3WhereBegin().

◆ OP_VRename

#define OP_VRename 167

Definition at line 15733 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OP_VUpdate

#define OP_VUpdate 10 /* synopsis: data=r[P3@P2] */

Definition at line 15576 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3VdbeExec(), and updateVirtualTable().

◆ OP_Yield

#define OP_Yield 14 /* jump */

Definition at line 15580 of file sqlite3.c.

Referenced by constructAutomaticIndex(), generateOutputSubroutine(), generateSortTail(), multiSelectOrderBy(), selectInnerLoop(), sqlite3EndTable(), sqlite3Insert(), and sqlite3VdbeExec().

◆ OpcodeRewriteTrace

#define OpcodeRewriteTrace	(	D,
		K,
		P ) /* no-op */

Definition at line 150872 of file sqlite3.c.

Referenced by sqlite3WhereEnd().

◆ OpenCounter

#define OpenCounter ( X )

Definition at line 33835 of file sqlite3.c.

Referenced by closeUnixFile().

◆ OPFLAG_APPEND

#define OPFLAG_APPEND 0x08 /* This is likely to be an append */

Definition at line 18842 of file sqlite3.c.

Referenced by analyzeOneTable(), generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3CompleteInsertion(), sqlite3StartTable(), sqlite3VdbeExec(), and xferOptimization().

◆ OPFLAG_AUXDELETE

#define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */

Definition at line 18853 of file sqlite3.c.

Referenced by sqlite3GenerateRowDelete(), and sqlite3VdbeExec().

◆ OPFLAG_BULKCSR

#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */

Definition at line 18847 of file sqlite3.c.

Referenced by sqlite3RefillIndex(), sqlite3VdbeExec(), and xferOptimization().

◆ OPFLAG_EPHEM

#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */

Definition at line 18839 of file sqlite3.c.

◆ OPFLAG_FORDELETE

#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */

Definition at line 18849 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3VdbeExec(), and sqlite3WhereBegin().

◆ OPFLAG_ISNOOP

#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */

Definition at line 18844 of file sqlite3.c.

Referenced by sqlite3CompleteInsertion(), sqlite3GenerateConstraintChecks(), sqlite3Update(), and sqlite3VdbeExec().

◆ OPFLAG_ISUPDATE

#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */

Definition at line 18841 of file sqlite3.c.

Referenced by sqlite3CompleteInsertion(), sqlite3Update(), and sqlite3VdbeExec().

◆ OPFLAG_LASTROWID

#define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */

Definition at line 18840 of file sqlite3.c.

Referenced by sqlite3CompleteInsertion(), sqlite3VdbeExec(), and xferOptimization().

◆ OPFLAG_LENGTHARG

#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */

Definition at line 18845 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ OPFLAG_NCHANGE

#define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */

Definition at line 18836 of file sqlite3.c.

Referenced by sqlite3CompleteInsertion(), sqlite3GenerateRowDelete(), sqlite3VdbeExec(), and xferOptimization().

◆ OPFLAG_NOCHNG

#define OPFLAG_NOCHNG 0x01 /* OP_VColumn nochange for UPDATE */

Definition at line 18838 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and updateVirtualTable().

◆ OPFLAG_NOCHNG_MAGIC

#define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */

Definition at line 18854 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and updateVirtualTable().

◆ OPFLAG_P2ISREG

#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */

Definition at line 18850 of file sqlite3.c.

Referenced by openStatTable(), sqlite3EndTable(), sqlite3RefillIndex(), sqlite3VdbeExec(), and sqlite3VdbeNextOpcode().

◆ OPFLAG_PERMUTE

#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */

Definition at line 18851 of file sqlite3.c.

Referenced by multiSelectOrderBy(), and sqlite3VdbeExec().

◆ OPFLAG_SAVEPOSITION

#define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */

Definition at line 18852 of file sqlite3.c.

Referenced by sqlite3CompleteInsertion(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3VdbeExec(), and windowCodeOp().

◆ OPFLAG_SEEKEQ

#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */

Definition at line 18848 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3WhereBegin().

◆ OPFLAG_TYPEOFARG

#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */

Definition at line 18846 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3Pragma(), sqlite3SetHasNullFlag(), and sqlite3VdbeExec().

◆ OPFLAG_USESEEKRESULT

#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */

Definition at line 18843 of file sqlite3.c.

Referenced by codeDistinct(), constructAutomaticIndex(), selectInnerLoop(), sqlite3CompleteInsertion(), sqlite3RefillIndex(), sqlite3VdbeExec(), and xferOptimization().

◆ OPFLG_IN1

#define OPFLG_IN1 0x02 /* in1: P1 is an input */

Definition at line 15748 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OPFLG_IN2

#define OPFLG_IN2 0x04 /* in2: P2 is an input */

Definition at line 15749 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OPFLG_IN3

#define OPFLG_IN3 0x08 /* in3: P3 is an input */

Definition at line 15750 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OPFLG_INITIALIZER

#define OPFLG_INITIALIZER

Value:

{\
/*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\
/*   8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\
/*  16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x01, 0x09, 0x09,\
/*  24 */ 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09,\
/*  32 */ 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\
/*  40 */ 0x01, 0x01, 0x23, 0x26, 0x26, 0x0b, 0x01, 0x01,\
/*  48 */ 0x03, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00,\
/*  64 */ 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\
/*  72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
/*  80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\
/*  88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
/*  96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\
/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10,\
/* 120 */ 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
/* 128 */ 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10, 0x00,\
/* 136 */ 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\
/* 144 */ 0x00, 0x00, 0x00, 0x06, 0x10, 0x00, 0x10, 0x04,\
/* 152 */ 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 168 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
}

Definition at line 15753 of file sqlite3.c.

#define OPFLG_INITIALIZER {\
/*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\
/*   8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\
/*  16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x01, 0x09, 0x09,\
/*  24 */ 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09,\
/*  32 */ 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\
/*  40 */ 0x01, 0x01, 0x23, 0x26, 0x26, 0x0b, 0x01, 0x01,\
/*  48 */ 0x03, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00,\
/*  64 */ 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\
/*  72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
/*  80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\
/*  88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
/*  96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\
/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10,\
/* 120 */ 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
/* 128 */ 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10, 0x00,\
/* 136 */ 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\
/* 144 */ 0x00, 0x00, 0x00, 0x06, 0x10, 0x00, 0x10, 0x04,\
/* 152 */ 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 168 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
}

◆ OPFLG_JUMP

#define OPFLG_JUMP 0x01 /* jump: P2 holds jmp target */

Definition at line 15747 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3GenerateConstraintChecks(), and sqlite3VdbeAddOpList().

◆ OPFLG_OUT2

#define OPFLG_OUT2 0x10 /* out2: P2 is an output */

Definition at line 15751 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OPFLG_OUT3

#define OPFLG_OUT3 0x20 /* out3: P3 is an output */

Definition at line 15752 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ OpHelp

#define OpHelp ( X )

Definition at line 33158 of file sqlite3.c.

Referenced by sqlite3OpcodeName().

◆ OptimizationDisabled

#define OptimizationDisabled	(		db,
			mask ) (((db)->dbOptFlags&(mask))!=0)

Definition at line 17063 of file sqlite3.c.

Referenced by flattenSubquery(), sqlite3WhereBegin(), and wherePathSatisfiesOrderBy().

◆ OptimizationEnabled

#define OptimizationEnabled	(		db,
			mask ) (((db)->dbOptFlags&(mask))==0)

Definition at line 17064 of file sqlite3.c.

Referenced by analyzeOneTable(), exprAnalyze(), openStatTable(), sqlite3Select(), sqlite3WhereBegin(), statInit(), termIsEquivalence(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ OS_VXWORKS

#define OS_VXWORKS 0

Definition at line 928 of file sqlite3.c.

Referenced by full_fsync(), and unixDelete().

◆ osAccess

#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)

◆ osClose

#define osClose ((int(*)(int))aSyscall[1].pCurrent)

◆ osFallocate

#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)

◆ osFchmod

#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)

◆ osFchown

#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

◆ osFcntl

#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)

◆ osFstat

#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)

◆ osFtruncate

#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)

◆ osGetcwd

#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)

◆ osGeteuid

#define osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent)

◆ osGetpagesize

#define osGetpagesize ((int(*)(void))aSyscall[25].pCurrent)

◆ osGetpid

#define osGetpid ( X ) (pid_t)getpid()

Definition at line 33531 of file sqlite3.c.

Referenced by dotlockUnlock(), posixUnlock(), unixLock(), unixOpen(), unixRandomness(), and unixShmLock().

◆ osLstat

#define osLstat ((int(*)(const char*,struct stat*))aSyscall[27].pCurrent)

◆ osMkdir

#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)

◆ osMmap

#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)

◆ osMremap

#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[24].pCurrent)

◆ osMunmap

#define osMunmap ((int(*)(void*,size_t))aSyscall[23].pCurrent)

◆ osOpen

#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)

◆ osOpenDirectory

#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)

◆ osPread

#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)

◆ osPread64

#define osPread64 ((ssize_t(*)(int,void*,size_t,off64_t))aSyscall[10].pCurrent)

◆ osPwrite

#define osPwrite

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\

aSyscall[12].pCurrent)

aSyscall

static struct unix_syscall aSyscall[]

unix_syscall::pCurrent

sqlite3_syscall_ptr pCurrent

Definition sqlite3.c:33927

◆ osPwrite64

#define osPwrite64

Value:

((ssize_t(*)(int,const void*,size_t,off64_t))\

aSyscall[13].pCurrent)

◆ osRead

#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)

◆ osReadlink

#define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[26].pCurrent)

◆ osRmdir

#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)

◆ osSetPosixAdvisoryLock

#define osSetPosixAdvisoryLock	(	h,
		x,
		t ) osFcntl(h,F_SETLK,x)

Definition at line 35103 of file sqlite3.c.

Referenced by unixFileLock(), and unixShmSystemLock().

◆ osStat

#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)

◆ OSTRACE

#define OSTRACE ( X )

Definition at line 13799 of file sqlite3.c.

Referenced by closeUnixFile(), dotlockCheckReservedLock(), dotlockUnlock(), openDirectory(), posixUnlock(), seekAndRead(), seekAndWriteFd(), unixCheckReservedLock(), unixLock(), unixOpen(), unixShmLock(), unixShmSystemLock(), and unixSync().

◆ osUnlink

#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)

◆ osWrite

#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)

◆ P4_ADVANCE

#define P4_ADVANCE (-5) /* P4 is a pointer to BtreeNext() or BtreePrev() */

Definition at line 15510 of file sqlite3.c.

Referenced by resolveP2Values(), and sqlite3VdbeDisplayP4().

◆ P4_COLLSEQ

#define P4_COLLSEQ (-2) /* P4 is a pointer to a CollSeq structure */

Definition at line 15507 of file sqlite3.c.

Referenced by analyzeOneTable(), selectInnerLoop(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3GetFuncCollSeq(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), updateAccumulator(), and windowAggStep().

◆ P4_DYNAMIC

#define P4_DYNAMIC (-7) /* Pointer to memory from sqliteMalloc() */

Definition at line 15514 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3Pragma(), sqlite3VdbeAddParseSchemaOp(), sqlite3VdbeExec(), sqlite3VdbeExplain(), and sqlite3WhereExplainOneScan().

◆ P4_DYNBLOB

#define P4_DYNBLOB (-17) /* Pointer to memory from sqliteMalloc() */

Definition at line 15524 of file sqlite3.c.

Referenced by analyzeOneTable(), and sqlite3VdbeDisplayP4().

◆ P4_EXPR

#define P4_EXPR (-10) /* P4 is a pointer to an Expr tree */

Definition at line 15517 of file sqlite3.c.

Referenced by sqlite3VdbeDisplayP4(), and sqlite3VdbeExec().

◆ P4_FREE_IF_LE

#define P4_FREE_IF_LE (-7)

Definition at line 15513 of file sqlite3.c.

Referenced by vdbeFreeOpArray().

◆ P4_FUNCCTX

#define P4_FUNCCTX (-16) /* P4 is a pointer to an sqlite3_context object */

Definition at line 15523 of file sqlite3.c.

Referenced by sqlite3VdbeAddFunctionCall(), sqlite3VdbeDisplayP4(), and sqlite3VdbeExec().

◆ P4_FUNCDEF

#define P4_FUNCDEF (-8) /* P4 is a pointer to a FuncDef structure */

Definition at line 15515 of file sqlite3.c.

Referenced by sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), updateAccumulator(), windowAggFinal(), and windowAggStep().

◆ P4_INT32

#define P4_INT32 (-3) /* P4 is a 32-bit signed integer */

Definition at line 15508 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), sqlite3VdbeAppendP4(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), and sqlite3WhereBegin().

◆ P4_INT64

#define P4_INT64 (-14) /* P4 is a 64-bit signed integer */

Definition at line 15521 of file sqlite3.c.

Referenced by codeInteger(), sqlite3FindInIndex(), sqlite3VdbeDisplayP4(), and sqlite3WhereBegin().

◆ P4_INTARRAY

#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */

Definition at line 15522 of file sqlite3.c.

Referenced by codeDeferredSeek(), multiSelectOrderBy(), sqlite3Pragma(), sqlite3VdbeDisplayP4(), and sqlite3VdbeExec().

◆ P4_KEYINFO

#define P4_KEYINFO (-9) /* P4 is a pointer to a KeyInfo structure */

Definition at line 15516 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), resetAccumulator(), sqlite3CodeRhsOfIN(), sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), windowFullScan(), and windowIfNewPeer().

◆ P4_MEM

#define P4_MEM (-11) /* P4 is a pointer to a Mem* structure */

Definition at line 15518 of file sqlite3.c.

Referenced by sqlite3ColumnDefault(), sqlite3VdbeDisplayP4(), and sqlite3VdbeExec().

◆ P4_NOTUSED

#define P4_NOTUSED 0 /* The P4 parameter is not used */

Definition at line 15504 of file sqlite3.c.

Referenced by sqlite3VdbeAddOpList(), and sqlite3VdbeAppendP4().

◆ P4_REAL

#define P4_REAL (-13) /* P4 is a 64-bit floating point value */

Definition at line 15520 of file sqlite3.c.

Referenced by codeReal(), and sqlite3VdbeDisplayP4().

◆ P4_STATIC

#define P4_STATIC (-1) /* Pointer to a static string */

Definition at line 15506 of file sqlite3.c.

Referenced by fkLookupParent(), sqlite3DeleteFrom(), sqlite3ExprCodeTarget(), sqlite3FkDropTable(), sqlite3Pragma(), sqlite3StartTable(), sqlite3UpsertDoUpdate(), sqlite3VdbeExec(), windowCheckValue(), and windowCodeRangeTest().

◆ P4_SUBPROGRAM

#define P4_SUBPROGRAM (-4) /* P4 is a pointer to a SubProgram structure */

Definition at line 15509 of file sqlite3.c.

Referenced by sqlite3CodeRowTriggerDirect(), sqlite3VdbeDisplayP4(), and sqlite3VdbeNextOpcode().

◆ P4_TABLE

#define P4_TABLE (-6) /* P4 is a pointer to a Table structure */

Definition at line 15511 of file sqlite3.c.

Referenced by analyzeOneTable(), sqlite3CompleteInsertion(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), and xferOptimization().

◆ P4_TRANSIENT

#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */

Definition at line 15505 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3GenerateIndexKey().

◆ P4_VTAB

#define P4_VTAB (-12) /* P4 is a pointer to an sqlite3_vtab structure */

Definition at line 15519 of file sqlite3.c.

Referenced by readsTable(), sqlite3DeleteFrom(), sqlite3FinishCoding(), sqlite3Insert(), sqlite3VdbeAppendP4(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3WhereBegin(), and updateVirtualTable().

◆ P5_ConstraintCheck

#define P5_ConstraintCheck 3

Definition at line 15529 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ P5_ConstraintFK

#define P5_ConstraintFK 4

Definition at line 15530 of file sqlite3.c.

Referenced by fkLookupParent(), and sqlite3FkDropTable().

◆ P5_ConstraintNotNull

#define P5_ConstraintNotNull 1

Definition at line 15527 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ P5_ConstraintUnique

#define P5_ConstraintUnique 2

Definition at line 15528 of file sqlite3.c.

◆ PAGE_IS_PINNED

#define PAGE_IS_PINNED ( p ) ((p)->pLruNext==0)

Definition at line 49880 of file sqlite3.c.

Referenced by pcache1Unpin().

◆ PAGE_IS_UNPINNED

#define PAGE_IS_UNPINNED ( p ) ((p)->pLruNext!=0)

Definition at line 49881 of file sqlite3.c.

Referenced by pcache1FetchNoMutex(), pcache1FetchStage2(), pcache1PinPage(), and pcache1TruncateUnsafe().

◆ PAGER_CACHESPILL

#define PAGER_CACHESPILL 0x20 /* PRAGMA cache_spill=ON */

Definition at line 14856 of file sqlite3.c.

Referenced by setAllPagerFlags(), and sqlite3PagerSetFlags().

◆ PAGER_CKPT_FULLFSYNC

#define PAGER_CKPT_FULLFSYNC 0x10 /* PRAGMA checkpoint_fullfsync=ON */

Definition at line 14855 of file sqlite3.c.

Referenced by setAllPagerFlags(), and sqlite3PagerSetFlags().

◆ pager_datahash

#define pager_datahash	(		X,
			Y ) 0

Definition at line 52966 of file sqlite3.c.

Referenced by pager_playback_one_page().

◆ PAGER_ERROR

#define PAGER_ERROR 6

Definition at line 52059 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_error(), pager_truncate(), pager_unlock(), pagerPlaybackSavepoint(), pagerUnlockAndRollback(), sqlite3PagerBegin(), sqlite3PagerCommitPhaseOne(), sqlite3PagerRollback(), sqlite3PagerSavepoint(), and sqlite3PagerSetJournalMode().

◆ PAGER_FLAGS_MASK

#define PAGER_FLAGS_MASK 0x38 /* All above except SYNCHRONOUS */

Definition at line 14857 of file sqlite3.c.

Referenced by attachFunc(), and setAllPagerFlags().

◆ PAGER_FULLFSYNC

#define PAGER_FULLFSYNC 0x08 /* PRAGMA fullfsync=ON */

Definition at line 14854 of file sqlite3.c.

Referenced by setAllPagerFlags(), and sqlite3PagerSetFlags().

◆ PAGER_GET_NOCONTENT

#define PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */

Definition at line 14838 of file sqlite3.c.

Referenced by allocateBtreePage(), btreeGetPage(), and getPageNormal().

◆ PAGER_GET_READONLY

#define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */

Definition at line 14839 of file sqlite3.c.

Referenced by accessPayload(), btreeCursor(), btreeGetPage(), and getOverflowPage().

◆ PAGER_INCR

#define PAGER_INCR ( v )

Definition at line 52425 of file sqlite3.c.

Referenced by pager_write_pagelist(), and readDbPage().

◆ PAGER_JOURNALMODE_DELETE

#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */

Definition at line 14828 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_unlock(), pagerOpenWalIfPresent(), sqlite3JournalModename(), sqlite3PagerSetJournalMode(), and sqlite3VdbeExec().

◆ PAGER_JOURNALMODE_MEMORY

#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */

Definition at line 14832 of file sqlite3.c.

Referenced by openSubJournal(), pager_end_transaction(), pager_open_journal(), pager_unlock(), sqlite3JournalModename(), sqlite3PagerOpen(), sqlite3PagerSetJournalMode(), sqlite3VdbeExec(), syncJournal(), writeJournalHdr(), and writeSuperJournal().

◆ PAGER_JOURNALMODE_OFF

#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */

Definition at line 14830 of file sqlite3.c.

Referenced by pager_open_journal(), pager_unlock(), sqlite3JournalModename(), sqlite3PagerCommitPhaseOne(), sqlite3PagerMovepage(), sqlite3PagerOpen(), sqlite3PagerSavepoint(), sqlite3PagerSetJournalMode(), sqlite3Pragma(), sqlite3VdbeExec(), and subjournalPage().

◆ PAGER_JOURNALMODE_PERSIST

#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */

Definition at line 14829 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_unlock(), sqlite3JournalModename(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerSetJournalMode(), and sqlite3VdbeExec().

◆ PAGER_JOURNALMODE_QUERY

#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */

Definition at line 14827 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ PAGER_JOURNALMODE_TRUNCATE

#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */

Definition at line 14831 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_unlock(), sqlite3JournalModename(), sqlite3PagerSetJournalMode(), and sqlite3VdbeExec().

◆ PAGER_JOURNALMODE_WAL

#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */

Definition at line 14833 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_unlock(), pagerOpenWalIfPresent(), sqlite3JournalModename(), sqlite3PagerCloseWal(), sqlite3PagerCommitPhaseOne(), sqlite3PagerOpenWal(), sqlite3PagerSetJournalMode(), and sqlite3VdbeExec().

◆ PAGER_LOCKINGMODE_EXCLUSIVE

#define PAGER_LOCKINGMODE_EXCLUSIVE 1

Definition at line 14818 of file sqlite3.c.

Referenced by getLockingMode(), sqlite3PagerLockingMode(), sqlite3PagerOpen(), and sqlite3Pragma().

◆ PAGER_LOCKINGMODE_NORMAL

#define PAGER_LOCKINGMODE_NORMAL 0

Definition at line 14817 of file sqlite3.c.

Referenced by getLockingMode(), sqlite3PagerLockingMode(), sqlite3PagerOpen(), and sqlite3Pragma().

◆ PAGER_LOCKINGMODE_QUERY

#define PAGER_LOCKINGMODE_QUERY -1

Definition at line 14816 of file sqlite3.c.

Referenced by getLockingMode(), sqlite3PagerLockingMode(), and sqlite3Pragma().

◆ PAGER_MEMORY

#define PAGER_MEMORY 0x0002 /* In-memory database */

Definition at line 14811 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ PAGER_MJ_PGNO

#define PAGER_MJ_PGNO ( x ) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))

Definition at line 14803 of file sqlite3.c.

Referenced by getPageNormal(), pager_playback_one_page(), pagerWriteLargeSector(), sqlite3PagerCommitPhaseOne(), and writeSuperJournal().

◆ PAGER_OMIT_JOURNAL

#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */

Definition at line 14810 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ PAGER_OPEN

#define PAGER_OPEN 0

Definition at line 52053 of file sqlite3.c.

Referenced by hasHotJournal(), pager_playback(), pager_playback_one_page(), pager_truncate(), pager_unlock(), pagerBeginReadTransaction(), pagerOpenWalIfPresent(), pagerPagecount(), pagerUnlockAndRollback(), sqlite3PagerMaxPageCount(), sqlite3PagerOpenWal(), sqlite3PagerSetJournalMode(), sqlite3PagerSetPagesize(), and sqlite3PagerSharedLock().

◆ pager_pagehash

#define pager_pagehash ( X ) 0

Definition at line 52967 of file sqlite3.c.

Referenced by pager_write_pagelist(), and readDbPage().

◆ PAGER_READER

#define PAGER_READER 1

Definition at line 52054 of file sqlite3.c.

Referenced by getPageNormal(), pager_end_transaction(), pager_truncate(), pager_unlock(), pagerBeginReadTransaction(), pagerUnlockAndRollback(), readDbPage(), sqlite3PagerBegin(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerOpen(), sqlite3PagerOpenWal(), sqlite3PagerPagecount(), sqlite3PagerRollback(), sqlite3PagerSetJournalMode(), and sqlite3PagerSharedLock().

◆ pager_set_pagehash

#define pager_set_pagehash ( X )

Definition at line 52968 of file sqlite3.c.

Referenced by getPageNormal(), pager_end_transaction(), pager_playback_one_page(), pager_write_pagelist(), pagerWalFrames(), and sqlite3PagerDontWrite().

◆ PAGER_STAT_HIT

#define PAGER_STAT_HIT 0

Definition at line 52409 of file sqlite3.c.

Referenced by getPageNormal(), and sqlite3PagerCacheStat().

◆ PAGER_STAT_MISS

#define PAGER_STAT_MISS 1

Definition at line 52410 of file sqlite3.c.

Referenced by getPageNormal(), and sqlite3PagerCacheStat().

◆ PAGER_STAT_SPILL

#define PAGER_STAT_SPILL 3

Definition at line 52412 of file sqlite3.c.

Referenced by pagerStress(), and sqlite3PagerCacheStat().

◆ PAGER_STAT_WRITE

#define PAGER_STAT_WRITE 2

Definition at line 52411 of file sqlite3.c.

Referenced by pager_incr_changecounter(), pager_write_pagelist(), pagerWalFrames(), and sqlite3PagerCacheStat().

◆ PAGER_SYNCHRONOUS_EXTRA

#define PAGER_SYNCHRONOUS_EXTRA 0x04 /* PRAGMA synchronous=EXTRA */

Definition at line 14852 of file sqlite3.c.

Referenced by sqlite3PagerSetFlags().

◆ PAGER_SYNCHRONOUS_FULL

#define PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */

Definition at line 14851 of file sqlite3.c.

Referenced by attachFunc(), and sqlite3PagerSetFlags().

◆ PAGER_SYNCHRONOUS_MASK

#define PAGER_SYNCHRONOUS_MASK 0x07 /* Mask for four values above */

Definition at line 14853 of file sqlite3.c.

Referenced by setAllPagerFlags(), sqlite3PagerSetFlags(), and sqlite3Pragma().

◆ PAGER_SYNCHRONOUS_NORMAL

#define PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */

Definition at line 14850 of file sqlite3.c.

◆ PAGER_SYNCHRONOUS_OFF

#define PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */

Definition at line 14849 of file sqlite3.c.

Referenced by openDatabase(), sqlite3PagerSetFlags(), and vdbeCommit().

◆ PAGER_WRITER_CACHEMOD

#define PAGER_WRITER_CACHEMOD 3

Definition at line 52056 of file sqlite3.c.

Referenced by pager_incr_changecounter(), pager_open_journal(), pager_playback_one_page(), pager_write(), pagerStress(), sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerExclusiveLock(), sqlite3PagerMovepage(), sqlite3PagerOkToChangeJournalMode(), sqlite3PagerSavepoint(), sqlite3PagerTruncateImage(), and syncJournal().

◆ PAGER_WRITER_DBMOD

#define PAGER_WRITER_DBMOD 4

Definition at line 52057 of file sqlite3.c.

Referenced by pager_incr_changecounter(), pager_playback(), pager_playback_one_page(), pager_truncate(), pager_write(), pager_write_pagelist(), sqlite3PagerCommitPhaseOne(), sqlite3PagerExclusiveLock(), sqlite3PagerMovepage(), and syncJournal().

◆ PAGER_WRITER_FINISHED

#define PAGER_WRITER_FINISHED 5

Definition at line 52058 of file sqlite3.c.

Referenced by sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), and sqlite3PagerPagecount().

◆ PAGER_WRITER_LOCKED

#define PAGER_WRITER_LOCKED 2

Definition at line 52055 of file sqlite3.c.

Referenced by pager_end_transaction(), pager_open_journal(), pager_write(), pagerOpenSavepoint(), pagerPlaybackSavepoint(), pagerUnlockAndRollback(), sqlite3PagerBegin(), sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerExclusiveLock(), sqlite3PagerRollback(), and sqlite3PagerWrite().

◆ PAGERID

#define PAGERID ( p ) (SQLITE_PTR_TO_INT(p->fd))

Definition at line 51833 of file sqlite3.c.

Referenced by pager_playback_one_page(), pager_write(), pager_write_pagelist(), pagerStress(), readDbPage(), sqlite3PagerBegin(), sqlite3PagerClose(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerDontWrite(), sqlite3PagerMovepage(), sqlite3PagerRollback(), subjournalPage(), and syncJournal().

◆ PAGERTRACE

#define PAGERTRACE ( X )

Definition at line 51822 of file sqlite3.c.

Referenced by pager_playback_one_page(), pager_write(), pager_write_pagelist(), pagerStress(), readDbPage(), sqlite3PagerBegin(), sqlite3PagerClose(), sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerDontWrite(), sqlite3PagerMovepage(), sqlite3PagerOpen(), sqlite3PagerRollback(), subjournalPage(), and syncJournal().

◆ pagerUseWal

#define pagerUseWal ( x ) ((x)->pWal!=0)

◆ PARSE_HDR_SZ

#define PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/

Definition at line 18789 of file sqlite3.c.

◆ PARSE_MODE_DECLARE_VTAB

#define PARSE_MODE_DECLARE_VTAB 1

Definition at line 18782 of file sqlite3.c.

Referenced by sqlite3_declare_vtab().

◆ PARSE_MODE_NORMAL

#define PARSE_MODE_NORMAL 0

Definition at line 18781 of file sqlite3.c.

Referenced by sqlite3_declare_vtab(), and sqlite3ViewGetColumnNames().

◆ PARSE_MODE_RENAME

#define PARSE_MODE_RENAME 2

Definition at line 18783 of file sqlite3.c.

Referenced by renameParseSql().

◆ PARSE_MODE_UNMAP

#define PARSE_MODE_UNMAP 3

Definition at line 18784 of file sqlite3.c.

Referenced by sqlite3ExprListSetName(), and sqlite3RenameTokenMap().

◆ PARSE_RECURSE_SZ

#define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */

Definition at line 18790 of file sqlite3.c.

◆ PARSE_TAIL

#define PARSE_TAIL ( X ) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */

Definition at line 18792 of file sqlite3.c.

Referenced by sqlite3NestedParse().

◆ PARSE_TAIL_SZ

#define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */

Definition at line 18791 of file sqlite3.c.

Referenced by sqlite3NestedParse().

◆ PARTLY_WITHIN

#define PARTLY_WITHIN 1 /* Object partially overlaps query region */

Definition at line 10973 of file sqlite3.c.

◆ pcache1

#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))

Definition at line 49994 of file sqlite3.c.

Referenced by pcache1Alloc(), pcache1Create(), pcache1Init(), pcache1Shutdown(), pcache1UnderMemoryPressure(), and sqlite3PCacheBufferSetup().

◆ PCACHE1_MIGHT_USE_GROUP_MUTEX

#define PCACHE1_MIGHT_USE_GROUP_MUTEX 0

Definition at line 50002 of file sqlite3.c.

◆ pcache1EnterMutex

#define pcache1EnterMutex ( X ) assert((X)->mutex==0)

Definition at line 50000 of file sqlite3.c.

Referenced by pcache1Cachesize(), pcache1Create(), pcache1Destroy(), pcache1ResizeHash(), pcache1Shrink(), pcache1Truncate(), and pcache1Unpin().

◆ pcache1LeaveMutex

#define pcache1LeaveMutex ( X ) assert((X)->mutex==0)

Definition at line 50001 of file sqlite3.c.

Referenced by pcache1Cachesize(), pcache1Create(), pcache1Destroy(), pcache1ResizeHash(), pcache1Shrink(), and pcache1Truncate().

◆ PCACHE_DIRTYLIST_ADD

#define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */

Definition at line 49022 of file sqlite3.c.

Referenced by pcacheManageDirtyList().

◆ PCACHE_DIRTYLIST_FRONT

#define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */

Definition at line 49023 of file sqlite3.c.

◆ PCACHE_DIRTYLIST_REMOVE

#define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */

Definition at line 49021 of file sqlite3.c.

Referenced by pcacheManageDirtyList(), and sqlite3PcacheDrop().

◆ pcacheDump

#define pcacheDump ( X )

Definition at line 48968 of file sqlite3.c.

Referenced by pcacheManageDirtyList(), and sqlite3PcacheFetchStress().

◆ pcacheTrace

#define pcacheTrace ( X )

Definition at line 48967 of file sqlite3.c.

Referenced by pcacheManageDirtyList(), sqlite3PcacheFetch(), sqlite3PcacheFetchStress(), sqlite3PcacheOpen(), and sqlite3PcacheTruncate().

◆ PENDING_BYTE

#define PENDING_BYTE sqlite3PendingByte

Definition at line 16423 of file sqlite3.c.

Referenced by posixUnlock(), unixLock(), unixRead(), and unixWrite().

◆ PENDING_BYTE_PAGE

#define PENDING_BYTE_PAGE ( pBt ) PAGER_MJ_PGNO(pBt)

Definition at line 64053 of file sqlite3.c.

Referenced by allocateBtreePage(), autoVacuumCommit(), backupOnePage(), btreeCreateTable(), btreeDropTable(), fillInCell(), finalDbSize(), getOverflowPage(), incrVacuumStep(), ptrmapPageno(), ptrmapPut(), and sqlite3BtreeIntegrityCheck().

◆ PENDING_LOCK

#define PENDING_LOCK 3

Definition at line 16362 of file sqlite3.c.

Referenced by unixLock().

◆ percent_rankFinalizeFunc

#define percent_rankFinalizeFunc percent_rankValueFunc

Definition at line 151524 of file sqlite3.c.

◆ PGHDR_CLEAN

#define PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */

Definition at line 16070 of file sqlite3.c.

Referenced by pcacheFetchFinishWithInit().

◆ PGHDR_DIRTY

#define PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */

Definition at line 16071 of file sqlite3.c.

Referenced by pagerStress(), sqlite3PagerDontWrite(), sqlite3PagerMovepage(), sqlite3PcacheDrop(), and sqlite3PcacheTruncate().

◆ PGHDR_DONT_WRITE

#define PGHDR_DONT_WRITE 0x010 /* Do not write content to disk */

Definition at line 16074 of file sqlite3.c.

Referenced by pager_write_pagelist(), and sqlite3PagerDontWrite().

◆ PGHDR_MMAP

#define PGHDR_MMAP 0x020 /* This is an mmap page object */

Definition at line 16075 of file sqlite3.c.

Referenced by sqlite3PagerUnrefNotNull(), and sqlite3PagerWrite().

◆ PGHDR_NEED_SYNC

#define PGHDR_NEED_SYNC

Value:

0x008 /* Fsync the rollback journal before

** writing this page to the database */

Definition at line 16073 of file sqlite3.c.

Referenced by pager_playback_one_page(), pager_write(), pager_write_pagelist(), pagerStress(), pagerWriteLargeSector(), pcacheManageDirtyList(), sqlite3PagerDontWrite(), sqlite3PagerMovepage(), and sqlite3PcacheFetchStress().

◆ PGHDR_WAL_APPEND

#define PGHDR_WAL_APPEND 0x040 /* Appended to wal file */

Definition at line 16077 of file sqlite3.c.

◆ PGHDR_WRITEABLE

#define PGHDR_WRITEABLE 0x004 /* Journaled and ready to modify */

Definition at line 16072 of file sqlite3.c.

Referenced by pager_write(), and sqlite3PagerWrite().

◆ PragFlg_NeedSchema

#define PragFlg_NeedSchema 0x01 /* Force schema load before running */

Definition at line 125174 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragFlg_NoColumns

#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */

Definition at line 125175 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragFlg_NoColumns1

#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */

Definition at line 125176 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragFlg_ReadOnly

#define PragFlg_ReadOnly 0x08 /* Read-only HEADER_VALUE */

Definition at line 125177 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragFlg_Result0

#define PragFlg_Result0 0x10 /* Acts as query when no argument */

Definition at line 125178 of file sqlite3.c.

Referenced by sqlite3PragmaVtabRegister().

◆ PragFlg_Result1

#define PragFlg_Result1 0x20 /* Acts as query when has one argument */

Definition at line 125179 of file sqlite3.c.

Referenced by sqlite3PragmaVtabRegister().

◆ PragFlg_SchemaOpt

#define PragFlg_SchemaOpt 0x40 /* Schema restricts name search if present */

Definition at line 125180 of file sqlite3.c.

◆ PragFlg_SchemaReq

#define PragFlg_SchemaReq 0x80 /* Schema required - "main" is default */

Definition at line 125181 of file sqlite3.c.

◆ PragTyp_ACTIVATE_EXTENSIONS

#define PragTyp_ACTIVATE_EXTENSIONS 0

Definition at line 125127 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_ANALYSIS_LIMIT

#define PragTyp_ANALYSIS_LIMIT 1

Definition at line 125128 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_AUTO_VACUUM

#define PragTyp_AUTO_VACUUM 3

Definition at line 125130 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_BUSY_TIMEOUT

#define PragTyp_BUSY_TIMEOUT 5

Definition at line 125132 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_CACHE_SIZE

#define PragTyp_CACHE_SIZE 6

Definition at line 125133 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_CACHE_SPILL

#define PragTyp_CACHE_SPILL 7

Definition at line 125134 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_CASE_SENSITIVE_LIKE

#define PragTyp_CASE_SENSITIVE_LIKE 8

Definition at line 125135 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_COLLATION_LIST

#define PragTyp_COLLATION_LIST 9

Definition at line 125136 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_COMPILE_OPTIONS

#define PragTyp_COMPILE_OPTIONS 10

Definition at line 125137 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_DATA_STORE_DIRECTORY

#define PragTyp_DATA_STORE_DIRECTORY 11

Definition at line 125138 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_DATABASE_LIST

#define PragTyp_DATABASE_LIST 12

Definition at line 125139 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_DEFAULT_CACHE_SIZE

#define PragTyp_DEFAULT_CACHE_SIZE 13

Definition at line 125140 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_ENCODING

#define PragTyp_ENCODING 14

Definition at line 125141 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_FLAG

#define PragTyp_FLAG 4

Definition at line 125131 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_FOREIGN_KEY_CHECK

#define PragTyp_FOREIGN_KEY_CHECK 15

Definition at line 125142 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_FOREIGN_KEY_LIST

#define PragTyp_FOREIGN_KEY_LIST 16

Definition at line 125143 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_FUNCTION_LIST

#define PragTyp_FUNCTION_LIST 17

Definition at line 125144 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_HARD_HEAP_LIMIT

#define PragTyp_HARD_HEAP_LIMIT 18

Definition at line 125145 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_HEADER_VALUE

#define PragTyp_HEADER_VALUE 2

Definition at line 125129 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_INCREMENTAL_VACUUM

#define PragTyp_INCREMENTAL_VACUUM 19

Definition at line 125146 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_INDEX_INFO

#define PragTyp_INDEX_INFO 20

Definition at line 125147 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_INDEX_LIST

#define PragTyp_INDEX_LIST 21

Definition at line 125148 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_INTEGRITY_CHECK

#define PragTyp_INTEGRITY_CHECK 22

Definition at line 125149 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_JOURNAL_MODE

#define PragTyp_JOURNAL_MODE 23

Definition at line 125150 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_JOURNAL_SIZE_LIMIT

#define PragTyp_JOURNAL_SIZE_LIMIT 24

Definition at line 125151 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_LOCK_PROXY_FILE

#define PragTyp_LOCK_PROXY_FILE 25

Definition at line 125152 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_LOCK_STATUS

#define PragTyp_LOCK_STATUS 43

Definition at line 125170 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_LOCKING_MODE

#define PragTyp_LOCKING_MODE 26

Definition at line 125153 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_MMAP_SIZE

#define PragTyp_MMAP_SIZE 28

Definition at line 125155 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_MODULE_LIST

#define PragTyp_MODULE_LIST 29

Definition at line 125156 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_OPTIMIZE

#define PragTyp_OPTIMIZE 30

Definition at line 125157 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_PAGE_COUNT

#define PragTyp_PAGE_COUNT 27

Definition at line 125154 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_PAGE_SIZE

#define PragTyp_PAGE_SIZE 31

Definition at line 125158 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_PRAGMA_LIST

#define PragTyp_PRAGMA_LIST 32

Definition at line 125159 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_SECURE_DELETE

#define PragTyp_SECURE_DELETE 33

Definition at line 125160 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_SHRINK_MEMORY

#define PragTyp_SHRINK_MEMORY 34

Definition at line 125161 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_SOFT_HEAP_LIMIT

#define PragTyp_SOFT_HEAP_LIMIT 35

Definition at line 125162 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_STATS

#define PragTyp_STATS 44

Definition at line 125171 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_SYNCHRONOUS

#define PragTyp_SYNCHRONOUS 36

Definition at line 125163 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_TABLE_INFO

#define PragTyp_TABLE_INFO 37

Definition at line 125164 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_TEMP_STORE

#define PragTyp_TEMP_STORE 38

Definition at line 125165 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_TEMP_STORE_DIRECTORY

#define PragTyp_TEMP_STORE_DIRECTORY 39

Definition at line 125166 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_THREADS

#define PragTyp_THREADS 40

Definition at line 125167 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_WAL_AUTOCHECKPOINT

#define PragTyp_WAL_AUTOCHECKPOINT 41

Definition at line 125168 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PragTyp_WAL_CHECKPOINT

#define PragTyp_WAL_CHECKPOINT 42

Definition at line 125169 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ PTF_INTKEY

#define PTF_INTKEY 0x01

Definition at line 63725 of file sqlite3.c.

Referenced by balance_quick(), btreeCreateTable(), decodeFlags(), and newDatabase().

◆ PTF_LEAF

#define PTF_LEAF 0x08

Definition at line 63728 of file sqlite3.c.

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), btreeCreateTable(), decodeFlags(), and newDatabase().

◆ PTF_LEAFDATA

#define PTF_LEAFDATA 0x04

Definition at line 63727 of file sqlite3.c.

Referenced by balance_quick(), btreeCreateTable(), decodeFlags(), and newDatabase().

◆ PTF_ZERODATA

#define PTF_ZERODATA 0x02

Definition at line 63726 of file sqlite3.c.

Referenced by btreeCreateTable(), and decodeFlags().

◆ PTRMAP_BTREE

#define PTRMAP_BTREE 5

Definition at line 64109 of file sqlite3.c.

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), checkTreePage(), modifyPagePointer(), relocatePage(), and setChildPtrmaps().

◆ PTRMAP_FREEPAGE

#define PTRMAP_FREEPAGE 2

Definition at line 64106 of file sqlite3.c.

Referenced by allocateBtreePage(), btreeCreateTable(), checkList(), freePage2(), and incrVacuumStep().

◆ PTRMAP_ISPAGE

#define PTRMAP_ISPAGE	(		pBt,
			pgno ) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))

Definition at line 64072 of file sqlite3.c.

Referenced by allocateBtreePage(), autoVacuumCommit(), btreeDropTable(), fillInCell(), finalDbSize(), getOverflowPage(), incrVacuumStep(), and ptrmapPut().

◆ PTRMAP_OVERFLOW1

#define PTRMAP_OVERFLOW1 3

Definition at line 64107 of file sqlite3.c.

Referenced by checkTreePage(), fillInCell(), modifyPagePointer(), ptrmapPutOvflPtr(), and relocatePage().

◆ PTRMAP_OVERFLOW2

#define PTRMAP_OVERFLOW2 4

Definition at line 64108 of file sqlite3.c.

Referenced by checkList(), fillInCell(), getOverflowPage(), modifyPagePointer(), and relocatePage().

◆ PTRMAP_PAGENO

#define PTRMAP_PAGENO	(		pBt,
			pgno ) ptrmapPageno(pBt, pgno)

Definition at line 64070 of file sqlite3.c.

Referenced by btreeCreateTable(), finalDbSize(), ptrmapGet(), ptrmapPut(), and sqlite3BtreeIntegrityCheck().

◆ PTRMAP_PTROFFSET

#define PTRMAP_PTROFFSET	(		pgptrmap,
			pgno ) (5*(pgno-pgptrmap-1))

Definition at line 64071 of file sqlite3.c.

Referenced by ptrmapGet(), and ptrmapPut().

◆ PTRMAP_ROOTPAGE

#define PTRMAP_ROOTPAGE 1

Definition at line 64105 of file sqlite3.c.

Referenced by btreeCreateTable(), btreeDropTable(), incrVacuumStep(), relocatePage(), and sqlite3BtreeIntegrityCheck().

◆ PURE_DATE

#define PURE_DATE	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \

(void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }

sqlite3Config

SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config

Definition sqlite3.c:20573

Definition at line 17258 of file sqlite3.c.

#define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
   0, 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterDateTimeFunctions().

◆ put2byte

#define put2byte	(		p,
			v ) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))

Definition at line 64164 of file sqlite3.c.

Referenced by allocateSpace(), defragmentPage(), dropCell(), editPage(), freeSpace(), insertCell(), pageFindSlot(), pageInsertArray(), and rebuildPage().

◆ put32bits

#define put32bits	(		A,
			B ) sqlite3Put4byte((u8*)A,B)

Definition at line 52809 of file sqlite3.c.

Referenced by pager_write_changecounter(), syncJournal(), write32bits(), and writeJournalHdr().

◆ put4byte

#define put4byte sqlite3Put4byte

Definition at line 64166 of file sqlite3.c.

Referenced by allocateBtreePage(), autoVacuumCommit(), balance_deeper(), balance_nonroot(), balance_quick(), fillInCell(), freePage2(), insertCell(), modifyPagePointer(), newDatabase(), ptrmapPut(), sqlite3BtreeBeginTrans(), and sqlite3BtreeIncrVacuum().

◆ putVarint

#define putVarint sqlite3PutVarint

Definition at line 19876 of file sqlite3.c.

Referenced by balance_nonroot(), and fillInCell().

◆ putVarint32

#define putVarint32	(		A,
			B )

Value:

(u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\

sqlite3PutVarint((A),(B)))

u8

UINT8_TYPE u8

Definition sqlite3.c:14334

Definition at line 19872 of file sqlite3.c.

*/
#define getVarint32(A,B)  \
  (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))

Referenced by fillInCell(), and sqlite3VdbeExec().

◆ READ_LOCK

#define READ_LOCK 1

Definition at line 63789 of file sqlite3.c.

Referenced by querySharedCacheTableLock(), setSharedCacheTableLock(), sqlite3BtreeBeginTrans(), sqlite3BtreeGetMeta(), sqlite3BtreeLockTable(), and sqlite3BtreeSchemaLocked().

◆ READ_UTF8

#define READ_UTF8	(	zIn,
		zTerm,
		c )

Value:

  c = *(zIn++);                                            \
  if( c>=0xc0 ){                                           \
    c = sqlite3Utf8Trans1[c-0xc0];                         \
    while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
      c = (c<<6) + (0x3f & *(zIn++));                      \
    }                                                      \
    if( c<0x80                                             \
        || (c&0xFFFFF800)==0xD800                          \
        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }        \
  }

Definition at line 30777 of file sqlite3.c.

**     invalid characters.
**
**  *  This routine accepts over-length UTF8 encodings
**     for unicode values 0x80 and greater.  It does not change over-length
**     encodings to 0xfffd as some systems recommend.
*/
#define READ_UTF8(zIn, zTerm, c)                           \
  c = *(zIn++);                                            \
  if( c>=0xc0 ){                                           \
    c = sqlite3Utf8Trans1[c-0xc0];                         \
    while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \

Referenced by sqlite3VdbeMemTranslate().

◆ READMARK_NOT_USED

#define READMARK_NOT_USED 0xffffffff

Definition at line 59795 of file sqlite3.c.

Referenced by walCheckpoint(), walIndexRecover(), walRestartHdr(), and walTryBeginRead().

◆ REGISTER_TRACE

#define REGISTER_TRACE	(		R,
			M )

Definition at line 85828 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ renameTokenCheckAll

#define renameTokenCheckAll	(		x,
			y )

Definition at line 106492 of file sqlite3.c.

Referenced by sqlite3RenameTokenMap(), and sqlite3RenameTokenRemap().

◆ REOPEN_AS_MEMDB

#define REOPEN_AS_MEMDB ( db ) (0)

◆ RESERVED_BYTE

#define RESERVED_BYTE (PENDING_BYTE+1)

Definition at line 16425 of file sqlite3.c.

Referenced by posixUnlock(), unixCheckReservedLock(), and unixLock().

◆ RESERVED_LOCK

#define RESERVED_LOCK 2

Definition at line 16361 of file sqlite3.c.

Referenced by hasHotJournal(), pager_end_transaction(), pager_wait_on_lock(), pagerLockDb(), sqlite3PagerBegin(), sqlite3PagerSetJournalMode(), and unixLock().

◆ restoreCursorPosition

#define restoreCursorPosition ( p )

Value:

  (p->eState>=CURSOR_REQUIRESEEK ? \
         btreeRestoreCursorPosition(p) : \
         SQLITE_OK)

Definition at line 65342 of file sqlite3.c.

      pCur->eState = CURSOR_SKIPNEXT;
    }
  }
  return rc;

Referenced by btreeNext(), btreePrevious(), sqlite3BtreeCursorRestore(), and sqlite3BtreePutData().

◆ ROUND8

#define ROUND8 ( x ) (((x)+7)&~7)

◆ ROUNDDOWN8

#define ROUNDDOWN8 ( x ) ((x)&~7)

Definition at line 14477 of file sqlite3.c.

Referenced by setupLookaside(), sqlite3PCacheBufferSetup(), and sqlite3VdbeMakeReady().

◆ ROWSET_ALLOCATION_SIZE

#define ROWSET_ALLOCATION_SIZE 1024

Definition at line 51108 of file sqlite3.c.

◆ ROWSET_ENTRY_PER_CHUNK

#define ROWSET_ENTRY_PER_CHUNK ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))

Definition at line 51113 of file sqlite3.c.

51113*/

51114#define ROWSET_ALLOCATION_SIZE 1024

Referenced by rowSetEntryAlloc().

◆ ROWSET_NEXT

#define ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */

Definition at line 51162 of file sqlite3.c.

Referenced by sqlite3RowSetInsert(), sqlite3RowSetNext(), and sqlite3RowSetTest().

◆ ROWSET_SORTED

#define ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */

Definition at line 51161 of file sqlite3.c.

Referenced by sqlite3RowSetClear(), sqlite3RowSetInit(), sqlite3RowSetNext(), and sqlite3RowSetTest().

◆ SAVEPOINT_BEGIN

#define SAVEPOINT_BEGIN 0

Definition at line 17295 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VtabSavepoint(), and yy_reduce().

◆ SAVEPOINT_RELEASE

#define SAVEPOINT_RELEASE 1

Definition at line 17296 of file sqlite3.c.

Referenced by sqlite3BtreeSavepoint(), sqlite3PagerSavepoint(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VtabSavepoint(), vdbeCloseStatement(), and yy_reduce().

◆ SAVEPOINT_ROLLBACK

#define SAVEPOINT_ROLLBACK 2

Definition at line 17297 of file sqlite3.c.

Referenced by sqlite3BtreeSavepoint(), sqlite3PagerRollback(), sqlite3PagerSavepoint(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VtabSavepoint(), vdbeCloseStatement(), and yy_reduce().

◆ SCHEMA_ENC

#define SCHEMA_ENC ( db ) ((db)->aDb[0].pSchema->enc)

Definition at line 16960 of file sqlite3.c.

Referenced by openDatabase(), sqlite3Init(), and sqlite3Pragma().

◆ SCHEMA_ROOT

#define SCHEMA_ROOT 1

Definition at line 14582 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), sqlite3BtreeGetMeta(), sqlite3BtreeSchemaLocked(), and sqlite3VdbeExec().

◆ SCHEMA_TABLE

#define SCHEMA_TABLE ( x ) ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE)

Definition at line 14587 of file sqlite3.c.

14587#define SCHEMA_TABLE(x) \

14588 ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE)

Referenced by sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3InitOne(), and sqlite3StartTable().

◆ SELECTTRACE

#define SELECTTRACE	(	K,
		P,
		S,
		X )

Definition at line 14550 of file sqlite3.c.

Referenced by flattenSubquery(), generateColumnNames(), havingToWhere(), sqlite3Select(), and sqlite3WindowRewrite().

◆ SELECTTRACE_ENABLED [1/2]

#define SELECTTRACE_ENABLED 0

Definition at line 14541 of file sqlite3.c.

◆ SELECTTRACE_ENABLED [2/2]

#define SELECTTRACE_ENABLED 0

Definition at line 14541 of file sqlite3.c.

◆ SET_FULLSYNC

#define SET_FULLSYNC	(		x,
			y )

Definition at line 16307 of file sqlite3.c.

◆ SETBIT

#define SETBIT	(		V,
			I ) V[I>>3] \|= (1<<(I&7))

Definition at line 48762 of file sqlite3.c.

Referenced by sqlite3BitvecBuiltinTest().

◆ setDefaultSyncFlag

#define setDefaultSyncFlag	(		pBt,
			safety_level )

Definition at line 67522 of file sqlite3.c.

Referenced by lockBtree().

◆ SF_Aggregate

#define SF_Aggregate 0x0000008 /* Contains agg functions or a GROUP BY */

Definition at line 18474 of file sqlite3.c.

Referenced by flattenSubquery(), generateWithRecursiveQuery(), isCandidateForInOpt(), pushDownWhereTerms(), sqlite3Select(), and sqlite3WindowRewrite().

◆ SF_All

#define SF_All 0x0000002 /* Includes the ALL keyword */

Definition at line 18472 of file sqlite3.c.

Referenced by yy_reduce().

◆ SF_ComplexResult

#define SF_ComplexResult 0x0040000 /* Result contains subquery or function */

Definition at line 18489 of file sqlite3.c.

Referenced by selectExpander(), and sqlite3Select().

◆ SF_Compound

#define SF_Compound 0x0000100 /* Part of a compound query */

Definition at line 18479 of file sqlite3.c.

Referenced by flattenSubquery(), multiSelect(), and parserDoubleLinkSelect().

◆ SF_Converted

#define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */

Definition at line 18487 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery().

◆ SF_Distinct

#define SF_Distinct 0x0000001 /* Output should be DISTINCT */

Definition at line 18471 of file sqlite3.c.

Referenced by flattenSubquery(), isCandidateForInOpt(), sqlite3CodeRhsOfIN(), sqlite3Select(), xferOptimization(), and yy_reduce().

◆ SF_Expanded

#define SF_Expanded 0x0000040 /* sqlite3SelectExpand() called on this */

Definition at line 18477 of file sqlite3.c.

Referenced by selectExpander(), and sqlite3WindowRewrite().

◆ SF_FixedLimit

#define SF_FixedLimit 0x0004000 /* nSelectRow set by a constant LIMIT */

Definition at line 18485 of file sqlite3.c.

Referenced by computeLimitRegisters(), and sqlite3Select().

◆ SF_HasAgg

#define SF_HasAgg 0x0000010 /* Contains aggregate functions */

Definition at line 18475 of file sqlite3.c.

◆ SF_HasTypeInfo

#define SF_HasTypeInfo 0x0000080 /* FROM subqueries have Table metadata */

Definition at line 18478 of file sqlite3.c.

Referenced by selectAddSubqueryTypeInfo(), and sqlite3SelectPrep().

◆ SF_IncludeHidden

#define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */

Definition at line 18488 of file sqlite3.c.

Referenced by selectExpander(), sqlite3MaterializeView(), and updateFromSelect().

◆ SF_MaybeConvert

#define SF_MaybeConvert 0x0008000 /* Need convertCompoundSelectToSubquery() */

Definition at line 18486 of file sqlite3.c.

◆ SF_MinMaxAgg

#define SF_MinMaxAgg 0x0001000 /* Aggregate containing min() or max() */

Definition at line 18483 of file sqlite3.c.

◆ SF_MultiValue

#define SF_MultiValue 0x0000400 /* Single VALUES term with multiple rows */

Definition at line 18481 of file sqlite3.c.

Referenced by multiSelect(), multiSelectValues(), parserDoubleLinkSelect(), and yy_reduce().

◆ SF_NestedFrom

#define SF_NestedFrom 0x0000800 /* Part of a parenthesized FROM clause */

Definition at line 18482 of file sqlite3.c.

Referenced by lookupName(), selectExpander(), and yy_reduce().

◆ SF_NoopOrderBy

#define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */

Definition at line 18493 of file sqlite3.c.

Referenced by flattenSubquery(), and sqlite3Select().

◆ SF_Recursive

#define SF_Recursive 0x0002000 /* The recursive part of a recursive CTE */

Definition at line 18484 of file sqlite3.c.

Referenced by flattenSubquery(), multiSelect(), pushDownWhereTerms(), and withExpand().

◆ SF_Resolved

#define SF_Resolved 0x0000004 /* Identifiers have been resolved */

Definition at line 18473 of file sqlite3.c.

Referenced by selectAddSubqueryTypeInfo(), and sqlite3SelectAddColumnTypeAndCollation().

◆ SF_UpdateFrom

#define SF_UpdateFrom 0x0800000 /* Statement is an UPDATE...FROM */

Definition at line 18494 of file sqlite3.c.

Referenced by sqlite3Select(), and updateFromSelect().

◆ SF_UsesEphemeral

#define SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */

Definition at line 18476 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), and multiSelect().

◆ SF_Values

#define SF_Values 0x0000200 /* Synthesized from VALUES clause */

Definition at line 18480 of file sqlite3.c.

Referenced by multiSelectValues(), sqlite3Insert(), sqlite3SelectWrongNumTermsError(), and yy_reduce().

◆ SF_View

#define SF_View 0x0200000 /* SELECT statement is a view */

Definition at line 18492 of file sqlite3.c.

Referenced by renameColumnSelectCb(), and renameTableFunc().

◆ SF_WhereBegin

#define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */

Definition at line 18490 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ SF_WinRewrite

#define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */

Definition at line 18491 of file sqlite3.c.

Referenced by sqlite3WindowRewrite().

◆ SFUNCTION

#define SFUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

SQLITE_DIRECTONLY

#define SQLITE_DIRECTONLY

Definition sqlite3.c:6325

SQLITE_FUNC_UNSAFE

#define SQLITE_FUNC_UNSAFE

Definition sqlite3.c:17164

Definition at line 17245 of file sqlite3.c.

#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ SHARED_FIRST

#define SHARED_FIRST (PENDING_BYTE+2)

Definition at line 16426 of file sqlite3.c.

Referenced by posixUnlock(), unixFileLock(), and unixLock().

◆ SHARED_LOCK

#define SHARED_LOCK 1

Definition at line 16360 of file sqlite3.c.

Referenced by dotlockUnlock(), hasHotJournal(), pager_end_transaction(), pager_wait_on_lock(), pagerLockDb(), pagerOpenWal(), pagerOpenWalIfPresent(), pagerPagecount(), pagerUnlockDb(), posixUnlock(), sqlite3PagerCloseWal(), sqlite3PagerSetJournalMode(), sqlite3PagerSharedLock(), unixCheckReservedLock(), unixLock(), and unixUnlock().

◆ SHARED_SIZE

#define SHARED_SIZE 510

Definition at line 16427 of file sqlite3.c.

Referenced by posixUnlock(), unixFileLock(), and unixLock().

◆ SimulateDiskfullError

#define SimulateDiskfullError ( A )

Definition at line 33825 of file sqlite3.c.

Referenced by unixSync(), and unixWrite().

◆ SimulateIOError

#define SimulateIOError ( A )

Definition at line 33824 of file sqlite3.c.

Referenced by dotlockCheckReservedLock(), seekAndRead(), seekAndWriteFd(), unixAccess(), unixCheckReservedLock(), unixDelete(), unixFullPathname(), unixGetTempname(), unixSync(), and unixWrite().

◆ SimulateIOErrorBenign

#define SimulateIOErrorBenign ( X )

Definition at line 33823 of file sqlite3.c.

Referenced by unixWrite().

◆ SLOT_2_0

#define SLOT_2_0 0x001fc07f

Definition at line 32139 of file sqlite3.c.

Referenced by sqlite3GetVarint().

◆ SLOT_4_2_0

#define SLOT_4_2_0 0xf01fc07f

Definition at line 32140 of file sqlite3.c.

Referenced by sqlite3GetVarint(), and sqlite3GetVarint32().

◆ SMALLEST_INT64

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

Definition at line 14466 of file sqlite3.c.

Referenced by absFunc(), codeInteger(), doubleToInt64(), sqlite3_str_vappendf(), sqlite3Atoi64(), sqlite3Int64ToText(), sqlite3VdbeExec(), and valueFromExpr().

◆ SORTER_MAX_MERGE_COUNT

#define SORTER_MAX_MERGE_COUNT 16

Definition at line 94338 of file sqlite3.c.

Referenced by sqlite3VdbeSorterInit(), vdbeMergeEngineNew(), vdbeSorterAddToTree(), vdbeSorterMergeTreeBuild(), and vdbeSorterTreeDepth().

◆ SORTER_TYPE_INTEGER

#define SORTER_TYPE_INTEGER 0x01

Definition at line 94216 of file sqlite3.c.

Referenced by sqlite3VdbeSorterInit().

◆ SORTER_TYPE_TEXT

#define SORTER_TYPE_TEXT 0x02

Definition at line 94217 of file sqlite3.c.

Referenced by sqlite3VdbeSorterInit().

◆ SORTFLAG_UseSorter

#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */

Definition at line 129362 of file sqlite3.c.

Referenced by generateSortTail(), selectInnerLoop(), and sqlite3Select().

◆ SPILLFLAG_NOSYNC

#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */

Definition at line 52150 of file sqlite3.c.

Referenced by pagerStress(), and pagerWriteLargeSector().

◆ SPILLFLAG_OFF

#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */

Definition at line 52148 of file sqlite3.c.

Referenced by pagerStress(), and sqlite3PagerSetFlags().

◆ SPILLFLAG_ROLLBACK

#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */

Definition at line 52149 of file sqlite3.c.

Referenced by pager_playback_one_page(), and pagerStress().

◆ sqlite3_column_database_name

#define sqlite3_column_database_name 0

Definition at line 124261 of file sqlite3.c.

◆ sqlite3_column_database_name16

#define sqlite3_column_database_name16 0

Definition at line 124262 of file sqlite3.c.

◆ sqlite3_column_origin_name

#define sqlite3_column_origin_name 0

Definition at line 124265 of file sqlite3.c.

◆ sqlite3_column_origin_name16

#define sqlite3_column_origin_name16 0

Definition at line 124266 of file sqlite3.c.

◆ sqlite3_column_table_name

#define sqlite3_column_table_name 0

Definition at line 124263 of file sqlite3.c.

◆ sqlite3_column_table_name16

#define sqlite3_column_table_name16 0

Definition at line 124264 of file sqlite3.c.

◆ SQLITE3_H

#define SQLITE3_H

Definition at line 1082 of file sqlite3.c.

◆ SQLITE3_MUTEX_INITIALIZER

#define SQLITE3_MUTEX_INITIALIZER ( id ) { PTHREAD_MUTEX_INITIALIZER }

Definition at line 26281 of file sqlite3.c.

Referenced by pthreadMutexAlloc().

◆ SQLITE3_TEXT

#define SQLITE3_TEXT 3

Definition at line 5800 of file sqlite3.c.

◆ sqlite3CodecQueryParameters

#define sqlite3CodecQueryParameters	(	A,
		B,
		C ) 0

Definition at line 19552 of file sqlite3.c.

◆ sqlite3ColumnPropertiesFromName

#define sqlite3ColumnPropertiesFromName	(		T,
			C ) /* no-op */

Definition at line 19540 of file sqlite3.c.

Referenced by sqlite3AddColumn(), and sqlite3ColumnsFromExprList().

◆ sqlite3ConnectionBlocked

#define sqlite3ConnectionBlocked	(		x,
			y )

Definition at line 20268 of file sqlite3.c.

Referenced by querySharedCacheTableLock(), and sqlite3BtreeBeginTrans().

◆ sqlite3ConnectionClosed

#define sqlite3ConnectionClosed ( x )

Definition at line 20270 of file sqlite3.c.

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3ConnectionUnlocked

#define sqlite3ConnectionUnlocked ( x )

Definition at line 20269 of file sqlite3.c.

Referenced by sqlite3VdbeHalt().

◆ sqlite3ExplainBreakpoint

#define sqlite3ExplainBreakpoint	(		A,
			B ) /no-op/

Definition at line 15842 of file sqlite3.c.

Referenced by sqlite3VdbeExplain(), and sqlite3WhereExplainOneScan().

◆ SQLITE3EXT_H

#define SQLITE3EXT_H

Definition at line 123608 of file sqlite3.c.

◆ sqlite3FileSuffix3

#define sqlite3FileSuffix3	(		X,
			Y )

Definition at line 19926 of file sqlite3.c.

Referenced by sqlite3PagerOpen(), unixOpenSharedMemory(), and vdbeCommit().

◆ sqlite3GlobalConfig

#define sqlite3GlobalConfig sqlite3Config

◆ sqlite3Isalnum

#define sqlite3Isalnum ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)

Definition at line 19320 of file sqlite3.c.

Referenced by identPut().

◆ sqlite3Isalpha

#define sqlite3Isalpha ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)

Definition at line 19321 of file sqlite3.c.

Referenced by sqlite3LoadExtension().

◆ sqlite3Isdigit

#define sqlite3Isdigit ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)

Definition at line 19322 of file sqlite3.c.

Referenced by getDigits(), getSafetyLevel(), identPut(), parseHhMmSs(), parseModifier(), sqlite3AffinityType(), sqlite3AtoF(), sqlite3ColumnsFromExprList(), sqlite3GetInt32(), sqlite3GetToken(), sqlite3GetUInt32(), sqlite3VdbeExpandSql(), and yy_reduce().

◆ sqlite3IsNumericAffinity

#define sqlite3IsNumericAffinity ( X ) ((X)>=SQLITE_AFF_NUMERIC)

Definition at line 17401 of file sqlite3.c.

Referenced by sqlite3CompareAffinity(), sqlite3FindInIndex(), sqlite3IndexAffinityOk(), and termIsEquivalence().

◆ sqlite3Isquote

#define sqlite3Isquote ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)

Definition at line 19325 of file sqlite3.c.

Referenced by sqlite3AlterRenameColumn(), sqlite3Dequote(), sqlite3ExprAlloc(), sqlite3RunParser(), and tokenExpr().

◆ sqlite3Isspace

#define sqlite3Isspace ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)

Definition at line 19319 of file sqlite3.c.

Referenced by parseModifier(), parseTimezone(), parseYyyyMmDd(), sqlite3_exec(), sqlite3AlterFinishAddColumn(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3DbSpanDup(), and sqlite3GetToken().

◆ sqlite3IsToplevel

#define sqlite3IsToplevel ( p ) ((p)->pToplevel==0)

Definition at line 19788 of file sqlite3.c.

Referenced by sqlite3DeleteFrom().

◆ sqlite3Isxdigit

#define sqlite3Isxdigit ( x ) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)

Definition at line 19323 of file sqlite3.c.

Referenced by sqlite3DecOrHexToI64(), sqlite3GetInt32(), sqlite3GetToken(), and sqlite3ParseUri().

◆ sqlite3MemdebugHasType

#define sqlite3MemdebugHasType	(		X,
			Y ) 1

Definition at line 20328 of file sqlite3.c.

Referenced by lookasideMallocSize(), and sqlite3DbFreeNN().

◆ sqlite3MemdebugNoType

#define sqlite3MemdebugNoType	(		X,
			Y ) 1

Definition at line 20329 of file sqlite3.c.

◆ sqlite3MemdebugSetType

#define sqlite3MemdebugSetType	(		X,
			Y ) /* no-op */

Definition at line 20327 of file sqlite3.c.

Referenced by dbMallocRawFinish(), and pcache1Alloc().

◆ sqlite3MutexWarnOnContention

#define sqlite3MutexWarnOnContention ( x )

Definition at line 19428 of file sqlite3.c.

Referenced by openDatabase().

◆ sqlite3PagerWalDb

#define sqlite3PagerWalDb	(		x,
			y )

Definition at line 14943 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans().

◆ sqlite3PagerWalWriteLock

#define sqlite3PagerWalWriteLock	(		y,
			z ) SQLITE_OK

Definition at line 14942 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans().

◆ sqlite3Parser_ENGINEALWAYSONSTACK

#define sqlite3Parser_ENGINEALWAYSONSTACK 1

Definition at line 154262 of file sqlite3.c.

◆ sqlite3ParserARG_FETCH

#define sqlite3ParserARG_FETCH

Definition at line 154506 of file sqlite3.c.

Referenced by yy_destructor(), and yy_reduce().

◆ sqlite3ParserARG_PARAM

#define sqlite3ParserARG_PARAM

Definition at line 154505 of file sqlite3.c.

◆ sqlite3ParserARG_PDECL

#define sqlite3ParserARG_PDECL

Definition at line 154504 of file sqlite3.c.

◆ sqlite3ParserARG_SDECL

#define sqlite3ParserARG_SDECL

Definition at line 154503 of file sqlite3.c.

◆ sqlite3ParserARG_STORE

#define sqlite3ParserARG_STORE

Definition at line 154507 of file sqlite3.c.

Referenced by sqlite3Parser().

◆ sqlite3ParserCTX_FETCH

#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;

Definition at line 154511 of file sqlite3.c.

Referenced by sqlite3Parser(), and yy_destructor().

◆ sqlite3ParserCTX_PARAM

#define sqlite3ParserCTX_PARAM ,pParse

Definition at line 154510 of file sqlite3.c.

Referenced by sqlite3Parser().

◆ sqlite3ParserCTX_PDECL

#define sqlite3ParserCTX_PDECL ,Parse *pParse

Definition at line 154509 of file sqlite3.c.

◆ sqlite3ParserCTX_SDECL

#define sqlite3ParserCTX_SDECL Parse *pParse;

Definition at line 154508 of file sqlite3.c.

◆ sqlite3ParserCTX_STORE

#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;

Definition at line 154512 of file sqlite3.c.

Referenced by sqlite3ParserInit().

◆ sqlite3ParserTOKENTYPE

#define sqlite3ParserTOKENTYPE Token

Definition at line 154480 of file sqlite3.c.

◆ sqlite3ParseToplevel

#define sqlite3ParseToplevel ( p ) ((p)->pToplevel ? (p)->pToplevel : (p))

Definition at line 19787 of file sqlite3.c.

Referenced by autoIncBegin(), codeDeferredSeek(), flattenSubquery(), getRowTrigger(), isSetNullAction(), sqlite3BeginWriteOperation(), sqlite3CodeVerifySchema(), sqlite3MayAbort(), sqlite3MultiWrite(), sqlite3TableLock(), sqlite3VtabMakeWritable(), and sqlite3WhereExplainOneScan().

◆ sqlite3ResolveNotValid

#define sqlite3ResolveNotValid	(	P,
		N,
		M,
		X,
		E )

Value:

assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \

if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E);

NC_IsCheck

#define NC_IsCheck

Definition sqlite3.c:18375

notValidImpl

static void notValidImpl(Parse *pParse, NameContext *pNC, const char *zMsg, Expr *pExpr)

Definition sqlite3.c:98442

NC_PartIdx

#define NC_PartIdx

Definition sqlite3.c:18374

NC_IdxExpr

#define NC_IdxExpr

Definition sqlite3.c:18378

NC_GenCol

#define NC_GenCol

Definition sqlite3.c:18376

Definition at line 98459 of file sqlite3.c.

#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
#endif

Referenced by resolveExprStep().

◆ sqlite3SetMakeRecordP5

#define sqlite3SetMakeRecordP5	(		A,
			B )

Definition at line 19732 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ sqlite3StackAllocRaw

#define sqlite3StackAllocRaw	(		D,
			N ) sqlite3DbMallocRaw(D,N)

Definition at line 19385 of file sqlite3.c.

Referenced by balance_nonroot(), and sqlite3BitvecSet().

◆ sqlite3StackAllocZero

#define sqlite3StackAllocZero	(		D,
			N ) sqlite3DbMallocZero(D,N)

Definition at line 19386 of file sqlite3.c.

◆ sqlite3StackFree

#define sqlite3StackFree	(		D,
			P ) sqlite3DbFree(D,P)

Definition at line 19387 of file sqlite3.c.

Referenced by balance_nonroot(), and sqlite3BitvecSet().

◆ sqlite3Strlen30NN

#define sqlite3Strlen30NN ( C ) (strlen(C)&0x3fffffff)

Definition at line 19343 of file sqlite3.c.

Referenced by dupedExprNodeSize(), sqlite3TableAffinity(), and sqlite3VdbeMemStringify().

◆ sqlite3StrNICmp

#define sqlite3StrNICmp sqlite3_strnicmp

Definition at line 19345 of file sqlite3.c.

Referenced by getSafetyLevel(), isAlterableTable(), nocaseCollatingFunc(), sqlite3_compileoption_used(), sqlite3_complete(), sqlite3BeginTrigger(), sqlite3CheckObjectName(), sqlite3CreateIndex(), sqlite3FindTable(), sqlite3JoinType(), sqlite3MatchEName(), sqlite3Pragma(), and vtabCallConstructor().

◆ sqlite3Tolower

#define sqlite3Tolower ( x ) (sqlite3UpperToLower[(unsigned char)(x)])

Definition at line 19324 of file sqlite3.c.

Referenced by exprAnalyze(), patternCompare(), sqlite3Pragma(), and sqlite3RunParser().

◆ sqlite3Toupper

#define sqlite3Toupper ( x ) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))

Definition at line 19318 of file sqlite3.c.

Referenced by exprAnalyze(), patternCompare(), and sqlite3RunParser().

◆ sqlite3VdbeAssertAbortable

#define sqlite3VdbeAssertAbortable ( V )

Definition at line 21284 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeIncrWriteCounter

#define sqlite3VdbeIncrWriteCounter	(		V,
			C )

Definition at line 21283 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeIOTraceSql

#define sqlite3VdbeIOTraceSql ( X )

Definition at line 20291 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeReleaseRegisters

#define sqlite3VdbeReleaseRegisters	(	P,
		A,
		N,
		M,
		F )

Definition at line 15857 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), and sqlite3Insert().

◆ sqlite3VdbeScanStatus

#define sqlite3VdbeScanStatus	(	a,
		b,
		c,
		d,
		e )

Definition at line 16007 of file sqlite3.c.

◆ sqlite3VdbeVerifyAbortable

#define sqlite3VdbeVerifyAbortable	(		A,
			B )

Definition at line 15823 of file sqlite3.c.

Referenced by fkLookupParent(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3RefillIndex(), sqlite3UpsertDoUpdate(), and xferOptimization().

◆ sqlite3VdbeVerifyNoMallocRequired

#define sqlite3VdbeVerifyNoMallocRequired	(		A,
			B )

Definition at line 15817 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ sqlite3VdbeVerifyNoResultRow

#define sqlite3VdbeVerifyNoResultRow ( A )

Definition at line 15818 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ sqlite3VtabInSync

#define sqlite3VtabInSync ( db ) ((db)->nVTrans>0 && (db)->aVTrans==0)

Definition at line 20115 of file sqlite3.c.

Referenced by sqlite3VdbeHalt(), and sqlite3VtabBegin().

◆ sqlite3WalDb

#define sqlite3WalDb	(		pWal,
			db )

Definition at line 61228 of file sqlite3.c.

Referenced by sqlite3WalCheckpoint().

◆ sqlite3WhereAddScanStatus

#define sqlite3WhereAddScanStatus	(	a,
		b,
		c,
		d ) ((void)d)

Definition at line 141452 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ SQLITE_ABORT

#define SQLITE_ABORT 4 /* Callback routine requested an abort */

Definition at line 1474 of file sqlite3.c.

Referenced by db_exec_callback(), sqlite3_blob_reopen(), sqlite3_exec(), sqlite3_get_table(), sqlite3_vtab_on_conflict(), sqlite3BtreePutData(), sqlite3PagerRollback(), and sqlite3PagerSavepoint().

◆ SQLITE_ABORT_ROLLBACK

#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8))

Definition at line 1575 of file sqlite3.c.

Referenced by sqlite3BtreeRollback(), sqlite3ErrStr(), sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ SQLITE_ACCESS_EXISTS

#define SQLITE_ACCESS_EXISTS 0

Definition at line 2476 of file sqlite3.c.

Referenced by hasHotJournal(), pager_delsuper(), pager_playback(), pagerOpenWalIfPresent(), sqlite3PagerCloseWal(), sqlite3PagerSharedLock(), unixAccess(), and vdbeCommit().

◆ SQLITE_ACCESS_READ

#define SQLITE_ACCESS_READ 2 /* Unused */

Definition at line 2478 of file sqlite3.c.

◆ SQLITE_ACCESS_READWRITE

#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

Definition at line 2477 of file sqlite3.c.

Referenced by sqlite3Pragma(), and unixAccess().

◆ SQLITE_AFF_BLOB

#define SQLITE_AFF_BLOB 0x41 /* 'A' */

◆ SQLITE_AFF_INTEGER

#define SQLITE_AFF_INTEGER 0x44 /* 'D' */

Definition at line 17398 of file sqlite3.c.

Referenced by applyAffinity(), createTableStmt(), exprTableRegister(), lookupName(), resolveExprStep(), sqlite3AffinityType(), sqlite3IndexAffinityStr(), sqlite3VdbeExec(), and sqlite3VdbeMemCast().

◆ SQLITE_AFF_MASK

#define SQLITE_AFF_MASK 0x47

Definition at line 17407 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_AFF_NONE

#define SQLITE_AFF_NONE 0x40 /* '@' */

Definition at line 17394 of file sqlite3.c.

Referenced by codeApplyAffinity(), selectAddSubqueryTypeInfo(), sqlite3CodeRhsOfIN(), sqlite3CompareAffinity(), sqlite3ComputeGeneratedColumns(), sqlite3SelectAddColumnTypeAndCollation(), sqlite3VdbeExec(), sqlite3ViewGetColumnNames(), and sqlite3WindowRewrite().

◆ SQLITE_AFF_NUMERIC

#define SQLITE_AFF_NUMERIC 0x43 /* 'C' */

Definition at line 17397 of file sqlite3.c.

Referenced by applyAffinity(), createTableStmt(), sqlite3AffinityType(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3CompareAffinity(), sqlite3ExprNeedsNoAffinityChange(), sqlite3IndexAffinityStr(), sqlite3VdbeExec(), sqlite3VdbeMemCast(), valueFromExpr(), windowCheckValue(), and windowExprGtZero().

◆ SQLITE_AFF_REAL

#define SQLITE_AFF_REAL 0x45 /* 'E' */

Definition at line 17399 of file sqlite3.c.

Referenced by applyAffinity(), createTableStmt(), sqlite3AffinityType(), sqlite3CodeRhsOfIN(), sqlite3ColumnDefault(), sqlite3ExprCodeTarget(), sqlite3UpsertDoUpdate(), sqlite3VdbeExec(), and sqlite3VdbeMemCast().

◆ SQLITE_AFF_TEXT

#define SQLITE_AFF_TEXT 0x42 /* 'B' */

Definition at line 17396 of file sqlite3.c.

Referenced by analyzeOneTable(), applyAffinity(), createTableStmt(), isLikeOrGlob(), sqlite3AffinityType(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeTarget(), sqlite3ExprNeedsNoAffinityChange(), sqlite3FindInIndex(), sqlite3IndexAffinityOk(), sqlite3VdbeExec(), and sqlite3VdbeMemCast().

◆ SQLITE_AllOpts

#define SQLITE_AllOpts 0xffff /* All optimizations */

Definition at line 17058 of file sqlite3.c.

◆ SQLITE_ALLOW_COVERING_INDEX_SCAN

#define SQLITE_ALLOW_COVERING_INDEX_SCAN 1

Definition at line 20511 of file sqlite3.c.

◆ SQLITE_ALTER_TABLE

#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */

Definition at line 4145 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn(), and sqlite3AlterRenameColumn().

◆ SQLITE_AMALGAMATION

#define SQLITE_AMALGAMATION 1

Definition at line 21 of file sqlite3.c.

◆ SQLITE_ANALYZE

#define SQLITE_ANALYZE 28 /* Table Name NULL */

Definition at line 4147 of file sqlite3.c.

Referenced by analyzeOneTable().

◆ SQLITE_ANY

#define SQLITE_ANY 5 /* Deprecated */

Definition at line 6256 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_API

#define SQLITE_API

Definition at line 1100 of file sqlite3.c.

◆ SQLITE_APICALL

#define SQLITE_APICALL

Definition at line 1106 of file sqlite3.c.

◆ SQLITE_ASCII

#define SQLITE_ASCII 1

Definition at line 14281 of file sqlite3.c.

◆ SQLITE_ATTACH

#define SQLITE_ATTACH 24 /* Filename NULL */

Definition at line 4143 of file sqlite3.c.

Referenced by sqlite3Attach().

◆ SQLITE_AUTH

#define SQLITE_AUTH 23 /* Authorization denied */

Definition at line 1493 of file sqlite3.c.

Referenced by sqlite3AuthCheck(), and sqlite3AuthReadCol().

◆ SQLITE_AUTH_USER

#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8))

Definition at line 1590 of file sqlite3.c.

Referenced by attachFunc(), and sqlite3FinishCoding().

◆ SQLITE_AutoIndex

#define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */

Definition at line 16994 of file sqlite3.c.

Referenced by openDatabase(), and whereLoopAddBtree().

◆ SQLITE_BIG_DBL

#define SQLITE_BIG_DBL (1e99)

Definition at line 14161 of file sqlite3.c.

Referenced by whereLoopAddVirtualOne().

◆ SQLITE_BIGENDIAN

#define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)

Definition at line 14454 of file sqlite3.c.

Referenced by walDecodeFrame(), walEncodeFrame(), and walIndexRecover().

◆ SQLITE_BLDF1_INDEXED

#define SQLITE_BLDF1_INDEXED 0x0001 /* An index is used */

Definition at line 141334 of file sqlite3.c.

Referenced by whereLoopAddBtree(), and whereLoopAddBtreeIndex().

◆ SQLITE_BLDF1_UNIQUE

#define SQLITE_BLDF1_UNIQUE 0x0002 /* All keys of a UNIQUE index used */

Definition at line 141335 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex().

◆ SQLITE_BLDF2_2NDPASS

#define SQLITE_BLDF2_2NDPASS 0x0004 /* Second builder pass needed */

Definition at line 141337 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), and whereLoopAddBtreeIndex().

◆ SQLITE_BLOB

#define SQLITE_BLOB 4

Definition at line 5793 of file sqlite3.c.

Referenced by db_push_value(), instrFunc(), likeFunc(), quoteFunc(), substrFunc(), and vm_push_column().

◆ SQLITE_BTREE_H

#define SQLITE_BTREE_H

Definition at line 15014 of file sqlite3.c.

◆ SQLITE_BUSY

#define SQLITE_BUSY 5 /* The database file is locked */

◆ SQLITE_BUSY_RECOVERY

#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))

Definition at line 1557 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and walTryBeginRead().

◆ SQLITE_BUSY_SNAPSHOT

#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8))

Definition at line 1558 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), sqlite3VdbeExec(), and sqlite3WalBeginWriteTransaction().

◆ SQLITE_BUSY_TIMEOUT

#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<8))

Definition at line 1559 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), sqlite3WalCheckpoint(), unixShmSystemLock(), and walBusyLock().

◆ SQLITE_BYTEORDER

#define SQLITE_BYTEORDER 0

Definition at line 14437 of file sqlite3.c.

◆ SQLITE_CacheSpill

#define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */

Definition at line 16983 of file sqlite3.c.

Referenced by openDatabase(), setAllPagerFlags(), and sqlite3Pragma().

◆ SQLITE_CALLBACK

#define SQLITE_CALLBACK

Definition at line 1112 of file sqlite3.c.

◆ SQLITE_CANTOPEN

#define SQLITE_CANTOPEN 14 /* Unable to open the database file */

Definition at line 1484 of file sqlite3.c.

Referenced by hasHotJournal(), sqlite3PagerOpenWal(), sqlite3PagerRollback(), unixDelete(), and unixSync().

◆ SQLITE_CANTOPEN_BKPT

#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)

Definition at line 19269 of file sqlite3.c.

Referenced by openDirectory(), sqlite3PagerOpen(), sqlite3PagerSharedLock(), unixFullPathname(), unixOpen(), unixOpenSharedMemory(), walIndexReadHdr(), and walIndexRecover().

◆ SQLITE_CANTOPEN_CONVPATH

#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8))

Definition at line 1563 of file sqlite3.c.

◆ SQLITE_CANTOPEN_DIRTYWAL

#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */

Definition at line 1564 of file sqlite3.c.

◆ SQLITE_CANTOPEN_FULLPATH

#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8))

Definition at line 1562 of file sqlite3.c.

◆ SQLITE_CANTOPEN_ISDIR

#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8))

Definition at line 1561 of file sqlite3.c.

◆ SQLITE_CANTOPEN_NOTEMPDIR

#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))

Definition at line 1560 of file sqlite3.c.

◆ SQLITE_CANTOPEN_SYMLINK

#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8))

Definition at line 1565 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_CDECL

#define SQLITE_CDECL

Definition at line 1103 of file sqlite3.c.

◆ SQLITE_CellSizeCk

#define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */

Definition at line 17000 of file sqlite3.c.

Referenced by btreeInitPage(), openDatabase(), and sqlite3BtreeIntegrityCheck().

◆ SQLITE_CHECKPOINT_FULL

#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */

Definition at line 10137 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ SQLITE_CHECKPOINT_PASSIVE

#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */

Definition at line 10136 of file sqlite3.c.

Referenced by sqlite3_wal_checkpoint(), sqlite3PagerCheckpoint(), sqlite3Pragma(), sqlite3VdbeExec(), sqlite3WalCheckpoint(), and walCheckpoint().

◆ SQLITE_CHECKPOINT_RESTART

#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */

Definition at line 10138 of file sqlite3.c.

Referenced by sqlite3Pragma(), sqlite3VdbeExec(), and walCheckpoint().

◆ SQLITE_CHECKPOINT_TRUNCATE

#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */

Definition at line 10139 of file sqlite3.c.

Referenced by sqlite3Pragma(), sqlite3VdbeExec(), and walCheckpoint().

◆ SQLITE_CkptFullFSync

#define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */

Definition at line 16982 of file sqlite3.c.

Referenced by openDatabase(), and setAllPagerFlags().

◆ SQLITE_CONFIG_COVERING_INDEX_SCAN

#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

Definition at line 3097 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_GETMALLOC

#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

Definition at line 3082 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_GETMUTEX

#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

Definition at line 3088 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_GETPCACHE

#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */

Definition at line 3092 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_GETPCACHE2

#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

Definition at line 3096 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_HEAP

#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */

Definition at line 3085 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_LOG

#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */

Definition at line 3093 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_LOOKASIDE

#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */

Definition at line 3090 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_MALLOC

#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

Definition at line 3081 of file sqlite3.c.

Referenced by sqlite3_config(), and sqlite3MemSetDefault().

◆ SQLITE_CONFIG_MEMDB_MAXSIZE

#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */

Definition at line 3106 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_MEMSTATUS

#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

Definition at line 3086 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_MMAP_SIZE

#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

Definition at line 3099 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_MULTITHREAD

#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */

Definition at line 3079 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_MUTEX

#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

Definition at line 3087 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_PAGECACHE

#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */

Definition at line 3084 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_PCACHE

#define SQLITE_CONFIG_PCACHE 14 /* no-op */

Definition at line 3091 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_PCACHE2

#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

Definition at line 3095 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_PCACHE_HDRSZ

#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */

Definition at line 3101 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_PMASZ

#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

Definition at line 3102 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_SCRATCH

#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */

Definition at line 3083 of file sqlite3.c.

◆ SQLITE_CONFIG_SERIALIZED

#define SQLITE_CONFIG_SERIALIZED 3 /* nil */

Definition at line 3080 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_SINGLETHREAD

#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

Definition at line 3078 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_SMALL_MALLOC

#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */

Definition at line 3104 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_SORTERREF_SIZE

#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */

Definition at line 3105 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_SQLLOG

#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */

Definition at line 3098 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_STMTJRNL_SPILL

#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */

Definition at line 3103 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_URI

#define SQLITE_CONFIG_URI 17 /* int */

Definition at line 3094 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONFIG_WIN32_HEAPSIZE

#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

Definition at line 3100 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_CONSTRAINT

#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

Definition at line 1489 of file sqlite3.c.

Referenced by attachFunc(), sqlite3BtreeOpen(), sqlite3HaltConstraint(), sqlite3VdbeExec(), sqlite3VdbeHalt(), vtabBestIndex(), and whereLoopAddVirtualOne().

◆ SQLITE_CONSTRAINT_CHECK

#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8))

Definition at line 1576 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ SQLITE_CONSTRAINT_COMMITHOOK

#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8))

Definition at line 1577 of file sqlite3.c.

Referenced by vdbeCommit().

◆ SQLITE_CONSTRAINT_FOREIGNKEY

#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8))

Definition at line 1578 of file sqlite3.c.

Referenced by fkLookupParent(), sqlite3FkDropTable(), sqlite3VdbeCheckFk(), and sqlite3VdbeHalt().

◆ SQLITE_CONSTRAINT_FUNCTION

#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8))

Definition at line 1579 of file sqlite3.c.

◆ SQLITE_CONSTRAINT_NOTNULL

#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8))

Definition at line 1580 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks().

◆ SQLITE_CONSTRAINT_PINNED

#define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8))

Definition at line 1586 of file sqlite3.c.

Referenced by saveCursorPosition().

◆ SQLITE_CONSTRAINT_PRIMARYKEY

#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8))

Definition at line 1581 of file sqlite3.c.

◆ SQLITE_CONSTRAINT_ROWID

#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8))

Definition at line 1585 of file sqlite3.c.

◆ SQLITE_CONSTRAINT_TRIGGER

#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8))

Definition at line 1582 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget().

◆ SQLITE_CONSTRAINT_UNIQUE

#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8))

Definition at line 1583 of file sqlite3.c.

◆ SQLITE_CONSTRAINT_VTAB

#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8))

Definition at line 1584 of file sqlite3.c.

◆ SQLITE_COPY

#define SQLITE_COPY 0 /* No longer used */

Definition at line 4152 of file sqlite3.c.

◆ SQLITE_CORE

#define SQLITE_CORE 1

Definition at line 20 of file sqlite3.c.

◆ SQLITE_CORRUPT

#define SQLITE_CORRUPT 11 /* The database disk image is malformed */

Definition at line 1481 of file sqlite3.c.

Referenced by checkTreePage(), getAndInitPage(), sqlite3BtreeDelete(), sqlite3BtreeMovetoUnpacked(), sqlite3PagerRollback(), sqlite3Pragma(), and sqlite3UpsertDoUpdate().

◆ SQLITE_CORRUPT_BKPT

#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)

Definition at line 19267 of file sqlite3.c.

Referenced by accessPayload(), allocateBtreePage(), anotherValidCursor(), autoVacuumCommit(), balance_nonroot(), balance_quick(), btreeCreateTable(), btreeCursor(), btreeDropTable(), btreeGetUnusedPage(), btreeMoveto(), btreeNext(), corruptSchema(), dropCell(), editPage(), freePage2(), getAndInitPage(), getPageNormal(), incrVacuumStep(), lockBtree(), moveToChild(), moveToRoot(), pageInsertArray(), ptrmapGet(), ptrmapPut(), ptrmapPutOvflPtr(), rebuildPage(), relocatePage(), renameParseSql(), sqlite3BtreeDelete(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreeMovetoUnpacked(), sqlite3CreateIndex(), sqlite3PagerMovepage(), sqlite3VdbeExec(), sqlite3VdbeFinishMoveto(), sqlite3VdbeIdxKeyCompare(), sqlite3VdbeIdxRowid(), sqlite3VdbeMemFromBtree(), sqlite3VdbeRecordCompareWithSkip(), sqlite3WalCheckpoint(), sqlite3WalFindFrame(), vdbeRecordCompareString(), walCheckpoint(), and walIndexAppend().

◆ SQLITE_CORRUPT_INDEX

#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8))

Definition at line 1568 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_CORRUPT_PAGE

#define SQLITE_CORRUPT_PAGE ( pMemPage ) SQLITE_CORRUPT_PGNO(pMemPage->pgno)

Definition at line 64617 of file sqlite3.c.

Referenced by accessPayload(), allocateSpace(), btreeInitPage(), decodeFlags(), defragmentPage(), freeSpace(), modifyPagePointer(), moveToRoot(), pageFindSlot(), and sqlite3BtreeMovetoUnpacked().

◆ SQLITE_CORRUPT_PGNO

#define SQLITE_CORRUPT_PGNO ( P ) sqlite3CorruptError(__LINE__)

Definition at line 19283 of file sqlite3.c.

Referenced by allocateBtreePage(), getAndInitPage(), and ptrmapGet().

◆ SQLITE_CORRUPT_SEQUENCE

#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8))

Definition at line 1567 of file sqlite3.c.

Referenced by autoIncBegin().

◆ SQLITE_CORRUPT_VTAB

#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))

Definition at line 1566 of file sqlite3.c.

◆ SQLITE_CountOfView

#define SQLITE_CountOfView 0x0200 /* The count-of-view optimization */

Definition at line 17050 of file sqlite3.c.

Referenced by sqlite3Select().

◆ SQLITE_CountRows

#define SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */

Definition at line 17011 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Update(), sqlite3VdbeExec(), and xferOptimization().

◆ SQLITE_CoverIdxScan

#define SQLITE_CoverIdxScan 0x0020 /* Covering index scans */

Definition at line 17046 of file sqlite3.c.

Referenced by whereLoopAddBtree().

◆ SQLITE_CREATE_INDEX

#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */

Definition at line 4120 of file sqlite3.c.

Referenced by sqlite3CreateIndex().

◆ SQLITE_CREATE_TABLE

#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */

Definition at line 4121 of file sqlite3.c.

Referenced by sqlite3StartTable().

◆ SQLITE_CREATE_TEMP_INDEX

#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */

Definition at line 4122 of file sqlite3.c.

Referenced by sqlite3CreateIndex().

◆ SQLITE_CREATE_TEMP_TABLE

#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

Definition at line 4123 of file sqlite3.c.

Referenced by sqlite3StartTable().

◆ SQLITE_CREATE_TEMP_TRIGGER

#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */

Definition at line 4124 of file sqlite3.c.

Referenced by sqlite3BeginTrigger().

◆ SQLITE_CREATE_TEMP_VIEW

#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

Definition at line 4125 of file sqlite3.c.

Referenced by sqlite3StartTable().

◆ SQLITE_CREATE_TRIGGER

#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */

Definition at line 4126 of file sqlite3.c.

Referenced by sqlite3BeginTrigger().

◆ SQLITE_CREATE_VIEW

#define SQLITE_CREATE_VIEW 8 /* View Name NULL */

Definition at line 4127 of file sqlite3.c.

Referenced by sqlite3StartTable().

◆ SQLITE_CREATE_VTABLE

#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */

Definition at line 4148 of file sqlite3.c.

Referenced by sqlite3VtabBeginParse().

◆ SQLITE_CursorHints

#define SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */

Definition at line 17051 of file sqlite3.c.

◆ SQLITE_DBCONFIG_DEFENSIVE

#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */

Definition at line 3387 of file sqlite3.c.

◆ SQLITE_DBCONFIG_DQS_DDL

#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */

Definition at line 3391 of file sqlite3.c.

◆ SQLITE_DBCONFIG_DQS_DML

#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */

Definition at line 3390 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_FKEY

#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

Definition at line 3379 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER

#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */

Definition at line 3381 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION

#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */

Definition at line 3382 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_QPSG

#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */

Definition at line 3384 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_TRIGGER

#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

Definition at line 3380 of file sqlite3.c.

◆ SQLITE_DBCONFIG_ENABLE_VIEW

#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */

Definition at line 3392 of file sqlite3.c.

◆ SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */

Definition at line 3389 of file sqlite3.c.

◆ SQLITE_DBCONFIG_LEGACY_FILE_FORMAT

#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */

Definition at line 3393 of file sqlite3.c.

◆ SQLITE_DBCONFIG_LOOKASIDE

#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */

Definition at line 3378 of file sqlite3.c.

◆ SQLITE_DBCONFIG_MAINDBNAME

#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */

Definition at line 3377 of file sqlite3.c.

◆ SQLITE_DBCONFIG_MAX

#define SQLITE_DBCONFIG_MAX 1017 /* Largest DBCONFIG */

Definition at line 3395 of file sqlite3.c.

◆ SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE

#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */

Definition at line 3383 of file sqlite3.c.

◆ SQLITE_DBCONFIG_RESET_DATABASE

#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */

Definition at line 3386 of file sqlite3.c.

◆ SQLITE_DBCONFIG_TRIGGER_EQP

#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */

Definition at line 3385 of file sqlite3.c.

◆ SQLITE_DBCONFIG_TRUSTED_SCHEMA

#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */

Definition at line 3394 of file sqlite3.c.

◆ SQLITE_DBCONFIG_WRITABLE_SCHEMA

#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */

Definition at line 3388 of file sqlite3.c.

◆ SQLITE_DBSTATUS_CACHE_HIT

#define SQLITE_DBSTATUS_CACHE_HIT 7

Definition at line 9204 of file sqlite3.c.

Referenced by sqlite3PagerCacheStat().

◆ SQLITE_DBSTATUS_CACHE_MISS

#define SQLITE_DBSTATUS_CACHE_MISS 8

Definition at line 9205 of file sqlite3.c.

Referenced by sqlite3PagerCacheStat().

◆ SQLITE_DBSTATUS_CACHE_SPILL

#define SQLITE_DBSTATUS_CACHE_SPILL 12

Definition at line 9209 of file sqlite3.c.

◆ SQLITE_DBSTATUS_CACHE_USED

#define SQLITE_DBSTATUS_CACHE_USED 1

Definition at line 9198 of file sqlite3.c.

◆ SQLITE_DBSTATUS_CACHE_USED_SHARED

#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11

Definition at line 9208 of file sqlite3.c.

◆ SQLITE_DBSTATUS_CACHE_WRITE

#define SQLITE_DBSTATUS_CACHE_WRITE 9

Definition at line 9206 of file sqlite3.c.

Referenced by sqlite3PagerCacheStat().

◆ SQLITE_DBSTATUS_DEFERRED_FKS

#define SQLITE_DBSTATUS_DEFERRED_FKS 10

Definition at line 9207 of file sqlite3.c.

◆ SQLITE_DBSTATUS_LOOKASIDE_HIT

#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4

Definition at line 9201 of file sqlite3.c.

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

Definition at line 9203 of file sqlite3.c.

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

Definition at line 9202 of file sqlite3.c.

◆ SQLITE_DBSTATUS_LOOKASIDE_USED

#define SQLITE_DBSTATUS_LOOKASIDE_USED 0

Definition at line 9197 of file sqlite3.c.

◆ SQLITE_DBSTATUS_MAX

#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */

Definition at line 9210 of file sqlite3.c.

◆ SQLITE_DBSTATUS_SCHEMA_USED

#define SQLITE_DBSTATUS_SCHEMA_USED 2

Definition at line 9199 of file sqlite3.c.

◆ SQLITE_DBSTATUS_STMT_USED

#define SQLITE_DBSTATUS_STMT_USED 3

Definition at line 9200 of file sqlite3.c.

◆ SQLITE_DEFAULT_AUTOVACUUM

#define SQLITE_DEFAULT_AUTOVACUUM 0

Definition at line 15026 of file sqlite3.c.

Referenced by sqlite3BtreeOpen().

◆ SQLITE_DEFAULT_CACHE_SIZE

#define SQLITE_DEFAULT_CACHE_SIZE -2000

Definition at line 13347 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), sqlite3InitOne(), and sqlite3Pragma().

◆ SQLITE_DEFAULT_FILE_FORMAT

#define SQLITE_DEFAULT_FILE_FORMAT 4

Definition at line 14183 of file sqlite3.c.

◆ SQLITE_DEFAULT_FILE_PERMISSIONS

#define SQLITE_DEFAULT_FILE_PERMISSIONS 0644

Definition at line 33509 of file sqlite3.c.

Referenced by robust_open().

◆ SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT

#define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1

Definition at line 14776 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_DEFAULT_LOOKASIDE

#define SQLITE_DEFAULT_LOOKASIDE 1200,40 /* 48KB of memory */

Definition at line 20557 of file sqlite3.c.

◆ SQLITE_DEFAULT_MEMSTATUS

#define SQLITE_DEFAULT_MEMSTATUS 1

Definition at line 13589 of file sqlite3.c.

◆ SQLITE_DEFAULT_MMAP_SIZE

#define SQLITE_DEFAULT_MMAP_SIZE 0

Definition at line 14527 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_DEFAULT_PAGE_SIZE

#define SQLITE_DEFAULT_PAGE_SIZE 4096

Definition at line 13400 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_DEFAULT_PCACHE_INITSZ

#define SQLITE_DEFAULT_PCACHE_INITSZ 20

Definition at line 14232 of file sqlite3.c.

◆ SQLITE_DEFAULT_PROXYDIR_PERMISSIONS

#define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

Definition at line 33516 of file sqlite3.c.

◆ SQLITE_DEFAULT_RECURSIVE_TRIGGERS

#define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

Definition at line 14191 of file sqlite3.c.

◆ SQLITE_DEFAULT_SECTOR_SIZE

#define SQLITE_DEFAULT_SECTOR_SIZE 4096

Definition at line 16314 of file sqlite3.c.

Referenced by setDeviceCharacteristics(), and sqlite3OsDeviceCharacteristics().

◆ SQLITE_DEFAULT_SORTERREF_SIZE

#define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff

Definition at line 14239 of file sqlite3.c.

Referenced by sqlite3_config().

◆ SQLITE_DEFAULT_SYNCHRONOUS

#define SQLITE_DEFAULT_SYNCHRONOUS 2

Definition at line 16592 of file sqlite3.c.

Referenced by attachFunc(), lockBtree(), and openDatabase().

◆ SQLITE_DEFAULT_WAL_AUTOCHECKPOINT

#define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000

Definition at line 13355 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_DEFAULT_WAL_SYNCHRONOUS

#define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS

Definition at line 16595 of file sqlite3.c.

Referenced by lockBtree().

◆ SQLITE_DEFAULT_WORKER_THREADS

#define SQLITE_DEFAULT_WORKER_THREADS 0

Definition at line 14215 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_Defensive

#define SQLITE_Defensive 0x10000000 /* Input SQL is likely hostile */

Definition at line 17007 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3Pragma().

◆ SQLITE_DeferFKs

#define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */

Definition at line 16998 of file sqlite3.c.

Referenced by fkActionTrigger(), fkLookupParent(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3Pragma(), sqlite3RollbackAll(), sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ SQLITE_DELETE

#define SQLITE_DELETE 9 /* Table Name NULL */

Definition at line 4128 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), and sqlite3VdbeExec().

◆ SQLITE_DENY

#define SQLITE_DENY 1 /* Abort the SQL statement with an error */

Definition at line 4097 of file sqlite3.c.

Referenced by flattenSubquery(), resolveExprStep(), sqlite3AuthCheck(), sqlite3AuthReadCol(), sqlite3DeleteFrom(), and sqlite3Update().

◆ SQLITE_DEPRECATED

#define SQLITE_DEPRECATED

Definition at line 1131 of file sqlite3.c.

◆ SQLITE_DESERIALIZE_FREEONCLOSE

#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */

Definition at line 10848 of file sqlite3.c.

◆ SQLITE_DESERIALIZE_READONLY

#define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */

Definition at line 10850 of file sqlite3.c.

◆ SQLITE_DESERIALIZE_RESIZEABLE

#define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */

Definition at line 10849 of file sqlite3.c.

◆ SQLITE_DETACH

#define SQLITE_DETACH 25 /* Database Name NULL */

Definition at line 4144 of file sqlite3.c.

Referenced by sqlite3Detach().

◆ SQLITE_DETERMINISTIC

#define SQLITE_DETERMINISTIC 0x000000800

Definition at line 6324 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_DIRECTONLY

#define SQLITE_DIRECTONLY 0x000080000

Definition at line 6325 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_DistinctOpt

#define SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */

Definition at line 17045 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ SQLITE_DONE

#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */

◆ SQLITE_DQS

#define SQLITE_DQS 3

◆ SQLITE_DqsDDL

#define SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/

Definition at line 17008 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_DqsDML

#define SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/

Definition at line 17009 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_DROP_INDEX

#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */

Definition at line 4129 of file sqlite3.c.

◆ SQLITE_DROP_TABLE

#define SQLITE_DROP_TABLE 11 /* Table Name NULL */

Definition at line 4130 of file sqlite3.c.

◆ SQLITE_DROP_TEMP_INDEX

#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */

Definition at line 4131 of file sqlite3.c.

◆ SQLITE_DROP_TEMP_TABLE

#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

Definition at line 4132 of file sqlite3.c.

◆ SQLITE_DROP_TEMP_TRIGGER

#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */

Definition at line 4133 of file sqlite3.c.

◆ SQLITE_DROP_TEMP_VIEW

#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

Definition at line 4134 of file sqlite3.c.

◆ SQLITE_DROP_TRIGGER

#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */

Definition at line 4135 of file sqlite3.c.

◆ SQLITE_DROP_VIEW

#define SQLITE_DROP_VIEW 17 /* View Name NULL */

Definition at line 4136 of file sqlite3.c.

◆ SQLITE_DROP_VTABLE

#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */

Definition at line 4149 of file sqlite3.c.

◆ SQLITE_DYNAMIC

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3OomFault)

Definition at line 14609 of file sqlite3.c.

Referenced by generateColumnNames(), sqlite3ErrorWithMsg(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetStr(), sqlite3VdbeSetColName(), strftimeFunc(), valueFromExpr(), and vdbeMemClearExternAndSetNull().

◆ SQLITE_ECEL_DUP

#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */

Definition at line 19665 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3ExprCodeExprList(), sqlite3ExprCodeTarget(), and updateAccumulator().

◆ SQLITE_ECEL_FACTOR

#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */

Definition at line 19666 of file sqlite3.c.

Referenced by sqlite3ExprCodeExprList(), and sqlite3ExprCodeTarget().

◆ SQLITE_ECEL_OMITREF

#define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */

Definition at line 19668 of file sqlite3.c.

Referenced by selectInnerLoop(), and sqlite3ExprCodeExprList().

◆ SQLITE_ECEL_REF

#define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */

Definition at line 19667 of file sqlite3.c.

Referenced by selectInnerLoop(), and sqlite3ExprCodeExprList().

◆ SQLITE_EMPTY

#define SQLITE_EMPTY 16 /* Internal use only */

Definition at line 1486 of file sqlite3.c.

Referenced by moveToRoot(), sqlite3BtreeCount(), sqlite3BtreeDelete(), and sqlite3BtreeMovetoUnpacked().

◆ SQLITE_ENABLE_LOCKING_STYLE

#define SQLITE_ENABLE_LOCKING_STYLE 0

Definition at line 33414 of file sqlite3.c.

◆ SQLITE_EnableQPSG

#define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/

Definition at line 17002 of file sqlite3.c.

Referenced by isLikeOrGlob(), openDatabase(), sqlite3VdbeGetBoundValue(), and sqlite3VdbeSetVarmask().

◆ SQLITE_EnableTrigger

#define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */

Definition at line 16997 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3TriggersExist().

◆ SQLITE_EnableView

#define SQLITE_EnableView 0x80000000 /* Enable the use of views */

Definition at line 17010 of file sqlite3.c.

Referenced by openDatabase(), and selectExpander().

◆ SQLITE_ERROR

#define SQLITE_ERROR 1 /* Generic error */

Definition at line 1471 of file sqlite3.c.

Referenced by attachFunc(), blobSeekToRow(), changeTempStorage(), checkReadTransaction(), corruptSchema(), createFunctionApi(), findBtree(), invalidateTempStorage(), localtimeOffset(), renameResolveTrigger(), sqlite3_backup_init(), sqlite3_config(), sqlite3_declare_vtab(), sqlite3_get_table_cb(), sqlite3_result_error16(), sqlite3_result_int(), sqlite3_table_column_metadata(), sqlite3_transfer_bindings(), sqlite3CheckCollSeq(), sqlite3CheckObjectName(), sqlite3ErrorMsg(), sqlite3ExpandSubquery(), sqlite3ExprCheckHeight(), sqlite3ExprCodeTarget(), sqlite3FinishCoding(), sqlite3IndexedByLookup(), sqlite3InitOne(), sqlite3LoadExtension(), sqlite3ParseUri(), sqlite3ResolveExprNames(), sqlite3Step(), sqlite3UpsertAnalyzeTarget(), sqlite3VdbeChangeEncoding(), sqlite3VdbeCheckFk(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VdbeList(), sqlite3VdbeNextOpcode(), sqlite3VtabCallConnect(), sqlite3VtabCallCreate(), synthCollSeq(), unixFullPathname(), unixGetTempname(), vdbeSorterJoinThread(), vtabCallConstructor(), whereLoopAddVirtualOne(), wherePathSolver(), windowCheckValue(), and withExpand().

◆ SQLITE_ERROR_MISSING_COLLSEQ

#define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8))

Definition at line 1520 of file sqlite3.c.

Referenced by sqlite3GetCollSeq(), and sqlite3KeyInfoOfIndex().

◆ SQLITE_ERROR_RETRY

#define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8))

Definition at line 1521 of file sqlite3.c.

Referenced by sqlite3KeyInfoOfIndex().

◆ SQLITE_ERROR_SNAPSHOT

#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8))

Definition at line 1522 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction().

◆ SQLITE_EXPERIMENTAL

#define SQLITE_EXPERIMENTAL

Definition at line 1132 of file sqlite3.c.

◆ SQLITE_EXTENSION_INIT1

#define SQLITE_EXTENSION_INIT1 /*no-op*/

Definition at line 124243 of file sqlite3.c.

◆ SQLITE_EXTENSION_INIT2

#define SQLITE_EXTENSION_INIT2 ( v ) (void)v; /* unused parameter */

Definition at line 124244 of file sqlite3.c.

◆ SQLITE_EXTENSION_INIT3

#define SQLITE_EXTENSION_INIT3 /*no-op*/

Definition at line 124245 of file sqlite3.c.

◆ SQLITE_EXTERN

#define SQLITE_EXTERN extern

Definition at line 1097 of file sqlite3.c.

◆ SQLITE_FactorOutConst

#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */

Definition at line 17044 of file sqlite3.c.

◆ SQLITE_FAIL

#define SQLITE_FAIL 3

Definition at line 10287 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict().

◆ SQLITE_FAULTINJECTOR_COUNT

#define SQLITE_FAULTINJECTOR_COUNT 1

Definition at line 20210 of file sqlite3.c.

◆ SQLITE_FAULTINJECTOR_MALLOC

#define SQLITE_FAULTINJECTOR_MALLOC 0

Definition at line 20209 of file sqlite3.c.

◆ SQLITE_FCNTL_BEGIN_ATOMIC_WRITE

#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31

Definition at line 2208 of file sqlite3.c.

Referenced by sqlite3PagerCommitPhaseOne().

◆ SQLITE_FCNTL_BUSYHANDLER

#define SQLITE_FCNTL_BUSYHANDLER 15

Definition at line 2193 of file sqlite3.c.

Referenced by sqlite3PagerSetBusyHandler().

◆ SQLITE_FCNTL_CHUNK_SIZE

#define SQLITE_FCNTL_CHUNK_SIZE 6

Definition at line 2184 of file sqlite3.c.

◆ SQLITE_FCNTL_CKPT_DONE

#define SQLITE_FCNTL_CKPT_DONE 37

Definition at line 2214 of file sqlite3.c.

Referenced by walCheckpoint().

◆ SQLITE_FCNTL_CKPT_START

#define SQLITE_FCNTL_CKPT_START 39

Definition at line 2216 of file sqlite3.c.

Referenced by walCheckpoint().

◆ SQLITE_FCNTL_COMMIT_ATOMIC_WRITE

#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32

Definition at line 2209 of file sqlite3.c.

Referenced by sqlite3PagerCommitPhaseOne().

◆ SQLITE_FCNTL_COMMIT_PHASETWO

#define SQLITE_FCNTL_COMMIT_PHASETWO 22

Definition at line 2199 of file sqlite3.c.

Referenced by pager_end_transaction(), and sqlite3OsFileControl().

◆ SQLITE_FCNTL_DATA_VERSION

#define SQLITE_FCNTL_DATA_VERSION 35

Definition at line 2212 of file sqlite3.c.

◆ SQLITE_FCNTL_DB_UNCHANGED

#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0

Definition at line 16448 of file sqlite3.c.

Referenced by pager_playback().

◆ SQLITE_FCNTL_FILE_POINTER

#define SQLITE_FCNTL_FILE_POINTER 7

Definition at line 2185 of file sqlite3.c.

◆ SQLITE_FCNTL_GET_LOCKPROXYFILE

#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2

Definition at line 2180 of file sqlite3.c.

◆ SQLITE_FCNTL_HAS_MOVED

#define SQLITE_FCNTL_HAS_MOVED 20

Definition at line 2197 of file sqlite3.c.

Referenced by databaseIsUnmoved().

◆ SQLITE_FCNTL_JOURNAL_POINTER

#define SQLITE_FCNTL_JOURNAL_POINTER 28

Definition at line 2205 of file sqlite3.c.

◆ SQLITE_FCNTL_LAST_ERRNO

#define SQLITE_FCNTL_LAST_ERRNO 4

Definition at line 2182 of file sqlite3.c.

◆ SQLITE_FCNTL_LOCK_TIMEOUT

#define SQLITE_FCNTL_LOCK_TIMEOUT 34

Definition at line 2211 of file sqlite3.c.

Referenced by sqlite3OsFileControl().

◆ SQLITE_FCNTL_LOCKSTATE

#define SQLITE_FCNTL_LOCKSTATE 1

Definition at line 2179 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_FCNTL_MMAP_SIZE

#define SQLITE_FCNTL_MMAP_SIZE 18

Definition at line 2195 of file sqlite3.c.

Referenced by sqlite3Pragma(), and vdbeSorterOpenTempFile().

◆ SQLITE_FCNTL_OVERWRITE

#define SQLITE_FCNTL_OVERWRITE 11

Definition at line 2189 of file sqlite3.c.

Referenced by sqlite3BtreeCopyFile().

◆ SQLITE_FCNTL_PDB

#define SQLITE_FCNTL_PDB 30

Definition at line 2207 of file sqlite3.c.

Referenced by sqlite3BtreeOpen().

◆ SQLITE_FCNTL_PERSIST_WAL

#define SQLITE_FCNTL_PERSIST_WAL 10

Definition at line 2188 of file sqlite3.c.

◆ SQLITE_FCNTL_POWERSAFE_OVERWRITE

#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

Definition at line 2191 of file sqlite3.c.

◆ SQLITE_FCNTL_PRAGMA

#define SQLITE_FCNTL_PRAGMA 14

Definition at line 2192 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_FCNTL_RBU

#define SQLITE_FCNTL_RBU 26

Definition at line 2203 of file sqlite3.c.

◆ SQLITE_FCNTL_RESERVE_BYTES

#define SQLITE_FCNTL_RESERVE_BYTES 38

Definition at line 2215 of file sqlite3.c.

◆ SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE

#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33

Definition at line 2210 of file sqlite3.c.

Referenced by sqlite3PagerCommitPhaseOne().

◆ SQLITE_FCNTL_SET_LOCKPROXYFILE

#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3

Definition at line 2181 of file sqlite3.c.

◆ SQLITE_FCNTL_SIZE_HINT

#define SQLITE_FCNTL_SIZE_HINT 5

Definition at line 2183 of file sqlite3.c.

Referenced by pager_write_pagelist(), and walCheckpoint().

◆ SQLITE_FCNTL_SIZE_LIMIT

#define SQLITE_FCNTL_SIZE_LIMIT 36

Definition at line 2213 of file sqlite3.c.

◆ SQLITE_FCNTL_SYNC

#define SQLITE_FCNTL_SYNC 21

Definition at line 2198 of file sqlite3.c.

Referenced by sqlite3PagerSync().

◆ SQLITE_FCNTL_SYNC_OMITTED

#define SQLITE_FCNTL_SYNC_OMITTED 8

Definition at line 2186 of file sqlite3.c.

◆ SQLITE_FCNTL_TEMPFILENAME

#define SQLITE_FCNTL_TEMPFILENAME 16

Definition at line 2194 of file sqlite3.c.

◆ SQLITE_FCNTL_TRACE

#define SQLITE_FCNTL_TRACE 19

Definition at line 2196 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_FCNTL_VFS_POINTER

#define SQLITE_FCNTL_VFS_POINTER 27

Definition at line 2204 of file sqlite3.c.

◆ SQLITE_FCNTL_VFSNAME

#define SQLITE_FCNTL_VFSNAME 12

Definition at line 2190 of file sqlite3.c.

◆ SQLITE_FCNTL_WAL_BLOCK

#define SQLITE_FCNTL_WAL_BLOCK 24

Definition at line 2201 of file sqlite3.c.

◆ SQLITE_FCNTL_WIN32_AV_RETRY

#define SQLITE_FCNTL_WIN32_AV_RETRY 9

Definition at line 2187 of file sqlite3.c.

◆ SQLITE_FCNTL_WIN32_GET_HANDLE

#define SQLITE_FCNTL_WIN32_GET_HANDLE 29

Definition at line 2206 of file sqlite3.c.

◆ SQLITE_FCNTL_WIN32_SET_HANDLE

#define SQLITE_FCNTL_WIN32_SET_HANDLE 23

Definition at line 2200 of file sqlite3.c.

◆ SQLITE_FCNTL_ZIPVFS

#define SQLITE_FCNTL_ZIPVFS 25

Definition at line 2202 of file sqlite3.c.

◆ SQLITE_FILE_HEADER

#define SQLITE_FILE_HEADER "SQLite format 3"

Definition at line 63718 of file sqlite3.c.

◆ SQLITE_FLOAT

#define SQLITE_FLOAT 2

Definition at line 5792 of file sqlite3.c.

Referenced by db_push_value(), isDate(), quoteFunc(), and vm_push_column().

◆ SQLITE_ForeignKeys

#define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */

Definition at line 16993 of file sqlite3.c.

Referenced by openDatabase(), renameTableFunc(), sqlite3AlterFinishAddColumn(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3FkOldmask(), sqlite3FkRequired(), sqlite3GenerateConstraintChecks(), sqlite3Pragma(), and xferOptimization().

◆ SQLITE_FORMAT

#define SQLITE_FORMAT 24 /* Not used */

Definition at line 1494 of file sqlite3.c.

◆ SQLITE_FP_PRECISION_LIMIT

#define SQLITE_FP_PRECISION_LIMIT 100000000

Definition at line 28335 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ SQLITE_FRAME_MAGIC

#define SQLITE_FRAME_MAGIC 0x879fb71e

Definition at line 20891 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_FREE

#define SQLITE_FREE ( x ) free(x)

Definition at line 23624 of file sqlite3.c.

Referenced by sqlite3MemFree().

◆ SQLITE_FSFLAGS_IS_MSDOS

#define SQLITE_FSFLAGS_IS_MSDOS 0x1

Definition at line 33496 of file sqlite3.c.

Referenced by findInodeInfo(), and unixOpen().

◆ SQLITE_Fts3Tokenizer

#define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */

Definition at line 17001 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_FULL

#define SQLITE_FULL 13 /* Insertion failed because database is full */

Definition at line 1483 of file sqlite3.c.

Referenced by getPageNormal(), pager_error(), sqlite3PagerRollback(), sqlite3PcacheFetchStress(), sqlite3VdbeExec(), sqlite3VdbeHalt(), unixSync(), unixWrite(), and vdbeCommit().

◆ SQLITE_FullColNames

#define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */

Definition at line 16980 of file sqlite3.c.

Referenced by generateColumnNames(), and selectExpander().

◆ SQLITE_FullFSync

#define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */

Definition at line 16981 of file sqlite3.c.

Referenced by setAllPagerFlags().

◆ SQLITE_FUNC_CASE

#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */

Definition at line 17147 of file sqlite3.c.

Referenced by sqlite3IsLikeFunction(), sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterLikeFunctions().

◆ SQLITE_FUNC_CONSTANT

#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */

Definition at line 17155 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3CreateFunc().

◆ SQLITE_FUNC_COUNT

#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */

Definition at line 17152 of file sqlite3.c.

Referenced by isSimpleCount(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_DIRECT

#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */

Definition at line 17162 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3CreateFunc(), sqlite3ExprCodeTarget(), and sqlite3ExprFunctionUsable().

◆ SQLITE_FUNC_ENCMASK

#define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */

Definition at line 17145 of file sqlite3.c.

Referenced by matchQuality(), and sqlite3CreateFunc().

◆ SQLITE_FUNC_EPHEM

#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */

Definition at line 17148 of file sqlite3.c.

Referenced by freeEphemeralFunction(), and sqlite3VtabOverloadFunction().

◆ SQLITE_FUNC_HASH

#define SQLITE_FUNC_HASH	(		C,
			L ) (((C)+(L))%SQLITE_FUNC_HASH_SZ)

Definition at line 16763 of file sqlite3.c.

Referenced by sqlite3FindFunction().

◆ SQLITE_FUNC_HASH_SZ

#define SQLITE_FUNC_HASH_SZ 23

Definition at line 16759 of file sqlite3.c.

Referenced by sqlite3Pragma(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_INLINE

#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */

Definition at line 17165 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget().

◆ SQLITE_FUNC_INTERNAL

#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */

Definition at line 17161 of file sqlite3.c.

Referenced by resolveExprStep().

◆ SQLITE_FUNC_LENGTH

#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */

Definition at line 17150 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_LIKE

#define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */

Definition at line 17146 of file sqlite3.c.

Referenced by sqlite3IsLikeFunction(), sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterLikeFunctions().

◆ SQLITE_FUNC_MINMAX

#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */

Definition at line 17156 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3RegisterBuiltinFunctions(), sqlite3WindowCodeInit(), windowAggFinal(), windowAggStep(), and windowInitAccum().

◆ SQLITE_FUNC_NEEDCOLL

#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/

Definition at line 17149 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), sqlite3Select(), updateAccumulator(), and windowAggStep().

◆ SQLITE_FUNC_OFFSET

#define SQLITE_FUNC_OFFSET 0x8000 /* Built-in sqlite_offset() function */

Definition at line 17159 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_SLOCHNG

#define SQLITE_FUNC_SLOCHNG

Value:

0x2000 /* "Slow Change". Value constant during a

** single query - might change over time */

Definition at line 17157 of file sqlite3.c.

Referenced by resolveExprStep().

◆ SQLITE_FUNC_SUBTYPE

#define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */

Definition at line 17163 of file sqlite3.c.

Referenced by sqlite3WindowRewrite().

◆ SQLITE_FUNC_TEST

#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */

Definition at line 17158 of file sqlite3.c.

◆ SQLITE_FUNC_TYPEOF

#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */

Definition at line 17151 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_UNLIKELY

#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */

Definition at line 17154 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3RegisterBuiltinFunctions().

◆ SQLITE_FUNC_UNSAFE

#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */

Definition at line 17164 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3CreateFunc(), sqlite3ExprCodeTarget(), and sqlite3ExprFunctionUsable().

◆ SQLITE_FUNC_WINDOW

#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */

Definition at line 17160 of file sqlite3.c.

Referenced by resolveExprStep(), and sqlite3WindowUpdate().

◆ SQLITE_FUNCTION

#define SQLITE_FUNCTION 31 /* NULL Function Name */

Definition at line 4150 of file sqlite3.c.

Referenced by resolveExprStep().

◆ SQLITE_GET_LOCKPROXYFILE

#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

Definition at line 2219 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_GroupByOrder

#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */

Definition at line 17043 of file sqlite3.c.

Referenced by sqlite3Select().

◆ SQLITE_HASH_H

#define SQLITE_HASH_H

Definition at line 13857 of file sqlite3.c.

◆ SQLITE_IDXTYPE_APPDEF

#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */

Definition at line 17817 of file sqlite3.c.

Referenced by deleteTable(), sqlite3CreateIndex(), and yy_reduce().

◆ SQLITE_IDXTYPE_IPK

#define SQLITE_IDXTYPE_IPK 3 /* INTEGER PRIMARY KEY index */

Definition at line 17820 of file sqlite3.c.

Referenced by whereLoopAddBtree(), and whereLoopInsert().

◆ SQLITE_IDXTYPE_PRIMARYKEY

#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */

Definition at line 17819 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), isDupColumn(), sqlite3AddPrimaryKey(), sqlite3CreateIndex(), sqlite3GenerateConstraintChecks(), and xferOptimization().

◆ SQLITE_IDXTYPE_UNIQUE

#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */

Definition at line 17818 of file sqlite3.c.

Referenced by yy_reduce().

◆ SQLITE_IGNORE

#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */

Definition at line 4098 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict(), sqlite3AuthCheck(), sqlite3AuthRead(), sqlite3AuthReadCol(), sqlite3DeleteFrom(), sqlite3FkCheck(), and sqlite3Update().

◆ SQLITE_IgnoreChecks

#define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */

Definition at line 16988 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3Pragma().

◆ SQLITE_INDEX_CONSTRAINT_EQ

#define SQLITE_INDEX_CONSTRAINT_EQ 2

Definition at line 7947 of file sqlite3.c.

Referenced by allocateIndexInfo(), and pragmaVtabBestIndex().

◆ SQLITE_INDEX_CONSTRAINT_FUNCTION

#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150

Definition at line 7961 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_GE

#define SQLITE_INDEX_CONSTRAINT_GE 32

Definition at line 7951 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_GLOB

#define SQLITE_INDEX_CONSTRAINT_GLOB 66

Definition at line 7954 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_GT

#define SQLITE_INDEX_CONSTRAINT_GT 4

Definition at line 7948 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_IS

#define SQLITE_INDEX_CONSTRAINT_IS 72

Definition at line 7960 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_ISNOT

#define SQLITE_INDEX_CONSTRAINT_ISNOT 69

Definition at line 7957 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_ISNOTNULL

#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70

Definition at line 7958 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_ISNULL

#define SQLITE_INDEX_CONSTRAINT_ISNULL 71

Definition at line 7959 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_LE

#define SQLITE_INDEX_CONSTRAINT_LE 8

Definition at line 7949 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_LIKE

#define SQLITE_INDEX_CONSTRAINT_LIKE 65

Definition at line 7953 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_LT

#define SQLITE_INDEX_CONSTRAINT_LT 16

Definition at line 7950 of file sqlite3.c.

Referenced by allocateIndexInfo().

◆ SQLITE_INDEX_CONSTRAINT_MATCH

#define SQLITE_INDEX_CONSTRAINT_MATCH 64

Definition at line 7952 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_NE

#define SQLITE_INDEX_CONSTRAINT_NE 68

Definition at line 7956 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_CONSTRAINT_REGEXP

#define SQLITE_INDEX_CONSTRAINT_REGEXP 67

Definition at line 7955 of file sqlite3.c.

Referenced by isAuxiliaryVtabOperator().

◆ SQLITE_INDEX_SCAN_UNIQUE

#define SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */

Definition at line 7937 of file sqlite3.c.

Referenced by whereLoopAddVirtualOne().

◆ SQLITE_INNOCUOUS

#define SQLITE_INNOCUOUS 0x000200000

Definition at line 6327 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_INSERT

#define SQLITE_INSERT 18 /* Table Name NULL */

Definition at line 4137 of file sqlite3.c.

Referenced by sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3Insert(), sqlite3StartTable(), and sqlite3VdbeExec().

◆ SQLITE_INT_TO_PTR

#define SQLITE_INT_TO_PTR ( X ) ((void*)&((char*)0)[X])

Definition at line 13513 of file sqlite3.c.

Referenced by sqlite3_get_table(), sqlite3_wal_autocheckpoint(), sqlite3GenerateConstraintChecks(), sqlite3PagerOpen(), sqlite3WhereBegin(), vdbeIncrPopulateThread(), vdbePmaReaderBgIncrInit(), and vdbeSorterJoinThread().

◆ SQLITE_INTEGER

#define SQLITE_INTEGER 1

Definition at line 5791 of file sqlite3.c.

Referenced by absFunc(), db_push_value(), isDate(), quoteFunc(), statPush(), sumStep(), and vm_push_column().

◆ SQLITE_INTEGRITY_CHECK_ERROR_MAX

#define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100

◆ SQLITE_INTERNAL

#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

Definition at line 1472 of file sqlite3.c.

◆ SQLITE_INTERRUPT

#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

Definition at line 1479 of file sqlite3.c.

Referenced by sqlite3InitCallback(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VdbeList(), and walCheckpoint().

◆ SQLITE_IOCAP_ATOMIC

#define SQLITE_IOCAP_ATOMIC 0x00000001

Definition at line 1661 of file sqlite3.c.

Referenced by jrnlBufferSize(), and sqlite3PagerOpen().

◆ SQLITE_IOCAP_ATOMIC16K

#define SQLITE_IOCAP_ATOMIC16K 0x00000040

Definition at line 1667 of file sqlite3.c.

◆ SQLITE_IOCAP_ATOMIC1K

#define SQLITE_IOCAP_ATOMIC1K 0x00000004

Definition at line 1663 of file sqlite3.c.

◆ SQLITE_IOCAP_ATOMIC2K

#define SQLITE_IOCAP_ATOMIC2K 0x00000008

Definition at line 1664 of file sqlite3.c.

◆ SQLITE_IOCAP_ATOMIC32K

#define SQLITE_IOCAP_ATOMIC32K 0x00000080

Definition at line 1668 of file sqlite3.c.

◆ SQLITE_IOCAP_ATOMIC4K

#define SQLITE_IOCAP_ATOMIC4K 0x00000010

Definition at line 1665 of file sqlite3.c.

◆ SQLITE_IOCAP_ATOMIC512

#define SQLITE_IOCAP_ATOMIC512 0x00000002

Definition at line 1662 of file sqlite3.c.

Referenced by jrnlBufferSize(), and sqlite3PagerOpen().

◆ SQLITE_IOCAP_ATOMIC64K

#define SQLITE_IOCAP_ATOMIC64K 0x00000100

Definition at line 1669 of file sqlite3.c.

Referenced by jrnlBufferSize(), and sqlite3PagerOpen().

◆ SQLITE_IOCAP_ATOMIC8K

#define SQLITE_IOCAP_ATOMIC8K 0x00000020

Definition at line 1666 of file sqlite3.c.

◆ SQLITE_IOCAP_BATCH_ATOMIC

#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000

Definition at line 1675 of file sqlite3.c.

Referenced by jrnlBufferSize(), pager_end_transaction(), setDeviceCharacteristics(), and sqlite3PagerCommitPhaseOne().

◆ SQLITE_IOCAP_IMMUTABLE

#define SQLITE_IOCAP_IMMUTABLE 0x00002000

Definition at line 1674 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_IOCAP_POWERSAFE_OVERWRITE

#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

Definition at line 1673 of file sqlite3.c.

Referenced by setDeviceCharacteristics(), setSectorSize(), and sqlite3WalOpen().

◆ SQLITE_IOCAP_SAFE_APPEND

#define SQLITE_IOCAP_SAFE_APPEND 0x00000200

Definition at line 1670 of file sqlite3.c.

Referenced by syncJournal(), and writeJournalHdr().

◆ SQLITE_IOCAP_SEQUENTIAL

#define SQLITE_IOCAP_SEQUENTIAL 0x00000400

Definition at line 1671 of file sqlite3.c.

Referenced by sqlite3WalOpen(), syncJournal(), and vdbeCommit().

◆ SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN

#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

Definition at line 1672 of file sqlite3.c.

Referenced by hasHotJournal(), and pager_unlock().

◆ SQLITE_IOERR

#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

Definition at line 1480 of file sqlite3.c.

Referenced by btreeRestoreCursorPosition(), findInodeInfo(), pager_error(), sqlite3PagerCommitPhaseOne(), sqlite3PagerRollback(), sqlite3VdbeHalt(), sqlite3WalBeginReadTransaction(), unixGetTempname(), and walRestartLog().

◆ SQLITE_IOERR_ACCESS

#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))

Definition at line 1535 of file sqlite3.c.

Referenced by unixAccess(), unixOpen(), and vdbeSorterOpenTempFile().

◆ SQLITE_IOERR_AUTH

#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8))

Definition at line 1550 of file sqlite3.c.

◆ SQLITE_IOERR_BEGIN_ATOMIC

#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8))

Definition at line 1551 of file sqlite3.c.

◆ SQLITE_IOERR_BLOCKED

#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))

Definition at line 1533 of file sqlite3.c.

Referenced by sqlite3PagerCommitPhaseOne().

◆ SQLITE_IOERR_CHECKRESERVEDLOCK

#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

Definition at line 1536 of file sqlite3.c.

Referenced by dotlockCheckReservedLock(), sqliteErrorFromPosixError(), and unixCheckReservedLock().

◆ SQLITE_IOERR_CLOSE

#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))

Definition at line 1538 of file sqlite3.c.

Referenced by robust_close().

◆ SQLITE_IOERR_COMMIT_ATOMIC

#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8))

Definition at line 1552 of file sqlite3.c.

◆ SQLITE_IOERR_CONVPATH

#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8))

Definition at line 1548 of file sqlite3.c.

◆ SQLITE_IOERR_DATA

#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8))

Definition at line 1554 of file sqlite3.c.

◆ SQLITE_IOERR_DELETE

#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))

Definition at line 1532 of file sqlite3.c.

Referenced by unixDelete().

◆ SQLITE_IOERR_DELETE_NOENT

#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8))

Definition at line 1545 of file sqlite3.c.

Referenced by unixDelete().

◆ SQLITE_IOERR_DIR_CLOSE

#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))

Definition at line 1539 of file sqlite3.c.

◆ SQLITE_IOERR_DIR_FSYNC

#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))

Definition at line 1527 of file sqlite3.c.

Referenced by unixDelete().

◆ SQLITE_IOERR_FSTAT

#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))

Definition at line 1529 of file sqlite3.c.

Referenced by fcntlSizeHint(), and unixOpenSharedMemory().

◆ SQLITE_IOERR_FSYNC

#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))

Definition at line 1526 of file sqlite3.c.

Referenced by unixSync().

◆ SQLITE_IOERR_GETTEMPPATH

#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8))

Definition at line 1547 of file sqlite3.c.

Referenced by unixGetTempname().

◆ SQLITE_IOERR_LOCK

#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))

Definition at line 1537 of file sqlite3.c.

Referenced by dotlockLock(), sqliteErrorFromPosixError(), unixLock(), and unixLockSharedMemory().

◆ SQLITE_IOERR_MMAP

#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8))

Definition at line 1546 of file sqlite3.c.

◆ SQLITE_IOERR_NOMEM

#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))

Definition at line 1534 of file sqlite3.c.

Referenced by attachFunc(), checkPtrmap(), openDatabase(), schemaIsValid(), sqlite3ApiExit(), sqlite3InitOne(), sqlite3PagerCommitPhaseOne(), and sqlite3VdbeExec().

◆ SQLITE_IOERR_NOMEM_BKPT

#define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM

Definition at line 19277 of file sqlite3.c.

Referenced by unixShmMap().

◆ SQLITE_IOERR_RDLOCK

#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))

Definition at line 1531 of file sqlite3.c.

Referenced by posixUnlock(), and sqliteErrorFromPosixError().

◆ SQLITE_IOERR_READ

#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))

Definition at line 1523 of file sqlite3.c.

Referenced by unixRead(), and vdbePmaReaderSeek().

◆ SQLITE_IOERR_ROLLBACK_ATOMIC

#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8))

Definition at line 1553 of file sqlite3.c.

◆ SQLITE_IOERR_SEEK

#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))

Definition at line 1544 of file sqlite3.c.

◆ SQLITE_IOERR_SHMLOCK

#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))

Definition at line 1542 of file sqlite3.c.

◆ SQLITE_IOERR_SHMMAP

#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))

Definition at line 1543 of file sqlite3.c.

Referenced by unixShmMap().

◆ SQLITE_IOERR_SHMOPEN

#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))

Definition at line 1540 of file sqlite3.c.

Referenced by unixLockSharedMemory().

◆ SQLITE_IOERR_SHMSIZE

#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))

Definition at line 1541 of file sqlite3.c.

Referenced by unixShmMap().

◆ SQLITE_IOERR_SHORT_READ

#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))

Definition at line 1524 of file sqlite3.c.

Referenced by hasHotJournal(), pager_playback(), readDbPage(), sqlite3PagerReadFileheader(), sqlite3PagerSharedLock(), syncJournal(), unixRead(), vdbePmaReadBlob(), and walIndexReadHdr().

◆ SQLITE_IOERR_TRUNCATE

#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))

Definition at line 1528 of file sqlite3.c.

Referenced by fcntlSizeHint().

◆ SQLITE_IOERR_UNLOCK

#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))

Definition at line 1530 of file sqlite3.c.

Referenced by dotlockUnlock(), posixUnlock(), sqliteErrorFromPosixError(), and unixLock().

◆ SQLITE_IOERR_VNODE

#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8))

Definition at line 1549 of file sqlite3.c.

◆ SQLITE_IOERR_WRITE

#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))

Definition at line 1525 of file sqlite3.c.

Referenced by fcntlSizeHint(), and unixWrite().

◆ SQLITE_JUMPIFNULL

#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */

Definition at line 17419 of file sqlite3.c.

Referenced by constructAutomaticIndex(), fkLookupParent(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3GenerateIndexKey(), sqlite3Pragma(), sqlite3Select(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WhereBegin(), updateAccumulator(), and windowCheckValue().

◆ SQLITE_KEEPNULL

#define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */

Definition at line 17418 of file sqlite3.c.

Referenced by codeVectorCompare(), and sqlite3VdbeExec().

◆ SQLITE_LAST_ERRNO

#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

Definition at line 2221 of file sqlite3.c.

◆ SQLITE_LegacyAlter

#define SQLITE_LegacyAlter 0x04000000 /* Legacy ALTER TABLE behaviour */

Definition at line 17005 of file sqlite3.c.

Referenced by openDatabase(), renameTableFunc(), renameTableTest(), and sqlite3VdbeExec().

◆ SQLITE_LegacyFileFmt

#define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */

Definition at line 16979 of file sqlite3.c.

Referenced by openDatabase(), sqlite3InitOne(), and sqlite3StartTable().

◆ SQLITE_LIMIT_ATTACHED

#define SQLITE_LIMIT_ATTACHED 7

Definition at line 4951 of file sqlite3.c.

Referenced by attachFunc(), and sqlite3_limit().

◆ SQLITE_LIMIT_COLUMN

#define SQLITE_LIMIT_COLUMN 2

Definition at line 4946 of file sqlite3.c.

Referenced by addModuleArgument(), resolveCompoundOrderBy(), selectExpander(), sqlite3_limit(), sqlite3AddColumn(), and sqlite3ResolveOrderGroupBy().

◆ SQLITE_LIMIT_COMPOUND_SELECT

#define SQLITE_LIMIT_COMPOUND_SELECT 4

Definition at line 4948 of file sqlite3.c.

Referenced by parserDoubleLinkSelect(), and sqlite3_limit().

◆ SQLITE_LIMIT_EXPR_DEPTH

#define SQLITE_LIMIT_EXPR_DEPTH 3

Definition at line 4947 of file sqlite3.c.

Referenced by sqlite3_limit(), and sqlite3ExprCheckHeight().

◆ SQLITE_LIMIT_FUNCTION_ARG

#define SQLITE_LIMIT_FUNCTION_ARG 6

Definition at line 4950 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_LIMIT_LENGTH

#define SQLITE_LIMIT_LENGTH 0

Definition at line 4944 of file sqlite3.c.

Referenced by contextMalloc(), replaceFunc(), sqlite3_limit(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeMemSetStr(), strftimeFunc(), and substrFunc().

◆ SQLITE_LIMIT_LIKE_PATTERN_LENGTH

#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

Definition at line 4952 of file sqlite3.c.

Referenced by likeFunc(), and sqlite3_limit().

◆ SQLITE_LIMIT_SQL_LENGTH

#define SQLITE_LIMIT_SQL_LENGTH 1

Definition at line 4945 of file sqlite3.c.

Referenced by sqlite3_limit(), and sqlite3RunParser().

◆ SQLITE_LIMIT_TRIGGER_DEPTH

#define SQLITE_LIMIT_TRIGGER_DEPTH 10

Definition at line 4954 of file sqlite3.c.

Referenced by sqlite3_limit(), and sqlite3VdbeExec().

◆ SQLITE_LIMIT_VARIABLE_NUMBER

#define SQLITE_LIMIT_VARIABLE_NUMBER 9

Definition at line 4953 of file sqlite3.c.

Referenced by sqlite3_limit(), and sqlite3ExprAssignVarNumber().

◆ SQLITE_LIMIT_VDBE_OP

#define SQLITE_LIMIT_VDBE_OP 5

Definition at line 4949 of file sqlite3.c.

Referenced by growOpArray(), and sqlite3_limit().

◆ SQLITE_LIMIT_WORKER_THREADS

#define SQLITE_LIMIT_WORKER_THREADS 11

Definition at line 4955 of file sqlite3.c.

Referenced by openDatabase(), sqlite3_limit(), sqlite3Pragma(), and sqlite3VdbeSorterInit().

◆ SQLITE_LITTLEENDIAN

#define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

Definition at line 14455 of file sqlite3.c.

◆ SQLITE_LoadExtension

#define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */

Definition at line 16995 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3LoadExtension().

◆ SQLITE_LoadExtFunc

#define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */

Definition at line 16996 of file sqlite3.c.

Referenced by loadExt().

◆ SQLITE_LOCK_EXCLUSIVE

#define SQLITE_LOCK_EXCLUSIVE 4

Definition at line 1688 of file sqlite3.c.

◆ SQLITE_LOCK_NONE

#define SQLITE_LOCK_NONE 0

Definition at line 1684 of file sqlite3.c.

◆ SQLITE_LOCK_PENDING

#define SQLITE_LOCK_PENDING 3

Definition at line 1687 of file sqlite3.c.

◆ SQLITE_LOCK_RESERVED

#define SQLITE_LOCK_RESERVED 2

Definition at line 1686 of file sqlite3.c.

◆ SQLITE_LOCK_SHARED

#define SQLITE_LOCK_SHARED 1

Definition at line 1685 of file sqlite3.c.

◆ SQLITE_LOCKED

#define SQLITE_LOCKED 6 /* A table in the database is locked */

Definition at line 1476 of file sqlite3.c.

Referenced by backupUpdate(), isFatalError(), sqlite3BtreeCheckpoint(), sqlite3InitCallback(), sqlite3Step(), sqlite3VdbeExec(), sqlite3VtabBegin(), sqlite3VtabCallDestroy(), and vtabCallConstructor().

◆ SQLITE_LOCKED_SHAREDCACHE

#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))

Definition at line 1555 of file sqlite3.c.

Referenced by querySharedCacheTableLock(), sqlite3BtreeBeginTrans(), and sqlite3BtreeSchemaLocked().

◆ SQLITE_LOCKED_VTAB

#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8))

Definition at line 1556 of file sqlite3.c.

◆ SQLITE_MAGIC_BUSY

#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */

Definition at line 17080 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_MAGIC_CLOSED

#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */

Definition at line 17078 of file sqlite3.c.

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ SQLITE_MAGIC_ERROR

#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */

Definition at line 17081 of file sqlite3.c.

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ SQLITE_MAGIC_OPEN

#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */

Definition at line 17077 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3SafetyCheckOk().

◆ SQLITE_MAGIC_SICK

#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */

Definition at line 17079 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_MAGIC_ZOMBIE

#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */

Definition at line 17082 of file sqlite3.c.

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ SQLITE_MALLOC

#define SQLITE_MALLOC ( x ) malloc(x)

Definition at line 23623 of file sqlite3.c.

Referenced by sqlite3MemMalloc().

◆ SQLITE_MALLOC_SOFT_LIMIT

#define SQLITE_MALLOC_SOFT_LIMIT 1024

Definition at line 13630 of file sqlite3.c.

Referenced by rehash().

◆ SQLITE_MATCH

#define SQLITE_MATCH 0

Definition at line 117682 of file sqlite3.c.

Referenced by likeFunc(), and patternCompare().

◆ SQLITE_MAX_ATTACHED

#define SQLITE_MAX_ATTACHED 10

Definition at line 13365 of file sqlite3.c.

Referenced by sqlite3_limit(), sqlite3Checkpoint(), sqlite3CodeVerifySchema(), sqlite3FindInIndex(), and sqlite3Pragma().

◆ SQLITE_MAX_COLUMN

#define SQLITE_MAX_COLUMN 2000

Definition at line 13282 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_COMPOUND_SELECT

#define SQLITE_MAX_COMPOUND_SELECT 500

Definition at line 13319 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_DEFAULT_PAGE_SIZE

#define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192

Definition at line 13415 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_MAX_EXPR_DEPTH

#define SQLITE_MAX_EXPR_DEPTH 1000

Definition at line 13307 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_FILE_FORMAT

#define SQLITE_MAX_FILE_FORMAT 4

Definition at line 14181 of file sqlite3.c.

Referenced by sqlite3InitOne(), and sqlite3StartTable().

◆ SQLITE_MAX_FUNCTION_ARG

#define SQLITE_MAX_FUNCTION_ARG 127

Definition at line 13334 of file sqlite3.c.

Referenced by sqlite3_limit(), and sqlite3CreateFunc().

◆ SQLITE_MAX_LENGTH

#define SQLITE_MAX_LENGTH 1000000000

Definition at line 13261 of file sqlite3.c.

Referenced by replaceFunc(), sqlite3_limit(), sqlite3BtreeIntegrityCheck(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeMemSetStr(), and sqlite3WhereExplainOneScan().

◆ SQLITE_MAX_LIKE_PATTERN_LENGTH

#define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

Definition at line 13439 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_MEMORY

#define SQLITE_MAX_MEMORY 0

Definition at line 27351 of file sqlite3.c.

◆ SQLITE_MAX_MMAP_SIZE

#define SQLITE_MAX_MMAP_SIZE 0

Definition at line 14517 of file sqlite3.c.

Referenced by sqlite3_config(), and vdbeSorterOpenTempFile().

◆ SQLITE_MAX_PAGE_COUNT

#define SQLITE_MAX_PAGE_COUNT 1073741823

Definition at line 13431 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_MAX_PAGE_SIZE

#define SQLITE_MAX_PAGE_SIZE 65536

Definition at line 13393 of file sqlite3.c.

Referenced by defragmentPage(), lockBtree(), readJournalHdr(), sqlite3BtreeOpen(), sqlite3BtreeSetPageSize(), sqlite3PagerSetPagesize(), and walIndexRecover().

◆ SQLITE_MAX_PMASZ

#define SQLITE_MAX_PMASZ (1<<29)

Definition at line 94033 of file sqlite3.c.

Referenced by sqlite3VdbeSorterInit().

◆ SQLITE_MAX_SCHEMA_RETRY

#define SQLITE_MAX_SCHEMA_RETRY 50

Definition at line 20730 of file sqlite3.c.

Referenced by sqlite3_step().

◆ SQLITE_MAX_SQL_LENGTH

#define SQLITE_MAX_SQL_LENGTH 1000000000

Definition at line 13293 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_SRCLIST

#define SQLITE_MAX_SRCLIST 200

Definition at line 114677 of file sqlite3.c.

Referenced by sqlite3SrcListEnlarge().

◆ SQLITE_MAX_SYMLINKS

#define SQLITE_MAX_SYMLINKS 100

Definition at line 33527 of file sqlite3.c.

Referenced by unixFullPathname().

◆ SQLITE_MAX_TRIGGER_DEPTH

#define SQLITE_MAX_TRIGGER_DEPTH 1000

Definition at line 13450 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_U32

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

Definition at line 14343 of file sqlite3.c.

Referenced by sqlite3GetVarint32(), and sqlite3VdbeIdxRowid().

◆ SQLITE_MAX_VARIABLE_NUMBER

#define SQLITE_MAX_VARIABLE_NUMBER 32766

Definition at line 13376 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_VDBE_OP

#define SQLITE_MAX_VDBE_OP 250000000

Definition at line 13327 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_MAX_WORKER_THREADS

#define SQLITE_MAX_WORKER_THREADS 8

Definition at line 14212 of file sqlite3.c.

Referenced by sqlite3_limit(), vdbeMergeEngineInit(), vdbePmaReaderIncrMergeInit(), and vdbeSorterMergeTreeBuild().

◆ SQLITE_MEMDB_DEFAULT_MAXSIZE

#define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824

Definition at line 20566 of file sqlite3.c.

◆ SQLITE_MINIMUM_FILE_DESCRIPTOR

#define SQLITE_MINIMUM_FILE_DESCRIPTOR 3

Definition at line 34196 of file sqlite3.c.

Referenced by robust_open().

◆ SQLITE_MISMATCH

#define SQLITE_MISMATCH 20 /* Data type mismatch */

Definition at line 1490 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_MISUSE

#define SQLITE_MISUSE 21 /* Library used incorrectly */

Definition at line 1491 of file sqlite3.c.

Referenced by dbvm_bind_index(), logBadConnection(), sqlite3_declare_vtab(), sqlite3Step(), and vdbeUnbind().

◆ SQLITE_MISUSE_BKPT

#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)

Definition at line 19268 of file sqlite3.c.

Referenced by columnName(), createFunctionApi(), openDatabase(), pthreadMutexAlloc(), pthreadMutexFree(), sqlite3_backup_init(), sqlite3_bind_blob64(), sqlite3_blob_reopen(), sqlite3_busy_timeout(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_compileoption_used(), sqlite3_complete(), sqlite3_config(), sqlite3_declare_vtab(), sqlite3_errcode(), sqlite3_exec(), sqlite3_finalize(), sqlite3_get_autocommit(), sqlite3_get_table(), sqlite3_limit(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_set_authorizer(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vfs_register(), sqlite3_vsnprintf(), sqlite3_vtab_config(), sqlite3_vtab_on_conflict(), sqlite3_wal_autocheckpoint(), sqlite3CreateFunc(), sqlite3Prepare16(), sqlite3Step(), and vdbeUnbind().

◆ SQLITE_MSVC_H

#define SQLITE_MSVC_H

Definition at line 866 of file sqlite3.c.

◆ SQLITE_MUTEX_FAST

#define SQLITE_MUTEX_FAST 0

Definition at line 8629 of file sqlite3.c.

Referenced by findInodeInfo(), pthreadMutexAlloc(), pthreadMutexFree(), sqlite3BtreeOpen(), and unixOpenSharedMemory().

◆ SQLITE_MUTEX_NREF

#define SQLITE_MUTEX_NREF 0

Definition at line 26258 of file sqlite3.c.

◆ SQLITE_MUTEX_PTHREADS

#define SQLITE_MUTEX_PTHREADS

Definition at line 16536 of file sqlite3.c.

◆ SQLITE_MUTEX_RECURSIVE

#define SQLITE_MUTEX_RECURSIVE 1

Definition at line 8630 of file sqlite3.c.

Referenced by openDatabase(), pthreadMutexAlloc(), pthreadMutexEnter(), pthreadMutexFree(), pthreadMutexLeave(), and sqlite3_initialize().

◆ SQLITE_MUTEX_STATIC_APP1

#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */

Definition at line 8639 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_APP2

#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */

Definition at line 8640 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_APP3

#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */

Definition at line 8641 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_LRU

#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

Definition at line 8636 of file sqlite3.c.

Referenced by pcache1Init().

◆ SQLITE_MUTEX_STATIC_LRU2

#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

Definition at line 8637 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_MAIN

#define SQLITE_MUTEX_STATIC_MAIN 2

Definition at line 8631 of file sqlite3.c.

Referenced by osLocaltime(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_cancel_auto_extension(), sqlite3_initialize(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3AutoLoadExtensions(), and sqlite3BtreeOpen().

◆ SQLITE_MUTEX_STATIC_MASTER

#define SQLITE_MUTEX_STATIC_MASTER 2

Definition at line 8647 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_MEM

#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

Definition at line 8632 of file sqlite3.c.

Referenced by sqlite3MallocInit().

◆ SQLITE_MUTEX_STATIC_MEM2

#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

Definition at line 8633 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_OPEN

#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

Definition at line 8634 of file sqlite3.c.

Referenced by sqlite3BtreeOpen().

◆ SQLITE_MUTEX_STATIC_PMEM

#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

Definition at line 8638 of file sqlite3.c.

Referenced by pcache1Init().

◆ SQLITE_MUTEX_STATIC_PRNG

#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */

Definition at line 8635 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_VFS1

#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */

Definition at line 8642 of file sqlite3.c.

Referenced by sqlite3_os_init().

◆ SQLITE_MUTEX_STATIC_VFS2

#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */

Definition at line 8643 of file sqlite3.c.

◆ SQLITE_MUTEX_STATIC_VFS3

#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */

Definition at line 8644 of file sqlite3.c.

◆ SQLITE_MX_JUMP_OPCODE

#define SQLITE_MX_JUMP_OPCODE 62 /* Maximum JUMP opcode */

Definition at line 15784 of file sqlite3.c.

Referenced by resolveP2Values().

◆ SQLITE_N_BTREE_META

#define SQLITE_N_BTREE_META 16

Definition at line 15019 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_N_KEYWORD

#define SQLITE_N_KEYWORD 145

Definition at line 159870 of file sqlite3.c.

◆ SQLITE_N_LIMIT

#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)

Definition at line 16671 of file sqlite3.c.

Referenced by sqlite3_limit().

◆ SQLITE_NO_TSAN

#define SQLITE_NO_TSAN

Definition at line 60111 of file sqlite3.c.

◆ SQLITE_NoCkptOnClose

#define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */

Definition at line 16990 of file sqlite3.c.

Referenced by sqlite3PagerClose().

◆ SQLITE_NOINLINE

#define SQLITE_NOINLINE

Definition at line 13529 of file sqlite3.c.

◆ SQLITE_NOLFS

#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */

Definition at line 1492 of file sqlite3.c.

Referenced by findInodeInfo().

◆ SQLITE_NOMATCH

#define SQLITE_NOMATCH 1

Definition at line 117683 of file sqlite3.c.

Referenced by patternCompare().

◆ SQLITE_NOMEM

#define SQLITE_NOMEM 7 /* A malloc() failed */

Definition at line 1477 of file sqlite3.c.

Referenced by addToSavepointBitvecs(), attachFunc(), checkPtrmap(), getPageNormal(), growOpArray(), openDatabase(), printfTempBuf(), renameColumnFunc(), renameEditSql(), renameParseSql(), renameResolveTrigger(), schemaIsValid(), sqlite3_exec(), sqlite3_get_table(), sqlite3_overload_function(), sqlite3_str_finish(), sqlite3_str_length(), sqlite3AlterFinishAddColumn(), sqlite3AnalysisLoad(), sqlite3BtreeInsert(), sqlite3BtreeMovetoUnpacked(), sqlite3ExpandSubquery(), sqlite3InitCallback(), sqlite3InitOne(), sqlite3MemMalloc(), sqlite3MemRealloc(), sqlite3PagerRollback(), sqlite3Pragma(), sqlite3RegisterPerConnectionBuiltinFunctions(), sqlite3Reprepare(), sqlite3Step(), sqlite3StrAccumEnlarge(), sqlite3VdbeChangeEncoding(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeHalt(), sqlite3VdbeList(), sqlite3VdbeMemMakeWriteable(), sqlite3VdbeMemSetRowSet(), sqlite3VdbeMemTranslate(), sqlite3WindowRewrite(), vdbeSorterSort(), vtabBestIndex(), vtabCallConstructor(), and walIndexPageRealloc().

◆ SQLITE_NOMEM_BKPT

#define SQLITE_NOMEM_BKPT SQLITE_NOMEM

Definition at line 19276 of file sqlite3.c.

Referenced by accessPayload(), attachFunc(), balance_nonroot(), btreeCursor(), btreeMoveto(), btreeSetHasContent(), corruptSchema(), findInodeInfo(), getPageNormal(), growOpArray(), multiSelect(), multiSelectOrderBy(), openDatabase(), pager_delsuper(), pager_open_journal(), pagerOpenSavepoint(), pagerPlaybackSavepoint(), saveCursorKey(), setSharedCacheTableLock(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_complete16(), sqlite3_exec(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3_initialize(), sqlite3_step(), sqlite3AnalysisLoad(), sqlite3BitvecSet(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3ColumnsFromExprList(), sqlite3CreateFunc(), sqlite3InitOne(), sqlite3LoadExtension(), sqlite3OomFault(), sqlite3OsInit(), sqlite3PagerOpen(), sqlite3PagerSetPagesize(), sqlite3ParseUri(), sqlite3PcacheFetchStress(), sqlite3RunParser(), sqlite3StartTable(), sqlite3Step(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTranslate(), sqlite3VdbeSetColName(), sqlite3VdbeSorterCompare(), sqlite3VdbeSorterInit(), sqlite3WalOpen(), unixFullPathname(), unixOpen(), unixOpenSharedMemory(), unixShmMap(), valueFromExpr(), vdbeCommit(), vdbeCompareMemString(), vdbeIncrMergerNew(), vdbeMemAddTerminator(), vdbeMergeEngineLevel0(), vdbePmaReadBlob(), vdbePmaReaderSeek(), vdbeSortAllocUnpacked(), vdbeSorterAddToTree(), vdbeSorterFlushPMA(), vdbeSorterMergeTreeBuild(), vdbeSorterSetupMerge(), vtabCallConstructor(), walBeginShmUnreliable(), walCheckpoint(), walIndexPageRealloc(), walIndexRecover(), walIteratorInit(), walRewriteChecksums(), whereLoopAddBtreeIndex(), whereLoopAddVirtual(), whereLoopInsert(), wherePathSolver(), and withExpand().

◆ SQLITE_NoSchemaError

#define SQLITE_NoSchemaError 0x08000000 /* Do not report schema parse errors*/

Definition at line 17006 of file sqlite3.c.

Referenced by sqlite3InitOne().

◆ SQLITE_NOTADB

#define SQLITE_NOTADB 26 /* File opened that is not a database file */

Definition at line 1496 of file sqlite3.c.

Referenced by lockBtree().

◆ SQLITE_NOTFOUND

#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

Definition at line 1482 of file sqlite3.c.

Referenced by databaseIsUnmoved(), pager_end_transaction(), sqlite3BtreeCopyFile(), sqlite3OsFileControl(), sqlite3PagerSync(), sqlite3Pragma(), unixSetSystemCall(), and whereLoopAddBtreeIndex().

◆ SQLITE_NOTICE

#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */

Definition at line 1497 of file sqlite3.c.

◆ SQLITE_NOTICE_RECOVER_ROLLBACK

#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

Definition at line 1588 of file sqlite3.c.

Referenced by pager_playback().

◆ SQLITE_NOTICE_RECOVER_WAL

#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8))

Definition at line 1587 of file sqlite3.c.

Referenced by walIndexRecover().

◆ SQLITE_NOTNULL

#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */

Definition at line 17422 of file sqlite3.c.

Referenced by fkLookupParent(), sqlite3GenerateConstraintChecks(), and sqlite3Pragma().

◆ SQLITE_NOWILDCARDMATCH

#define SQLITE_NOWILDCARDMATCH 2

Definition at line 117684 of file sqlite3.c.

Referenced by patternCompare().

◆ SQLITE_NULL

#define SQLITE_NULL 5

Definition at line 5794 of file sqlite3.c.

Referenced by absFunc(), db_push_value(), instrFunc(), minmaxStep(), quoteFunc(), replaceFunc(), sqlite3_exec(), substrFunc(), sumStep(), and vm_push_column().

◆ SQLITE_NullCallback

#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */

Definition at line 16986 of file sqlite3.c.

Referenced by sqlite3_exec().

◆ SQLITE_NULLEQ

#define SQLITE_NULLEQ 0x80 /* NULL=NULL */

Definition at line 17421 of file sqlite3.c.

Referenced by analyzeOneTable(), codeVectorCompare(), selectInnerLoop(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VdbeExec(), and windowCodeRangeTest().

◆ SQLITE_OK

#define SQLITE_OK 0 /* Successful result */

Definition at line 1469 of file sqlite3.c.

Referenced by accessPayload(), addToSavepointBitvecs(), allocateBtreePage(), allocateCursor(), allocateSpace(), anotherValidCursor(), attachFunc(), autoVacuumCommit(), backupOnePage(), backupTruncateFile(), balance(), balance_deeper(), balance_nonroot(), balance_quick(), blobSeekToRow(), btreeCreateTable(), btreeDropTable(), btreeGetPage(), btreeGetUnusedPage(), btreeInitPage(), btreeLockCarefully(), btreeNext(), btreePrevious(), btreeRestoreCursorPosition(), btreeSetHasContent(), changeTempStorage(), checkPtrmap(), checkReadTransaction(), copyNodeContent(), copyPayload(), createFunctionApi(), createModule(), databaseIsUnmoved(), db_do_next_row(), db_do_rows(), db_load_extension(), db_prepare(), db_register_function(), dbvm_bind_names(), dbvm_bind_values(), decodeFlags(), defragmentPage(), dotlockCheckReservedLock(), dotlockLock(), dotlockUnlock(), doWalCallbacks(), editPage(), execSql(), fcntlSizeHint(), fillInCell(), findCreateFileMode(), freePage2(), freeSpace(), getAndInitPage(), getOverflowPage(), getPageNormal(), growOpArray(), hasHotJournal(), incrVacuumStep(), insertCell(), invalidateTempStorage(), isFatalError(), localtimeOffset(), lockBtree(), lsqlite_do_open(), lsqlite_open_ptr(), modifyPagePointer(), moveToLeftmost(), moveToRightmost(), moveToRoot(), multiSelect(), newDatabase(), noopMutexAlloc(), noopMutexFree(), openDatabase(), openDirectory(), openSubJournal(), pager_delsuper(), pager_end_transaction(), pager_error(), pager_incr_changecounter(), pager_open_journal(), pager_playback(), pager_playback_one_page(), pager_truncate(), pager_unlock(), pager_write(), pager_write_pagelist(), pagerBeginReadTransaction(), pagerLockDb(), pagerOpenSavepoint(), pagerOpentemp(), pagerOpenWal(), pagerOpenWalIfPresent(), pagerPagecount(), pagerPlaybackSavepoint(), pagerStress(), pagerSyncHotJournal(), pagerUndoCallback(), pagerUnlockDb(), pagerWalFrames(), pagerWriteLargeSector(), parseModifier(), pcache1Init(), posixUnlock(), pragmaVtabBestIndex(), pthreadMutexEnd(), ptrmapGet(), ptrmapPut(), querySharedCacheTableLock(), read32bits(), readDbPage(), readJournalHdr(), readSuperJournal(), rebuildPage(), relocatePage(), renameColumnFunc(), renameEditSql(), renameParseSql(), renameResolveTrigger(), renameTableFunc(), renameTableTest(), resolveAttachExpr(), resolveExprStep(), robust_ftruncate(), saveAllCursors(), saveCursorKey(), saveCursorPosition(), saveCursorsOnList(), schemaIsValid(), setChildPtrmaps(), setSharedCacheTableLock(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_blob_reopen(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_config(), sqlite3_declare_vtab(), sqlite3_enable_shared_cache(), sqlite3_exec(), sqlite3_finalize(), sqlite3_get_table(), sqlite3_global_recover(), sqlite3_initialize(), sqlite3_memory_alarm(), sqlite3_mutex_try(), sqlite3_os_end(), sqlite3_os_init(), sqlite3_overload_function(), sqlite3_prepare16_v2(), sqlite3_prepare16_v3(), sqlite3_prepare_v2(), sqlite3_reset(), sqlite3_set_authorizer(), sqlite3_shutdown(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_value_blob(), sqlite3_vfs_register(), sqlite3_vtab_config(), sqlite3_wal_autocheckpoint(), sqlite3AlterBeginAddColumn(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3AnalysisLoad(), sqlite3Analyze(), sqlite3AuthCheck(), sqlite3AuthReadCol(), sqlite3BitvecSet(), sqlite3BtreeBeginTrans(), sqlite3BtreeCheckpoint(), sqlite3BtreeClearTable(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeCopyFile(), sqlite3BtreeCount(), sqlite3BtreeCursorRestore(), sqlite3BtreeDelete(), sqlite3BtreeGetMeta(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreeLockTable(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeNext(), sqlite3BtreeOpen(), sqlite3BtreePutData(), sqlite3BtreeRollback(), sqlite3BtreeSavepoint(), sqlite3BtreeSchemaLocked(), sqlite3BtreeSetAutoVacuum(), sqlite3BtreeSetCacheSize(), sqlite3BtreeSetPagerFlags(), sqlite3BtreeSetPageSize(), sqlite3BtreeSetVersion(), sqlite3BtreeTripAllCursors(), sqlite3CheckCollSeq(), sqlite3CheckObjectName(), sqlite3Checkpoint(), sqlite3ColumnsFromExprList(), sqlite3CreateFunc(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3DropTrigger(), sqlite3ExpandSubquery(), sqlite3ExprCheckHeight(), sqlite3ExprCodeTarget(), sqlite3FaultSim(), sqlite3FinishCoding(), sqlite3IndexedByLookup(), sqlite3Init(), sqlite3InitCallback(), sqlite3InitOne(), sqlite3LeaveMutexAndCloseZombie(), sqlite3LoadExtension(), sqlite3LocateTable(), sqlite3MallocInit(), sqlite3MutexEnd(), sqlite3MutexInit(), sqlite3OsUnfetch(), sqlite3PagerBegin(), sqlite3PagerCheckpoint(), sqlite3PagerClose(), sqlite3PagerCloseWal(), sqlite3PagerCommitPhaseOne(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerExclusiveLock(), sqlite3PagerMovepage(), sqlite3PagerOpen(), sqlite3PagerOpenWal(), sqlite3PagerReadFileheader(), sqlite3PagerRollback(), sqlite3PagerSavepoint(), sqlite3PagerSetJournalMode(), sqlite3PagerSetPagesize(), sqlite3PagerSharedLock(), sqlite3PagerSync(), sqlite3PagerWrite(), sqlite3ParseUri(), sqlite3PcacheFetchStress(), sqlite3Pragma(), sqlite3Prepare16(), sqlite3RegisterPerConnectionBuiltinFunctions(), sqlite3Reindex(), sqlite3Reprepare(), sqlite3ResolveExprNames(), sqlite3ResolveSelfReference(), sqlite3RunParser(), sqlite3StartTable(), sqlite3Step(), sqlite3UpsertAnalyzeTarget(), sqlite3VdbeChangeEncoding(), sqlite3VdbeCheckFk(), sqlite3VdbeCursorMoveto(), sqlite3VdbeExec(), sqlite3VdbeFinishMoveto(), sqlite3VdbeHalt(), sqlite3VdbeIdxKeyCompare(), sqlite3VdbeIdxRowid(), sqlite3VdbeList(), sqlite3VdbeMemCast(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemFromBtree(), sqlite3VdbeMemGrow(), sqlite3VdbeMemHandleBom(), sqlite3VdbeMemMakeWriteable(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemSetRowSet(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTranslate(), sqlite3VdbeNextOpcode(), sqlite3VdbeResetStepResult(), sqlite3VdbeSorterCompare(), sqlite3VdbeSorterInit(), sqlite3VdbeSorterNext(), sqlite3VdbeSorterRewind(), sqlite3VtabBegin(), sqlite3VtabCallConnect(), sqlite3VtabCallCreate(), sqlite3VtabCallDestroy(), sqlite3VtabSavepoint(), sqlite3VtabSync(), sqlite3WalBeginReadTransaction(), sqlite3WalBeginWriteTransaction(), sqlite3WalCheckpoint(), sqlite3WalDefaultHook(), sqlite3WalExclusiveMode(), sqlite3WalFindFrame(), sqlite3WalOpen(), sqlite3WalSavepointUndo(), sqlite3WalUndo(), sqlite3WindowRewrite(), subjournalPage(), syncJournal(), synthCollSeq(), unixCheckReservedLock(), unixCurrentTimeInt64(), unixDelete(), unixFetch(), unixFullPathname(), unixGetTempname(), unixLock(), unixLockSharedMemory(), unixOpen(), unixOpenSharedMemory(), unixRead(), unixSetSystemCall(), unixShmLock(), unixShmMap(), unixShmSystemLock(), unixShmUnmap(), unixSync(), unixUnfetch(), unixWrite(), valueFromExpr(), valueToText(), vdbeCloseStatement(), vdbeCommit(), vdbeIncrMergerNew(), vdbeIncrPopulate(), vdbeIncrSwap(), vdbeMemAddTerminator(), vdbeMergeEngineInit(), vdbeMergeEngineLevel0(), vdbeMergeEngineStep(), vdbePmaReadBlob(), vdbePmaReaderIncrInit(), vdbePmaReaderIncrMergeInit(), vdbePmaReaderInit(), vdbePmaReaderSeek(), vdbeSortAllocUnpacked(), vdbeSorterAddToTree(), vdbeSorterFlushPMA(), vdbeSorterJoinThread(), vdbeSorterListToPMA(), vdbeSorterMapFile(), vdbeSorterMergeTreeBuild(), vdbeSorterOpenTempFile(), vdbeSorterSetupMerge(), vdbeSorterSort(), vdbeUnbind(), vtabBestIndex(), vtabCallConstructor(), walBeginShmUnreliable(), walCheckpoint(), walHashGet(), walIndexAppend(), walIndexPageRealloc(), walIndexReadHdr(), walIndexRecover(), walIteratorInit(), walLockShared(), walRestartLog(), walRewriteChecksums(), walTryBeginRead(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopAddOr(), whereLoopAddVirtual(), whereLoopAddVirtualOne(), whereLoopInsert(), wherePathSolver(), whereRangeScanEst(), withExpand(), writeJournalHdr(), writeSuperJournal(), xferOptimization(), and zeroJournalHdr().

◆ SQLITE_OK_LOAD_PERMANENTLY

#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8))

Definition at line 1591 of file sqlite3.c.

Referenced by sqlite3LoadExtension().

◆ SQLITE_OK_SYMLINK

#define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8))

Definition at line 1592 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), sqlite3PagerOpen(), and unixFullPathname().

◆ SQLITE_OmitNoopJoin

#define SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */

Definition at line 17049 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ SQLITE_OPEN_AUTOPROXY

#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

Definition at line 1606 of file sqlite3.c.

Referenced by unixOpen().

◆ SQLITE_OPEN_CREATE

#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

Definition at line 1603 of file sqlite3.c.

Referenced by lsqlite_open(), lsqlite_open_memory(), openDatabase(), openSubJournal(), pager_open_journal(), pagerOpentemp(), sqlite3_open_v2(), sqlite3ParseUri(), sqlite3VdbeExec(), sqlite3WalOpen(), unixOpen(), vdbeCommit(), and vdbeSorterOpenTempFile().

◆ SQLITE_OPEN_DELETEONCLOSE

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

Definition at line 1604 of file sqlite3.c.

Referenced by findCreateFileMode(), openDatabase(), openSubJournal(), pager_open_journal(), pagerOpentemp(), sqlite3VdbeExec(), unixOpen(), and vdbeSorterOpenTempFile().

◆ SQLITE_OPEN_EXCLUSIVE

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

Definition at line 1605 of file sqlite3.c.

Referenced by openDatabase(), openSubJournal(), pagerOpentemp(), sqlite3VdbeExec(), unixOpen(), vdbeCommit(), and vdbeSorterOpenTempFile().

◆ SQLITE_OPEN_FULLMUTEX

#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

Definition at line 1617 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_OPEN_MAIN_DB

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

Definition at line 1609 of file sqlite3.c.

Referenced by attachFunc(), openDatabase(), sqlite3BtreeOpen(), and unixOpen().

◆ SQLITE_OPEN_MAIN_JOURNAL

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

Definition at line 1612 of file sqlite3.c.

Referenced by findCreateFileMode(), hasHotJournal(), openDatabase(), pager_open_journal(), sqlite3PagerSharedLock(), and unixOpen().

◆ SQLITE_OPEN_MASTER_JOURNAL

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

Definition at line 1625 of file sqlite3.c.

◆ SQLITE_OPEN_MEMORY

#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */

Definition at line 1608 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), sqlite3PagerOpen(), and sqlite3ParseUri().

◆ SQLITE_OPEN_NOFOLLOW

#define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */

Definition at line 1621 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ SQLITE_OPEN_NOMUTEX

#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

Definition at line 1616 of file sqlite3.c.

Referenced by openDatabase().

◆ SQLITE_OPEN_PRIVATECACHE

#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

Definition at line 1619 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3ParseUri().

◆ SQLITE_OPEN_READONLY

#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

Definition at line 1601 of file sqlite3.c.

Referenced by findReusableFd(), hasHotJournal(), openDatabase(), pager_delsuper(), sqlite3PagerOpen(), sqlite3PagerSharedLock(), sqlite3ParseUri(), sqlite3WalOpen(), and unixOpen().

◆ SQLITE_OPEN_READWRITE

#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

Definition at line 1602 of file sqlite3.c.

Referenced by findReusableFd(), lsqlite_open(), lsqlite_open_memory(), openDatabase(), openSubJournal(), pager_open_journal(), pagerOpentemp(), sqlite3_open_v2(), sqlite3PagerSharedLock(), sqlite3ParseUri(), sqlite3VdbeExec(), sqlite3WalOpen(), unixOpen(), vdbeCommit(), and vdbeSorterOpenTempFile().

◆ SQLITE_OPEN_SHAREDCACHE

#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

Definition at line 1618 of file sqlite3.c.

Referenced by openDatabase(), sqlite3BtreeOpen(), and sqlite3ParseUri().

◆ SQLITE_OPEN_SUBJOURNAL

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

Definition at line 1614 of file sqlite3.c.

Referenced by openDatabase(), openSubJournal(), and unixOpen().

◆ SQLITE_OPEN_SUPER_JOURNAL

#define SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */

Definition at line 1615 of file sqlite3.c.

Referenced by openDatabase(), pager_delsuper(), unixOpen(), and vdbeCommit().

◆ SQLITE_OPEN_TEMP_DB

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

Definition at line 1610 of file sqlite3.c.

Referenced by openDatabase(), sqlite3BtreeOpen(), and unixOpen().

◆ SQLITE_OPEN_TEMP_JOURNAL

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

Definition at line 1613 of file sqlite3.c.

Referenced by openDatabase(), pager_open_journal(), unixOpen(), and vdbeSorterOpenTempFile().

◆ SQLITE_OPEN_TRANSIENT_DB

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

Definition at line 1611 of file sqlite3.c.

Referenced by openDatabase(), sqlite3VdbeExec(), and unixOpen().

◆ SQLITE_OPEN_URI

#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

Definition at line 1607 of file sqlite3.c.

Referenced by findCreateFileMode(), sqlite3BtreeOpen(), sqlite3ParseUri(), and unixOpen().

◆ SQLITE_OPEN_WAL

#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */

Definition at line 1620 of file sqlite3.c.

Referenced by findCreateFileMode(), openDatabase(), sqlite3WalOpen(), and unixOpen().

◆ SQLITE_OrderByIdxJoin

#define SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */

Definition at line 17047 of file sqlite3.c.

Referenced by wherePathSatisfiesOrderBy().

◆ SQLITE_OS_OTHER

#define SQLITE_OS_OTHER 0

Definition at line 16279 of file sqlite3.c.

◆ SQLITE_OS_SETUP_H

#define SQLITE_OS_SETUP_H

Definition at line 16258 of file sqlite3.c.

◆ SQLITE_OS_UNIX

#define SQLITE_OS_UNIX 1

Definition at line 16287 of file sqlite3.c.

◆ SQLITE_OS_WIN

#define SQLITE_OS_WIN 0

Definition at line 16286 of file sqlite3.c.

◆ SQLITE_PAGER_H

#define SQLITE_PAGER_H

Definition at line 14768 of file sqlite3.c.

◆ SQLITE_PERM

#define SQLITE_PERM 3 /* Access permission denied */

Definition at line 1473 of file sqlite3.c.

Referenced by sqlite3ParseUri(), and sqliteErrorFromPosixError().

◆ SQLITE_POWERSAFE_OVERWRITE

#define SQLITE_POWERSAFE_OVERWRITE 1

Definition at line 13580 of file sqlite3.c.

◆ SQLITE_PRAGMA

#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */

Definition at line 4138 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_PREPARE_MASK

#define SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */

Definition at line 15793 of file sqlite3.c.

◆ SQLITE_PREPARE_NO_VTAB

#define SQLITE_PREPARE_NO_VTAB 0x04

Definition at line 4994 of file sqlite3.c.

◆ SQLITE_PREPARE_NORMALIZE

#define SQLITE_PREPARE_NORMALIZE 0x02

Definition at line 4993 of file sqlite3.c.

◆ SQLITE_PREPARE_PERSISTENT

#define SQLITE_PREPARE_PERSISTENT 0x01

Definition at line 4992 of file sqlite3.c.

◆ SQLITE_PREPARE_SAVESQL

#define SQLITE_PREPARE_SAVESQL 0x80 /* Preserve SQL text */

Definition at line 15792 of file sqlite3.c.

Referenced by sqlite3_prepare16_v3(), sqlite3_transfer_bindings(), sqlite3Step(), and vdbeUnbind().

◆ SQLITE_PRINT_BUF_SIZE

#define SQLITE_PRINT_BUF_SIZE 70

Definition at line 28327 of file sqlite3.c.

Referenced by renderLogMsg().

◆ SQLITE_PRINTF_INTERNAL

#define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */

Definition at line 18977 of file sqlite3.c.

Referenced by sqlite3_str_vappendf(), and sqlite3BtreeIntegrityCheck().

◆ SQLITE_PRINTF_MALLOCED

#define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */

Definition at line 18979 of file sqlite3.c.

Referenced by sqlite3_str_vappendf(), sqlite3StrAccumEnlarge(), and strAccumFinishRealloc().

◆ SQLITE_PRINTF_SQLFUNC

#define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */

Definition at line 18978 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ SQLITE_PRIVATE

#define SQLITE_PRIVATE static

Definition at line 23 of file sqlite3.c.

Referenced by sqlite3RunParser().

◆ SQLITE_PropagateConst

#define SQLITE_PropagateConst 0x8000 /* The constant propagation opt */

Definition at line 17057 of file sqlite3.c.

Referenced by sqlite3Select().

◆ SQLITE_PROTOCOL

#define SQLITE_PROTOCOL 15 /* Database lock protocol error */

Definition at line 1485 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), walRestartLog(), and walTryBeginRead().

◆ SQLITE_PTR_TO_INT

#define SQLITE_PTR_TO_INT ( X ) ((int)(((char*)X)-(char*)0))

Definition at line 13514 of file sqlite3.c.

Referenced by balance_nonroot(), sqlite3ExprCodeTarget(), sqlite3Pragma(), sqlite3WalDefaultHook(), valueToText(), and vdbeSorterJoinThread().

◆ SQLITE_PTRSIZE

#define SQLITE_PTRSIZE 8

Definition at line 14393 of file sqlite3.c.

Referenced by sqlite3_initialize().

◆ SQLITE_PushDown

#define SQLITE_PushDown 0x1000 /* The push-down optimization */

Definition at line 17054 of file sqlite3.c.

Referenced by sqlite3Select().

◆ SQLITE_QUERY_PLANNER_LIMIT

#define SQLITE_QUERY_PLANNER_LIMIT 20000

Definition at line 141353 of file sqlite3.c.

◆ SQLITE_QUERY_PLANNER_LIMIT_INCR

#define SQLITE_QUERY_PLANNER_LIMIT_INCR 1000

Definition at line 141356 of file sqlite3.c.

◆ SQLITE_QueryFlattener

#define SQLITE_QueryFlattener 0x0001 /* Query flattening */

Definition at line 17041 of file sqlite3.c.

Referenced by flattenSubquery(), and sqlite3Select().

◆ SQLITE_QueryOnly

#define SQLITE_QueryOnly 0x00100000 /* Disable database changes */

Definition at line 16999 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_RANGE

#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

Definition at line 1495 of file sqlite3.c.

Referenced by columnMem(), and vdbeUnbind().

◆ SQLITE_READ

#define SQLITE_READ 20 /* Table Name Column Name */

Definition at line 4139 of file sqlite3.c.

Referenced by sqlite3AuthReadCol(), and sqlite3Select().

◆ SQLITE_READONLY

#define SQLITE_READONLY 8 /* Attempt to write a readonly database */

Definition at line 1478 of file sqlite3.c.

Referenced by backupOnePage(), sqlite3BtreeBeginTrans(), sqlite3BtreePutData(), sqlite3BtreeSetAutoVacuum(), sqlite3BtreeSetPageSize(), sqlite3VdbeExec(), sqlite3WalBeginWriteTransaction(), sqlite3WalCheckpoint(), unixShmMap(), walBeginShmUnreliable(), walIndexPageRealloc(), and walIndexReadHdr().

◆ SQLITE_READONLY_CANTINIT

#define SQLITE_READONLY_CANTINIT (SQLITE_READONLY | (5<<8))

Definition at line 1573 of file sqlite3.c.

Referenced by unixLockSharedMemory(), unixOpenSharedMemory(), walBeginShmUnreliable(), walIndexReadHdr(), and walTryBeginRead().

◆ SQLITE_READONLY_CANTLOCK

#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))

Definition at line 1570 of file sqlite3.c.

◆ SQLITE_READONLY_DBMOVED

#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8))

Definition at line 1572 of file sqlite3.c.

Referenced by databaseIsUnmoved().

◆ SQLITE_READONLY_DIRECTORY

#define SQLITE_READONLY_DIRECTORY (SQLITE_READONLY | (6<<8))

Definition at line 1574 of file sqlite3.c.

Referenced by unixOpen().

◆ SQLITE_READONLY_RECOVERY

#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))

Definition at line 1569 of file sqlite3.c.

Referenced by walIndexReadHdr().

◆ SQLITE_READONLY_ROLLBACK

#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8))

Definition at line 1571 of file sqlite3.c.

Referenced by sqlite3PagerSharedLock().

◆ SQLITE_ReadUncommit

#define SQLITE_ReadUncommit 0x00000400 /* READ UNCOMMITTED in shared-cache */

Definition at line 16989 of file sqlite3.c.

Referenced by querySharedCacheTableLock(), setSharedCacheTableLock(), and sqlite3VdbeExec().

◆ SQLITE_REALLOC

#define SQLITE_REALLOC	(		x,
			y ) realloc((x),(y))

Definition at line 23625 of file sqlite3.c.

Referenced by sqlite3MemRealloc().

◆ SQLITE_RecTriggers

#define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */

Definition at line 16992 of file sqlite3.c.

Referenced by openDatabase(), sqlite3CodeRowTriggerDirect(), and sqlite3GenerateConstraintChecks().

◆ SQLITE_RECURSIVE

#define SQLITE_RECURSIVE 33 /* NULL NULL */

Definition at line 4153 of file sqlite3.c.

Referenced by generateWithRecursiveQuery().

◆ SQLITE_REINDEX

#define SQLITE_REINDEX 27 /* Index Name NULL */

Definition at line 4146 of file sqlite3.c.

Referenced by sqlite3RefillIndex().

◆ SQLITE_REPLACE

#define SQLITE_REPLACE 5

Definition at line 10289 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict().

◆ SQLITE_ResetDatabase

#define SQLITE_ResetDatabase 0x02000000 /* Reset the database */

Definition at line 17004 of file sqlite3.c.

Referenced by lockBtree(), sqlite3BtreeBeginTrans(), and sqlite3InitOne().

◆ SQLITE_ReverseOrder

#define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */

Definition at line 16991 of file sqlite3.c.

Referenced by openDatabase(), and sqlite3WhereBegin().

◆ SQLITE_ROLLBACK

#define SQLITE_ROLLBACK 1

Definition at line 10285 of file sqlite3.c.

Referenced by sqlite3_vtab_on_conflict().

◆ SQLITE_ROW

#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */

Definition at line 1499 of file sqlite3.c.

Referenced by blobSeekToRow(), db_do_next_row(), dbvm_step(), execSql(), sqlite3_exec(), sqlite3ErrStr(), sqlite3Step(), sqlite3VdbeExec(), and sqlite3VdbeList().

◆ SQLITE_SAVEPOINT

#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

Definition at line 4151 of file sqlite3.c.

◆ SQLITE_SCANSTAT_EST

#define SQLITE_SCANSTAT_EST 2

Definition at line 10340 of file sqlite3.c.

◆ SQLITE_SCANSTAT_EXPLAIN

#define SQLITE_SCANSTAT_EXPLAIN 4

Definition at line 10342 of file sqlite3.c.

◆ SQLITE_SCANSTAT_NAME

#define SQLITE_SCANSTAT_NAME 3

Definition at line 10341 of file sqlite3.c.

◆ SQLITE_SCANSTAT_NLOOP

#define SQLITE_SCANSTAT_NLOOP 0

Definition at line 10338 of file sqlite3.c.

◆ SQLITE_SCANSTAT_NVISIT

#define SQLITE_SCANSTAT_NVISIT 1

Definition at line 10339 of file sqlite3.c.

◆ SQLITE_SCANSTAT_SELECTID

#define SQLITE_SCANSTAT_SELECTID 5

Definition at line 10343 of file sqlite3.c.

◆ SQLITE_SCHEMA

#define SQLITE_SCHEMA 17 /* The database schema changed */

Definition at line 1487 of file sqlite3.c.

Referenced by schemaIsValid(), sqlite3_blob_reopen(), sqlite3_step(), sqlite3Step(), and sqlite3VdbeExec().

◆ SQLITE_SELECT

#define SQLITE_SELECT 21 /* NULL NULL */

Definition at line 4140 of file sqlite3.c.

Referenced by flattenSubquery(), and sqlite3Select().

◆ SQLITE_SERIALIZE_NOCOPY

#define SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */

Definition at line 10787 of file sqlite3.c.

◆ SQLITE_SET_LOCKPROXYFILE

#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

Definition at line 2220 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_SHM_EXCLUSIVE

#define SQLITE_SHM_EXCLUSIVE 8

Definition at line 2505 of file sqlite3.c.

Referenced by unixShmLock().

◆ SQLITE_SHM_LOCK

#define SQLITE_SHM_LOCK 2

Definition at line 2503 of file sqlite3.c.

Referenced by unixShmLock().

◆ SQLITE_SHM_NLOCK

#define SQLITE_SHM_NLOCK 8

Definition at line 2515 of file sqlite3.c.

Referenced by unixShmLock(), and unixShmSystemLock().

◆ SQLITE_SHM_SHARED

#define SQLITE_SHM_SHARED 4

Definition at line 2504 of file sqlite3.c.

Referenced by unixShmLock(), and walLockExclusive().

◆ SQLITE_SHM_UNLOCK

#define SQLITE_SHM_UNLOCK 1

Definition at line 2502 of file sqlite3.c.

Referenced by unixShmLock(), and walLockExclusive().

◆ SQLITE_ShortColNames

#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */

Definition at line 16984 of file sqlite3.c.

Referenced by generateColumnNames(), openDatabase(), and selectExpander().

◆ SQLITE_SimplifyJoin

#define SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */

Definition at line 17055 of file sqlite3.c.

Referenced by sqlite3Select().

◆ SQLITE_SKIP_UTF8

#define SQLITE_SKIP_UTF8 ( zIn )

Value:

  {                        \
  if( (*(zIn++))>=0xc0 ){                              \
    while( (*zIn & 0xc0)==0x80 ){ zIn++; }             \
  }                                                    \
}

Definition at line 19250 of file sqlite3.c.

 
/*
** Assuming zIn points to the first byte of a UTF-8 character,
** advance zIn to point to the first byte of the next UTF-8 character.
*/

Referenced by patternCompare(), sqlite3_str_vappendf(), sqlite3Utf8CharLen(), and substrFunc().

◆ SQLITE_SkipScan

#define SQLITE_SkipScan 0x4000 /* Skip-scans */

Definition at line 17056 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex().

◆ SQLITE_SO_ASC

#define SQLITE_SO_ASC 0 /* Sort in ascending order */

Definition at line 17376 of file sqlite3.c.

Referenced by yy_reduce().

◆ SQLITE_SO_DESC

#define SQLITE_SO_DESC 1 /* Sort in ascending order */

Definition at line 17377 of file sqlite3.c.

Referenced by sqlite3AddPrimaryKey(), and yy_reduce().

◆ SQLITE_SO_UNDEFINED

#define SQLITE_SO_UNDEFINED -1 /* No sort order specified */

Definition at line 17378 of file sqlite3.c.

Referenced by parserAddExprIdListTerm(), sqlite3CreateIndex(), and yy_reduce().

◆ SQLITE_SORTER_PMASZ

#define SQLITE_SORTER_PMASZ 250

Definition at line 20525 of file sqlite3.c.

◆ SQLITE_SOURCE_ID [1/2]

#define SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f"

Definition at line 1176 of file sqlite3.c.

Referenced by sqlite3_sourceid().

◆ SQLITE_SOURCE_ID [2/2]

#define SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0alt2"

Definition at line 1176 of file sqlite3.c.

◆ SQLITE_Stat4

#define SQLITE_Stat4 0x0800 /* Use STAT4 data */

Definition at line 17052 of file sqlite3.c.

Referenced by analyzeOneTable(), exprAnalyze(), openStatTable(), statInit(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ SQLITE_STAT4_SAMPLES

#define SQLITE_STAT4_SAMPLES 1

Definition at line 107693 of file sqlite3.c.

Referenced by statInit().

◆ SQLITE_STATIC

#define SQLITE_STATIC ((sqlite3_destructor_type)0)

Definition at line 6670 of file sqlite3.c.

Referenced by callCollNeeded(), quoteFunc(), sourceidFunc(), sqlite3_complete16(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Update(), sqlite3Utf16to8(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeList(), sqlite3VdbeMakeReady(), and sqlite3VdbeMemSetStr().

◆ SQLITE_STATUS_MALLOC_COUNT

#define SQLITE_STATUS_MALLOC_COUNT 9

Definition at line 9059 of file sqlite3.c.

Referenced by mallocWithAlarm().

◆ SQLITE_STATUS_MALLOC_SIZE

#define SQLITE_STATUS_MALLOC_SIZE 5

Definition at line 9055 of file sqlite3.c.

Referenced by mallocWithAlarm(), and sqlite3StatusHighwater().

◆ SQLITE_STATUS_MEMORY_USED

#define SQLITE_STATUS_MEMORY_USED 0

Definition at line 9050 of file sqlite3.c.

Referenced by mallocWithAlarm(), sqlite3_memory_highwater(), and sqlite3_soft_heap_limit64().

◆ SQLITE_STATUS_PAGECACHE_OVERFLOW

#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2

Definition at line 9052 of file sqlite3.c.

Referenced by pcache1Alloc().

◆ SQLITE_STATUS_PAGECACHE_SIZE

#define SQLITE_STATUS_PAGECACHE_SIZE 7

Definition at line 9057 of file sqlite3.c.

Referenced by pcache1Alloc(), and sqlite3StatusHighwater().

◆ SQLITE_STATUS_PAGECACHE_USED

#define SQLITE_STATUS_PAGECACHE_USED 1

Definition at line 9051 of file sqlite3.c.

Referenced by pcache1Alloc().

◆ SQLITE_STATUS_PARSER_STACK

#define SQLITE_STATUS_PARSER_STACK 6

Definition at line 9056 of file sqlite3.c.

Referenced by sqlite3RunParser(), and sqlite3StatusHighwater().

◆ SQLITE_STATUS_SCRATCH_OVERFLOW

#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */

Definition at line 9054 of file sqlite3.c.

◆ SQLITE_STATUS_SCRATCH_SIZE

#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */

Definition at line 9058 of file sqlite3.c.

◆ SQLITE_STATUS_SCRATCH_USED

#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */

Definition at line 9053 of file sqlite3.c.

◆ SQLITE_STDCALL

#define SQLITE_STDCALL SQLITE_APICALL

Definition at line 1109 of file sqlite3.c.

◆ SQLITE_STMTJRNL_SPILL

#define SQLITE_STMTJRNL_SPILL (64*1024)

Definition at line 20537 of file sqlite3.c.

◆ SQLITE_STMTSTATUS_AUTOINDEX

#define SQLITE_STMTSTATUS_AUTOINDEX 3

Definition at line 9296 of file sqlite3.c.

Referenced by constructAutomaticIndex().

◆ SQLITE_STMTSTATUS_FULLSCAN_STEP

#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1

Definition at line 9294 of file sqlite3.c.

◆ SQLITE_STMTSTATUS_MEMUSED

#define SQLITE_STMTSTATUS_MEMUSED 99

Definition at line 9300 of file sqlite3.c.

◆ SQLITE_STMTSTATUS_REPREPARE

#define SQLITE_STMTSTATUS_REPREPARE 5

Definition at line 9298 of file sqlite3.c.

◆ SQLITE_STMTSTATUS_RUN

#define SQLITE_STMTSTATUS_RUN 6

Definition at line 9299 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_STMTSTATUS_SORT

#define SQLITE_STMTSTATUS_SORT 2

Definition at line 9295 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_STMTSTATUS_VM_STEP

#define SQLITE_STMTSTATUS_VM_STEP 4

Definition at line 9297 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_STOREP2

#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */

Definition at line 17420 of file sqlite3.c.

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ SQLITE_SUBTYPE

#define SQLITE_SUBTYPE 0x000100000

Definition at line 6326 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_SYNC_DATAONLY

#define SQLITE_SYNC_DATAONLY 0x00010

Definition at line 1718 of file sqlite3.c.

Referenced by syncJournal(), unixSync(), and zeroJournalHdr().

◆ SQLITE_SYNC_FULL

#define SQLITE_SYNC_FULL 0x00003

Definition at line 1717 of file sqlite3.c.

Referenced by sqlite3PagerSetFlags(), syncJournal(), and unixSync().

◆ SQLITE_SYNC_NORMAL

#define SQLITE_SYNC_NORMAL 0x00002

Definition at line 1716 of file sqlite3.c.

Referenced by pagerSyncHotJournal(), sqlite3PagerOpen(), sqlite3PagerSetFlags(), unixSync(), and vdbeCommit().

◆ SQLITE_SYSAPI

#define SQLITE_SYSAPI

Definition at line 1115 of file sqlite3.c.

◆ SQLITE_SYSTEM_MALLOC

#define SQLITE_SYSTEM_MALLOC 1

Definition at line 13622 of file sqlite3.c.

◆ SQLITE_TCLAPI

#define SQLITE_TCLAPI

Definition at line 840 of file sqlite3.c.

◆ SQLITE_TEMP_FILE_PREFIX

#define SQLITE_TEMP_FILE_PREFIX "etilqs_"

Definition at line 16339 of file sqlite3.c.

Referenced by unixGetTempname().

◆ SQLITE_TEMP_STORE

#define SQLITE_TEMP_STORE 1

Definition at line 14199 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ SQLITE_TESTCTRL_ALWAYS

#define SQLITE_TESTCTRL_ALWAYS 13

Definition at line 8744 of file sqlite3.c.

◆ SQLITE_TESTCTRL_ASSERT

#define SQLITE_TESTCTRL_ASSERT 12

Definition at line 8743 of file sqlite3.c.

◆ SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS

#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

Definition at line 8741 of file sqlite3.c.

◆ SQLITE_TESTCTRL_BITVEC_TEST

#define SQLITE_TESTCTRL_BITVEC_TEST 8

Definition at line 8739 of file sqlite3.c.

◆ SQLITE_TESTCTRL_BYTEORDER

#define SQLITE_TESTCTRL_BYTEORDER 22

Definition at line 8755 of file sqlite3.c.

◆ SQLITE_TESTCTRL_EXPLAIN_STMT

#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

Definition at line 8751 of file sqlite3.c.

◆ SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS

#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29

Definition at line 8762 of file sqlite3.c.

◆ SQLITE_TESTCTRL_FAULT_INSTALL

#define SQLITE_TESTCTRL_FAULT_INSTALL 9

Definition at line 8740 of file sqlite3.c.

◆ SQLITE_TESTCTRL_FIRST

#define SQLITE_TESTCTRL_FIRST 5

Definition at line 8735 of file sqlite3.c.

◆ SQLITE_TESTCTRL_IMPOSTER

#define SQLITE_TESTCTRL_IMPOSTER 25

Definition at line 8758 of file sqlite3.c.

◆ SQLITE_TESTCTRL_INTERNAL_FUNCTIONS

#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17

Definition at line 8749 of file sqlite3.c.

◆ SQLITE_TESTCTRL_ISINIT

#define SQLITE_TESTCTRL_ISINIT 23

Definition at line 8756 of file sqlite3.c.

◆ SQLITE_TESTCTRL_ISKEYWORD

#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */

Definition at line 8747 of file sqlite3.c.

◆ SQLITE_TESTCTRL_LAST

#define SQLITE_TESTCTRL_LAST 29 /* Largest TESTCTRL */

Definition at line 8763 of file sqlite3.c.

◆ SQLITE_TESTCTRL_LOCALTIME_FAULT

#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18

Definition at line 8750 of file sqlite3.c.

◆ SQLITE_TESTCTRL_NEVER_CORRUPT

#define SQLITE_TESTCTRL_NEVER_CORRUPT 20

Definition at line 8753 of file sqlite3.c.

◆ SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD

#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19

Definition at line 8752 of file sqlite3.c.

◆ SQLITE_TESTCTRL_OPTIMIZATIONS

#define SQLITE_TESTCTRL_OPTIMIZATIONS 15

Definition at line 8746 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PARSER_COVERAGE

#define SQLITE_TESTCTRL_PARSER_COVERAGE 26

Definition at line 8759 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PENDING_BYTE

#define SQLITE_TESTCTRL_PENDING_BYTE 11

Definition at line 8742 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PRNG_RESET

#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */

Definition at line 8738 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PRNG_RESTORE

#define SQLITE_TESTCTRL_PRNG_RESTORE 6

Definition at line 8737 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PRNG_SAVE

#define SQLITE_TESTCTRL_PRNG_SAVE 5

Definition at line 8736 of file sqlite3.c.

◆ SQLITE_TESTCTRL_PRNG_SEED

#define SQLITE_TESTCTRL_PRNG_SEED 28

Definition at line 8761 of file sqlite3.c.

◆ SQLITE_TESTCTRL_RESERVE

#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */

Definition at line 8745 of file sqlite3.c.

◆ SQLITE_TESTCTRL_RESULT_INTREAL

#define SQLITE_TESTCTRL_RESULT_INTREAL 27

Definition at line 8760 of file sqlite3.c.

◆ SQLITE_TESTCTRL_SCRATCHMALLOC

#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */

Definition at line 8748 of file sqlite3.c.

◆ SQLITE_TESTCTRL_SORTER_MMAP

#define SQLITE_TESTCTRL_SORTER_MMAP 24

Definition at line 8757 of file sqlite3.c.

◆ SQLITE_TESTCTRL_VDBE_COVERAGE

#define SQLITE_TESTCTRL_VDBE_COVERAGE 21

Definition at line 8754 of file sqlite3.c.

◆ SQLITE_TEXT

#define SQLITE_TEXT 3

Definition at line 5798 of file sqlite3.c.

Referenced by db_push_value(), exprCompareVariable(), isLikeOrGlob(), quoteFunc(), sqlite3_value_numeric_type(), and vm_push_column().

◆ SQLITE_THREADS_IMPLEMENTED

#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */

Definition at line 30403 of file sqlite3.c.

◆ SQLITE_THREADSAFE

#define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

Definition at line 13571 of file sqlite3.c.

Referenced by removeFromSharingList(), and sqlite3BtreeOpen().

◆ SQLITE_TOKEN_KEYWORD

#define SQLITE_TOKEN_KEYWORD 0x2 /* Token is a keyword. */

Definition at line 17851 of file sqlite3.c.

◆ SQLITE_TOKEN_QUOTED

#define SQLITE_TOKEN_QUOTED 0x1 /* Token is a quoted identifier. */

Definition at line 17850 of file sqlite3.c.

◆ SQLITE_TOOBIG

#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

Definition at line 1488 of file sqlite3.c.

Referenced by invokeValueDestructor(), printfTempBuf(), sqlite3_result_error_code(), sqlite3NestedParse(), sqlite3RunParser(), sqlite3StrAccumEnlarge(), sqlite3VdbeExec(), and sqlite3VdbeMemSetStr().

◆ SQLITE_TRACE_CLOSE

#define SQLITE_TRACE_CLOSE 0x08

Definition at line 4247 of file sqlite3.c.

◆ SQLITE_TRACE_LEGACY

#define SQLITE_TRACE_LEGACY 0x40 /* Use the legacy xTrace */

Definition at line 16807 of file sqlite3.c.

Referenced by sqlite3_trace(), and sqlite3VdbeExec().

◆ SQLITE_TRACE_NONLEGACY_MASK

#define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */

Definition at line 16813 of file sqlite3.c.

Referenced by sqlite3_profile().

◆ SQLITE_TRACE_PROFILE

#define SQLITE_TRACE_PROFILE 0x02

Definition at line 4245 of file sqlite3.c.

Referenced by invokeProfileCallback(), and sqlite3Step().

◆ SQLITE_TRACE_ROW

#define SQLITE_TRACE_ROW 0x04

Definition at line 4246 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_TRACE_STMT

#define SQLITE_TRACE_STMT 0x01

Definition at line 4244 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ SQLITE_TRACE_XPROFILE

#define SQLITE_TRACE_XPROFILE 0x80 /* Use the legacy xProfile */

Definition at line 16808 of file sqlite3.c.

Referenced by invokeProfileCallback(), sqlite3_profile(), and sqlite3Step().

◆ SQLITE_TRANSACTION

#define SQLITE_TRANSACTION 22 /* Operation NULL */

Definition at line 4141 of file sqlite3.c.

Referenced by sqlite3EndTransaction().

◆ SQLITE_TRANSIENT

#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

Definition at line 6671 of file sqlite3.c.

Referenced by dateFunc(), datetimeFunc(), dbvm_bind_blob(), dbvm_bind_index(), generateColumnNames(), lcontext_result(), lcontext_result_blob(), lcontext_result_text(), quoteFunc(), renameEditSql(), sqlite3_result_error16(), sqlite3_result_int(), sqlite3Pragma(), sqlite3VdbeMemSetStr(), sqlite3VdbeTransferError(), statGet(), strftimeFunc(), substrFunc(), and timeFunc().

◆ SQLITE_Transitive

#define SQLITE_Transitive 0x0080 /* Transitive constraints */

Definition at line 17048 of file sqlite3.c.

Referenced by termIsEquivalence().

◆ SQLITE_TriggerEQP

#define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */

Definition at line 17003 of file sqlite3.c.

Referenced by sqlite3VdbeList().

◆ SQLITE_TrustedSchema

#define SQLITE_TrustedSchema

Value:

0x00000080 /* Allow unsafe functions and

** vtabs in the schema definition */

Definition at line 16985 of file sqlite3.c.

Referenced by openDatabase(), selectExpander(), and sqlite3ExprFunctionUsable().

◆ SQLITE_UPDATE

#define SQLITE_UPDATE 23 /* Table Name Column Name */

Definition at line 4142 of file sqlite3.c.

Referenced by sqlite3Update(), and sqlite3VdbeExec().

◆ SQLITE_USE_URI

#define SQLITE_USE_URI 0

Definition at line 20503 of file sqlite3.c.

◆ SQLITE_UTF16

#define SQLITE_UTF16 4 /* Use native byte order */

Definition at line 6255 of file sqlite3.c.

Referenced by sqlite3CreateFunc().

◆ SQLITE_UTF16_ALIGNED

#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

Definition at line 6257 of file sqlite3.c.

Referenced by sqlite3ValueText(), and valueToText().

◆ SQLITE_UTF16BE

#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */

Definition at line 6254 of file sqlite3.c.

Referenced by findCollSeqEntry(), openDatabase(), sqlite3_result_text16le(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3CreateFunc(), sqlite3FindCollSeq(), sqlite3MemCompare(), sqlite3Pragma(), sqlite3VdbeChangeEncoding(), sqlite3VdbeExec(), sqlite3VdbeMemHandleBom(), sqlite3VdbeMemTranslate(), and synthCollSeq().

◆ SQLITE_UTF16LE

#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */

Definition at line 6253 of file sqlite3.c.

Referenced by findCollSeqEntry(), openDatabase(), sqlite3_result_value(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3CreateFunc(), sqlite3FindCollSeq(), sqlite3MemCompare(), sqlite3Pragma(), sqlite3Utf16ByteLen(), sqlite3VdbeChangeEncoding(), sqlite3VdbeExec(), sqlite3VdbeMemHandleBom(), sqlite3VdbeMemTranslate(), and synthCollSeq().

◆ SQLITE_UTF16NATIVE

#define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

Definition at line 14456 of file sqlite3.c.

Referenced by callCollNeeded(), sqlite3_bind_value(), sqlite3_complete16(), sqlite3_result_int(), sqlite3_result_text16be(), sqlite3_value_int(), sqlite3_value_text16le(), sqlite3CreateFunc(), sqlite3Pragma(), sqlite3Prepare16(), and sqlite3Utf16ByteLen().

◆ SQLITE_UTF8

#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */

Definition at line 6252 of file sqlite3.c.

Referenced by callCollNeeded(), charFunc(), codeReal(), db_create_collation(), db_register_function(), exprCompareVariable(), exprProbability(), findCollSeqEntry(), isLikeOrGlob(), openDatabase(), parseDateOrTime(), parseModifier(), quoteFunc(), sqlite3_bind_text64(), sqlite3_complete16(), sqlite3_overload_function(), sqlite3_result_error16(), sqlite3_result_text64(), sqlite3_value_double(), sqlite3AlterFinishAddColumn(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3Attach(), sqlite3CreateFunc(), sqlite3DecOrHexToI64(), sqlite3Detach(), sqlite3ErrorWithMsg(), sqlite3ExprAssignVarNumber(), sqlite3FindCollSeq(), sqlite3InitOne(), sqlite3IsLikeFunction(), sqlite3MemCompare(), sqlite3Pragma(), sqlite3RegisterLikeFunctions(), sqlite3Utf16to8(), sqlite3VdbeChangeEncoding(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeGetBoundValue(), sqlite3VdbeList(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTranslate(), sqlite3VdbeSetColName(), sqlite3VdbeTransferError(), substrFunc(), synthCollSeq(), and valueFromExpr().

◆ SQLITE_VDBE_H

#define SQLITE_VDBE_H

Definition at line 15412 of file sqlite3.c.

◆ SQLITE_VDBEINT_H

#define SQLITE_VDBEINT_H

Definition at line 20723 of file sqlite3.c.

◆ SQLITE_VERSION

#define SQLITE_VERSION "3.33.0"

Definition at line 1174 of file sqlite3.c.

◆ SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER 3033000

Definition at line 1175 of file sqlite3.c.

Referenced by pager_write_changecounter(), and sqlite3_threadsafe().

◆ SQLITE_VTAB_CONSTRAINT_SUPPORT

#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1

Definition at line 10223 of file sqlite3.c.

Referenced by sqlite3_vtab_config().

◆ SQLITE_VTAB_DIRECTONLY

#define SQLITE_VTAB_DIRECTONLY 3

Definition at line 10225 of file sqlite3.c.

Referenced by sqlite3_vtab_config().

◆ SQLITE_VTAB_INNOCUOUS

#define SQLITE_VTAB_INNOCUOUS 2

Definition at line 10224 of file sqlite3.c.

Referenced by sqlite3_vtab_config().

◆ SQLITE_VTABRISK_High

#define SQLITE_VTABRISK_High 2

Definition at line 17481 of file sqlite3.c.

Referenced by sqlite3_vtab_config().

◆ SQLITE_VTABRISK_Low

#define SQLITE_VTABRISK_Low 0

Definition at line 17479 of file sqlite3.c.

Referenced by sqlite3_vtab_config().

◆ SQLITE_VTABRISK_Normal

#define SQLITE_VTABRISK_Normal 1

Definition at line 17480 of file sqlite3.c.

Referenced by vtabCallConstructor().

◆ SQLITE_WAL_H

#define SQLITE_WAL_H

Definition at line 51585 of file sqlite3.c.

◆ SQLITE_WARNING

#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */

Definition at line 1498 of file sqlite3.c.

Referenced by lookupName(), robust_open(), and verifyDbFile().

◆ SQLITE_WARNING_AUTOINDEX

#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8))

Definition at line 1589 of file sqlite3.c.

Referenced by constructAutomaticIndex().

◆ SQLITE_WHEREINT_H

#define SQLITE_WHEREINT_H

Definition at line 140932 of file sqlite3.c.

◆ SQLITE_WIN32_DATA_DIRECTORY_TYPE

#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1

Definition at line 7155 of file sqlite3.c.

◆ SQLITE_WIN32_TEMP_DIRECTORY_TYPE

#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2

Definition at line 7156 of file sqlite3.c.

◆ SQLITE_WindowFunc

#define SQLITE_WindowFunc 0x0002 /* Use xInverse for window functions */

Definition at line 17042 of file sqlite3.c.

◆ SQLITE_WITHIN

#define SQLITE_WITHIN	(	P,
		S,
		E ) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))

Definition at line 14415 of file sqlite3.c.

Referenced by balance_nonroot(), editPage(), isLookaside(), pageFreeArray(), ptrmapPutOvflPtr(), and rebuildPage().

◆ SQLITE_WriteSchema

#define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_SCHEMA */

Definition at line 16978 of file sqlite3.c.

Referenced by corruptSchema(), and sqlite3Pragma().

◆ SQLITE_WSD

#define SQLITE_WSD

Definition at line 14632 of file sqlite3.c.

◆ sqliteHashData

#define sqliteHashData ( E ) ((E)->data)

Definition at line 13928 of file sqlite3.c.

Referenced by detachFunc(), reindexDatabases(), sqlite3AnalysisLoad(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Pragma(), sqlite3RootPageMoved(), sqlite3SchemaClear(), sqlite3TriggerList(), and sqliteViewResetAll().

◆ sqliteHashFirst

#define sqliteHashFirst ( H ) ((H)->first)

Definition at line 13926 of file sqlite3.c.

Referenced by detachFunc(), reindexDatabases(), sqlite3AnalysisLoad(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Pragma(), sqlite3RootPageMoved(), sqlite3SchemaClear(), sqlite3TriggerList(), and sqliteViewResetAll().

◆ sqliteHashNext

#define sqliteHashNext ( E ) ((E)->next)

Definition at line 13927 of file sqlite3.c.

Referenced by detachFunc(), reindexDatabases(), sqlite3AnalysisLoad(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Pragma(), sqlite3RootPageMoved(), sqlite3SchemaClear(), sqlite3TriggerList(), and sqliteViewResetAll().

◆ SQLITEINT_H

#define SQLITEINT_H

Definition at line 806 of file sqlite3.c.

◆ SRT_Coroutine

#define SRT_Coroutine 13 /* Generate a single row of result */

Definition at line 18584 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), multiSelectOrderBy(), selectInnerLoop(), sqlite3EndTable(), sqlite3Insert(), and sqlite3Select().

◆ SRT_Discard

#define SRT_Discard 4 /* Do not save the results anywhere */

Definition at line 18571 of file sqlite3.c.

Referenced by selectInnerLoop(), and sqlite3Select().

◆ SRT_DistFifo

#define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */

Definition at line 18573 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), selectInnerLoop(), and sqlite3Select().

◆ SRT_DistQueue

#define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */

Definition at line 18575 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), selectInnerLoop(), and sqlite3Select().

◆ SRT_EphemTab

#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */

Definition at line 18583 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), multiSelect(), selectInnerLoop(), sqlite3MaterializeView(), and sqlite3Select().

◆ SRT_Except

#define SRT_Except 2 /* Remove result from a UNION index */

Definition at line 18569 of file sqlite3.c.

Referenced by multiSelect(), selectInnerLoop(), and sqlite3Select().

◆ SRT_Exists

#define SRT_Exists 3 /* Store 1 if the result is not empty */

Definition at line 18570 of file sqlite3.c.

Referenced by generateOutputSubroutine(), selectInnerLoop(), sqlite3CodeSubselect(), and sqlite3Select().

◆ SRT_Fifo

#define SRT_Fifo 5 /* Store result as data with an automatic rowid */

Definition at line 18572 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), selectInnerLoop(), and sqlite3Select().

◆ SRT_Mem

#define SRT_Mem 10 /* Store result in a memory cell */

Definition at line 18581 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), and sqlite3CodeSubselect().

◆ SRT_Output

#define SRT_Output 9 /* Output each row of result */

Definition at line 18580 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3Select(), and yy_reduce().

◆ SRT_Queue

#define SRT_Queue 7 /* Store result in an queue */

Definition at line 18574 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), selectInnerLoop(), and sqlite3Select().

◆ SRT_Set

#define SRT_Set 11 /* Store results as keys in an index */

Definition at line 18582 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), and sqlite3CodeRhsOfIN().

◆ SRT_Table

#define SRT_Table 14 /* Store result as data with an automatic rowid */

Definition at line 18585 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), multiSelect(), selectInnerLoop(), and updateFromSelect().

◆ SRT_Union

#define SRT_Union 1 /* Store result as keys in an index */

Definition at line 18568 of file sqlite3.c.

Referenced by multiSelect(), selectInnerLoop(), and sqlite3Select().

◆ SRT_Upfrom

#define SRT_Upfrom 15 /* Store result as data with rowid */

Definition at line 18586 of file sqlite3.c.

Referenced by generateSortTail(), selectInnerLoop(), and updateFromSelect().

◆ SRVAL

#define SRVAL ( p ) ((void*)((SorterRecord*)(p) + 1))

Definition at line 94334 of file sqlite3.c.

Referenced by vdbeSorterListToPMA().

◆ STAT_GET_NDLT

#define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */

Definition at line 108336 of file sqlite3.c.

Referenced by analyzeOneTable(), and statGet().

◆ STAT_GET_NEQ

#define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */

Definition at line 108334 of file sqlite3.c.

Referenced by analyzeOneTable(), and statGet().

◆ STAT_GET_NLT

#define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */

Definition at line 108335 of file sqlite3.c.

Referenced by analyzeOneTable(), and statGet().

◆ STAT_GET_ROWID

#define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */

Definition at line 108333 of file sqlite3.c.

Referenced by analyzeOneTable(), and statGet().

◆ STAT_GET_STAT1

#define STAT_GET_STAT1 0 /* "stat" column of stat1 table */

Definition at line 108332 of file sqlite3.c.

Referenced by analyzeOneTable(), and statGet().

◆ STR_FUNCTION

#define STR_FUNCTION	(	zName,
		nArg,
		pArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

pArg, 0, xFunc, 0, 0, 0, #zName, }

Definition at line 17264 of file sqlite3.c.

#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
  {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterDateTimeFunctions().

◆ SWAP

#define SWAP	(	TYPE,
		A,
		B ) {TYPE t=A; A=B; B=t;}

Definition at line 14272 of file sqlite3.c.

Referenced by exprAnalyze(), havingToWhereExprCb(), isAuxiliaryVtabOperator(), and whereRangeScanEst().

◆ swapMixedEndianFloat

#define swapMixedEndianFloat ( X )

Definition at line 81517 of file sqlite3.c.

Referenced by serialGet(), and sqlite3VdbeSerialPut().

◆ TERM_ANDINFO

#define TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */

Definition at line 141196 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm(), and sqlite3WhereClauseClear().

◆ TERM_CODED

#define TERM_CODED 0x0004 /* This term is already coded */

Definition at line 141193 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), disableTerm(), exprAnalyze(), sqlite3WhereBegin(), and whereApplyPartialIndexConstraints().

◆ TERM_COPIED

#define TERM_COPIED 0x0008 /* Has a child */

Definition at line 141194 of file sqlite3.c.

Referenced by exprAnalyze(), and exprAnalyzeOrTerm().

◆ TERM_DYNAMIC

#define TERM_DYNAMIC 0x0001 /* Need to call sqlite3ExprDelete(db, pExpr) */

Definition at line 141191 of file sqlite3.c.

Referenced by exprAnalyze(), exprAnalyzeOrTerm(), sqlite3WhereClauseClear(), sqlite3WhereTabFuncArgs(), whereClauseInsert(), and whereCombineDisjuncts().

◆ TERM_HEURTRUTH

#define TERM_HEURTRUTH 0x2000 /* Heuristic truthProb used */

Definition at line 141208 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex(), and whereLoopOutputAdjust().

◆ TERM_HIGHTRUTH

#define TERM_HIGHTRUTH 0 /* Only used with STAT4 */

Definition at line 141212 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex(), and whereLoopOutputAdjust().

◆ TERM_IS

#define TERM_IS 0x0800 /* Term.pExpr is an IS operator */

Definition at line 141206 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), and exprAnalyze().

◆ TERM_LIKE

#define TERM_LIKE 0x0400 /* The original LIKE operator */

Definition at line 141205 of file sqlite3.c.

Referenced by disableTerm(), and exprAnalyze().

◆ TERM_LIKECOND

#define TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */

Definition at line 141204 of file sqlite3.c.

Referenced by disableTerm().

◆ TERM_LIKEOPT

#define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */

Definition at line 141203 of file sqlite3.c.

Referenced by exprAnalyze(), whereLikeOptimizationStringFixup(), and whereLoopAddBtreeIndex().

◆ TERM_OR_OK

#define TERM_OR_OK 0x0040 /* Used during OR-clause processing */

Definition at line 141197 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm().

◆ TERM_ORINFO

#define TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */

Definition at line 141195 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm(), and sqlite3WhereClauseClear().

◆ TERM_VARSELECT

#define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */

Definition at line 141207 of file sqlite3.c.

Referenced by exprAnalyze().

◆ TERM_VIRTUAL

#define TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */

Definition at line 141192 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), constructAutomaticIndex(), exprAnalyze(), exprAnalyzeOrTerm(), sqlite3WhereBegin(), whereClauseInsert(), whereCombineDisjuncts(), and whereLoopOutputAdjust().

◆ TERM_VNULL

#define TERM_VNULL 0x0000 /* Disabled if not using stat4 */

Definition at line 141201 of file sqlite3.c.

Referenced by allocateIndexInfo(), exprAnalyze(), whereLoopAddBtreeIndex(), whereRangeAdjust(), and whereRangeScanEst().

◆ TEST_FUNC

#define TEST_FUNC	(	zName,
		nArg,
		iArg,
		mFlags )

Value:

  {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
         SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
   SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }

Definition at line 17251 of file sqlite3.c.

#define INLINE_FUNC(zName, nArg, iArg, mFlags) \
  {nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
   SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
#define TEST_FUNC(zName, nArg, iArg, mFlags) \

Referenced by sqlite3RegisterBuiltinFunctions().

◆ TESTBIT

#define TESTBIT	(		V,
			I ) (V[I>>3]&(1<<(I&7)))!=0

Definition at line 48764 of file sqlite3.c.

Referenced by sqlite3BitvecBuiltinTest().

◆ testcase

#define testcase ( X )

Definition at line 13686 of file sqlite3.c.

Referenced by addToSavepointBitvecs(), allocateBtreePage(), allocateIndexInfo(), allocateSpace(), analyzeAggregate(), applyAffinity(), balance_nonroot(), blobSeekToRow(), btreeInitPage(), btreeParseCellAdjustSizeForOverflow(), cellSizePtr(), codeAllEqualityTerms(), codeDeferredSeek(), codeEqualityTerm(), codeVectorCompare(), compare2pow63(), constructAutomaticIndex(), contextMalloc(), convertToWithoutRowidTable(), createTableStmt(), defragmentPage(), dropCell(), exprAnalyze(), exprAnalyzeOrTerm(), exprCodeBetween(), exprNodeIsConstant(), fillInCell(), fkActionTrigger(), flattenSubquery(), generateOutputSubroutine(), generateSortTail(), getAndInitPage(), getPageNormal(), impliesNotNullRow(), isAuxiliaryVtabOperator(), isCandidateForInOpt(), isDupColumn(), keywordCode(), likeFunc(), lookupName(), moveToParent(), multiSelect(), numericType(), openDatabase(), pageFindSlot(), pager_playback(), pager_playback_one_page(), pager_truncate(), pagerOpenWalIfPresent(), pagerStress(), propagateConstantExprRewrite(), ptrmapPutOvflPtr(), readJournalHdr(), rebuildPage(), recomputeColumnsNotIndexed(), replaceFunc(), resolveExprStep(), saveCursorsOnList(), selectExpander(), selectInnerLoop(), serialGet(), sqlite3_aggregate_context(), sqlite3_str_vappendf(), sqlite3AddDefaultValue(), sqlite3AddInt64(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3AuthCheck(), sqlite3BtreeConnectionCount(), sqlite3BtreeInsert(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeMovetoUnpacked(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3ColumnsFromExprList(), sqlite3ComputeGeneratedColumns(), sqlite3CreateFunc(), sqlite3CreateIndex(), sqlite3DbMallocZero(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprAssignVarNumber(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprReferencesUpdatedColumn(), sqlite3FindInIndex(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3GetInt32(), sqlite3GetToken(), sqlite3Insert(), sqlite3JoinType(), sqlite3MemCompare(), sqlite3MemMalloc(), sqlite3MemRealloc(), sqlite3PagerDontWrite(), sqlite3PagerOpen(), sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), sqlite3SafetyCheckOk(), sqlite3Select(), sqlite3StrAccumEnlarge(), sqlite3TriggerInsertStep(), sqlite3UnlinkAndDeleteTable(), sqlite3Update(), sqlite3VdbeDeleteAuxData(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeFindCompare(), sqlite3VdbeIdxRowid(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemGrow(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemSetStr(), sqlite3VdbeRecordCompareWithSkip(), sqlite3WalBeginReadTransaction(), sqlite3WalCheckpoint(), sqlite3WalReadFrame(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereFindTerm(), strftimeFunc(), substExpr(), termCanDriveIndex(), updateAccumulator(), valueFromExpr(), vdbeMemClearExternAndSetNull(), vdbePmaReaderSeek(), vdbeRecordCompareInt(), vdbeRecordDecodeInt(), vdbeSorterMapFile(), walCheckpoint(), walCleanupHash(), walIndexPageRealloc(), walIndexReadHdr(), walIndexRecover(), walIndexTryHdr(), walkExpr(), walRestartLog(), whereClauseInsert(), whereIndexExprTransNode(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopAddOr(), whereLoopAddVirtualOne(), whereLoopOutputAdjust(), wherePathSatisfiesOrderBy(), wherePathSolver(), whereRangeScanEst(), whereRangeVectorLen(), whereScanNext(), whereShortCut(), windowCodeRangeTest(), xferOptimization(), and yy_reduce().

◆ TESTONLY

#define TESTONLY ( X )

Definition at line 13697 of file sqlite3.c.

Referenced by deleteTable(), flattenSubquery(), getPageNormal(), pcache1TruncateUnsafe(), sqlite3InitCallback(), and sqlite3PagerUnrefNotNull().

◆ TF_Autoincrement

#define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */

Definition at line 17538 of file sqlite3.c.

Referenced by autoIncBegin(), sqlite3_table_column_metadata(), sqlite3AddPrimaryKey(), sqlite3EndTable(), and xferOptimization().

◆ TF_Ephemeral

#define TF_Ephemeral 0x0002 /* An ephemeral table */

Definition at line 17536 of file sqlite3.c.

Referenced by deleteTable(), selectAddSubqueryTypeInfo(), sqlite3ExpandSubquery(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WindowRewrite(), whereLoopAddBtree(), and withExpand().

◆ TF_HasGenerated

#define TF_HasGenerated 0x0060 /* Combo: HasVirtual + HasStored */

Definition at line 17542 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Update(), and sqlite3WhereBegin().

◆ TF_HasNotNull

#define TF_HasNotNull 0x0800 /* Contains NOT NULL constraints */

Definition at line 17547 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), sqlite3AddNotNull(), and sqlite3GenerateConstraintChecks().

◆ TF_HasPrimaryKey

#define TF_HasPrimaryKey 0x0004 /* Table has a primary key */

Definition at line 17537 of file sqlite3.c.

Referenced by sqlite3AddPrimaryKey(), and sqlite3EndTable().

◆ TF_HasStat1

#define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */

Definition at line 17539 of file sqlite3.c.

Referenced by analysisLoader().

◆ TF_HasStored

#define TF_HasStored 0x0040 /* Has one or more STORED columns */

Definition at line 17541 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3Insert(), and sqlite3Update().

◆ TF_HasVirtual

#define TF_HasVirtual 0x0020 /* Has one or more VIRTUAL columns */

Definition at line 17540 of file sqlite3.c.

Referenced by sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3Insert(), sqlite3StorageColumnToTable(), sqlite3TableColumnToStorage(), and sqlite3Update().

◆ TF_NoVisibleRowid

#define TF_NoVisibleRowid 0x0200 /* No user-visible "rowid" column */

Definition at line 17545 of file sqlite3.c.

Referenced by sqlite3_declare_vtab(), sqlite3EndTable(), withExpand(), and yy_reduce().

◆ TF_OOOHidden

#define TF_OOOHidden 0x0400 /* Out-of-Order hidden columns */

Definition at line 17546 of file sqlite3.c.

Referenced by sqlite3Insert(), and vtabCallConstructor().

◆ TF_Readonly

#define TF_Readonly 0x0001 /* Read-only system table */

Definition at line 17535 of file sqlite3.c.

Referenced by sqlite3EndTable(), and tabIsReadOnly().

◆ TF_Shadow

#define TF_Shadow 0x1000 /* True for a shadow table */

Definition at line 17548 of file sqlite3.c.

Referenced by isAlterableTable(), sqlite3EndTable(), and tabIsReadOnly().

◆ TF_StatsUsed

#define TF_StatsUsed

Value:

0x0100 /* Query planner decisions affected by

** Index.aiRowLogEst[] values */

Definition at line 17544 of file sqlite3.c.

Referenced by sqlite3Pragma(), and whereLoopAddBtree().

◆ TF_WithoutRowid

#define TF_WithoutRowid 0x0080 /* No rowid. PRIMARY KEY is the key */

Definition at line 17543 of file sqlite3.c.

Referenced by isDupColumn(), sqlite3_declare_vtab(), sqlite3EndTable(), sqlite3WhereBegin(), and yy_reduce().

◆ threadid

#define threadid pthread_self()

Definition at line 33865 of file sqlite3.c.

Referenced by mg_join_thread().

◆ THREE_BYTE_INT

#define THREE_BYTE_INT ( x ) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])

Definition at line 81574 of file sqlite3.c.

Referenced by vdbeRecordCompareInt(), and vdbeRecordDecodeInt().

◆ TIMER_ELAPSED

#define TIMER_ELAPSED ((sqlite_uint64)0)

Definition at line 33785 of file sqlite3.c.

Referenced by seekAndRead(), and seekAndWriteFd().

◆ TIMER_END

#define TIMER_END

Definition at line 33784 of file sqlite3.c.

Referenced by seekAndRead(), and seekAndWriteFd().

◆ TIMER_START

#define TIMER_START

Definition at line 33783 of file sqlite3.c.

Referenced by seekAndRead(), and seekAndWriteFd().

◆ TK_ABORT

#define TK_ABORT 27

Definition at line 13969 of file sqlite3.c.

◆ TK_ACTION

#define TK_ACTION 28

Definition at line 13970 of file sqlite3.c.

◆ TK_ADD

#define TK_ADD 160

Definition at line 14102 of file sqlite3.c.

◆ TK_AFTER

#define TK_AFTER 29

Definition at line 13971 of file sqlite3.c.

◆ TK_AGG_COLUMN

#define TK_AGG_COLUMN 166

Definition at line 14108 of file sqlite3.c.

Referenced by agginfoPersistExprCb(), analyzeAggregate(), exprNodeIsConstant(), generateColumnNames(), impliesNotNullRow(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), and sqlite3ExprCompare().

◆ TK_AGG_FUNCTION

#define TK_AGG_FUNCTION 165

Definition at line 14107 of file sqlite3.c.

Referenced by agginfoPersistExprCb(), analyzeAggregate(), exprNodeIsConstant(), impliesNotNullRow(), incrAggFunctionDepth(), isSimpleCount(), minMaxQuery(), resolveExprStep(), selectWindowRewriteExprCb(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3FunctionUsesThisSrc(), sqlite3WhereExprUsageNN(), and sqlite3WindowExtraAggFuncDepth().

◆ TK_ALL

#define TK_ALL 133

Definition at line 14075 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery(), flattenSubquery(), multiSelect(), multiSelectOrderBy(), multiSelectValues(), withExpand(), and yy_reduce().

◆ TK_ALTER

#define TK_ALTER 159

Definition at line 14101 of file sqlite3.c.

◆ TK_ALWAYS

#define TK_ALWAYS 96

Definition at line 14038 of file sqlite3.c.

◆ TK_ANALYZE

#define TK_ANALYZE 30

Definition at line 13972 of file sqlite3.c.

◆ TK_AND

#define TK_AND 44

◆ TK_ANY

#define TK_ANY 100

Definition at line 14042 of file sqlite3.c.

◆ TK_AS

#define TK_AS 24

Definition at line 13966 of file sqlite3.c.

Referenced by exprAnalyze().

◆ TK_ASC

#define TK_ASC 31

Definition at line 13973 of file sqlite3.c.

◆ TK_ASTERISK

#define TK_ASTERISK 177

Definition at line 14119 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery(), selectExpander(), sqlite3SelectNew(), xferOptimization(), and yy_reduce().

◆ TK_ATTACH

#define TK_ATTACH 32

Definition at line 13974 of file sqlite3.c.

◆ TK_AUTOINCR

#define TK_AUTOINCR 124

Definition at line 14066 of file sqlite3.c.

◆ TK_BEFORE

#define TK_BEFORE 33

Definition at line 13975 of file sqlite3.c.

Referenced by sqlite3BeginTrigger(), and yy_reduce().

◆ TK_BEGIN

#define TK_BEGIN 5

Definition at line 13947 of file sqlite3.c.

◆ TK_BETWEEN

#define TK_BETWEEN 48

Definition at line 13990 of file sqlite3.c.

Referenced by exprAnalyze(), exprImpliesNotNull(), impliesNotNullRow(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and yy_reduce().

◆ TK_BITAND

#define TK_BITAND 101

Definition at line 14043 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_BITNOT

#define TK_BITNOT 112

Definition at line 14054 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_BITOR

#define TK_BITOR 102

Definition at line 14044 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_BLOB

#define TK_BLOB 151

Definition at line 14093 of file sqlite3.c.

Referenced by sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprNeedsNoAffinityChange(), sqlite3GetToken(), sqlite3RunParser(), and valueFromExpr().

◆ TK_BY

#define TK_BY 34

Definition at line 13976 of file sqlite3.c.

◆ TK_CASCADE

#define TK_CASCADE 35

Definition at line 13977 of file sqlite3.c.

◆ TK_CASE

#define TK_CASE 154

Definition at line 14096 of file sqlite3.c.

Referenced by impliesNotNullRow(), sqlite3ExprCodeTarget(), and yy_reduce().

◆ TK_CAST

#define TK_CAST 36

Definition at line 13978 of file sqlite3.c.

Referenced by sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), valueFromExpr(), and yy_reduce().

◆ TK_CHECK

#define TK_CHECK 122

Definition at line 14064 of file sqlite3.c.

◆ TK_COLLATE

#define TK_COLLATE 111

Definition at line 14053 of file sqlite3.c.

Referenced by exprAnalyze(), exprImpliesNotNull(), resolveAlias(), resolveCompoundOrderBy(), sqlite3CreateIndex(), sqlite3ExprAddCollateToken(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3ExprCompare(), sqlite3ExprSkipCollateAndLikely(), sqlite3StringToId(), sqlite3UpsertAnalyzeTarget(), and substExpr().

◆ TK_COLUMN

#define TK_COLUMN 164

Definition at line 14106 of file sqlite3.c.

Referenced by allocateIndexInfo(), analyzeAggregate(), checkConstraintExprNode(), columnTypeImpl(), constInsert(), exprAnalyze(), exprIdxCover(), exprNodeIsConstant(), findConstInWhere(), findIndexCol(), generateColumnNames(), impliesNotNullRow(), indexMightHelpWithOrderBy(), isAuxiliaryVtabOperator(), isCandidateForInOpt(), isDistinctRedundant(), isLikeOrGlob(), lookupName(), propagateConstantExprRewrite(), recomputeColumnsUsedExpr(), renameColumnExprCb(), resolveExprStep(), selectWindowRewriteExprCb(), sqlite3AuthRead(), sqlite3ColumnsFromExprList(), sqlite3CreateIndex(), sqlite3ExprAffinity(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3ExprCompare(), sqlite3ExprNeedsNoAffinityChange(), sqlite3UpsertAnalyzeTarget(), sqlite3VtabOverloadFunction(), sqlite3WhereExprUsageNN(), sqlite3WhereTabFuncArgs(), substExpr(), whereIndexExprTransNode(), wherePathSatisfiesOrderBy(), whereRangeVectorLen(), and whereScanNext().

◆ TK_COLUMNKW

#define TK_COLUMNKW 60

Definition at line 14002 of file sqlite3.c.

◆ TK_COMMA

#define TK_COMMA 26

Definition at line 13968 of file sqlite3.c.

Referenced by sqlite3GetToken().

◆ TK_COMMIT

#define TK_COMMIT 10

Definition at line 13952 of file sqlite3.c.

Referenced by sqlite3EndTransaction().

◆ TK_CONCAT

#define TK_CONCAT 110

Definition at line 14052 of file sqlite3.c.

Referenced by exprImpliesNotNull(), getbinopr(), getbinopr(), getbinopr(), getbinopr(), llex(), llex(), llex(), llex(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_CONFLICT

#define TK_CONFLICT 37

Definition at line 13979 of file sqlite3.c.

◆ TK_CONSTRAINT

#define TK_CONSTRAINT 117

Definition at line 14059 of file sqlite3.c.

◆ TK_CREATE

#define TK_CREATE 17

Definition at line 13959 of file sqlite3.c.

◆ TK_CTIME_KW

#define TK_CTIME_KW 99

Definition at line 14041 of file sqlite3.c.

◆ TK_CURRENT

#define TK_CURRENT 85

Definition at line 14027 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), sqlite3WindowUpdate(), windowFullScan(), and yy_reduce().

◆ TK_DATABASE

#define TK_DATABASE 38

Definition at line 13980 of file sqlite3.c.

◆ TK_DEFAULT

#define TK_DEFAULT 118

Definition at line 14060 of file sqlite3.c.

◆ TK_DEFERRABLE

#define TK_DEFERRABLE 129

Definition at line 14071 of file sqlite3.c.

◆ TK_DEFERRED

#define TK_DEFERRED 7

Definition at line 13949 of file sqlite3.c.

Referenced by yy_reduce().

◆ TK_DELETE

#define TK_DELETE 126

Definition at line 14068 of file sqlite3.c.

Referenced by fkActionTrigger(), lookupName(), sqlite3BeginTrigger(), sqlite3CodeRowTrigger(), sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3TriggerColmask(), and sqlite3TriggerDeleteStep().

◆ TK_DESC

#define TK_DESC 39

Definition at line 13981 of file sqlite3.c.

◆ TK_DETACH

#define TK_DETACH 40

Definition at line 13982 of file sqlite3.c.

◆ TK_DISTINCT

#define TK_DISTINCT 138

Definition at line 14080 of file sqlite3.c.

◆ TK_DO

#define TK_DO 61

Definition at line 14003 of file sqlite3.c.

Referenced by forbody(), forbody(), forbody(), forbody(), statement(), statement(), statement(), statement(), whilestat(), whilestat(), whilestat(), and whilestat().

◆ TK_DOT

#define TK_DOT 139

Definition at line 14081 of file sqlite3.c.

Referenced by exprNodeIsConstant(), fkActionTrigger(), resolveExprStep(), selectExpander(), sqlite3ColumnsFromExprList(), sqlite3GetToken(), and yy_reduce().

◆ TK_DROP

#define TK_DROP 131

Definition at line 14073 of file sqlite3.c.

◆ TK_EACH

#define TK_EACH 41

Definition at line 13983 of file sqlite3.c.

◆ TK_ELSE

#define TK_ELSE 157

Definition at line 14099 of file sqlite3.c.

Referenced by block_follow(), block_follow(), block_follow(), block_follow(), ifstat(), ifstat(), ifstat(), ifstat(), test_then_block(), test_then_block(), and test_then_block().

◆ TK_END

#define TK_END 11

Definition at line 13953 of file sqlite3.c.

Referenced by block_follow(), block_follow(), block_follow(), block_follow(), body(), body(), body(), body(), forstat(), forstat(), forstat(), forstat(), ifstat(), ifstat(), ifstat(), ifstat(), sqlite3EndTransaction(), statement(), statement(), statement(), statement(), whilestat(), whilestat(), whilestat(), and whilestat().

◆ TK_EQ

#define TK_EQ 53

◆ TK_ESCAPE

#define TK_ESCAPE 58

Definition at line 14000 of file sqlite3.c.

◆ TK_EXCEPT

#define TK_EXCEPT 134

Definition at line 14076 of file sqlite3.c.

Referenced by multiSelect(), and multiSelectOrderBy().

◆ TK_EXCLUDE

#define TK_EXCLUDE 91

Definition at line 14033 of file sqlite3.c.

◆ TK_EXCLUSIVE

#define TK_EXCLUSIVE 9

Definition at line 13951 of file sqlite3.c.

◆ TK_EXISTS

#define TK_EXISTS 20

Definition at line 13962 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3CodeSubselect(), sqlite3ExprCodeTarget(), and yy_reduce().

◆ TK_EXPLAIN

#define TK_EXPLAIN 2

Definition at line 13944 of file sqlite3.c.

◆ TK_FAIL

#define TK_FAIL 42

Definition at line 13984 of file sqlite3.c.

◆ TK_FILTER

#define TK_FILTER 163

Definition at line 14105 of file sqlite3.c.

Referenced by sqlite3RunParser(), and yy_reduce().

◆ TK_FIRST

#define TK_FIRST 83

Definition at line 14025 of file sqlite3.c.

◆ TK_FLOAT

#define TK_FLOAT 150

Definition at line 14092 of file sqlite3.c.

Referenced by exprProbability(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprNeedsNoAffinityChange(), sqlite3GetToken(), sqlite3RunParser(), and valueFromExpr().

◆ TK_FOLLOWING

#define TK_FOLLOWING 86

Definition at line 14028 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), sqlite3WindowUpdate(), and windowCodeOp().

◆ TK_FOR

#define TK_FOR 62

Definition at line 14004 of file sqlite3.c.

Referenced by forstat(), forstat(), forstat(), forstat(), statement(), statement(), statement(), and statement().

◆ TK_FOREIGN

#define TK_FOREIGN 130

Definition at line 14072 of file sqlite3.c.

◆ TK_FROM

#define TK_FROM 140

Definition at line 14082 of file sqlite3.c.

◆ TK_FUNCTION

#define TK_FUNCTION 169

◆ TK_GE

#define TK_GE 57

Definition at line 13999 of file sqlite3.c.

Referenced by allowedOp(), codeVectorCompare(), exprAnalyze(), exprCodeBetween(), exprImpliesNotNull(), getbinopr(), getbinopr(), getbinopr(), getbinopr(), impliesNotNullRow(), llex(), llex(), llex(), llex(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GetToken(), and whereCombineDisjuncts().

◆ TK_GENERATED

#define TK_GENERATED 95

Definition at line 14037 of file sqlite3.c.

◆ TK_GROUP

#define TK_GROUP 144

Definition at line 14086 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep().

◆ TK_GROUPS

#define TK_GROUPS 92

Definition at line 14034 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ TK_GT

#define TK_GT 54

Definition at line 13996 of file sqlite3.c.

Referenced by allowedOp(), codeVectorCompare(), exprAnalyze(), exprImpliesNotNull(), impliesNotNullRow(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3GetToken().

◆ TK_HAVING

#define TK_HAVING 145

Definition at line 14087 of file sqlite3.c.

◆ TK_ID

#define TK_ID 59

◆ TK_IF

#define TK_IF 18

Definition at line 13960 of file sqlite3.c.

Referenced by ifstat(), ifstat(), ifstat(), ifstat(), statement(), statement(), statement(), and statement().

◆ TK_IF_NULL_ROW

#define TK_IF_NULL_ROW 176

Definition at line 14118 of file sqlite3.c.

Referenced by exprNodeIsConstant(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprSkipCollateAndLikely(), sqlite3WhereExprUsageNN(), and substExpr().

◆ TK_IGNORE

#define TK_IGNORE 63

Definition at line 14005 of file sqlite3.c.

◆ TK_ILLEGAL

#define TK_ILLEGAL 180

Definition at line 14122 of file sqlite3.c.

Referenced by findNextHostParameter(), sqlite3GetToken(), and sqlite3RunParser().

◆ TK_IMMEDIATE

#define TK_IMMEDIATE 8

Definition at line 13950 of file sqlite3.c.

◆ TK_IN

#define TK_IN 49

Definition at line 13991 of file sqlite3.c.

Referenced by allowedOp(), codeEqualityTerm(), exprAnalyze(), exprAnalyzeOrTerm(), exprImpliesNotNull(), exprINAffinity(), forlist(), forlist(), forlist(), forlist(), forstat(), forstat(), forstat(), forstat(), impliesNotNullRow(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FindInIndex(), sqlite3RunParser(), and yy_reduce().

◆ TK_INDEX

#define TK_INDEX 158

Definition at line 14100 of file sqlite3.c.

◆ TK_INDEXED

#define TK_INDEXED 114

Definition at line 14056 of file sqlite3.c.

◆ TK_INITIALLY

#define TK_INITIALLY 64

Definition at line 14006 of file sqlite3.c.

◆ TK_INSERT

#define TK_INSERT 125

Definition at line 14067 of file sqlite3.c.

Referenced by lookupName(), sqlite3BeginTrigger(), sqlite3CodeRowTrigger(), sqlite3Insert(), and sqlite3TriggerInsertStep().

◆ TK_INSTEAD

#define TK_INSTEAD 65

Definition at line 14007 of file sqlite3.c.

Referenced by sqlite3BeginTrigger(), and yy_reduce().

◆ TK_INTEGER

#define TK_INTEGER 152

Definition at line 14094 of file sqlite3.c.

Referenced by havingToWhereExprCb(), multiSelectOrderBy(), resolveCompoundOrderBy(), sqlite3CodeSubselect(), sqlite3ExprAlloc(), sqlite3ExprAnd(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprIsInteger(), sqlite3ExprNeedsNoAffinityChange(), sqlite3GetToken(), sqlite3RunParser(), sqlite3WindowRewrite(), sqlite3WindowUpdate(), valueFromExpr(), and yy_reduce().

◆ TK_INTERSECT

#define TK_INTERSECT 135

Definition at line 14077 of file sqlite3.c.

Referenced by multiSelect(), and multiSelectOrderBy().

◆ TK_INTO

#define TK_INTO 148

Definition at line 14090 of file sqlite3.c.

◆ TK_IS

#define TK_IS 45

◆ TK_ISNOT

#define TK_ISNOT 168

Definition at line 14110 of file sqlite3.c.

Referenced by codeVectorCompare(), impliesNotNullRow(), isAuxiliaryVtabOperator(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and yy_reduce().

◆ TK_ISNULL

#define TK_ISNULL 50

Definition at line 13992 of file sqlite3.c.

Referenced by allowedOp(), codeEqualityTerm(), exprAnalyze(), impliesNotNullRow(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and yy_reduce().

◆ TK_JOIN

#define TK_JOIN 141

Definition at line 14083 of file sqlite3.c.

◆ TK_JOIN_KW

#define TK_JOIN_KW 116

Definition at line 14058 of file sqlite3.c.

Referenced by getToken().

◆ TK_KEY

#define TK_KEY 67

Definition at line 14009 of file sqlite3.c.

◆ TK_LAST

#define TK_LAST 84

Definition at line 14026 of file sqlite3.c.

◆ TK_LE

#define TK_LE 55

Definition at line 13997 of file sqlite3.c.

Referenced by allowedOp(), codeVectorCompare(), exprAnalyze(), exprCodeBetween(), exprImpliesNotNull(), getbinopr(), getbinopr(), getbinopr(), getbinopr(), impliesNotNullRow(), llex(), llex(), llex(), llex(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3GetToken().

◆ TK_LIKE_KW

#define TK_LIKE_KW 47

Definition at line 13989 of file sqlite3.c.

◆ TK_LIMIT

#define TK_LIMIT 146

Definition at line 14088 of file sqlite3.c.

Referenced by computeLimitRegisters(), sqlite3CodeSubselect(), and yy_reduce().

◆ TK_LP

#define TK_LP 22

Definition at line 13964 of file sqlite3.c.

Referenced by analyzeFilterKeyword(), sqlite3GetToken(), and sqlite3RunParser().

◆ TK_LSHIFT

#define TK_LSHIFT 103

Definition at line 14045 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_LT

#define TK_LT 56

Definition at line 13998 of file sqlite3.c.

Referenced by allowedOp(), codeVectorCompare(), exprAnalyze(), exprImpliesNotNull(), impliesNotNullRow(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3GetToken().

◆ TK_MATCH

#define TK_MATCH 46

Definition at line 13988 of file sqlite3.c.

Referenced by exprAnalyze().

◆ TK_MINUS

#define TK_MINUS 106

Definition at line 14048 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_NE

#define TK_NE 52

Definition at line 13994 of file sqlite3.c.

Referenced by codeVectorCompare(), exprImpliesNotNull(), fkScanChildren(), getbinopr(), getbinopr(), getbinopr(), getbinopr(), impliesNotNullRow(), isAuxiliaryVtabOperator(), llex(), llex(), llex(), llex(), resolveExprStep(), sqlite3CodeSubselect(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3GetToken().

◆ TK_NO

#define TK_NO 66

Definition at line 14008 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowFullScan().

◆ TK_NOT

#define TK_NOT 19

Definition at line 13961 of file sqlite3.c.

Referenced by exprImpliesNotNull(), fkActionTrigger(), fkScanChildren(), getunopr(), getunopr(), getunopr(), getunopr(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3RunParser(), and yy_reduce().

◆ TK_NOTHING

#define TK_NOTHING 149

Definition at line 14091 of file sqlite3.c.

◆ TK_NOTNULL

#define TK_NOTNULL 51

Definition at line 13993 of file sqlite3.c.

Referenced by exprAnalyze(), impliesNotNullRow(), isAuxiliaryVtabOperator(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprImpliesExpr(), sqlite3ExprImpliesNonNullRow(), and yy_reduce().

◆ TK_NULL

#define TK_NULL 119

Definition at line 14061 of file sqlite3.c.

Referenced by exprAnalyze(), exprImpliesNotNull(), exprNodeIsConstant(), fkActionTrigger(), resolveExprStep(), sqlite3AlterFinishAddColumn(), sqlite3AuthRead(), sqlite3EndTable(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3Insert(), sqlite3RunParser(), sqlite3WindowOffsetExpr(), substExpr(), and valueFromExpr().

◆ TK_NULLS

#define TK_NULLS 82

Definition at line 14024 of file sqlite3.c.

◆ TK_OF

#define TK_OF 68

Definition at line 14010 of file sqlite3.c.

◆ TK_OFFSET

#define TK_OFFSET 69

Definition at line 14011 of file sqlite3.c.

◆ TK_ON

#define TK_ON 113

Definition at line 14055 of file sqlite3.c.

◆ TK_OR

#define TK_OR 43

Definition at line 13985 of file sqlite3.c.

Referenced by exprAnalyze(), exprAnalyzeOrTerm(), getbinopr(), getbinopr(), getbinopr(), getbinopr(), impliesNotNullRow(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprImpliesExpr(), and sqlite3ExprSimplifiedAndOr().

◆ TK_ORDER

#define TK_ORDER 143

Definition at line 14085 of file sqlite3.c.

◆ TK_OTHERS

#define TK_OTHERS 93

Definition at line 14035 of file sqlite3.c.

◆ TK_OVER

#define TK_OVER 162

Definition at line 14104 of file sqlite3.c.

Referenced by analyzeFilterKeyword(), getToken(), and sqlite3RunParser().

◆ TK_PARTITION

#define TK_PARTITION 87

Definition at line 14029 of file sqlite3.c.

◆ TK_PLAN

#define TK_PLAN 4

Definition at line 13946 of file sqlite3.c.

◆ TK_PLUS

#define TK_PLUS 105

Definition at line 14047 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), sqlite3GetToken(), and yy_reduce().

◆ TK_PRAGMA

#define TK_PRAGMA 70

Definition at line 14012 of file sqlite3.c.

◆ TK_PRECEDING

#define TK_PRECEDING 88

Definition at line 14030 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ TK_PRIMARY

#define TK_PRIMARY 120

Definition at line 14062 of file sqlite3.c.

◆ TK_QUERY

#define TK_QUERY 3

Definition at line 13945 of file sqlite3.c.

◆ TK_RAISE

#define TK_RAISE 71

Definition at line 14013 of file sqlite3.c.

Referenced by fkActionTrigger(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), and yy_reduce().

◆ TK_RANGE

#define TK_RANGE 89

Definition at line 14031 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), sqlite3WindowUpdate(), and windowCodeOp().

◆ TK_RECURSIVE

#define TK_RECURSIVE 72

Definition at line 14014 of file sqlite3.c.

◆ TK_REFERENCES

#define TK_REFERENCES 123

Definition at line 14065 of file sqlite3.c.

◆ TK_REGISTER

#define TK_REGISTER 173

Definition at line 14115 of file sqlite3.c.

Referenced by exprNodeIsConstant(), exprTableRegister(), exprToRegister(), exprVectorRegister(), isLikeOrGlob(), lookupName(), sqlite3ExprAffinity(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprCodeTemp(), sqlite3ExprCollSeq(), sqlite3ExprNeedsNoAffinityChange(), sqlite3ExprVectorSize(), sqlite3VectorFieldSubexpr(), valueFromExpr(), and yy_reduce().

◆ TK_REINDEX

#define TK_REINDEX 97

Definition at line 14039 of file sqlite3.c.

◆ TK_RELEASE

#define TK_RELEASE 14

Definition at line 13956 of file sqlite3.c.

◆ TK_REM

#define TK_REM 109

Definition at line 14051 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_RENAME

#define TK_RENAME 98

Definition at line 14040 of file sqlite3.c.

◆ TK_REPLACE

#define TK_REPLACE 73

Definition at line 14015 of file sqlite3.c.

◆ TK_RESTRICT

#define TK_RESTRICT 74

Definition at line 14016 of file sqlite3.c.

◆ TK_ROLLBACK

#define TK_ROLLBACK 12

Definition at line 13954 of file sqlite3.c.

Referenced by sqlite3EndTransaction().

◆ TK_ROW

#define TK_ROW 75

Definition at line 14017 of file sqlite3.c.

Referenced by exprRowColumn(), resolveExprStep(), updateFromSelect(), and updateVirtualTable().

◆ TK_ROWS

#define TK_ROWS 76

Definition at line 14018 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), sqlite3WindowUpdate(), and windowCodeOp().

◆ TK_RP

#define TK_RP 23

Definition at line 13965 of file sqlite3.c.

Referenced by sqlite3GetToken(), and sqlite3RunParser().

◆ TK_RSHIFT

#define TK_RSHIFT 104

Definition at line 14046 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_SAVEPOINT

#define TK_SAVEPOINT 13

Definition at line 13955 of file sqlite3.c.

◆ TK_SELECT

#define TK_SELECT 136

◆ TK_SELECT_COLUMN

#define TK_SELECT_COLUMN 175

Definition at line 14117 of file sqlite3.c.

Referenced by dupedExprStructSize(), exprDup(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprForVectorField(), and sqlite3ExprListAppendVector().

◆ TK_SEMI

#define TK_SEMI 1

Definition at line 13943 of file sqlite3.c.

Referenced by sqlite3GetToken(), and sqlite3RunParser().

◆ TK_SET

#define TK_SET 128

Definition at line 14070 of file sqlite3.c.

◆ TK_SLASH

#define TK_SLASH 108

Definition at line 14050 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_SPACE

#define TK_SPACE 179

Definition at line 14121 of file sqlite3.c.

Referenced by getToken(), sqlite3GetToken(), and sqlite3RunParser().

◆ TK_SPAN

#define TK_SPAN 178

Definition at line 14120 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3AddDefaultValue(), sqlite3AlterFinishAddColumn(), sqlite3ExprCodeTarget(), sqlite3Pragma(), valueFromExpr(), and xferOptimization().

◆ TK_STAR

#define TK_STAR 107

Definition at line 14049 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCodeTarget(), and sqlite3GetToken().

◆ TK_STRING

#define TK_STRING 115

◆ TK_TABLE

#define TK_TABLE 16

Definition at line 13958 of file sqlite3.c.

◆ TK_TEMP

#define TK_TEMP 21

Definition at line 13963 of file sqlite3.c.

◆ TK_THEN

#define TK_THEN 156

Definition at line 14098 of file sqlite3.c.

Referenced by test_then_block(), test_then_block(), test_then_block(), and test_then_block().

◆ TK_TIES

#define TK_TIES 94

Definition at line 14036 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowFullScan().

◆ TK_TO

#define TK_TO 15

Definition at line 13957 of file sqlite3.c.

◆ TK_TRANSACTION

#define TK_TRANSACTION 6

Definition at line 13948 of file sqlite3.c.

◆ TK_TRIGGER

#define TK_TRIGGER 77

Definition at line 14019 of file sqlite3.c.

Referenced by lookupName(), renameColumnExprCb(), sqlite3AuthRead(), sqlite3ExprCodeTarget(), and sqlite3ExprCollSeq().

◆ TK_TRUEFALSE

#define TK_TRUEFALSE 167

Definition at line 14109 of file sqlite3.c.

Referenced by resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprIdToTrueFalse(), valueFromExpr(), and yy_reduce().

◆ TK_TRUTH

#define TK_TRUTH 172

Definition at line 14114 of file sqlite3.c.

Referenced by exprImpliesNotNull(), impliesNotNullRow(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ TK_UMINUS

#define TK_UMINUS 170

Definition at line 14112 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprIsInteger(), sqlite3ExprNeedsNoAffinityChange(), valueFromExpr(), and yy_reduce().

◆ TK_UNBOUNDED

#define TK_UNBOUNDED 90

Definition at line 14032 of file sqlite3.c.

Referenced by sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), sqlite3WindowUpdate(), windowAggFinal(), windowAggStep(), windowCodeOp(), windowInitAccum(), and yy_reduce().

◆ TK_UNION

#define TK_UNION 132

Definition at line 14074 of file sqlite3.c.

Referenced by generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), and withExpand().

◆ TK_UNIQUE

#define TK_UNIQUE 121

Definition at line 14063 of file sqlite3.c.

◆ TK_UPDATE

#define TK_UPDATE 127

Definition at line 14069 of file sqlite3.c.

Referenced by fkActionTrigger(), lookupName(), sqlite3BeginTrigger(), sqlite3CodeRowTrigger(), sqlite3TriggerColmask(), sqlite3TriggerUpdateStep(), sqlite3Update(), and yy_reduce().

◆ TK_UPLUS

#define TK_UPLUS 171

Definition at line 14113 of file sqlite3.c.

Referenced by exprImpliesNotNull(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3ExprIsInteger(), sqlite3ExprNeedsNoAffinityChange(), sqlite3WhereTabFuncArgs(), valueFromExpr(), and yy_reduce().

◆ TK_USING

#define TK_USING 142

Definition at line 14084 of file sqlite3.c.

◆ TK_VACUUM

#define TK_VACUUM 78

Definition at line 14020 of file sqlite3.c.

◆ TK_VALUES

#define TK_VALUES 137

Definition at line 14079 of file sqlite3.c.

◆ TK_VARIABLE

#define TK_VARIABLE 153

Definition at line 14095 of file sqlite3.c.

Referenced by exprNodeIsConstant(), findNextHostParameter(), isLikeOrGlob(), resolveExprStep(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3GetToken(), sqlite3RunParser(), and yy_reduce().

◆ TK_VECTOR

#define TK_VECTOR 174

Definition at line 14116 of file sqlite3.c.

Referenced by exprAnalyze(), exprVectorRegister(), impliesNotNullRow(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprCollSeq(), sqlite3ExprForVectorField(), sqlite3ExprVectorSize(), and yy_reduce().

◆ TK_VIEW

#define TK_VIEW 79

Definition at line 14021 of file sqlite3.c.

◆ TK_VIRTUAL

#define TK_VIRTUAL 80

Definition at line 14022 of file sqlite3.c.

◆ TK_WHEN

#define TK_WHEN 155

Definition at line 14097 of file sqlite3.c.

◆ TK_WHERE

#define TK_WHERE 147

Definition at line 14089 of file sqlite3.c.

◆ TK_WINDOW

#define TK_WINDOW 161

Definition at line 14103 of file sqlite3.c.

Referenced by getToken(), and sqlite3RunParser().

◆ TK_WITH

#define TK_WITH 81

Definition at line 14023 of file sqlite3.c.

◆ TK_WITHOUT

#define TK_WITHOUT 25

Definition at line 13967 of file sqlite3.c.

◆ tkCREATE

#define tkCREATE 4

Definition at line 160651 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkEND

#define tkEND 7

Definition at line 160654 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkEXPLAIN

#define tkEXPLAIN 3

Definition at line 160650 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkOTHER

#define tkOTHER 2

Definition at line 160648 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkSEMI

#define tkSEMI 0

Definition at line 160646 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkTEMP

#define tkTEMP 5

Definition at line 160652 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkTRIGGER

#define tkTRIGGER 6

Definition at line 160653 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ tkWS

#define tkWS 1

Definition at line 160647 of file sqlite3.c.

Referenced by sqlite3_complete().

◆ TOKEN

#define TOKEN yyminor

◆ TRACE

#define TRACE ( X )

Definition at line 64509 of file sqlite3.c.

Referenced by allocateBtreePage(), balance_deeper(), balance_nonroot(), freePage2(), ptrmapPut(), relocatePage(), and sqlite3BtreeInsert().

◆ TRANS_NONE

#define TRANS_NONE 0

Definition at line 63837 of file sqlite3.c.

Referenced by btreeCursor(), sqlite3BtreeBeginTrans(), sqlite3BtreeCheckpoint(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeGetMeta(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeIsInBackup(), sqlite3BtreeLockTable(), sqlite3BtreeOpen(), and unlockBtreeIfUnused().

◆ TRANS_READ

#define TRANS_READ 1

Definition at line 63838 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), sqlite3BtreeCommitPhaseTwo(), and sqlite3BtreeRollback().

◆ TRANS_WRITE

#define TRANS_WRITE 2

Definition at line 63839 of file sqlite3.c.

Referenced by btreeCreateTable(), btreeCursor(), btreeDropTable(), querySharedCacheTableLock(), sqlite3BtreeBeginStmt(), sqlite3BtreeBeginTrans(), sqlite3BtreeClearTable(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeDelete(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreePutData(), sqlite3BtreeRollback(), and sqlite3BtreeSavepoint().

◆ TRIGGER_AFTER

#define TRIGGER_AFTER 2

Definition at line 18893 of file sqlite3.c.

Referenced by sqlite3BeginTrigger(), sqlite3CodeRowTrigger(), sqlite3GenerateRowDelete(), sqlite3Insert(), and sqlite3Update().

◆ TRIGGER_BEFORE

#define TRIGGER_BEFORE 1

Definition at line 18892 of file sqlite3.c.

Referenced by sqlite3BeginTrigger(), sqlite3CodeRowTrigger(), sqlite3GenerateRowDelete(), sqlite3Insert(), and sqlite3Update().

◆ TWO_BYTE_INT

#define TWO_BYTE_INT ( x ) (256*(i8)((x)[0])|(x)[1])

Definition at line 81573 of file sqlite3.c.

Referenced by vdbeRecordCompareInt(), and vdbeRecordDecodeInt().

◆ UINT16_TYPE

#define UINT16_TYPE unsigned short int

Definition at line 14302 of file sqlite3.c.

◆ UINT32_TYPE

#define UINT32_TYPE unsigned int

Definition at line 14295 of file sqlite3.c.

◆ UINT8_TYPE

#define UINT8_TYPE unsigned char

Definition at line 14316 of file sqlite3.c.

◆ UNIX_SHM_BASE

#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */

Definition at line 37831 of file sqlite3.c.

Referenced by sqlite3WalOpen(), and unixShmLock().

◆ UNIX_SHM_DMS

#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */

Definition at line 37832 of file sqlite3.c.

Referenced by unixLockSharedMemory().

◆ UNIXFILE_DELETE

#define UNIXFILE_DELETE 0x20 /* Delete on close */

Definition at line 33636 of file sqlite3.c.

Referenced by closeUnixFile(), and unixOpen().

◆ UNIXFILE_DIRSYNC

#define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */

Definition at line 33631 of file sqlite3.c.

Referenced by unixOpen(), and unixSync().

◆ UNIXFILE_EXCL

#define UNIXFILE_EXCL 0x01 /* Connections from one process only */

Definition at line 33627 of file sqlite3.c.

Referenced by unixFileLock().

◆ UNIXFILE_NOLOCK

#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */

Definition at line 33638 of file sqlite3.c.

Referenced by unixOpen(), and verifyDbFile().

◆ UNIXFILE_PERSIST_WAL

#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

Definition at line 33629 of file sqlite3.c.

◆ UNIXFILE_PSOW

#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

Definition at line 33635 of file sqlite3.c.

Referenced by setDeviceCharacteristics().

◆ UNIXFILE_RDONLY

#define UNIXFILE_RDONLY 0x02 /* Connection is read only */

Definition at line 33628 of file sqlite3.c.

Referenced by unixFileLock(), and unixOpen().

◆ UNIXFILE_URI

#define UNIXFILE_URI 0x40 /* Filename might have query parameters */

Definition at line 33637 of file sqlite3.c.

Referenced by unixOpen().

◆ unixLogError

#define unixLogError	(	a,
		b,
		c ) unixLogErrorAtLine(a,b,c,__LINE__)

Definition at line 34762 of file sqlite3.c.

Referenced by fcntlSizeHint(), openDirectory(), unixDelete(), unixFullPathname(), unixLockSharedMemory(), unixOpen(), unixOpenSharedMemory(), unixShmMap(), and unixSync().

◆ UNIXVFS

#define UNIXVFS	(		VFSNAME,
			FINDER )

Value:

    {                        \
    3,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
    unixSetSystemCall,    /* xSetSystemCall */              \
    unixGetSystemCall,    /* xGetSystemCall */              \
    unixNextSystemCall,   /* xNextSystemCall */             \
  }

◆ UNKNOWN_LOCK

#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)

Definition at line 52109 of file sqlite3.c.

Referenced by pager_unlock(), pagerLockDb(), pagerUnlockDb(), and sqlite3PagerSharedLock().

◆ unlikely

#define unlikely ( X ) (X)

Definition at line 13838 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions(), and sqlite3VdbeIdxRowid().

◆ UNUSED_PARAMETER

#define UNUSED_PARAMETER ( x ) (void)(x)

Definition at line 14653 of file sqlite3.c.

Referenced by absFunc(), attachFunc(), btreeParseCellPtrNoPayload(), compileoptiongetFunc(), compileoptionusedFunc(), cume_distStepFunc(), decodeIntArray(), detachFunc(), errlogFunc(), full_fsync(), growOpArray(), instrFunc(), jrnlBufferSize(), minmaxStep(), nocaseCollatingFunc(), nolockLock(), noopMutexLeave(), noopValueFunc(), ntileStepFunc(), nullifFunc(), pager_incr_changecounter(), pcache1Init(), pcache1Shutdown(), percent_rankStepFunc(), quoteFunc(), renameColumnFunc(), renameTableFunc(), renameTableTest(), replaceFunc(), resolveAsName(), row_numberValueFunc(), sqlite3_release_memory(), sqlite3_wal_autocheckpoint(), sqlite3SelectWalkFail(), sqlite3TempInMemory(), sqlite3VdbeMemSetPointer(), sqlite3WalkerDepthDecrease(), statInit(), statPush(), sumStep(), unixAccess(), unixCurrentTime(), unixCurrentTimeInt64(), unixDelete(), unixDlError(), unixDlOpen(), unixFullPathname(), unixGetLastError(), unixGetSystemCall(), unixNextSystemCall(), unixRandomness(), unixSetSystemCall(), unixShmBarrier(), unixSleep(), unixUnfetch(), updateFromSelect(), valueNew(), vdbeCommit(), and whereRangeScanEst().

◆ UNUSED_PARAMETER2

#define UNUSED_PARAMETER2	(		x,
			y ) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

Definition at line 14654 of file sqlite3.c.

Referenced by analysisLoader(), cdateFunc(), changes(), ctimeFunc(), ctimestampFunc(), memjrnlSync(), randomFunc(), sourceidFunc(), sqlite3ExprWalkNoop(), sqlite3InitCallback(), and sqlite3InvalidFunction().

◆ UPDATE_MAX_BLOBSIZE

#define UPDATE_MAX_BLOBSIZE ( P )

Definition at line 85349 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ UpperToLower

#define UpperToLower sqlite3UpperToLower

Definition at line 31448 of file sqlite3.c.

◆ USEFETCH

#define USEFETCH ( x ) 0

Definition at line 52488 of file sqlite3.c.

Referenced by pager_unlock(), pagerBeginReadTransaction(), setGetterMethod(), and sqlite3PagerSharedLock().

◆ Utf8Read

#define Utf8Read ( A ) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))

Definition at line 117668 of file sqlite3.c.

Referenced by patternCompare().

◆ valueFromFunction

#define valueFromFunction	(	a,
		b,
		c,
		d,
		e,
		f ) SQLITE_OK

Definition at line 77290 of file sqlite3.c.

Referenced by valueFromExpr().

◆ VDBE_DISPLAY_P4

#define VDBE_DISPLAY_P4 1

Definition at line 20740 of file sqlite3.c.

◆ VDBE_MAGIC_DEAD

#define VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */

Definition at line 21163 of file sqlite3.c.

◆ VDBE_MAGIC_HALT

#define VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */

Definition at line 21161 of file sqlite3.c.

Referenced by sqlite3VdbeHalt().

◆ VDBE_MAGIC_INIT

#define VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */

Definition at line 21159 of file sqlite3.c.

Referenced by sqlite3VdbeAddOpList(), sqlite3VdbeClearObject(), sqlite3VdbeGetOp(), and sqlite3VdbeMakeReady().

◆ VDBE_MAGIC_RESET

#define VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */

Definition at line 21162 of file sqlite3.c.

Referenced by sqlite3VdbeReset().

◆ VDBE_MAGIC_RUN

#define VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */

Definition at line 21160 of file sqlite3.c.

Referenced by sqlite3Step(), sqlite3VdbeExec(), sqlite3VdbeHalt(), sqlite3VdbeList(), and vdbeUnbind().

◆ VDBE_OFFSET_LINENO

#define VDBE_OFFSET_LINENO ( x ) 0

Definition at line 16001 of file sqlite3.c.

Referenced by autoIncrementEnd(), and sqlite3Pragma().

◆ vdbeAssertFieldCountWithinLimits

#define vdbeAssertFieldCountWithinLimits	(	A,
		B,
		C )

Definition at line 81934 of file sqlite3.c.

Referenced by vdbeRecordCompareInt(), and vdbeRecordCompareString().

◆ VdbeBranchTaken

#define VdbeBranchTaken	(		I,
			M )

Definition at line 85410 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ VdbeComment

◆ VdbeCoverage

#define VdbeCoverage ( v )

Definition at line 15994 of file sqlite3.c.

Referenced by analyzeOneTable(), autoIncrementEnd(), codeAllEqualityTerms(), codeDistinct(), codeEqualityTerm(), codeVectorCompare(), computeLimitRegisters(), constructAutomaticIndex(), fkLookupParent(), fkScanChildren(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), integrityCheckResultRow(), multiSelect(), multiSelectOrderBy(), selectInnerLoop(), sqlite3AlterFinishAddColumn(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3CompleteInsertion(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeIN(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FindInIndex(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), updateAccumulator(), updateVirtualTable(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), windowReturnOneRow(), and xferOptimization().

◆ VdbeCoverageAlwaysTaken

#define VdbeCoverageAlwaysTaken ( v )

Definition at line 15996 of file sqlite3.c.

◆ VdbeCoverageEqNe

#define VdbeCoverageEqNe ( v )

Definition at line 16000 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), windowFullScan(), and windowIfNewPeer().

◆ VdbeCoverageIf

#define VdbeCoverageIf	(		v,
			x )

Definition at line 15995 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), codeEqualityTerm(), codeVectorCompare(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3WhereEnd(), windowCheckValue(), and windowCodeRangeTest().

◆ VdbeCoverageNeverNull

#define VdbeCoverageNeverNull ( v )

Definition at line 15998 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), windowFullScan(), and windowReturnOneRow().

◆ VdbeCoverageNeverNullIf

#define VdbeCoverageNeverNullIf	(		v,
			x )

Definition at line 15999 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowCheckValue().

◆ VdbeCoverageNeverTaken

#define VdbeCoverageNeverTaken ( v )

Definition at line 15997 of file sqlite3.c.

Referenced by sqlite3Update(), sqlite3WindowCodeStep(), windowAggStep(), and windowReturnOneRow().

◆ VdbeFrameMem

#define VdbeFrameMem ( p ) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])

Definition at line 20897 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeFrameDelete().

◆ vdbeInvokeSqllog

#define vdbeInvokeSqllog ( x )

Definition at line 81003 of file sqlite3.c.

Referenced by sqlite3VdbeReset().

◆ VdbeMemDynamic

#define VdbeMemDynamic ( X ) (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)

Definition at line 20981 of file sqlite3.c.

20981#endif

20982

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemRelease(), sqlite3VdbeMemShallowCopy(), vdbeMemClear(), and vdbeMemClearExternAndSetNull().

◆ VdbeModuleComment

#define VdbeModuleComment ( X )

Definition at line 15935 of file sqlite3.c.

Referenced by sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3GenerateRowIndexDelete(), sqlite3WhereBegin(), sqlite3WhereEnd(), windowCodeRangeTest(), and windowFullScan().

◆ VdbeNoopComment

#define VdbeNoopComment ( X )

Definition at line 15934 of file sqlite3.c.

Referenced by multiSelectOrderBy(), sqlite3ExprCodeIN(), sqlite3GenerateConstraintChecks(), sqlite3Select(), and sqlite3UpsertDoUpdate().

◆ vdbeSorterBlockDebug

#define vdbeSorterBlockDebug	(	x,
		y,
		z )

Definition at line 94979 of file sqlite3.c.

Referenced by vdbeSorterJoinThread().

◆ vdbeSorterExtendFile

#define vdbeSorterExtendFile	(	x,
		y,
		z )

Definition at line 95170 of file sqlite3.c.

Referenced by vdbeSorterListToPMA(), and vdbeSorterOpenTempFile().

◆ vdbeSorterPopulateDebug

#define vdbeSorterPopulateDebug	(		x,
			y )

Definition at line 94978 of file sqlite3.c.

Referenced by vdbeIncrPopulate().

◆ vdbeSorterRewindDebug

#define vdbeSorterRewindDebug ( y )

Definition at line 94977 of file sqlite3.c.

Referenced by sqlite3VdbeSorterRewind().

◆ vdbeSorterWorkDebug

#define vdbeSorterWorkDebug	(		x,
			y )

Definition at line 94976 of file sqlite3.c.

Referenced by vdbeSorterListToPMA().

◆ vfsList

#define vfsList GLOBAL(sqlite3_vfs *, vfsList)

Definition at line 23301 of file sqlite3.c.

Referenced by sqlite3_vfs_find(), and sqlite3_vfs_register().

◆ VFUNCTION

#define VFUNCTION	(	zName,
		nArg,
		iArg,
		bNC,
		xFunc )

Value:

{nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \

SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Definition at line 17242 of file sqlite3.c.

#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ VisibleRowid

#define VisibleRowid ( X ) (((X)->tabFlags & TF_NoVisibleRowid)==0)

Definition at line 17584 of file sqlite3.c.

Referenced by lookupName().

◆ VVA_ONLY

#define VVA_ONLY ( X )

Definition at line 13711 of file sqlite3.c.

Referenced by autoVacuumCommit(), balance(), balance_nonroot(), sqlite3BtreeIntegrityCheck(), sqlite3BtreePutData(), sqlite3RunParser(), sqlite3Select(), sqlite3VdbeRecordCompareWithSkip(), and walTryBeginRead().

◆ WAGGREGATE

#define WAGGREGATE	(	zName,
		nArg,
		arg,
		nc,
		xStep,
		xFinal,
		xValue,
		xInverse,
		f )

Value:

{nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \

SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}

Definition at line 17270 of file sqlite3.c.

#define LIKEFUNC(zName, nArg, arg, flags) \
  {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
   (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ WAL_ALL_BUT_WRITE

#define WAL_ALL_BUT_WRITE 1

Definition at line 59689 of file sqlite3.c.

Referenced by walIndexRecover().

◆ WAL_CKPT_LOCK

#define WAL_CKPT_LOCK 1

Definition at line 59690 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), sqlite3WalCheckpoint(), and walIndexRecover().

◆ WAL_EXCLUSIVE_MODE

#define WAL_EXCLUSIVE_MODE 1

Definition at line 59876 of file sqlite3.c.

Referenced by sqlite3WalExclusiveMode().

◆ WAL_FRAME_HDRSIZE

#define WAL_FRAME_HDRSIZE 24

Definition at line 59807 of file sqlite3.c.

Referenced by sqlite3WalReadFrame(), walBeginShmUnreliable(), walCheckpoint(), walDecodeFrame(), walEncodeFrame(), walIndexRecover(), and walRewriteChecksums().

◆ WAL_HDRSIZE

#define WAL_HDRSIZE 32

Definition at line 59810 of file sqlite3.c.

Referenced by walBeginShmUnreliable(), and walIndexRecover().

◆ WAL_HEAPMEMORY_MODE

#define WAL_HEAPMEMORY_MODE 2

Definition at line 59877 of file sqlite3.c.

Referenced by sqlite3WalExclusiveMode(), sqlite3WalHeapMemory(), sqlite3WalOpen(), walIndexPageRealloc(), and walIndexReadHdr().

◆ WAL_MAGIC

#define WAL_MAGIC 0x377f0682

Definition at line 59821 of file sqlite3.c.

Referenced by walIndexRecover().

◆ WAL_MAX_VERSION

#define WAL_MAX_VERSION 3007000

Definition at line 59671 of file sqlite3.c.

Referenced by walIndexRecover().

◆ WAL_NORMAL_MODE

#define WAL_NORMAL_MODE 0

Definition at line 59875 of file sqlite3.c.

Referenced by sqlite3WalExclusiveMode(), sqlite3WalOpen(), and walIndexReadHdr().

◆ WAL_NREADER

#define WAL_NREADER (SQLITE_SHM_NLOCK-3)

Definition at line 59693 of file sqlite3.c.

Referenced by walCheckpoint(), walIndexRecover(), walRestartHdr(), walRestartLog(), and walTryBeginRead().

◆ WAL_RDONLY

#define WAL_RDONLY 1 /* The WAL file is readonly */

Definition at line 59883 of file sqlite3.c.

Referenced by sqlite3WalOpen().

◆ WAL_RDWR

#define WAL_RDWR 0 /* Normal read/write connection */

Definition at line 59882 of file sqlite3.c.

◆ WAL_READ_LOCK

#define WAL_READ_LOCK ( I ) (3+(I))

Definition at line 59692 of file sqlite3.c.

Referenced by sqlite3WalExclusiveMode(), walBeginShmUnreliable(), walCheckpoint(), walIndexRecover(), walRestartLog(), and walTryBeginRead().

◆ WAL_RECOVER_LOCK

#define WAL_RECOVER_LOCK 2

Definition at line 59691 of file sqlite3.c.

Referenced by walTryBeginRead().

◆ WAL_RETRY

#define WAL_RETRY (-1)

Definition at line 61670 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), walBeginShmUnreliable(), walIndexReadHdr(), walRestartLog(), and walTryBeginRead().

◆ WAL_SAVEPOINT_NDATA

#define WAL_SAVEPOINT_NDATA 4

Definition at line 51617 of file sqlite3.c.

◆ WAL_SHM_RDONLY

#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */

Definition at line 59884 of file sqlite3.c.

Referenced by walBeginShmUnreliable(), walIndexPageRealloc(), walIndexReadHdr(), and walTryBeginRead().

◆ WAL_SYNC_FLAGS

#define WAL_SYNC_FLAGS ( X ) ((X)&0x03)

Definition at line 51592 of file sqlite3.c.

Referenced by walWriteToLog().

◆ WAL_WRITE_LOCK

#define WAL_WRITE_LOCK 0

Definition at line 59688 of file sqlite3.c.

Referenced by sqlite3WalBeginWriteTransaction(), sqlite3WalCheckpoint(), walIndexReadHdr(), and walIndexRecover().

◆ walDisableBlocking

#define walDisableBlocking ( x )

Definition at line 61226 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), sqlite3WalCheckpoint(), and walBusyLock().

◆ walEnableBlocking

#define walEnableBlocking ( x ) 0

Definition at line 61225 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), and sqlite3WalCheckpoint().

◆ walFrameOffset

#define walFrameOffset	(		iFrame,
			szPage )

Value:

  (                               \
  WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE)         \
)

Definition at line 59828 of file sqlite3.c.

 
/*
** Return the offset of frame iFrame in the write-ahead log file,

Referenced by sqlite3WalReadFrame(), walBeginShmUnreliable(), walCheckpoint(), walIndexRecover(), and walRewriteChecksums().

◆ WALINDEX_HDR_SIZE

#define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))

Definition at line 59804 of file sqlite3.c.

Referenced by sqlite3WalOpen(), walHashGet(), and walIndexRecover().

◆ WALINDEX_LOCK_OFFSET

#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock))

Definition at line 59803 of file sqlite3.c.

Referenced by sqlite3WalOpen().

◆ WALINDEX_MAX_VERSION

#define WALINDEX_MAX_VERSION 3007000

Definition at line 59672 of file sqlite3.c.

Referenced by walIndexReadHdr(), and walIndexWriteHdr().

◆ WALINDEX_PGSZ

#define WALINDEX_PGSZ

Value:

    (                                         \
    sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
)

Definition at line 59939 of file sqlite3.c.

** wal-index is smaller than usual. This is so that there is a complete
** hash-table on each aligned 32KB page of the wal-index.
*/

Referenced by walBeginShmUnreliable(), walIndexPageRealloc(), and walIndexRecover().

◆ walLockWriter

#define walLockWriter ( pWal ) walLockExclusive((pWal), WAL_WRITE_LOCK, 1)

Definition at line 61227 of file sqlite3.c.

Referenced by walIndexReadHdr().

◆ WALTRACE

#define WALTRACE ( X )

Definition at line 59655 of file sqlite3.c.

Referenced by sqlite3WalCheckpoint(), sqlite3WalOpen(), walIndexRecover(), and walLockExclusive().

◆ WHERE_AUTO_INDEX

#define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */

Definition at line 141527 of file sqlite3.c.

Referenced by constructAutomaticIndex(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), whereLoopAddBtree(), whereLoopFindLesser(), whereLoopOutputAdjust(), and wherePathSolver().

◆ WHERE_BIGNULL_SORT

#define WHERE_BIGNULL_SORT 0x00080000 /* Column nEq of index is BIGNULL */

Definition at line 141532 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), and wherePathSatisfiesOrderBy().

◆ WHERE_BOTH_LIMIT

#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */

Definition at line 141519 of file sqlite3.c.

Referenced by sqlite3WhereExplainOneScan().

◆ WHERE_BTM_LIMIT

#define WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */

Definition at line 141518 of file sqlite3.c.

Referenced by explainIndexRange(), sqlite3WhereExplainOneScan(), and whereLoopAddBtreeIndex().

◆ WHERE_COLUMN_EQ

#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */

Definition at line 141512 of file sqlite3.c.

Referenced by constructAutomaticIndex(), sqlite3WhereExplainOneScan(), whereLoopAddBtreeIndex(), whereLoopFindLesser(), and whereShortCut().

◆ WHERE_COLUMN_IN

#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */

Definition at line 141514 of file sqlite3.c.

Referenced by sqlite3WhereExplainOneScan(), whereLoopAddBtreeIndex(), and wherePathSolver().

◆ WHERE_COLUMN_NULL

#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */

Definition at line 141515 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex().

◆ WHERE_COLUMN_RANGE

#define WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */

Definition at line 141513 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), and whereLoopAddBtreeIndex().

◆ WHERE_CONSTRAINT

#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */

Definition at line 141516 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), and sqlite3WhereExplainOneScan().

◆ WHERE_DISTINCT_NOOP

#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */

Definition at line 18323 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3Select(), and wherePathSolver().

◆ WHERE_DISTINCT_ORDERED

#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */

Definition at line 18325 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3WhereBegin(), sqlite3WhereEnd(), and wherePathSolver().

◆ WHERE_DISTINCT_UNIQUE

#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */

Definition at line 18324 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3WhereBegin(), and whereShortCut().

◆ WHERE_DISTINCT_UNORDERED

#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */

Definition at line 18326 of file sqlite3.c.

Referenced by selectInnerLoop(), sqlite3Select(), and sqlite3WhereBegin().

◆ WHERE_DISTINCTBY

#define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */

Definition at line 18311 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), wherePathSatisfiesOrderBy(), and wherePathSolver().

◆ WHERE_DUPLICATES_OK

#define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */

Definition at line 18308 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), and sqlite3WhereBegin().

◆ WHERE_GROUPBY

#define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */

Definition at line 18310 of file sqlite3.c.

Referenced by sqlite3Select(), sqlite3WhereIsSorted(), and wherePathSatisfiesOrderBy().

◆ WHERE_IDX_ONLY

#define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */

Definition at line 141520 of file sqlite3.c.

Referenced by constructAutomaticIndex(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopCheaperProperSubset(), and whereShortCut().

◆ WHERE_IN_ABLE

#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */

Definition at line 141524 of file sqlite3.c.

Referenced by codeEqualityTerm(), and sqlite3WhereEnd().

◆ WHERE_IN_EARLYOUT

#define WHERE_IN_EARLYOUT 0x00040000 /* Perhaps quit IN loops early */

Definition at line 141531 of file sqlite3.c.

Referenced by codeEqualityTerm(), and sqlite3WhereEnd().

◆ WHERE_INDEXED

#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */

Definition at line 141522 of file sqlite3.c.

Referenced by constructAutomaticIndex(), sqlite3WhereBegin(), sqlite3WhereEnd(), whereLoopAddBtree(), whereLoopAdjustCost(), whereLoopFindLesser(), and whereShortCut().

◆ WHERE_IPK

#define WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */

Definition at line 141521 of file sqlite3.c.

Referenced by sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), wherePathSatisfiesOrderBy(), wherePathSolver(), and whereShortCut().

◆ WHERE_LOOP_XFER_SZ

#define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)

Definition at line 141062 of file sqlite3.c.

◆ WHERE_MULTI_OR

#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */

Definition at line 141526 of file sqlite3.c.

Referenced by codeEqualityTerm(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), and whereLoopAddOr().

◆ WHERE_ONEPASS_DESIRED

#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */

Definition at line 18306 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Update(), sqlite3WhereBegin(), updateVirtualTable(), and whereLoopAddBtree().

◆ WHERE_ONEPASS_MULTIROW

#define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */

Definition at line 18307 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Update(), and sqlite3WhereBegin().

◆ WHERE_ONEROW

#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */

Definition at line 141525 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), whereLoopAddBtreeIndex(), whereLoopAddVirtualOne(), wherePathSatisfiesOrderBy(), wherePathSolver(), and whereShortCut().

◆ WHERE_OR_SUBCLAUSE

#define WHERE_OR_SUBCLAUSE

Value:

0x0020 /* Processing a sub-WHERE as part of

** the OR optimization */

Definition at line 18309 of file sqlite3.c.

Referenced by codeDeferredSeek(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), whereLoopAddBtree(), and whereShortCut().

◆ WHERE_ORDERBY_LIMIT

#define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */

Definition at line 18315 of file sqlite3.c.

Referenced by wherePathSatisfiesOrderBy(), and wherePathSolver().

◆ WHERE_ORDERBY_MAX

#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */

Definition at line 18305 of file sqlite3.c.

Referenced by minMaxQuery(), sqlite3WhereExplainOneScan(), wherePathSatisfiesOrderBy(), and wherePathSolver().

◆ WHERE_ORDERBY_MIN

#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */

Definition at line 18304 of file sqlite3.c.

Referenced by minMaxQuery(), sqlite3WhereBegin(), sqlite3WhereExplainOneScan(), wherePathSatisfiesOrderBy(), and wherePathSolver().

◆ WHERE_ORDERBY_NORMAL

#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */

Definition at line 18303 of file sqlite3.c.

Referenced by minMaxQuery(), and sqlite3Select().

◆ WHERE_PARTIALIDX

#define WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */

Definition at line 141530 of file sqlite3.c.

Referenced by constructAutomaticIndex(), and sqlite3WhereExplainOneScan().

◆ WHERE_SEEK_TABLE

#define WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */

Definition at line 18314 of file sqlite3.c.

Referenced by sqlite3DeleteFrom().

◆ WHERE_SEEK_UNIQ_TABLE

#define WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */

Definition at line 18316 of file sqlite3.c.

Referenced by sqlite3Update().

◆ WHERE_SKIPSCAN

#define WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */

Definition at line 141528 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), whereLoopAddBtreeIndex(), and wherePathSatisfiesOrderBy().

◆ WHERE_SORTBYGROUP

#define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */

Definition at line 18313 of file sqlite3.c.

Referenced by sqlite3Select(), sqlite3WhereIsSorted(), and wherePathSolver().

◆ WHERE_TOP_LIMIT

#define WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */

Definition at line 141517 of file sqlite3.c.

Referenced by explainIndexRange(), sqlite3WhereExplainOneScan(), and whereLoopAddBtreeIndex().

◆ WHERE_UNQ_WANTED

#define WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/

Definition at line 141529 of file sqlite3.c.

Referenced by whereLoopAddBtreeIndex().

◆ WHERE_USE_LIMIT

#define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */

Definition at line 18318 of file sqlite3.c.

Referenced by sqlite3Select(), sqlite3WhereBegin(), and whereSortingCost().

◆ WHERE_VIRTUALTABLE

#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */

Definition at line 141523 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), codeEqualityTerm(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), whereLoopAddBtreeIndex(), whereLoopAddVirtual(), whereLoopInsert(), and wherePathSatisfiesOrderBy().

◆ WHERE_WANT_DISTINCT

#define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */

Definition at line 18312 of file sqlite3.c.

Referenced by sqlite3Select(), sqlite3WhereBegin(), wherePathSolver(), and whereShortCut().

◆ WHERETRACE

#define WHERETRACE	(		K,
			X )

Definition at line 140945 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), whereLoopAddBtreeIndex(), whereLoopAddOr(), whereLoopAddVirtual(), whereLoopAddVirtualOne(), whereLoopAdjustCost(), whereLoopInsert(), wherePathSolver(), and whereRangeScanEst().

◆ WHERETRACE_ALL_LOOPS

#define WHERETRACE_ALL_LOOPS	(		W,
			C )

Definition at line 150204 of file sqlite3.c.

Referenced by sqlite3WhereBegin().

◆ whereTraceIndexInfoInputs

#define whereTraceIndexInfoInputs ( A )

Definition at line 146259 of file sqlite3.c.

Referenced by vtabBestIndex().

◆ whereTraceIndexInfoOutputs

#define whereTraceIndexInfoOutputs ( A )

Definition at line 146260 of file sqlite3.c.

Referenced by vtabBestIndex().

◆ WINDOW_AGGINVERSE

#define WINDOW_AGGINVERSE 2

Definition at line 152873 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ WINDOW_AGGSTEP

#define WINDOW_AGGSTEP 3

Definition at line 152874 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ WINDOW_ENDING_INT

#define WINDOW_ENDING_INT 1

Definition at line 152584 of file sqlite3.c.

◆ WINDOW_ENDING_NUM

#define WINDOW_ENDING_NUM 4

Definition at line 152587 of file sqlite3.c.

◆ WINDOW_NTH_VALUE_INT

#define WINDOW_NTH_VALUE_INT 2

Definition at line 152585 of file sqlite3.c.

◆ WINDOW_RETURN_ROW

#define WINDOW_RETURN_ROW 1

Definition at line 152872 of file sqlite3.c.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ WINDOW_STARTING_INT

#define WINDOW_STARTING_INT 0

Definition at line 152583 of file sqlite3.c.

◆ WINDOW_STARTING_NUM

#define WINDOW_STARTING_NUM 3

Definition at line 152586 of file sqlite3.c.

Referenced by windowCheckValue().

◆ WINDOWFUNCALL

#define WINDOWFUNCALL	(	name,
		nArg,
		extra )

Value:

  {                                   \
  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
  name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc,               \
  name ## InvFunc, name ## Name, {0}                                       \
}

Definition at line 151742 of file sqlite3.c.

  assert(0);                 /*NO_TEST*/
}                            /*NO_TEST*/
static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
 
/* Window functions that use all window interfaces: xStep, xFinal,

Referenced by sqlite3WindowFunctions().

◆ WINDOWFUNCNOOP

#define WINDOWFUNCNOOP	(	name,
		nArg,
		extra )

Value:

  {                                  \
  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
  noopStepFunc, noopValueFunc, noopValueFunc,                              \
  noopStepFunc, name ## Name, {0}                                          \
}

Definition at line 151750 of file sqlite3.c.

  name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc,               \
  name ## InvFunc, name ## Name, {0}                                       \
}
 
/* Window functions that are implemented using bytecode and thus have

Referenced by sqlite3WindowFunctions().

◆ WINDOWFUNCX

#define WINDOWFUNCX	(	name,
		nArg,
		extra )

Value:

  {                                     \
  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
  name ## StepFunc, name ## ValueFunc, name ## ValueFunc,                  \
  noopStepFunc, name ## Name, {0}                                          \
}

Definition at line 151759 of file sqlite3.c.

  noopStepFunc, name ## Name, {0}                                          \
}
 
/* Window functions that use all window interfaces: xStep, the
** same routine for xFinalize and xValue and which never call

Referenced by sqlite3WindowFunctions().

◆ WO_ALL

#define WO_ALL 0x1fff /* Mask of all possible WO_* values */

Definition at line 141504 of file sqlite3.c.

Referenced by allocateIndexInfo(), and exprAnalyze().

◆ WO_AND

#define WO_AND 0x0400 /* Two or more AND-connected terms */

Definition at line 141500 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm(), whereLoopAddOr(), and whereNthSubterm().

◆ WO_AUX

#define WO_AUX 0x0040 /* Op useful to virtual tables only */

Definition at line 141496 of file sqlite3.c.

Referenced by allocateIndexInfo(), exprAnalyze(), and exprAnalyzeOrTerm().

◆ WO_EQ

#define WO_EQ 0x0002

Definition at line 141491 of file sqlite3.c.

Referenced by allocateIndexInfo(), exprAnalyzeOrTerm(), isDistinctRedundant(), sqlite3WhereFindTerm(), termCanDriveIndex(), whereCombineDisjuncts(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopOutputAdjust(), wherePathSatisfiesOrderBy(), whereScanNext(), and whereShortCut().

◆ WO_EQUIV

#define WO_EQUIV 0x0800 /* Of the form A==B, both columns */

Definition at line 141501 of file sqlite3.c.

Referenced by allocateIndexInfo(), exprAnalyze(), and whereScanNext().

◆ WO_GE

#define WO_GE (WO_EQ<<(TK_GE-TK_EQ))

Definition at line 141495 of file sqlite3.c.

Referenced by allocateIndexInfo(), whereCombineDisjuncts(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ WO_GT

#define WO_GT (WO_EQ<<(TK_GT-TK_EQ))

Definition at line 141494 of file sqlite3.c.

Referenced by allocateIndexInfo(), exprAnalyze(), whereCombineDisjuncts(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ WO_IN

#define WO_IN 0x0001

Definition at line 141490 of file sqlite3.c.

Referenced by allocateIndexInfo(), codeAllEqualityTerms(), whereLoopAddBtreeIndex(), whereLoopAddVirtual(), whereLoopAddVirtualOne(), and wherePathSatisfiesOrderBy().

◆ WO_IS

#define WO_IS 0x0080

Definition at line 141497 of file sqlite3.c.

Referenced by allocateIndexInfo(), sqlite3WhereFindTerm(), termCanDriveIndex(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopOutputAdjust(), wherePathSatisfiesOrderBy(), whereScanNext(), and whereShortCut().

◆ WO_ISNULL

#define WO_ISNULL 0x0100

Definition at line 141498 of file sqlite3.c.

Referenced by allocateIndexInfo(), codeAllEqualityTerms(), whereLoopAddBtreeIndex(), wherePathSatisfiesOrderBy(), and whereScanNext().

◆ WO_LE

#define WO_LE (WO_EQ<<(TK_LE-TK_EQ))

Definition at line 141493 of file sqlite3.c.

Referenced by allocateIndexInfo(), whereCombineDisjuncts(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ WO_LT

#define WO_LT (WO_EQ<<(TK_LT-TK_EQ))

Definition at line 141492 of file sqlite3.c.

Referenced by allocateIndexInfo(), whereCombineDisjuncts(), whereLoopAddBtreeIndex(), and whereRangeScanEst().

◆ WO_NOOP

#define WO_NOOP 0x1000 /* This term does not restrict search space */

Definition at line 141502 of file sqlite3.c.

◆ WO_OR

#define WO_OR 0x0200 /* Two or more OR-connected terms */

Definition at line 141499 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm(), and whereLoopAddOr().

◆ WO_SINGLE

#define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */

Definition at line 141505 of file sqlite3.c.

Referenced by exprAnalyzeOrTerm().

◆ WRC_Abort

#define WRC_Abort 2 /* Abandon the tree walk */

Definition at line 19139 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery(), exprIdxCover(), exprNodeIsConstant(), impliesNotNullRow(), lookupName(), resolveExprStep(), selectExpander(), selectWindowRewriteExprCb(), sqlite3ResolveExprListNames(), sqlite3SelectWalkFail(), sqlite3WalkSelect(), sqlite3WalkSelectExpr(), sqlite3WalkSelectFrom(), walkExpr(), walkWindowList(), and withExpand().

◆ WRC_Continue

#define WRC_Continue 0 /* Continue down into children */

◆ WRC_Prune

#define WRC_Prune 1 /* Omit children but continue walking siblings */

Definition at line 19138 of file sqlite3.c.

Referenced by analyzeAggregate(), exprNodeIsConstant(), havingToWhereExprCb(), impliesNotNullRow(), lookupName(), propagateConstantExprRewrite(), renameColumnSelectCb(), resolveExprStep(), selectExpander(), selectWindowRewriteExprCb(), and whereIndexExprTransNode().

◆ WRITE_LOCK

#define WRITE_LOCK 2

Definition at line 63790 of file sqlite3.c.

Referenced by querySharedCacheTableLock(), setSharedCacheTableLock(), and sqlite3BtreeLockTable().

◆ WRITE_UTF16BE

#define WRITE_UTF16BE	(		zOut,
			c )

Value:

  {                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
  }else{                                                            \
    *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
    *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
    *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
    *zOut++ = (u8)(c&0x00FF);                                       \
  }                                                                 \
}

Definition at line 30738 of file sqlite3.c.

    *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
  }                                                                 \
}
 
#define WRITE_UTF16BE(zOut, c) {                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
  }else{                                                            \

Referenced by sqlite3VdbeMemTranslate().

◆ WRITE_UTF16LE

#define WRITE_UTF16LE	(		zOut,
			c )

Value:

  {                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
  }else{                                                            \
    *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
    *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
  }                                                                 \
}

Definition at line 30726 of file sqlite3.c.

    *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);             \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
}
 
#define WRITE_UTF16LE(zOut, c) {                                    \
  if( c<=0xFFFF ){                                                  \
    *zOut++ = (u8)(c&0x00FF);                                       \
    *zOut++ = (u8)((c>>8)&0x00FF);                                  \
  }else{                                                            \

Referenced by sqlite3VdbeMemTranslate().

◆ WRITE_UTF8

#define WRITE_UTF8	(		zOut,
			c )

Value:

  {                          \
  if( c<0x00080 ){                                     \
    *zOut++ = (u8)(c&0xFF);                            \
  }                                                    \
  else if( c<0x00800 ){                                \
    *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);                \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
  else if( c<0x10000 ){                                \
    *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);               \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }else{                                               \
    *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);             \
    *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);             \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
}

Definition at line 30706 of file sqlite3.c.

  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
};
 
 
#define WRITE_UTF8(zOut, c) {                          \
  if( c<0x00080 ){                                     \
    *zOut++ = (u8)(c&0xFF);                            \
  }                                                    \
  else if( c<0x00800 ){                                \
    *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);                \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }                                                    \
  else if( c<0x10000 ){                                \
    *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);               \
    *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
    *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
  }else{                                               \

Referenced by sqlite3VdbeMemTranslate().

◆ wsdAutoext

#define wsdAutoext sqlite3Autoext

Definition at line 124945 of file sqlite3.c.

Referenced by sqlite3_auto_extension(), sqlite3_cancel_auto_extension(), and sqlite3AutoLoadExtensions().

◆ wsdAutoextInit

#define wsdAutoextInit

Definition at line 124944 of file sqlite3.c.

Referenced by sqlite3_auto_extension(), sqlite3_cancel_auto_extension(), and sqlite3AutoLoadExtensions().

◆ wsdHooks

#define wsdHooks sqlite3Hooks

Definition at line 23447 of file sqlite3.c.

Referenced by sqlite3BenignMallocHooks(), and sqlite3EndBenignMalloc().

◆ wsdHooksInit

#define wsdHooksInit

Definition at line 23446 of file sqlite3.c.

Referenced by sqlite3BenignMallocHooks().

◆ wsdPrng

#define wsdPrng sqlite3Prng

◆ wsdStat

#define wsdStat sqlite3Stat

Definition at line 21375 of file sqlite3.c.

Referenced by sqlite3StatusDown(), sqlite3StatusHighwater(), sqlite3StatusUp(), and sqlite3StatusValue().

◆ wsdStatInit

#define wsdStatInit

Definition at line 21374 of file sqlite3.c.

Referenced by sqlite3StatusHighwater(), sqlite3StatusUp(), and sqlite3StatusValue().

◆ XN_EXPR

#define XN_EXPR (-2) /* Indexed column is an expression */

Definition at line 17832 of file sqlite3.c.

Referenced by codeAllEqualityTerms(), explainIndexColumnName(), exprAnalyzeOrTerm(), exprMightBeIndexed2(), indexColumnIsBeingUpdated(), indexMightHelpWithOrderBy(), isDupColumn(), sqlite3CreateIndex(), sqlite3GenerateConstraintChecks(), sqlite3GenerateIndexKey(), sqlite3IndexAffinityStr(), sqlite3UpsertAnalyzeTarget(), whereIndexExprTrans(), whereScanInit(), whereScanNext(), and xferCompatibleIndex().

◆ XN_ROWID

#define XN_ROWID (-1) /* Indexed column is the rowid */

Definition at line 17831 of file sqlite3.c.

Referenced by columnTypeImpl(), constructAutomaticIndex(), explainIndexColumnName(), indexColumnIsBeingUpdated(), isDupColumn(), sqlite3CreateIndex(), sqlite3ExprCodeTarget(), sqlite3FindInIndex(), sqlite3GenerateConstraintChecks(), sqlite3IndexAffinityStr(), sqlite3Pragma(), sqlite3UpsertAnalyzeTarget(), whereLoopAddBtreeIndex(), wherePathSatisfiesOrderBy(), whereRangeVectorLen(), and whereScanInit().

◆ YY_ACCEPT_ACTION

#define YY_ACCEPT_ACTION 1189

Definition at line 154522 of file sqlite3.c.

Referenced by sqlite3Parser().

◆ YY_ACTTAB_COUNT

#define YY_ACTTAB_COUNT (1962)

Definition at line 154592 of file sqlite3.c.

Referenced by yy_find_shift_action().

◆ YY_ERROR_ACTION

#define YY_ERROR_ACTION 1188

Definition at line 154521 of file sqlite3.c.

Referenced by sqlite3Parser(), and yy_reduce().

◆ YY_MAX_REDUCE

#define YY_MAX_REDUCE 1575

Definition at line 154525 of file sqlite3.c.

◆ YY_MAX_SHIFT

#define YY_MAX_SHIFT 552

Definition at line 154518 of file sqlite3.c.

Referenced by yy_find_shift_action(), yy_reduce(), and yy_shift().

◆ YY_MAX_SHIFTREDUCE

#define YY_MAX_SHIFTREDUCE 1187

Definition at line 154520 of file sqlite3.c.

Referenced by sqlite3Parser(), and yy_reduce().

◆ YY_MIN_REDUCE

#define YY_MIN_REDUCE 1191

Definition at line 154524 of file sqlite3.c.

Referenced by sqlite3Parser(), and yy_shift().

◆ YY_MIN_SHIFTREDUCE

#define YY_MIN_SHIFTREDUCE 803

Definition at line 154519 of file sqlite3.c.

Referenced by yy_shift().

◆ YY_NLOOKAHEAD

#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

Definition at line 154527 of file sqlite3.c.

Referenced by yy_find_shift_action().

◆ YY_NO_ACTION

#define YY_NO_ACTION 1190

Definition at line 154523 of file sqlite3.c.

◆ YY_REDUCE_COUNT

#define YY_REDUCE_COUNT (391)

Definition at line 155070 of file sqlite3.c.

◆ YY_REDUCE_MAX

#define YY_REDUCE_MAX (1625)

Definition at line 155072 of file sqlite3.c.

◆ YY_REDUCE_MIN

#define YY_REDUCE_MIN (-262)

Definition at line 155071 of file sqlite3.c.

◆ YY_SHIFT_COUNT

#define YY_SHIFT_COUNT (552)

Definition at line 155009 of file sqlite3.c.

Referenced by yy_find_shift_action().

◆ YY_SHIFT_MAX

#define YY_SHIFT_MAX (1951)

Definition at line 155011 of file sqlite3.c.

◆ YY_SHIFT_MIN

#define YY_SHIFT_MIN (0)

Definition at line 155010 of file sqlite3.c.

◆ YYACTIONTYPE

#define YYACTIONTYPE unsigned short int

Definition at line 154478 of file sqlite3.c.

Referenced by sqlite3Parser(), and yy_reduce().

◆ YYCODETYPE

#define YYCODETYPE unsigned short int

Definition at line 154476 of file sqlite3.c.

Referenced by sqlite3Parser(), yy_find_shift_action(), and yy_reduce().

◆ YYFALLBACK

#define YYFALLBACK 1

Definition at line 154513 of file sqlite3.c.

◆ YYMALLOCARGTYPE

#define YYMALLOCARGTYPE u64

Definition at line 154269 of file sqlite3.c.

◆ YYNOCODE

#define YYNOCODE 310

Definition at line 154477 of file sqlite3.c.

Referenced by sqlite3Parser(), yy_find_shift_action(), and yy_reduce().

◆ YYNOERRORRECOVERY

#define YYNOERRORRECOVERY 1

Definition at line 154239 of file sqlite3.c.

◆ YYNRULE

#define YYNRULE 385

Definition at line 154515 of file sqlite3.c.

◆ YYNRULE_WITH_ACTION

#define YYNRULE_WITH_ACTION 325

Definition at line 154516 of file sqlite3.c.

Referenced by yy_reduce().

◆ YYNSTATE

#define YYNSTATE 553

Definition at line 154514 of file sqlite3.c.

◆ YYNTOKEN

#define YYNTOKEN 181

Definition at line 154517 of file sqlite3.c.

Referenced by yy_find_shift_action().

◆ YYPARSEFREENEVERNULL

#define YYPARSEFREENEVERNULL 1

Definition at line 154250 of file sqlite3.c.

◆ YYSTACKDEPTH

#define YYSTACKDEPTH 100

Definition at line 154501 of file sqlite3.c.

Referenced by sqlite3ParserInit().

◆ yytestcase

#define yytestcase ( X ) testcase(X)

Definition at line 154244 of file sqlite3.c.

Referenced by yy_reduce().

◆ yyTraceShift

#define yyTraceShift	(	X,
		Y,
		Z )

Definition at line 156620 of file sqlite3.c.

Referenced by yy_reduce().

◆ YYWILDCARD

#define YYWILDCARD 100

Definition at line 154479 of file sqlite3.c.

Referenced by yy_find_shift_action().

Typedef Documentation

◆ AggInfo

typedef struct AggInfo AggInfo

Definition at line 14659 of file sqlite3.c.

◆ analysisInfo

typedef struct analysisInfo analysisInfo

Definition at line 109007 of file sqlite3.c.

◆ AuthContext

typedef struct AuthContext AuthContext

Definition at line 14660 of file sqlite3.c.

◆ AutoincInfo

typedef struct AutoincInfo AutoincInfo

Definition at line 14661 of file sqlite3.c.

◆ AuxData

typedef struct AuxData AuxData

Definition at line 20761 of file sqlite3.c.

◆ BenignMallocHooks

typedef struct BenignMallocHooks BenignMallocHooks

Definition at line 23429 of file sqlite3.c.

◆ bft

typedef unsigned bft

Definition at line 21048 of file sqlite3.c.

◆ Bitmask

typedef u64 Bitmask

Definition at line 14720 of file sqlite3.c.

◆ Bitvec

typedef struct Bitvec Bitvec

Definition at line 14662 of file sqlite3.c.

◆ Bool

typedef unsigned Bool

Definition at line 20755 of file sqlite3.c.

◆ BtCursor

typedef struct BtCursor BtCursor

Definition at line 15037 of file sqlite3.c.

◆ BtLock

typedef struct BtLock BtLock

Definition at line 63702 of file sqlite3.c.

◆ Btree

typedef struct Btree Btree

Definition at line 15036 of file sqlite3.c.

◆ BtreePayload

typedef struct BtreePayload BtreePayload

Definition at line 15039 of file sqlite3.c.

◆ BtShared

typedef struct BtShared BtShared

Definition at line 15038 of file sqlite3.c.

◆ BusyHandler

typedef struct BusyHandler BusyHandler

Definition at line 14563 of file sqlite3.c.

◆ CellArray

typedef struct CellArray CellArray

Definition at line 71359 of file sqlite3.c.

◆ CellInfo

typedef struct CellInfo CellInfo

Definition at line 63703 of file sqlite3.c.

◆ CollSeq

typedef struct CollSeq CollSeq

Definition at line 14663 of file sqlite3.c.

◆ Column

typedef struct Column Column

Definition at line 14664 of file sqlite3.c.

◆ CountCtx

typedef struct CountCtx CountCtx

Definition at line 118648 of file sqlite3.c.

◆ DateTime

typedef struct DateTime DateTime

Definition at line 21775 of file sqlite3.c.

◆ Db

typedef struct Db Db

Definition at line 14665 of file sqlite3.c.

◆ DbFixer

typedef struct DbFixer DbFixer

Definition at line 18954 of file sqlite3.c.

◆ DblquoteStr

typedef struct DblquoteStr DblquoteStr

Definition at line 21070 of file sqlite3.c.

◆ DbPage

typedef struct PgHdr DbPage

Definition at line 14793 of file sqlite3.c.

◆ DistinctCtx

typedef struct DistinctCtx DistinctCtx

Definition at line 129315 of file sqlite3.c.

◆ et_info

typedef struct et_info et_info

◆ etByte

typedef unsigned char etByte

Definition at line 28178 of file sqlite3.c.

◆ Expr

typedef struct Expr Expr

Definition at line 14667 of file sqlite3.c.

◆ ExprList

typedef struct ExprList ExprList

Definition at line 14668 of file sqlite3.c.

◆ FileChunk

typedef struct FileChunk FileChunk

Definition at line 97099 of file sqlite3.c.

◆ FilePoint

typedef struct FilePoint FilePoint

Definition at line 97098 of file sqlite3.c.

◆ FKey

typedef struct FKey FKey

Definition at line 14669 of file sqlite3.c.

◆ fts5_api

typedef struct fts5_api fts5_api

Definition at line 13181 of file sqlite3.c.

◆ fts5_extension_function

typedef void(* fts5_extension_function) (const Fts5ExtensionApi *pApi, Fts5Context *pFts, sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)

Definition at line 12686 of file sqlite3.c.

◆ fts5_tokenizer

typedef struct fts5_tokenizer fts5_tokenizer

Definition at line 13145 of file sqlite3.c.

◆ Fts5Context

typedef struct Fts5Context Fts5Context

Definition at line 12683 of file sqlite3.c.

◆ Fts5ExtensionApi

typedef struct Fts5ExtensionApi Fts5ExtensionApi

Definition at line 12682 of file sqlite3.c.

◆ Fts5PhraseIter

typedef struct Fts5PhraseIter Fts5PhraseIter

Definition at line 12684 of file sqlite3.c.

◆ Fts5Tokenizer

typedef struct Fts5Tokenizer Fts5Tokenizer

Definition at line 13144 of file sqlite3.c.

◆ FuncDef

typedef struct FuncDef FuncDef

Definition at line 14671 of file sqlite3.c.

◆ FuncDefHash

typedef struct FuncDefHash FuncDefHash

Definition at line 14672 of file sqlite3.c.

◆ FuncDestructor

typedef struct FuncDestructor FuncDestructor

Definition at line 14670 of file sqlite3.c.

◆ Hash

typedef struct Hash Hash

Definition at line 13860 of file sqlite3.c.

◆ HashElem

typedef struct HashElem HashElem

Definition at line 13861 of file sqlite3.c.

◆ HiddenIndexInfo

typedef struct HiddenIndexInfo HiddenIndexInfo

Definition at line 145636 of file sqlite3.c.

◆ ht_slot

typedef u16 ht_slot

Definition at line 59890 of file sqlite3.c.

◆ i16

typedef INT16_TYPE i16

Definition at line 14333 of file sqlite3.c.

◆ i64

typedef sqlite_int64 i64

Definition at line 14329 of file sqlite3.c.

◆ i8

typedef INT8_TYPE i8

Definition at line 14335 of file sqlite3.c.

◆ IdList

typedef struct IdList IdList

Definition at line 14673 of file sqlite3.c.

◆ IdxExprTrans

typedef struct IdxExprTrans IdxExprTrans

◆ Incrblob

typedef struct Incrblob Incrblob

Definition at line 93391 of file sqlite3.c.

◆ IncrMerger

typedef struct IncrMerger IncrMerger

Definition at line 94045 of file sqlite3.c.

◆ Index

typedef struct Index Index

Definition at line 14674 of file sqlite3.c.

◆ IndexSample

typedef struct IndexSample IndexSample

Definition at line 14675 of file sqlite3.c.

◆ IntegrityCk

typedef struct IntegrityCk IntegrityCk

Definition at line 64143 of file sqlite3.c.

◆ KeyClass

typedef struct KeyClass KeyClass

Definition at line 14676 of file sqlite3.c.

◆ KeyInfo

typedef struct KeyInfo KeyInfo

Definition at line 14677 of file sqlite3.c.

◆ LogEst

typedef INT16_TYPE LogEst

Definition at line 14380 of file sqlite3.c.

◆ Lookaside

typedef struct Lookaside Lookaside

Definition at line 14678 of file sqlite3.c.

◆ LookasideSlot

typedef struct LookasideSlot LookasideSlot

Definition at line 14679 of file sqlite3.c.

◆ Mem

typedef struct sqlite3_value Mem

Definition at line 15426 of file sqlite3.c.

◆ MemJournal

typedef struct MemJournal MemJournal

Definition at line 97097 of file sqlite3.c.

◆ MemPage

typedef struct MemPage MemPage

Definition at line 63701 of file sqlite3.c.

◆ MergeEngine

typedef struct MergeEngine MergeEngine

Definition at line 94038 of file sqlite3.c.

◆ Module

typedef struct Module Module

Definition at line 14680 of file sqlite3.c.

◆ NameContext

typedef struct NameContext NameContext

Definition at line 14681 of file sqlite3.c.

◆ Op

typedef struct VdbeOp Op

Definition at line 20750 of file sqlite3.c.

◆ Pager

typedef struct Pager Pager

Definition at line 14788 of file sqlite3.c.

◆ PagerSavepoint

typedef struct PagerSavepoint PagerSavepoint

Definition at line 52133 of file sqlite3.c.

◆ Parse

typedef struct Parse Parse

Definition at line 14682 of file sqlite3.c.

◆ PCache

typedef struct PCache PCache

Definition at line 16038 of file sqlite3.c.

◆ PCache1

typedef struct PCache1 PCache1

Definition at line 49843 of file sqlite3.c.

◆ PgFreeslot

typedef struct PgFreeslot PgFreeslot

Definition at line 49845 of file sqlite3.c.

◆ PgHdr

typedef struct PgHdr PgHdr

Definition at line 16037 of file sqlite3.c.

◆ PgHdr1

typedef struct PgHdr1 PgHdr1

Definition at line 49844 of file sqlite3.c.

◆ Pgno

typedef u32 Pgno

Definition at line 14783 of file sqlite3.c.

◆ PGroup

typedef struct PGroup PGroup

Definition at line 49846 of file sqlite3.c.

◆ PmaReader

typedef struct PmaReader PmaReader

Definition at line 94039 of file sqlite3.c.

◆ PmaWriter

typedef struct PmaWriter PmaWriter

Definition at line 94040 of file sqlite3.c.

◆ PragmaName

typedef struct PragmaName PragmaName

◆ PragmaVtab

typedef struct PragmaVtab PragmaVtab

Definition at line 128024 of file sqlite3.c.

◆ PragmaVtabCursor

typedef struct PragmaVtabCursor PragmaVtabCursor

Definition at line 128025 of file sqlite3.c.

◆ PreUpdate

typedef struct PreUpdate PreUpdate

Definition at line 14683 of file sqlite3.c.

◆ PrintfArguments

typedef struct PrintfArguments PrintfArguments

Definition at line 14684 of file sqlite3.c.

◆ RecordCompare

typedef int(* RecordCompare) (int, const void *, UnpackedRecord *)

Definition at line 15904 of file sqlite3.c.

◆ RenameCtx

typedef struct RenameCtx RenameCtx

Definition at line 106446 of file sqlite3.c.

◆ RenameToken

typedef struct RenameToken RenameToken

Definition at line 14685 of file sqlite3.c.

◆ RowLoadInfo

typedef struct RowLoadInfo RowLoadInfo

Definition at line 129820 of file sqlite3.c.

◆ RowSet

typedef struct RowSet RowSet

Definition at line 14686 of file sqlite3.c.

◆ Savepoint

typedef struct Savepoint Savepoint

Definition at line 14687 of file sqlite3.c.

◆ ScanStatus

typedef struct ScanStatus ScanStatus

Definition at line 21053 of file sqlite3.c.

◆ Schema

typedef struct Schema Schema

Definition at line 14666 of file sqlite3.c.

◆ Select

typedef struct Select Select

Definition at line 14688 of file sqlite3.c.

◆ SelectDest

typedef struct SelectDest SelectDest

Definition at line 14690 of file sqlite3.c.

◆ SortCtx

typedef struct SortCtx SortCtx

Definition at line 129341 of file sqlite3.c.

◆ SorterCompare

typedef int(* SorterCompare) (SortSubtask *, int *, const void *, int, const void *, int)

Definition at line 94172 of file sqlite3.c.

◆ SorterFile

typedef struct SorterFile SorterFile

Definition at line 94043 of file sqlite3.c.

◆ SorterList

typedef struct SorterList SorterList

Definition at line 94044 of file sqlite3.c.

◆ SorterRecord

typedef struct SorterRecord SorterRecord

Definition at line 94041 of file sqlite3.c.

◆ SortSubtask

typedef struct SortSubtask SortSubtask

Definition at line 94042 of file sqlite3.c.

◆ sqlite3

typedef struct sqlite3 sqlite3

Definition at line 1297 of file sqlite3.c.

◆ sqlite3_api_routines

typedef struct sqlite3_api_routines sqlite3_api_routines

Definition at line 2244 of file sqlite3.c.

◆ sqlite3_backup

typedef struct sqlite3_backup sqlite3_backup

Definition at line 9539 of file sqlite3.c.

◆ sqlite3_blob

typedef struct sqlite3_blob sqlite3_blob

Definition at line 8124 of file sqlite3.c.

◆ sqlite3_callback

typedef int(* sqlite3_callback) (void *, int, char **, char **)

Definition at line 1386 of file sqlite3.c.

◆ sqlite3_context

typedef struct sqlite3_context sqlite3_context

Definition at line 5306 of file sqlite3.c.

◆ sqlite3_destructor_type

typedef void(* sqlite3_destructor_type) (void *)

Definition at line 6669 of file sqlite3.c.

◆ sqlite3_file

typedef struct sqlite3_file sqlite3_file

Definition at line 1731 of file sqlite3.c.

◆ sqlite3_index_info

typedef struct sqlite3_index_info sqlite3_index_info

Definition at line 7738 of file sqlite3.c.

◆ sqlite3_int64

typedef sqlite_int64 sqlite3_int64

Definition at line 1329 of file sqlite3.c.

◆ sqlite3_io_methods

typedef struct sqlite3_io_methods sqlite3_io_methods

Definition at line 1830 of file sqlite3.c.

◆ sqlite3_loadext_entry

typedef int(* sqlite3_loadext_entry) (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pThunk)

Definition at line 123933 of file sqlite3.c.

◆ sqlite3_mem_methods

typedef struct sqlite3_mem_methods sqlite3_mem_methods

Definition at line 2713 of file sqlite3.c.

◆ sqlite3_module

typedef struct sqlite3_module sqlite3_module

Definition at line 7740 of file sqlite3.c.

◆ sqlite3_mutex

typedef struct sqlite3_mutex sqlite3_mutex

Definition at line 2234 of file sqlite3.c.

◆ sqlite3_mutex_methods

typedef struct sqlite3_mutex_methods sqlite3_mutex_methods

Definition at line 8572 of file sqlite3.c.

◆ sqlite3_pcache

typedef struct sqlite3_pcache sqlite3_pcache

Definition at line 9313 of file sqlite3.c.

◆ sqlite3_pcache_methods

typedef struct sqlite3_pcache_methods sqlite3_pcache_methods

Definition at line 9513 of file sqlite3.c.

◆ sqlite3_pcache_methods2

typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2

Definition at line 9490 of file sqlite3.c.

◆ sqlite3_pcache_page

typedef struct sqlite3_pcache_page sqlite3_pcache_page

Definition at line 9325 of file sqlite3.c.

◆ sqlite3_rtree_dbl

typedef double sqlite3_rtree_dbl

Definition at line 10896 of file sqlite3.c.

◆ sqlite3_rtree_geometry

typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry

Definition at line 10887 of file sqlite3.c.

◆ sqlite3_rtree_query_info

typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info

Definition at line 10888 of file sqlite3.c.

◆ sqlite3_snapshot

typedef struct sqlite3_snapshot sqlite3_snapshot

◆ sqlite3_stmt

typedef struct sqlite3_stmt sqlite3_stmt

Definition at line 4844 of file sqlite3.c.

◆ sqlite3_str

typedef struct sqlite3_str sqlite3_str

Definition at line 8832 of file sqlite3.c.

◆ sqlite3_syscall_ptr

typedef void(* sqlite3_syscall_ptr) (void)

Definition at line 2416 of file sqlite3.c.

◆ sqlite3_uint64

typedef sqlite_uint64 sqlite3_uint64

Definition at line 1330 of file sqlite3.c.

◆ sqlite3_value

typedef struct sqlite3_value sqlite3_value

Definition at line 5292 of file sqlite3.c.

◆ sqlite3_vfs

typedef struct sqlite3_vfs sqlite3_vfs

Definition at line 2415 of file sqlite3.c.

◆ sqlite3_vtab

typedef struct sqlite3_vtab sqlite3_vtab

Definition at line 7737 of file sqlite3.c.

◆ sqlite3_vtab_cursor

typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor

Definition at line 7739 of file sqlite3.c.

◆ sqlite3_xauth

typedef int(* sqlite3_xauth) (void *, int, const char *, const char *, const char *, const char *)

Definition at line 16799 of file sqlite3.c.

◆ sqlite3AutoExtList

typedef struct sqlite3AutoExtList sqlite3AutoExtList

Definition at line 124927 of file sqlite3.c.

◆ sqlite3StatType

typedef struct sqlite3StatType sqlite3StatType

Definition at line 21340 of file sqlite3.c.

◆ sqlite3StatValueType

typedef sqlite3_int64 sqlite3StatValueType

Definition at line 21336 of file sqlite3.c.

◆ sqlite_int64

typedef long long int sqlite_int64

Definition at line 1326 of file sqlite3.c.

◆ sqlite_uint64

typedef unsigned long long int sqlite_uint64

Definition at line 1327 of file sqlite3.c.

◆ SQLiteThread

typedef struct SQLiteThread SQLiteThread

Definition at line 14689 of file sqlite3.c.

◆ SrcList

typedef struct SrcList SrcList

Definition at line 14691 of file sqlite3.c.

◆ StatAccum

typedef struct StatAccum StatAccum

Definition at line 107807 of file sqlite3.c.

◆ StatSample

typedef struct StatSample StatSample

Definition at line 107808 of file sqlite3.c.

◆ StrAccum

typedef struct sqlite3_str StrAccum

Definition at line 14692 of file sqlite3.c.

◆ SubProgram

typedef struct SubProgram SubProgram

Definition at line 15427 of file sqlite3.c.

◆ SubstContext

typedef struct SubstContext SubstContext

◆ SumCtx

typedef struct SumCtx SumCtx

Definition at line 118551 of file sqlite3.c.

◆ Table

typedef struct Table Table

Definition at line 14693 of file sqlite3.c.

◆ TableLock

typedef struct TableLock TableLock

Definition at line 14694 of file sqlite3.c.

◆ TabResult

typedef struct TabResult TabResult

◆ Token

typedef struct Token Token

Definition at line 14695 of file sqlite3.c.

◆ TreeView

typedef struct TreeView TreeView

Definition at line 14696 of file sqlite3.c.

◆ Trigger

typedef struct Trigger Trigger

Definition at line 14697 of file sqlite3.c.

◆ TriggerPrg

typedef struct TriggerPrg TriggerPrg

Definition at line 14698 of file sqlite3.c.

◆ TriggerStep

typedef struct TriggerStep TriggerStep

Definition at line 14699 of file sqlite3.c.

◆ tRowcnt

typedef u32 tRowcnt

Definition at line 14354 of file sqlite3.c.

◆ u16

typedef UINT16_TYPE u16

Definition at line 14332 of file sqlite3.c.

◆ u32

typedef UINT32_TYPE u32

Definition at line 14331 of file sqlite3.c.

◆ u64

typedef sqlite_uint64 u64

Definition at line 14330 of file sqlite3.c.

◆ u8

typedef UINT8_TYPE u8

Definition at line 14334 of file sqlite3.c.

◆ unixFile

typedef struct unixFile unixFile

Definition at line 33561 of file sqlite3.c.

◆ unixInodeInfo

typedef struct unixInodeInfo unixInodeInfo

Definition at line 33542 of file sqlite3.c.

◆ unixShm

typedef struct unixShm unixShm

Definition at line 33540 of file sqlite3.c.

◆ unixShmNode

typedef struct unixShmNode unixShmNode

Definition at line 33541 of file sqlite3.c.

◆ UnixUnusedFd

typedef struct UnixUnusedFd UnixUnusedFd

Definition at line 33543 of file sqlite3.c.

◆ UnpackedRecord

typedef struct UnpackedRecord UnpackedRecord

Definition at line 14700 of file sqlite3.c.

◆ Upsert

typedef struct Upsert Upsert

Definition at line 14701 of file sqlite3.c.

◆ uptr

typedef u64 uptr

Definition at line 14404 of file sqlite3.c.

◆ Vdbe

typedef struct Vdbe Vdbe

Definition at line 15420 of file sqlite3.c.

◆ VdbeCursor

typedef struct VdbeCursor VdbeCursor

Definition at line 20779 of file sqlite3.c.

◆ VdbeFrame

typedef struct VdbeFrame VdbeFrame

Definition at line 20865 of file sqlite3.c.

◆ VdbeOp

typedef struct VdbeOp VdbeOp

Definition at line 15473 of file sqlite3.c.

◆ VdbeOpList

typedef struct VdbeOpList VdbeOpList

Definition at line 15499 of file sqlite3.c.

◆ VdbeSorter

typedef struct VdbeSorter VdbeSorter

Definition at line 20758 of file sqlite3.c.

◆ VList

typedef int VList

Definition at line 14742 of file sqlite3.c.

◆ VtabCtx

typedef struct VtabCtx VtabCtx

Definition at line 14703 of file sqlite3.c.

◆ VTable

typedef struct VTable VTable

Definition at line 14702 of file sqlite3.c.

◆ Wal

typedef struct Wal Wal

Definition at line 51622 of file sqlite3.c.

◆ WalCkptInfo

typedef struct WalCkptInfo WalCkptInfo

Definition at line 59699 of file sqlite3.c.

◆ WalHashLoc

typedef struct WalHashLoc WalHashLoc

Definition at line 60309 of file sqlite3.c.

◆ WalIndexHdr

typedef struct WalIndexHdr WalIndexHdr

Definition at line 59697 of file sqlite3.c.

◆ WalIterator

typedef struct WalIterator WalIterator

Definition at line 59698 of file sqlite3.c.

◆ Walker

typedef struct Walker Walker

Definition at line 14704 of file sqlite3.c.

◆ WalWriter

typedef struct WalWriter WalWriter

◆ WhereAndInfo

typedef struct WhereAndInfo WhereAndInfo

Definition at line 140953 of file sqlite3.c.

◆ WhereClause

typedef struct WhereClause WhereClause

Definition at line 140950 of file sqlite3.c.

◆ WhereConst

typedef struct WhereConst WhereConst

Definition at line 133496 of file sqlite3.c.

◆ WhereExprMod

typedef struct WhereExprMod WhereExprMod

Definition at line 141366 of file sqlite3.c.

◆ WhereInfo

typedef struct WhereInfo WhereInfo

Definition at line 14705 of file sqlite3.c.

◆ WhereLevel

typedef struct WhereLevel WhereLevel

Definition at line 140954 of file sqlite3.c.

◆ WhereLoop

typedef struct WhereLoop WhereLoop

Definition at line 140955 of file sqlite3.c.

◆ WhereLoopBuilder

typedef struct WhereLoopBuilder WhereLoopBuilder

Definition at line 140958 of file sqlite3.c.

◆ WhereMaskSet

typedef struct WhereMaskSet WhereMaskSet

Definition at line 140951 of file sqlite3.c.

◆ WhereOrCost

typedef struct WhereOrCost WhereOrCost

Definition at line 140960 of file sqlite3.c.

◆ WhereOrInfo

typedef struct WhereOrInfo WhereOrInfo

Definition at line 140952 of file sqlite3.c.

◆ WhereOrSet

typedef struct WhereOrSet WhereOrSet

Definition at line 140961 of file sqlite3.c.

◆ WherePath

typedef struct WherePath WherePath

Definition at line 140956 of file sqlite3.c.

◆ WhereScan

typedef struct WhereScan WhereScan

Definition at line 140959 of file sqlite3.c.

◆ WhereTerm

typedef struct WhereTerm WhereTerm

Definition at line 140957 of file sqlite3.c.

◆ Window

typedef struct Window Window

Definition at line 14706 of file sqlite3.c.

◆ WindowCodeArg

typedef struct WindowCodeArg WindowCodeArg

Definition at line 152647 of file sqlite3.c.

◆ WindowCsrAndReg

typedef struct WindowCsrAndReg WindowCsrAndReg

Definition at line 152648 of file sqlite3.c.

◆ WindowRewrite

typedef struct WindowRewrite WindowRewrite

Definition at line 151893 of file sqlite3.c.

◆ With

typedef struct With With

Definition at line 14707 of file sqlite3.c.

◆ yDbMask

typedef unsigned int yDbMask

Definition at line 18655 of file sqlite3.c.

◆ ynVar

typedef i16 ynVar

Definition at line 17925 of file sqlite3.c.

◆ yyParser

typedef struct yyParser yyParser

Definition at line 155421 of file sqlite3.c.

◆ yyStackEntry

typedef struct yyStackEntry yyStackEntry

Definition at line 155398 of file sqlite3.c.

Function Documentation

◆ absFunc()

static void absFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117190 of file sqlite3.c.

                                                                             {
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  switch( sqlite3_value_type(argv[0]) ){
    case SQLITE_INTEGER: {
      i64 iVal = sqlite3_value_int64(argv[0]);
      if( iVal<0 ){
        if( iVal==SMALLEST_INT64 ){
          /* IMP: R-31676-45509 If X is the integer -9223372036854775808
          ** then abs(X) throws an integer overflow error since there is no
          ** equivalent positive 64-bit two complement value. */
          sqlite3_result_error(context, "integer overflow", -1);
          return;
        }
        iVal = -iVal;
      }
      sqlite3_result_int64(context, iVal);
      break;
    }
    case SQLITE_NULL: {
      /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
      sqlite3_result_null(context);
      break;
    }
    default: {
      /* Because sqlite3_value_double() returns 0.0 if the argument is not
      ** something that can be converted into a number, we have:
      ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
      ** that cannot be converted to a numeric value.
      */
      double rVal = sqlite3_value_double(argv[0]);

References SMALLEST_INT64, sqlite3_result_double(), sqlite3_result_error(), sqlite3_result_int64(), sqlite3_result_null(), sqlite3_value_double(), sqlite3_value_int64(), sqlite3_value_type(), SQLITE_INTEGER, SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ accessPayload()

static int accessPayload	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		unsigned char *	pBuf,
		int	eOp )

static

Definition at line 69259 of file sqlite3.c.

 {
  unsigned char *aPayload;
  int rc = SQLITE_OK;
  int iIdx = 0;
  MemPage *pPage = pCur->pPage;               /* Btree page of current entry */
  BtShared *pBt = pCur->pBt;                  /* Btree this cursor belongs to */
#ifdef SQLITE_DIRECT_OVERFLOW_READ
  unsigned char * const pBufStart = pBuf;     /* Start of original out buffer */
#endif
 
  assert( pPage );
  assert( eOp==0 || eOp==1 );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->ix<pPage->nCell );
  assert( cursorHoldsMutex(pCur) );
 
  getCellInfo(pCur);
  aPayload = pCur->info.pPayload;
  assert( offset+amt <= pCur->info.nPayload );
 
  assert( aPayload > pPage->aData );
  if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
    /* Trying to read or write past the end of the data is an error.  The
    ** conditional above is really:
    **    &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
    ** but is recast into its current form to avoid integer overflow problems
    */
    return SQLITE_CORRUPT_PAGE(pPage);
  }
 
  /* Check if data must be read/written to/from the btree page itself. */
  if( offset<pCur->info.nLocal ){
    int a = amt;
    if( a+offset>pCur->info.nLocal ){
      a = pCur->info.nLocal - offset;
    }
    rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
    offset = 0;
    pBuf += a;
    amt -= a;
  }else{
    offset -= pCur->info.nLocal;
  }
 
 
  if( rc==SQLITE_OK && amt>0 ){
    const u32 ovflSize = pBt->usableSize - 4;  /* Bytes content per ovfl page */
    Pgno nextPage;
 
    nextPage = get4byte(&aPayload[pCur->info.nLocal]);
 
    /* If the BtCursor.aOverflow[] has not been allocated, allocate it now.
    **
    ** The aOverflow[] array is sized at one entry for each overflow page
    ** in the overflow chain. The page number of the first overflow page is
    ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array
    ** means "not yet known" (the cache is lazily populated).
    */
    if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
      int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
      if( pCur->aOverflow==0
       || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
      ){
        Pgno *aNew = (Pgno*)sqlite3Realloc(
            pCur->aOverflow, nOvfl*2*sizeof(Pgno)
        );
        if( aNew==0 ){
          return SQLITE_NOMEM_BKPT;
        }else{
          pCur->aOverflow = aNew;
        }
      }
      memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
      pCur->curFlags |= BTCF_ValidOvfl;
    }else{
      /* If the overflow page-list cache has been allocated and the
      ** entry for the first required overflow page is valid, skip
      ** directly to it.
      */
      if( pCur->aOverflow[offset/ovflSize] ){
        iIdx = (offset/ovflSize);
        nextPage = pCur->aOverflow[iIdx];
        offset = (offset%ovflSize);
      }
    }
 
    assert( rc==SQLITE_OK && amt>0 );
    while( nextPage ){
      /* If required, populate the overflow page-list cache. */
      if( nextPage > pBt->nPage ) return SQLITE_CORRUPT_BKPT;
      assert( pCur->aOverflow[iIdx]==0
              || pCur->aOverflow[iIdx]==nextPage
              || CORRUPT_DB );
      pCur->aOverflow[iIdx] = nextPage;
 
      if( offset>=ovflSize ){
        /* The only reason to read this page is to obtain the page
        ** number for the next page in the overflow chain. The page
        ** data is not required. So first try to lookup the overflow
        ** page-list cache, if any, then fall back to the getOverflowPage()
        ** function.
        */
        assert( pCur->curFlags & BTCF_ValidOvfl );
        assert( pCur->pBtree->db==pBt->db );
        if( pCur->aOverflow[iIdx+1] ){
          nextPage = pCur->aOverflow[iIdx+1];
        }else{
          rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
        }
        offset -= ovflSize;
      }else{
        /* Need to read this page properly. It contains some of the
        ** range of data that is being read (eOp==0) or written (eOp!=0).
        */
        int a = amt;
        if( a + offset > ovflSize ){
          a = ovflSize - offset;
        }
 
#ifdef SQLITE_DIRECT_OVERFLOW_READ
        /* If all the following are true:
        **
        **   1) this is a read operation, and
        **   2) data is required from the start of this overflow page, and
        **   3) there are no dirty pages in the page-cache
        **   4) the database is file-backed, and
        **   5) the page is not in the WAL file
        **   6) at least 4 bytes have already been read into the output buffer
        **
        ** then data can be read directly from the database file into the
        ** output buffer, bypassing the page-cache altogether. This speeds
        ** up loading large records that span many overflow pages.
        */
        if( eOp==0                                             /* (1) */
         && offset==0                                          /* (2) */
         && sqlite3PagerDirectReadOk(pBt->pPager, nextPage)    /* (3,4,5) */
         && &pBuf[-4]>=pBufStart                               /* (6) */
        ){
          sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
          u8 aSave[4];
          u8 *aWrite = &pBuf[-4];
          assert( aWrite>=pBufStart );                         /* due to (6) */
          memcpy(aSave, aWrite, 4);
          rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
          if( rc && nextPage>pBt->nPage ) rc = SQLITE_CORRUPT_BKPT;
          nextPage = get4byte(aWrite);
          memcpy(aWrite, aSave, 4);
        }else
#endif
 
        {
          DbPage *pDbPage;
          rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,
              (eOp==0 ? PAGER_GET_READONLY : 0)
          );
          if( rc==SQLITE_OK ){
            aPayload = sqlite3PagerGetData(pDbPage);
            nextPage = get4byte(aPayload);
            rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
            sqlite3PagerUnref(pDbPage);
            offset = 0;
          }
        }
        amt -= a;
        if( amt==0 ) return rc;
        pBuf += a;
      }
      if( rc ) break;
      iIdx++;
    }
  }
 

References MemPage::aData, BtCursor::aOverflow, BTCF_ValidOvfl, copyPayload(), CORRUPT_DB, BtCursor::curFlags, CURSOR_VALID, Btree::db, BtShared::db, BtCursor::eState, get4byte, getCellInfo(), getOverflowPage(), BtCursor::info, BtCursor::ix, MemPage::nCell, CellInfo::nLocal, BtShared::nPage, CellInfo::nPayload, PAGER_GET_READONLY, BtShared::pageSize, BtCursor::pBt, BtCursor::pBtree, MemPage::pDbPage, BtCursor::pPage, BtShared::pPager, CellInfo::pPayload, sqlite3MallocSize(), sqlite3OsRead(), sqlite3PagerFile(), sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerUnref(), sqlite3Realloc(), SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PAGE, SQLITE_NOMEM_BKPT, SQLITE_OK, and BtShared::usableSize.

Referenced by sqlite3BtreeMovetoUnpacked(), and sqlite3BtreePayload().

◆ accessPayloadChecked()

static SQLITE_NOINLINE int accessPayloadChecked	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		void *	pBuf )

static

Definition at line 69475 of file sqlite3.c.

 {
  int rc;
  if ( pCur->eState==CURSOR_INVALID ){

References CURSOR_INVALID, and BtCursor::eState.

◆ actionName()

static const char * actionName ( u8 action )

static

Definition at line 125978 of file sqlite3.c.

                                        {
  const char *zName;
  switch( action ){
    case OE_SetNull:  zName = "SET NULL";        break;
    case OE_SetDflt:  zName = "SET DEFAULT";     break;
    case OE_Cascade:  zName = "CASCADE";         break;

References OE_Cascade, OE_None, OE_Restrict, OE_SetDflt, OE_SetNull, and zName.

Referenced by sqlite3Pragma().

◆ addAggInfoColumn()

static int addAggInfoColumn	(	sqlite3 *	db,
		AggInfo *	pInfo )

static

Definition at line 105507 of file sqlite3.c.

                                                        {
  int i;
  pInfo->aCol = sqlite3ArrayAllocate(
       db,
       pInfo->aCol,

Referenced by analyzeAggregate().

◆ addAggInfoFunc()

static int addAggInfoFunc	(	sqlite3 *	db,
		AggInfo *	pInfo )

static

Definition at line 105523 of file sqlite3.c.

                                                      {
  int i;
  pInfo->aFunc = sqlite3ArrayAllocate(
       db,
       pInfo->aFunc,

Referenced by analyzeAggregate().

◆ addArgumentToVtab()

static void addArgumentToVtab ( Parse * pParse )

static

Definition at line 139996 of file sqlite3.c.

140002 {

140003 if( pParse->sArg.z && pParse->pNewTable ){

Parse::pNewTable

Table * pNewTable

Definition sqlite3.c:18762

Parse::sArg

Token sArg

Definition sqlite3.c:18769

Token::z

const char * z

Definition sqlite3.c:17864

References addModuleArgument(), Parse::db, Token::n, Parse::pNewTable, Parse::sArg, sqlite3DbStrNDup(), and Token::z.

◆ addModuleArgument()

static void addModuleArgument	(	Parse *	pParse,
		Table *	pTable,
		char *	zArg )

static

Definition at line 139925 of file sqlite3.c.

                                                                       {
  sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg);
  char **azModuleArg;
  sqlite3 *db = pParse->db;
  if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
  }
  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
  if( azModuleArg==0 ){
    sqlite3DbFree(db, zArg);
  }else{

References sqlite3::aLimit, Table::azModuleArg, Parse::db, Table::nModuleArg, sqlite3DbFree(), sqlite3DbRealloc(), sqlite3ErrorMsg(), SQLITE_LIMIT_COLUMN, and Table::zName.

Referenced by addArgumentToVtab(), sqlite3VtabBeginParse(), and sqlite3VtabEponymousTableInit().

◆ addToSavepointBitvecs()

static int addToSavepointBitvecs	(	Pager *	pPager,
		Pgno	pgno )

static

Definition at line 53484 of file sqlite3.c.

                                                          {
  int ii;                   /* Loop counter */
  int rc = SQLITE_OK;       /* Result code */
 
  for(ii=0; ii<pPager->nSavepoint; ii++){
    PagerSavepoint *p = &pPager->aSavepoint[ii];
    if( pgno<=p->nOrig ){
      rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);

References Pager::aSavepoint, Pager::nSavepoint, PagerSavepoint::pInSavepoint, sqlite3BitvecSet(), SQLITE_NOMEM, SQLITE_OK, and testcase.

Referenced by getPageNormal().

◆ addToVTrans()

static void addToVTrans	(	sqlite3 *	db,
		VTable *	pVTab )

static

Definition at line 140311 of file sqlite3.c.

Referenced by sqlite3VtabBegin(), and sqlite3VtabCallCreate().

◆ addWhereTerm()

static void addWhereTerm	(	Parse *	pParse,
		SrcList *	pSrc,
		int	iLeft,
		int	iColLeft,
		int	iRight,
		int	iColRight,
		int	isOuterJoin,
		Expr **	ppWhere )

static

Definition at line 129615 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  Expr *pE1;
  Expr *pE2;
  Expr *pEq;
 
  assert( iLeft<iRight );
  assert( pSrc->nSrc>iRight );
  assert( pSrc->a[iLeft].pTab );
  assert( pSrc->a[iRight].pTab );
 
  pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
  pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
 
  pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
  if( pEq && isOuterJoin ){
    ExprSetProperty(pEq, EP_FromJoin);

References SrcList::a, Parse::db, EP_FromJoin, EP_NoReduce, EP_Reduced, EP_TokenOnly, ExprHasProperty, ExprSetProperty, ExprSetVVAProperty, Expr::iRightJoinTable, Expr::iTable, SrcList::nSrc, SrcList::SrcList_item::pTab, sqlite3CreateColumnExpr(), sqlite3ExprAnd(), sqlite3PExpr(), and TK_EQ.

Referenced by sqliteProcessJoin().

◆ agginfoFree()

static void agginfoFree	(	sqlite3 *	db,
		AggInfo *	p )

static

Definition at line 128882 of file sqlite3.c.

◆ agginfoPersistExprCb()

static int agginfoPersistExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 105458 of file sqlite3.c.

                                                             {
  if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
   && pExpr->pAggInfo!=0
  ){
    AggInfo *pAggInfo = pExpr->pAggInfo;
    int iAgg = pExpr->iAgg;
    Parse *pParse = pWalker->pParse;
    sqlite3 *db = pParse->db;
    assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_AGG_FUNCTION );
    if( pExpr->op==TK_AGG_COLUMN ){
      assert( iAgg>=0 && iAgg<pAggInfo->nColumn );
      if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){
        pExpr = sqlite3ExprDup(db, pExpr, 0);
        if( pExpr ){
          pAggInfo->aCol[iAgg].pCExpr = pExpr;
          pParse->pConstExpr =
             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
        }
      }
    }else{
      assert( iAgg>=0 && iAgg<pAggInfo->nFunc );
      if( pAggInfo->aFunc[iAgg].pFExpr==pExpr ){
        pExpr = sqlite3ExprDup(db, pExpr, 0);
        if( pExpr ){
          pAggInfo->aFunc[iAgg].pFExpr = pExpr;
          pParse->pConstExpr =
             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);

References AggInfo::aCol, AggInfo::aFunc, ALWAYS, Parse::db, EP_Reduced, EP_TokenOnly, ExprHasProperty, Expr::iAgg, Expr::op, Expr::pAggInfo, AggInfo::AggInfo_col::pCExpr, Parse::pConstExpr, AggInfo::AggInfo_func::pFExpr, Walker::pParse, sqlite3ExprDup(), sqlite3ExprListAppend(), TK_AGG_COLUMN, TK_AGG_FUNCTION, and WRC_Continue.

◆ allocateBtreePage()

static int allocateBtreePage	(	BtShared *	pBt,
		MemPage **	ppPage,
		Pgno *	pPgno,
		Pgno	nearby,
		u8	eMode )

static

Definition at line 70389 of file sqlite3.c.

 {
  MemPage *pPage1;
  int rc;
  u32 n;     /* Number of pages on the freelist */
  u32 k;     /* Number of leaves on the trunk of the freelist */
  MemPage *pTrunk = 0;
  MemPage *pPrevTrunk = 0;
  Pgno mxPage;     /* Total size of the database file */
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
  pPage1 = pBt->pPage1;
  mxPage = btreePagecount(pBt);
  /* EVIDENCE-OF: R-05119-02637 The 4-byte big-endian integer at offset 36
  ** stores stores the total number of pages on the freelist. */
  n = get4byte(&pPage1->aData[36]);
  testcase( n==mxPage-1 );
  if( n>=mxPage ){
    return SQLITE_CORRUPT_BKPT;
  }
  if( n>0 ){
    /* There are pages on the freelist.  Reuse one of those pages. */
    Pgno iTrunk;
    u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
    u32 nSearch = 0;   /* Count of the number of search attempts */
 
    /* If eMode==BTALLOC_EXACT and a query of the pointer-map
    ** shows that the page 'nearby' is somewhere on the free-list, then
    ** the entire-list will be searched for that page.
    */
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( eMode==BTALLOC_EXACT ){
      if( nearby<=mxPage ){
        u8 eType;
        assert( nearby>0 );
        assert( pBt->autoVacuum );
        rc = ptrmapGet(pBt, nearby, &eType, 0);
        if( rc ) return rc;
        if( eType==PTRMAP_FREEPAGE ){
          searchList = 1;
        }
      }
    }else if( eMode==BTALLOC_LE ){
      searchList = 1;
    }
#endif
 
    /* Decrement the free-list count by 1. Set iTrunk to the index of the
    ** first free-list trunk page. iPrevTrunk is initially 1.
    */
    rc = sqlite3PagerWrite(pPage1->pDbPage);
    if( rc ) return rc;
    put4byte(&pPage1->aData[36], n-1);
 
    /* The code within this loop is run only once if the 'searchList' variable
    ** is not true. Otherwise, it runs once for each trunk-page on the
    ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT)
    ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT)
    */
    do {
      pPrevTrunk = pTrunk;
      if( pPrevTrunk ){
        /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page
        ** is the page number of the next freelist trunk page in the list or
        ** zero if this is the last freelist trunk page. */
        iTrunk = get4byte(&pPrevTrunk->aData[0]);
      }else{
        /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32
        ** stores the page number of the first page of the freelist, or zero if
        ** the freelist is empty. */
        iTrunk = get4byte(&pPage1->aData[32]);
      }
      testcase( iTrunk==mxPage );
      if( iTrunk>mxPage || nSearch++ > n ){
        rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1);
      }else{
        rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0);
      }
      if( rc ){
        pTrunk = 0;
        goto end_allocate_page;
      }
      assert( pTrunk!=0 );
      assert( pTrunk->aData!=0 );
      /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page
      ** is the number of leaf page pointers to follow. */
      k = get4byte(&pTrunk->aData[4]);
      if( k==0 && !searchList ){
        /* The trunk has no leaves and the list is not being searched.
        ** So extract the trunk page itself and use it as the newly
        ** allocated page */
        assert( pPrevTrunk==0 );
        rc = sqlite3PagerWrite(pTrunk->pDbPage);
        if( rc ){
          goto end_allocate_page;
        }
        *pPgno = iTrunk;
        memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
        *ppPage = pTrunk;
        pTrunk = 0;
        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
      }else if( k>(u32)(pBt->usableSize/4 - 2) ){
        /* Value of k is out of range.  Database corruption */
        rc = SQLITE_CORRUPT_PGNO(iTrunk);
        goto end_allocate_page;
#ifndef SQLITE_OMIT_AUTOVACUUM
      }else if( searchList
            && (nearby==iTrunk || (iTrunk<nearby && eMode==BTALLOC_LE))
      ){
        /* The list is being searched and this trunk page is the page
        ** to allocate, regardless of whether it has leaves.
        */
        *pPgno = iTrunk;
        *ppPage = pTrunk;
        searchList = 0;
        rc = sqlite3PagerWrite(pTrunk->pDbPage);
        if( rc ){
          goto end_allocate_page;
        }
        if( k==0 ){
          if( !pPrevTrunk ){
            memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
          }else{
            rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
            if( rc!=SQLITE_OK ){
              goto end_allocate_page;
            }
            memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
          }
        }else{
          /* The trunk page is required by the caller but it contains
          ** pointers to free-list leaves. The first leaf becomes a trunk
          ** page in this case.
          */
          MemPage *pNewTrunk;
          Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
          if( iNewTrunk>mxPage ){
            rc = SQLITE_CORRUPT_PGNO(iTrunk);
            goto end_allocate_page;
          }
          testcase( iNewTrunk==mxPage );
          rc = btreeGetUnusedPage(pBt, iNewTrunk, &pNewTrunk, 0);
          if( rc!=SQLITE_OK ){
            goto end_allocate_page;
          }
          rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
          if( rc!=SQLITE_OK ){
            releasePage(pNewTrunk);
            goto end_allocate_page;
          }
          memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
          put4byte(&pNewTrunk->aData[4], k-1);
          memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
          releasePage(pNewTrunk);
          if( !pPrevTrunk ){
            assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
            put4byte(&pPage1->aData[32], iNewTrunk);
          }else{
            rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
            if( rc ){
              goto end_allocate_page;
            }
            put4byte(&pPrevTrunk->aData[0], iNewTrunk);
          }
        }
        pTrunk = 0;
        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
#endif
      }else if( k>0 ){
        /* Extract a leaf from the trunk */
        u32 closest;
        Pgno iPage;
        unsigned char *aData = pTrunk->aData;
        if( nearby>0 ){
          u32 i;
          closest = 0;
          if( eMode==BTALLOC_LE ){
            for(i=0; i<k; i++){
              iPage = get4byte(&aData[8+i*4]);
              if( iPage<=nearby ){
                closest = i;
                break;
              }
            }
          }else{
            int dist;
            dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
            for(i=1; i<k; i++){
              int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
              if( d2<dist ){
                closest = i;
                dist = d2;
              }
            }
          }
        }else{
          closest = 0;
        }
 
        iPage = get4byte(&aData[8+closest*4]);
        testcase( iPage==mxPage );
        if( iPage>mxPage ){
          rc = SQLITE_CORRUPT_PGNO(iTrunk);
          goto end_allocate_page;
        }
        testcase( iPage==mxPage );
        if( !searchList
         || (iPage==nearby || (iPage<nearby && eMode==BTALLOC_LE))
        ){
          int noContent;
          *pPgno = iPage;
          TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
                 ": %d more free pages\n",
                 *pPgno, closest+1, k, pTrunk->pgno, n-1));
          rc = sqlite3PagerWrite(pTrunk->pDbPage);
          if( rc ) goto end_allocate_page;
          if( closest<k-1 ){
            memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
          }
          put4byte(&aData[4], k-1);
          noContent = !btreeGetHasContent(pBt, *pPgno)? PAGER_GET_NOCONTENT : 0;
          rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, noContent);
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerWrite((*ppPage)->pDbPage);
            if( rc!=SQLITE_OK ){
              releasePage(*ppPage);
              *ppPage = 0;
            }
          }
          searchList = 0;
        }
      }
      releasePage(pPrevTrunk);
      pPrevTrunk = 0;
    }while( searchList );
  }else{
    /* There are no pages on the freelist, so append a new page to the
    ** database image.
    **
    ** Normally, new pages allocated by this block can be requested from the
    ** pager layer with the 'no-content' flag set. This prevents the pager
    ** from trying to read the pages content from disk. However, if the
    ** current transaction has already run one or more incremental-vacuum
    ** steps, then the page we are about to allocate may contain content
    ** that is required in the event of a rollback. In this case, do
    ** not set the no-content flag. This causes the pager to load and journal
    ** the current page content before overwriting it.
    **
    ** Note that the pager will not actually attempt to load or journal
    ** content for any page that really does lie past the end of the database
    ** file on disk. So the effects of disabling the no-content optimization
    ** here are confined to those pages that lie between the end of the
    ** database image and the end of the database file.
    */
    int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0;
 
    rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
    if( rc ) return rc;
    pBt->nPage++;
    if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
 
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
      /* If *pPgno refers to a pointer-map page, allocate two new pages
      ** at the end of the file instead of one. The first allocated page
      ** becomes a new pointer-map page, the second is used by the caller.
      */
      MemPage *pPg = 0;
      TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
      assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
      rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent);
      if( rc==SQLITE_OK ){
        rc = sqlite3PagerWrite(pPg->pDbPage);
        releasePage(pPg);
      }
      if( rc ) return rc;
      pBt->nPage++;
      if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
    }
#endif
    put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
    *pPgno = pBt->nPage;
 
    assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
    rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent);
    if( rc ) return rc;
    rc = sqlite3PagerWrite((*ppPage)->pDbPage);
    if( rc!=SQLITE_OK ){
      releasePage(*ppPage);
      *ppPage = 0;
    }
    TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
  }
 
  assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) );
 
end_allocate_page:

References MemPage::aData, BtShared::autoVacuum, BtShared::bDoTruncate, BTALLOC_ANY, BTALLOC_EXACT, BTALLOC_LE, btreeGetHasContent(), btreeGetUnusedPage(), btreePagecount(), CORRUPT_DB, eType, get4byte, IfNotOmitAV, BtShared::mutex, BtShared::nPage, PAGER_GET_NOCONTENT, MemPage::pDbPage, PENDING_BYTE_PAGE, MemPage::pgno, BtShared::pPage1, PTRMAP_FREEPAGE, PTRMAP_ISPAGE, ptrmapGet(), put4byte, releasePage(), sqlite3_mutex_held(), sqlite3AbsInt32(), sqlite3PagerPageRefcount(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PGNO, SQLITE_OK, testcase, TRACE, and BtShared::usableSize.

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), btreeCreateTable(), fillInCell(), and incrVacuumStep().

◆ allocateCursor()

static VdbeCursor * allocateCursor	(	Vdbe *	p,
		int	iCur,
		int	nField,
		int	iDb,
		u8	eCurType )

static

Definition at line 85472 of file sqlite3.c.

 {
  /* Find the memory cell that will be used to store the blob of memory
  ** required for this VdbeCursor structure. It is convenient to use a
  ** vdbe memory cell to manage the memory allocation required for a
  ** VdbeCursor structure for the following reasons:
  **
  **   * Sometimes cursor numbers are used for a couple of different
  **     purposes in a vdbe program. The different uses might require
  **     different sized allocations. Memory cells provide growable
  **     allocations.
  **
  **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
  **     be freed lazily via the sqlite3_release_memory() API. This
  **     minimizes the number of malloc calls made by the system.
  **
  ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from
  ** the top of the register space.  Cursor 1 is at Mem[p->nMem-1].
  ** Cursor 2 is at Mem[p->nMem-2]. And so forth.
  */
  Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
 
  int nByte;
  VdbeCursor *pCx = 0;
  nByte =
      ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
      (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
 
  assert( iCur>=0 && iCur<p->nCursor );
  if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
    /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag
    ** is clear. Otherwise, if this is an ephemeral cursor created by
    ** OP_OpenDup, the cursor will not be closed and will still be part
    ** of a BtShared.pCursor list.  */
    if( p->apCsr[iCur]->pBtx==0 ) p->apCsr[iCur]->isEphemeral = 0;
    sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
    p->apCsr[iCur] = 0;
  }
  if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){
    p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
    memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
    pCx->eCurType = eCurType;
    pCx->iDb = iDb;
    pCx->nField = nField;
    pCx->aOffset = &pCx->aType[nField];
    if( eCurType==CURTYPE_BTREE ){
      pCx->uc.pCursor = (BtCursor*)

References Vdbe::aMem, VdbeCursor::aOffset, Vdbe::apCsr, VdbeCursor::aType, CURTYPE_BTREE, VdbeCursor::eCurType, VdbeCursor::iDb, VdbeCursor::isEphemeral, VdbeCursor::nField, Vdbe::nMem, offsetof, VdbeCursor::pBtx, VdbeCursor::pCursor, ROUND8, sqlite3BtreeCursorSize(), sqlite3BtreeCursorZero(), sqlite3VdbeFreeCursor(), sqlite3VdbeMemClearAndResize(), SQLITE_OK, VdbeCursor::uc, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ allocateIndexInfo()

static sqlite3_index_info * allocateIndexInfo	(	Parse *	pParse,
		WhereClause *	pWC,
		Bitmask	mUnusable,
		struct SrcList_item *	pSrc,
		ExprList *	pOrderBy,
		u16 *	pmNoOmit )

static

Definition at line 146509 of file sqlite3.c.

 {
  int i, j;
  int nTerm;
  struct sqlite3_index_constraint *pIdxCons;
  struct sqlite3_index_orderby *pIdxOrderBy;
  struct sqlite3_index_constraint_usage *pUsage;
  struct HiddenIndexInfo *pHidden;
  WhereTerm *pTerm;
  int nOrderBy;
  sqlite3_index_info *pIdxInfo;
  u16 mNoOmit = 0;
 
  /* Count the number of possible WHERE clause constraints referring
  ** to this virtual table */
  for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    if( pTerm->leftCursor != pSrc->iCursor ) continue;
    if( pTerm->prereqRight & mUnusable ) continue;
    assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
    testcase( pTerm->eOperator & WO_IN );
    testcase( pTerm->eOperator & WO_ISNULL );
    testcase( pTerm->eOperator & WO_IS );
    testcase( pTerm->eOperator & WO_ALL );
    if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
    if( pTerm->wtFlags & TERM_VNULL ) continue;
    assert( pTerm->u.leftColumn>=(-1) );
    nTerm++;
  }
 
  /* If the ORDER BY clause contains only columns in the current
  ** virtual table then allocate space for the aOrderBy part of
  ** the sqlite3_index_info structure.
  */
  nOrderBy = 0;
  if( pOrderBy ){
    int n = pOrderBy->nExpr;
    for(i=0; i<n; i++){
      Expr *pExpr = pOrderBy->a[i].pExpr;
      if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
      if( pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL ) break;
    }
    if( i==n){
      nOrderBy = n;
    }
  }
 
  /* Allocate the sqlite3_index_info structure
  */
  pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
                           + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
                           + sizeof(*pIdxOrderBy)*nOrderBy + sizeof(*pHidden) );
  if( pIdxInfo==0 ){
    sqlite3ErrorMsg(pParse, "out of memory");
    return 0;
  }
  pHidden = (struct HiddenIndexInfo*)&pIdxInfo[1];
  pIdxCons = (struct sqlite3_index_constraint*)&pHidden[1];
  pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm];
  pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy];
  pIdxInfo->nOrderBy = nOrderBy;
  pIdxInfo->aConstraint = pIdxCons;
  pIdxInfo->aOrderBy = pIdxOrderBy;
  pIdxInfo->aConstraintUsage = pUsage;
  pHidden->pWC = pWC;
  pHidden->pParse = pParse;
  for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    u16 op;
    if( pTerm->leftCursor != pSrc->iCursor ) continue;
    if( pTerm->prereqRight & mUnusable ) continue;
    assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
    testcase( pTerm->eOperator & WO_IN );
    testcase( pTerm->eOperator & WO_IS );
    testcase( pTerm->eOperator & WO_ISNULL );
    testcase( pTerm->eOperator & WO_ALL );
    if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
    if( pTerm->wtFlags & TERM_VNULL ) continue;
 
    /* tag-20191211-002: WHERE-clause constraints are not useful to the
    ** right-hand table of a LEFT JOIN.  See tag-20191211-001 for the
    ** equivalent restriction for ordinary tables. */
    if( (pSrc->fg.jointype & JT_LEFT)!=0
     && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
    ){
      continue;
    }
    assert( pTerm->u.leftColumn>=(-1) );
    pIdxCons[j].iColumn = pTerm->u.leftColumn;
    pIdxCons[j].iTermOffset = i;
    op = pTerm->eOperator & WO_ALL;
    if( op==WO_IN ) op = WO_EQ;
    if( op==WO_AUX ){
      pIdxCons[j].op = pTerm->eMatchOp;
    }else if( op & (WO_ISNULL|WO_IS) ){
      if( op==WO_ISNULL ){
        pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_ISNULL;
      }else{
        pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_IS;
      }
    }else{
      pIdxCons[j].op = (u8)op;
      /* The direct assignment in the previous line is possible only because
      ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical.  The
      ** following asserts verify this fact. */
      assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
      assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
      assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
      assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
      assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
      assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
 
      if( op & (WO_LT|WO_LE|WO_GT|WO_GE)
       && sqlite3ExprIsVector(pTerm->pExpr->pRight)
      ){
        testcase( j!=i );
        if( j<16 ) mNoOmit |= (1 << j);
        if( op==WO_LT ) pIdxCons[j].op = WO_LE;
        if( op==WO_GT ) pIdxCons[j].op = WO_GE;
      }
    }
 
    j++;
  }
  pIdxInfo->nConstraint = j;
  for(i=0; i<nOrderBy; i++){
    Expr *pExpr = pOrderBy->a[i].pExpr;
    pIdxOrderBy[i].iColumn = pExpr->iColumn;

References ExprList::a, WhereClause::a, sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::aOrderBy, Parse::db, WhereTerm::eMatchOp, WhereTerm::eOperator, EP_FromJoin, ExprHasProperty, Expr::iColumn, IsPowerOfTwo, Expr::iTable, JT_LEFT, KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, WhereTerm::leftColumn, WhereTerm::leftCursor, sqlite3_index_info::nConstraint, ExprList::nExpr, sqlite3_index_info::nOrderBy, WhereClause::nTerm, Expr::op, ExprList::ExprList_item::pExpr, WhereTerm::pExpr, HiddenIndexInfo::pParse, WhereTerm::prereqRight, Expr::pRight, HiddenIndexInfo::pWC, ExprList::ExprList_item::sortFlags, sqlite3DbMallocZero(), sqlite3ErrorMsg(), sqlite3ExprIsVector(), SQLITE_INDEX_CONSTRAINT_EQ, SQLITE_INDEX_CONSTRAINT_GE, SQLITE_INDEX_CONSTRAINT_GT, SQLITE_INDEX_CONSTRAINT_IS, SQLITE_INDEX_CONSTRAINT_ISNULL, SQLITE_INDEX_CONSTRAINT_LE, SQLITE_INDEX_CONSTRAINT_LT, TERM_VNULL, testcase, TK_COLUMN, WhereTerm::u, WO_ALL, WO_AUX, WO_EQ, WO_EQUIV, WO_GE, WO_GT, WO_IN, WO_IS, WO_ISNULL, WO_LE, WO_LT, and WhereTerm::wtFlags.

Referenced by whereLoopAddVirtual().

◆ allocateSpace()

static int allocateSpace	(	MemPage *	pPage,
		int	nByte,
		int *	pIdx )

static

Definition at line 66089 of file sqlite3.c.

                                                              {
  const int hdr = pPage->hdrOffset;    /* Local cache of pPage->hdrOffset */
  u8 * const data = pPage->aData;      /* Local cache of pPage->aData */
  int top;                             /* First byte of cell content area */
  int rc = SQLITE_OK;                  /* Integer return code */
  int gap;        /* First byte of gap between cell pointers and cell content */
 
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( pPage->pBt );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( nByte>=0 );  /* Minimum cell size is 4 */
  assert( pPage->nFree>=nByte );
  assert( pPage->nOverflow==0 );
  assert( nByte < (int)(pPage->pBt->usableSize-8) );
 
  assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
  gap = pPage->cellOffset + 2*pPage->nCell;
  assert( gap<=65536 );
  /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size
  ** and the reserved space is zero (the usual value for reserved space)
  ** then the cell content offset of an empty page wants to be 65536.
  ** However, that integer is too large to be stored in a 2-byte unsigned
  ** integer, so a value of 0 is used in its place. */
  top = get2byte(&data[hdr+5]);
  assert( top<=(int)pPage->pBt->usableSize ); /* by btreeComputeFreeSpace() */
  if( gap>top ){
    if( top==0 && pPage->pBt->usableSize==65536 ){
      top = 65536;
    }else{
      return SQLITE_CORRUPT_PAGE(pPage);
    }
  }
 
  /* If there is enough space between gap and top for one more cell pointer,
  ** and if the freelist is not empty, then search the
  ** freelist looking for a slot big enough to satisfy the request.
  */
  testcase( gap+2==top );
  testcase( gap+1==top );
  testcase( gap==top );
  if( (data[hdr+2] || data[hdr+1]) && gap+2<=top ){
    u8 *pSpace = pageFindSlot(pPage, nByte, &rc);
    if( pSpace ){
      int g2;
      assert( pSpace+nByte<=data+pPage->pBt->usableSize );
      *pIdx = g2 = (int)(pSpace-data);
      if( NEVER(g2<=gap) ){
        return SQLITE_CORRUPT_PAGE(pPage);
      }else{
        return SQLITE_OK;
      }
    }else if( rc ){
      return rc;
    }
  }
 
  /* The request could not be fulfilled using a freelist slot.  Check
  ** to see if defragmentation is necessary.
  */
  testcase( gap+2+nByte==top );
  if( gap+2+nByte>top ){
    assert( pPage->nCell>0 || CORRUPT_DB );
    assert( pPage->nFree>=0 );
    rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
    if( rc ) return rc;
    top = get2byteNotZero(&data[hdr+5]);
    assert( gap+2+nByte<=top );
  }
 
 
  /* Allocate memory from the gap in between the cell pointer array
  ** and the cell content area.  The btreeComputeFreeSpace() call has already
  ** validated the freelist.  Given that the freelist is valid, there
  ** is no way that the allocation can extend off the end of the page.
  ** The assert() below verifies the previous sentence.
  */

References MemPage::aData, MemPage::cellOffset, CORRUPT_DB, defragmentPage(), get2byte, get2byteNotZero, MemPage::hdrOffset, MemPage::leaf, MIN, BtShared::mutex, MemPage::nCell, NEVER, MemPage::nFree, MemPage::nOverflow, pageFindSlot(), MemPage::pBt, MemPage::pDbPage, put2byte, sqlite3_mutex_held(), SQLITE_CORRUPT_PAGE, SQLITE_OK, testcase, and BtShared::usableSize.

Referenced by insertCell().

◆ allocateTempSpace()

static void allocateTempSpace ( BtShared * pBt )

static

Definition at line 67146 of file sqlite3.c.

                                            {
  if( !pBt->pTmpSpace ){
    pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
 
    /* One of the uses of pBt->pTmpSpace is to format cells before
    ** inserting them into a leaf page (function fillInCell()). If
    ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes
    ** by the various routines that manipulate binary cells. Which
    ** can mean that fillInCell() only initializes the first 2 or 3
    ** bytes of pTmpSpace, but that the first 4 bytes are copied from
    ** it into a database page. This is not actually a problem, but it
    ** does cause a valgrind error when the 1 or 2 bytes of unitialized
    ** data is passed to system call write(). So to avoid this error,
    ** zero the first 4 bytes of temp space here.
    **
    ** Also:  Provide four bytes of initialized space before the
    ** beginning of pTmpSpace as an area available to prepend the
    ** left-child pointer to the beginning of a cell.
    */

References BtShared::pageSize, BtShared::pTmpSpace, and sqlite3PageMalloc().

Referenced by btreeCursor().

◆ allocSpace()

static void * allocSpace	(	struct ReusableSpace *	p,
		void *	pBuf,
		sqlite3_int64	nByte )

static

Definition at line 79999 of file sqlite3.c.

 {
  assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
  if( pBuf==0 ){
    nByte = ROUND8(nByte);
    if( nByte <= p->nFree ){
      p->nFree -= nByte;
      pBuf = &p->pSpace[p->nFree];
    }else{

References EIGHT_BYTE_ALIGNMENT, ReusableSpace::nFree, ReusableSpace::nNeeded, ReusableSpace::pSpace, and ROUND8.

Referenced by sqlite3VdbeMakeReady().

◆ allowedOp()

static int allowedOp ( int op )

static

Definition at line 144091 of file sqlite3.c.

144097 {

References TK_EQ, TK_GE, TK_GT, TK_IN, TK_IS, TK_ISNULL, TK_LE, and TK_LT.

Referenced by exprAnalyze(), and exprAnalyzeOrTerm().

◆ alsoAnInt()

static int alsoAnInt	(	Mem *	pRec,
		double	rValue,
		i64 *	piValue )

static

Definition at line 85537 of file sqlite3.c.

85543 {

85544 i64 iValue = (double)rValue;

References sqlite3_value::enc, sqlite3_value::n, sqlite3Atoi64(), sqlite3RealSameAsInt(), and sqlite3_value::z.

Referenced by applyNumericAffinity().

◆ analysisLoader()

static int analysisLoader	(	void *	pData,
		int	argc,
		char **	argv,
		char **	NotUsed )

static

Definition at line 109091 of file sqlite3.c.

                                                                             {
  analysisInfo *pInfo = (analysisInfo*)pData;
  Index *pIndex;
  Table *pTable;
  const char *z;
 
  assert( argc==3 );
  UNUSED_PARAMETER2(NotUsed, argc);
 
  if( argv==0 || argv[0]==0 || argv[2]==0 ){
    return 0;
  }
  pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
  if( pTable==0 ){
    return 0;
  }
  if( argv[1]==0 ){
    pIndex = 0;
  }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){
    pIndex = sqlite3PrimaryKeyIndex(pTable);
  }else{
    pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
  }
  z = argv[2];
 
  if( pIndex ){
    tRowcnt *aiRowEst = 0;
    int nCol = pIndex->nKeyCol+1;
#ifdef SQLITE_ENABLE_STAT4
    /* Index.aiRowEst may already be set here if there are duplicate
    ** sqlite_stat1 entries for this index. In that case just clobber
    ** the old data with the new instead of allocating a new array.  */
    if( pIndex->aiRowEst==0 ){
      pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
      if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db);
    }
    aiRowEst = pIndex->aiRowEst;
#endif
    pIndex->bUnordered = 0;
    decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
    pIndex->hasStat1 = 1;
    if( pIndex->pPartIdxWhere==0 ){
      pTable->nRowLogEst = pIndex->aiRowLogEst[0];
      pTable->tabFlags |= TF_HasStat1;
    }
  }else{
    Index fakeIdx;
    fakeIdx.szIdxRow = pTable->szTabRow;
#ifdef SQLITE_ENABLE_COSTMULT
    fakeIdx.pTable = pTable;
#endif
    decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);

References Index::aiRowLogEst, Index::bUnordered, analysisInfo::db, decodeIntArray(), Index::hasStat1, Index::nKeyCol, Table::nRowLogEst, Index::pPartIdxWhere, Index::pTable, sqlite3_stricmp(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3MallocZero(), sqlite3OomFault(), sqlite3PrimaryKeyIndex(), Index::szIdxRow, Table::szTabRow, Table::tabFlags, TF_HasStat1, UNUSED_PARAMETER2, and analysisInfo::zDatabase.

Referenced by sqlite3AnalysisLoad().

◆ analyzeAggregate()

static int analyzeAggregate	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 105540 of file sqlite3.c.

                                                         {
  int i;
  NameContext *pNC = pWalker->u.pNC;
  Parse *pParse = pNC->pParse;
  SrcList *pSrcList = pNC->pSrcList;
  AggInfo *pAggInfo = pNC->uNC.pAggInfo;
 
  assert( pNC->ncFlags & NC_UAggInfo );
  switch( pExpr->op ){
    case TK_AGG_COLUMN:
    case TK_COLUMN: {
      testcase( pExpr->op==TK_AGG_COLUMN );
      testcase( pExpr->op==TK_COLUMN );
      /* Check to see if the column is in one of the tables in the FROM
      ** clause of the aggregate query */
      if( ALWAYS(pSrcList!=0) ){
        struct SrcList_item *pItem = pSrcList->a;
        for(i=0; i<pSrcList->nSrc; i++, pItem++){
          struct AggInfo_col *pCol;
          assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
          if( pExpr->iTable==pItem->iCursor ){
            /* If we reach this point, it means that pExpr refers to a table
            ** that is in the FROM clause of the aggregate query.
            **
            ** Make an entry for the column in pAggInfo->aCol[] if there
            ** is not an entry there already.
            */
            int k;
            pCol = pAggInfo->aCol;
            for(k=0; k<pAggInfo->nColumn; k++, pCol++){
              if( pCol->iTable==pExpr->iTable &&
                  pCol->iColumn==pExpr->iColumn ){
                break;
              }
            }
            if( (k>=pAggInfo->nColumn)
             && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
            ){
              pCol = &pAggInfo->aCol[k];
              pCol->pTab = pExpr->y.pTab;
              pCol->iTable = pExpr->iTable;
              pCol->iColumn = pExpr->iColumn;
              pCol->iMem = ++pParse->nMem;
              pCol->iSorterColumn = -1;
              pCol->pCExpr = pExpr;
              if( pAggInfo->pGroupBy ){
                int j, n;
                ExprList *pGB = pAggInfo->pGroupBy;
                struct ExprList_item *pTerm = pGB->a;
                n = pGB->nExpr;
                for(j=0; j<n; j++, pTerm++){
                  Expr *pE = pTerm->pExpr;
                  if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
                      pE->iColumn==pExpr->iColumn ){
                    pCol->iSorterColumn = j;
                    break;
                  }
                }
              }
              if( pCol->iSorterColumn<0 ){
                pCol->iSorterColumn = pAggInfo->nSortingColumn++;
              }
            }
            /* There is now an entry for pExpr in pAggInfo->aCol[] (either
            ** because it was there before or because we just created it).
            ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
            ** pAggInfo->aCol[] entry.
            */
            ExprSetVVAProperty(pExpr, EP_NoReduce);
            pExpr->pAggInfo = pAggInfo;
            pExpr->op = TK_AGG_COLUMN;
            pExpr->iAgg = (i16)k;
            break;
          } /* endif pExpr->iTable==pItem->iCursor */
        } /* end loop over pSrcList */
      }
      return WRC_Prune;
    }
    case TK_AGG_FUNCTION: {
      if( (pNC->ncFlags & NC_InAggFunc)==0
       && pWalker->walkerDepth==pExpr->op2
      ){
        /* Check to see if pExpr is a duplicate of another aggregate
        ** function that is already in the pAggInfo structure
        */
        struct AggInfo_func *pItem = pAggInfo->aFunc;
        for(i=0; i<pAggInfo->nFunc; i++, pItem++){
          if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
            break;
          }
        }
        if( i>=pAggInfo->nFunc ){
          /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]
          */
          u8 enc = ENC(pParse->db);
          i = addAggInfoFunc(pParse->db, pAggInfo);
          if( i>=0 ){
            assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
            pItem = &pAggInfo->aFunc[i];
            pItem->pFExpr = pExpr;
            pItem->iMem = ++pParse->nMem;
            assert( !ExprHasProperty(pExpr, EP_IntValue) );
            pItem->pFunc = sqlite3FindFunction(pParse->db,
                   pExpr->u.zToken,
                   pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
            if( pExpr->flags & EP_Distinct ){
              pItem->iDistinct = pParse->nTab++;
            }else{
              pItem->iDistinct = -1;
            }
          }
        }
        /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
        */
        assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
        ExprSetVVAProperty(pExpr, EP_NoReduce);
        pExpr->iAgg = (i16)i;
        pExpr->pAggInfo = pAggInfo;
        return WRC_Prune;
      }else{

References ExprList::a, SrcList::a, AggInfo::aCol, addAggInfoColumn(), addAggInfoFunc(), AggInfo::aFunc, ALWAYS, Parse::db, ENC, EP_Distinct, EP_IntValue, EP_NoReduce, EP_Reduced, EP_TokenOnly, EP_xIsSelect, ExprHasProperty, ExprSetVVAProperty, Expr::flags, Expr::iAgg, Expr::iColumn, Expr::iTable, NC_InAggFunc, NC_UAggInfo, NameContext::ncFlags, AggInfo::nColumn, ExprList::nExpr, AggInfo::nFunc, Parse::nMem, AggInfo::nSortingColumn, SrcList::nSrc, Parse::nTab, Expr::op, Expr::op2, Expr::pAggInfo, NameContext::pAggInfo, AggInfo::AggInfo_func::pFExpr, AggInfo::pGroupBy, Expr::pList, Walker::pNC, NameContext::pParse, NameContext::pSrcList, AggInfo::AggInfo_col::pTab, Expr::pTab, sqlite3ExprCompare(), sqlite3FindFunction(), testcase, TK_AGG_COLUMN, TK_AGG_FUNCTION, TK_COLUMN, Expr::u, Walker::u, NameContext::uNC, Walker::walkerDepth, WRC_Continue, WRC_Prune, Expr::x, Expr::y, and Expr::zToken.

Referenced by sqlite3ExprAnalyzeAggregates().

◆ analyzeDatabase()

static void analyzeDatabase	(	Parse *	pParse,
		int	iDb )

static

Definition at line 108897 of file sqlite3.c.

                                                   {
  sqlite3 *db = pParse->db;
  Schema *pSchema = db->aDb[iDb].pSchema;    /* Schema of database iDb */
  HashElem *k;
  int iStatCur;
  int iMem;
  int iTab;
 
  sqlite3BeginWriteOperation(pParse, 0, iDb);
  iStatCur = pParse->nTab;
  pParse->nTab += 3;
  openStatTable(pParse, iDb, iStatCur, 0, 0);
  iMem = pParse->nMem+1;
  iTab = pParse->nTab;
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

Referenced by sqlite3Analyze().

◆ analyzeFilterKeyword()

static int analyzeFilterKeyword	(	const unsigned char *	z,
		int	lastToken )

static

Definition at line 159996 of file sqlite3.c.

                        {
    int t = getToken(&z);
    if( t==TK_LP || t==TK_ID ) return TK_OVER;
  }
  return TK_ID;
}

References getToken(), TK_ID, TK_LP, and TK_OVER.

Referenced by sqlite3RunParser().

◆ analyzeOneTable()

static void analyzeOneTable	(	Parse *	pParse,
		Table *	pTab,
		Index *	pOnlyIdx,
		int	iStatCur,
		int	iMem,
		int	iTab )

static

Definition at line 108525 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;    /* Database handle */
  Index *pIdx;                 /* An index to being analyzed */
  int iIdxCur;                 /* Cursor open on index being analyzed */
  int iTabCur;                 /* Table cursor */
  Vdbe *v;                     /* The virtual machine being built up */
  int i;                       /* Loop counter */
  int jZeroRows = -1;          /* Jump from here if number of rows is zero */
  int iDb;                     /* Index of database containing pTab */
  u8 needTableCnt = 1;         /* True to count the table */
  int regNewRowid = iMem++;    /* Rowid for the inserted record */
  int regStat = iMem++;        /* Register to hold StatAccum object */
  int regChng = iMem++;        /* Index of changed index field */
  int regRowid = iMem++;       /* Rowid argument passed to stat_push() */
  int regTemp = iMem++;        /* Temporary use register */
  int regTemp2 = iMem++;       /* Second temporary use register */
  int regTabname = iMem++;     /* Register containing table name */
  int regIdxname = iMem++;     /* Register containing index name */
  int regStat1 = iMem++;       /* Value for the stat column of sqlite_stat1 */
  int regPrev = iMem;          /* MUST BE LAST (see below) */
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  Table *pStat1 = 0;
#endif
 
  pParse->nMem = MAX(pParse->nMem, iMem);
  v = sqlite3GetVdbe(pParse);
  if( v==0 || NEVER(pTab==0) ){
    return;
  }
  if( pTab->tnum==0 ){
    /* Do not gather statistics on views or virtual tables */
    return;
  }
  if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
    /* Do not gather statistics on system tables */
    return;
  }
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb>=0 );
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
      db->aDb[iDb].zDbSName ) ){
    return;
  }
#endif
 
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  if( db->xPreUpdateCallback ){
    pStat1 = (Table*)sqlite3DbMallocZero(db, sizeof(Table) + 13);
    if( pStat1==0 ) return;
    pStat1->zName = (char*)&pStat1[1];
    memcpy(pStat1->zName, "sqlite_stat1", 13);
    pStat1->nCol = 3;
    pStat1->iPKey = -1;
    sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNBLOB);
  }
#endif
 
  /* Establish a read-lock on the table at the shared-cache level.
  ** Open a read-only cursor on the table. Also allocate a cursor number
  ** to use for scanning indexes (iIdxCur). No index cursor is opened at
  ** this time though.  */
  sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
  iTabCur = iTab++;
  iIdxCur = iTab++;
  pParse->nTab = MAX(pParse->nTab, iTab);
  sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
  sqlite3VdbeLoadString(v, regTabname, pTab->zName);
 
  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    int nCol;                     /* Number of columns in pIdx. "N" */
    int addrRewind;               /* Address of "OP_Rewind iIdxCur" */
    int addrNextRow;              /* Address of "next_row:" */
    const char *zIdxName;         /* Name of the index */
    int nColTest;                 /* Number of columns to test for changes */
 
    if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
    if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0;
    if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){
      nCol = pIdx->nKeyCol;
      zIdxName = pTab->zName;
      nColTest = nCol - 1;
    }else{
      nCol = pIdx->nColumn;
      zIdxName = pIdx->zName;
      nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
    }
 
    /* Populate the register containing the index name. */
    sqlite3VdbeLoadString(v, regIdxname, zIdxName);
    VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
 
    /*
    ** Pseudo-code for loop that calls stat_push():
    **
    **   Rewind csr
    **   if eof(csr) goto end_of_scan;
    **   regChng = 0
    **   goto chng_addr_0;
    **
    **  next_row:
    **   regChng = 0
    **   if( idx(0) != regPrev(0) ) goto chng_addr_0
    **   regChng = 1
    **   if( idx(1) != regPrev(1) ) goto chng_addr_1
    **   ...
    **   regChng = N
    **   goto chng_addr_N
    **
    **  chng_addr_0:
    **   regPrev(0) = idx(0)
    **  chng_addr_1:
    **   regPrev(1) = idx(1)
    **  ...
    **
    **  endDistinctTest:
    **   regRowid = idx(rowid)
    **   stat_push(P, regChng, regRowid)
    **   Next csr
    **   if !eof(csr) goto next_row;
    **
    **  end_of_scan:
    */
 
    /* Make sure there are enough memory cells allocated to accommodate
    ** the regPrev array and a trailing rowid (the rowid slot is required
    ** when building a record to insert into the sample column of
    ** the sqlite_stat4 table.  */
    pParse->nMem = MAX(pParse->nMem, regPrev+nColTest);
 
    /* Open a read-only cursor on the index being analyzed. */
    assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
    sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
    sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
    VdbeComment((v, "%s", pIdx->zName));
 
    /* Invoke the stat_init() function. The arguments are:
    **
    **    (1) the number of columns in the index including the rowid
    **        (or for a WITHOUT ROWID table, the number of PK columns),
    **    (2) the number of columns in the key without the rowid/pk
    **    (3) estimated number of rows in the index,
    */
    sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
    assert( regRowid==regStat+2 );
    sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
#ifdef SQLITE_ENABLE_STAT4
    if( OptimizationEnabled(db, SQLITE_Stat4) ){
      sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regTemp);
      addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
      VdbeCoverage(v);
    }else
#endif
    {
      addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
      VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp, 1);
    }
    assert( regTemp2==regStat+4 );
    sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
    sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4,
                               &statInitFuncdef, 0);
 
    /* Implementation of the following:
    **
    **   Rewind csr
    **   if eof(csr) goto end_of_scan;
    **   regChng = 0
    **   goto next_push_0;
    **
    */
    sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng);
    addrNextRow = sqlite3VdbeCurrentAddr(v);
 
    if( nColTest>0 ){
      int endDistinctTest = sqlite3VdbeMakeLabel(pParse);
      int *aGotoChng;               /* Array of jump instruction addresses */
      aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest);
      if( aGotoChng==0 ) continue;
 
      /*
      **  next_row:
      **   regChng = 0
      **   if( idx(0) != regPrev(0) ) goto chng_addr_0
      **   regChng = 1
      **   if( idx(1) != regPrev(1) ) goto chng_addr_1
      **   ...
      **   regChng = N
      **   goto endDistinctTest
      */
      sqlite3VdbeAddOp0(v, OP_Goto);
      addrNextRow = sqlite3VdbeCurrentAddr(v);
      if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){
        /* For a single-column UNIQUE index, once we have found a non-NULL
        ** row, we know that all the rest will be distinct, so skip
        ** subsequent distinctness tests. */
        sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest);
        VdbeCoverage(v);
      }
      for(i=0; i<nColTest; i++){
        char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
        sqlite3VdbeAddOp2(v, OP_Integer, i, regChng);
        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp);
        analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
        aGotoChng[i] =
        sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ);
        sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
        VdbeCoverage(v);
      }
      sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng);
      sqlite3VdbeGoto(v, endDistinctTest);
 
 
      /*
      **  chng_addr_0:
      **   regPrev(0) = idx(0)
      **  chng_addr_1:
      **   regPrev(1) = idx(1)
      **  ...
      */
      sqlite3VdbeJumpHere(v, addrNextRow-1);
      for(i=0; i<nColTest; i++){
        sqlite3VdbeJumpHere(v, aGotoChng[i]);
        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regPrev+i);
        analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
      }
      sqlite3VdbeResolveLabel(v, endDistinctTest);
      sqlite3DbFree(db, aGotoChng);
    }
 
    /*
    **  chng_addr_N:
    **   regRowid = idx(rowid)            // STAT4 only
    **   stat_push(P, regChng, regRowid)  // 3rd parameter STAT4 only
    **   Next csr
    **   if !eof(csr) goto next_row;
    */
#ifdef SQLITE_ENABLE_STAT4
    if( OptimizationEnabled(db, SQLITE_Stat4) ){
      assert( regRowid==(regStat+2) );
      if( HasRowid(pTab) ){
        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
      }else{
        Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
        int j, k, regKey;
        regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
        for(j=0; j<pPk->nKeyCol; j++){
          k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
          assert( k>=0 && k<pIdx->nColumn );
          sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j);
          analyzeVdbeCommentIndexWithColumnName(v,pIdx,k);
        }
        sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid);
        sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol);
      }
    }
#endif
    assert( regChng==(regStat+1) );
    {
      sqlite3VdbeAddFunctionCall(pParse, 1, regStat, regTemp, 2+IsStat4,
                                 &statPushFuncdef, 0);
      if( db->nAnalysisLimit ){
        int j1, j2, j3;
        j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regTemp); VdbeCoverage(v);
        j2 = sqlite3VdbeAddOp1(v, OP_If, regTemp); VdbeCoverage(v);
        j3 = sqlite3VdbeAddOp4Int(v, OP_SeekGT, iIdxCur, 0, regPrev, 1);
        VdbeCoverage(v);
        sqlite3VdbeJumpHere(v, j1);
        sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
        sqlite3VdbeJumpHere(v, j2);
        sqlite3VdbeJumpHere(v, j3);
      }else{
        sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
      }
    }
 
    /* Add the entry to the stat1 table. */
    callStatGet(pParse, regStat, STAT_GET_STAT1, regStat1);
    assert( "BBB"[0]==SQLITE_AFF_TEXT );
    sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
    sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
    sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
#endif
    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
 
    /* Add the entries to the stat4 table. */
#ifdef SQLITE_ENABLE_STAT4
    if( OptimizationEnabled(db, SQLITE_Stat4) && db->nAnalysisLimit==0 ){
      int regEq = regStat1;
      int regLt = regStat1+1;
      int regDLt = regStat1+2;
      int regSample = regStat1+3;
      int regCol = regStat1+4;
      int regSampleRowid = regCol + nCol;
      int addrNext;
      int addrIsNull;
      u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
 
      pParse->nMem = MAX(pParse->nMem, regCol+nCol);
 
      addrNext = sqlite3VdbeCurrentAddr(v);
      callStatGet(pParse, regStat, STAT_GET_ROWID, regSampleRowid);
      addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid);
      VdbeCoverage(v);
      callStatGet(pParse, regStat, STAT_GET_NEQ, regEq);
      callStatGet(pParse, regStat, STAT_GET_NLT, regLt);
      callStatGet(pParse, regStat, STAT_GET_NDLT, regDLt);
      sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0);
      VdbeCoverage(v);
      for(i=0; i<nCol; i++){
        sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, i, regCol+i);
      }
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regTabname, 6, regTemp);
      sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regTemp, regNewRowid);
      sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
      sqlite3VdbeJumpHere(v, addrIsNull);
    }
#endif /* SQLITE_ENABLE_STAT4 */
 
    /* End of analysis */
    sqlite3VdbeJumpHere(v, addrRewind);
  }
 
 
  /* Create a single sqlite_stat1 entry containing NULL as the index
  ** name and the row count as the content.
  */
  if( pOnlyIdx==0 && needTableCnt ){
    VdbeComment((v, "%s", pTab->zName));
    sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1);
    jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
    assert( "BBB"[0]==SQLITE_AFF_TEXT );
    sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
    sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
    sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);

References sqlite3::aDb, Index::aiColumn, analyzeVdbeCommentIndexWithColumnName, Index::azColl, callStatGet(), Parse::db, HasRowid, Table::iPKey, IsPrimaryKeyIndex, IsStat4, IsUniqueIndex, MAX, sqlite3::nAnalysisLimit, Table::nCol, Index::nColumn, NEVER, Index::nKeyCol, Parse::nMem, Parse::nTab, OP_Column, OP_Count, OP_Goto, OP_IdxRowid, OP_If, OP_IfNot, OP_Insert, OP_Integer, OP_IsNull, OP_MakeRecord, OP_Ne, OP_NewRowid, OP_Next, OP_Noop, OP_NotExists, OP_NotFound, OP_NotNull, OP_Null, OP_OpenRead, OP_Rewind, OP_SeekGT, OPFLAG_APPEND, OptimizationEnabled, P4_COLLSEQ, P4_DYNBLOB, P4_TABLE, Table::pIndex, Index::pNext, Index::pPartIdxWhere, Table::pSchema, Index::pSchema, Index::pTable, Parse::pVdbe, sqlite3_strlike(), sqlite3AuthCheck(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3DbMallocZero(), sqlite3ExprCodeLoadIndexColumn(), sqlite3GetTempRange(), sqlite3GetVdbe(), sqlite3LocateCollSeq(), sqlite3OpenTable(), sqlite3PrimaryKeyIndex(), sqlite3ReleaseTempRange(), sqlite3SchemaToIndex(), sqlite3TableColumnToIndex(), sqlite3TableLock(), sqlite3VdbeAddFunctionCall(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeLoadString(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeSetP4KeyInfo(), SQLITE_AFF_TEXT, SQLITE_ANALYZE, SQLITE_NULLEQ, SQLITE_Stat4, STAT_GET_NDLT, STAT_GET_NEQ, STAT_GET_NLT, STAT_GET_ROWID, STAT_GET_STAT1, statInitFuncdef, statPushFuncdef, Table::tnum, Index::tnum, Index::uniqNotNull, VdbeComment, VdbeCoverage, Db::zDbSName, Table::zName, and Index::zName.

Referenced by analyzeTable().

◆ analyzeOverKeyword()

static int analyzeOverKeyword	(	const unsigned char *	z,
		int	lastToken )

static

Definition at line 159989 of file sqlite3.c.

159995 {

Referenced by sqlite3RunParser().

◆ analyzeTable()

static void analyzeTable	(	Parse *	pParse,
		Table *	pTab,
		Index *	pOnlyIdx )

static

Definition at line 108924 of file sqlite3.c.

                                                                     {
  int iDb;
  int iStatCur;
 
  assert( pTab!=0 );
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  sqlite3BeginWriteOperation(pParse, 0, iDb);
  iStatCur = pParse->nTab;
  pParse->nTab += 3;
  if( pOnlyIdx ){
    openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");

References analyzeOneTable(), Parse::db, loadAnalysis(), Parse::nMem, Parse::nTab, openStatTable(), Table::pSchema, sqlite3BeginWriteOperation(), sqlite3SchemaToIndex(), Table::zName, and Index::zName.

Referenced by sqlite3Analyze().

◆ analyzeWindowKeyword()

static int analyzeWindowKeyword ( const unsigned char * z )

static

Definition at line 159981 of file sqlite3.c.

                         :
**
**   * the previous token was TK_RP, and
**   * the next token is TK_LP.
*/
static int analyzeWindowKeyword(const unsigned char *z){
  int t;

Referenced by sqlite3RunParser().

◆ anotherValidCursor()

static int anotherValidCursor ( BtCursor * pCur )

static

Definition at line 72838 of file sqlite3.c.

                                             {
  BtCursor *pOther;
  for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
    if( pOther!=pCur
     && pOther->eState==CURSOR_VALID
     && pOther->pPage==pCur->pPage

References CURSOR_VALID, BtCursor::eState, BtCursor::pBt, BtShared::pCursor, BtCursor::pNext, BtCursor::pPage, SQLITE_CORRUPT_BKPT, and SQLITE_OK.

Referenced by balance().

◆ apiOomError()

static SQLITE_NOINLINE int apiOomError ( sqlite3 * db )

static

Definition at line 28103 of file sqlite3.c.

Referenced by sqlite3ApiExit().

◆ appendText()

static char * appendText	(	char *	p,
		const char *	z )

static

Definition at line 165226 of file sqlite3.c.

Referenced by sqlite3_create_filename().

◆ applyAffinity()

static void applyAffinity	(	Mem *	pRec,
		char	affinity,
		u8	enc )

static

Definition at line 85601 of file sqlite3.c.

                  :
** SQLITE_AFF_NONE:
**    No-op.  pRec is unchanged.
*/
static void applyAffinity(
  Mem *pRec,          /* The value to apply affinity to */
  char affinity,      /* The affinity to be applied */
  u8 enc              /* Use this text encoding */
){
  if( affinity>=SQLITE_AFF_NUMERIC ){
    assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
             || affinity==SQLITE_AFF_NUMERIC );
    if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
      if( (pRec->flags & MEM_Real)==0 ){
        if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
      }else{
        sqlite3VdbeIntegerAffinity(pRec);
      }
    }
  }else if( affinity==SQLITE_AFF_TEXT ){
    /* Only attempt the conversion to TEXT if there is an integer or real
    ** representation (blob and NULL do not get converted) but no string
    ** representation.  It would be harmless to repeat the conversion if
    ** there is already a string rep, but it is pointless to waste those
    ** CPU cycles. */
    if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
      if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
        testcase( pRec->flags & MEM_Int );
        testcase( pRec->flags & MEM_Real );
        testcase( pRec->flags & MEM_IntReal );

References applyNumericAffinity(), sqlite3_value::flags, MEM_Int, MEM_IntReal, MEM_Real, MEM_Str, sqlite3VdbeIntegerAffinity(), sqlite3VdbeMemStringify(), SQLITE_AFF_INTEGER, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, and testcase.

Referenced by sqlite3VdbeExec().

◆ applyNumericAffinity()

static void applyNumericAffinity	(	Mem *	pRec,
		int	bTryForInt )

static

Definition at line 85561 of file sqlite3.c.

                                                           {
  double rValue;
  u8 enc = pRec->enc;
  int rc;
  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
  rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
  if( rc<=0 ) return;
  if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
    pRec->flags |= MEM_Int;
  }else{
    pRec->u.r = rValue;
    pRec->flags |= MEM_Real;
    if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
  }

References alsoAnInt(), sqlite3_value::enc, sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Int, MEM_IntReal, MEM_Real, MEM_Str, sqlite3_value::n, sqlite3_value::MemValue::r, sqlite3AtoF(), sqlite3VdbeIntegerAffinity(), sqlite3_value::u, and sqlite3_value::z.

Referenced by applyAffinity(), sqlite3_value_numeric_type(), and sqlite3VdbeExec().

◆ areDoubleQuotedStringsEnabled()

static int areDoubleQuotedStringsEnabled	(	sqlite3 *	db,
		NameContext *	pTopNC )

static

Definition at line 97920 of file sqlite3.c.

                                                                          {
  if( db->init.busy ) return 1;  /* Always support for legacy schemas */
  if( pTopNC->ncFlags & NC_IsDDL ){
    /* Currently parsing a DDL statement */
    if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
      return 1;
    }

Referenced by lookupName().

◆ attachBackupObject()

static void attachBackupObject ( sqlite3_backup * p )

static

Definition at line 75359 of file sqlite3.c.

75365 {

75366 sqlite3_backup **pp;

sqlite3_backup

Definition sqlite3.c:75071

◆ attachFunc()

static void attachFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 109562 of file sqlite3.c.

 {
  int i;
  int rc = 0;
  sqlite3 *db = sqlite3_context_db_handle(context);
  const char *zName;
  const char *zFile;
  char *zPath = 0;
  char *zErr = 0;
  unsigned int flags;
  Db *aNew;                 /* New array of Db pointers */
  Db *pNew;                 /* Db object for the newly attached database */
  char *zErrDyn = 0;
  sqlite3_vfs *pVfs;
 
  UNUSED_PARAMETER(NotUsed);
  zFile = (const char *)sqlite3_value_text(argv[0]);
  zName = (const char *)sqlite3_value_text(argv[1]);
  if( zFile==0 ) zFile = "";
  if( zName==0 ) zName = "";
 
#ifdef SQLITE_ENABLE_DESERIALIZE
# define REOPEN_AS_MEMDB(db)  (db->init.reopenMemdb)
#else
# define REOPEN_AS_MEMDB(db)  (0)
#endif
 
  if( REOPEN_AS_MEMDB(db) ){
    /* This is not a real ATTACH.  Instead, this routine is being called
    ** from sqlite3_deserialize() to close database db->init.iDb and
    ** reopen it as a MemDB */
    pVfs = sqlite3_vfs_find("memdb");
    if( pVfs==0 ) return;
    pNew = &db->aDb[db->init.iDb];
    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
    pNew->pBt = 0;
    pNew->pSchema = 0;
    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
  }else{
    /* This is a real ATTACH
    **
    ** Check for the following errors:
    **
    **     * Too many attached databases,
    **     * Transaction currently open
    **     * Specified database name already being used.
    */
    if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
      zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
        db->aLimit[SQLITE_LIMIT_ATTACHED]
      );
      goto attach_error;
    }
    for(i=0; i<db->nDb; i++){
      assert( zName );
      if( sqlite3DbIsNamed(db, i, zName) ){
        zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
        goto attach_error;
      }
    }
 
    /* Allocate the new entry in the db->aDb[] array and initialize the schema
    ** hash tables.
    */
    if( db->aDb==db->aDbStatic ){
      aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
      if( aNew==0 ) return;
      memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
    }else{
      aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
      if( aNew==0 ) return;
    }
    db->aDb = aNew;
    pNew = &db->aDb[db->nDb];
    memset(pNew, 0, sizeof(*pNew));
 
    /* Open the database file. If the btree is successfully opened, use
    ** it to obtain the database schema. At this point the schema may
    ** or may not be initialized.
    */
    flags = db->openFlags;
    rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
    if( rc!=SQLITE_OK ){
      if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
      sqlite3_result_error(context, zErr, -1);
      sqlite3_free(zErr);
      return;
    }
    assert( pVfs );
    flags |= SQLITE_OPEN_MAIN_DB;
    rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
    db->nDb++;
    pNew->zDbSName = sqlite3DbStrDup(db, zName);
  }
  db->noSharedCache = 0;
  if( rc==SQLITE_CONSTRAINT ){
    rc = SQLITE_ERROR;
    zErrDyn = sqlite3MPrintf(db, "database is already attached");
  }else if( rc==SQLITE_OK ){
    Pager *pPager;
    pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
    if( !pNew->pSchema ){
      rc = SQLITE_NOMEM_BKPT;
    }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
      zErrDyn = sqlite3MPrintf(db,
        "attached databases must use the same text encoding as main database");
      rc = SQLITE_ERROR;
    }
    sqlite3BtreeEnter(pNew->pBt);
    pPager = sqlite3BtreePager(pNew->pBt);
    sqlite3PagerLockingMode(pPager, db->dfltLockMode);
    sqlite3BtreeSecureDelete(pNew->pBt,
                             sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
    sqlite3BtreeSetPagerFlags(pNew->pBt,
                      PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
#endif
    sqlite3BtreeLeave(pNew->pBt);
  }
  pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
  if( rc==SQLITE_OK && pNew->zDbSName==0 ){
    rc = SQLITE_NOMEM_BKPT;
  }
  sqlite3_free_filename( zPath );
 
  /* If the file was opened successfully, read the schema for the new database.
  ** If this fails, or if opening the file failed, then close the file and
  ** remove the entry from the db->aDb[] array. i.e. put everything back the
  ** way we found it.
  */
  if( rc==SQLITE_OK ){
    sqlite3BtreeEnterAll(db);
    db->init.iDb = 0;
    db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
    if( !REOPEN_AS_MEMDB(db) ){
      rc = sqlite3Init(db, &zErrDyn);
    }
    sqlite3BtreeLeaveAll(db);
    assert( zErrDyn==0 || rc!=SQLITE_OK );
  }
#ifdef SQLITE_USER_AUTHENTICATION
  if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
    u8 newAuth = 0;
    rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
    if( newAuth<db->auth.authLevel ){
      rc = SQLITE_AUTH_USER;
    }
  }
#endif
  if( rc ){
    if( !REOPEN_AS_MEMDB(db) ){
      int iDb = db->nDb - 1;
      assert( iDb>=2 );
      if( db->aDb[iDb].pBt ){
        sqlite3BtreeClose(db->aDb[iDb].pBt);
        db->aDb[iDb].pBt = 0;
        db->aDb[iDb].pSchema = 0;
      }
      sqlite3ResetAllSchemasOfConnection(db);
      db->nDb = iDb;
      if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
        sqlite3OomFault(db);
        sqlite3DbFree(db, zErrDyn);
        zErrDyn = sqlite3MPrintf(db, "out of memory");
      }else if( zErrDyn==0 ){
        zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
      }
    }
    goto attach_error;
  }
 
  return;
 
attach_error:
  /* Return an error if we get here */

References sqlite3::aDb, sqlite3::aDbStatic, sqlite3::aLimit, DBFLAG_SchemaKnownOk, sqlite3::dfltLockMode, Schema::enc, ENC, Schema::file_format, sqlite3::flags, sqlite3::sqlite3InitInfo::iDb, sqlite3::init, sqlite3::mDbFlags, sqlite3::nDb, sqlite3::noSharedCache, sqlite3::openFlags, PAGER_FLAGS_MASK, PAGER_SYNCHRONOUS_FULL, Db::pBt, Db::pSchema, sqlite3::pVfs, REOPEN_AS_MEMDB, Db::safety_level, sqlite3_context_db_handle(), sqlite3_free(), sqlite3_free_filename(), sqlite3_result_error(), sqlite3_result_error_code(), sqlite3_value_text(), sqlite3_vfs_find(), sqlite3BtreeClose(), sqlite3BtreeEnter(), sqlite3BtreeEnterAll(), sqlite3BtreeLeave(), sqlite3BtreeLeaveAll(), sqlite3BtreeOpen(), sqlite3BtreePager(), sqlite3BtreeSecureDelete(), sqlite3BtreeSetPagerFlags(), sqlite3DbFree(), sqlite3DbIsNamed(), sqlite3DbMallocRawNN(), sqlite3DbRealloc(), sqlite3DbStrDup(), sqlite3Init(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3PagerLockingMode(), sqlite3ParseUri(), sqlite3ResetAllSchemasOfConnection(), sqlite3SchemaGet(), SQLITE_AUTH_USER, SQLITE_CONSTRAINT, SQLITE_DEFAULT_SYNCHRONOUS, SQLITE_ERROR, SQLITE_IOERR_NOMEM, SQLITE_LIMIT_ATTACHED, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_MAIN_DB, UNUSED_PARAMETER, Db::zDbSName, sqlite3_vfs::zName, and zName.

Referenced by sqlite3Attach().

◆ autoIncBegin()

static int autoIncBegin	(	Parse *	pParse,
		int	iDb,
		Table *	pTab )

static

Definition at line 120888 of file sqlite3.c.

 {
  int memId = 0;      /* Register holding maximum rowid */
  assert( pParse->db->aDb[iDb].pSchema!=0 );
  if( (pTab->tabFlags & TF_Autoincrement)!=0
   && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
  ){
    Parse *pToplevel = sqlite3ParseToplevel(pParse);
    AutoincInfo *pInfo;
    Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
 
    /* Verify that the sqlite_sequence table exists and is an ordinary
    ** rowid table with exactly two columns.
    ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
    if( pSeqTab==0
     || !HasRowid(pSeqTab)
     || IsVirtual(pSeqTab)
     || pSeqTab->nCol!=2
    ){
      pParse->nErr++;
      pParse->rc = SQLITE_CORRUPT_SEQUENCE;
      return 0;
    }
 
    pInfo = pToplevel->pAinc;
    while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
    if( pInfo==0 ){
      pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
      if( pInfo==0 ) return 0;
      pInfo->pNext = pToplevel->pAinc;
      pToplevel->pAinc = pInfo;
      pInfo->pTab = pTab;
      pInfo->iDb = iDb;
      pToplevel->nMem++;                  /* Register to hold name of table */
      pInfo->regCtr = ++pToplevel->nMem;  /* Max rowid register */

References sqlite3::aDb, Parse::db, DBFLAG_Vacuum, HasRowid, AutoincInfo::iDb, IsVirtual, sqlite3::mDbFlags, Table::nCol, Parse::nErr, Parse::nMem, Parse::pAinc, AutoincInfo::pNext, Db::pSchema, Schema::pSeqTab, AutoincInfo::pTab, Parse::rc, AutoincInfo::regCtr, sqlite3DbMallocRawNN(), sqlite3ParseToplevel, SQLITE_CORRUPT_SEQUENCE, Table::tabFlags, and TF_Autoincrement.

Referenced by sqlite3Insert(), and xferOptimization().

◆ autoIncrementEnd()

static SQLITE_NOINLINE void autoIncrementEnd ( Parse * pParse )

static

Definition at line 121011 of file sqlite3.c.

                                                           {
  AutoincInfo *p;
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;
 
  assert( v );
  for(p = pParse->pAinc; p; p = p->pNext){
    static const int iLn = VDBE_OFFSET_LINENO(2);
    static const VdbeOpList autoIncEnd[] = {
      /* 0 */ {OP_NotNull,     0, 2, 0},
      /* 1 */ {OP_NewRowid,    0, 0, 0},
      /* 2 */ {OP_MakeRecord,  0, 2, 0},
      /* 3 */ {OP_Insert,      0, 0, 0},
      /* 4 */ {OP_Close,       0, 0, 0}
    };
    VdbeOp *aOp;
    Db *pDb = &db->aDb[p->iDb];
    int iRec;
    int memId = p->regCtr;
 
    iRec = sqlite3GetTempReg(pParse);
    assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
    sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
    VdbeCoverage(v);
    sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
    aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
    if( aOp==0 ) break;
    aOp[0].p1 = memId+1;
    aOp[1].p2 = memId+1;
    aOp[2].p1 = memId-1;
    aOp[2].p3 = iRec;

References sqlite3::aDb, ArraySize, Parse::db, AutoincInfo::iDb, OP_Close, OP_Insert, OP_Le, OP_MakeRecord, OP_NewRowid, OP_NotNull, OP_OpenWrite, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, Parse::pAinc, AutoincInfo::pNext, Db::pSchema, Schema::pSeqTab, Parse::pVdbe, AutoincInfo::regCtr, sqlite3GetTempReg(), sqlite3OpenTable(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOpList(), sqlite3VdbeCurrentAddr(), VDBE_OFFSET_LINENO, and VdbeCoverage.

◆ autoIncStep()

static void autoIncStep	(	Parse *	pParse,
		int	memId,
		int	regRowid )

static

Definition at line 120998 of file sqlite3.c.

References OP_MemMax, Parse::pVdbe, and sqlite3VdbeAddOp2().

Referenced by sqlite3Insert(), and xferOptimization().

◆ autoVacuumCommit()

static int autoVacuumCommit ( BtShared * pBt )

static

Definition at line 68394 of file sqlite3.c.

                                          {
  int rc = SQLITE_OK;
  Pager *pPager = pBt->pPager;
  VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); )
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  invalidateAllOverflowCache(pBt);
  assert(pBt->autoVacuum);
  if( !pBt->incrVacuum ){
    Pgno nFin;         /* Number of pages in database after autovacuuming */
    Pgno nFree;        /* Number of pages on the freelist initially */
    Pgno iFree;        /* The next page to be freed */
    Pgno nOrig;        /* Database size before freeing */
 
    nOrig = btreePagecount(pBt);
    if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
      /* It is not possible to create a database for which the final page
      ** is either a pointer-map page or the pending-byte page. If one
      ** is encountered, this indicates corruption.
      */
      return SQLITE_CORRUPT_BKPT;
    }
 
    nFree = get4byte(&pBt->pPage1->aData[36]);
    nFin = finalDbSize(pBt, nOrig, nFree);
    if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT;
    if( nFin<nOrig ){
      rc = saveAllCursors(pBt, 0, 0);
    }
    for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
      rc = incrVacuumStep(pBt, nFin, iFree, 1);
    }
    if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
      rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
      put4byte(&pBt->pPage1->aData[32], 0);
      put4byte(&pBt->pPage1->aData[36], 0);
      put4byte(&pBt->pPage1->aData[28], nFin);
      pBt->bDoTruncate = 1;
      pBt->nPage = nFin;
    }
    if( rc!=SQLITE_OK ){
      sqlite3PagerRollback(pPager);

References MemPage::aData, BtShared::autoVacuum, BtShared::bDoTruncate, btreePagecount(), finalDbSize(), get4byte, BtShared::incrVacuum, incrVacuumStep(), invalidateAllOverflowCache(), BtShared::mutex, BtShared::nPage, MemPage::pDbPage, PENDING_BYTE_PAGE, BtShared::pPage1, BtShared::pPager, PTRMAP_ISPAGE, put4byte, saveAllCursors(), sqlite3_mutex_held(), sqlite3PagerRollback(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_DONE, SQLITE_OK, and VVA_ONLY.

Referenced by sqlite3BtreeCommitPhaseOne().

◆ avgFinalize()

static void avgFinalize ( sqlite3_context * context )

static

Definition at line 118630 of file sqlite3.c.

         {
      sqlite3_result_int64(context, p->iSum);
    }
  }
}
static void avgFinalize(sqlite3_context *context){

Referenced by sqlite3RegisterBuiltinFunctions().

◆ backupOnePage()

static int backupOnePage	(	sqlite3_backup *	p,
		Pgno	iSrcPg,
		const u8 *	zSrcData,
		int	bUpdate )

static

Definition at line 75277 of file sqlite3.c.

 {
  Pager * const pDestPager = sqlite3BtreePager(p->pDest);
  const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc);
  int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest);
  const int nCopy = MIN(nSrcPgsz, nDestPgsz);
  const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz;
  int rc = SQLITE_OK;
  i64 iOff;
 
  assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 );
  assert( p->bDestLocked );
  assert( !isFatalError(p->rc) );
  assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
  assert( zSrcData );
 
  /* Catch the case where the destination is an in-memory database and the
  ** page sizes of the source and destination differ.
  */
  if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){
    rc = SQLITE_READONLY;
  }
 
  /* This loop runs once for each destination page spanned by the source
  ** page. For each iteration, variable iOff is set to the byte offset
  ** of the destination page.
  */
  for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
    DbPage *pDestPg = 0;
    Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
    if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
    if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0))
     && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
    ){
      const u8 *zIn = &zSrcData[iOff%nSrcPgsz];
      u8 *zDestData = sqlite3PagerGetData(pDestPg);
      u8 *zOut = &zDestData[iOff%nDestPgsz];
 
      /* Copy the data from the source page into the destination page.
      ** Then clear the Btree layer MemPage.isInit flag. Both this module
      ** and the pager code use this trick (clearing the first byte
      ** of the page 'extra' space to invalidate the Btree layers
      ** cached parse of the page). MemPage.isInit is marked
      ** "MUST BE FIRST" for this purpose.
      */
      memcpy(zOut, zIn, nCopy);
      ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0;
      if( iOff==0 && bUpdate==0 ){
        sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc));
      }

References sqlite3_backup::bDestLocked, isFatalError(), MIN, Btree::pBt, sqlite3_backup::pDest, PENDING_BYTE_PAGE, sqlite3_backup::pSrc, sqlite3_backup::rc, sqlite3BtreeGetPageSize(), sqlite3BtreeGetReserveNoMutex(), sqlite3BtreeLastPage(), sqlite3BtreePager(), sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerGetExtra(), sqlite3PagerIsMemdb(), sqlite3PagerUnref(), sqlite3PagerWrite(), sqlite3Put4byte(), SQLITE_OK, and SQLITE_READONLY.

Referenced by backupUpdate().

◆ backupTruncateFile()

static int backupTruncateFile	(	sqlite3_file *	pFile,
		i64	iSize )

static

Definition at line 75346 of file sqlite3.c.

75352 {

75353 i64 iCurrent;

References sqlite3OsFileSize(), sqlite3OsTruncate(), and SQLITE_OK.

◆ backupUpdate()

static SQLITE_NOINLINE void backupUpdate	(	sqlite3_backup *	p,
		Pgno	iPage,
		const u8 *	aData )

static

Definition at line 75715 of file sqlite3.c.

 {
  assert( p!=0 );
  do{
    assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
    if( !isFatalError(p->rc) && iPage<p->iNext ){
      /* The backup process p has already copied page iPage. But now it
      ** has been modified by a transaction on the source pager. Copy
      ** the new data into the backup.
      */
      int rc;
      assert( p->pDestDb );
      sqlite3_mutex_enter(p->pDestDb->mutex);
      rc = backupOnePage(p, iPage, aData, 1);
      sqlite3_mutex_leave(p->pDestDb->mutex);
      assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );

References backupOnePage(), isFatalError(), sqlite3::mutex, BtShared::mutex, Btree::pBt, sqlite3_backup::pDestDb, sqlite3_backup::pSrc, sqlite3_backup::rc, sqlite3_mutex_enter(), sqlite3_mutex_held(), sqlite3_mutex_leave(), SQLITE_BUSY, and SQLITE_LOCKED.

◆ balance()

static int balance ( BtCursor * pCur )

static

Definition at line 72861 of file sqlite3.c.

                                  :
**
**   balance_quick()
**   balance_deeper()
**   balance_nonroot()
*/
static int balance(BtCursor *pCur){
  int rc = SQLITE_OK;
  const int nMin = pCur->pBt->usableSize * 2 / 3;
  u8 aBalanceQuickSpace[13];
  u8 *pFree = 0;
 
  VVA_ONLY( int balance_quick_called = 0 );
  VVA_ONLY( int balance_deeper_called = 0 );
 
  do {
    int iPage;
    MemPage *pPage = pCur->pPage;
 
    if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break;
    if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
      break;
    }else if( (iPage = pCur->iPage)==0 ){
      if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
        /* The root page of the b-tree is overfull. In this case call the
        ** balance_deeper() function to create a new child for the root-page
        ** and copy the current contents of the root-page to it. The
        ** next iteration of the do-loop will balance the child page.
        */
        assert( balance_deeper_called==0 );
        VVA_ONLY( balance_deeper_called++ );
        rc = balance_deeper(pPage, &pCur->apPage[1]);
        if( rc==SQLITE_OK ){
          pCur->iPage = 1;
          pCur->ix = 0;
          pCur->aiIdx[0] = 0;
          pCur->apPage[0] = pPage;
          pCur->pPage = pCur->apPage[1];
          assert( pCur->pPage->nOverflow );
        }
      }else{
        break;
      }
    }else{
      MemPage * const pParent = pCur->apPage[iPage-1];
      int const iIdx = pCur->aiIdx[iPage-1];
 
      rc = sqlite3PagerWrite(pParent->pDbPage);
      if( rc==SQLITE_OK && pParent->nFree<0 ){
        rc = btreeComputeFreeSpace(pParent);
      }
      if( rc==SQLITE_OK ){
#ifndef SQLITE_OMIT_QUICKBALANCE
        if( pPage->intKeyLeaf
         && pPage->nOverflow==1
         && pPage->aiOvfl[0]==pPage->nCell
         && pParent->pgno!=1
         && pParent->nCell==iIdx
        ){
          /* Call balance_quick() to create a new sibling of pPage on which
          ** to store the overflow cell. balance_quick() inserts a new cell
          ** into pParent, which may cause pParent overflow. If this
          ** happens, the next iteration of the do-loop will balance pParent
          ** use either balance_nonroot() or balance_deeper(). Until this
          ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
          ** buffer.
          **
          ** The purpose of the following assert() is to check that only a
          ** single call to balance_quick() is made for each call to this
          ** function. If this were not verified, a subtle bug involving reuse
          ** of the aBalanceQuickSpace[] might sneak in.
          */
          assert( balance_quick_called==0 );
          VVA_ONLY( balance_quick_called++ );
          rc = balance_quick(pParent, pPage, aBalanceQuickSpace);
        }else
#endif
        {
          /* In this case, call balance_nonroot() to redistribute cells
          ** between pPage and up to 2 of its sibling pages. This involves
          ** modifying the contents of pParent, which may cause pParent to
          ** become overfull or underfull. The next iteration of the do-loop
          ** will balance the parent page to correct this.
          **
          ** If the parent page becomes overfull, the overflow cell or cells
          ** are stored in the pSpace buffer allocated immediately below.
          ** A subsequent iteration of the do-loop will deal with this by
          ** calling balance_nonroot() (balance_deeper() may be called first,
          ** but it doesn't deal with overflow cells - just moves them to a
          ** different page). Once this subsequent call to balance_nonroot()
          ** has completed, it is safe to release the pSpace buffer used by
          ** the previous call, as the overflow cell data will have been
          ** copied either into the body of a database page or into the new
          ** pSpace buffer passed to the latter call to balance_nonroot().
          */
          u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
          rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1,
                               pCur->hints&BTREE_BULKLOAD);
          if( pFree ){
            /* If pFree is not NULL, it points to the pSpace buffer used
            ** by a previous call to balance_nonroot(). Its contents are
            ** now stored either on real database pages or within the
            ** new pSpace buffer, so it may be safely freed here. */
            sqlite3PageFree(pFree);
          }
 
          /* The pSpace buffer will be freed after the next call to
          ** balance_nonroot(), or just before this function returns, whichever
          ** comes first. */
          pFree = pSpace;
        }
      }
 
      pPage->nOverflow = 0;
 
      /* The next iteration of the do-loop balances the parent page. */
      releasePage(pPage);
      pCur->iPage--;
      assert( pCur->iPage>=0 );
      pCur->pPage = pCur->apPage[pCur->iPage];
    }
  }while( rc==SQLITE_OK );

References BtCursor::aiIdx, MemPage::aiOvfl, anotherValidCursor(), BtCursor::apPage, balance_deeper(), balance_nonroot(), balance_quick(), BTREE_BULKLOAD, btreeComputeFreeSpace(), BtCursor::hints, MemPage::intKeyLeaf, BtCursor::iPage, BtCursor::ix, MemPage::nCell, NEVER, MemPage::nFree, MemPage::nOverflow, BtShared::pageSize, BtCursor::pBt, MemPage::pDbPage, MemPage::pgno, BtCursor::pPage, releasePage(), sqlite3PageFree(), sqlite3PageMalloc(), sqlite3PagerWrite(), SQLITE_OK, BtShared::usableSize, and VVA_ONLY.

Referenced by sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ balance_deeper()

static int balance_deeper	(	MemPage *	pRoot,
		MemPage **	ppChild )

static

Definition at line 72780 of file sqlite3.c.

                                                            {
  int rc;                        /* Return value from subprocedures */
  MemPage *pChild = 0;           /* Pointer to a new child page */
  Pgno pgnoChild = 0;            /* Page number of the new child page */
  BtShared *pBt = pRoot->pBt;    /* The BTree */
 
  assert( pRoot->nOverflow>0 );
  assert( sqlite3_mutex_held(pBt->mutex) );
 
  /* Make pRoot, the root page of the b-tree, writable. Allocate a new
  ** page that will become the new right-child of pPage. Copy the contents
  ** of the node stored on pRoot into the new child page.
  */
  rc = sqlite3PagerWrite(pRoot->pDbPage);
  if( rc==SQLITE_OK ){
    rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
    copyNodeContent(pRoot, pChild, &rc);
    if( ISAUTOVACUUM ){
      ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
    }
  }
  if( rc ){
    *ppChild = 0;
    releasePage(pChild);
    return rc;
  }
  assert( sqlite3PagerIswriteable(pChild->pDbPage) );
  assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
  assert( pChild->nCell==pRoot->nCell || CORRUPT_DB );
 
  TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
 
  /* Copy the overflow cells from pRoot to pChild */
  memcpy(pChild->aiOvfl, pRoot->aiOvfl,
         pRoot->nOverflow*sizeof(pRoot->aiOvfl[0]));
  memcpy(pChild->apOvfl, pRoot->apOvfl,
         pRoot->nOverflow*sizeof(pRoot->apOvfl[0]));
  pChild->nOverflow = pRoot->nOverflow;
 
  /* Zero the contents of pRoot. Then install pChild as the right-child. */

References MemPage::aData, MemPage::aiOvfl, allocateBtreePage(), MemPage::apOvfl, copyNodeContent(), CORRUPT_DB, MemPage::hdrOffset, ISAUTOVACUUM, BtShared::mutex, MemPage::nCell, MemPage::nOverflow, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, PTF_LEAF, PTRMAP_BTREE, ptrmapPut(), put4byte, releasePage(), sqlite3_mutex_held(), sqlite3PagerWrite(), SQLITE_OK, TRACE, and zeroPage().

Referenced by balance().

◆ balance_nonroot()

static int balance_nonroot	(	MemPage *	pParent,
		int	iParentIdx,
		u8 *	aOvflSpace,
		int	isRoot,
		int	bBulk )

static

Definition at line 71994 of file sqlite3.c.

 {
  BtShared *pBt;               /* The whole database */
  int nMaxCells = 0;           /* Allocated size of apCell, szCell, aFrom. */
  int nNew = 0;                /* Number of pages in apNew[] */
  int nOld;                    /* Number of pages in apOld[] */
  int i, j, k;                 /* Loop counters */
  int nxDiv;                   /* Next divider slot in pParent->aCell[] */
  int rc = SQLITE_OK;          /* The return code */
  u16 leafCorrection;          /* 4 if pPage is a leaf.  0 if not */
  int leafData;                /* True if pPage is a leaf of a LEAFDATA tree */
  int usableSpace;             /* Bytes in pPage beyond the header */
  int pageFlags;               /* Value of pPage->aData[0] */
  int iSpace1 = 0;             /* First unused byte of aSpace1[] */
  int iOvflSpace = 0;          /* First unused byte of aOvflSpace[] */
  int szScratch;               /* Size of scratch memory requested */
  MemPage *apOld[NB];          /* pPage and up to two siblings */
  MemPage *apNew[NB+2];        /* pPage and up to NB siblings after balancing */
  u8 *pRight;                  /* Location in parent of right-sibling pointer */
  u8 *apDiv[NB-1];             /* Divider cells in pParent */
  int cntNew[NB+2];            /* Index in b.paCell[] of cell after i-th page */
  int cntOld[NB+2];            /* Old index in b.apCell[] */
  int szNew[NB+2];             /* Combined size of cells placed on i-th page */
  u8 *aSpace1;                 /* Space for copies of dividers cells */
  Pgno pgno;                   /* Temp var to store a page number in */
  u8 abDone[NB+2];             /* True after i'th new page is populated */
  Pgno aPgno[NB+2];            /* Page numbers of new pages before shuffling */
  Pgno aPgOrder[NB+2];         /* Copy of aPgno[] used for sorting pages */
  u16 aPgFlags[NB+2];          /* flags field of new pages before shuffling */
  CellArray b;                  /* Parsed information on cells being balanced */
 
  memset(abDone, 0, sizeof(abDone));
  b.nCell = 0;
  b.apCell = 0;
  pBt = pParent->pBt;
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( sqlite3PagerIswriteable(pParent->pDbPage) );
 
  /* At this point pParent may have at most one overflow cell. And if
  ** this overflow cell is present, it must be the cell with
  ** index iParentIdx. This scenario comes about when this function
  ** is called (indirectly) from sqlite3BtreeDelete().
  */
  assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
  assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx );
 
  if( !aOvflSpace ){
    return SQLITE_NOMEM_BKPT;
  }
  assert( pParent->nFree>=0 );
 
  /* Find the sibling pages to balance. Also locate the cells in pParent
  ** that divide the siblings. An attempt is made to find NN siblings on
  ** either side of pPage. More siblings are taken from one side, however,
  ** if there are fewer than NN siblings on the other side. If pParent
  ** has NB or fewer children then all children of pParent are taken.
  **
  ** This loop also drops the divider cells from the parent page. This
  ** way, the remainder of the function does not have to deal with any
  ** overflow cells in the parent page, since if any existed they will
  ** have already been removed.
  */
  i = pParent->nOverflow + pParent->nCell;
  if( i<2 ){
    nxDiv = 0;
  }else{
    assert( bBulk==0 || bBulk==1 );
    if( iParentIdx==0 ){
      nxDiv = 0;
    }else if( iParentIdx==i ){
      nxDiv = i-2+bBulk;
    }else{
      nxDiv = iParentIdx-1;
    }
    i = 2-bBulk;
  }
  nOld = i+1;
  if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
    pRight = &pParent->aData[pParent->hdrOffset+8];
  }else{
    pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
  }
  pgno = get4byte(pRight);
  while( 1 ){
    rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
    if( rc ){
      memset(apOld, 0, (i+1)*sizeof(MemPage*));
      goto balance_cleanup;
    }
    if( apOld[i]->nFree<0 ){
      rc = btreeComputeFreeSpace(apOld[i]);
      if( rc ){
        memset(apOld, 0, (i)*sizeof(MemPage*));
        goto balance_cleanup;
      }
    }
    if( (i--)==0 ) break;
 
    if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){
      apDiv[i] = pParent->apOvfl[0];
      pgno = get4byte(apDiv[i]);
      szNew[i] = pParent->xCellSize(pParent, apDiv[i]);
      pParent->nOverflow = 0;
    }else{
      apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow);
      pgno = get4byte(apDiv[i]);
      szNew[i] = pParent->xCellSize(pParent, apDiv[i]);
 
      /* Drop the cell from the parent page. apDiv[i] still points to
      ** the cell within the parent, even though it has been dropped.
      ** This is safe because dropping a cell only overwrites the first
      ** four bytes of it, and this function does not need the first
      ** four bytes of the divider cell. So the pointer is safe to use
      ** later on.
      **
      ** But not if we are in secure-delete mode. In secure-delete mode,
      ** the dropCell() routine will overwrite the entire cell with zeroes.
      ** In this case, temporarily copy the cell into the aOvflSpace[]
      ** buffer. It will be copied out again as soon as the aSpace[] buffer
      ** is allocated.  */
      if( pBt->btsFlags & BTS_FAST_SECURE ){
        int iOff;
 
        iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
        if( (iOff+szNew[i])>(int)pBt->usableSize ){
          rc = SQLITE_CORRUPT_BKPT;
          memset(apOld, 0, (i+1)*sizeof(MemPage*));
          goto balance_cleanup;
        }else{
          memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
          apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
        }
      }
      dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc);
    }
  }
 
  /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
  ** alignment */
  nMaxCells = nOld*(MX_CELL(pBt) + ArraySize(pParent->apOvfl));
  nMaxCells = (nMaxCells + 3)&~3;
 
  /*
  ** Allocate space for memory structures
  */
  szScratch =
       nMaxCells*sizeof(u8*)                       /* b.apCell */
     + nMaxCells*sizeof(u16)                       /* b.szCell */
     + pBt->pageSize;                              /* aSpace1 */
 
  assert( szScratch<=7*(int)pBt->pageSize );
  b.apCell = sqlite3StackAllocRaw(0, szScratch );
  if( b.apCell==0 ){
    rc = SQLITE_NOMEM_BKPT;
    goto balance_cleanup;
  }
  b.szCell = (u16*)&b.apCell[nMaxCells];
  aSpace1 = (u8*)&b.szCell[nMaxCells];
  assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
 
  /*
  ** Load pointers to all cells on sibling pages and the divider cells
  ** into the local b.apCell[] array.  Make copies of the divider cells
  ** into space obtained from aSpace1[]. The divider cells have already
  ** been removed from pParent.
  **
  ** If the siblings are on leaf pages, then the child pointers of the
  ** divider cells are stripped from the cells before they are copied
  ** into aSpace1[].  In this way, all cells in b.apCell[] are without
  ** child pointers.  If siblings are not leaves, then all cell in
  ** b.apCell[] include child pointers.  Either way, all cells in b.apCell[]
  ** are alike.
  **
  ** leafCorrection:  4 if pPage is a leaf.  0 if pPage is not a leaf.
  **       leafData:  1 if pPage holds key+data and pParent holds only keys.
  */
  b.pRef = apOld[0];
  leafCorrection = b.pRef->leaf*4;
  leafData = b.pRef->intKeyLeaf;
  for(i=0; i<nOld; i++){
    MemPage *pOld = apOld[i];
    int limit = pOld->nCell;
    u8 *aData = pOld->aData;
    u16 maskPage = pOld->maskPage;
    u8 *piCell = aData + pOld->cellOffset;
    u8 *piEnd;
    VVA_ONLY( int nCellAtStart = b.nCell; )
 
    /* Verify that all sibling pages are of the same "type" (table-leaf,
    ** table-interior, index-leaf, or index-interior).
    */
    if( pOld->aData[0]!=apOld[0]->aData[0] ){
      rc = SQLITE_CORRUPT_BKPT;
      goto balance_cleanup;
    }
 
    /* Load b.apCell[] with pointers to all cells in pOld.  If pOld
    ** contains overflow cells, include them in the b.apCell[] array
    ** in the correct spot.
    **
    ** Note that when there are multiple overflow cells, it is always the
    ** case that they are sequential and adjacent.  This invariant arises
    ** because multiple overflows can only occurs when inserting divider
    ** cells into a parent on a prior balance, and divider cells are always
    ** adjacent and are inserted in order.  There is an assert() tagged
    ** with "NOTE 1" in the overflow cell insertion loop to prove this
    ** invariant.
    **
    ** This must be done in advance.  Once the balance starts, the cell
    ** offset section of the btree page will be overwritten and we will no
    ** long be able to find the cells if a pointer to each cell is not saved
    ** first.
    */
    memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
    if( pOld->nOverflow>0 ){
      if( NEVER(limit<pOld->aiOvfl[0]) ){
        rc = SQLITE_CORRUPT_BKPT;
        goto balance_cleanup;
      }
      limit = pOld->aiOvfl[0];
      for(j=0; j<limit; j++){
        b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
        piCell += 2;
        b.nCell++;
      }
      for(k=0; k<pOld->nOverflow; k++){
        assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */
        b.apCell[b.nCell] = pOld->apOvfl[k];
        b.nCell++;
      }
    }
    piEnd = aData + pOld->cellOffset + 2*pOld->nCell;
    while( piCell<piEnd ){
      assert( b.nCell<nMaxCells );
      b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
      piCell += 2;
      b.nCell++;
    }
    assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) );
 
    cntOld[i] = b.nCell;
    if( i<nOld-1 && !leafData){
      u16 sz = (u16)szNew[i];
      u8 *pTemp;
      assert( b.nCell<nMaxCells );
      b.szCell[b.nCell] = sz;
      pTemp = &aSpace1[iSpace1];
      iSpace1 += sz;
      assert( sz<=pBt->maxLocal+23 );
      assert( iSpace1 <= (int)pBt->pageSize );
      memcpy(pTemp, apDiv[i], sz);
      b.apCell[b.nCell] = pTemp+leafCorrection;
      assert( leafCorrection==0 || leafCorrection==4 );
      b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection;
      if( !pOld->leaf ){
        assert( leafCorrection==0 );
        assert( pOld->hdrOffset==0 );
        /* The right pointer of the child page pOld becomes the left
        ** pointer of the divider cell */
        memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
      }else{
        assert( leafCorrection==4 );
        while( b.szCell[b.nCell]<4 ){
          /* Do not allow any cells smaller than 4 bytes. If a smaller cell
          ** does exist, pad it with 0x00 bytes. */
          assert( b.szCell[b.nCell]==3 || CORRUPT_DB );
          assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB );
          aSpace1[iSpace1++] = 0x00;
          b.szCell[b.nCell]++;
        }
      }
      b.nCell++;
    }
  }
 
  /*
  ** Figure out the number of pages needed to hold all b.nCell cells.
  ** Store this number in "k".  Also compute szNew[] which is the total
  ** size of all cells on the i-th page and cntNew[] which is the index
  ** in b.apCell[] of the cell that divides page i from page i+1.
  ** cntNew[k] should equal b.nCell.
  **
  ** Values computed by this block:
  **
  **           k: The total number of sibling pages
  **    szNew[i]: Spaced used on the i-th sibling page.
  **   cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to
  **              the right of the i-th sibling page.
  ** usableSpace: Number of bytes of space available on each sibling.
  **
  */
  usableSpace = pBt->usableSize - 12 + leafCorrection;
  for(i=k=0; i<nOld; i++, k++){
    MemPage *p = apOld[i];
    b.apEnd[k] = p->aDataEnd;
    b.ixNx[k] = cntOld[i];
    if( k && b.ixNx[k]==b.ixNx[k-1] ){
      k--;  /* Omit b.ixNx[] entry for child pages with no cells */
    }
    if( !leafData ){
      k++;
      b.apEnd[k] = pParent->aDataEnd;
      b.ixNx[k] = cntOld[i]+1;
    }
    assert( p->nFree>=0 );
    szNew[i] = usableSpace - p->nFree;
    for(j=0; j<p->nOverflow; j++){
      szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);
    }
    cntNew[i] = cntOld[i];
  }
  k = nOld;
  for(i=0; i<k; i++){
    int sz;
    while( szNew[i]>usableSpace ){
      if( i+1>=k ){
        k = i+2;
        if( k>NB+2 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; }
        szNew[k-1] = 0;
        cntNew[k-1] = b.nCell;
      }
      sz = 2 + cachedCellSize(&b, cntNew[i]-1);
      szNew[i] -= sz;
      if( !leafData ){
        if( cntNew[i]<b.nCell ){
          sz = 2 + cachedCellSize(&b, cntNew[i]);
        }else{
          sz = 0;
        }
      }
      szNew[i+1] += sz;
      cntNew[i]--;
    }
    while( cntNew[i]<b.nCell ){
      sz = 2 + cachedCellSize(&b, cntNew[i]);
      if( szNew[i]+sz>usableSpace ) break;
      szNew[i] += sz;
      cntNew[i]++;
      if( !leafData ){
        if( cntNew[i]<b.nCell ){
          sz = 2 + cachedCellSize(&b, cntNew[i]);
        }else{
          sz = 0;
        }
      }
      szNew[i+1] -= sz;
    }
    if( cntNew[i]>=b.nCell ){
      k = i+1;
    }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){
      rc = SQLITE_CORRUPT_BKPT;
      goto balance_cleanup;
    }
  }
 
  /*
  ** The packing computed by the previous block is biased toward the siblings
  ** on the left side (siblings with smaller keys). The left siblings are
  ** always nearly full, while the right-most sibling might be nearly empty.
  ** The next block of code attempts to adjust the packing of siblings to
  ** get a better balance.
  **
  ** This adjustment is more than an optimization.  The packing above might
  ** be so out of balance as to be illegal.  For example, the right-most
  ** sibling might be completely empty.  This adjustment is not optional.
  */
  for(i=k-1; i>0; i--){
    int szRight = szNew[i];  /* Size of sibling on the right */
    int szLeft = szNew[i-1]; /* Size of sibling on the left */
    int r;              /* Index of right-most cell in left sibling */
    int d;              /* Index of first cell to the left of right sibling */
 
    r = cntNew[i-1] - 1;
    d = r + 1 - leafData;
    (void)cachedCellSize(&b, d);
    do{
      assert( d<nMaxCells );
      assert( r<nMaxCells );
      (void)cachedCellSize(&b, r);
      if( szRight!=0
       && (bBulk || szRight+b.szCell[d]+2 > szLeft-(b.szCell[r]+(i==k-1?0:2)))){
        break;
      }
      szRight += b.szCell[d] + 2;
      szLeft -= b.szCell[r] + 2;
      cntNew[i-1] = r;
      r--;
      d--;
    }while( r>=0 );
    szNew[i] = szRight;
    szNew[i-1] = szLeft;
    if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){
      rc = SQLITE_CORRUPT_BKPT;
      goto balance_cleanup;
    }
  }
 
  /* Sanity check:  For a non-corrupt database file one of the follwing
  ** must be true:
  **    (1) We found one or more cells (cntNew[0])>0), or
  **    (2) pPage is a virtual root page.  A virtual root page is when
  **        the real root page is page 1 and we are the only child of
  **        that page.
  */
  assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
  TRACE(("BALANCE: old: %d(nc=%d) %d(nc=%d) %d(nc=%d)\n",
    apOld[0]->pgno, apOld[0]->nCell,
    nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0,
    nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0
  ));
 
  /*
  ** Allocate k new pages.  Reuse old pages where possible.
  */
  pageFlags = apOld[0]->aData[0];
  for(i=0; i<k; i++){
    MemPage *pNew;
    if( i<nOld ){
      pNew = apNew[i] = apOld[i];
      apOld[i] = 0;
      rc = sqlite3PagerWrite(pNew->pDbPage);
      nNew++;
      if( rc ) goto balance_cleanup;
    }else{
      assert( i>0 );
      rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
      if( rc ) goto balance_cleanup;
      zeroPage(pNew, pageFlags);
      apNew[i] = pNew;
      nNew++;
      cntOld[i] = b.nCell;
 
      /* Set the pointer-map entry for the new sibling page. */
      if( ISAUTOVACUUM ){
        ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
        if( rc!=SQLITE_OK ){
          goto balance_cleanup;
        }
      }
    }
  }
 
  /*
  ** Reassign page numbers so that the new pages are in ascending order.
  ** This helps to keep entries in the disk file in order so that a scan
  ** of the table is closer to a linear scan through the file. That in turn
  ** helps the operating system to deliver pages from the disk more rapidly.
  **
  ** An O(n^2) insertion sort algorithm is used, but since n is never more
  ** than (NB+2) (a small constant), that should not be a problem.
  **
  ** When NB==3, this one optimization makes the database about 25% faster
  ** for large insertions and deletions.
  */
  for(i=0; i<nNew; i++){
    aPgOrder[i] = aPgno[i] = apNew[i]->pgno;
    aPgFlags[i] = apNew[i]->pDbPage->flags;
    for(j=0; j<i; j++){
      if( aPgno[j]==aPgno[i] ){
        /* This branch is taken if the set of sibling pages somehow contains
        ** duplicate entries. This can happen if the database is corrupt.
        ** It would be simpler to detect this as part of the loop below, but
        ** we do the detection here in order to avoid populating the pager
        ** cache with two separate objects associated with the same
        ** page number.  */
        assert( CORRUPT_DB );
        rc = SQLITE_CORRUPT_BKPT;
        goto balance_cleanup;
      }
    }
  }
  for(i=0; i<nNew; i++){
    int iBest = 0;                /* aPgno[] index of page number to use */
    for(j=1; j<nNew; j++){
      if( aPgOrder[j]<aPgOrder[iBest] ) iBest = j;
    }
    pgno = aPgOrder[iBest];
    aPgOrder[iBest] = 0xffffffff;
    if( iBest!=i ){
      if( iBest>i ){
        sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0);
      }
      sqlite3PagerRekey(apNew[i]->pDbPage, pgno, aPgFlags[iBest]);
      apNew[i]->pgno = pgno;
    }
  }
 
  TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) "
         "%d(%d nc=%d) %d(%d nc=%d)\n",
    apNew[0]->pgno, szNew[0], cntNew[0],
    nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
    nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
    nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
    nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
    nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
    nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
    nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
    nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
  ));
 
  assert( sqlite3PagerIswriteable(pParent->pDbPage) );
  assert( nNew>=1 && nNew<=ArraySize(apNew) );
  assert( apNew[nNew-1]!=0 );
  put4byte(pRight, apNew[nNew-1]->pgno);
 
  /* If the sibling pages are not leaves, ensure that the right-child pointer
  ** of the right-most new sibling page is set to the value that was
  ** originally in the same field of the right-most old sibling page. */
  if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
    MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
    memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
  }
 
  /* Make any required updates to pointer map entries associated with
  ** cells stored on sibling pages following the balance operation. Pointer
  ** map entries associated with divider cells are set by the insertCell()
  ** routine. The associated pointer map entries are:
  **
  **   a) if the cell contains a reference to an overflow chain, the
  **      entry associated with the first page in the overflow chain, and
  **
  **   b) if the sibling pages are not leaves, the child page associated
  **      with the cell.
  **
  ** If the sibling pages are not leaves, then the pointer map entry
  ** associated with the right-child of each sibling may also need to be
  ** updated. This happens below, after the sibling pages have been
  ** populated, not here.
  */
  if( ISAUTOVACUUM ){
    MemPage *pOld;
    MemPage *pNew = pOld = apNew[0];
    int cntOldNext = pNew->nCell + pNew->nOverflow;
    int iNew = 0;
    int iOld = 0;
 
    for(i=0; i<b.nCell; i++){
      u8 *pCell = b.apCell[i];
      while( i==cntOldNext ){
        iOld++;
        assert( iOld<nNew || iOld<nOld );
        assert( iOld>=0 && iOld<NB );
        pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
        cntOldNext += pOld->nCell + pOld->nOverflow + !leafData;
      }
      if( i==cntNew[iNew] ){
        pNew = apNew[++iNew];
        if( !leafData ) continue;
      }
 
      /* Cell pCell is destined for new sibling page pNew. Originally, it
      ** was either part of sibling page iOld (possibly an overflow cell),
      ** or else the divider cell to the left of sibling page iOld. So,
      ** if sibling page iOld had the same page number as pNew, and if
      ** pCell really was a part of sibling page iOld (not a divider or
      ** overflow cell), we can skip updating the pointer map entries.  */
      if( iOld>=nNew
       || pNew->pgno!=aPgno[iOld]
       || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
      ){
        if( !leafCorrection ){
          ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
        }
        if( cachedCellSize(&b,i)>pNew->minLocal ){
          ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
        }
        if( rc ) goto balance_cleanup;
      }
    }
  }
 
  /* Insert new divider cells into pParent. */
  for(i=0; i<nNew-1; i++){
    u8 *pCell;
    u8 *pTemp;
    int sz;
    MemPage *pNew = apNew[i];
    j = cntNew[i];
 
    assert( j<nMaxCells );
    assert( b.apCell[j]!=0 );
    pCell = b.apCell[j];
    sz = b.szCell[j] + leafCorrection;
    pTemp = &aOvflSpace[iOvflSpace];
    if( !pNew->leaf ){
      memcpy(&pNew->aData[8], pCell, 4);
    }else if( leafData ){
      /* If the tree is a leaf-data tree, and the siblings are leaves,
      ** then there is no divider cell in b.apCell[]. Instead, the divider
      ** cell consists of the integer key for the right-most cell of
      ** the sibling-page assembled above only.
      */
      CellInfo info;
      j--;
      pNew->xParseCell(pNew, b.apCell[j], &info);
      pCell = pTemp;
      sz = 4 + putVarint(&pCell[4], info.nKey);
      pTemp = 0;
    }else{
      pCell -= 4;
      /* Obscure case for non-leaf-data trees: If the cell at pCell was
      ** previously stored on a leaf node, and its reported size was 4
      ** bytes, then it may actually be smaller than this
      ** (see btreeParseCellPtr(), 4 bytes is the minimum size of
      ** any cell). But it is important to pass the correct size to
      ** insertCell(), so reparse the cell now.
      **
      ** This can only happen for b-trees used to evaluate "IN (SELECT ...)"
      ** and WITHOUT ROWID tables with exactly one column which is the
      ** primary key.
      */
      if( b.szCell[j]==4 ){
        assert(leafCorrection==4);
        sz = pParent->xCellSize(pParent, pCell);
      }
    }
    iOvflSpace += sz;
    assert( sz<=pBt->maxLocal+23 );
    assert( iOvflSpace <= (int)pBt->pageSize );
    insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);
    if( rc!=SQLITE_OK ) goto balance_cleanup;
    assert( sqlite3PagerIswriteable(pParent->pDbPage) );
  }
 
  /* Now update the actual sibling pages. The order in which they are updated
  ** is important, as this code needs to avoid disrupting any page from which
  ** cells may still to be read. In practice, this means:
  **
  **  (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1])
  **      then it is not safe to update page apNew[iPg] until after
  **      the left-hand sibling apNew[iPg-1] has been updated.
  **
  **  (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1])
  **      then it is not safe to update page apNew[iPg] until after
  **      the right-hand sibling apNew[iPg+1] has been updated.
  **
  ** If neither of the above apply, the page is safe to update.
  **
  ** The iPg value in the following loop starts at nNew-1 goes down
  ** to 0, then back up to nNew-1 again, thus making two passes over
  ** the pages.  On the initial downward pass, only condition (1) above
  ** needs to be tested because (2) will always be true from the previous
  ** step.  On the upward pass, both conditions are always true, so the
  ** upwards pass simply processes pages that were missed on the downward
  ** pass.
  */
  for(i=1-nNew; i<nNew; i++){
    int iPg = i<0 ? -i : i;
    assert( iPg>=0 && iPg<nNew );
    if( abDone[iPg] ) continue;         /* Skip pages already processed */
    if( i>=0                            /* On the upwards pass, or... */
     || cntOld[iPg-1]>=cntNew[iPg-1]    /* Condition (1) is true */
    ){
      int iNew;
      int iOld;
      int nNewCell;
 
      /* Verify condition (1):  If cells are moving left, update iPg
      ** only after iPg-1 has already been updated. */
      assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] );
 
      /* Verify condition (2):  If cells are moving right, update iPg
      ** only after iPg+1 has already been updated. */
      assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] );
 
      if( iPg==0 ){
        iNew = iOld = 0;
        nNewCell = cntNew[0];
      }else{
        iOld = iPg<nOld ? (cntOld[iPg-1] + !leafData) : b.nCell;
        iNew = cntNew[iPg-1] + !leafData;
        nNewCell = cntNew[iPg] - iNew;
      }
 
      rc = editPage(apNew[iPg], iOld, iNew, nNewCell, &b);
      if( rc ) goto balance_cleanup;
      abDone[iPg]++;
      apNew[iPg]->nFree = usableSpace-szNew[iPg];
      assert( apNew[iPg]->nOverflow==0 );
      assert( apNew[iPg]->nCell==nNewCell );
    }
  }
 
  /* All pages have been processed exactly once */
  assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
 
  assert( nOld>0 );
  assert( nNew>0 );
 
  if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
    /* The root page of the b-tree now contains no cells. The only sibling
    ** page is the right-child of the parent. Copy the contents of the
    ** child page into the parent, decreasing the overall height of the
    ** b-tree structure by one. This is described as the "balance-shallower"
    ** sub-algorithm in some documentation.
    **
    ** If this is an auto-vacuum database, the call to copyNodeContent()
    ** sets all pointer-map entries corresponding to database image pages
    ** for which the pointer is stored within the content being copied.
    **
    ** It is critical that the child page be defragmented before being
    ** copied into the parent, because if the parent is page 1 then it will
    ** by smaller than the child due to the database header, and so all the
    ** free space needs to be up front.
    */
    assert( nNew==1 || CORRUPT_DB );
    rc = defragmentPage(apNew[0], -1);
    testcase( rc!=SQLITE_OK );
    assert( apNew[0]->nFree ==
        (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset
          - apNew[0]->nCell*2)
      || rc!=SQLITE_OK
    );
    copyNodeContent(apNew[0], pParent, &rc);
    freePage(apNew[0], &rc);
  }else if( ISAUTOVACUUM && !leafCorrection ){
    /* Fix the pointer map entries associated with the right-child of each
    ** sibling page. All other pointer map entries have already been taken
    ** care of.  */
    for(i=0; i<nNew; i++){
      u32 key = get4byte(&apNew[i]->aData[8]);
      ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
    }
  }
 
  assert( pParent->isInit );
  TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
          nOld, nNew, b.nCell));
 
  /* Free any old pages that were not reused as new pages.
  */
  for(i=nNew; i<nOld; i++){
    freePage(apOld[i], &rc);
  }
 
#if 0
  if( ISAUTOVACUUM && rc==SQLITE_OK && apNew[0]->isInit ){
    /* The ptrmapCheckPages() contains assert() statements that verify that
    ** all pointer map pages are set correctly. This is helpful while
    ** debugging. This is usually disabled because a corrupt database may
    ** cause an assert() statement to fail.  */
    ptrmapCheckPages(apNew, nNew);
    ptrmapCheckPages(&pParent, 1);
  }
#endif
 
  /*
  ** Cleanup before returning.
  */
balance_cleanup:
  sqlite3StackFree(0, b.apCell);
  for(i=0; i<nOld; i++){
    releasePage(apOld[i]);
  }

References MemPage::aData, MemPage::aDataEnd, MemPage::aiOvfl, allocateBtreePage(), CellArray::apCell, CellArray::apEnd, MemPage::apOvfl, ArraySize, btreeComputeFreeSpace(), BTS_FAST_SECURE, BtShared::btsFlags, cachedCellSize(), MemPage::cellOffset, copyNodeContent(), CORRUPT_DB, defragmentPage(), dropCell(), editPage(), EIGHT_BYTE_ALIGNMENT, findCell, PgHdr::flags, freePage(), get2byteAligned, get2byteNotZero, get4byte, getAndInitPage(), MemPage::hdrOffset, insertCell(), MemPage::intKeyLeaf, ISAUTOVACUUM, MemPage::isInit, CellArray::ixNx, MemPage::leaf, MemPage::maskPage, MemPage::minLocal, BtShared::mutex, MX_CELL, NB, MemPage::nCell, CellArray::nCell, NEVER, MemPage::nFree, CellInfo::nKey, MemPage::nOverflow, BtShared::nPage, BtShared::pageSize, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, CellArray::pRef, PTF_LEAF, PTRMAP_BTREE, ptrmapPut(), ptrmapPutOvflPtr(), put4byte, putVarint, releasePage(), sqlite3_mutex_held(), sqlite3PagerRekey(), sqlite3PagerWrite(), sqlite3StackAllocRaw, sqlite3StackFree, SQLITE_CORRUPT_BKPT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_PTR_TO_INT, SQLITE_WITHIN, CellArray::szCell, testcase, TRACE, BtShared::usableSize, VVA_ONLY, MemPage::xCellSize, MemPage::xParseCell, and zeroPage().

Referenced by balance().

◆ balance_quick()

static int balance_quick	(	MemPage *	pParent,
		MemPage *	pPage,
		u8 *	pSpace )

static

Definition at line 71757 of file sqlite3.c.

                                                                      {
  BtShared *const pBt = pPage->pBt;    /* B-Tree Database */
  MemPage *pNew;                       /* Newly allocated page */
  int rc;                              /* Return Code */
  Pgno pgnoNew;                        /* Page number of pNew */
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( sqlite3PagerIswriteable(pParent->pDbPage) );
  assert( pPage->nOverflow==1 );
 
  if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT;  /* dbfuzz001.test */
  assert( pPage->nFree>=0 );
  assert( pParent->nFree>=0 );
 
  /* Allocate a new page. This page will become the right-sibling of
  ** pPage. Make the parent page writable, so that the new divider cell
  ** may be inserted. If both these operations are successful, proceed.
  */
  rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
 
  if( rc==SQLITE_OK ){
 
    u8 *pOut = &pSpace[4];
    u8 *pCell = pPage->apOvfl[0];
    u16 szCell = pPage->xCellSize(pPage, pCell);
    u8 *pStop;
    CellArray b;
 
    assert( sqlite3PagerIswriteable(pNew->pDbPage) );
    assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
    zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
    b.nCell = 1;
    b.pRef = pPage;
    b.apCell = &pCell;
    b.szCell = &szCell;
    b.apEnd[0] = pPage->aDataEnd;
    b.ixNx[0] = 2;
    rc = rebuildPage(&b, 0, 1, pNew);
    if( NEVER(rc) ){
      releasePage(pNew);
      return rc;
    }
    pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
 
    /* If this is an auto-vacuum database, update the pointer map
    ** with entries for the new page, and any pointer from the
    ** cell on the page to an overflow page. If either of these
    ** operations fails, the return code is set, but the contents
    ** of the parent page are still manipulated by thh code below.
    ** That is Ok, at this point the parent page is guaranteed to
    ** be marked as dirty. Returning an error code will cause a
    ** rollback, undoing any changes made to the parent page.
    */
    if( ISAUTOVACUUM ){
      ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
      if( szCell>pNew->minLocal ){
        ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);
      }
    }
 
    /* Create a divider cell to insert into pParent. The divider cell
    ** consists of a 4-byte page number (the page number of pPage) and
    ** a variable length key value (which must be the same value as the
    ** largest key on pPage).
    **
    ** To find the largest key value on pPage, first find the right-most
    ** cell on pPage. The first two fields of this cell are the
    ** record-length (a variable length integer at most 32-bits in size)
    ** and the key value (a variable length integer, may have any value).
    ** The first of the while(...) loops below skips over the record-length
    ** field. The second while(...) loop copies the key value from the
    ** cell on pPage into the pSpace buffer.
    */
    pCell = findCell(pPage, pPage->nCell-1);
    pStop = &pCell[9];
    while( (*(pCell++)&0x80) && pCell<pStop );
    pStop = &pCell[9];
    while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
 
    /* Insert the new divider cell into pParent. */
    if( rc==SQLITE_OK ){
      insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
                   0, pPage->pgno, &rc);
    }
 
    /* Set the right-child pointer of pParent to point to the new page. */
    put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
 

References MemPage::aData, MemPage::aDataEnd, allocateBtreePage(), CellArray::apCell, CellArray::apEnd, MemPage::apOvfl, MemPage::cellOffset, CORRUPT_DB, findCell, MemPage::hdrOffset, insertCell(), ISAUTOVACUUM, CellArray::ixNx, MemPage::minLocal, BtShared::mutex, MemPage::nCell, CellArray::nCell, NEVER, MemPage::nFree, MemPage::nOverflow, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, CellArray::pRef, PTF_INTKEY, PTF_LEAF, PTF_LEAFDATA, PTRMAP_BTREE, ptrmapPut(), ptrmapPutOvflPtr(), put4byte, rebuildPage(), releasePage(), sqlite3_mutex_held(), SQLITE_CORRUPT_BKPT, SQLITE_OK, CellArray::szCell, BtShared::usableSize, MemPage::xCellSize, and zeroPage().

Referenced by balance().

◆ binaryCompareP5()

static u8 binaryCompareP5	(	const Expr *	pExpr1,
		const Expr *	pExpr2,
		int	jumpIfNull )

static

Definition at line 100019 of file sqlite3.c.

◆ binaryToUnaryIfNull()

static void binaryToUnaryIfNull	(	Parse *	pParse,
		Expr *	pY,
		Expr *	pA,
		int	op )

static

Definition at line 154379 of file sqlite3.c.

154385 {

154386 sqlite3 *db = pParse->db;

Referenced by yy_reduce().

◆ binCollFunc()

static int binCollFunc	(	void *	NotUsed,
		int	nKey1,
		const void *	pKey1,
		int	nKey2,
		const void *	pKey2 )

static

Definition at line 161985 of file sqlite3.c.

 {
  int rc, n;
  UNUSED_PARAMETER(NotUsed);
  n = nKey1<nKey2 ? nKey1 : nKey2;
  /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
  ** strings byte by byte using the memcmp() function from the standard C
  ** library. */
  assert( pKey1 && pKey2 );

Referenced by openDatabase().

◆ bindText()

static int bindText	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	nData,
		void()(void )	xDel,
		u8	encoding )

static

Definition at line 84354 of file sqlite3.c.

 {
  Vdbe *p = (Vdbe *)pStmt;
  Mem *pVar;
  int rc;
 
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    if( zData!=0 ){
      pVar = &p->aVar[i-1];
      rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
      if( rc==SQLITE_OK && encoding!=0 ){
        rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
      }
      if( rc ){
        sqlite3Error(p->db, rc);
        rc = sqlite3ApiExit(p->db, rc);
      }
    }

Referenced by sqlite3_bind_blob64(), sqlite3_bind_text64(), and sqlite3_bind_value().

◆ blobReadWrite()

static int blobReadWrite	(	sqlite3_blob *	pBlob,
		void *	z,
		int	n,
		int	iOffset,
		int()(BtCursor , u32, u32, void *)	xCall )

static

Definition at line 93740 of file sqlite3.c.

 {
  int rc;
  Incrblob *p = (Incrblob *)pBlob;
  Vdbe *v;
  sqlite3 *db;
 
  if( p==0 ) return SQLITE_MISUSE_BKPT;
  db = p->db;
  sqlite3_mutex_enter(db->mutex);
  v = (Vdbe*)p->pStmt;
 
  if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
    /* Request is out of range. Return a transient error. */
    rc = SQLITE_ERROR;
  }else if( v==0 ){
    /* If there is no statement handle, then the blob-handle has
    ** already been invalidated. Return SQLITE_ABORT in this case.
    */
    rc = SQLITE_ABORT;
  }else{
    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
    ** returned, clean-up the statement handle.
    */
    assert( db == v->db );
    sqlite3BtreeEnterCursor(p->pCsr);
 
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    if( xCall==sqlite3BtreePutData && db->xPreUpdateCallback ){
      /* If a pre-update hook is registered and this is a write cursor,
      ** invoke it here.
      **
      ** TODO: The preupdate-hook is passed SQLITE_DELETE, even though this
      ** operation should really be an SQLITE_UPDATE. This is probably
      ** incorrect, but is convenient because at this point the new.* values
      ** are not easily obtainable. And for the sessions module, an
      ** SQLITE_UPDATE where the PK columns do not change is handled in the
      ** same way as an SQLITE_DELETE (the SQLITE_DELETE code is actually
      ** slightly more efficient). Since you cannot write to a PK column
      ** using the incremental-blob API, this works. For the sessions module
      ** anyhow.
      */
      sqlite3_int64 iKey;
      iKey = sqlite3BtreeIntegerKey(p->pCsr);
      sqlite3VdbePreUpdateHook(
          v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1
      );
    }
#endif
 
    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
    sqlite3BtreeLeaveCursor(p->pCsr);
    if( rc==SQLITE_ABORT ){
      sqlite3VdbeFinalize(v);
      p->pStmt = 0;
    }else{
      v->rc = rc;
    }

◆ blobSeekToRow()

static int blobSeekToRow	(	Incrblob *	p,
		sqlite3_int64	iRow,
		char **	pzErr )

static

Definition at line 93421 of file sqlite3.c.

                                                                       {
  int rc;                         /* Error code */
  char *zErr = 0;                 /* Error message */
  Vdbe *v = (Vdbe *)p->pStmt;
 
  /* Set the value of register r[1] in the SQL statement to integer iRow.
  ** This is done directly as a performance optimization
  */
  v->aMem[1].flags = MEM_Int;
  v->aMem[1].u.i = iRow;
 
  /* If the statement has been run before (and is paused at the OP_ResultRow)
  ** then back it up to the point where it does the OP_NotExists.  This could
  ** have been down with an extra OP_Goto, but simply setting the program
  ** counter is faster. */
  if( v->pc>4 ){
    v->pc = 4;
    assert( v->aOp[v->pc].opcode==OP_NotExists );
    rc = sqlite3VdbeExec(v);
  }else{
    rc = sqlite3_step(p->pStmt);
  }
  if( rc==SQLITE_ROW ){
    VdbeCursor *pC = v->apCsr[0];
    u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
    testcase( pC->nHdrParsed==p->iCol );
    testcase( pC->nHdrParsed==p->iCol+1 );
    if( type<12 ){
      zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
          type==0?"null": type==7?"real": "integer"
      );
      rc = SQLITE_ERROR;
      sqlite3_finalize(p->pStmt);
      p->pStmt = 0;
    }else{
      p->iOffset = pC->aType[p->iCol + pC->nField];
      p->nByte = sqlite3VdbeSerialTypeLen(type);
      p->pCsr =  pC->uc.pCursor;
      sqlite3BtreeIncrblobCursor(p->pCsr);
    }
  }
 
  if( rc==SQLITE_ROW ){
    rc = SQLITE_OK;
  }else if( p->pStmt ){
    rc = sqlite3_finalize(p->pStmt);
    p->pStmt = 0;
    if( rc==SQLITE_OK ){
      zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
      rc = SQLITE_ERROR;
    }else{
      zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
    }
  }
 

References Vdbe::aMem, Vdbe::aOp, Vdbe::apCsr, VdbeCursor::aType, Incrblob::db, sqlite3_value::flags, sqlite3_value::MemValue::i, Incrblob::iCol, Incrblob::iOffset, MEM_Int, Incrblob::nByte, VdbeCursor::nField, VdbeCursor::nHdrParsed, OP_NotExists, VdbeOp::opcode, Vdbe::pc, Incrblob::pCsr, VdbeCursor::pCursor, Incrblob::pStmt, sqlite3_errmsg(), sqlite3_finalize(), sqlite3_step(), sqlite3BtreeIncrblobCursor(), sqlite3MPrintf(), sqlite3VdbeExec(), sqlite3VdbeSerialTypeLen(), SQLITE_DONE, SQLITE_ERROR, SQLITE_OK, SQLITE_ROW, testcase, sqlite3_value::u, and VdbeCursor::uc.

Referenced by sqlite3_blob_reopen().

◆ btreeCellSizeCheck()

static SQLITE_NOINLINE int btreeCellSizeCheck ( MemPage * pPage )

static

Definition at line 66427 of file sqlite3.c.

                                                             {
  int iCellFirst;    /* First allowable cell or freeblock offset */
  int iCellLast;     /* Last possible cell or freeblock offset */
  int i;             /* Index into the cell pointer array */
  int sz;            /* Size of a cell */
  int pc;            /* Address of a freeblock within pPage->aData[] */
  u8 *data;          /* Equal to pPage->aData */
  int usableSize;    /* Maximum usable space on the page */
  int cellOffset;    /* Start of cell content area */
 
  iCellFirst = pPage->cellOffset + 2*pPage->nCell;
  usableSize = pPage->pBt->usableSize;
  iCellLast = usableSize - 4;
  data = pPage->aData;
  cellOffset = pPage->cellOffset;
  if( !pPage->leaf ) iCellLast--;
  for(i=0; i<pPage->nCell; i++){
    pc = get2byteAligned(&data[cellOffset+i*2]);
    testcase( pc==iCellFirst );
    testcase( pc==iCellLast );
    if( pc<iCellFirst || pc>iCellLast ){
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    sz = pPage->xCellSize(pPage, &data[pc]);
    testcase( pc+sz==usableSize );

Referenced by btreeInitPage().

◆ btreeClearHasContent()

static void btreeClearHasContent ( BtShared * pBt )

static

Definition at line 65100 of file sqlite3.c.

Referenced by sqlite3BtreeCommitPhaseTwo(), and sqlite3BtreeRollback().

◆ btreeComputeFreeSpace()

static int btreeComputeFreeSpace ( MemPage * pPage )

static

Definition at line 66345 of file sqlite3.c.

                                                {
  int pc;            /* Address of a freeblock within pPage->aData[] */
  u8 hdr;            /* Offset to beginning of page header */
  u8 *data;          /* Equal to pPage->aData */
  int usableSize;    /* Amount of usable space on each page */
  int nFree;         /* Number of unused bytes on the page */
  int top;           /* First byte of the cell content area */
  int iCellFirst;    /* First allowable cell or freeblock offset */
  int iCellLast;     /* Last possible cell or freeblock offset */
 
  assert( pPage->pBt!=0 );
  assert( pPage->pBt->db!=0 );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
  assert( pPage->isInit==1 );
  assert( pPage->nFree<0 );
 
  usableSize = pPage->pBt->usableSize;
  hdr = pPage->hdrOffset;
  data = pPage->aData;
  /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
  ** the start of the cell content area. A zero value for this integer is
  ** interpreted as 65536. */
  top = get2byteNotZero(&data[hdr+5]);
  iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell;
  iCellLast = usableSize - 4;
 
  /* Compute the total free space on the page
  ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the
  ** start of the first freeblock on the page, or is zero if there are no
  ** freeblocks. */
  pc = get2byte(&data[hdr+1]);
  nFree = data[hdr+7] + top;  /* Init nFree to non-freeblock free space */
  if( pc>0 ){
    u32 next, size;
    if( pc<top ){
      /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
      ** always be at least one cell before the first freeblock.
      */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    while( 1 ){
      if( pc>iCellLast ){
        /* Freeblock off the end of the page */
        return SQLITE_CORRUPT_PAGE(pPage);
      }
      next = get2byte(&data[pc]);
      size = get2byte(&data[pc+2]);
      nFree = nFree + size;
      if( next<=pc+size+3 ) break;
      pc = next;
    }
    if( next>0 ){
      /* Freeblock not in ascending order */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    if( pc+size>(unsigned int)usableSize ){
      /* Last freeblock extends past page end */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
  }
 
  /* At this point, nFree contains the sum of the offset to the start
  ** of the cell-content area plus the number of free bytes within
  ** the cell-content area. If this is greater than the usable-size
  ** of the page, then the page must be corrupted. This check also
  ** serves to verify that the offset to the start of the cell-content
  ** area, according to the page header, lies within the page.
  */

Referenced by balance(), balance_nonroot(), checkTreePage(), copyNodeContent(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ btreeCreateTable()

static int btreeCreateTable	(	Btree *	p,
		Pgno *	piTable,
		int	createTabFlags )

static

Definition at line 73578 of file sqlite3.c.

                       :
**
**     BTREE_INTKEY|BTREE_LEAFDATA     Used for SQL tables with rowid keys
**     BTREE_ZERODATA                  Used for SQL indices
*/
static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){
  BtShared *pBt = p->pBt;
  MemPage *pRoot;
  Pgno pgnoRoot;
  int rc;
  int ptfFlags;          /* Page-type flage for the root page of new table */
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( pBt->inTransaction==TRANS_WRITE );
  assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
 
#ifdef SQLITE_OMIT_AUTOVACUUM
  rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
  if( rc ){
    return rc;
  }
#else
  if( pBt->autoVacuum ){
    Pgno pgnoMove;      /* Move a page here to make room for the root-page */
    MemPage *pPageMove; /* The page to move to. */
 
    /* Creating a new table may probably require moving an existing database
    ** to make room for the new tables root page. In case this page turns
    ** out to be an overflow page, delete all overflow page-map caches
    ** held by open cursors.
    */
    invalidateAllOverflowCache(pBt);
 
    /* Read the value of meta[3] from the database to determine where the
    ** root page of the new table should go. meta[3] is the largest root-page
    ** created so far, so the new root-page is (meta[3]+1).
    */
    sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
    if( pgnoRoot>btreePagecount(pBt) ){
      return SQLITE_CORRUPT_BKPT;
    }
    pgnoRoot++;
 
    /* The new root-page may not be allocated on a pointer-map page, or the
    ** PENDING_BYTE page.
    */
    while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
        pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
      pgnoRoot++;
    }
    assert( pgnoRoot>=3 );
 
    /* Allocate a page. The page that currently resides at pgnoRoot will
    ** be moved to the allocated page (unless the allocated page happens
    ** to reside at pgnoRoot).
    */
    rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT);
    if( rc!=SQLITE_OK ){
      return rc;
    }
 
    if( pgnoMove!=pgnoRoot ){
      /* pgnoRoot is the page that will be used for the root-page of
      ** the new table (assuming an error did not occur). But we were
      ** allocated pgnoMove. If required (i.e. if it was not allocated
      ** by extending the file), the current page at position pgnoMove
      ** is already journaled.
      */
      u8 eType = 0;
      Pgno iPtrPage = 0;
 
      /* Save the positions of any open cursors. This is required in
      ** case they are holding a reference to an xFetch reference
      ** corresponding to page pgnoRoot.  */
      rc = saveAllCursors(pBt, 0, 0);
      releasePage(pPageMove);
      if( rc!=SQLITE_OK ){
        return rc;
      }
 
      /* Move the page currently at pgnoRoot to pgnoMove. */
      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
      if( rc!=SQLITE_OK ){
        return rc;
      }
      rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
      if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
        rc = SQLITE_CORRUPT_BKPT;
      }
      if( rc!=SQLITE_OK ){
        releasePage(pRoot);
        return rc;
      }
      assert( eType!=PTRMAP_ROOTPAGE );
      assert( eType!=PTRMAP_FREEPAGE );
      rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
      releasePage(pRoot);
 
      /* Obtain the page at pgnoRoot */
      if( rc!=SQLITE_OK ){
        return rc;
      }
      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
      if( rc!=SQLITE_OK ){
        return rc;
      }
      rc = sqlite3PagerWrite(pRoot->pDbPage);
      if( rc!=SQLITE_OK ){
        releasePage(pRoot);
        return rc;
      }
    }else{
      pRoot = pPageMove;
    }
 
    /* Update the pointer-map and meta-data with the new root-page number. */
    ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
    if( rc ){
      releasePage(pRoot);
      return rc;
    }
 
    /* When the new root page was allocated, page 1 was made writable in
    ** order either to increase the database filesize, or to decrement the
    ** freelist count.  Hence, the sqlite3BtreeUpdateMeta() call cannot fail.
    */
    assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
    rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
    if( NEVER(rc) ){
      releasePage(pRoot);
      return rc;
    }
 
  }else{
    rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
    if( rc ) return rc;
  }
#endif
  assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
  if( createTabFlags & BTREE_INTKEY ){
    ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF;
  }else{
    ptfFlags = PTF_ZERODATA | PTF_LEAF;
  }

References allocateBtreePage(), BtShared::autoVacuum, BTALLOC_EXACT, BTREE_INTKEY, BTREE_LARGEST_ROOT_PAGE, btreeGetPage(), btreePagecount(), BTS_READ_ONLY, BtShared::btsFlags, eType, BtShared::inTransaction, invalidateAllOverflowCache(), NEVER, Btree::pBt, MemPage::pDbPage, PENDING_BYTE_PAGE, BtShared::pPage1, PTF_INTKEY, PTF_LEAF, PTF_LEAFDATA, PTF_ZERODATA, PTRMAP_FREEPAGE, PTRMAP_PAGENO, PTRMAP_ROOTPAGE, ptrmapGet(), ptrmapPut(), releasePage(), relocatePage(), saveAllCursors(), sqlite3BtreeGetMeta(), sqlite3BtreeUpdateMeta(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_OK, and TRANS_WRITE.

◆ btreeCursor()

static int btreeCursor	(	Btree *	p,
		Pgno	iTable,
		int	wrFlag,
		struct KeyInfo *	pKeyInfo,
		BtCursor *	pCur )

static

Definition at line 68849 of file sqlite3.c.

 {
  BtShared *pBt = p->pBt;                /* Shared b-tree handle */
  BtCursor *pX;                          /* Looping over other all cursors */
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( wrFlag==0
       || wrFlag==BTREE_WRCSR
       || wrFlag==(BTREE_WRCSR|BTREE_FORDELETE)
  );
 
  /* The following assert statements verify that if this is a sharable
  ** b-tree database, the connection is holding the required table locks,
  ** and that no other connection has any open cursor that conflicts with
  ** this lock.  The iTable<1 term disables the check for corrupt schemas. */
  assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1))
          || iTable<1 );
  assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
 
  /* Assert that the caller has opened the required transaction. */
  assert( p->inTrans>TRANS_NONE );
  assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
  assert( pBt->pPage1 && pBt->pPage1->aData );
  assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 );
 
  if( wrFlag ){
    allocateTempSpace(pBt);
    if( pBt->pTmpSpace==0 ) return SQLITE_NOMEM_BKPT;
  }
  if( iTable<=1 ){
    if( iTable<1 ){
      return SQLITE_CORRUPT_BKPT;
    }else if( btreePagecount(pBt)==0 ){
      assert( wrFlag==0 );
      iTable = 0;
    }
  }
 
  /* Now that no other errors can occur, finish filling in the BtCursor
  ** variables and link the cursor into the BtShared list.  */
  pCur->pgnoRoot = iTable;
  pCur->iPage = -1;
  pCur->pKeyInfo = pKeyInfo;
  pCur->pBtree = p;
  pCur->pBt = pBt;
  pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0;
  pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY;
  /* If there are two or more cursors on the same btree, then all such
  ** cursors *must* have the BTCF_Multiple flag set. */
  for(pX=pBt->pCursor; pX; pX=pX->pNext){
    if( pX->pgnoRoot==iTable ){
      pX->curFlags |= BTCF_Multiple;
      pCur->curFlags |= BTCF_Multiple;
    }

References MemPage::aData, allocateTempSpace(), BTCF_Multiple, BTCF_WriteFlag, BTREE_FORDELETE, BTREE_WRCSR, btreePagecount(), BTS_READ_ONLY, BtShared::btsFlags, BtCursor::curFlags, BtCursor::curPagerFlags, Btree::inTrans, BtCursor::iPage, PAGER_GET_READONLY, Btree::pBt, BtCursor::pBt, BtCursor::pBtree, BtShared::pCursor, BtCursor::pgnoRoot, BtCursor::pKeyInfo, BtCursor::pNext, BtShared::pPage1, BtShared::pTmpSpace, SQLITE_CORRUPT_BKPT, SQLITE_NOMEM_BKPT, TRANS_NONE, and TRANS_WRITE.

◆ btreeCursorWithLock()

static int btreeCursorWithLock	(	Btree *	p,
		Pgno	iTable,
		int	wrFlag,
		struct KeyInfo *	pKeyInfo,
		BtCursor *	pCur )

static

Definition at line 68914 of file sqlite3.c.

68926 {

◆ btreeDropTable()

static int btreeDropTable	(	Btree *	p,
		Pgno	iTable,
		int *	piMoved )

static

Definition at line 73850 of file sqlite3.c.

                                                              {
  int rc;
  MemPage *pPage = 0;
  BtShared *pBt = p->pBt;
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( p->inTrans==TRANS_WRITE );
  assert( iTable>=2 );
  if( iTable>btreePagecount(pBt) ){
    return SQLITE_CORRUPT_BKPT;
  }
 
  rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
  if( rc ) return rc;
  rc = sqlite3BtreeClearTable(p, iTable, 0);
  if( rc ){
    releasePage(pPage);
    return rc;
  }
 
  *piMoved = 0;
 
#ifdef SQLITE_OMIT_AUTOVACUUM
  freePage(pPage, &rc);
  releasePage(pPage);
#else
  if( pBt->autoVacuum ){
    Pgno maxRootPgno;
    sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
 
    if( iTable==maxRootPgno ){
      /* If the table being dropped is the table with the largest root-page
      ** number in the database, put the root page on the free list.
      */
      freePage(pPage, &rc);
      releasePage(pPage);
      if( rc!=SQLITE_OK ){
        return rc;
      }
    }else{
      /* The table being dropped does not have the largest root-page
      ** number in the database. So move the page that does into the
      ** gap left by the deleted root-page.
      */
      MemPage *pMove;
      releasePage(pPage);
      rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
      if( rc!=SQLITE_OK ){
        return rc;
      }
      rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
      releasePage(pMove);
      if( rc!=SQLITE_OK ){
        return rc;
      }
      pMove = 0;
      rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
      freePage(pMove, &rc);
      releasePage(pMove);
      if( rc!=SQLITE_OK ){
        return rc;
      }
      *piMoved = maxRootPgno;
    }
 
    /* Set the new 'max-root-page' value in the database header. This
    ** is the old value less one, less one more if that happens to
    ** be a root-page number, less one again if that is the
    ** PENDING_BYTE_PAGE.
    */
    maxRootPgno--;
    while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
           || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
      maxRootPgno--;
    }
    assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
 
    rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
  }else{

References BtShared::autoVacuum, BTREE_LARGEST_ROOT_PAGE, btreeGetPage(), btreePagecount(), freePage(), Btree::inTrans, Btree::pBt, PENDING_BYTE_PAGE, PTRMAP_ISPAGE, PTRMAP_ROOTPAGE, releasePage(), relocatePage(), sqlite3BtreeClearTable(), sqlite3BtreeGetMeta(), sqlite3BtreeUpdateMeta(), SQLITE_CORRUPT_BKPT, SQLITE_OK, and TRANS_WRITE.

◆ btreeEndTransaction()

static void btreeEndTransaction ( Btree * p )

static

Definition at line 68500 of file sqlite3.c.

                                         {
  BtShared *pBt = p->pBt;
  sqlite3 *db = p->db;
  assert( sqlite3BtreeHoldsMutex(p) );
 
#ifndef SQLITE_OMIT_AUTOVACUUM
  pBt->bDoTruncate = 0;
#endif
  if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
    /* If there are other active statements that belong to this database
    ** handle, downgrade to a read-only transaction. The other statements
    ** may still be reading from the database.  */
    downgradeAllSharedCacheTableLocks(p);
    p->inTrans = TRANS_READ;
  }else{
    /* If the handle had any kind of transaction open, decrement the
    ** transaction count of the shared btree. If the transaction count
    ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
    ** call below will unlock the pager.  */
    if( p->inTrans!=TRANS_NONE ){
      clearAllSharedCacheTableLocks(p);
      pBt->nTransaction--;
      if( 0==pBt->nTransaction ){
        pBt->inTransaction = TRANS_NONE;
      }
    }
 
    /* Set the current transaction state to TRANS_NONE and unlock the
    ** pager if this call closed the only read or write transaction.  */

Referenced by sqlite3BtreeCommitPhaseTwo(), and sqlite3BtreeRollback().

◆ btreeEnterAll()

static void SQLITE_NOINLINE btreeEnterAll ( sqlite3 * db )

static

Definition at line 64352 of file sqlite3.c.

                                                      {
  int i;
  int skipOk = 1;
  Btree *p;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nDb; i++){
    p = db->aDb[i].pBt;
    if( p && p->sharable ){

References sqlite3::aDb, sqlite3::mutex, sqlite3::nDb, Db::pBt, Btree::sharable, and sqlite3_mutex_held().

◆ btreeGetHasContent()

static int btreeGetHasContent	(	BtShared *	pBt,
		Pgno	pgno )

static

Definition at line 65091 of file sqlite3.c.

References BtShared::pHasContent, sqlite3BitvecSize(), and sqlite3BitvecTestNotNull().

Referenced by allocateBtreePage().

◆ btreeGetPage()

static int btreeGetPage	(	BtShared *	pBt,
		Pgno	pgno,
		MemPage **	ppPage,
		int	flags )

static

Definition at line 66582 of file sqlite3.c.

 {
  int rc;
  DbPage *pDbPage;
 
  assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY );

References btreePageFromDbPage(), BtShared::mutex, PAGER_GET_NOCONTENT, PAGER_GET_READONLY, BtShared::pPager, sqlite3_mutex_held(), sqlite3PagerGet(), and SQLITE_OK.

Referenced by btreeCreateTable(), btreeDropTable(), btreeGetUnusedPage(), checkTreePage(), freePage2(), getOverflowPage(), incrVacuumStep(), lockBtree(), relocatePage(), and sqlite3BtreeRollback().

◆ btreeGetUnusedPage()

static int btreeGetUnusedPage	(	BtShared *	pBt,
		Pgno	pgno,
		MemPage **	ppPage,
		int	flags )

static

Definition at line 66730 of file sqlite3.c.

                                                        :
**
**   *  If the page is already in use for some other purpose, immediately
**      release it and return an SQLITE_CURRUPT error.
**   *  Make sure the isInit flag is clear
*/
static int btreeGetUnusedPage(
  BtShared *pBt,       /* The btree */
  Pgno pgno,           /* Number of the page to fetch */
  MemPage **ppPage,    /* Return the page in this parameter */
  int flags            /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
){
  int rc = btreeGetPage(pBt, pgno, ppPage, flags);
  if( rc==SQLITE_OK ){
    if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
      releasePage(*ppPage);
      *ppPage = 0;
      return SQLITE_CORRUPT_BKPT;
    }

References btreeGetPage(), MemPage::isInit, releasePage(), sqlite3PagerPageRefcount(), SQLITE_CORRUPT_BKPT, and SQLITE_OK.

Referenced by allocateBtreePage().

◆ btreeHeapInsert()

static void btreeHeapInsert	(	u32 *	aHeap,
		u32	x )

static

Definition at line 74293 of file sqlite3.c.

                                              {
  u32 j, i = ++aHeap[0];
  aHeap[i] = x;
  while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){

Referenced by checkTreePage().

◆ btreeHeapPull()

static int btreeHeapPull	(	u32 *	aHeap,
		u32 *	pOut )

static

Definition at line 74303 of file sqlite3.c.

                                               {
  u32 j, i, x;
  if( (x = aHeap[0])==0 ) return 0;
  *pOut = aHeap[1];
  aHeap[1] = aHeap[x];
  aHeap[x] = 0xffffffff;
  aHeap[0]--;
  i = 1;
  while( (j = i*2)<=aHeap[0] ){
    if( aHeap[j]>aHeap[j+1] ) j++;
    if( aHeap[i]<aHeap[j] ) break;
    x = aHeap[i];

Referenced by checkTreePage().

◆ btreeInitPage()

static int btreeInitPage ( MemPage * pPage )

static

Definition at line 66468 of file sqlite3.c.

                                        {
  u8 *data;          /* Equal to pPage->aData */
  BtShared *pBt;        /* The main btree structure */
 
  assert( pPage->pBt!=0 );
  assert( pPage->pBt->db!=0 );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
  assert( pPage->isInit==0 );
 
  pBt = pPage->pBt;
  data = pPage->aData + pPage->hdrOffset;
  /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
  ** the b-tree page type. */
  if( decodeFlags(pPage, data[0]) ){
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
  pPage->maskPage = (u16)(pBt->pageSize - 1);
  pPage->nOverflow = 0;
  pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize;
  pPage->aCellIdx = data + pPage->childPtrSize + 8;
  pPage->aDataEnd = pPage->aData + pBt->usableSize;
  pPage->aDataOfst = pPage->aData + pPage->childPtrSize;
  /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
  ** number of cells on the page. */
  pPage->nCell = get2byte(&data[3]);
  if( pPage->nCell>MX_CELL(pBt) ){
    /* To many cells for a single page.  The page must be corrupt */
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  testcase( pPage->nCell==MX_CELL(pBt) );
  /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
  ** possible for a root page of a table that contains no rows) then the
  ** offset to the cell content area will equal the page size minus the
  ** bytes of reserved space. */
  assert( pPage->nCell>0
       || get2byteNotZero(&data[5])==(int)pBt->usableSize
       || CORRUPT_DB );
  pPage->nFree = -1;  /* Indicate that this value is yet uncomputed */

References MemPage::aCellIdx, MemPage::aData, MemPage::aDataEnd, MemPage::aDataOfst, btreeCellSizeCheck(), MemPage::cellOffset, MemPage::childPtrSize, CORRUPT_DB, BtShared::db, decodeFlags(), sqlite3::flags, get2byte, get2byteNotZero, MemPage::hdrOffset, MemPage::isInit, MemPage::maskPage, BtShared::mutex, MX_CELL, MemPage::nCell, MemPage::nFree, MemPage::nOverflow, BtShared::pageSize, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, sqlite3_mutex_held(), sqlite3PagerGetData(), sqlite3PagerGetExtra(), SQLITE_CellSizeCk, SQLITE_CORRUPT_PAGE, SQLITE_OK, testcase, and BtShared::usableSize.

Referenced by checkTreePage(), copyNodeContent(), getAndInitPage(), modifyPagePointer(), pageReinit(), and setChildPtrmaps().

◆ btreeInvokeBusyHandler()

static int btreeInvokeBusyHandler ( void * pArg )

static

Definition at line 66781 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), and sqlite3BtreeOpen().

◆ btreeLeaveAll()

static void SQLITE_NOINLINE btreeLeaveAll ( sqlite3 * db )

static

Definition at line 64369 of file sqlite3.c.

                                                     {
  if( db->noSharedCache==0 ) btreeEnterAll(db);
}
static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){
  int i;
  Btree *p;

◆ btreeLockCarefully()

static void SQLITE_NOINLINE btreeLockCarefully ( Btree * p )

static

Definition at line 64271 of file sqlite3.c.

                                                        {
  Btree *pLater;
 
  /* In most cases, we should be able to acquire the lock we
  ** want without having to go through the ascending lock
  ** procedure that follows.  Just be sure not to block.
  */
  if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
    p->pBt->db = p->db;
    p->locked = 1;
    return;
  }
 
  /* To avoid deadlock, first release all locks with a larger
  ** BtShared address.  Then acquire our lock.  Then reacquire
  ** the other BtShared locks that we used to hold in ascending
  ** order.
  */
  for(pLater=p->pNext; pLater; pLater=pLater->pNext){
    assert( pLater->sharable );
    assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
    assert( !pLater->locked || pLater->wantToLock>0 );
    if( pLater->locked ){
      unlockBtreeMutex(pLater);
    }
  }
  lockBtreeMutex(p);

References Btree::db, BtShared::db, lockBtreeMutex(), Btree::locked, BtShared::mutex, Btree::pBt, Btree::pNext, Btree::sharable, sqlite3_mutex_try(), SQLITE_OK, unlockBtreeMutex(), and Btree::wantToLock.

Referenced by sqlite3BtreeEnter().

◆ btreeMoveto()

static int btreeMoveto	(	BtCursor *	pCur,
		const void *	pKey,
		i64	nKey,
		int	bias,
		int *	pRes )

static

Definition at line 65278 of file sqlite3.c.

 {
  int rc;                    /* Status code */
  UnpackedRecord *pIdxKey;   /* Unpacked index key */
 
  if( pKey ){
    KeyInfo *pKeyInfo = pCur->pKeyInfo;
    assert( nKey==(i64)(int)nKey );
    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
    if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
    if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
      rc = SQLITE_CORRUPT_BKPT;
      goto moveto_done;
    }
  }else{
    pIdxKey = 0;
  }
  rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);

References KeyInfo::db, KeyInfo::nAllField, UnpackedRecord::nField, BtCursor::pKeyInfo, sqlite3BtreeMovetoUnpacked(), sqlite3DbFree(), sqlite3VdbeAllocUnpackedRecord(), sqlite3VdbeRecordUnpack(), SQLITE_CORRUPT_BKPT, and SQLITE_NOMEM_BKPT.

Referenced by btreeRestoreCursorPosition(), and sqlite3BtreeInsert().

◆ btreeNext()

static SQLITE_NOINLINE int btreeNext ( BtCursor * pCur )

static

Definition at line 70192 of file sqlite3.c.

                                                    {
  int rc;
  int idx;
  MemPage *pPage;
 
  assert( cursorOwnsBtShared(pCur) );
  if( pCur->eState!=CURSOR_VALID ){
    assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      return SQLITE_DONE;
    }
    if( pCur->eState==CURSOR_SKIPNEXT ){
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext>0 ) return SQLITE_OK;
    }
  }
 
  pPage = pCur->pPage;
  idx = ++pCur->ix;
  if( !pPage->isInit ){
    /* The only known way for this to happen is for there to be a
    ** recursive SQL function that does a DELETE operation as part of a
    ** SELECT which deletes content out from under an active cursor
    ** in a corrupt database file where the table being DELETE-ed from
    ** has pages in common with the table being queried.  See TH3
    ** module cov1/btree78.test testcase 220 (2018-06-08) for an
    ** example. */
    return SQLITE_CORRUPT_BKPT;
  }
 
  /* If the database file is corrupt, it is possible for the value of idx
  ** to be invalid here. This can only occur if a second cursor modifies
  ** the page while cursor pCur is holding a reference to it. Which can
  ** only happen if the database is corrupt in such a way as to link the
  ** page into more than one b-tree structure.
  **
  ** Update 2019-12-23: appears to long longer be possible after the
  ** addition of anotherValidCursor() condition on balance_deeper().  */
  harmless( idx>pPage->nCell );
 
  if( idx>=pPage->nCell ){
    if( !pPage->leaf ){
      rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
      if( rc ) return rc;
      return moveToLeftmost(pCur);
    }
    do{
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        return SQLITE_DONE;
      }
      moveToParent(pCur);
      pPage = pCur->pPage;
    }while( pCur->ix>=pPage->nCell );
    if( pPage->intKey ){
      return sqlite3BtreeNext(pCur, 0);
    }else{
      return SQLITE_OK;
    }
  }

References MemPage::aData, BTCF_ValidOvfl, BtCursor::curFlags, CURSOR_INVALID, CURSOR_SKIPNEXT, CURSOR_VALID, BtCursor::eState, get4byte, harmless, MemPage::hdrOffset, MemPage::intKey, BtCursor::iPage, MemPage::isInit, BtCursor::ix, MemPage::leaf, moveToChild(), moveToLeftmost(), moveToParent(), MemPage::nCell, BtCursor::pPage, restoreCursorPosition, BtCursor::skipNext, sqlite3BtreeNext(), SQLITE_CORRUPT_BKPT, SQLITE_DONE, and SQLITE_OK.

◆ btreeOverwriteCell()

static int btreeOverwriteCell	(	BtCursor *	pCur,
		const BtreePayload *	pX )

static

Definition at line 73030 of file sqlite3.c.

                                                                     {
  int iOffset;                        /* Next byte of pX->pData to write */
  int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */
  int rc;                             /* Return code */
  MemPage *pPage = pCur->pPage;       /* Page being written */
  BtShared *pBt;                      /* Btree */
  Pgno ovflPgno;                      /* Next overflow page to write */
  u32 ovflPageSize;                   /* Size to write on overflow page */
 
  if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
   || pCur->info.pPayload < pPage->aData + pPage->cellOffset
  ){
    return SQLITE_CORRUPT_BKPT;
  }
  /* Overwrite the local portion first */
  rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
                             0, pCur->info.nLocal);
  if( rc ) return rc;
  if( pCur->info.nLocal==nTotal ) return SQLITE_OK;
 
  /* Now overwrite the overflow pages */
  iOffset = pCur->info.nLocal;
  assert( nTotal>=0 );
  assert( iOffset>=0 );
  ovflPgno = get4byte(pCur->info.pPayload + iOffset);
  pBt = pPage->pBt;
  ovflPageSize = pBt->usableSize - 4;
  do{
    rc = btreeGetPage(pBt, ovflPgno, &pPage, 0);
    if( rc ) return rc;
    if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 ){
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      if( iOffset+ovflPageSize<(u32)nTotal ){
        ovflPgno = get4byte(pPage->aData);
      }else{
        ovflPageSize = nTotal - iOffset;
      }
      rc = btreeOverwriteContent(pPage, pPage->aData+4, pX,
                                 iOffset, ovflPageSize);
    }

Referenced by sqlite3BtreeInsert().

◆ btreeOverwriteContent()

static int btreeOverwriteContent	(	MemPage *	pPage,
		u8 *	pDest,
		const BtreePayload *	pX,
		int	iOffset,
		int	iAmt )

static

Definition at line 72987 of file sqlite3.c.

 {
  int nData = pX->nData - iOffset;
  if( nData<=0 ){
    /* Overwritting with zeros */
    int i;
    for(i=0; i<iAmt && pDest[i]==0; i++){}
    if( i<iAmt ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      memset(pDest + i, 0, iAmt - i);
    }
  }else{
    if( nData<iAmt ){
      /* Mixed read data and zeros at the end.  Make a recursive call
      ** to write the zeros then fall through to write the real data */
      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
                                 iAmt-nData);
      if( rc ) return rc;
      iAmt = nData;
    }
    if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      /* In a corrupt database, it is possible for the source and destination
      ** buffers to overlap.  This is harmless since the database is already
      ** corrupt but it does cause valgrind and ASAN warnings.  So use

◆ btreePagecount()

static Pgno btreePagecount ( BtShared * pBt )

static

Definition at line 66618 of file sqlite3.c.

Referenced by allocateBtreePage(), autoVacuumCommit(), btreeCreateTable(), btreeCursor(), btreeDropTable(), freePage2(), getAndInitPage(), getOverflowPage(), sqlite3BtreeIncrVacuum(), and sqlite3BtreeIntegrityCheck().

◆ btreePageFromDbPage()

static MemPage * btreePageFromDbPage	(	DbPage *	pDbPage,
		Pgno	pgno,
		BtShared *	pBt )

static

Definition at line 66558 of file sqlite3.c.

                                                                              {
  MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
  if( pgno!=pPage->pgno ){
    pPage->aData = sqlite3PagerGetData(pDbPage);
    pPage->pDbPage = pDbPage;
    pPage->pBt = pBt;

References MemPage::aData, MemPage::hdrOffset, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, sqlite3PagerGetData(), and sqlite3PagerGetExtra().

Referenced by btreeGetPage(), btreePageLookup(), and getAndInitPage().

◆ btreePageLookup()

static MemPage * btreePageLookup	(	BtShared *	pBt,
		Pgno	pgno )

static

Definition at line 66604 of file sqlite3.c.

                                                         {
  DbPage *pDbPage;
  assert( sqlite3_mutex_held(pBt->mutex) );

References btreePageFromDbPage(), BtShared::mutex, BtShared::pPager, sqlite3_mutex_held(), and sqlite3PagerLookup().

Referenced by freePage2().

◆ btreeParseCell()

static void btreeParseCell	(	MemPage *	pPage,
		int	iCell,
		CellInfo *	pInfo )

static

Definition at line 65748 of file sqlite3.c.

       {
    btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo);
  }
}
static void btreeParseCell(

◆ btreeParseCellAdjustSizeForOverflow()

static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow	(	MemPage *	pPage,
		u8 *	pCell,
		CellInfo *	pInfo )

static

Definition at line 65581 of file sqlite3.c.

 {
  /* If the payload will not fit completely on the local page, we have
  ** to decide how much to store locally and how much to spill onto
  ** overflow pages.  The strategy is to minimize the amount of unused
  ** space on overflow pages while keeping the amount of local storage
  ** in between minLocal and maxLocal.
  **
  ** Warning:  changing the way overflow payload is distributed in any
  ** way will result in an incompatible file format.
  */
  int minLocal;  /* Minimum amount of payload held locally */
  int maxLocal;  /* Maximum amount of payload held locally */
  int surplus;   /* Overflow payload available for local storage */
 
  minLocal = pPage->minLocal;
  maxLocal = pPage->maxLocal;
  surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4);
  testcase( surplus==maxLocal );
  testcase( surplus==maxLocal+1 );
  if( surplus <= maxLocal ){

References MemPage::maxLocal, MemPage::minLocal, CellInfo::nLocal, CellInfo::nPayload, CellInfo::nSize, MemPage::pBt, CellInfo::pPayload, testcase, and BtShared::usableSize.

◆ btreeParseCellPtr()

static void btreeParseCellPtr	(	MemPage *	pPage,
		u8 *	pCell,
		CellInfo *	pInfo )

static

Definition at line 65643 of file sqlite3.c.

 {
  u8 *pIter;              /* For scanning through pCell */
  u32 nPayload;           /* Number of bytes of cell payload */
  u64 iKey;               /* Extracted Key value */
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->leaf==0 || pPage->leaf==1 );
  assert( pPage->intKeyLeaf );
  assert( pPage->childPtrSize==0 );
  pIter = pCell;
 
  /* The next block of code is equivalent to:
  **
  **     pIter += getVarint32(pIter, nPayload);
  **
  ** The code is inlined to avoid a function call.
  */
  nPayload = *pIter;
  if( nPayload>=0x80 ){
    u8 *pEnd = &pIter[8];
    nPayload &= 0x7f;
    do{
      nPayload = (nPayload<<7) | (*++pIter & 0x7f);
    }while( (*pIter)>=0x80 && pIter<pEnd );
  }
  pIter++;
 
  /* The next block of code is equivalent to:
  **
  **     pIter += getVarint(pIter, (u64*)&pInfo->nKey);
  **
  ** The code is inlined to avoid a function call.
  */
  iKey = *pIter;
  if( iKey>=0x80 ){
    u8 *pEnd = &pIter[7];
    iKey &= 0x7f;
    while(1){
      iKey = (iKey<<7) | (*++pIter & 0x7f);
      if( (*pIter)<0x80 ) break;
      if( pIter>=pEnd ){
        iKey = (iKey<<8) | *++pIter;
        break;
      }
    }
  }
  pIter++;
 
  pInfo->nKey = *(i64*)&iKey;
  pInfo->nPayload = nPayload;
  pInfo->pPayload = pIter;
  testcase( nPayload==pPage->maxLocal );
  testcase( nPayload==pPage->maxLocal+1 );
  if( nPayload<=pPage->maxLocal ){
    /* This is the (easy) common case where the entire payload fits
    ** on the local page.  No overflow is required.
    */
    pInfo->nSize = nPayload + (u16)(pIter - pCell);

Referenced by decodeFlags().

◆ btreeParseCellPtrIndex()

static void btreeParseCellPtrIndex	(	MemPage *	pPage,
		u8 *	pCell,
		CellInfo *	pInfo )

static

Definition at line 65711 of file sqlite3.c.

       {
    btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo);
  }
}
static void btreeParseCellPtrIndex(
  MemPage *pPage,         /* Page containing the cell */
  u8 *pCell,              /* Pointer to the cell text. */
  CellInfo *pInfo         /* Fill in this structure */
){
  u8 *pIter;              /* For scanning through pCell */
  u32 nPayload;           /* Number of bytes of cell payload */
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->leaf==0 || pPage->leaf==1 );
  assert( pPage->intKeyLeaf==0 );
  pIter = pCell + pPage->childPtrSize;
  nPayload = *pIter;
  if( nPayload>=0x80 ){
    u8 *pEnd = &pIter[8];
    nPayload &= 0x7f;
    do{
      nPayload = (nPayload<<7) | (*++pIter & 0x7f);
    }while( *(pIter)>=0x80 && pIter<pEnd );
  }
  pIter++;
  pInfo->nKey = nPayload;
  pInfo->nPayload = nPayload;
  pInfo->pPayload = pIter;
  testcase( nPayload==pPage->maxLocal );
  testcase( nPayload==pPage->maxLocal+1 );
  if( nPayload<=pPage->maxLocal ){
    /* This is the (easy) common case where the entire payload fits
    ** on the local page.  No overflow is required.
    */
    pInfo->nSize = nPayload + (u16)(pIter - pCell);

Referenced by decodeFlags().

◆ btreeParseCellPtrNoPayload()

static void btreeParseCellPtrNoPayload	(	MemPage *	pPage,
		u8 *	pCell,
		CellInfo *	pInfo )

static

Definition at line 65626 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->leaf==0 );
  assert( pPage->childPtrSize==4 );
#ifndef SQLITE_DEBUG
  UNUSED_PARAMETER(pPage);
#endif

References MemPage::childPtrSize, MemPage::leaf, BtShared::mutex, MemPage::pBt, sqlite3_mutex_held(), and UNUSED_PARAMETER.

Referenced by decodeFlags().

◆ btreePrevious()

static SQLITE_NOINLINE int btreePrevious ( BtCursor * pCur )

static

Definition at line 70302 of file sqlite3.c.

                                                        {
  int rc;
  MemPage *pPage;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
  assert( pCur->info.nSize==0 );
  if( pCur->eState!=CURSOR_VALID ){
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      return SQLITE_DONE;
    }
    if( CURSOR_SKIPNEXT==pCur->eState ){
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext<0 ) return SQLITE_OK;
    }
  }
 
  pPage = pCur->pPage;
  assert( pPage->isInit );
  if( !pPage->leaf ){
    int idx = pCur->ix;
    rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
    if( rc ) return rc;
    rc = moveToRightmost(pCur);
  }else{
    while( pCur->ix==0 ){
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        return SQLITE_DONE;
      }
      moveToParent(pCur);
    }
    assert( pCur->info.nSize==0 );
    assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
 
    pCur->ix--;
    pPage = pCur->pPage;
    if( pPage->intKey && !pPage->leaf ){
      rc = sqlite3BtreePrevious(pCur, 0);

References BTCF_AtLast, BTCF_ValidNKey, BTCF_ValidOvfl, BtCursor::curFlags, CURSOR_INVALID, CURSOR_SKIPNEXT, CURSOR_VALID, BtCursor::eState, findCell, get4byte, BtCursor::info, MemPage::intKey, BtCursor::iPage, MemPage::isInit, BtCursor::ix, MemPage::leaf, moveToChild(), moveToParent(), moveToRightmost(), CellInfo::nSize, BtCursor::pPage, restoreCursorPosition, BtCursor::skipNext, sqlite3BtreePrevious(), SQLITE_DONE, and SQLITE_OK.

◆ btreeReleaseAllCursorPages()

static void btreeReleaseAllCursorPages ( BtCursor * pCur )

static

Definition at line 65108 of file sqlite3.c.

                                                      {
  int i;
  if( pCur->iPage>=0 ){
    for(i=0; i<pCur->iPage; i++){

Referenced by saveCursorPosition(), saveCursorsOnList(), sqlite3BtreeDelete(), sqlite3BtreeInsert(), and sqlite3BtreeTripAllCursors().

◆ btreeRestoreCursorPosition()

static int btreeRestoreCursorPosition ( BtCursor * pCur )

static

Definition at line 65316 of file sqlite3.c.

                                                     {
  int rc;
  int skipNext = 0;
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState>=CURSOR_REQUIRESEEK );
  if( pCur->eState==CURSOR_FAULT ){
    return pCur->skipNext;
  }
  pCur->eState = CURSOR_INVALID;
  if( sqlite3FaultSim(410) ){
    rc = SQLITE_IOERR;
  }else{
    rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
  }
  if( rc==SQLITE_OK ){
    sqlite3_free(pCur->pKey);
    pCur->pKey = 0;
    assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
    if( skipNext ) pCur->skipNext = skipNext;

References btreeMoveto(), CURSOR_FAULT, CURSOR_INVALID, CURSOR_REQUIRESEEK, CURSOR_VALID, BtCursor::eState, BtCursor::nKey, BtCursor::pKey, BtCursor::skipNext, sqlite3_free(), sqlite3FaultSim(), SQLITE_IOERR, and SQLITE_OK.

Referenced by sqlite3BtreeDelete().

◆ btreeSetHasContent()

static int btreeSetHasContent	(	BtShared *	pBt,
		Pgno	pgno )

static

Definition at line 65069 of file sqlite3.c.

                                                       {
  int rc = SQLITE_OK;
  if( !pBt->pHasContent ){
    assert( pgno<=pBt->nPage );
    pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
    if( !pBt->pHasContent ){
      rc = SQLITE_NOMEM_BKPT;
    }

References BtShared::nPage, BtShared::pHasContent, sqlite3BitvecCreate(), sqlite3BitvecSet(), sqlite3BitvecSize(), SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by freePage2().

◆ btreeSetNPage()

static void btreeSetNPage	(	BtShared *	pBt,
		MemPage *	pPage1 )

static

Definition at line 68663 of file sqlite3.c.

68669 {

Referenced by sqlite3BtreeRollback(), and sqlite3BtreeSavepoint().

◆ cachedCellSize()

static u16 cachedCellSize	(	CellArray *	p,
		int	N )

static

Definition at line 71397 of file sqlite3.c.

                                                               {
  assert( N>=0 && N<p->nCell );
  assert( p->szCell[N]==0 );
  p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]);
  return p->szCell[N];

References CellArray::apCell, CellArray::pRef, CellArray::szCell, and MemPage::xCellSize.

Referenced by balance_nonroot(), and editPage().

◆ callCollNeeded()

static void callCollNeeded	(	sqlite3 *	db,
		int	enc,
		const char *	zName )

static

Definition at line 115559 of file sqlite3.c.

                                                                   {
  assert( !db->xCollNeeded || !db->xCollNeeded16 );
  if( db->xCollNeeded ){
    char *zExternal = sqlite3DbStrDup(db, zName);
    if( !zExternal ) return;
    db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
    sqlite3DbFree(db, zExternal);
  }
#ifndef SQLITE_OMIT_UTF16
  if( db->xCollNeeded16 ){
    char const *zExternal;
    sqlite3_value *pTmp = sqlite3ValueNew(db);
    sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);
    if( zExternal ){

References ENC, sqlite3::pCollNeededArg, sqlite3DbFree(), sqlite3DbStrDup(), sqlite3ValueFree(), sqlite3ValueNew(), sqlite3ValueSetStr(), sqlite3ValueText(), SQLITE_STATIC, SQLITE_UTF16NATIVE, SQLITE_UTF8, sqlite3::xCollNeeded, sqlite3::xCollNeeded16, and zName.

Referenced by sqlite3GetCollSeq().

◆ callFinaliser()

static void callFinaliser	(	sqlite3 *	db,
		int	offset )

static

Definition at line 140492 of file sqlite3.c.

                                                  {
  int i;
  if( db->aVTrans ){
    VTable **aVTrans = db->aVTrans;
    db->aVTrans = 0;
    for(i=0; i<db->nVTrans; i++){
      VTable *pVTab = aVTrans[i];
      sqlite3_vtab *p = pVTab->pVtab;
      if( p ){
        int (*x)(sqlite3_vtab *);
        x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
        if( x ) x(p);
      }
      pVTab->iSavepoint = 0;

References sqlite3::aVTrans, VTable::iSavepoint, sqlite3::nVTrans, sqlite3_vtab::pModule, VTable::pVtab, sqlite3DbFree(), and sqlite3VtabUnlock().

◆ callStatGet()

static void callStatGet	(	Parse *	pParse,
		int	regStat,
		int	iParam,
		int	regOut )

static

Definition at line 108484 of file sqlite3.c.

  {0}
};
 
static void callStatGet(Parse *pParse, int regStat, int iParam, int regOut){
#ifdef SQLITE_ENABLE_STAT4
  sqlite3VdbeAddOp2(pParse->pVdbe, OP_Integer, iParam, regStat+1);
#elif SQLITE_DEBUG
  assert( iParam==STAT_GET_STAT1 );
#else

Referenced by analyzeOneTable().

◆ cannotBeFunction()

static int cannotBeFunction	(	Parse *	pParse,
		struct SrcList_item *	pFrom )

static

Definition at line 133996 of file sqlite3.c.

134002 {

References sqlite3ErrorMsg().

Referenced by selectExpander(), and withExpand().

◆ cdateFunc()

static void cdateFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 22866 of file sqlite3.c.

References dateFunc(), and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterDateTimeFunctions().

◆ cellSizePtr()

static u16 cellSizePtr	(	MemPage *	pPage,
		u8 *	pCell )

static

Definition at line 65768 of file sqlite3.c.

                                                 {
  u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */
  u8 *pEnd;                                /* End mark for a varint */
  u32 nSize;                               /* Size value to return */
 
#ifdef SQLITE_DEBUG
  /* The value returned by this function should always be the same as
  ** the (CellInfo.nSize) value found by doing a full parse of the
  ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
  ** this function verifies that this invariant is not violated. */
  CellInfo debuginfo;
  pPage->xParseCell(pPage, pCell, &debuginfo);
#endif
 
  nSize = *pIter;
  if( nSize>=0x80 ){
    pEnd = &pIter[8];
    nSize &= 0x7f;
    do{
      nSize = (nSize<<7) | (*++pIter & 0x7f);
    }while( *(pIter)>=0x80 && pIter<pEnd );
  }
  pIter++;
  if( pPage->intKey ){
    /* pIter now points at the 64-bit integer key value, a variable length
    ** integer. The following block moves pIter to point at the first byte
    ** past the end of the key value. */
    pEnd = &pIter[9];
    while( (*pIter++)&0x80 && pIter<pEnd );
  }
  testcase( nSize==pPage->maxLocal );
  testcase( nSize==pPage->maxLocal+1 );
  if( nSize<=pPage->maxLocal ){
    nSize += (u32)(pIter - pCell);
    if( nSize<4 ) nSize = 4;
  }else{
    int minLocal = pPage->minLocal;
    nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
    testcase( nSize==pPage->maxLocal );
    testcase( nSize==pPage->maxLocal+1 );
    if( nSize>pPage->maxLocal ){
      nSize = minLocal;

References MemPage::childPtrSize, MemPage::intKey, MemPage::maxLocal, MemPage::minLocal, MemPage::pBt, testcase, BtShared::usableSize, and MemPage::xParseCell.

Referenced by decodeFlags(), and sqlite3BtreeDelete().

◆ cellSizePtrNoPayload()

static u16 cellSizePtrNoPayload	(	MemPage *	pPage,
		u8 *	pCell )

static

Definition at line 65816 of file sqlite3.c.

                                                          {
  u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
  u8 *pEnd;              /* End mark for a varint */
 
#ifdef SQLITE_DEBUG
  /* The value returned by this function should always be the same as
  ** the (CellInfo.nSize) value found by doing a full parse of the
  ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
  ** this function verifies that this invariant is not violated. */
  CellInfo debuginfo;
  pPage->xParseCell(pPage, pCell, &debuginfo);
#else
  UNUSED_PARAMETER(pPage);
#endif
 

Referenced by decodeFlags().

◆ changes()

static void changes	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117622 of file sqlite3.c.

      : R-62073-11209 The changes() SQL function is a wrapper
** around the sqlite3_changes() C/C++ function and hence follows the same
** rules for counting changes.
*/
static void changes(
  sqlite3_context *context,
  int NotUsed,

References sqlite3_changes(), sqlite3_context_db_handle(), sqlite3_result_int(), and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ changeTempStorage()

static int changeTempStorage	(	Parse *	pParse,
		const char *	zStorageType )

static

Definition at line 125892 of file sqlite3.c.

                                                                     {
  int ts = getTempStore(zStorageType);
  sqlite3 *db = pParse->db;
  if( db->temp_store==ts ) return SQLITE_OK;

References Parse::db, getTempStore(), invalidateTempStorage(), SQLITE_ERROR, SQLITE_OK, and sqlite3::temp_store.

Referenced by sqlite3Pragma().

◆ charFunc()

static void charFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118170 of file sqlite3.c.

 {
  unsigned char *z, *zOut;
  int i;
  zOut = z = sqlite3_malloc64( argc*4+1 );
  if( z==0 ){
    sqlite3_result_error_nomem(context);
    return;
  }
  for(i=0; i<argc; i++){
    sqlite3_int64 x;
    unsigned c;
    x = sqlite3_value_int64(argv[i]);
    if( x<0 || x>0x10ffff ) x = 0xfffd;
    c = (unsigned)(x & 0x1fffff);
    if( c<0x00080 ){
      *zOut++ = (u8)(c&0xFF);
    }else if( c<0x00800 ){
      *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
      *zOut++ = 0x80 + (u8)(c & 0x3F);
    }else if( c<0x10000 ){
      *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
      *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
      *zOut++ = 0x80 + (u8)(c & 0x3F);
    }else{
      *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
      *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);

References sqlite3_free(), sqlite3_malloc64(), sqlite3_result_error_nomem(), sqlite3_result_text64(), sqlite3_value_int64(), and SQLITE_UTF8.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ checkAppendMsg()

static void checkAppendMsg	(	IntegrityCk *	pCheck,
		const char *	zFormat,
			... )

static

Definition at line 74103 of file sqlite3.c.

 {
  va_list ap;
  if( !pCheck->mxErr ) return;
  pCheck->mxErr--;
  pCheck->nErr++;
  va_start(ap, zFormat);
  if( pCheck->errMsg.nChar ){
    sqlite3_str_append(&pCheck->errMsg, "\n", 1);
  }
  if( pCheck->zPfx ){
    sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2);
  }

Referenced by checkList(), checkPtrmap(), checkRef(), checkTreePage(), and sqlite3BtreeIntegrityCheck().

◆ checkColumnOverlap()

static int checkColumnOverlap	(	IdList *	pIdList,
		ExprList *	pEList )

static

Definition at line 137078 of file sqlite3.c.

137084 {

137085 int e;

References ExprList::a, NEVER, ExprList::nExpr, sqlite3IdListIndex(), and ExprList::ExprList_item::zEName.

Referenced by sqlite3CodeRowTrigger(), sqlite3TriggerColmask(), and sqlite3TriggersExist().

◆ checkConstraintExprNode()

static int checkConstraintExprNode	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 121897 of file sqlite3.c.

                                                                {
  if( pExpr->op==TK_COLUMN ){
    assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
    if( pExpr->iColumn>=0 ){
      if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
        pWalker->eCode |= CKCNSTRNT_COLUMN;
      }

References Walker::aiCol, CKCNSTRNT_COLUMN, CKCNSTRNT_ROWID, Walker::eCode, Expr::iColumn, Expr::op, TK_COLUMN, Walker::u, and WRC_Continue.

Referenced by sqlite3ExprReferencesUpdatedColumn().

◆ checkList()

static void checkList	(	IntegrityCk *	pCheck,
		int	isFreeList,
		Pgno	iPage,
		u32	N )

static

Definition at line 74204 of file sqlite3.c.

 {
  int i;
  u32 expected = N;
  int nErrAtStart = pCheck->nErr;
  while( iPage!=0 && pCheck->mxErr ){
    DbPage *pOvflPage;
    unsigned char *pOvflData;
    if( checkRef(pCheck, iPage) ) break;
    N--;
    if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
      checkAppendMsg(pCheck, "failed to get page %d", iPage);
      break;
    }
    pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
    if( isFreeList ){
      u32 n = (u32)get4byte(&pOvflData[4]);
#ifndef SQLITE_OMIT_AUTOVACUUM
      if( pCheck->pBt->autoVacuum ){
        checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0);
      }
#endif
      if( n>pCheck->pBt->usableSize/4-2 ){
        checkAppendMsg(pCheck,
           "freelist leaf count too big on page %d", iPage);
        N--;
      }else{
        for(i=0; i<(int)n; i++){
          Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
#ifndef SQLITE_OMIT_AUTOVACUUM
          if( pCheck->pBt->autoVacuum ){
            checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0);
          }
#endif
          checkRef(pCheck, iFreePage);
        }
        N -= n;
      }
    }
#ifndef SQLITE_OMIT_AUTOVACUUM
    else{
      /* If this database supports auto-vacuum and iPage is not the last
      ** page in this overflow list, check that the pointer-map entry for
      ** the following page matches iPage.
      */
      if( pCheck->pBt->autoVacuum && N>0 ){
        i = get4byte(pOvflData);
        checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage);
      }
    }
#endif
    iPage = get4byte(pOvflData);
    sqlite3PagerUnref(pOvflPage);
  }
  if( N && nErrAtStart==pCheck->nErr ){

References BtShared::autoVacuum, checkAppendMsg(), checkPtrmap(), checkRef(), get4byte, IntegrityCk::mxErr, IntegrityCk::nErr, IntegrityCk::pBt, IntegrityCk::pPager, PTRMAP_FREEPAGE, PTRMAP_OVERFLOW2, sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerUnref(), and BtShared::usableSize.

Referenced by checkTreePage(), and sqlite3BtreeIntegrityCheck().

◆ checkPtrmap()

static void checkPtrmap	(	IntegrityCk *	pCheck,
		Pgno	iChild,
		u8	eType,
		Pgno	iParent )

static

Definition at line 74175 of file sqlite3.c.

 {
  int rc;
  u8 ePtrmapType;
  Pgno iPtrmapParent;
 
  rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->bOomFault = 1;
    checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild);
    return;
  }
 

References IntegrityCk::bOomFault, checkAppendMsg(), eType, IntegrityCk::pBt, ptrmapGet(), SQLITE_IOERR_NOMEM, SQLITE_NOMEM, and SQLITE_OK.

Referenced by checkList(), checkTreePage(), and sqlite3BtreeIntegrityCheck().

◆ checkReadTransaction()

static int checkReadTransaction	(	sqlite3 *	db,
		Btree *	p )

static

Definition at line 75175 of file sqlite3.c.

75181 {

References sqlite3BtreeIsInReadTrans(), sqlite3ErrorWithMsg(), SQLITE_ERROR, and SQLITE_OK.

Referenced by sqlite3_backup_init().

◆ checkRef()

static int checkRef	(	IntegrityCk *	pCheck,
		Pgno	iPage )

static

Definition at line 74155 of file sqlite3.c.

                                                    {
  if( iPage>pCheck->nPage || iPage==0 ){
    checkAppendMsg(pCheck, "invalid page number %d", iPage);
    return 1;
  }
  if( getPageReferenced(pCheck, iPage) ){
    checkAppendMsg(pCheck, "2nd reference to page %d", iPage);

References AtomicLoad, checkAppendMsg(), IntegrityCk::db, getPageReferenced(), sqlite3::isInterrupted, IntegrityCk::nPage, setPageReferenced(), and sqlite3::u1.

Referenced by checkList(), and checkTreePage().

◆ checkTreePage()

static int checkTreePage	(	IntegrityCk *	pCheck,
		Pgno	iPage,
		i64 *	piMinKey,
		i64	maxKey )

static

Definition at line 74337 of file sqlite3.c.

 {
  MemPage *pPage = 0;      /* The page being analyzed */
  int i;                   /* Loop counter */
  int rc;                  /* Result code from subroutine call */
  int depth = -1, d2;      /* Depth of a subtree */
  int pgno;                /* Page number */
  int nFrag;               /* Number of fragmented bytes on the page */
  int hdr;                 /* Offset to the page header */
  int cellStart;           /* Offset to the start of the cell pointer array */
  int nCell;               /* Number of cells */
  int doCoverageCheck = 1; /* True if cell coverage checking should be done */
  int keyCanBeEqual = 1;   /* True if IPK can be equal to maxKey
                           ** False if IPK must be strictly less than maxKey */
  u8 *data;                /* Page content */
  u8 *pCell;               /* Cell content */
  u8 *pCellIdx;            /* Next element of the cell pointer array */
  BtShared *pBt;           /* The BtShared object that owns pPage */
  u32 pc;                  /* Address of a cell */
  u32 usableSize;          /* Usable size of the page */
  u32 contentOffset;       /* Offset to the start of the cell content area */
  u32 *heap = 0;           /* Min-heap used for checking cell coverage */
  u32 x, prev = 0;         /* Next and previous entry on the min-heap */
  const char *saved_zPfx = pCheck->zPfx;
  int saved_v1 = pCheck->v1;
  int saved_v2 = pCheck->v2;
  u8 savedIsInit = 0;
 
  /* Check that the page exists
  */
  pBt = pCheck->pBt;
  usableSize = pBt->usableSize;
  if( iPage==0 ) return 0;
  if( checkRef(pCheck, iPage) ) return 0;
  pCheck->zPfx = "Page %u: ";
  pCheck->v1 = iPage;
  if( (rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0 ){
    checkAppendMsg(pCheck,
       "unable to get the page. error code=%d", rc);
    goto end_of_check;
  }
 
  /* Clear MemPage.isInit to make sure the corruption detection code in
  ** btreeInitPage() is executed.  */
  savedIsInit = pPage->isInit;
  pPage->isInit = 0;
  if( (rc = btreeInitPage(pPage))!=0 ){
    assert( rc==SQLITE_CORRUPT );  /* The only possible error from InitPage */
    checkAppendMsg(pCheck,
                   "btreeInitPage() returns error code %d", rc);
    goto end_of_check;
  }
  if( (rc = btreeComputeFreeSpace(pPage))!=0 ){
    assert( rc==SQLITE_CORRUPT );
    checkAppendMsg(pCheck, "free space corruption", rc);
    goto end_of_check;
  }
  data = pPage->aData;
  hdr = pPage->hdrOffset;
 
  /* Set up for cell analysis */
  pCheck->zPfx = "On tree page %u cell %d: ";
  contentOffset = get2byteNotZero(&data[hdr+5]);
  assert( contentOffset<=usableSize );  /* Enforced by btreeInitPage() */
 
  /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
  ** number of cells on the page. */
  nCell = get2byte(&data[hdr+3]);
  assert( pPage->nCell==nCell );
 
  /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page
  ** immediately follows the b-tree page header. */
  cellStart = hdr + 12 - 4*pPage->leaf;
  assert( pPage->aCellIdx==&data[cellStart] );
  pCellIdx = &data[cellStart + 2*(nCell-1)];
 
  if( !pPage->leaf ){
    /* Analyze the right-child page of internal pages */
    pgno = get4byte(&data[hdr+8]);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum ){
      pCheck->zPfx = "On page %u at right child: ";
      checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
    }
#endif
    depth = checkTreePage(pCheck, pgno, &maxKey, maxKey);
    keyCanBeEqual = 0;
  }else{
    /* For leaf pages, the coverage check will occur in the same loop
    ** as the other cell checks, so initialize the heap.  */
    heap = pCheck->heap;
    heap[0] = 0;
  }
 
  /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte
  ** integer offsets to the cell contents. */
  for(i=nCell-1; i>=0 && pCheck->mxErr; i--){
    CellInfo info;
 
    /* Check cell size */
    pCheck->v2 = i;
    assert( pCellIdx==&data[cellStart + i*2] );
    pc = get2byteAligned(pCellIdx);
    pCellIdx -= 2;
    if( pc<contentOffset || pc>usableSize-4 ){
      checkAppendMsg(pCheck, "Offset %d out of range %d..%d",
                             pc, contentOffset, usableSize-4);
      doCoverageCheck = 0;
      continue;
    }
    pCell = &data[pc];
    pPage->xParseCell(pPage, pCell, &info);
    if( pc+info.nSize>usableSize ){
      checkAppendMsg(pCheck, "Extends off end of page");
      doCoverageCheck = 0;
      continue;
    }
 
    /* Check for integer primary key out of range */
    if( pPage->intKey ){
      if( keyCanBeEqual ? (info.nKey > maxKey) : (info.nKey >= maxKey) ){
        checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey);
      }
      maxKey = info.nKey;
      keyCanBeEqual = 0;     /* Only the first key on the page may ==maxKey */
    }
 
    /* Check the content overflow list */
    if( info.nPayload>info.nLocal ){
      u32 nPage;       /* Number of pages on the overflow chain */
      Pgno pgnoOvfl;   /* First page of the overflow chain */
      assert( pc + info.nSize - 4 <= usableSize );
      nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4);
      pgnoOvfl = get4byte(&pCell[info.nSize - 4]);
#ifndef SQLITE_OMIT_AUTOVACUUM
      if( pBt->autoVacuum ){
        checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage);
      }
#endif
      checkList(pCheck, 0, pgnoOvfl, nPage);
    }
 
    if( !pPage->leaf ){
      /* Check sanity of left child page for internal pages */
      pgno = get4byte(pCell);
#ifndef SQLITE_OMIT_AUTOVACUUM
      if( pBt->autoVacuum ){
        checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
      }
#endif
      d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey);
      keyCanBeEqual = 0;
      if( d2!=depth ){
        checkAppendMsg(pCheck, "Child page depth differs");
        depth = d2;
      }
    }else{
      /* Populate the coverage-checking heap for leaf pages */
      btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1));
    }
  }
  *piMinKey = maxKey;
 
  /* Check for complete coverage of the page
  */
  pCheck->zPfx = 0;
  if( doCoverageCheck && pCheck->mxErr>0 ){
    /* For leaf pages, the min-heap has already been initialized and the
    ** cells have already been inserted.  But for internal pages, that has
    ** not yet been done, so do it now */
    if( !pPage->leaf ){
      heap = pCheck->heap;
      heap[0] = 0;
      for(i=nCell-1; i>=0; i--){
        u32 size;
        pc = get2byteAligned(&data[cellStart+i*2]);
        size = pPage->xCellSize(pPage, &data[pc]);
        btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
      }
    }
    /* Add the freeblocks to the min-heap
    **
    ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header
    ** is the offset of the first freeblock, or zero if there are no
    ** freeblocks on the page.
    */
    i = get2byte(&data[hdr+1]);
    while( i>0 ){
      int size, j;
      assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
      size = get2byte(&data[i+2]);
      assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */
      btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1));
      /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
      ** big-endian integer which is the offset in the b-tree page of the next
      ** freeblock in the chain, or zero if the freeblock is the last on the
      ** chain. */
      j = get2byte(&data[i]);
      /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
      ** increasing offset. */
      assert( j==0 || j>i+size );     /* Enforced by btreeComputeFreeSpace() */
      assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
      i = j;
    }
    /* Analyze the min-heap looking for overlap between cells and/or
    ** freeblocks, and counting the number of untracked bytes in nFrag.
    **
    ** Each min-heap entry is of the form:    (start_address<<16)|end_address.
    ** There is an implied first entry the covers the page header, the cell
    ** pointer index, and the gap between the cell pointer index and the start
    ** of cell content.
    **
    ** The loop below pulls entries from the min-heap in order and compares
    ** the start_address against the previous end_address.  If there is an
    ** overlap, that means bytes are used multiple times.  If there is a gap,
    ** that gap is added to the fragmentation count.
    */
    nFrag = 0;
    prev = contentOffset - 1;   /* Implied first min-heap entry */
    while( btreeHeapPull(heap,&x) ){
      if( (prev&0xffff)>=(x>>16) ){
        checkAppendMsg(pCheck,
          "Multiple uses for byte %u of page %u", x>>16, iPage);
        break;
      }else{
        nFrag += (x>>16) - (prev&0xffff) - 1;
        prev = x;
      }
    }
    nFrag += usableSize - (prev&0xffff) - 1;
    /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
    ** is stored in the fifth field of the b-tree page header.
    ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the
    ** number of fragmented free bytes within the cell content area.
    */
    if( heap[0]==0 && nFrag!=data[hdr+7] ){
      checkAppendMsg(pCheck,
          "Fragmentation of %d bytes reported as %d on page %u",
          nFrag, data[hdr+7], iPage);
    }
  }
 
end_of_check:
  if( !doCoverageCheck ) pPage->isInit = savedIsInit;

References MemPage::aCellIdx, MemPage::aData, BtShared::autoVacuum, btreeComputeFreeSpace(), btreeGetPage(), btreeHeapInsert(), btreeHeapPull(), btreeInitPage(), checkAppendMsg(), checkList(), checkPtrmap(), checkRef(), checkTreePage(), depth, get2byte, get2byteAligned, get2byteNotZero, get4byte, MemPage::hdrOffset, IntegrityCk::heap, MemPage::intKey, MemPage::isInit, MemPage::leaf, IntegrityCk::mxErr, MemPage::nCell, CellInfo::nKey, CellInfo::nLocal, CellInfo::nPayload, CellInfo::nSize, IntegrityCk::pBt, PTRMAP_BTREE, PTRMAP_OVERFLOW1, releasePage(), SQLITE_CORRUPT, BtShared::usableSize, IntegrityCk::v1, IntegrityCk::v2, MemPage::xCellSize, MemPage::xParseCell, and IntegrityCk::zPfx.

Referenced by checkTreePage(), and sqlite3BtreeIntegrityCheck().

◆ clearAllSharedCacheTableLocks()

static void clearAllSharedCacheTableLocks ( Btree * p )

static

Definition at line 64890 of file sqlite3.c.

                                                   {
  BtShared *pBt = p->pBt;
  BtLock **ppIter = &pBt->pLock;
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( p->sharable || 0==*ppIter );
  assert( p->inTrans>0 );
 
  while( *ppIter ){
    BtLock *pLock = *ppIter;
    assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
    assert( pLock->pBtree->inTrans>=pLock->eLock );
    if( pLock->pBtree==p ){
      *ppIter = pLock->pNext;
      assert( pLock->iTable!=1 || pLock==&p->lock );
      if( pLock->iTable!=1 ){
        sqlite3_free(pLock);
      }
    }else{
      ppIter = &pLock->pNext;
    }
  }
 
  assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
  if( pBt->pWriter==p ){
    pBt->pWriter = 0;
    pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
  }else if( pBt->nTransaction==2 ){
    /* This function is called when Btree p is concluding its
    ** transaction. If there currently exists a writer, and p is not
    ** that writer, then the number of locks held by connections other
    ** than the writer must be about to drop to zero. In this case
    ** set the BTS_PENDING flag to 0.
    **

References BTS_EXCLUSIVE, BTS_PENDING, BtShared::btsFlags, BtLock::eLock, Btree::inTrans, BtLock::iTable, Btree::lock, BtShared::nTransaction, Btree::pBt, BtLock::pBtree, BtShared::pLock, BtLock::pNext, BtShared::pWriter, Btree::sharable, and sqlite3_free().

◆ clearCell()

static int clearCell	(	MemPage *	pPage,
		unsigned char *	pCell,
		CellInfo *	pInfo )

static

Definition at line 70855 of file sqlite3.c.

 {
  BtShared *pBt;
  Pgno ovflPgno;
  int rc;
  int nOvfl;
  u32 ovflPageSize;
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  pPage->xParseCell(pPage, pCell, pInfo);
  if( pInfo->nLocal==pInfo->nPayload ){
    return SQLITE_OK;  /* No overflow pages. Return without doing anything */
  }
  testcase( pCell + pInfo->nSize == pPage->aDataEnd );
  testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
  if( pCell + pInfo->nSize > pPage->aDataEnd ){
    /* Cell extends past end of page */
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  ovflPgno = get4byte(pCell + pInfo->nSize - 4);
  pBt = pPage->pBt;
  assert( pBt->usableSize > 4 );
  ovflPageSize = pBt->usableSize - 4;
  nOvfl = (pInfo->nPayload - pInfo->nLocal + ovflPageSize - 1)/ovflPageSize;
  assert( nOvfl>0 ||
    (CORRUPT_DB && (pInfo->nPayload + ovflPageSize)<ovflPageSize)
  );
  while( nOvfl-- ){
    Pgno iNext = 0;
    MemPage *pOvfl = 0;
    if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
      /* 0 is not a legal page number and page 1 cannot be an
      ** overflow page. Therefore if ovflPgno<2 or past the end of the
      ** file the database must be corrupt. */
      return SQLITE_CORRUPT_BKPT;
    }
    if( nOvfl ){
      rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
      if( rc ) return rc;
    }
 
    if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
     && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1
    ){
      /* There is no reason any cursor should have an outstanding reference
      ** to an overflow page belonging to a cell that is being deleted/updated.
      ** So if there exists more than one reference to this page, then it
      ** must not really be an overflow page and the database must be corrupt.
      ** It is helpful to detect this before calling freePage2(), as
      ** freePage2() may zero the page contents if secure-delete mode is
      ** enabled. If this 'overflow' page happens to be a page that the
      ** caller is iterating through or using in some other way, this
      ** can be problematic.
      */
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      rc = freePage2(pBt, pOvfl, ovflPgno);
    }
 
    if( pOvfl ){
      sqlite3PagerUnref(pOvfl->pDbPage);

Referenced by sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ clearDatabasePage()

static int clearDatabasePage	(	BtShared *	pBt,
		Pgno	pgno,
		int	freePageFlag,
		int *	pnChange )

static

Definition at line 73735 of file sqlite3.c.

 {
  MemPage *pPage;
  int rc;
  unsigned char *pCell;
  int i;
  int hdr;
  CellInfo info;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  if( pgno>btreePagecount(pBt) ){
    return SQLITE_CORRUPT_BKPT;
  }
  rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
  if( rc ) return rc;
  if( pPage->bBusy ){
    rc = SQLITE_CORRUPT_BKPT;
    goto cleardatabasepage_out;
  }
  pPage->bBusy = 1;
  hdr = pPage->hdrOffset;
  for(i=0; i<pPage->nCell; i++){
    pCell = findCell(pPage, i);
    if( !pPage->leaf ){
      rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
      if( rc ) goto cleardatabasepage_out;
    }
    rc = clearCell(pPage, pCell, &info);
    if( rc ) goto cleardatabasepage_out;
  }
  if( !pPage->leaf ){
    rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
    if( rc ) goto cleardatabasepage_out;
  }else if( pnChange ){
    assert( pPage->intKey || CORRUPT_DB );
    testcase( !pPage->intKey );
    *pnChange += pPage->nCell;
  }
  if( freePageFlag ){
    freePage(pPage, &rc);
  }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
    zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
  }

Referenced by sqlite3BtreeClearTable().

◆ clearSelect()

static void clearSelect	(	sqlite3 *	db,
		Select *	p,
		int	bFree )

static

Definition at line 129371 of file sqlite3.c.

                                                          {
  while( p ){
    Select *pPrior = p->pPrior;
    sqlite3ExprListDelete(db, p->pEList);
    sqlite3SrcListDelete(db, p->pSrc);
    sqlite3ExprDelete(db, p->pWhere);
    sqlite3ExprListDelete(db, p->pGroupBy);
    sqlite3ExprDelete(db, p->pHaving);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pLimit);
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
      sqlite3WindowListDelete(db, p->pWinDefn);
    }
#endif

References OK_IF_ALWAYS_TRUE, Select::pEList, Select::pGroupBy, Select::pHaving, Select::pLimit, Select::pOrderBy, Select::pPrior, Select::pSrc, Select::pWhere, Select::pWinDefn, Select::pWith, sqlite3DbFreeNN(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3SrcListDelete(), sqlite3WindowListDelete(), and sqlite3WithDelete().

Referenced by sqlite3SelectNew().

◆ clearYMD_HMS_TZ()

static void clearYMD_HMS_TZ ( DateTime * p )

static

Definition at line 22184 of file sqlite3.c.

Referenced by parseModifier().

◆ closeAllCursors()

static void closeAllCursors ( Vdbe * p )

static

Definition at line 80284 of file sqlite3.c.

                                    {
  if( p->pFrame ){
    VdbeFrame *pFrame;
    for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
    sqlite3VdbeFrameRestore(pFrame);
    p->pFrame = 0;
    p->nFrame = 0;
  }
  assert( p->nFrame==0 );
  closeCursorsInFrame(p);
  if( p->aMem ){
    releaseMemArray(p->aMem, p->nMem);
  }
  while( p->pDelFrame ){
    VdbeFrame *pDel = p->pDelFrame;
    p->pDelFrame = pDel->pParent;
    sqlite3VdbeFrameDelete(pDel);

References Vdbe::aMem, closeCursorsInFrame(), Vdbe::db, Vdbe::nFrame, Vdbe::nMem, Vdbe::pAuxData, Vdbe::pDelFrame, Vdbe::pFrame, VdbeFrame::pParent, releaseMemArray(), sqlite3VdbeDeleteAuxData(), sqlite3VdbeFrameDelete(), and sqlite3VdbeFrameRestore().

Referenced by sqlite3VdbeHalt().

◆ closeCursorsInFrame()

static void closeCursorsInFrame ( Vdbe * p )

static

Definition at line 80237 of file sqlite3.c.

                                        {
  if( p->apCsr ){
    int i;
    for(i=0; i<p->nCursor; i++){
      VdbeCursor *pC = p->apCsr[i];
      if( pC ){

Referenced by closeAllCursors(), and sqlite3VdbeFrameRestore().

◆ closePendingFds()

static void closePendingFds ( unixFile * pFile )

static

Definition at line 34846 of file sqlite3.c.

                                            {
  unixInodeInfo *pInode = pFile->pInode;
  UnixUnusedFd *p;
  UnixUnusedFd *pNext;
  assert( unixFileMutexHeld(pFile) );
  for(p=pInode->pUnused; p; p=pNext){

Referenced by posixUnlock(), and releaseInodeInfo().

◆ closeUnixFile()

static int closeUnixFile ( sqlite3_file * id )

static

Definition at line 35628 of file sqlite3.c.

                                          {
  unixFile *pFile = (unixFile*)id;
#if SQLITE_MAX_MMAP_SIZE>0
  unixUnmapfile(pFile);
#endif
  if( pFile->h>=0 ){
    robust_close(pFile, pFile->h, __LINE__);
    pFile->h = -1;
  }
#if OS_VXWORKS
  if( pFile->pId ){
    if( pFile->ctrlFlags & UNIXFILE_DELETE ){
      osUnlink(pFile->pId->zCanonicalName);
    }
    vxworksReleaseFileId(pFile->pId);
    pFile->pId = 0;
  }
#endif
#ifdef SQLITE_UNLINK_AFTER_CLOSE
  if( pFile->ctrlFlags & UNIXFILE_DELETE ){
    osUnlink(pFile->zPath);
    sqlite3_free(*(char**)&pFile->zPath);
    pFile->zPath = 0;
  }
#endif

References unixFile::ctrlFlags, unixFile::h, OpenCounter, OSTRACE, osUnlink, unixFile::pPreallocatedUnused, robust_close(), sqlite3_free(), UNIXFILE_DELETE, and unixFile::zPath.

◆ codeAllEqualityTerms()

static int codeAllEqualityTerms	(	Parse *	pParse,
		WhereLevel *	pLevel,
		int	bRev,
		int	nExtraReg,
		char **	pzAff )

static

Definition at line 142180 of file sqlite3.c.

 {
  u16 nEq;                      /* The number of == or IN constraints to code */
  u16 nSkip;                    /* Number of left-most columns to skip */
  Vdbe *v = pParse->pVdbe;      /* The vm under construction */
  Index *pIdx;                  /* The index being used for this loop */
  WhereTerm *pTerm;             /* A single constraint term */
  WhereLoop *pLoop;             /* The WhereLoop object */
  int j;                        /* Loop counter */
  int regBase;                  /* Base register */
  int nReg;                     /* Number of registers to allocate */
  char *zAff;                   /* Affinity string to return */
 
  /* This module is only called on query plans that use an index. */
  pLoop = pLevel->pWLoop;
  assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 );
  nEq = pLoop->u.btree.nEq;
  nSkip = pLoop->nSkip;
  pIdx = pLoop->u.btree.pIndex;
  assert( pIdx!=0 );
 
  /* Figure out how many memory cells we will need then allocate them.
  */
  regBase = pParse->nMem + 1;
  nReg = pLoop->u.btree.nEq + nExtraReg;
  pParse->nMem += nReg;
 
  zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
  assert( zAff!=0 || pParse->db->mallocFailed );
 
  if( nSkip ){
    int iIdxCur = pLevel->iIdxCur;
    sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur);
    VdbeCoverageIf(v, bRev==0);
    VdbeCoverageIf(v, bRev!=0);
    VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
    j = sqlite3VdbeAddOp0(v, OP_Goto);
    pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT),
                            iIdxCur, 0, regBase, nSkip);
    VdbeCoverageIf(v, bRev==0);
    VdbeCoverageIf(v, bRev!=0);
    sqlite3VdbeJumpHere(v, j);
    for(j=0; j<nSkip; j++){
      sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j);
      testcase( pIdx->aiColumn[j]==XN_EXPR );
      VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
    }
  }
 
  /* Evaluate the equality constraints
  */
  assert( zAff==0 || (int)strlen(zAff)>=nEq );
  for(j=nSkip; j<nEq; j++){
    int r1;
    pTerm = pLoop->aLTerm[j];
    assert( pTerm!=0 );
    /* The following testcase is true for indices with redundant columns.
    ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */
    testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
    testcase( pTerm->wtFlags & TERM_VIRTUAL );
    r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j);
    if( r1!=regBase+j ){
      if( nReg==1 ){
        sqlite3ReleaseTempReg(pParse, regBase);
        regBase = r1;
      }else{
        sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
      }
    }
    if( pTerm->eOperator & WO_IN ){
      if( pTerm->pExpr->flags & EP_xIsSelect ){
        /* No affinity ever needs to be (or should be) applied to a value
        ** from the RHS of an "? IN (SELECT ...)" expression. The
        ** sqlite3FindInIndex() routine has already ensured that the
        ** affinity of the comparison has been applied to the value.  */
        if( zAff ) zAff[j] = SQLITE_AFF_BLOB;
      }
    }else if( (pTerm->eOperator & WO_ISNULL)==0 ){
      Expr *pRight = pTerm->pExpr->pRight;
      if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
        VdbeCoverage(v);
      }
      if( zAff ){
        if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
          zAff[j] = SQLITE_AFF_BLOB;
        }
        if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
          zAff[j] = SQLITE_AFF_BLOB;
        }

References WhereLevel::addrBrk, WhereLevel::addrSkip, Index::aiColumn, WhereLoop::aLTerm, WhereLoop::btree, codeEqualityTerm(), Parse::db, WhereTerm::eOperator, EP_xIsSelect, explainIndexColumnName(), Expr::flags, WhereLevel::iIdxCur, sqlite3::mallocFailed, WhereLoop::nEq, Parse::nMem, WhereLoop::nSkip, OP_Column, OP_Goto, OP_IsNull, OP_Last, OP_Rewind, OP_SCopy, OP_SeekGT, OP_SeekLT, WhereTerm::pExpr, WhereLoop::pIndex, Expr::pRight, Parse::pVdbe, WhereLevel::pWLoop, sqlite3CompareAffinity(), sqlite3DbStrDup(), sqlite3ExprCanBeNull(), sqlite3ExprNeedsNoAffinityChange(), sqlite3IndexAffinityStr(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Int(), sqlite3VdbeJumpHere(), SQLITE_AFF_BLOB, TERM_CODED, TERM_IS, TERM_VIRTUAL, testcase, WhereLoop::u, VdbeComment, VdbeCoverage, VdbeCoverageIf, WHERE_VIRTUALTABLE, WO_IN, WO_ISNULL, WhereLoop::wsFlags, WhereTerm::wtFlags, XN_EXPR, and Index::zName.

◆ codeApplyAffinity()

static void codeApplyAffinity	(	Parse *	pParse,
		int	base,
		int	n,
		char *	zAff )

static

Definition at line 141844 of file sqlite3.c.

                                                                         {
  Vdbe *v = pParse->pVdbe;
  if( zAff==0 ){
    assert( pParse->db->mallocFailed );
    return;
  }
  assert( v!=0 );
 
  /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE
  ** entries at the beginning and end of the affinity string.
  */
  assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
  while( n>0 && zAff[0]<=SQLITE_AFF_BLOB ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){
    n--;
  }

References Parse::db, sqlite3::mallocFailed, OP_Affinity, Parse::pVdbe, sqlite3VdbeAddOp4(), SQLITE_AFF_BLOB, and SQLITE_AFF_NONE.

◆ codeAttach()

static void codeAttach	(	Parse *	pParse,
		int	type,
		FuncDef const *	pFunc,
		Expr *	pAuthArg,
		Expr *	pFilename,
		Expr *	pDbname,
		Expr *	pKey )

static

Definition at line 109815 of file sqlite3.c.

 {
  int rc;
  NameContext sName;
  Vdbe *v;
  sqlite3* db = pParse->db;
  int regArgs;
 
  if( pParse->nErr ) goto attach_end;
  memset(&sName, 0, sizeof(NameContext));
  sName.pParse = pParse;
 
  if(
      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
  ){
    goto attach_end;
  }
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( pAuthArg ){
    char *zAuthArg;
    if( pAuthArg->op==TK_STRING ){
      zAuthArg = pAuthArg->u.zToken;
    }else{
      zAuthArg = 0;
    }
    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
    if(rc!=SQLITE_OK ){
      goto attach_end;
    }
  }
#endif /* SQLITE_OMIT_AUTHORIZATION */
 
 
  v = sqlite3GetVdbe(pParse);
  regArgs = sqlite3GetTempRange(pParse, 4);
  sqlite3ExprCode(pParse, pFilename, regArgs);
  sqlite3ExprCode(pParse, pDbname, regArgs+1);
  sqlite3ExprCode(pParse, pKey, regArgs+2);
 
  assert( v || db->mallocFailed );
  if( v ){
    sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
                               pFunc->nArg, pFunc, 0);
    /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
    ** statement only). For DETACH, set it to false (expire all existing
    ** statements).
    */
    sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
  }

Referenced by sqlite3Attach(), and sqlite3Detach().

◆ codeCompare()

static int codeCompare	(	Parse *	pParse,
		Expr *	pLeft,
		Expr *	pRight,
		int	opcode,
		int	in1,
		int	in2,
		int	dest,
		int	jumpIfNull,
		int	isCommuted )

static

Definition at line 100080 of file sqlite3.c.

 {
  int p5;
  int addr;
  CollSeq *p4;
 
  if( pParse->nErr ) return 0;
  if( isCommuted ){
    p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft);
  }else{
    p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
  }

Referenced by codeVectorCompare(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ codeDeferredSeek()

static void codeDeferredSeek	(	WhereInfo *	pWInfo,
		Index *	pIdx,
		int	iCur,
		int	iIdxCur )

static

Definition at line 142552 of file sqlite3.c.

 {
  Parse *pParse = pWInfo->pParse; /* Parse context */
  Vdbe *v = pParse->pVdbe;        /* Vdbe to generate code within */
 
  assert( iIdxCur>0 );
  assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
 
  pWInfo->bDeferredSeek = 1;
  sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
  if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
   && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
  ){
    int i;
    Table *pTab = pIdx->pTable;
    u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
    if( ai ){
      ai[0] = pTab->nCol;
      for(i=0; i<pIdx->nColumn-1; i++){
        int x1, x2;
        assert( pIdx->aiColumn[i]<pTab->nCol );
        x1 = pIdx->aiColumn[i];
        x2 = sqlite3TableColumnToStorage(pTab, x1);
        testcase( x1!=x2 );

References Index::aiColumn, WhereInfo::bDeferredSeek, Parse::db, DbMaskAllZero, Table::nCol, Index::nColumn, OP_DeferredSeek, P4_INTARRAY, WhereInfo::pParse, Index::pTable, Parse::pVdbe, sqlite3DbMallocZero(), sqlite3ParseToplevel, sqlite3TableColumnToStorage(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP4(), testcase, WhereInfo::wctrlFlags, and WHERE_OR_SUBCLAUSE.

◆ codeDistinct()

static void codeDistinct	(	Parse *	pParse,
		int	iTab,
		int	addrRepeat,
		int	N,
		int	iMem )

static

Definition at line 130038 of file sqlite3.c.

 {
  Vdbe *v;
  int r1;
 
  v = pParse->pVdbe;
  r1 = sqlite3GetTempReg(pParse);

References OP_Found, OP_IdxInsert, OP_MakeRecord, OPFLAG_USESEEKRESULT, Parse::pVdbe, sqlite3GetTempReg(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), and VdbeCoverage.

Referenced by selectInnerLoop(), and updateAccumulator().

◆ codeEqualityTerm()

static int codeEqualityTerm	(	Parse *	pParse,
		WhereTerm *	pTerm,
		WhereLevel *	pLevel,
		int	iEq,
		int	bRev,
		int	iTarget )

static

Definition at line 142009 of file sqlite3.c.

 {
  Expr *pX = pTerm->pExpr;
  Vdbe *v = pParse->pVdbe;
  int iReg;                  /* Register holding results */
 
  assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
  assert( iTarget>0 );
  if( pX->op==TK_EQ || pX->op==TK_IS ){
    iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
  }else if( pX->op==TK_ISNULL ){
    iReg = iTarget;
    sqlite3VdbeAddOp2(v, OP_Null, 0, iReg);
#ifndef SQLITE_OMIT_SUBQUERY
  }else{
    int eType = IN_INDEX_NOOP;
    int iTab;
    struct InLoop *pIn;
    WhereLoop *pLoop = pLevel->pWLoop;
    int i;
    int nEq = 0;
    int *aiMap = 0;
 
    if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
      && pLoop->u.btree.pIndex!=0
      && pLoop->u.btree.pIndex->aSortOrder[iEq]
    ){
      testcase( iEq==0 );
      testcase( bRev );
      bRev = !bRev;
    }
    assert( pX->op==TK_IN );
    iReg = iTarget;
 
    for(i=0; i<iEq; i++){
      if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
        disableTerm(pLevel, pTerm);
        return iTarget;
      }
    }
    for(i=iEq;i<pLoop->nLTerm; i++){
      assert( pLoop->aLTerm[i]!=0 );
      if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
    }
 
    iTab = 0;
    if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){
      eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
    }else{
      sqlite3 *db = pParse->db;
      pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
 
      if( !db->mallocFailed ){
        aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
        eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
        pTerm->pExpr->iTable = iTab;
      }
      sqlite3ExprDelete(db, pX);
      pX = pTerm->pExpr;
    }
 
    if( eType==IN_INDEX_INDEX_DESC ){
      testcase( bRev );
      bRev = !bRev;
    }
    sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
    VdbeCoverageIf(v, bRev);
    VdbeCoverageIf(v, !bRev);
    assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
 
    pLoop->wsFlags |= WHERE_IN_ABLE;
    if( pLevel->u.in.nIn==0 ){
      pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
    }
 
    i = pLevel->u.in.nIn;
    pLevel->u.in.nIn += nEq;
    pLevel->u.in.aInLoop =
       sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
                              sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
    pIn = pLevel->u.in.aInLoop;
    if( pIn ){
      int iMap = 0;               /* Index in aiMap[] */
      pIn += i;
      for(i=iEq;i<pLoop->nLTerm; i++){
        if( pLoop->aLTerm[i]->pExpr==pX ){
          int iOut = iReg + i - iEq;
          if( eType==IN_INDEX_ROWID ){
            pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
          }else{
            int iCol = aiMap ? aiMap[iMap++] : 0;
            pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
          }
          sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
          if( i==iEq ){
            pIn->iCur = iTab;
            pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
            if( iEq>0 ){
              pIn->iBase = iReg - i;
              pIn->nPrefix = i;
              pLoop->wsFlags |= WHERE_IN_EARLYOUT;
            }else{
              pIn->nPrefix = 0;
            }
          }else{
            pIn->eEndLoopOp = OP_Noop;
          }
          pIn++;
        }
      }
    }else{
      pLevel->u.in.nIn = 0;
    }

References WhereLevel::addrNxt, WhereLevel::aInLoop, WhereLoop::aLTerm, Index::aSortOrder, WhereLoop::btree, Parse::db, disableTerm(), EP_xIsSelect, eType, Expr::flags, WhereLevel::in, IN_INDEX_INDEX_DESC, IN_INDEX_LOOP, IN_INDEX_NOOP, IN_INDEX_ROWID, Expr::iTable, sqlite3::mallocFailed, ExprList::nExpr, WhereLevel::nIn, WhereLoop::nLTerm, Expr::op, OP_Column, OP_IsNull, OP_Last, OP_Next, OP_Noop, OP_Null, OP_Prev, OP_Rewind, OP_Rowid, Select::pEList, WhereTerm::pExpr, WhereLoop::pIndex, Expr::pRight, Expr::pSelect, Parse::pVdbe, WhereLevel::pWLoop, removeUnindexableInClauseTerms(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbReallocOrFree(), sqlite3ExprCodeTarget(), sqlite3ExprDelete(), sqlite3FindInIndex(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeMakeLabel(), testcase, TK_EQ, TK_IN, TK_IS, TK_ISNULL, WhereLevel::u, WhereLoop::u, VdbeCoverage, VdbeCoverageIf, WHERE_IN_ABLE, WHERE_IN_EARLYOUT, WHERE_MULTI_OR, WHERE_VIRTUALTABLE, WhereLoop::wsFlags, and Expr::x.

Referenced by codeAllEqualityTerms().

◆ codeExprOrVector()

static void codeExprOrVector	(	Parse *	pParse,
		Expr *	p,
		int	iReg,
		int	nReg )

static

Definition at line 142596 of file sqlite3.c.

                                                                        {
  assert( nReg>0 );
  if( p && sqlite3ExprIsVector(p) ){
#ifndef SQLITE_OMIT_SUBQUERY
    if( (p->flags & EP_xIsSelect) ){
      Vdbe *v = pParse->pVdbe;
      int iSelect;
      assert( p->op==TK_SELECT );
      iSelect = sqlite3CodeSubselect(pParse, p);
      sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
    }else
#endif
    {
      int i;
      ExprList *pList = p->x.pList;
      assert( nReg<=pList->nExpr );
      for(i=0; i<nReg; i++){
        sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
      }

References ExprList::a, EP_xIsSelect, Expr::flags, Expr::op, OP_Copy, ExprList::ExprList_item::pExpr, Expr::pList, Parse::pVdbe, sqlite3CodeSubselect(), sqlite3ExprCode(), sqlite3ExprIsVector(), sqlite3VdbeAddOp3(), TK_SELECT, and Expr::x.

◆ codeInteger()

static void codeInteger	(	Parse *	pParse,
		Expr *	pExpr,
		int	negFlag,
		int	iMem )

static

Definition at line 103155 of file sqlite3.c.

                                                                          {
  Vdbe *v = pParse->pVdbe;
  if( pExpr->flags & EP_IntValue ){
    int i = pExpr->u.iValue;
    assert( i>=0 );
    if( negFlag ) i = -i;
    sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  }else{
    int c;
    i64 value;
    const char *z = pExpr->u.zToken;
    assert( z!=0 );
    c = sqlite3DecOrHexToI64(z, &value);
    if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){
#ifdef SQLITE_OMIT_FLOATING_POINT
      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
#else
#ifndef SQLITE_OMIT_HEX_INTEGER
      if( sqlite3_strnicmp(z,"0x",2)==0 ){
        sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z);
      }else
#endif
      {
        codeReal(v, z, negFlag, iMem);
      }
#endif

References codeReal(), EP_IntValue, Expr::flags, Expr::iValue, OP_Int64, OP_Integer, P4_INT64, Parse::pVdbe, SMALLEST_INT64, sqlite3_strnicmp(), sqlite3DecOrHexToI64(), sqlite3ErrorMsg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp4Dup8(), Expr::u, value, and Expr::zToken.

Referenced by sqlite3ExprCodeTarget().

◆ codeOffset()

static void codeOffset	(	Vdbe *	v,
		int	iOffset,
		int	iContinue )

static

Definition at line 130018 of file sqlite3.c.

Referenced by generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), and selectInnerLoop().

◆ codeReal()

static void codeReal	(	Vdbe *	v,
		const char *	z,
		int	negateFlag,
		int	iMem )

static

Definition at line 103137 of file sqlite3.c.

                                                                      {
  if( ALWAYS(z!=0) ){
    double value;

References ALWAYS, OP_Real, P4_REAL, sqlite3AtoF(), sqlite3IsNaN(), sqlite3Strlen30(), sqlite3VdbeAddOp4Dup8(), SQLITE_UTF8, and value.

Referenced by codeInteger(), and sqlite3ExprCodeTarget().

◆ codeRowTrigger()

static TriggerPrg * codeRowTrigger	(	Parse *	pParse,
		Trigger *	pTrigger,
		Table *	pTab,
		int	orconf )

static

Definition at line 137279 of file sqlite3.c.

 {
  Parse *pTop = sqlite3ParseToplevel(pParse);
  sqlite3 *db = pParse->db;   /* Database handle */
  TriggerPrg *pPrg;           /* Value to return */
  Expr *pWhen = 0;            /* Duplicate of trigger WHEN expression */
  Vdbe *v;                    /* Temporary VM */
  NameContext sNC;            /* Name context for sub-vdbe */
  SubProgram *pProgram = 0;   /* Sub-vdbe for trigger program */
  Parse *pSubParse;           /* Parse context for sub-vdbe */
  int iEndTrigger = 0;        /* Label to jump to if WHEN is false */
 
  assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
  assert( pTop->pVdbe );
 
  /* Allocate the TriggerPrg and SubProgram objects. To ensure that they
  ** are freed if an error occurs, link them into the Parse.pTriggerPrg
  ** list of the top-level Parse object sooner rather than later.  */
  pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));
  if( !pPrg ) return 0;
  pPrg->pNext = pTop->pTriggerPrg;
  pTop->pTriggerPrg = pPrg;
  pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
  if( !pProgram ) return 0;
  sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
  pPrg->pTrigger = pTrigger;
  pPrg->orconf = orconf;
  pPrg->aColmask[0] = 0xffffffff;
  pPrg->aColmask[1] = 0xffffffff;
 
  /* Allocate and populate a new Parse context to use for coding the
  ** trigger sub-program.  */
  pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
  if( !pSubParse ) return 0;
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pSubParse;
  pSubParse->db = db;
  pSubParse->pTriggerTab = pTab;
  pSubParse->pToplevel = pTop;
  pSubParse->zAuthContext = pTrigger->zName;
  pSubParse->eTriggerOp = pTrigger->op;
  pSubParse->nQueryLoop = pParse->nQueryLoop;
  pSubParse->disableVtab = pParse->disableVtab;
 
  v = sqlite3GetVdbe(pSubParse);
  if( v ){
    VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
      pTrigger->zName, onErrorText(orconf),
      (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
        (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
        (pTrigger->op==TK_INSERT ? "INSERT" : ""),
        (pTrigger->op==TK_DELETE ? "DELETE" : ""),
      pTab->zName
    ));
#ifndef SQLITE_OMIT_TRACE
    if( pTrigger->zName ){
      sqlite3VdbeChangeP4(v, -1,
        sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
      );
    }
#endif
 
    /* If one was specified, code the WHEN clause. If it evaluates to false
    ** (or NULL) the sub-vdbe is immediately halted by jumping to the
    ** OP_Halt inserted at the end of the program.  */
    if( pTrigger->pWhen ){
      pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
      if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
       && db->mallocFailed==0
      ){
        iEndTrigger = sqlite3VdbeMakeLabel(pSubParse);
        sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
      }
      sqlite3ExprDelete(db, pWhen);
    }
 
    /* Code the trigger program into the sub-vdbe. */
    codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);
 
    /* Insert an OP_Halt at the end of the sub-program. */
    if( iEndTrigger ){
      sqlite3VdbeResolveLabel(v, iEndTrigger);
    }
    sqlite3VdbeAddOp0(v, OP_Halt);
    VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
 
    transferParseError(pParse, pSubParse);
    if( db->mallocFailed==0 && pParse->nErr==0 ){
      pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
    }
    pProgram->nMem = pSubParse->nMem;
    pProgram->nCsr = pSubParse->nTab;
    pProgram->token = (void *)pTrigger;
    pPrg->aColmask[0] = pSubParse->oldmask;
    pPrg->aColmask[1] = pSubParse->newmask;
    sqlite3VdbeDelete(v);
  }
 
  assert( !pSubParse->pAinc       && !pSubParse->pZombieTab );

Referenced by getRowTrigger().

◆ codeTableLocks()

static void codeTableLocks ( Parse * pParse )

static

Definition at line 110479 of file sqlite3.c.

                                         {
  int i;
  Vdbe *pVdbe;
 
  pVdbe = sqlite3GetVdbe(pParse);
  assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
 
  for(i=0; i<pParse->nTableLock; i++){

Referenced by sqlite3FinishCoding().

◆ codeTriggerProgram()

static int codeTriggerProgram	(	Parse *	pParse,
		TriggerStep *	pStepList,
		int	orconf )

static

Definition at line 137159 of file sqlite3.c.

 {
  TriggerStep *pStep;
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;
 
  assert( pParse->pTriggerTab && pParse->pToplevel );
  assert( pStepList );
  assert( v!=0 );
  for(pStep=pStepList; pStep; pStep=pStep->pNext){
    /* Figure out the ON CONFLICT policy that will be used for this step
    ** of the trigger program. If the statement that caused this trigger
    ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
    ** the ON CONFLICT policy that was specified as part of the trigger
    ** step statement. Example:
    **
    **   CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
    **     INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
    **   END;
    **
    **   INSERT INTO t1 ... ;            -- insert into t2 uses REPLACE policy
    **   INSERT OR IGNORE INTO t1 ... ;  -- insert into t2 uses IGNORE policy
    */
    pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
    assert( pParse->okConstFactor==0 );
 
#ifndef SQLITE_OMIT_TRACE
    if( pStep->zSpan ){
      sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0,
                        sqlite3MPrintf(db, "-- %s", pStep->zSpan),
                        P4_DYNAMIC);
    }
#endif
 
    switch( pStep->op ){
      case TK_UPDATE: {
        sqlite3Update(pParse,
          sqlite3TriggerStepSrc(pParse, pStep),
          sqlite3ExprListDup(db, pStep->pExprList, 0),
          sqlite3ExprDup(db, pStep->pWhere, 0),
          pParse->eOrconf, 0, 0, 0
        );
        break;
      }
      case TK_INSERT: {
        sqlite3Insert(pParse,
          sqlite3TriggerStepSrc(pParse, pStep),
          sqlite3SelectDup(db, pStep->pSelect, 0),
          sqlite3IdListDup(db, pStep->pIdList),
          pParse->eOrconf,
          sqlite3UpsertDup(db, pStep->pUpsert)
        );
        break;
      }
      case TK_DELETE: {
        sqlite3DeleteFrom(pParse,
          sqlite3TriggerStepSrc(pParse, pStep),
          sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0
        );
        break;
      }
      default: assert( pStep->op==TK_SELECT ); {
        SelectDest sDest;
        Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0);
        sqlite3SelectDestInit(&sDest, SRT_Discard, 0);
        sqlite3Select(pParse, pSelect, &sDest);
        sqlite3SelectDelete(db, pSelect);
        break;
      }
    }
    if( pStep->op!=TK_SELECT ){

◆ codeVectorCompare()

static void codeVectorCompare	(	Parse *	pParse,
		Expr *	pExpr,
		int	dest,
		u8	op,
		u8	p5 )

static

Definition at line 100294 of file sqlite3.c.

                                                      :
**
**    if pExpr->op==TK_IS:      op==TK_EQ and p5==SQLITE_NULLEQ
**    if pExpr->op==TK_ISNOT:   op==TK_NE and p5==SQLITE_NULLEQ
**    otherwise:                op==pExpr->op and p5==0
*/
static void codeVectorCompare(
  Parse *pParse,        /* Code generator context */
  Expr *pExpr,          /* The comparison operation */
  int dest,             /* Write results into this register */
  u8 op,                /* Comparison operator */
  u8 p5                 /* SQLITE_NULLEQ or zero */
){
  Vdbe *v = pParse->pVdbe;
  Expr *pLeft = pExpr->pLeft;
  Expr *pRight = pExpr->pRight;
  int nLeft = sqlite3ExprVectorSize(pLeft);
  int i;
  int regLeft = 0;
  int regRight = 0;
  u8 opx = op;
  int addrDone = sqlite3VdbeMakeLabel(pParse);
  int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
 
  assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
  if( pParse->nErr ) return;
  if( nLeft!=sqlite3ExprVectorSize(pRight) ){
    sqlite3ErrorMsg(pParse, "row value misused");
    return;
  }
  assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
       || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
       || pExpr->op==TK_LT || pExpr->op==TK_GT
       || pExpr->op==TK_LE || pExpr->op==TK_GE
  );
  assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
            || (pExpr->op==TK_ISNOT && op==TK_NE) );
  assert( p5==0 || pExpr->op!=op );
  assert( p5==SQLITE_NULLEQ || pExpr->op==op );
 
  p5 |= SQLITE_STOREP2;
  if( opx==TK_LE ) opx = TK_LT;
  if( opx==TK_GE ) opx = TK_GT;
 
  regLeft = exprCodeSubselect(pParse, pLeft);
  regRight = exprCodeSubselect(pParse, pRight);
 
  for(i=0; 1 /*Loop exits by "break"*/; i++){
    int regFree1 = 0, regFree2 = 0;
    Expr *pL, *pR;
    int r1, r2;
    assert( i>=0 && i<nLeft );
    r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, &regFree1);
    r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, &regFree2);
    codeCompare(pParse, pL, pR, opx, r1, r2, dest, p5, isCommuted);
    testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
    testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
    testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
    testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
    testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
    testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
    sqlite3ReleaseTempReg(pParse, regFree1);
    sqlite3ReleaseTempReg(pParse, regFree2);
    if( i==nLeft-1 ){
      break;
    }
    if( opx==TK_EQ ){
      sqlite3VdbeAddOp2(v, OP_IfNot, dest, addrDone); VdbeCoverage(v);
      p5 |= SQLITE_KEEPNULL;
    }else if( opx==TK_NE ){
      sqlite3VdbeAddOp2(v, OP_If, dest, addrDone); VdbeCoverage(v);
      p5 |= SQLITE_KEEPNULL;
    }else{
      assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE );
      sqlite3VdbeAddOp2(v, OP_ElseNotEq, 0, addrDone);
      VdbeCoverageIf(v, op==TK_LT);
      VdbeCoverageIf(v, op==TK_GT);
      VdbeCoverageIf(v, op==TK_LE);

References codeCompare(), EP_Commuted, EP_Immutable, exprCodeSubselect(), ExprHasProperty, ExprHasVVAProperty, exprVectorRegister(), Parse::nErr, Expr::op, OP_ElseNotEq, OP_Eq, OP_Ge, OP_Gt, OP_If, OP_IfNot, OP_Le, OP_Lt, OP_Ne, Expr::pLeft, Expr::pRight, Parse::pVdbe, sqlite3ErrorMsg(), sqlite3ExprVectorSize(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_KEEPNULL, SQLITE_NULLEQ, SQLITE_STOREP2, testcase, TK_EQ, TK_GE, TK_GT, TK_IS, TK_ISNOT, TK_LE, TK_LT, TK_NE, VdbeCoverage, and VdbeCoverageIf.

Referenced by sqlite3ExprCodeTarget().

◆ collationMatch()

static int collationMatch	(	const char *	zColl,
		Index *	pIndex )

static

Definition at line 115294 of file sqlite3.c.

                                                           {
  int i;
  assert( zColl!=0 );
  for(i=0; i<pIndex->nColumn; i++){
    const char *z = pIndex->azColl[i];
    assert( z!=0 || pIndex->aiColumn[i]<0 );

References Index::aiColumn, Index::azColl, Index::nColumn, and sqlite3StrICmp().

Referenced by reindexTable().

◆ columnIndex()

static int columnIndex	(	Table *	pTab,
		const char *	zCol )

static

Definition at line 129558 of file sqlite3.c.

                                                     {
  int i;
  u8 h = sqlite3StrIHash(zCol);

Referenced by sqliteProcessJoin(), and tableAndColumnIndex().

◆ columnMallocFailure()

static void columnMallocFailure ( sqlite3_stmt * pStmt )

static

Definition at line 84071 of file sqlite3.c.

{
  /* If malloc() failed during an encoding conversion within an
  ** sqlite3_column_XXX API, then set the return code of the statement to
  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
  ** and _finalize() will return NOMEM.
  */
  Vdbe *p = (Vdbe *)pStmt;
  if( p ){

References Vdbe::db, sqlite3::mutex, Vdbe::rc, sqlite3_mutex_held(), sqlite3_mutex_leave(), and sqlite3ApiExit().

Referenced by sqlite3_column_type().

◆ columnMem()

static Mem * columnMem	(	sqlite3_stmt *	pStmt,
		int	i )

static

Definition at line 84036 of file sqlite3.c.

                                                 {
  Vdbe *pVm;
  Mem *pOut;
 
  pVm = (Vdbe *)pStmt;
  if( pVm==0 ) return (Mem*)columnNullValue();
  assert( pVm->db );
  sqlite3_mutex_enter(pVm->db->mutex);
  if( pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
    pOut = &pVm->pResultSet[i];

References columnNullValue(), Vdbe::db, sqlite3::mutex, Vdbe::pResultSet, sqlite3_mutex_enter(), sqlite3Error(), and SQLITE_RANGE.

Referenced by sqlite3_column_type().

◆ columnName()

static const void * columnName	(	sqlite3_stmt *	pStmt,
		int	N,
		int	useUtf16,
		int	useType )

static

Definition at line 84169 of file sqlite3.c.

 {
  const void *ret;
  Vdbe *p;
  int n;
  sqlite3 *db;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pStmt==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  ret = 0;
  p = (Vdbe *)pStmt;
  db = p->db;
  assert( db!=0 );
  n = sqlite3_column_count(pStmt);
  if( N<n && N>=0 ){
    N += useType*n;
    sqlite3_mutex_enter(db->mutex);
    assert( db->mallocFailed==0 );
#ifndef SQLITE_OMIT_UTF16
    if( useUtf16 ){
      ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
    }else
#endif
    {
      ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
    }
    /* A malloc may have failed inside of the _text() call. If this
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if( db->mallocFailed ){
      sqlite3OomClear(db);

References Vdbe::aColName, Vdbe::db, sqlite3::mallocFailed, sqlite3::mutex, sqlite3_column_count(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_value_text(), sqlite3_value_text16(), sqlite3OomClear(), and SQLITE_MISUSE_BKPT.

Referenced by sqlite3_column_decltype16(), and sqlite3_column_name16().

◆ columnNullValue()

static const Mem * columnNullValue ( void )

static

Definition at line 83996 of file sqlite3.c.

                                       {
  /* Even though the Mem structure contains an element
  ** of type i64, on certain architectures (x86) with certain compiler
  ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
  ** instead of an 8-byte one. This all works fine, except that when
  ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
  ** that a Mem structure is located on an 8-byte boundary. To prevent
  ** these assert()s from failing, when building with SQLITE_DEBUG defined
  ** using gcc, we force nullMem to be 8-byte aligned using the magical
  ** __attribute__((aligned(8))) macro.  */
  static const Mem nullMem
#if defined(SQLITE_DEBUG) && defined(__GNUC__)
    __attribute__((aligned(8)))
#endif
    = {
        /* .u          = */ {0},
        /* .flags      = */ (u16)MEM_Null,
        /* .enc        = */ (u8)0,
        /* .eSubtype   = */ (u8)0,
        /* .n          = */ (int)0,
        /* .z          = */ (char*)0,
        /* .zMalloc    = */ (char*)0,
        /* .szMalloc   = */ (int)0,
        /* .uTemp      = */ (u32)0,
        /* .db         = */ (sqlite3*)0,
        /* .xDel       = */ (void(*)(void*))0,
#ifdef SQLITE_DEBUG

Referenced by columnMem().

◆ columnTypeImpl()

static const char * columnTypeImpl	(	NameContext *	pNC,
		Expr *	pExpr )

static

Definition at line 130952 of file sqlite3.c.

 {
  char const *zType = 0;
  int j;
#ifdef SQLITE_ENABLE_COLUMN_METADATA
  char const *zOrigDb = 0;
  char const *zOrigTab = 0;
  char const *zOrigCol = 0;
#endif
 
  assert( pExpr!=0 );
  assert( pNC->pSrcList!=0 );
  switch( pExpr->op ){
    case TK_COLUMN: {
      /* The expression is a column. Locate the table the column is being
      ** extracted from in NameContext.pSrcList. This table may be real
      ** database table or a subquery.
      */
      Table *pTab = 0;            /* Table structure column is extracted from */
      Select *pS = 0;             /* Select the column is extracted from */
      int iCol = pExpr->iColumn;  /* Index of column in pTab */
      while( pNC && !pTab ){
        SrcList *pTabList = pNC->pSrcList;
        for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
        if( j<pTabList->nSrc ){
          pTab = pTabList->a[j].pTab;
          pS = pTabList->a[j].pSelect;
        }else{
          pNC = pNC->pNext;
        }
      }
 
      if( pTab==0 ){
        /* At one time, code such as "SELECT new.x" within a trigger would
        ** cause this condition to run.  Since then, we have restructured how
        ** trigger code is generated and so this condition is no longer
        ** possible. However, it can still be true for statements like
        ** the following:
        **
        **   CREATE TABLE t1(col INTEGER);
        **   SELECT (SELECT t1.col) FROM FROM t1;
        **
        ** when columnType() is called on the expression "t1.col" in the
        ** sub-select. In this case, set the column type to NULL, even
        ** though it should really be "INTEGER".
        **
        ** This is not a problem, as the column type of "t1.col" is never
        ** used. When columnType() is called on the expression
        ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
        ** branch below.  */
        break;
      }
 
      assert( pTab && pExpr->y.pTab==pTab );
      if( pS ){
        /* The "table" is actually a sub-select or a view in the FROM clause
        ** of the SELECT statement. Return the declaration type and origin
        ** data for the result-set column of the sub-select.
        */
        if( iCol>=0 && iCol<pS->pEList->nExpr ){
          /* If iCol is less than zero, then the expression requests the
          ** rowid of the sub-select or view. This expression is legal (see
          ** test case misc2.2.2) - it always evaluates to NULL.
          */
          NameContext sNC;
          Expr *p = pS->pEList->a[iCol].pExpr;
          sNC.pSrcList = pS->pSrc;
          sNC.pNext = pNC;
          sNC.pParse = pNC->pParse;
          zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol);
        }
      }else{
        /* A real table or a CTE table */
        assert( !pS );
#ifdef SQLITE_ENABLE_COLUMN_METADATA
        if( iCol<0 ) iCol = pTab->iPKey;
        assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
        if( iCol<0 ){
          zType = "INTEGER";
          zOrigCol = "rowid";
        }else{
          zOrigCol = pTab->aCol[iCol].zName;
          zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
        }
        zOrigTab = pTab->zName;
        if( pNC->pParse && pTab->pSchema ){
          int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
          zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
        }
#else
        assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
        if( iCol<0 ){
          zType = "INTEGER";
        }else{
          zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
        }
#endif
      }
      break;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT: {
      /* The expression is a sub-select. Return the declaration type and
      ** origin info for the single column in the result set of the SELECT
      ** statement.
      */
      NameContext sNC;
      Select *pS = pExpr->x.pSelect;
      Expr *p = pS->pEList->a[0].pExpr;
      assert( ExprHasProperty(pExpr, EP_xIsSelect) );
      sNC.pSrcList = pS->pSrc;
      sNC.pNext = pNC;
      sNC.pParse = pNC->pParse;
      zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
      break;
    }
#endif
  }
 
#ifdef SQLITE_ENABLE_COLUMN_METADATA
  if( pzOrigDb ){
    assert( pzOrigTab && pzOrigCol );
    *pzOrigDb = zOrigDb;

References ExprList::a, SrcList::a, Table::aCol, sqlite3::aDb, columnType, Parse::db, EP_xIsSelect, ExprHasProperty, SrcList::SrcList_item::iCursor, Table::iPKey, ExprList::nExpr, SrcList::nSrc, Select::pEList, ExprList::ExprList_item::pExpr, NameContext::pNext, NameContext::pParse, Table::pSchema, SrcList::SrcList_item::pSelect, Select::pSrc, NameContext::pSrcList, SrcList::SrcList_item::pTab, sqlite3ColumnType(), sqlite3SchemaToIndex(), TK_COLUMN, TK_SELECT, XN_ROWID, Db::zDbSName, Column::zName, and Table::zName.

◆ compare2pow63()

static int compare2pow63	(	const char *	zNum,
		int	incr )

static

Definition at line 31816 of file sqlite3.c.

                                                    {
  int c = 0;
  int i;
                    /* 012345678901234567 */
  const char *pow63 = "922337203685477580";
  for(i=0; c==0 && i<18; i++){
    c = (zNum[i*incr]-pow63[i])*10;
  }
  if( c==0 ){
    c = zNum[18*incr] - '8';

References testcase.

Referenced by sqlite3Atoi64().

◆ comparisonAffinity()

static char comparisonAffinity ( const Expr * pExpr )

static

Definition at line 99981 of file sqlite3.c.

                                                 {
  char aff;
  assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
          pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
          pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
  assert( pExpr->pLeft );
  aff = sqlite3ExprAffinity(pExpr->pLeft);
  if( pExpr->pRight ){
    aff = sqlite3CompareAffinity(pExpr->pRight, aff);
  }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){

Referenced by sqlite3IndexAffinityOk().

◆ compileoptiongetFunc()

static void compileoptiongetFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118049 of file sqlite3.c.

 {
  int n;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);

References sqlite3_value_int(), and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ compileoptionusedFunc()

static void compileoptionusedFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118025 of file sqlite3.c.

 {
  const char *zOptName;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
  ** function is a wrapper around the sqlite3_compileoption_used() C/C++

References sqlite3_compileoption_used(), sqlite3_result_int(), sqlite3_value_text(), and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ computeCellSize()

static SQLITE_NOINLINE u16 computeCellSize	(	CellArray *	p,
		int	N )

static

Definition at line 71391 of file sqlite3.c.

◆ computeHMS()

static void computeHMS ( DateTime * p )

static

Definition at line 22157 of file sqlite3.c.

                                   {
  int s;
  if( p->validHMS ) return;
  computeJD(p);
  s = (int)((p->iJD + 43200000) % 86400000);
  p->s = s/1000.0;
  s = (int)p->s;
  p->s -= s;
  p->h = s/3600;
  s -= p->h*3600;

Referenced by timeFunc().

◆ computeJD()

static void computeJD ( DateTime * p )

static

Definition at line 21960 of file sqlite3.c.

                             :MM:SS to julian day.  We always assume
** that the YYYY-MM-DD is according to the Gregorian calendar.
**
** Reference:  Meeus page 61
*/
static void computeJD(DateTime *p){
  int Y, M, D, A, B, X1, X2;
 
  if( p->validJD ) return;
  if( p->validYMD ){
    Y = p->Y;
    M = p->M;
    D = p->D;
  }else{
    Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
    M = 1;
    D = 1;
  }
  if( Y<-4713 || Y>9999 || p->rawS ){
    datetimeError(p);
    return;
  }
  if( M<=2 ){
    Y--;
    M += 12;
  }
  A = Y/100;
  B = 2 - A + (A/4);
  X1 = 36525*(Y+4716)/100;
  X2 = 306001*(M+1)/10000;
  p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
  p->validJD = 1;
  if( p->validHMS ){
    p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
    if( p->validTZ ){
      p->iJD -= p->tz*60000;
      p->validYMD = 0;

References DateTime::D, datetimeError(), DateTime::h, DateTime::iJD, DateTime::M, DateTime::m, DateTime::rawS, DateTime::s, DateTime::tz, DateTime::validHMS, DateTime::validJD, DateTime::validTZ, DateTime::validYMD, and DateTime::Y.

Referenced by isDate(), juliandayFunc(), localtimeOffset(), parseModifier(), parseYyyyMmDd(), and strftimeFunc().

◆ computeLimitRegisters()

static void computeLimitRegisters	(	Parse *	pParse,
		Select *	p,
		int	iBreak )

static

Definition at line 131478 of file sqlite3.c.

                                                                       {
  Vdbe *v = 0;
  int iLimit = 0;
  int iOffset;
  int n;
  Expr *pLimit = p->pLimit;
 
  if( p->iLimit ) return;
 
  /*
  ** "LIMIT -1" always shows all rows.  There is some
  ** controversy about what the correct behavior should be.
  ** The current implementation interprets "LIMIT 0" to mean
  ** no rows.
  */
  if( pLimit ){
    assert( pLimit->op==TK_LIMIT );
    assert( pLimit->pLeft!=0 );
    p->iLimit = iLimit = ++pParse->nMem;
    v = sqlite3GetVdbe(pParse);
    assert( v!=0 );
    if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
      sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
      VdbeComment((v, "LIMIT counter"));
      if( n==0 ){
        sqlite3VdbeGoto(v, iBreak);
      }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){
        p->nSelectRow = sqlite3LogEst((u64)n);
        p->selFlags |= SF_FixedLimit;
      }
    }else{
      sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
      sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
      VdbeComment((v, "LIMIT counter"));
      sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
    }
    if( pLimit->pRight ){
      p->iOffset = iOffset = ++pParse->nMem;
      pParse->nMem++;   /* Allocate an extra register for limit+offset */
      sqlite3ExprCode(pParse, pLimit->pRight, iOffset);
      sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);

References Select::iLimit, Select::iOffset, Parse::nMem, Select::nSelectRow, Expr::op, OP_IfNot, OP_Integer, OP_MustBeInt, OP_OffsetLimit, Expr::pLeft, Select::pLimit, Expr::pRight, Select::selFlags, SF_FixedLimit, sqlite3ExprCode(), sqlite3ExprIsInteger(), sqlite3GetVdbe(), sqlite3LogEst(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeGoto(), TK_LIMIT, VdbeComment, and VdbeCoverage.

Referenced by generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), and sqlite3Select().

◆ computeNumericType()

static u16 SQLITE_NOINLINE computeNumericType ( Mem * pMem )

static

Definition at line 85668 of file sqlite3.c.

                                                        {
  int rc;
  sqlite3_int64 ix;
  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
  assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
  ExpandBlob(pMem);
  rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
  if( rc<=0 ){
    if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
      pMem->u.i = ix;
      return MEM_Int;
    }else{
      return MEM_Real;
    }

References sqlite3_value::enc, ExpandBlob, sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Real, MEM_Str, sqlite3_value::n, sqlite3_value::MemValue::r, sqlite3AtoF(), sqlite3Atoi64(), sqlite3_value::u, and sqlite3_value::z.

Referenced by numericType().

◆ computeYMD()

static void computeYMD ( DateTime * p )

static

Definition at line 22128 of file sqlite3.c.

                                   {
  int Z, A, B, C, D, E, X1;
  if( p->validYMD ) return;
  if( !p->validJD ){
    p->Y = 2000;
    p->M = 1;
    p->D = 1;
  }else if( !validJulianDay(p->iJD) ){
    datetimeError(p);
    return;
  }else{
    Z = (int)((p->iJD + 43200000)/86400000);
    A = (int)((Z - 1867216.25)/36524.25);
    A = Z + 1 + A - (A/4);
    B = A + 1524;
    C = (int)((B - 122.1)/365.25);
    D = (36525*(C&32767))/100;
    E = (int)((B-D)/30.6001);
    X1 = (int)(30.6001*E);
    p->D = B - D - X1;

Referenced by dateFunc(), and parseModifier().

◆ computeYMD_HMS()

static void computeYMD_HMS ( DateTime * p )

static

Definition at line 22176 of file sqlite3.c.

Referenced by datetimeFunc(), localtimeOffset(), parseModifier(), and strftimeFunc().

◆ connectionIsBusy()

static int connectionIsBusy ( sqlite3 * db )

static

Definition at line 162173 of file sqlite3.c.

                                        {
  int j;
  assert( sqlite3_mutex_held(db->mutex) );
  if( db->pVdbe ) return 1;

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ constInsert()

static void constInsert	(	WhereConst *	pConst,
		Expr *	pColumn,
		Expr *	pValue,
		Expr *	pExpr )

static

Definition at line 133512 of file sqlite3.c.

 {
  int i;
  assert( pColumn->op==TK_COLUMN );
  assert( sqlite3ExprIsConstant(pValue) );
 
  if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
  if( sqlite3ExprAffinity(pValue)!=0 ) return;
  if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
    return;
  }
 
  /* 2018-10-25 ticket [cf5ed20f]
  ** Make sure the same pColumn is not inserted more than once */
  for(i=0; i<pConst->nConst; i++){
    const Expr *pE2 = pConst->apExpr[i*2];
    assert( pE2->op==TK_COLUMN );
    if( pE2->iTable==pColumn->iTable
     && pE2->iColumn==pColumn->iColumn
    ){
      return;  /* Already present.  Return without doing anything. */
    }
  }
 
  pConst->nConst++;
  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
                         pConst->nConst*2*sizeof(Expr*));
  if( pConst->apExpr==0 ){

References WhereConst::apExpr, Parse::db, EP_FixedCol, ExprHasProperty, Expr::iColumn, Expr::iTable, WhereConst::nConst, Expr::op, WhereConst::pParse, sqlite3DbReallocOrFree(), sqlite3ExprAffinity(), sqlite3ExprCompareCollSeq(), sqlite3ExprIsConstant(), sqlite3IsBinary(), and TK_COLUMN.

Referenced by findConstInWhere().

◆ constructAutomaticIndex()

static void constructAutomaticIndex	(	Parse *	pParse,
		WhereClause *	pWC,
		struct SrcList_item *	pSrc,
		Bitmask	notReady,
		WhereLevel *	pLevel )

static

Definition at line 146302 of file sqlite3.c.

 {
  int nKeyCol;                /* Number of columns in the constructed index */
  WhereTerm *pTerm;           /* A single term of the WHERE clause */
  WhereTerm *pWCEnd;          /* End of pWC->a[] */
  Index *pIdx;                /* Object describing the transient index */
  Vdbe *v;                    /* Prepared statement under construction */
  int addrInit;               /* Address of the initialization bypass jump */
  Table *pTable;              /* The table being indexed */
  int addrTop;                /* Top of the index fill loop */
  int regRecord;              /* Register holding an index record */
  int n;                      /* Column counter */
  int i;                      /* Loop counter */
  int mxBitCol;               /* Maximum column in pSrc->colUsed */
  CollSeq *pColl;             /* Collating sequence to on a column */
  WhereLoop *pLoop;           /* The Loop object */
  char *zNotUsed;             /* Extra space on the end of pIdx */
  Bitmask idxCols;            /* Bitmap of columns used for indexing */
  Bitmask extraCols;          /* Bitmap of additional columns */
  u8 sentWarning = 0;         /* True if a warnning has been issued */
  Expr *pPartial = 0;         /* Partial Index Expression */
  int iContinue = 0;          /* Jump here to skip excluded rows */
  struct SrcList_item *pTabItem;  /* FROM clause term being indexed */
  int addrCounter = 0;        /* Address where integer counter is initialized */
  int regBase;                /* Array of registers where record is assembled */
 
  /* Generate code to skip over the creation and initialization of the
  ** transient index on 2nd and subsequent iterations of the loop. */
  v = pParse->pVdbe;
  assert( v!=0 );
  addrInit = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
 
  /* Count the number of columns that will be added to the index
  ** and used to match WHERE clause constraints */
  nKeyCol = 0;
  pTable = pSrc->pTab;
  pWCEnd = &pWC->a[pWC->nTerm];
  pLoop = pLevel->pWLoop;
  idxCols = 0;
  for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
    Expr *pExpr = pTerm->pExpr;
    assert( !ExprHasProperty(pExpr, EP_FromJoin)    /* prereq always non-zero */
         || pExpr->iRightJoinTable!=pSrc->iCursor   /*   for the right-hand   */
         || pLoop->prereq!=0 );                     /*   table of a LEFT JOIN */
    if( pLoop->prereq==0
     && (pTerm->wtFlags & TERM_VIRTUAL)==0
     && !ExprHasProperty(pExpr, EP_FromJoin)
     && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){
      pPartial = sqlite3ExprAnd(pParse, pPartial,
                                sqlite3ExprDup(pParse->db, pExpr, 0));
    }
    if( termCanDriveIndex(pTerm, pSrc, notReady) ){
      int iCol = pTerm->u.leftColumn;
      Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
      testcase( iCol==BMS );
      testcase( iCol==BMS-1 );
      if( !sentWarning ){
        sqlite3_log(SQLITE_WARNING_AUTOINDEX,
            "automatic index on %s(%s)", pTable->zName,
            pTable->aCol[iCol].zName);
        sentWarning = 1;
      }
      if( (idxCols & cMask)==0 ){
        if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){
          goto end_auto_index_create;
        }
        pLoop->aLTerm[nKeyCol++] = pTerm;
        idxCols |= cMask;
      }
    }
  }
  assert( nKeyCol>0 );
  pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol;
  pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED
                     | WHERE_AUTO_INDEX;
 
  /* Count the number of additional columns needed to create a
  ** covering index.  A "covering index" is an index that contains all
  ** columns that are needed by the query.  With a covering index, the
  ** original table never needs to be accessed.  Automatic indices must
  ** be a covering index because the index will not be updated if the
  ** original table changes and the index and table cannot both be used
  ** if they go out of sync.
  */
  extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1));
  mxBitCol = MIN(BMS-1,pTable->nCol);
  testcase( pTable->nCol==BMS-1 );
  testcase( pTable->nCol==BMS-2 );
  for(i=0; i<mxBitCol; i++){
    if( extraCols & MASKBIT(i) ) nKeyCol++;
  }
  if( pSrc->colUsed & MASKBIT(BMS-1) ){
    nKeyCol += pTable->nCol - BMS + 1;
  }
 
  /* Construct the Index object to describe this index */
  pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
  if( pIdx==0 ) goto end_auto_index_create;
  pLoop->u.btree.pIndex = pIdx;
  pIdx->zName = "auto-index";
  pIdx->pTable = pTable;
  n = 0;
  idxCols = 0;
  for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
    if( termCanDriveIndex(pTerm, pSrc, notReady) ){
      int iCol = pTerm->u.leftColumn;
      Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
      testcase( iCol==BMS-1 );
      testcase( iCol==BMS );
      if( (idxCols & cMask)==0 ){
        Expr *pX = pTerm->pExpr;
        idxCols |= cMask;
        pIdx->aiColumn[n] = pTerm->u.leftColumn;
        pColl = sqlite3ExprCompareCollSeq(pParse, pX);
        assert( pColl!=0 || pParse->nErr>0 ); /* TH3 collate01.800 */
        pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
        n++;
      }
    }
  }
  assert( (u32)n==pLoop->u.btree.nEq );
 
  /* Add additional columns needed to make the automatic index into
  ** a covering index */
  for(i=0; i<mxBitCol; i++){
    if( extraCols & MASKBIT(i) ){
      pIdx->aiColumn[n] = i;
      pIdx->azColl[n] = sqlite3StrBINARY;
      n++;
    }
  }
  if( pSrc->colUsed & MASKBIT(BMS-1) ){
    for(i=BMS-1; i<pTable->nCol; i++){
      pIdx->aiColumn[n] = i;
      pIdx->azColl[n] = sqlite3StrBINARY;
      n++;
    }
  }
  assert( n==nKeyCol );
  pIdx->aiColumn[n] = XN_ROWID;
  pIdx->azColl[n] = sqlite3StrBINARY;
 
  /* Create the automatic index */
  assert( pLevel->iIdxCur>=0 );
  pLevel->iIdxCur = pParse->nTab++;
  sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);
  sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
  VdbeComment((v, "for %s", pTable->zName));
 
  /* Fill the automatic index with content */
  pTabItem = &pWC->pWInfo->pTabList->a[pLevel->iFrom];
  if( pTabItem->fg.viaCoroutine ){
    int regYield = pTabItem->regReturn;
    addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0);
    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
    addrTop =  sqlite3VdbeAddOp1(v, OP_Yield, regYield);
    VdbeCoverage(v);
    VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
  }else{
    addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
  }
  if( pPartial ){
    iContinue = sqlite3VdbeMakeLabel(pParse);
    sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL);
    pLoop->wsFlags |= WHERE_PARTIALIDX;
  }
  regRecord = sqlite3GetTempReg(pParse);
  regBase = sqlite3GenerateIndexKey(
      pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0
  );
  sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
  sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
  if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);
  if( pTabItem->fg.viaCoroutine ){
    sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
    testcase( pParse->db->mallocFailed );
    assert( pLevel->iIdxCur>0 );
    translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
                          pTabItem->regResult, pLevel->iIdxCur);
    sqlite3VdbeGoto(v, addrTop);
    pTabItem->fg.viaCoroutine = 0;
  }else{
    sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
    sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
  }
  sqlite3VdbeJumpHere(v, addrTop);
  sqlite3ReleaseTempReg(pParse, regRecord);
 

References SrcList::a, WhereClause::a, Table::aCol, Index::aiColumn, WhereLoop::aLTerm, Index::azColl, BMS, WhereLoop::btree, Parse::db, EP_FromJoin, ExprHasProperty, WhereLevel::iFrom, WhereLevel::iIdxCur, Expr::iRightJoinTable, WhereLevel::iTabCur, WhereTerm::leftColumn, sqlite3::mallocFailed, MASKBIT, MIN, Table::nCol, WhereLoop::nEq, Parse::nErr, WhereLoop::nLTerm, Parse::nTab, WhereClause::nTerm, OP_IdxInsert, OP_InitCoroutine, OP_Integer, OP_Next, OP_Once, OP_OpenAutoindex, OP_Rewind, OP_Yield, OPFLAG_USESEEKRESULT, WhereTerm::pExpr, WhereLoop::pIndex, WhereLoop::prereq, Index::pTable, WhereInfo::pTabList, Parse::pVdbe, WhereClause::pWInfo, WhereLevel::pWLoop, sqlite3_log(), sqlite3AllocateIndexObject(), sqlite3ExprAnd(), sqlite3ExprCompareCollSeq(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIfFalse(), sqlite3ExprIsTableConstant(), sqlite3GenerateIndexKey(), sqlite3GetTempReg(), sqlite3ReleaseTempReg(), sqlite3StrBINARY, sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP2(), sqlite3VdbeChangeP5(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeSetP4KeyInfo(), SQLITE_JUMPIFNULL, SQLITE_STMTSTATUS_AUTOINDEX, SQLITE_WARNING_AUTOINDEX, TERM_VIRTUAL, termCanDriveIndex(), testcase, translateColumnToCopy(), WhereLoop::u, WhereTerm::u, VdbeComment, VdbeCoverage, WHERE_AUTO_INDEX, WHERE_COLUMN_EQ, WHERE_IDX_ONLY, WHERE_INDEXED, WHERE_PARTIALIDX, whereLoopResize(), WhereLoop::wsFlags, WhereTerm::wtFlags, XN_ROWID, Column::zName, CollSeq::zName, Table::zName, and Index::zName.

Referenced by sqlite3WhereBegin().

◆ contextMalloc()

static void * contextMalloc	(	sqlite3_context *	context,
		i64	nByte )

static

Definition at line 117479 of file sqlite3.c.

                                                               {
  char *z;
  sqlite3 *db = sqlite3_context_db_handle(context);
  assert( nByte>0 );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
  if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
    sqlite3_result_error_toobig(context);
    z = 0;
  }else{
    z = sqlite3Malloc(nByte);

References sqlite3::aLimit, sqlite3_context_db_handle(), sqlite3_result_error_nomem(), sqlite3_result_error_toobig(), sqlite3Malloc(), SQLITE_LIMIT_LENGTH, and testcase.

Referenced by quoteFunc(), and replaceFunc().

◆ convertCompoundSelectToSubquery()

static int convertCompoundSelectToSubquery	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 133931 of file sqlite3.c.

       ://www.sqlite.org/src/info/6709574d2a
**
** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
** The UNION ALL operator works fine with multiSelectOrderBy() even when
** there are COLLATE terms in the ORDER BY.
*/
static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
  int i;
  Select *pNew;
  Select *pX;
  sqlite3 *db;
  struct ExprList_item *a;
  SrcList *pNewSrc;
  Parse *pParse;
  Token dummy;
 
  if( p->pPrior==0 ) return WRC_Continue;
  if( p->pOrderBy==0 ) return WRC_Continue;
  for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
  if( pX==0 ) return WRC_Continue;
  a = p->pOrderBy->a;
#ifndef SQLITE_OMIT_WINDOWFUNC
  /* If iOrderByCol is already non-zero, then it has already been matched
  ** to a result column of the SELECT statement. This occurs when the
  ** SELECT is rewritten for window-functions processing and then passed
  ** to sqlite3SelectPrep() and similar a second time. The rewriting done
  ** by this function is not required in this case. */
  if( a[0].u.x.iOrderByCol ) return WRC_Continue;
#endif
  for(i=p->pOrderBy->nExpr-1; i>=0; i--){
    if( a[i].pExpr->flags & EP_Collate ) break;
  }
  if( i<0 ) return WRC_Continue;
 
  /* If we reach this point, that means the transformation is required. */
 
  pParse = pWalker->pParse;
  db = pParse->db;
  pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
  if( pNew==0 ) return WRC_Abort;
  memset(&dummy, 0, sizeof(dummy));
  pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
  if( pNewSrc==0 ) return WRC_Abort;
  *pNew = *p;
  p->pSrc = pNewSrc;
  p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
  p->op = TK_SELECT;
  p->pWhere = 0;
  pNew->pGroupBy = 0;
  pNew->pHaving = 0;
  pNew->pOrderBy = 0;
  p->pPrior = 0;
  p->pNext = 0;
  p->pWith = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
  p->pWinDefn = 0;
#endif
  p->selFlags &= ~SF_Compound;
  assert( (p->selFlags & SF_Converted)==0 );

References ExprList::a, Parse::db, dummy, EP_Collate, Expr::flags, ExprList::nExpr, Select::op, Select::pEList, Select::pGroupBy, Select::pHaving, Select::pLimit, Select::pNext, Select::pOrderBy, Walker::pParse, Select::pPrior, Select::pSrc, Select::pWhere, Select::pWinDefn, Select::pWith, Select::selFlags, SF_Converted, sqlite3DbMallocZero(), sqlite3Expr(), sqlite3ExprListAppend(), sqlite3SrcListAppendFromTerm(), TK_ALL, TK_ASTERISK, TK_SELECT, WRC_Abort, and WRC_Continue.

Referenced by sqlite3SelectExpand().

◆ convertToWithoutRowidTable()

static void convertToWithoutRowidTable	(	Parse *	pParse,
		Table *	pTab )

static

Definition at line 112425 of file sqlite3.c.

                                                                  {
  Index *pIdx;
  Index *pPk;
  int nPk;
  int nExtra;
  int i, j;
  sqlite3 *db = pParse->db;
  Vdbe *v = pParse->pVdbe;
 
  /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
  */
  if( !db->init.imposterTable ){
    for(i=0; i<pTab->nCol; i++){
      if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
        pTab->aCol[i].notNull = OE_Abort;
      }
    }
    pTab->tabFlags |= TF_HasNotNull;
  }
 
  /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
  ** into BTREE_BLOBKEY.
  */
  if( pParse->addrCrTab ){
    assert( v );
    sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY);
  }
 
  /* Locate the PRIMARY KEY index.  Or, if this table was originally
  ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
  */
  if( pTab->iPKey>=0 ){
    ExprList *pList;
    Token ipkToken;
    sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
    pList = sqlite3ExprListAppend(pParse, 0,
                  sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
    if( pList==0 ) return;
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
    }
    pList->a[0].sortFlags = pParse->iPkSortOrder;
    assert( pParse->pNewTable==pTab );
    pTab->iPKey = -1;
    sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
                       SQLITE_IDXTYPE_PRIMARYKEY);
    if( db->mallocFailed || pParse->nErr ) return;
    pPk = sqlite3PrimaryKeyIndex(pTab);
    assert( pPk->nKeyCol==1 );
  }else{
    pPk = sqlite3PrimaryKeyIndex(pTab);
    assert( pPk!=0 );
 
    /*
    ** Remove all redundant columns from the PRIMARY KEY.  For example, change
    ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)".  Later
    ** code assumes the PRIMARY KEY contains no repeated columns.
    */
    for(i=j=1; i<pPk->nKeyCol; i++){
      if( isDupColumn(pPk, j, pPk, i) ){
        pPk->nColumn--;
      }else{
        testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
        pPk->azColl[j] = pPk->azColl[i];
        pPk->aSortOrder[j] = pPk->aSortOrder[i];
        pPk->aiColumn[j++] = pPk->aiColumn[i];
      }
    }
    pPk->nKeyCol = j;
  }
  assert( pPk!=0 );
  pPk->isCovering = 1;
  if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
  nPk = pPk->nColumn = pPk->nKeyCol;
 
  /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
  ** table entry. This is only required if currently generating VDBE
  ** code for a CREATE TABLE (not when parsing one as part of reading
  ** a database schema).  */
  if( v && pPk->tnum>0 ){
    assert( db->init.busy==0 );
    sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
  }
 
  /* The root page of the PRIMARY KEY is the table root page */
  pPk->tnum = pTab->tnum;
 
  /* Update the in-memory representation of all UNIQUE indices by converting
  ** the final rowid column into one or more columns of the PRIMARY KEY.
  */
  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    int n;
    if( IsPrimaryKeyIndex(pIdx) ) continue;
    for(i=n=0; i<nPk; i++){
      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
        n++;
      }
    }
    if( n==0 ){
      /* This index is a superset of the primary key */
      pIdx->nColumn = pIdx->nKeyCol;
      continue;
    }
    if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
    for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
        pIdx->aiColumn[j] = pPk->aiColumn[i];
        pIdx->azColl[j] = pPk->azColl[i];
        if( pPk->aSortOrder[i] ){
          /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
          pIdx->bAscKeyBug = 1;
        }
        j++;
      }
    }
    assert( pIdx->nColumn>=pIdx->nKeyCol+n );
    assert( pIdx->nColumn>=j );
  }
 
  /* Add all table columns to the PRIMARY KEY index
  */
  nExtra = 0;
  for(i=0; i<pTab->nCol; i++){
    if( !hasColumn(pPk->aiColumn, nPk, i)
     && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
  }
  if( resizeIndexObject(db, pPk, nPk+nExtra) ) return;
  for(i=0, j=nPk; i<pTab->nCol; i++){
    if( !hasColumn(pPk->aiColumn, j, i)
     && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
    ){
      assert( j<pPk->nColumn );
      pPk->aiColumn[j] = i;
      pPk->azColl[j] = sqlite3StrBINARY;
      j++;

References ExprList::a, Table::aCol, Parse::addrCrTab, Index::aiColumn, Index::aSortOrder, Index::azColl, Index::bAscKeyBug, BTREE_BLOBKEY, sqlite3::sqlite3InitInfo::busy, COLFLAG_PRIMKEY, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, hasColumn(), sqlite3::sqlite3InitInfo::imposterTable, IN_RENAME_OBJECT, sqlite3::init, Table::iPKey, Parse::iPkSortOrder, Index::isCovering, isDupColumn(), IsPrimaryKeyIndex, Table::keyConf, sqlite3::mallocFailed, Table::nCol, Index::nColumn, Parse::nErr, Index::nKeyCol, Table::nNVCol, Column::notNull, OE_Abort, OP_Goto, ExprList::ExprList_item::pExpr, Table::pIndex, Parse::pNewTable, Index::pNext, Parse::pVdbe, recomputeColumnsNotIndexed(), resizeIndexObject(), ExprList::ExprList_item::sortFlags, sqlite3CreateIndex(), sqlite3ExprAlloc(), sqlite3ExprListAppend(), sqlite3PrimaryKeyIndex(), sqlite3RenameTokenRemap(), sqlite3StrBINARY, sqlite3TokenInit(), sqlite3VdbeChangeOpcode(), sqlite3VdbeChangeP3(), SQLITE_IDXTYPE_PRIMARYKEY, Table::tabFlags, testcase, TF_HasNotNull, TK_ID, Table::tnum, Index::tnum, Index::uniqNotNull, and Column::zName.

Referenced by sqlite3EndTable().

◆ copyNodeContent()

static void copyNodeContent	(	MemPage *	pFrom,
		MemPage *	pTo,
		int *	pRC )

static

Definition at line 71912 of file sqlite3.c.

                                                                   {
  if( (*pRC)==SQLITE_OK ){
    BtShared * const pBt = pFrom->pBt;
    u8 * const aFrom = pFrom->aData;
    u8 * const aTo = pTo->aData;
    int const iFromHdr = pFrom->hdrOffset;
    int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
    int rc;
    int iData;
 
 
    assert( pFrom->isInit );
    assert( pFrom->nFree>=iToHdr );
    assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
 
    /* Copy the b-tree node content from page pFrom to page pTo. */
    iData = get2byte(&aFrom[iFromHdr+5]);
    memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
    memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
 
    /* Reinitialize page pTo so that the contents of the MemPage structure
    ** match the new data. The initialization of pTo can actually fail under
    ** fairly obscure circumstances, even though it is a copy of initialized
    ** page pFrom.
    */
    pTo->isInit = 0;
    rc = btreeInitPage(pTo);
    if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo);
    if( rc!=SQLITE_OK ){
      *pRC = rc;
      return;
    }
 
    /* If this is an auto-vacuum database, update the pointer-map entries
    ** for any b-tree or overflow pages that pTo now contains the pointers to.

References MemPage::aData, btreeComputeFreeSpace(), btreeInitPage(), MemPage::cellOffset, get2byte, MemPage::hdrOffset, ISAUTOVACUUM, MemPage::isInit, MemPage::nCell, MemPage::nFree, MemPage::pBt, MemPage::pgno, setChildPtrmaps(), SQLITE_OK, and BtShared::usableSize.

Referenced by balance_deeper(), and balance_nonroot().

◆ copyPayload()

static int copyPayload	(	void *	pPayload,
		void *	pBuf,
		int	nByte,
		int	eOp,
		DbPage *	pDbPage )

static

Definition at line 69209 of file sqlite3.c.

 {
  if( eOp ){
    /* Copy data from buffer to page (a write operation) */
    int rc = sqlite3PagerWrite(pDbPage);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    memcpy(pPayload, pBuf, nByte);

References sqlite3PagerWrite(), and SQLITE_OK.

Referenced by accessPayload().

◆ corruptSchema()

static void corruptSchema	(	InitData *	pData,
		const char *	zObj,
		const char *	zExtra )

static

Definition at line 128355 of file sqlite3.c.

 {
  sqlite3 *db = pData->db;
  if( db->mallocFailed ){
    pData->rc = SQLITE_NOMEM_BKPT;
  }else if( pData->pzErrMsg[0]!=0 ){
    /* A error message has already been generated.  Do not overwrite it */
  }else if( pData->mInitFlags & INITFLAG_AlterTable ){
    *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
    pData->rc = SQLITE_ERROR;
  }else if( db->flags & SQLITE_WriteSchema ){
    pData->rc = SQLITE_CORRUPT_BKPT;
  }else{
    char *z;
    if( zObj==0 ) zObj = "?";

References InitData::db, sqlite3::flags, INITFLAG_AlterTable, sqlite3::mallocFailed, InitData::mInitFlags, InitData::pzErrMsg, InitData::rc, sqlite3DbStrDup(), sqlite3MPrintf(), SQLITE_CORRUPT_BKPT, SQLITE_ERROR, SQLITE_NOMEM_BKPT, and SQLITE_WriteSchema.

Referenced by sqlite3InitCallback().

◆ countFinalize()

static void countFinalize ( sqlite3_context * context )

static

Definition at line 118675 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ countInverse()

static void countInverse	(	sqlite3_context *	ctx,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118681 of file sqlite3.c.

                                                   {
  CountCtx *p;
  p = sqlite3_aggregate_context(context, 0);
  sqlite3_result_int64(context, p ? p->n : 0);
}
#ifndef SQLITE_OMIT_WINDOWFUNC
static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
  CountCtx *p;
  p = sqlite3_aggregate_context(ctx, sizeof(*p));
  /* p is always non-NULL since countStep() will have been called first */
  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){

References CountCtx::n, sqlite3_aggregate_context(), and sqlite3_result_int64().

Referenced by sqlite3RegisterBuiltinFunctions().

◆ countLookasideSlots()

static u32 countLookasideSlots ( LookasideSlot * p )

static

Definition at line 21489 of file sqlite3.c.

                                                {
  u32 cnt = 0;
  while( p ){

◆ countStep()

static void countStep	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118659 of file sqlite3.c.

                                                                               {
  CountCtx *p;
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
    p->n++;
  }
 
#ifndef SQLITE_OMIT_DEPRECATED
  /* The sqlite3_aggregate_count() function is deprecated.  But just to make
  ** sure it still operates correctly, verify that its count agrees with our

Referenced by sqlite3RegisterBuiltinFunctions().

◆ createAggContext()

static SQLITE_NOINLINE void * createAggContext	(	sqlite3_context *	p,
		int	nByte )

static

Definition at line 83845 of file sqlite3.c.

                                                                            {
  Mem *pMem = p->pMem;
  assert( (pMem->flags & MEM_Agg)==0 );
  if( nByte<=0 ){
    sqlite3VdbeMemSetNull(pMem);
    pMem->z = 0;
  }else{
    sqlite3VdbeMemClearAndResize(pMem, nByte);
    pMem->flags = MEM_Agg;
    pMem->u.pDef = p->pFunc;

Referenced by sqlite3_aggregate_context().

◆ createCollation()

static int createCollation	(	sqlite3 *	db,
		const char *	zName,
		u8	enc,
		void *	pCtx,
		int()(void , int, const void , int, const void )	xCompare,
		void()(void )	xDel )

static

Definition at line 163588 of file sqlite3.c.

 {
  CollSeq *pColl;
  int enc2;
 
  assert( sqlite3_mutex_held(db->mutex) );
 
  /* If SQLITE_UTF16 is specified as the encoding type, transform this
  ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
  ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
  */
  enc2 = enc;
  testcase( enc2==SQLITE_UTF16 );
  testcase( enc2==SQLITE_UTF16_ALIGNED );
  if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){
    enc2 = SQLITE_UTF16NATIVE;
  }
  if( enc2<SQLITE_UTF8 || enc2>SQLITE_UTF16BE ){
    return SQLITE_MISUSE_BKPT;
  }
 
  /* Check if this call is removing or replacing an existing collation
  ** sequence. If so, and there are active VMs, return busy. If there
  ** are no active VMs, invalidate any pre-compiled statements.
  */
  pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
  if( pColl && pColl->xCmp ){
    if( db->nVdbeActive ){
      sqlite3ErrorWithMsg(db, SQLITE_BUSY,
        "unable to delete/modify collation sequence due to active statements");
      return SQLITE_BUSY;
    }
    sqlite3ExpirePreparedStatements(db, 0);
 
    /* If collation sequence pColl was created directly by a call to
    ** sqlite3_create_collation, and not generated by synthCollSeq(),
    ** then any copies made by synthCollSeq() need to be invalidated.
    ** Also, collation destructor - CollSeq.xDel() - function may need
    ** to be called.
    */
    if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
      CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
      int j;
      for(j=0; j<3; j++){
        CollSeq *p = &aColl[j];
        if( p->enc==pColl->enc ){
          if( p->xDel ){
            p->xDel(p->pUser);
          }
          p->xCmp = 0;
        }
      }
    }
  }
 
  pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
  if( pColl==0 ) return SQLITE_NOMEM_BKPT;
  pColl->xCmp = xCompare;

Referenced by openDatabase().

◆ createFunctionApi()

static int createFunctionApi	(	sqlite3 *	db,
		const char *	zFunc,
		int	nArg,
		int	enc,
		void *	p,
		void()(sqlite3_context , int, sqlite3_value **)	xSFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(sqlite3_context )	xValue,
		void()(sqlite3_context , int, sqlite3_value **)	xInverse,
		void()(void )	xDestroy )

static

Definition at line 162885 of file sqlite3.c.

                                                               :
**
**    sqlite3_create_function()
**    sqlite3_create_function_v2()
**    sqlite3_create_window_function()
*/
static int createFunctionApi(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*),
  void (*xValue)(sqlite3_context*),
  void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
  void(*xDestroy)(void*)
){
  int rc = SQLITE_ERROR;
  FuncDestructor *pArg = 0;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( xDestroy ){
    pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor));
    if( !pArg ){
      sqlite3OomFault(db);
      xDestroy(p);
      goto out;
    }
    pArg->nRef = 0;
    pArg->xDestroy = xDestroy;
    pArg->pUserData = p;
  }
  rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p,
      xSFunc, xStep, xFinal, xValue, xInverse, pArg
  );
  if( pArg && pArg->nRef==0 ){
    assert( rc!=SQLITE_OK );
    xDestroy(p);
    sqlite3_free(pArg);
  }

References sqlite3::mutex, FuncDestructor::nRef, FuncDestructor::pUserData, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3CreateFunc(), sqlite3Malloc(), sqlite3OomFault(), sqlite3SafetyCheckOk(), SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_OK, and FuncDestructor::xDestroy.

Referenced by sqlite3_create_function16(), sqlite3_create_function_v2(), and sqlite3_create_window_function().

◆ createMask()

static void createMask	(	WhereMaskSet *	pMaskSet,
		int	iCursor )

static

Definition at line 145838 of file sqlite3.c.

References ArraySize, WhereMaskSet::ix, and WhereMaskSet::n.

Referenced by sqlite3WhereBegin().

◆ createModule()

static int createModule	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	pModule,
		void *	pAux,
		void()(void )	xDestroy )

static

Definition at line 139658 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
 
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3VtabCreateModule(), SQLITE_OK, and zName.

◆ createTableStmt()

static char * createTableStmt	(	sqlite3 *	db,
		Table *	p )

static

Definition at line 112201 of file sqlite3.c.

                                                   {
  int i, k, n;
  char *zStmt;
  char *zSep, *zSep2, *zEnd;
  Column *pCol;
  n = 0;
  for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
    n += identLength(pCol->zName) + 5;
  }
  n += identLength(p->zName);
  if( n<50 ){
    zSep = "";
    zSep2 = ",";
    zEnd = ")";
  }else{
    zSep = "\n  ";
    zSep2 = ",\n  ";
    zEnd = "\n)";
  }
  n += 35 + 6*p->nCol;
  zStmt = sqlite3DbMallocRaw(0, n);
  if( zStmt==0 ){
    sqlite3OomFault(db);
    return 0;
  }
  sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
  k = sqlite3Strlen30(zStmt);
  identPut(zStmt, &k, p->zName);
  zStmt[k++] = '(';
  for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
    static const char * const azType[] = {
        /* SQLITE_AFF_BLOB    */ "",
        /* SQLITE_AFF_TEXT    */ " TEXT",
        /* SQLITE_AFF_NUMERIC */ " NUM",
        /* SQLITE_AFF_INTEGER */ " INT",
        /* SQLITE_AFF_REAL    */ " REAL"
    };
    int len;
    const char *zType;
 
    sqlite3_snprintf(n-k, &zStmt[k], zSep);
    k += sqlite3Strlen30(&zStmt[k]);
    zSep = zSep2;
    identPut(zStmt, &k, pCol->zName);
    assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
    assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
    testcase( pCol->affinity==SQLITE_AFF_BLOB );
    testcase( pCol->affinity==SQLITE_AFF_TEXT );
    testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
    testcase( pCol->affinity==SQLITE_AFF_INTEGER );
    testcase( pCol->affinity==SQLITE_AFF_REAL );
 
    zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
    len = sqlite3Strlen30(zType);
    assert( pCol->affinity==SQLITE_AFF_BLOB
            || pCol->affinity==sqlite3AffinityType(zType, 0) );
    memcpy(&zStmt[k], zType, len);

References Table::aCol, Column::affinity, ArraySize, identLength(), identPut(), Table::nCol, sqlite3_snprintf(), sqlite3AffinityType(), sqlite3DbMallocRaw(), sqlite3OomFault(), sqlite3Strlen30(), SQLITE_AFF_BLOB, SQLITE_AFF_INTEGER, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, testcase, Column::zName, and Table::zName.

Referenced by sqlite3EndTable().

◆ ctimeFunc()

static void ctimeFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 22852 of file sqlite3.c.

References timeFunc(), and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterDateTimeFunctions().

◆ ctimestampFunc()

static void ctimestampFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 22880 of file sqlite3.c.

References datetimeFunc(), and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterDateTimeFunctions().

◆ cume_distInvFunc()

static void cume_distInvFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151545 of file sqlite3.c.

         {
    p->nTotal++;
  }
}
static void cume_distInvFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){

◆ cume_distStepFunc()

static void cume_distStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151532 of file sqlite3.c.

 {
  struct CallCount *p;
  UNUSED_PARAMETER(nArg); assert( nArg==0 );

References UNUSED_PARAMETER.

◆ cume_distValueFunc()

static void cume_distValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151556 of file sqlite3.c.

151562 {

151563 struct CallCount *p;

◆ databaseIsUnmoved()

static int databaseIsUnmoved ( Pager * pPager )

static

Definition at line 55751 of file sqlite3.c.

                                           {
  int bHasMoved = 0;
  int rc;
 
  if( pPager->tempFile ) return SQLITE_OK;
  if( pPager->dbSize==0 ) return SQLITE_OK;
  assert( pPager->zFilename && pPager->zFilename[0] );
  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
  if( rc==SQLITE_NOTFOUND ){
    /* If the HAS_MOVED file-control is unimplemented, assume that the file
    ** has not been moved.  That is the historical behavior of SQLite: prior to
    ** version 3.8.3, it never checked */

References Pager::dbSize, Pager::fd, sqlite3OsFileControl(), SQLITE_FCNTL_HAS_MOVED, SQLITE_NOTFOUND, SQLITE_OK, SQLITE_READONLY_DBMOVED, Pager::tempFile, and Pager::zFilename.

Referenced by pager_open_journal(), and sqlite3PagerClose().

◆ databaseName()

static const char * databaseName ( const char * zName )

static

Definition at line 165215 of file sqlite3.c.

References zName.

Referenced by sqlite3_filename_journal(), sqlite3_free_filename(), and sqlite3_uri_parameter().

◆ dateFunc()

static void dateFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 22681 of file sqlite3.c.

 {
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];

References computeYMD(), DateTime::D, isDate(), DateTime::M, sqlite3_result_text(), sqlite3_snprintf(), SQLITE_TRANSIENT, and DateTime::Y.

Referenced by cdateFunc(), and sqlite3RegisterDateTimeFunctions().

◆ datetimeError()

static void datetimeError ( DateTime * p )

static

Definition at line 21949 of file sqlite3.c.

Referenced by computeJD().

◆ datetimeFunc()

static void datetimeFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 22642 of file sqlite3.c.

 {
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];
    computeYMD_HMS(&x);

References computeYMD_HMS(), DateTime::D, DateTime::h, isDate(), DateTime::M, DateTime::m, DateTime::s, sqlite3_result_text(), sqlite3_snprintf(), SQLITE_TRANSIENT, and DateTime::Y.

Referenced by ctimestampFunc(), and sqlite3RegisterDateTimeFunctions().

◆ dbMallocRawFinish()

static SQLITE_NOINLINE void * dbMallocRawFinish	(	sqlite3 *	db,
		u64	n )

static

Definition at line 27861 of file sqlite3.c.

                                                                  {
  void *p;
  assert( db!=0 );
  p = sqlite3Malloc(n);

References Lookaside::bDisable, sqlite3::lookaside, MEMTYPE_HEAP, MEMTYPE_LOOKASIDE, sqlite3Malloc(), sqlite3MemdebugSetType, and sqlite3OomFault().

◆ dbReallocFinish()

static SQLITE_NOINLINE void * dbReallocFinish	(	sqlite3 *	db,
		void *	p,
		u64	n )

static

Definition at line 27972 of file sqlite3.c.

                                                                         {
  void *pNew = 0;
  assert( db!=0 );
  assert( p!=0 );
  if( db->mallocFailed==0 ){
    if( isLookaside(db, p) ){
      pNew = sqlite3DbMallocRawNN(db, n);
      if( pNew ){
        memcpy(pNew, p, lookasideMallocSize(db, p));
        sqlite3DbFree(db, p);
      }
    }else{
      assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
      pNew = sqlite3Realloc(p, n);
      if( !pNew ){
        sqlite3OomFault(db);
      }
      sqlite3MemdebugSetType(pNew,

◆ decodeFlags()

static int decodeFlags	(	MemPage *	pPage,
		int	flagByte )

static

Definition at line 66292 of file sqlite3.c.

                                                    {
  BtShared *pBt;     /* A copy of pPage->pBt */
 
  assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  pPage->leaf = (u8)(flagByte>>3);  assert( PTF_LEAF == 1<<3 );
  flagByte &= ~PTF_LEAF;
  pPage->childPtrSize = 4-4*pPage->leaf;
  pPage->xCellSize = cellSizePtr;
  pBt = pPage->pBt;
  if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){
    /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an
    ** interior table b-tree page. */
    assert( (PTF_LEAFDATA|PTF_INTKEY)==5 );
    /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a
    ** leaf table b-tree page. */
    assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 );
    pPage->intKey = 1;
    if( pPage->leaf ){
      pPage->intKeyLeaf = 1;
      pPage->xParseCell = btreeParseCellPtr;
    }else{
      pPage->intKeyLeaf = 0;
      pPage->xCellSize = cellSizePtrNoPayload;
      pPage->xParseCell = btreeParseCellPtrNoPayload;
    }
    pPage->maxLocal = pBt->maxLeaf;
    pPage->minLocal = pBt->minLeaf;
  }else if( flagByte==PTF_ZERODATA ){
    /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an
    ** interior index b-tree page. */
    assert( (PTF_ZERODATA)==2 );
    /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a
    ** leaf index b-tree page. */
    assert( (PTF_ZERODATA|PTF_LEAF)==10 );
    pPage->intKey = 0;
    pPage->intKeyLeaf = 0;
    pPage->xParseCell = btreeParseCellPtrIndex;
    pPage->maxLocal = pBt->maxLocal;
    pPage->minLocal = pBt->minLocal;
  }else{
    /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is

References btreeParseCellPtr(), btreeParseCellPtrIndex(), btreeParseCellPtrNoPayload(), cellSizePtr(), cellSizePtrNoPayload(), MemPage::childPtrSize, MemPage::hdrOffset, MemPage::intKey, MemPage::intKeyLeaf, MemPage::leaf, MemPage::max1bytePayload, BtShared::max1bytePayload, BtShared::maxLeaf, MemPage::maxLocal, BtShared::maxLocal, BtShared::minLeaf, MemPage::minLocal, BtShared::minLocal, BtShared::mutex, MemPage::pBt, MemPage::pgno, PTF_INTKEY, PTF_LEAF, PTF_LEAFDATA, PTF_ZERODATA, sqlite3_mutex_held(), SQLITE_CORRUPT_PAGE, SQLITE_OK, MemPage::xCellSize, and MemPage::xParseCell.

Referenced by btreeInitPage().

◆ decodeIntArray()

static void decodeIntArray	(	char *	zIntArray,
		int	nOut,
		tRowcnt *	aOut,
		LogEst *	aLog,
		Index *	pIndex )

static

Definition at line 109018 of file sqlite3.c.

 {
  char *z = zIntArray;
  int c;
  int i;
  tRowcnt v;
 
#ifdef SQLITE_ENABLE_STAT4
  if( z==0 ) z = "";
#else
  assert( z!=0 );
#endif
  for(i=0; *z && i<nOut; i++){
    v = 0;
    while( (c=z[0])>='0' && c<='9' ){
      v = v*10 + c - '0';
      z++;
    }
#ifdef SQLITE_ENABLE_STAT4
    if( aOut ) aOut[i] = v;
    if( aLog ) aLog[i] = sqlite3LogEst(v);
#else
    assert( aOut==0 );
    UNUSED_PARAMETER(aOut);
    assert( aLog!=0 );
    aLog[i] = sqlite3LogEst(v);
#endif
    if( *z==' ' ) z++;
  }
#ifndef SQLITE_ENABLE_STAT4
  assert( pIndex!=0 ); {
#else
  if( pIndex ){
#endif
    pIndex->bUnordered = 0;
    pIndex->noSkipScan = 0;
    while( z[0] ){
      if( sqlite3_strglob("unordered*", z)==0 ){
        pIndex->bUnordered = 1;
      }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){
        int sz = sqlite3Atoi(z+3);
        if( sz<2 ) sz = 2;
        pIndex->szIdxRow = sqlite3LogEst(sz);
      }else if( sqlite3_strglob("noskipscan*", z)==0 ){
        pIndex->noSkipScan = 1;
      }
#ifdef SQLITE_ENABLE_COSTMULT
      else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){
        pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9));
      }

References Index::bUnordered, Index::noSkipScan, Index::pTable, sqlite3_strglob(), sqlite3Atoi(), sqlite3LogEst(), Index::szIdxRow, and UNUSED_PARAMETER.

Referenced by analysisLoader().

◆ defragmentPage()

static int defragmentPage	(	MemPage *	pPage,
		int	nMaxFrag )

static

Definition at line 65885 of file sqlite3.c.

              : R-44582-60138 SQLite may from time to time reorganize a
** b-tree page so that there are no freeblocks or fragment bytes, all
** unused bytes are contained in the unallocated space region, and all
** cells are packed tightly at the end of the page.
*/
static int defragmentPage(MemPage *pPage, int nMaxFrag){
  int i;                     /* Loop counter */
  int pc;                    /* Address of the i-th cell */
  int hdr;                   /* Offset to the page header */
  int size;                  /* Size of a cell */
  int usableSize;            /* Number of usable bytes on a page */
  int cellOffset;            /* Offset to the cell pointer array */
  int cbrk;                  /* Offset to the cell content area */
  int nCell;                 /* Number of cells on the page */
  unsigned char *data;       /* The page data */
  unsigned char *temp;       /* Temp area for cell content */
  unsigned char *src;        /* Source of content */
  int iCellFirst;            /* First allowable cell index */
  int iCellLast;             /* Last possible cell index */
 
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( pPage->pBt!=0 );
  assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
  assert( pPage->nOverflow==0 );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  temp = 0;
  src = data = pPage->aData;
  hdr = pPage->hdrOffset;
  cellOffset = pPage->cellOffset;
  nCell = pPage->nCell;
  assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB );
  iCellFirst = cellOffset + 2*nCell;
  usableSize = pPage->pBt->usableSize;
 
  /* This block handles pages with two or fewer free blocks and nMaxFrag
  ** or fewer fragmented bytes. In this case it is faster to move the
  ** two (or one) blocks of cells using memmove() and add the required
  ** offsets to each pointer in the cell-pointer array than it is to
  ** reconstruct the entire page.  */
  if( (int)data[hdr+7]<=nMaxFrag ){
    int iFree = get2byte(&data[hdr+1]);
    if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
    if( iFree ){
      int iFree2 = get2byte(&data[iFree]);
      if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
      if( 0==iFree2 || (data[iFree2]==0 && data[iFree2+1]==0) ){
        u8 *pEnd = &data[cellOffset + nCell*2];
        u8 *pAddr;
        int sz2 = 0;
        int sz = get2byte(&data[iFree+2]);
        int top = get2byte(&data[hdr+5]);
        if( top>=iFree ){
          return SQLITE_CORRUPT_PAGE(pPage);
        }
        if( iFree2 ){
          if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage);
          sz2 = get2byte(&data[iFree2+2]);
          if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage);
          memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
          sz += sz2;
        }else if( NEVER(iFree+sz>usableSize) ){
          return SQLITE_CORRUPT_PAGE(pPage);
        }
 
        cbrk = top+sz;
        assert( cbrk+(iFree-top) <= usableSize );
        memmove(&data[cbrk], &data[top], iFree-top);
        for(pAddr=&data[cellOffset]; pAddr<pEnd; pAddr+=2){
          pc = get2byte(pAddr);
          if( pc<iFree ){ put2byte(pAddr, pc+sz); }
          else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
        }
        goto defragment_out;
      }
    }
  }
 
  cbrk = usableSize;
  iCellLast = usableSize - 4;
  for(i=0; i<nCell; i++){
    u8 *pAddr;     /* The i-th cell pointer */
    pAddr = &data[cellOffset + i*2];
    pc = get2byte(pAddr);
    testcase( pc==iCellFirst );
    testcase( pc==iCellLast );
    /* These conditions have already been verified in btreeInitPage()
    ** if PRAGMA cell_size_check=ON.
    */
    if( pc<iCellFirst || pc>iCellLast ){
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    assert( pc>=iCellFirst && pc<=iCellLast );
    size = pPage->xCellSize(pPage, &src[pc]);
    cbrk -= size;
    if( cbrk<iCellFirst || pc+size>usableSize ){
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
    testcase( cbrk+size==usableSize );
    testcase( pc+size==usableSize );
    put2byte(pAddr, cbrk);
    if( temp==0 ){
      int x;
      if( cbrk==pc ) continue;
      temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
      x = get2byte(&data[hdr+5]);
      memcpy(&temp[x], &data[x], (cbrk+size) - x);
      src = temp;
    }
    memcpy(&data[cbrk], &src[pc], size);
  }
  data[hdr+7] = 0;
 
 defragment_out:
  assert( pPage->nFree>=0 );
  if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
    return SQLITE_CORRUPT_PAGE(pPage);
  }
  assert( cbrk>=iCellFirst );
  put2byte(&data[hdr+5], cbrk);

References MemPage::aData, MemPage::cellOffset, CORRUPT_DB, get2byte, MemPage::hdrOffset, BtShared::mutex, MemPage::nCell, NEVER, MemPage::nFree, MemPage::nOverflow, MemPage::pBt, MemPage::pDbPage, BtShared::pPager, put2byte, sqlite3_mutex_held(), sqlite3PagerTempSpace(), SQLITE_CORRUPT_PAGE, SQLITE_MAX_PAGE_SIZE, SQLITE_OK, testcase, BtShared::usableSize, and MemPage::xCellSize.

Referenced by allocateSpace(), and balance_nonroot().

◆ deleteTable()

static void SQLITE_NOINLINE deleteTable	(	sqlite3 *	db,
		Table *	pTable )

static

Definition at line 111051 of file sqlite3.c.

                                                                   {
  Index *pIndex, *pNext;
 
#ifdef SQLITE_DEBUG
  /* Record the number of outstanding lookaside allocations in schema Tables
  ** prior to doing any free() operations. Since schema Tables do not use
  ** lookaside, this number should not change.
  **
  ** If malloc has already failed, it may be that it failed while allocating
  ** a Table object that was going to be marked ephemeral. So do not check
  ** that no lookaside memory is used in this case either. */
  int nLookaside = 0;
  if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
    nLookaside = sqlite3LookasideUsed(db, 0);
  }
#endif
 
  /* Delete all indices associated with this table. */
  for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
    pNext = pIndex->pNext;
    assert( pIndex->pSchema==pTable->pSchema
         || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
    if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
      char *zName = pIndex->zName;
      TESTONLY ( Index *pOld = ) sqlite3HashInsert(
         &pIndex->pSchema->idxHash, zName, 0
      );
      assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
      assert( pOld==pIndex || pOld==0 );
    }
    sqlite3FreeIndex(db, pIndex);
  }
 
  /* Delete any foreign keys attached to this table. */
  sqlite3FkDelete(db, pTable);
 
  /* Delete the Table structure itself.
  */
  sqlite3DeleteColumnNames(db, pTable);
  sqlite3DbFree(db, pTable->zName);
  sqlite3DbFree(db, pTable->zColAff);
  sqlite3SelectDelete(db, pTable->pSelect);
  sqlite3ExprListDelete(db, pTable->pCheck);
#ifndef SQLITE_OMIT_VIRTUALTABLE
  sqlite3VtabClear(db, pTable);

References Schema::idxHash, Index::idxType, IsVirtual, sqlite3::mallocFailed, Table::pCheck, Table::pIndex, sqlite3::pnBytesFreed, Index::pNext, Table::pSchema, Index::pSchema, Table::pSelect, sqlite3DbFree(), sqlite3DeleteColumnNames(), sqlite3ExprListDelete(), sqlite3FkDelete(), sqlite3FreeIndex(), sqlite3HashInsert(), sqlite3LookasideUsed(), sqlite3SelectDelete(), sqlite3VtabClear(), SQLITE_IDXTYPE_APPDEF, Table::tabFlags, TESTONLY, TF_Ephemeral, Table::zColAff, Table::zName, Index::zName, and zName.

◆ dense_rankStepFunc()

static void dense_rankStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151337 of file sqlite3.c.

151347 {

◆ dense_rankValueFunc()

static void dense_rankValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151348 of file sqlite3.c.

                                                      {
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nStep ){

◆ destroyRootPage()

static void destroyRootPage	(	Parse *	pParse,
		int	iTable,
		int	iDb )

static

Definition at line 113228 of file sqlite3.c.

                                                               {
  Vdbe *v = sqlite3GetVdbe(pParse);
  int r1 = sqlite3GetTempReg(pParse);
  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  sqlite3MayAbort(pParse);
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* OP_Destroy stores an in integer r1. If this integer
  ** is non-zero, then it is the root page number of a table moved to
  ** location iTable. The following code modifies the sqlite_schema table to
  ** reflect this.
  **
  ** The "#NNN" in the SQL is a special constant that means whatever value
  ** is in register NNN.  See grammar rules associated with the TK_REGISTER
  ** token for additional information.
  */
  sqlite3NestedParse(pParse,

References sqlite3::aDb, Parse::db, DFLT_SCHEMA_TABLE, OP_Destroy, sqlite3ErrorMsg(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3MayAbort(), sqlite3NestedParse(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp3(), and Db::zDbSName.

Referenced by destroyTable().

◆ destroyTable()

static void destroyTable	(	Parse *	pParse,
		Table *	pTab )

static

Definition at line 113258 of file sqlite3.c.

                                                    {
  /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
  ** is not defined), then it is important to call OP_Destroy on the
  ** table and index root-pages in order, starting with the numerically
  ** largest root-page number. This guarantees that none of the root-pages
  ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
  ** following were coded:
  **
  ** OP_Destroy 4 0
  ** ...
  ** OP_Destroy 5 0
  **
  ** and root page 5 happened to be the largest root-page number in the
  ** database, then root page 5 would be moved to page 4 by the
  ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
  ** a free-list page.
  */
  Pgno iTab = pTab->tnum;
  Pgno iDestroyed = 0;
 
  while( 1 ){
    Index *pIdx;
    Pgno iLargest = 0;
 
    if( iDestroyed==0 || iTab<iDestroyed ){
      iLargest = iTab;
    }
    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
      Pgno iIdx = pIdx->tnum;
      assert( pIdx->pSchema==pTab->pSchema );
      if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
        iLargest = iIdx;
      }
    }
    if( iLargest==0 ){
      return;
    }else{
      int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);

References Parse::db, destroyRootPage(), sqlite3::nDb, Table::pIndex, Index::pNext, Table::pSchema, Index::pSchema, sqlite3SchemaToIndex(), Table::tnum, and Index::tnum.

◆ detachFunc()

static void detachFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 109755 of file sqlite3.c.

                                                                        :
**
**     DETACH DATABASE x
**
**     SELECT sqlite_detach(x)
*/
static void detachFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  const char *zName = (const char *)sqlite3_value_text(argv[0]);
  sqlite3 *db = sqlite3_context_db_handle(context);
  int i;
  Db *pDb = 0;
  HashElem *pEntry;
  char zErr[128];
 
  UNUSED_PARAMETER(NotUsed);
 
  if( zName==0 ) zName = "";
  for(i=0; i<db->nDb; i++){
    pDb = &db->aDb[i];
    if( pDb->pBt==0 ) continue;
    if( sqlite3DbIsNamed(db, i, zName) ) break;
  }
 
  if( i>=db->nDb ){
    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
    goto detach_error;
  }
  if( i<2 ){
    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
    goto detach_error;
  }
  if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
    goto detach_error;
  }
 
  /* If any TEMP triggers reference the schema being detached, move those
  ** triggers to reference the TEMP schema itself. */
  assert( db->aDb[1].pSchema );
  pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
  while( pEntry ){
    Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
    if( pTrig->pTabSchema==pDb->pSchema ){
      pTrig->pTabSchema = pTrig->pSchema;
    }
    pEntry = sqliteHashNext(pEntry);
  }
 
  sqlite3BtreeClose(pDb->pBt);
  pDb->pBt = 0;
  pDb->pSchema = 0;

References sqlite3::aDb, sqlite3::nDb, Db::pBt, Db::pSchema, Trigger::pSchema, Trigger::pTabSchema, sqlite3_context_db_handle(), sqlite3_result_error(), sqlite3_snprintf(), sqlite3_value_text(), sqlite3BtreeClose(), sqlite3BtreeIsInBackup(), sqlite3BtreeIsInReadTrans(), sqlite3CollapseDatabaseArray(), sqlite3DbIsNamed(), sqliteHashData, sqliteHashFirst, sqliteHashNext, Schema::trigHash, UNUSED_PARAMETER, and zName.

Referenced by sqlite3Detach().

◆ disableLookaside()

static void disableLookaside ( Parse * pParse )

static

Definition at line 154288 of file sqlite3.c.

                      { int eType; Expr *pExpr; };
 
/*
** Disable lookaside memory allocation for objects that might be
** shared across database connections.

References FrameBound::eType, and FrameBound::pExpr.

Referenced by yy_reduce().

◆ disableTerm()

static void disableTerm	(	WhereLevel *	pLevel,
		WhereTerm *	pTerm )

static

Definition at line 141812 of file sqlite3.c.

                                                             {
  int nLoop = 0;
  assert( pTerm!=0 );
  while( (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
      && (pLevel->notReady & pTerm->prereqAll)==0
  ){
    if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
      pTerm->wtFlags |= TERM_LIKECOND;
    }else{
      pTerm->wtFlags |= TERM_CODED;
    }
    if( pTerm->iParent<0 ) break;
    pTerm = &pTerm->pWC->a[pTerm->iParent];

References WhereClause::a, EP_FromJoin, ExprHasProperty, WhereLevel::iLeftJoin, WhereTerm::iParent, WhereTerm::nChild, WhereLevel::notReady, WhereTerm::pExpr, WhereTerm::prereqAll, WhereTerm::pWC, TERM_CODED, TERM_LIKE, TERM_LIKECOND, and WhereTerm::wtFlags.

Referenced by codeEqualityTerm().

◆ disconnectAllVtab()

static void disconnectAllVtab ( sqlite3 * db )

static

Definition at line 162142 of file sqlite3.c.

                                          {
#ifndef SQLITE_OMIT_VIRTUALTABLE
  int i;
  HashElem *p;
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Schema *pSchema = db->aDb[i].pSchema;
    if( pSchema ){
      for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
        Table *pTab = (Table *)sqliteHashData(p);
        if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
      }
    }
  }
  for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){
    Module *pMod = (Module *)sqliteHashData(p);
    if( pMod->pEpoTab ){
      sqlite3VtabDisconnect(db, pMod->pEpoTab);
    }
  }

◆ dotlockCheckReservedLock()

static int dotlockCheckReservedLock	(	sqlite3_file *	id,
		int *	pResOut )

static

Definition at line 35776 of file sqlite3.c.

                                                                    {
  int rc = SQLITE_OK;
  int reserved = 0;
  unixFile *pFile = (unixFile*)id;
 
  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
 

References unixFile::h, unixFile::lockingContext, osAccess, OSTRACE, SimulateIOError, SQLITE_IOERR_CHECKRESERVEDLOCK, and SQLITE_OK.

◆ dotlockClose()

static int dotlockClose ( sqlite3_file * id )

static

Definition at line 35910 of file sqlite3.c.

35916 {

◆ dotlockLock()

static int dotlockLock	(	sqlite3_file *	id,
		int	eFileLock )

static

Definition at line 35817 of file sqlite3.c.

                                                         : EXCLUSIVE.
** But we track the other locking levels internally.
*/
static int dotlockLock(sqlite3_file *id, int eFileLock) {
  unixFile *pFile = (unixFile*)id;
  char *zLockFile = (char *)pFile->lockingContext;
  int rc = SQLITE_OK;
 
 
  /* If we have any lock, then the lock file already exists.  All we have
  ** to do is adjust our internal record of the lock level.
  */
  if( pFile->eFileLock > NO_LOCK ){
    pFile->eFileLock = eFileLock;
    /* Always update the timestamp on the old file */
#ifdef HAVE_UTIME
    utime(zLockFile, NULL);
#else
    utimes(zLockFile, NULL);
#endif
    return SQLITE_OK;
  }
 
  /* grab an exclusive lock */
  rc = osMkdir(zLockFile, 0777);
  if( rc<0 ){
    /* failed to open/create the lock directory */
    int tErrno = errno;
    if( EEXIST == tErrno ){
      rc = SQLITE_BUSY;
    } else {
      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
      if( rc!=SQLITE_BUSY ){
        storeLastErrno(pFile, tErrno);
      }
    }
    return rc;

References unixFile::eFileLock, unixFile::lockingContext, NO_LOCK, NULL, osMkdir, SQLITE_BUSY, SQLITE_IOERR_LOCK, SQLITE_OK, sqliteErrorFromPosixError(), and storeLastErrno().

◆ dotlockUnlock()

static int dotlockUnlock	(	sqlite3_file *	id,
		int	eFileLock )

static

Definition at line 35867 of file sqlite3.c.

                                                          {
  unixFile *pFile = (unixFile*)id;
  char *zLockFile = (char *)pFile->lockingContext;
  int rc;
 
  assert( pFile );
  OSTRACE(("UNLOCK  %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
           pFile->eFileLock, osGetpid(0)));
  assert( eFileLock<=SHARED_LOCK );
 
  /* no-op if possible */
  if( pFile->eFileLock==eFileLock ){
    return SQLITE_OK;
  }
 
  /* To downgrade to shared, simply update our internal notion of the
  ** lock state.  No need to mess with the file on disk.
  */
  if( eFileLock==SHARED_LOCK ){
    pFile->eFileLock = SHARED_LOCK;
    return SQLITE_OK;
  }
 
  /* To fully unlock the database, delete the lock file */
  assert( eFileLock==NO_LOCK );
  rc = osRmdir(zLockFile);
  if( rc<0 ){
    int tErrno = errno;
    if( tErrno==ENOENT ){
      rc = SQLITE_OK;
    }else{
      rc = SQLITE_IOERR_UNLOCK;
      storeLastErrno(pFile, tErrno);

References unixFile::eFileLock, unixFile::h, unixFile::lockingContext, NO_LOCK, osGetpid, osRmdir, OSTRACE, SHARED_LOCK, SQLITE_IOERR_UNLOCK, SQLITE_OK, and storeLastErrno().

◆ doubleToInt64()

static SQLITE_NOINLINE i64 doubleToInt64 ( double r )

static

Definition at line 76375 of file sqlite3.c.

                                                  {
#ifdef SQLITE_OMIT_FLOATING_POINT
  /* When floating-point is omitted, double and int64 are the same thing */
  return r;
#else
  /*
  ** Many compilers we encounter do not define constants for the
  ** minimum and maximum 64-bit integers, or they define them
  ** inconsistently.  And many do not understand the "LL" notation.
  ** So we define our own static constants here using nothing
  ** larger than a 32-bit integer constant.
  */
  static const i64 maxInt = LARGEST_INT64;
  static const i64 minInt = SMALLEST_INT64;
 
  if( r<=(double)minInt ){
    return minInt;
  }else if( r>=(double)maxInt ){

References LARGEST_INT64, and SMALLEST_INT64.

◆ doWalCallbacks()

static int doWalCallbacks ( sqlite3 * db )

static

Definition at line 83566 of file sqlite3.c.

                                      {
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_WAL
  int i;
  for(i=0; i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      int nEntry;
      sqlite3BtreeEnter(pBt);
      nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
      sqlite3BtreeLeave(pBt);
      if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){
        rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry);

References sqlite3::aDb, sqlite3::nDb, Db::pBt, sqlite3::pWalArg, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3PagerWalCallback(), SQLITE_OK, sqlite3::xWalCallback, and Db::zDbSName.

Referenced by sqlite3Step().

◆ downgradeAllSharedCacheTableLocks()

static void downgradeAllSharedCacheTableLocks ( Btree * p )

static

Definition at line 64934 of file sqlite3.c.

                                                       {
  BtShared *pBt = p->pBt;
  if( pBt->pWriter==p ){
    BtLock *pLock;
    pBt->pWriter = 0;
    pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);

◆ dropCell()

static void dropCell	(	MemPage *	pPage,
		int	idx,
		int	sz,
		int *	pRC )

static

Definition at line 71128 of file sqlite3.c.

                                                               {
  u32 pc;         /* Offset to cell content of cell being deleted */
  u8 *data;       /* pPage->aData */
  u8 *ptr;        /* Used to move bytes around within data[] */
  int rc;         /* The return code */
  int hdr;        /* Beginning of the header.  0 most pages.  100 page 1 */
 
  if( *pRC ) return;
  assert( idx>=0 && idx<pPage->nCell );
  assert( CORRUPT_DB || sz==cellSize(pPage, idx) );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->nFree>=0 );
  data = pPage->aData;
  ptr = &pPage->aCellIdx[2*idx];
  pc = get2byte(ptr);
  hdr = pPage->hdrOffset;
  testcase( pc==get2byte(&data[hdr+5]) );
  testcase( pc+sz==pPage->pBt->usableSize );
  if( pc+sz > pPage->pBt->usableSize ){
    *pRC = SQLITE_CORRUPT_BKPT;
    return;
  }
  rc = freeSpace(pPage, pc, sz);
  if( rc ){
    *pRC = rc;
    return;
  }
  pPage->nCell--;
  if( pPage->nCell==0 ){
    memset(&data[hdr+1], 0, 4);
    data[hdr+7] = 0;
    put2byte(&data[hdr+5], pPage->pBt->usableSize);
    pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset
                       - pPage->childPtrSize - 8;

References MemPage::aCellIdx, MemPage::aData, MemPage::childPtrSize, CORRUPT_DB, freeSpace(), get2byte, MemPage::hdrOffset, BtShared::mutex, MemPage::nCell, MemPage::nFree, MemPage::pBt, MemPage::pDbPage, put2byte, sqlite3_mutex_held(), SQLITE_CORRUPT_BKPT, testcase, and BtShared::usableSize.

Referenced by balance_nonroot(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ dupedExprNodeSize()

static int dupedExprNodeSize	(	Expr *	p,
		int	flags )

static

Definition at line 100941 of file sqlite3.c.

100947 {

References dupedExprStructSize(), EP_IntValue, ExprHasProperty, ROUND8, sqlite3Strlen30NN, Expr::u, and Expr::zToken.

Referenced by dupedExprSize(), and exprDup().

◆ dupedExprSize()

static int dupedExprSize	(	Expr *	p,
		int	flags )

static

Definition at line 100962 of file sqlite3.c.

                                            {
  int nByte = 0;
  if( p ){
    nByte = dupedExprNodeSize(p, flags);

References dupedExprNodeSize(), dupedExprSize(), EXPRDUP_REDUCE, Expr::pLeft, and Expr::pRight.

Referenced by dupedExprSize(), and exprDup().

◆ dupedExprStructSize()

static int dupedExprStructSize	(	Expr *	p,
		int	flags )

static

Definition at line 100910 of file sqlite3.c.

                                                  {
  int nSize;
  assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
  assert( EXPR_FULLSIZE<=0xfff );
  assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 );
  if( 0==flags || p->op==TK_SELECT_COLUMN
#ifndef SQLITE_OMIT_WINDOWFUNC
   || ExprHasProperty(p, EP_WinFunc)
#endif
  ){
    nSize = EXPR_FULLSIZE;
  }else{
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    assert( !ExprHasProperty(p, EP_FromJoin) );
    assert( !ExprHasProperty(p, EP_MemToken) );
    assert( !ExprHasVVAProperty(p, EP_NoReduce) );
    if( p->pLeft || p->x.pList ){
      nSize = EXPR_REDUCEDSIZE | EP_Reduced;
    }else{

References EP_FromJoin, EP_MemToken, EP_NoReduce, EP_Reduced, EP_TokenOnly, EP_WinFunc, EXPR_FULLSIZE, EXPR_REDUCEDSIZE, EXPR_TOKENONLYSIZE, EXPRDUP_REDUCE, ExprHasProperty, ExprHasVVAProperty, Expr::op, Expr::pLeft, Expr::pList, Expr::pRight, TK_SELECT_COLUMN, and Expr::x.

Referenced by dupedExprNodeSize(), and exprDup().

◆ editPage()

static int editPage	(	MemPage *	pPg,
		int	iOld,
		int	iNew,
		int	nNew,
		CellArray *	pCArray )

static

Definition at line 71629 of file sqlite3.c.

 {
  u8 * const aData = pPg->aData;
  const int hdr = pPg->hdrOffset;
  u8 *pBegin = &pPg->aCellIdx[nNew * 2];
  int nCell = pPg->nCell;       /* Cells stored on pPg */
  u8 *pData;
  u8 *pCellptr;
  int i;
  int iOldEnd = iOld + pPg->nCell + pPg->nOverflow;
  int iNewEnd = iNew + nNew;
 
#ifdef SQLITE_DEBUG
  u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
  memcpy(pTmp, aData, pPg->pBt->usableSize);
#endif
 
  /* Remove cells from the start and end of the page */
  assert( nCell>=0 );
  if( iOld<iNew ){
    int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
    if( NEVER(nShift>nCell) ) return SQLITE_CORRUPT_BKPT;
    memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2);
    nCell -= nShift;
  }
  if( iNewEnd < iOldEnd ){
    int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray);
    assert( nCell>=nTail );
    nCell -= nTail;
  }
 
  pData = &aData[get2byteNotZero(&aData[hdr+5])];
  if( pData<pBegin ) goto editpage_fail;
 
  /* Add cells to the start of the page */
  if( iNew<iOld ){
    int nAdd = MIN(nNew,iOld-iNew);
    assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
    assert( nAdd>=0 );
    pCellptr = pPg->aCellIdx;
    memmove(&pCellptr[nAdd*2], pCellptr, nCell*2);
    if( pageInsertArray(
          pPg, pBegin, &pData, pCellptr,
          iNew, nAdd, pCArray
    ) ) goto editpage_fail;
    nCell += nAdd;
  }
 
  /* Add any overflow cells */
  for(i=0; i<pPg->nOverflow; i++){
    int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
    if( iCell>=0 && iCell<nNew ){
      pCellptr = &pPg->aCellIdx[iCell * 2];
      if( nCell>iCell ){
        memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2);
      }
      nCell++;
      cachedCellSize(pCArray, iCell+iNew);
      if( pageInsertArray(
            pPg, pBegin, &pData, pCellptr,
            iCell+iNew, 1, pCArray
      ) ) goto editpage_fail;
    }
  }
 
  /* Append cells to the end of the page */
  assert( nCell>=0 );
  pCellptr = &pPg->aCellIdx[nCell*2];
  if( pageInsertArray(
        pPg, pBegin, &pData, pCellptr,
        iNew+nCell, nNew-nCell, pCArray
  ) ) goto editpage_fail;
 
  pPg->nCell = nNew;
  pPg->nOverflow = 0;
 
  put2byte(&aData[hdr+3], pPg->nCell);
  put2byte(&aData[hdr+5], pData - aData);
 
#ifdef SQLITE_DEBUG
  for(i=0; i<nNew && !CORRUPT_DB; i++){
    u8 *pCell = pCArray->apCell[i+iNew];
    int iOff = get2byteAligned(&pPg->aCellIdx[i*2]);
    if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
      pCell = &pTmp[pCell - aData];
    }
    assert( 0==memcmp(pCell, &aData[iOff],
            pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) );
  }
#endif
 

References MemPage::aCellIdx, MemPage::aData, MemPage::aiOvfl, CellArray::apCell, cachedCellSize(), CORRUPT_DB, get2byteAligned, get2byteNotZero, MemPage::hdrOffset, MIN, MemPage::nCell, NEVER, MemPage::nOverflow, pageFreeArray(), pageInsertArray(), MemPage::pBt, populateCellCache(), BtShared::pPager, CellArray::pRef, put2byte, rebuildPage(), sqlite3PagerTempSpace(), SQLITE_CORRUPT_BKPT, SQLITE_OK, SQLITE_WITHIN, BtShared::usableSize, and MemPage::xCellSize.

Referenced by balance_nonroot().

◆ enlargeAndAppend()

static void SQLITE_NOINLINE enlargeAndAppend	(	StrAccum *	p,
		const char *	z,
		int	N )

static

Definition at line 29111 of file sqlite3.c.

29117 {

References sqlite3_str::nChar, sqlite3StrAccumEnlarge(), and sqlite3_str::zText.

◆ errlogFunc()

static void errlogFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118009 of file sqlite3.c.

References sqlite3_log(), sqlite3_value_int(), sqlite3_value_text(), and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ estimateIndexWidth()

static void estimateIndexWidth ( Index * pIdx )

static

Definition at line 112307 of file sqlite3.c.

                                           {
  unsigned wIndex = 0;
  int i;
  const Column *aCol = pIdx->pTable->aCol;
  for(i=0; i<pIdx->nColumn; i++){

Referenced by sqlite3CreateIndex(), and sqlite3EndTable().

◆ estimateTableWidth()

static void estimateTableWidth ( Table * pTab )

static

Definition at line 112293 of file sqlite3.c.

                                           {
  unsigned wTable = 0;
  const Column *pTabCol;
  int i;

Referenced by sqlite3EndTable().

◆ estLog()

static LogEst estLog ( LogEst N )

static

Definition at line 146171 of file sqlite3.c.

Referenced by whereLoopAddBtree(), whereLoopAddBtreeIndex(), and whereSortingCost().

◆ et_getdigit()

static char et_getdigit	(	LONGDOUBLE_TYPE *	val,
		int *	cnt )

static

Definition at line 28260 of file sqlite3.c.

             :    *val = 1.4159    function return = '3'
**
** The counter *cnt is incremented each time.  After counter exceeds
** 16 (the number of significant digits in a 64-bit float) '0' is
** always returned.
*/
static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
  int digit;
  LONGDOUBLE_TYPE d;
  if( (*cnt)<=0 ) return '0';
  (*cnt)--;

References digit(), and LONGDOUBLE_TYPE.

Referenced by sqlite3_str_vappendf().

◆ execSql()

static int execSql	(	sqlite3 *	db,
		char **	pzErrMsg,
		const char *	zSql )

static

Definition at line 139196 of file sqlite3.c.

                                                                  {
  sqlite3_stmt *pStmt;
  int rc;
 
  /* printf("SQL: [%s]\n", zSql); fflush(stdout); */
  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ) return rc;
  while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
    const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0);
    assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 );
    /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX,
    ** or INSERT.  Historically there have been attacks that first
    ** corrupt the sqlite_schema.sql field with other kinds of statements
    ** then run VACUUM to get those statements to execute at inappropriate
    ** times. */
    if( zSubSql
     && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0)
    ){
      rc = execSql(db, pzErrMsg, zSubSql);
      if( rc!=SQLITE_OK ) break;
    }
  }
  assert( rc!=SQLITE_ROW );
  if( rc==SQLITE_DONE ) rc = SQLITE_OK;

References execSql(), sqlite3_column_text(), sqlite3_prepare_v2(), sqlite3_step(), sqlite3_strnicmp(), SQLITE_DONE, SQLITE_OK, and SQLITE_ROW.

Referenced by execSql().

◆ execSqlF()

static int execSqlF	(	sqlite3 *	db,
		char **	pzErrMsg,
		const char *	zSql,
			... )

static

Definition at line 139226 of file sqlite3.c.

          {
    sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
  }
  (void)sqlite3_finalize(pStmt);
  return rc;
}
static int execSqlF(sqlite3 *db, char **pzErrMsg, const char *zSql, ...){
  char *z;
  va_list ap;
  int rc;
  va_start(ap, zSql);
  z = sqlite3VMPrintf(db, zSql, ap);

References sqlite3_errmsg(), and sqlite3SetString().

◆ explainAppendTerm()

static void explainAppendTerm	(	StrAccum *	pStr,
		Index *	pIdx,
		int	nTerm,
		int	iTerm,
		int	bAnd,
		const char *	zOp )

static

Definition at line 141559 of file sqlite3.c.

 {
  int i;
 
  assert( nTerm>=1 );
  if( bAnd ) sqlite3_str_append(pStr, " AND ", 5);
 
  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
  for(i=0; i<nTerm; i++){
    if( i ) sqlite3_str_append(pStr, ",", 1);
    sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i));
  }
  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);
 
  sqlite3_str_append(pStr, zOp, 1);
 
  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);

References explainIndexColumnName(), sqlite3_str_append(), and sqlite3_str_appendall().

Referenced by explainIndexRange().

◆ explainIndexColumnName()

static const char * explainIndexColumnName	(	Index *	pIdx,
		int	i )

static

Definition at line 141544 of file sqlite3.c.

References Table::aCol, Index::aiColumn, Index::pTable, XN_EXPR, XN_ROWID, and Column::zName.

Referenced by codeAllEqualityTerms(), explainAppendTerm(), and explainIndexRange().

◆ explainIndexRange()

static void explainIndexRange	(	StrAccum *	pStr,
		WhereLoop *	pLoop )

static

Definition at line 141603 of file sqlite3.c.

                    :
**
**   "a=? AND b>?"
*/
static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){
  Index *pIndex = pLoop->u.btree.pIndex;
  u16 nEq = pLoop->u.btree.nEq;
  u16 nSkip = pLoop->nSkip;
  int i, j;
 
  if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return;
  sqlite3_str_append(pStr, " (", 2);
  for(i=0; i<nEq; i++){
    const char *z = explainIndexColumnName(pIndex, i);
    if( i ) sqlite3_str_append(pStr, " AND ", 5);
    sqlite3_str_appendf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z);
  }
 
  j = i;
  if( pLoop->wsFlags&WHERE_BTM_LIMIT ){
    explainAppendTerm(pStr, pIndex, pLoop->u.btree.nBtm, j, i, ">");
    i = 1;

References WhereLoop::btree, explainAppendTerm(), explainIndexColumnName(), WhereLoop::nBtm, WhereLoop::nEq, WhereLoop::nSkip, WhereLoop::nTop, WhereLoop::pIndex, sqlite3_str_append(), sqlite3_str_appendf(), WhereLoop::u, WHERE_BTM_LIMIT, WHERE_TOP_LIMIT, and WhereLoop::wsFlags.

Referenced by sqlite3WhereExplainOneScan().

◆ explainSimpleCount()

static void explainSimpleCount	(	Parse *	pParse,
		Table *	pTab,
		Index *	pIdx )

static

Definition at line 134849 of file sqlite3.c.

 {
  if( pParse->explain==2 ){
    int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
    sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",

References Parse::explain, HasRowid, IsPrimaryKeyIndex, sqlite3VdbeExplain(), Table::zName, and Index::zName.

Referenced by sqlite3Select().

◆ explainTempTable()

static void explainTempTable	(	Parse *	pParse,
		const char *	zUsage )

static

Definition at line 130701 of file sqlite3.c.

References ExplainQueryPlan.

Referenced by sqlite3Select().

◆ exprAnalyze()

static void exprAnalyze	(	SrcList *	pSrc,
		WhereClause *	pWC,
		int	idxTerm )

static

Definition at line 145018 of file sqlite3.c.

 {
  WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */
  WhereTerm *pTerm;                /* The term to be analyzed */
  WhereMaskSet *pMaskSet;          /* Set of table index masks */
  Expr *pExpr;                     /* The expression to be analyzed */
  Bitmask prereqLeft;              /* Prerequesites of the pExpr->pLeft */
  Bitmask prereqAll;               /* Prerequesites of pExpr */
  Bitmask extraRight = 0;          /* Extra dependencies on LEFT JOIN */
  Expr *pStr1 = 0;                 /* RHS of LIKE/GLOB operator */
  int isComplete = 0;              /* RHS of LIKE/GLOB ends with wildcard */
  int noCase = 0;                  /* uppercase equivalent to lowercase */
  int op;                          /* Top-level operator.  pExpr->op */
  Parse *pParse = pWInfo->pParse;  /* Parsing context */
  sqlite3 *db = pParse->db;        /* Database connection */
  unsigned char eOp2 = 0;          /* op2 value for LIKE/REGEXP/GLOB */
  int nLeft;                       /* Number of elements on left side vector */
 
  if( db->mallocFailed ){
    return;
  }
  pTerm = &pWC->a[idxTerm];
  pMaskSet = &pWInfo->sMaskSet;
  pExpr = pTerm->pExpr;
  assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
  prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
  op = pExpr->op;
  if( op==TK_IN ){
    assert( pExpr->pRight==0 );
    if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
    }else{
      pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
    }
  }else if( op==TK_ISNULL ){
    pTerm->prereqRight = 0;
  }else{
    pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
  }
  pMaskSet->bVarSelect = 0;
  prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
  if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT;
  if( ExprHasProperty(pExpr, EP_FromJoin) ){
    Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
    prereqAll |= x;
    extraRight = x-1;  /* ON clause terms may not be used with an index
                       ** on left table of a LEFT JOIN.  Ticket #3015 */
    if( (prereqAll>>1)>=x ){
      sqlite3ErrorMsg(pParse, "ON clause references tables to its right");
      return;
    }
  }
  pTerm->prereqAll = prereqAll;
  pTerm->leftCursor = -1;
  pTerm->iParent = -1;
  pTerm->eOperator = 0;
  if( allowedOp(op) ){
    int aiCurCol[2];
    Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
    Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
    u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
 
    if( pTerm->iField>0 ){
      assert( op==TK_IN );
      assert( pLeft->op==TK_VECTOR );
      pLeft = pLeft->x.pList->a[pTerm->iField-1].pExpr;
    }
 
    if( exprMightBeIndexed(pSrc, prereqLeft, aiCurCol, pLeft, op) ){
      pTerm->leftCursor = aiCurCol[0];
      pTerm->u.leftColumn = aiCurCol[1];
      pTerm->eOperator = operatorMask(op) & opMask;
    }
    if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
    if( pRight
     && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op)
    ){
      WhereTerm *pNew;
      Expr *pDup;
      u16 eExtraOp = 0;        /* Extra bits for pNew->eOperator */
      assert( pTerm->iField==0 );
      if( pTerm->leftCursor>=0 ){
        int idxNew;
        pDup = sqlite3ExprDup(db, pExpr, 0);
        if( db->mallocFailed ){
          sqlite3ExprDelete(db, pDup);
          return;
        }
        idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);
        if( idxNew==0 ) return;
        pNew = &pWC->a[idxNew];
        markTermAsChild(pWC, idxNew, idxTerm);
        if( op==TK_IS ) pNew->wtFlags |= TERM_IS;
        pTerm = &pWC->a[idxTerm];
        pTerm->wtFlags |= TERM_COPIED;
 
        if( termIsEquivalence(pParse, pDup) ){
          pTerm->eOperator |= WO_EQUIV;
          eExtraOp = WO_EQUIV;
        }
      }else{
        pDup = pExpr;
        pNew = pTerm;
      }
      pNew->wtFlags |= exprCommute(pParse, pDup);
      pNew->leftCursor = aiCurCol[0];
      pNew->u.leftColumn = aiCurCol[1];
      testcase( (prereqLeft | extraRight) != prereqLeft );
      pNew->prereqRight = prereqLeft | extraRight;
      pNew->prereqAll = prereqAll;
      pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
    }
  }
 
#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION
  /* If a term is the BETWEEN operator, create two new virtual terms
  ** that define the range that the BETWEEN implements.  For example:
  **
  **      a BETWEEN b AND c
  **
  ** is converted into:
  **
  **      (a BETWEEN b AND c) AND (a>=b) AND (a<=c)
  **
  ** The two new terms are added onto the end of the WhereClause object.
  ** The new terms are "dynamic" and are children of the original BETWEEN
  ** term.  That means that if the BETWEEN term is coded, the children are
  ** skipped.  Or, if the children are satisfied by an index, the original
  ** BETWEEN term is skipped.
  */
  else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
    ExprList *pList = pExpr->x.pList;
    int i;
    static const u8 ops[] = {TK_GE, TK_LE};
    assert( pList!=0 );
    assert( pList->nExpr==2 );
    for(i=0; i<2; i++){
      Expr *pNewExpr;
      int idxNew;
      pNewExpr = sqlite3PExpr(pParse, ops[i],
                             sqlite3ExprDup(db, pExpr->pLeft, 0),
                             sqlite3ExprDup(db, pList->a[i].pExpr, 0));
      transferJoinMarkings(pNewExpr, pExpr);
      idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
      testcase( idxNew==0 );
      exprAnalyze(pSrc, pWC, idxNew);
      pTerm = &pWC->a[idxTerm];
      markTermAsChild(pWC, idxNew, idxTerm);
    }
  }
#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */
 
#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
  /* Analyze a term that is composed of two or more subterms connected by
  ** an OR operator.
  */
  else if( pExpr->op==TK_OR ){
    assert( pWC->op==TK_AND );
    exprAnalyzeOrTerm(pSrc, pWC, idxTerm);
    pTerm = &pWC->a[idxTerm];
  }
#endif /* SQLITE_OMIT_OR_OPTIMIZATION */
 
#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
  /* Add constraints to reduce the search space on a LIKE or GLOB
  ** operator.
  **
  ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints
  **
  **          x>='ABC' AND x<'abd' AND x LIKE 'aBc%'
  **
  ** The last character of the prefix "abc" is incremented to form the
  ** termination condition "abd".  If case is not significant (the default
  ** for LIKE) then the lower-bound is made all uppercase and the upper-
  ** bound is made all lowercase so that the bounds also work when comparing
  ** BLOBs.
  */
  if( pWC->op==TK_AND
   && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
  ){
    Expr *pLeft;       /* LHS of LIKE/GLOB operator */
    Expr *pStr2;       /* Copy of pStr1 - RHS of LIKE/GLOB operator */
    Expr *pNewExpr1;
    Expr *pNewExpr2;
    int idxNew1;
    int idxNew2;
    const char *zCollSeqName;     /* Name of collating sequence */
    const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC;
 
    pLeft = pExpr->x.pList->a[1].pExpr;
    pStr2 = sqlite3ExprDup(db, pStr1, 0);
 
    /* Convert the lower bound to upper-case and the upper bound to
    ** lower-case (upper-case is less than lower-case in ASCII) so that
    ** the range constraints also work for BLOBs
    */
    if( noCase && !pParse->db->mallocFailed ){
      int i;
      char c;
      pTerm->wtFlags |= TERM_LIKE;
      for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
        pStr1->u.zToken[i] = sqlite3Toupper(c);
        pStr2->u.zToken[i] = sqlite3Tolower(c);
      }
    }
 
    if( !db->mallocFailed ){
      u8 c, *pC;       /* Last character before the first wildcard */
      pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
      c = *pC;
      if( noCase ){
        /* The point is to increment the last character before the first
        ** wildcard.  But if we increment '@', that will push it into the
        ** alphabetic range where case conversions will mess up the
        ** inequality.  To avoid this, make sure to also run the full
        ** LIKE on all candidate expressions by clearing the isComplete flag
        */
        if( c=='A'-1 ) isComplete = 0;
        c = sqlite3UpperToLower[c];
      }
      *pC = c + 1;
    }
    zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY;
    pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
           sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
           pStr1);
    transferJoinMarkings(pNewExpr1, pExpr);
    idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags);
    testcase( idxNew1==0 );
    exprAnalyze(pSrc, pWC, idxNew1);
    pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
           sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName),
           pStr2);
    transferJoinMarkings(pNewExpr2, pExpr);
    idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags);
    testcase( idxNew2==0 );
    exprAnalyze(pSrc, pWC, idxNew2);
    pTerm = &pWC->a[idxTerm];
    if( isComplete ){
      markTermAsChild(pWC, idxNew1, idxTerm);
      markTermAsChild(pWC, idxNew2, idxTerm);
    }
  }
#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Add a WO_AUX auxiliary term to the constraint set if the
  ** current expression is of the form "column OP expr" where OP
  ** is an operator that gets passed into virtual tables but which is
  ** not normally optimized for ordinary tables.  In other words, OP
  ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL.
  ** This information is used by the xBestIndex methods of
  ** virtual tables.  The native query optimizer does not attempt
  ** to do anything with MATCH functions.
  */
  if( pWC->op==TK_AND ){
    Expr *pRight = 0, *pLeft = 0;
    int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
    while( res-- > 0 ){
      int idxNew;
      WhereTerm *pNewTerm;
      Bitmask prereqColumn, prereqExpr;
 
      prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight);
      prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft);
      if( (prereqExpr & prereqColumn)==0 ){
        Expr *pNewExpr;
        pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
            0, sqlite3ExprDup(db, pRight, 0));
        if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
          ExprSetProperty(pNewExpr, EP_FromJoin);
          pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
        }
        idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
        testcase( idxNew==0 );
        pNewTerm = &pWC->a[idxNew];
        pNewTerm->prereqRight = prereqExpr;
        pNewTerm->leftCursor = pLeft->iTable;
        pNewTerm->u.leftColumn = pLeft->iColumn;
        pNewTerm->eOperator = WO_AUX;
        pNewTerm->eMatchOp = eOp2;
        markTermAsChild(pWC, idxNew, idxTerm);
        pTerm = &pWC->a[idxTerm];
        pTerm->wtFlags |= TERM_COPIED;
        pNewTerm->prereqAll = pTerm->prereqAll;
      }
      SWAP(Expr*, pLeft, pRight);
    }
  }
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
  /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create
  ** new terms for each component comparison - "a = ?" and "b = ?".  The
  ** new terms completely replace the original vector comparison, which is
  ** no longer used.
  **
  ** This is only required if at least one side of the comparison operation
  ** is not a sub-select.  */
  if( pWC->op==TK_AND
  && (pExpr->op==TK_EQ || pExpr->op==TK_IS)
  && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
  && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
  && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
    || (pExpr->pRight->flags & EP_xIsSelect)==0)
  ){
    int i;
    for(i=0; i<nLeft; i++){
      int idxNew;
      Expr *pNew;
      Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i);
      Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i);
 
      pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
      transferJoinMarkings(pNew, pExpr);
      idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC);
      exprAnalyze(pSrc, pWC, idxNew);
    }
    pTerm = &pWC->a[idxTerm];
    pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL;  /* Disable the original */
    pTerm->eOperator = 0;
  }
 
  /* If there is a vector IN term - e.g. "(a, b) IN (SELECT ...)" - create
  ** a virtual term for each vector component. The expression object
  ** used by each such virtual term is pExpr (the full vector IN(...)
  ** expression). The WhereTerm.iField variable identifies the index within
  ** the vector on the LHS that the virtual term represents.
  **
  ** This only works if the RHS is a simple SELECT (not a compound) that does
  ** not use window functions.
  */
  if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->iField==0
   && pExpr->pLeft->op==TK_VECTOR
   && pExpr->x.pSelect->pPrior==0
#ifndef SQLITE_OMIT_WINDOWFUNC
   && pExpr->x.pSelect->pWin==0
#endif
  ){
    int i;
    for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
      int idxNew;
      idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL);
      pWC->a[idxNew].iField = i+1;
      exprAnalyze(pSrc, pWC, idxNew);
      markTermAsChild(pWC, idxNew, idxTerm);
    }
  }
 
#ifdef SQLITE_ENABLE_STAT4
  /* When sqlite_stat4 histogram data is available an operator of the
  ** form "x IS NOT NULL" can sometimes be evaluated more efficiently
  ** as "x>NULL" if x is not an INTEGER PRIMARY KEY.  So construct a
  ** virtual term of that form.
  **
  ** Note that the virtual term must be tagged with TERM_VNULL.
  */
  if( pExpr->op==TK_NOTNULL
   && pExpr->pLeft->op==TK_COLUMN
   && pExpr->pLeft->iColumn>=0
   && !ExprHasProperty(pExpr, EP_FromJoin)
   && OptimizationEnabled(db, SQLITE_Stat4)
  ){
    Expr *pNewExpr;
    Expr *pLeft = pExpr->pLeft;
    int idxNew;
    WhereTerm *pNewTerm;
 
    pNewExpr = sqlite3PExpr(pParse, TK_GT,
                            sqlite3ExprDup(db, pLeft, 0),
                            sqlite3ExprAlloc(db, TK_NULL, 0, 0));
 
    idxNew = whereClauseInsert(pWC, pNewExpr,
                              TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
    if( idxNew ){
      pNewTerm = &pWC->a[idxNew];
      pNewTerm->prereqRight = 0;
      pNewTerm->leftCursor = pLeft->iTable;
      pNewTerm->u.leftColumn = pLeft->iColumn;
      pNewTerm->eOperator = WO_GT;
      markTermAsChild(pWC, idxNew, idxTerm);
      pTerm = &pWC->a[idxTerm];
      pTerm->wtFlags |= TERM_COPIED;
      pNewTerm->prereqAll = pTerm->prereqAll;
    }
  }
#endif /* SQLITE_ENABLE_STAT4 */
 
  /* Prevent ON clause terms of a LEFT JOIN from being used to drive

References ExprList::a, WhereClause::a, allowedOp(), WhereMaskSet::bVarSelect, Parse::db, WhereTerm::eMatchOp, WhereTerm::eOperator, EP_FromJoin, EP_xIsSelect, exprAnalyze(), exprAnalyzeOrTerm(), exprCommute(), ExprHasProperty, exprMightBeIndexed(), exprSelectUsage(), ExprSetProperty, Expr::flags, Expr::iColumn, WhereTerm::iField, WhereTerm::iParent, Expr::iRightJoinTable, isAuxiliaryVtabOperator(), isLikeOrGlob(), Expr::iTable, WhereTerm::leftColumn, WhereTerm::leftCursor, sqlite3::mallocFailed, markTermAsChild(), ExprList::nExpr, Expr::op, WhereClause::op, operatorMask(), OptimizationEnabled, ExprList::ExprList_item::pExpr, WhereTerm::pExpr, Expr::pLeft, Expr::pList, WhereInfo::pParse, Select::pPrior, WhereTerm::prereqAll, WhereTerm::prereqRight, Expr::pRight, Expr::pSelect, Select::pWin, WhereClause::pWInfo, WhereInfo::sMaskSet, sqlite3ErrorMsg(), sqlite3ExprAddCollateString(), sqlite3ExprAlloc(), sqlite3ExprCheckIN(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprForVectorField(), sqlite3ExprSkipCollate(), sqlite3ExprVectorSize(), sqlite3PExpr(), sqlite3StrBINARY, sqlite3Strlen30(), sqlite3Tolower, sqlite3Toupper, sqlite3UpperToLower, sqlite3WhereExprListUsage(), sqlite3WhereExprUsage(), sqlite3WhereExprUsageNN(), sqlite3WhereGetMask(), SQLITE_Stat4, SWAP, TERM_CODED, TERM_COPIED, TERM_DYNAMIC, TERM_IS, TERM_LIKE, TERM_LIKEOPT, TERM_VARSELECT, TERM_VIRTUAL, TERM_VNULL, termIsEquivalence(), testcase, TK_AND, TK_AS, TK_BETWEEN, TK_COLLATE, TK_COLUMN, TK_EQ, TK_GE, TK_GT, TK_IN, TK_IS, TK_ISNULL, TK_LE, TK_LT, TK_MATCH, TK_NOTNULL, TK_NULL, TK_OR, TK_VECTOR, transferJoinMarkings(), Expr::u, WhereTerm::u, whereClauseInsert(), WO_ALL, WO_AUX, WO_EQUIV, WO_GT, WhereTerm::wtFlags, Expr::x, and Expr::zToken.

Referenced by exprAnalyze(), exprAnalyzeOrTerm(), sqlite3WhereExprAnalyze(), and whereCombineDisjuncts().

◆ exprAnalyzeOrTerm()

static void exprAnalyzeOrTerm	(	SrcList *	pSrc,
		WhereClause *	pWC,
		int	idxTerm )

static

Definition at line 144618 of file sqlite3.c.

            :
**
** If none of cases 1, 2, or 3 apply, then leave the eOperator set to
** zero.  This term is not useful for search.
*/
static void exprAnalyzeOrTerm(
  SrcList *pSrc,            /* the FROM clause */
  WhereClause *pWC,         /* the complete WHERE clause */
  int idxTerm               /* Index of the OR-term to be analyzed */
){
  WhereInfo *pWInfo = pWC->pWInfo;        /* WHERE clause processing context */
  Parse *pParse = pWInfo->pParse;         /* Parser context */
  sqlite3 *db = pParse->db;               /* Database connection */
  WhereTerm *pTerm = &pWC->a[idxTerm];    /* The term to be analyzed */
  Expr *pExpr = pTerm->pExpr;             /* The expression of the term */
  int i;                                  /* Loop counters */
  WhereClause *pOrWc;       /* Breakup of pTerm into subterms */
  WhereTerm *pOrTerm;       /* A Sub-term within the pOrWc */
  WhereOrInfo *pOrInfo;     /* Additional information associated with pTerm */
  Bitmask chngToIN;         /* Tables that might satisfy case 1 */
  Bitmask indexable;        /* Tables that are indexable, satisfying case 2 */
 
  /*
  ** Break the OR clause into its separate subterms.  The subterms are
  ** stored in a WhereClause structure containing within the WhereOrInfo
  ** object that is attached to the original OR clause term.
  */
  assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
  assert( pExpr->op==TK_OR );
  pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
  if( pOrInfo==0 ) return;
  pTerm->wtFlags |= TERM_ORINFO;
  pOrWc = &pOrInfo->wc;
  memset(pOrWc->aStatic, 0, sizeof(pOrWc->aStatic));
  sqlite3WhereClauseInit(pOrWc, pWInfo);
  sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
  sqlite3WhereExprAnalyze(pSrc, pOrWc);
  if( db->mallocFailed ) return;
  assert( pOrWc->nTerm>=2 );
 
  /*
  ** Compute the set of tables that might satisfy cases 1 or 3.
  */
  indexable = ~(Bitmask)0;
  chngToIN = ~(Bitmask)0;
  for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){
    if( (pOrTerm->eOperator & WO_SINGLE)==0 ){
      WhereAndInfo *pAndInfo;
      assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
      chngToIN = 0;
      pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo));
      if( pAndInfo ){
        WhereClause *pAndWC;
        WhereTerm *pAndTerm;
        int j;
        Bitmask b = 0;
        pOrTerm->u.pAndInfo = pAndInfo;
        pOrTerm->wtFlags |= TERM_ANDINFO;
        pOrTerm->eOperator = WO_AND;
        pAndWC = &pAndInfo->wc;
        memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic));
        sqlite3WhereClauseInit(pAndWC, pWC->pWInfo);
        sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
        sqlite3WhereExprAnalyze(pSrc, pAndWC);
        pAndWC->pOuter = pWC;
        if( !db->mallocFailed ){
          for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
            assert( pAndTerm->pExpr );
            if( allowedOp(pAndTerm->pExpr->op)
             || pAndTerm->eOperator==WO_AUX
            ){
              b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor);
            }
          }
        }
        indexable &= b;
      }
    }else if( pOrTerm->wtFlags & TERM_COPIED ){
      /* Skip this term for now.  We revisit it when we process the
      ** corresponding TERM_VIRTUAL term */
    }else{
      Bitmask b;
      b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor);
      if( pOrTerm->wtFlags & TERM_VIRTUAL ){
        WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
        b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor);
      }
      indexable &= b;
      if( (pOrTerm->eOperator & WO_EQ)==0 ){
        chngToIN = 0;
      }else{
        chngToIN &= b;
      }
    }
  }
 
  /*
  ** Record the set of tables that satisfy case 3.  The set might be
  ** empty.
  */
  pOrInfo->indexable = indexable;
  if( indexable ){
    pTerm->eOperator = WO_OR;
    pWC->hasOr = 1;
  }else{
    pTerm->eOperator = WO_OR;
  }
 
  /* For a two-way OR, attempt to implementation case 2.
  */
  if( indexable && pOrWc->nTerm==2 ){
    int iOne = 0;
    WhereTerm *pOne;
    while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){
      int iTwo = 0;
      WhereTerm *pTwo;
      while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){
        whereCombineDisjuncts(pSrc, pWC, pOne, pTwo);
      }
    }
  }
 
  /*
  ** chngToIN holds a set of tables that *might* satisfy case 1.  But
  ** we have to do some additional checking to see if case 1 really
  ** is satisfied.
  **
  ** chngToIN will hold either 0, 1, or 2 bits.  The 0-bit case means
  ** that there is no possibility of transforming the OR clause into an
  ** IN operator because one or more terms in the OR clause contain
  ** something other than == on a column in the single table.  The 1-bit
  ** case means that every term of the OR clause is of the form
  ** "table.column=expr" for some single table.  The one bit that is set
  ** will correspond to the common table.  We still need to check to make
  ** sure the same column is used on all terms.  The 2-bit case is when
  ** the all terms are of the form "table1.column=table2.column".  It
  ** might be possible to form an IN operator with either table1.column
  ** or table2.column as the LHS if either is common to every term of
  ** the OR clause.
  **
  ** Note that terms of the form "table.column1=table.column2" (the
  ** same table on both sizes of the ==) cannot be optimized.
  */
  if( chngToIN ){
    int okToChngToIN = 0;     /* True if the conversion to IN is valid */
    int iColumn = -1;         /* Column index on lhs of IN operator */
    int iCursor = -1;         /* Table cursor common to all terms */
    int j = 0;                /* Loop counter */
 
    /* Search for a table and column that appears on one side or the
    ** other of the == operator in every subterm.  That table and column
    ** will be recorded in iCursor and iColumn.  There might not be any
    ** such table and column.  Set okToChngToIN if an appropriate table
    ** and column is found but leave okToChngToIN false if not found.
    */
    for(j=0; j<2 && !okToChngToIN; j++){
      Expr *pLeft = 0;
      pOrTerm = pOrWc->a;
      for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
        assert( pOrTerm->eOperator & WO_EQ );
        pOrTerm->wtFlags &= ~TERM_OR_OK;
        if( pOrTerm->leftCursor==iCursor ){
          /* This is the 2-bit case and we are on the second iteration and
          ** current term is from the first iteration.  So skip this term. */
          assert( j==1 );
          continue;
        }
        if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet,
                                            pOrTerm->leftCursor))==0 ){
          /* This term must be of the form t1.a==t2.b where t2 is in the
          ** chngToIN set but t1 is not.  This term will be either preceded
          ** or follwed by an inverted copy (t2.b==t1.a).  Skip this term
          ** and use its inversion. */
          testcase( pOrTerm->wtFlags & TERM_COPIED );
          testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
          assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
          continue;
        }
        iColumn = pOrTerm->u.leftColumn;
        iCursor = pOrTerm->leftCursor;
        pLeft = pOrTerm->pExpr->pLeft;
        break;
      }
      if( i<0 ){
        /* No candidate table+column was found.  This can only occur
        ** on the second iteration */
        assert( j==1 );
        assert( IsPowerOfTwo(chngToIN) );
        assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) );
        break;
      }
      testcase( j==1 );
 
      /* We have found a candidate table and column.  Check to see if that
      ** table and column is common to every term in the OR clause */
      okToChngToIN = 1;
      for(; i>=0 && okToChngToIN; i--, pOrTerm++){
        assert( pOrTerm->eOperator & WO_EQ );
        if( pOrTerm->leftCursor!=iCursor ){
          pOrTerm->wtFlags &= ~TERM_OR_OK;
        }else if( pOrTerm->u.leftColumn!=iColumn || (iColumn==XN_EXPR
               && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
        )){
          okToChngToIN = 0;
        }else{
          int affLeft, affRight;
          /* If the right-hand side is also a column, then the affinities
          ** of both right and left sides must be such that no type
          ** conversions are required on the right.  (Ticket #2249)
          */
          affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
          affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
          if( affRight!=0 && affRight!=affLeft ){
            okToChngToIN = 0;
          }else{
            pOrTerm->wtFlags |= TERM_OR_OK;
          }
        }
      }
    }
 
    /* At this point, okToChngToIN is true if original pTerm satisfies
    ** case 1.  In that case, construct a new virtual term that is
    ** pTerm converted into an IN operator.
    */
    if( okToChngToIN ){
      Expr *pDup;            /* A transient duplicate expression */
      ExprList *pList = 0;   /* The RHS of the IN operator */
      Expr *pLeft = 0;       /* The LHS of the IN operator */
      Expr *pNew;            /* The complete IN operator */
 
      for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
        if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue;
        assert( pOrTerm->eOperator & WO_EQ );
        assert( pOrTerm->leftCursor==iCursor );
        assert( pOrTerm->u.leftColumn==iColumn );
        pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
        pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
        pLeft = pOrTerm->pExpr->pLeft;
      }
      assert( pLeft!=0 );
      pDup = sqlite3ExprDup(db, pLeft, 0);
      pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0);
      if( pNew ){
        int idxNew;
        transferJoinMarkings(pNew, pExpr);
        assert( !ExprHasProperty(pNew, EP_xIsSelect) );
        pNew->x.pList = pList;
        idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
        testcase( idxNew==0 );
        exprAnalyze(pSrc, pWC, idxNew);
        /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where used again */
        markTermAsChild(pWC, idxNew, idxTerm);

References WhereClause::a, allowedOp(), WhereClause::aStatic, Parse::db, WhereTerm::eOperator, EP_xIsSelect, exprAnalyze(), ExprHasProperty, WhereClause::hasOr, WhereOrInfo::indexable, WhereTerm::iParent, IsPowerOfTwo, WhereTerm::leftColumn, WhereTerm::leftCursor, sqlite3::mallocFailed, markTermAsChild(), WhereClause::nTerm, Expr::op, WhereTerm::pAndInfo, WhereTerm::pExpr, Expr::pLeft, Expr::pList, WhereTerm::pOrInfo, WhereClause::pOuter, WhereInfo::pParse, Expr::pRight, WhereClause::pWInfo, WhereInfo::sMaskSet, sqlite3DbMallocRawNN(), sqlite3DbMallocZero(), sqlite3ExprAffinity(), sqlite3ExprCompare(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListDelete(), sqlite3PExpr(), sqlite3WhereClauseInit(), sqlite3WhereExprAnalyze(), sqlite3WhereGetMask(), sqlite3WhereSplit(), TERM_ANDINFO, TERM_COPIED, TERM_DYNAMIC, TERM_OR_OK, TERM_ORINFO, TERM_VIRTUAL, testcase, TK_AND, TK_IN, TK_OR, transferJoinMarkings(), WhereTerm::u, WhereOrInfo::wc, WhereAndInfo::wc, whereClauseInsert(), whereCombineDisjuncts(), whereNthSubterm(), WO_AND, WO_AUX, WO_EQ, WO_OR, WO_SINGLE, WhereTerm::wtFlags, Expr::x, and XN_EXPR.

Referenced by exprAnalyze().

◆ exprCodeBetween()

static void exprCodeBetween	(	Parse *	pParse,
		Expr *	pExpr,
		int	dest,
		void()(Parse , Expr *, int, int)	xJump,
		int	jumpIfNull )

static

Definition at line 104481 of file sqlite3.c.

          :                   Store the boolean result in reg[dest]
**    sqlite3ExprIfTrue:      Jump to dest if true
**    sqlite3ExprIfFalse:     Jump to dest if false
**
** The jumpIfNull parameter is ignored if xJumpIf is NULL.
*/
static void exprCodeBetween(
  Parse *pParse,    /* Parsing and code generating context */
  Expr *pExpr,      /* The BETWEEN expression */
  int dest,         /* Jump destination or storage location */
  void (*xJump)(Parse*,Expr*,int,int), /* Action to take */
  int jumpIfNull    /* Take the jump if the BETWEEN is NULL */
){
  Expr exprAnd;     /* The AND operator in  x>=y AND x<=z  */
  Expr compLeft;    /* The  x>=y  term */
  Expr compRight;   /* The  x<=z  term */
  int regFree1 = 0; /* Temporary use register */
  Expr *pDel = 0;
  sqlite3 *db = pParse->db;
 
  memset(&compLeft, 0, sizeof(Expr));
  memset(&compRight, 0, sizeof(Expr));
  memset(&exprAnd, 0, sizeof(Expr));
 
  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
  pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
  if( db->mallocFailed==0 ){
    exprAnd.op = TK_AND;
    exprAnd.pLeft = &compLeft;
    exprAnd.pRight = &compRight;
    compLeft.op = TK_GE;
    compLeft.pLeft = pDel;
    compLeft.pRight = pExpr->x.pList->a[0].pExpr;
    compRight.op = TK_LE;
    compRight.pLeft = pDel;
    compRight.pRight = pExpr->x.pList->a[1].pExpr;
    exprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
    if( xJump ){
      xJump(pParse, &exprAnd, dest, jumpIfNull);
    }else{
      /* Mark the expression is being from the ON or USING clause of a join
      ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
      ** it into the Parse.pConstExpr list.  We should use a new bit for this,
      ** for clarity, but we are out of bits in the Expr.flags field so we
      ** have to reuse the EP_FromJoin bit.  Bummer. */
      pDel->flags |= EP_FromJoin;
      sqlite3ExprCodeTarget(pParse, &exprAnd, dest);
    }
    sqlite3ReleaseTempReg(pParse, regFree1);
  }
  sqlite3ExprDelete(db, pDel);
 
  /* Ensure adequate test coverage */
  testcase( xJump==sqlite3ExprIfTrue  && jumpIfNull==0 && regFree1==0 );
  testcase( xJump==sqlite3ExprIfTrue  && jumpIfNull==0 && regFree1!=0 );
  testcase( xJump==sqlite3ExprIfTrue  && jumpIfNull!=0 && regFree1==0 );
  testcase( xJump==sqlite3ExprIfTrue  && jumpIfNull!=0 && regFree1!=0 );

References ExprList::a, Parse::db, EP_FromJoin, EP_xIsSelect, exprCodeVector(), ExprHasProperty, exprToRegister(), Expr::flags, sqlite3::mallocFailed, Expr::op, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, sqlite3ExprCodeTarget(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ReleaseTempReg(), testcase, TK_AND, TK_GE, TK_LE, and Expr::x.

Referenced by sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ exprCodeInlineFunction()

static int exprCodeInlineFunction	(	Parse *	pParse,
		ExprList *	pFarg,
		int	iFuncId,
		int	target )

static

Definition at line 103386 of file sqlite3.c.

 {
  int nFarg;
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  assert( pFarg!=0 );
  nFarg = pFarg->nExpr;
  assert( nFarg>0 );  /* All in-line functions have at least one argument */
  switch( iFuncId ){
    case INLINEFUNC_coalesce: {
      /* Attempt a direct implementation of the built-in COALESCE() and
      ** IFNULL() functions.  This avoids unnecessary evaluation of
      ** arguments past the first non-NULL argument.
      */
      int endCoalesce = sqlite3VdbeMakeLabel(pParse);
      int i;
      assert( nFarg>=2 );
      sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
      for(i=1; i<nFarg; i++){
        sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
        VdbeCoverage(v);
        sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
      }
      setDoNotMergeFlagOnCopy(v);
      sqlite3VdbeResolveLabel(v, endCoalesce);
      break;
    }
    case INLINEFUNC_iif: {
      Expr caseExpr;
      memset(&caseExpr, 0, sizeof(caseExpr));
      caseExpr.op = TK_CASE;
      caseExpr.x.pList = pFarg;
      return sqlite3ExprCodeTarget(pParse, &caseExpr, target);
    }
 
    default: {
      /* The UNLIKELY() function is a no-op.  The result is the value
      ** of the first argument.
      */
      assert( nFarg==1 || nFarg==2 );
      target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
      break;
    }
 
  /***********************************************************************
  ** Test-only SQL functions that are only usable if enabled
  ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
  */
    case INLINEFUNC_expr_compare: {
      /* Compare two expressions using sqlite3ExprCompare() */
      assert( nFarg==2 );
      sqlite3VdbeAddOp2(v, OP_Integer,
         sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
         target);
      break;
    }
 
    case INLINEFUNC_expr_implies_expr: {
      /* Compare two expressions using sqlite3ExprImpliesExpr() */
      assert( nFarg==2 );
      sqlite3VdbeAddOp2(v, OP_Integer,
         sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
         target);
      break;
    }
 
    case INLINEFUNC_implies_nonnull_row: {
      /* REsult of sqlite3ExprImpliesNonNullRow() */
      Expr *pA1;
      assert( nFarg==2 );
      pA1 = pFarg->a[1].pExpr;
      if( pA1->op==TK_COLUMN ){
        sqlite3VdbeAddOp2(v, OP_Integer,
           sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable),
           target);
      }else{
        sqlite3VdbeAddOp2(v, OP_Null, 0, target);
      }
      break;
    }
 
#ifdef SQLITE_DEBUG
    case INLINEFUNC_affinity: {
      /* The AFFINITY() function evaluates to a string that describes
      ** the type affinity of the argument.  This is used for testing of
      ** the SQLite type logic.
      */
      const char *azAff[] = { "blob", "text", "numeric", "integer", "real" };
      char aff;
      assert( nFarg==1 );
      aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
      sqlite3VdbeLoadString(v, target,
              (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]);

Referenced by sqlite3ExprCodeTarget().

◆ exprCodeSubselect()

static int exprCodeSubselect	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 100233 of file sqlite3.c.

                                                        {
  int reg = 0;
#ifndef SQLITE_OMIT_SUBQUERY

References Expr::op, sqlite3CodeSubselect(), and TK_SELECT.

Referenced by codeVectorCompare().

◆ exprCodeVector()

static int exprCodeVector	(	Parse *	pParse,
		Expr *	p,
		int *	piToFree )

static

Definition at line 103347 of file sqlite3.c.

                                                                  {
  int iResult;
  int nResult = sqlite3ExprVectorSize(p);
  if( nResult==1 ){
    iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable);
  }else{
    *piFreeable = 0;
    if( p->op==TK_SELECT ){
#if SQLITE_OMIT_SUBQUERY
      iResult = 0;
#else
      iResult = sqlite3CodeSubselect(pParse, p);
#endif
    }else{
      int i;
      iResult = pParse->nMem+1;
      pParse->nMem += nResult;
      for(i=0; i<nResult; i++){

References ExprList::a, Parse::nMem, Expr::op, ExprList::ExprList_item::pExpr, Expr::pList, sqlite3CodeSubselect(), sqlite3ExprCodeFactorable(), sqlite3ExprCodeTemp(), sqlite3ExprVectorSize(), TK_SELECT, and Expr::x.

Referenced by exprCodeBetween(), sqlite3ExprCodeIN(), and sqlite3ExprCodeTarget().

◆ exprColumnFlagUnion()

static int exprColumnFlagUnion	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 120754 of file sqlite3.c.

120760 {

Referenced by sqlite3ComputeGeneratedColumns().

◆ exprCommute()

static u16 exprCommute	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 144103 of file sqlite3.c.

                                                  {
  if( pExpr->pLeft->op==TK_VECTOR
   || pExpr->pRight->op==TK_VECTOR
   || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
      sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
  ){
    pExpr->flags ^= EP_Commuted;
  }
  SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
  if( pExpr->op>=TK_GT ){
    assert( TK_LT==TK_GT+2 );
    assert( TK_GE==TK_LE+2 );
    assert( TK_GT>TK_EQ );

Referenced by exprAnalyze().

◆ exprCompareVariable()

static int exprCompareVariable	(	Parse *	pParse,
		Expr *	pVar,
		Expr *	pExpr )

static

Definition at line 104889 of file sqlite3.c.

                                                                      {
  int res = 0;
  int iVar;
  sqlite3_value *pL, *pR = 0;
 
  sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
  if( pR ){
    iVar = pVar->iColumn;
    sqlite3VdbeSetVarmask(pParse->pVdbe, iVar);
    pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB);
    if( pL ){
      if( sqlite3_value_type(pL)==SQLITE_TEXT ){
        sqlite3_value_text(pL); /* Make sure the encoding is UTF-8 */
      }
      res =  0==sqlite3MemCompare(pL, pR, 0);
    }

References Parse::db, Expr::iColumn, Parse::pReprepare, Parse::pVdbe, sqlite3_value_text(), sqlite3_value_type(), sqlite3MemCompare(), sqlite3ValueFree(), sqlite3ValueFromExpr(), sqlite3VdbeGetBoundValue(), sqlite3VdbeSetVarmask(), SQLITE_AFF_BLOB, SQLITE_TEXT, and SQLITE_UTF8.

Referenced by sqlite3ExprCompare().

◆ exprDup()

static Expr * exprDup	(	sqlite3 *	db,
		Expr *	p,
		int	dupFlags,
		u8 **	pzBuffer )

static

Definition at line 100981 of file sqlite3.c.

                                                                       {
  Expr *pNew;           /* Value to return */
  u8 *zAlloc;           /* Memory space from which to build Expr object */
  u32 staticFlag;       /* EP_Static if space not obtained from malloc */
 
  assert( db!=0 );
  assert( p );
  assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE );
  assert( pzBuffer==0 || dupFlags==EXPRDUP_REDUCE );
 
  /* Figure out where to write the new Expr structure. */
  if( pzBuffer ){
    zAlloc = *pzBuffer;
    staticFlag = EP_Static;
  }else{
    zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags));
    staticFlag = 0;
  }
  pNew = (Expr *)zAlloc;
 
  if( pNew ){
    /* Set nNewSize to the size allocated for the structure pointed to
    ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
    ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
    ** by the copy of the p->u.zToken string (if any).
    */
    const unsigned nStructSize = dupedExprStructSize(p, dupFlags);
    const int nNewSize = nStructSize & 0xfff;
    int nToken;
    if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
      nToken = sqlite3Strlen30(p->u.zToken) + 1;
    }else{
      nToken = 0;
    }
    if( dupFlags ){
      assert( ExprHasProperty(p, EP_Reduced)==0 );
      memcpy(zAlloc, p, nNewSize);
    }else{
      u32 nSize = (u32)exprStructSize(p);
      memcpy(zAlloc, p, nSize);
      if( nSize<EXPR_FULLSIZE ){
        memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
      }
    }
 
    /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
    pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static|EP_MemToken);
    pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
    pNew->flags |= staticFlag;
    ExprClearVVAProperties(pNew);
    if( dupFlags ){
      ExprSetVVAProperty(pNew, EP_Immutable);
    }
 
    /* Copy the p->u.zToken string, if any. */
    if( nToken ){
      char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
      memcpy(zToken, p->u.zToken, nToken);
    }
 
    if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){
      /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
      if( ExprHasProperty(p, EP_xIsSelect) ){
        pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags);
      }else{
        pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags);
      }
    }
 
    /* Fill in pNew->pLeft and pNew->pRight. */
    if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){
      zAlloc += dupedExprNodeSize(p, dupFlags);
      if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){
        pNew->pLeft = p->pLeft ?
                      exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc) : 0;
        pNew->pRight = p->pRight ?
                       exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc) : 0;
      }
#ifndef SQLITE_OMIT_WINDOWFUNC
      if( ExprHasProperty(p, EP_WinFunc) ){
        pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin);
        assert( ExprHasProperty(pNew, EP_WinFunc) );
      }
#endif /* SQLITE_OMIT_WINDOWFUNC */
      if( pzBuffer ){
        *pzBuffer = zAlloc;
      }
    }else{
      if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
        if( pNew->op==TK_SELECT_COLUMN ){
          pNew->pLeft = p->pLeft;
          assert( p->iColumn==0 || p->pRight==0 );
          assert( p->pRight==0  || p->pRight==p->pLeft );
        }else{
          pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
        }

References dupedExprNodeSize(), dupedExprSize(), dupedExprStructSize(), EP_Immutable, EP_IntValue, EP_Leaf, EP_MemToken, EP_Reduced, EP_Static, EP_TokenOnly, EP_WinFunc, EP_xIsSelect, EXPR_FULLSIZE, ExprClearVVAProperties, exprDup(), EXPRDUP_REDUCE, ExprHasProperty, ExprSetVVAProperty, exprStructSize(), Expr::flags, Expr::iColumn, Expr::op, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pSelect, Expr::pWin, sqlite3DbMallocRawNN(), sqlite3ExprDup(), sqlite3ExprListDup(), sqlite3SelectDup(), sqlite3Strlen30(), sqlite3WindowDup(), TK_SELECT_COLUMN, Expr::u, Expr::x, Expr::y, and Expr::zToken.

Referenced by exprDup(), and sqlite3ExprListDup().

◆ exprIdxCover()

static int exprIdxCover	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 105323 of file sqlite3.c.

                                                     {
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pWalker->u.pIdxCover->iCur
   && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0

References Walker::eCode, Expr::iColumn, IdxCover::iCur, Expr::iTable, Expr::op, IdxCover::pIdx, Walker::pIdxCover, sqlite3TableColumnToIndex(), TK_COLUMN, Walker::u, WRC_Abort, and WRC_Continue.

Referenced by sqlite3ExprCoveredByIndex().

◆ exprImpliesNotNull()

static int exprImpliesNotNull	(	Parse *	pParse,
		Expr *	p,
		Expr *	pNN,
		int	iTab,
		int	seenNot )

static

Definition at line 105057 of file sqlite3.c.

 {
  assert( p );
  assert( pNN );
  if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){
    return pNN->op!=TK_NULL;
  }
  switch( p->op ){
    case TK_IN: {
      if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0;
      assert( ExprHasProperty(p,EP_xIsSelect)
           || (p->x.pList!=0 && p->x.pList->nExpr>0) );
      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
    }
    case TK_BETWEEN: {
      ExprList *pList = p->x.pList;
      assert( pList!=0 );
      assert( pList->nExpr==2 );
      if( seenNot ) return 0;
      if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
       || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
      ){
        return 1;
      }
      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
    }
    case TK_EQ:
    case TK_NE:
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE:
    case TK_PLUS:
    case TK_MINUS:
    case TK_BITOR:
    case TK_LSHIFT:
    case TK_RSHIFT:
    case TK_CONCAT:
      seenNot = 1;
      /* no break */ deliberate_fall_through
    case TK_STAR:
    case TK_REM:
    case TK_BITAND:
    case TK_SLASH: {
      if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1;
      /* no break */ deliberate_fall_through
    }
    case TK_SPAN:
    case TK_COLLATE:
    case TK_UPLUS:
    case TK_UMINUS: {
      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot);
    }
    case TK_TRUTH: {
      if( seenNot ) return 0;
      if( p->op2!=TK_IS ) return 0;
      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
    }
    case TK_BITNOT:

References ExprList::a, deliberate_fall_through, EP_xIsSelect, ExprHasProperty, exprImpliesNotNull(), ExprList::nExpr, Expr::op, Expr::op2, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, sqlite3ExprCompare(), TK_BETWEEN, TK_BITAND, TK_BITNOT, TK_BITOR, TK_COLLATE, TK_CONCAT, TK_EQ, TK_GE, TK_GT, TK_IN, TK_IS, TK_LE, TK_LSHIFT, TK_LT, TK_MINUS, TK_NE, TK_NOT, TK_NULL, TK_PLUS, TK_REM, TK_RSHIFT, TK_SLASH, TK_SPAN, TK_STAR, TK_TRUTH, TK_UMINUS, TK_UPLUS, and Expr::x.

Referenced by exprImpliesNotNull(), and sqlite3ExprImpliesExpr().

◆ exprINAffinity()

static char * exprINAffinity	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 102452 of file sqlite3.c.

                                                       {
  Expr *pLeft = pExpr->pLeft;
  int nVal = sqlite3ExprVectorSize(pLeft);
  Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
  char *zRet;
 
  assert( pExpr->op==TK_IN );
  zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
  if( zRet ){
    int i;
    for(i=0; i<nVal; i++){
      Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
      char a = sqlite3ExprAffinity(pA);
      if( pSelect ){
        zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
      }else{
        zRet[i] = a;

References ExprList::a, Parse::db, EP_xIsSelect, Expr::flags, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pSelect, sqlite3CompareAffinity(), sqlite3DbMallocRaw(), sqlite3ExprAffinity(), sqlite3ExprVectorSize(), sqlite3VectorFieldSubexpr(), TK_IN, and Expr::x.

Referenced by sqlite3CodeRhsOfIN(), and sqlite3ExprCodeIN().

◆ exprIsConst()

static int exprIsConst	(	Expr *	p,
		int	initFlag,
		int	iCur )

static

Definition at line 101782 of file sqlite3.c.

           :
      testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
      testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
      return WRC_Continue;
  }
}
static int exprIsConst(Expr *p, int initFlag, int iCur){
  Walker w;
  w.eCode = initFlag;
  w.xExprCallback = exprNodeIsConstant;
  w.xSelectCallback = sqlite3SelectWalkFail;
#ifdef SQLITE_DEBUG

Referenced by sqlite3ExprIsConstant(), sqlite3ExprIsConstantNotJoin(), sqlite3ExprIsConstantOrFunction(), and sqlite3ExprIsTableConstant().

◆ exprIsDeterministic()

static int exprIsDeterministic ( Expr * p )

static

Definition at line 150175 of file sqlite3.c.

                                       {
  Walker w;
  memset(&w, 0, sizeof(w));

References Walker::eCode, exprNodeIsDeterministic(), sqlite3SelectWalkFail(), sqlite3WalkExpr(), Walker::xExprCallback, and Walker::xSelectCallback.

Referenced by sqlite3WhereBegin().

◆ exprListAppendList()

static ExprList * exprListAppendList	(	Parse *	pParse,
		ExprList *	pList,
		ExprList *	pAppend,
		int	bIntToNull )

static

Definition at line 152049 of file sqlite3.c.

 {
  if( pAppend ){
    int i;
    int nInit = pList ? pList->nExpr : 0;
    for(i=0; i<pAppend->nExpr; i++){
      Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
      assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) );
      if( bIntToNull && pDup ){
        int iDummy;
        Expr *pSub;
        for(pSub=pDup; ExprHasProperty(pSub, EP_Skip); pSub=pSub->pLeft){
          assert( pSub );
        }
        if( sqlite3ExprIsInteger(pSub, &iDummy) ){
          pSub->op = TK_NULL;
          pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
          pSub->u.zToken = 0;
        }
      }

Referenced by sqlite3WindowRewrite().

◆ exprListDeleteNN()

static SQLITE_NOINLINE void exprListDeleteNN	(	sqlite3 *	db,
		ExprList *	pList )

static

Definition at line 101567 of file sqlite3.c.

                                                                          {
  int i = pList->nExpr;
  struct ExprList_item *pItem =  pList->a;
  assert( pList->nExpr>0 );
  do{

◆ exprMightBeIndexed()

static int exprMightBeIndexed	(	SrcList *	pFrom,
		Bitmask	mPrereq,
		int *	aiCurCol,
		Expr *	pExpr,
		int	op )

static

Definition at line 144973 of file sqlite3.c.

 {
  /* If this expression is a vector to the left or right of a
  ** inequality constraint (>, <, >= or <=), perform the processing
  ** on the first element of the vector.  */
  assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE );
  assert( TK_IS<TK_GE && TK_ISNULL<TK_GE && TK_IN<TK_GE );
  assert( op<=TK_GE );
  if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
    pExpr = pExpr->x.pList->a[0].pExpr;
  }
 
  if( pExpr->op==TK_COLUMN ){
    aiCurCol[0] = pExpr->iTable;
    aiCurCol[1] = pExpr->iColumn;

Referenced by exprAnalyze().

◆ exprMightBeIndexed2()

static SQLITE_NOINLINE int exprMightBeIndexed2	(	SrcList *	pFrom,
		Bitmask	mPrereq,
		int *	aiCurCol,
		Expr *	pExpr )

static

Definition at line 144949 of file sqlite3.c.

 {
  Index *pIdx;
  int i;
  int iCur;
  for(i=0; mPrereq>1; i++, mPrereq>>=1){}
  iCur = pFrom->a[i].iCursor;
  for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    if( pIdx->aColExpr==0 ) continue;
    for(i=0; i<pIdx->nKeyCol; i++){
      if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
      if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
        aiCurCol[0] = iCur;
        aiCurCol[1] = XN_EXPR;

References ExprList::a, SrcList::a, Index::aColExpr, Index::aiColumn, SrcList::SrcList_item::iCursor, Index::nKeyCol, ExprList::ExprList_item::pExpr, Table::pIndex, Index::pNext, SrcList::SrcList_item::pTab, sqlite3ExprCompareSkip(), and XN_EXPR.

◆ exprNodeIsConstant()

static int exprNodeIsConstant	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 101710 of file sqlite3.c.

                                                           {
 
  /* If pWalker->eCode is 2 then any term of the expression that comes from
  ** the ON or USING clauses of a left join disqualifies the expression
  ** from being considered constant. */
  if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_FromJoin) ){
    pWalker->eCode = 0;
    return WRC_Abort;
  }
 
  switch( pExpr->op ){
    /* Consider functions to be constant if all their arguments are constant
    ** and either pWalker->eCode==4 or 5 or the function has the
    ** SQLITE_FUNC_CONST flag. */
    case TK_FUNCTION:
      if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
       && !ExprHasProperty(pExpr, EP_WinFunc)
      ){
        if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
        return WRC_Continue;
      }else{
        pWalker->eCode = 0;
        return WRC_Abort;
      }
    case TK_ID:
      /* Convert "true" or "false" in a DEFAULT clause into the
      ** appropriate TK_TRUEFALSE operator */
      if( sqlite3ExprIdToTrueFalse(pExpr) ){
        return WRC_Prune;
      }
      /* no break */ deliberate_fall_through
    case TK_COLUMN:
    case TK_AGG_FUNCTION:
    case TK_AGG_COLUMN:
      testcase( pExpr->op==TK_ID );
      testcase( pExpr->op==TK_COLUMN );
      testcase( pExpr->op==TK_AGG_FUNCTION );
      testcase( pExpr->op==TK_AGG_COLUMN );
      if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
        return WRC_Continue;
      }
      if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
        return WRC_Continue;
      }
      /* no break */ deliberate_fall_through
    case TK_IF_NULL_ROW:
    case TK_REGISTER:
    case TK_DOT:
      testcase( pExpr->op==TK_REGISTER );
      testcase( pExpr->op==TK_IF_NULL_ROW );
      testcase( pExpr->op==TK_DOT );
      pWalker->eCode = 0;
      return WRC_Abort;
    case TK_VARIABLE:
      if( pWalker->eCode==5 ){
        /* Silently convert bound parameters that appear inside of CREATE
        ** statements into a NULL when parsing the CREATE statement text out
        ** of the sqlite_schema table */
        pExpr->op = TK_NULL;
      }else if( pWalker->eCode==4 ){
        /* A bound parameter in a CREATE statement that originates from
        ** sqlite3_prepare() causes an error */
        pWalker->eCode = 0;
        return WRC_Abort;
      }
      /* no break */ deliberate_fall_through

References deliberate_fall_through, Walker::eCode, EP_ConstFunc, EP_FixedCol, EP_FromDDL, EP_FromJoin, EP_WinFunc, ExprHasProperty, ExprSetProperty, Walker::iCur, Expr::iTable, Expr::op, sqlite3ExprIdToTrueFalse(), testcase, TK_AGG_COLUMN, TK_AGG_FUNCTION, TK_COLUMN, TK_DOT, TK_FUNCTION, TK_ID, TK_IF_NULL_ROW, TK_NULL, TK_REGISTER, TK_VARIABLE, Walker::u, WRC_Abort, WRC_Continue, and WRC_Prune.

◆ exprNodeIsConstantOrGroupBy()

static int exprNodeIsConstantOrGroupBy	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 101838 of file sqlite3.c.

                                                                    {
  ExprList *pGroupBy = pWalker->u.pGroupBy;
  int i;
 
  /* Check if pExpr is identical to any GROUP BY term. If so, consider
  ** it constant.  */
  for(i=0; i<pGroupBy->nExpr; i++){
    Expr *p = pGroupBy->a[i].pExpr;
    if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
      CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p);
      if( sqlite3IsBinary(pColl) ){
        return WRC_Prune;
      }
    }
  }
 
  /* Check if pExpr is a sub-select. If so, consider it variable. */
  if( ExprHasProperty(pExpr, EP_xIsSelect) ){

Referenced by sqlite3ExprIsConstantOrGroupBy().

◆ exprNodeIsDeterministic()

static int exprNodeIsDeterministic	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 150162 of file sqlite3.c.

150168 {

Referenced by exprIsDeterministic().

◆ exprProbability()

static int exprProbability ( Expr * p )

static

Definition at line 98468 of file sqlite3.c.

98474 {

98475 double r = -1.0;

References Expr::op, sqlite3AtoF(), sqlite3Strlen30(), SQLITE_UTF8, TK_FLOAT, Expr::u, and Expr::zToken.

Referenced by resolveExprStep().

◆ exprRowColumn()

static Expr * exprRowColumn	(	Parse *	pParse,
		int	iCol )

static

Definition at line 137734 of file sqlite3.c.

References Expr::iColumn, sqlite3PExpr(), and TK_ROW.

Referenced by updateFromSelect(), and updateVirtualTable().

◆ exprSelectUsage()

static Bitmask exprSelectUsage	(	WhereMaskSet *	pMaskSet,
		Select *	pS )

static

Definition at line 144912 of file sqlite3.c.

                                                                  {
  Bitmask mask = 0;
  while( pS ){
    SrcList *pSrc = pS->pSrc;
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList);
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy);
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy);
    mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere);
    mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving);
    if( ALWAYS(pSrc!=0) ){
      int i;
      for(i=0; i<pSrc->nSrc; i++){
        mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
        mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn);
        if( pSrc->a[i].fg.isTabFunc ){
          mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
        }

References SrcList::a, ALWAYS, exprSelectUsage(), SrcList::SrcList_item::fg, SrcList::SrcList_item::isTabFunc, mask, SrcList::nSrc, Select::pEList, SrcList::SrcList_item::pFuncArg, Select::pGroupBy, Select::pHaving, SrcList::SrcList_item::pOn, Select::pOrderBy, Select::pPrior, SrcList::SrcList_item::pSelect, Select::pSrc, Select::pWhere, sqlite3WhereExprListUsage(), sqlite3WhereExprUsage(), and SrcList::SrcList_item::u1.

Referenced by exprAnalyze(), exprSelectUsage(), and sqlite3WhereExprUsageNN().

◆ exprSetHeight()

static void exprSetHeight ( Expr * p )

static

Definition at line 100437 of file sqlite3.c.

                                  {
  int nHeight = 0;
  heightOfExpr(p->pLeft, &nHeight);
  heightOfExpr(p->pRight, &nHeight);
  if( ExprHasProperty(p, EP_xIsSelect) ){
    heightOfSelect(p->x.pSelect, &nHeight);

References EP_Propagate, EP_xIsSelect, ExprHasProperty, Expr::flags, heightOfExpr(), heightOfExprList(), heightOfSelect(), Expr::nHeight, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pSelect, sqlite3ExprListFlags(), and Expr::x.

Referenced by sqlite3ExprAttachSubtrees(), and sqlite3ExprSetHeightAndFlags().

◆ exprSrcCount()

static int exprSrcCount	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 105391 of file sqlite3.c.

                                                     {
  /* There was once a NEVER() on the second term on the grounds that
  ** sqlite3FunctionUsesThisSrc() was always called before
  ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet
  ** been converted into TK_AGG_COLUMN. But this is no longer true due
  ** to window functions - sqlite3WindowRewrite() may now indirectly call
  ** FunctionUsesThisSrc() when creating a new sub-select. */
  if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){
    int i;
    struct SrcCount *p = pWalker->u.pSrcCount;
    SrcList *pSrc = p->pSrc;
    int nSrc = pSrc ? pSrc->nSrc : 0;
    for(i=0; i<nSrc; i++){
      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
    }
    if( i<nSrc ){
      p->nThis++;
    }else if( pExpr->iTable<p->iSrcInner ){
      /* In a well-formed parse tree (no name resolution errors),
      ** TK_COLUMN nodes with smaller Expr.iTable values are in an

Referenced by sqlite3FunctionUsesThisSrc().

◆ exprStructSize()

static int exprStructSize ( Expr * p )

static

Definition at line 100870 of file sqlite3.c.

References EP_Reduced, EP_TokenOnly, EXPR_FULLSIZE, EXPR_REDUCEDSIZE, EXPR_TOKENONLYSIZE, and ExprHasProperty.

Referenced by exprDup().

◆ exprTableColumn()

static Expr * exprTableColumn	(	sqlite3 *	db,
		Table *	pTab,
		int	iCursor,
		i16	iCol )

static

Definition at line 119598 of file sqlite3.c.

 {
  Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
  if( pExpr ){

Referenced by fkScanChildren().

◆ exprTableRegister()

static Expr * exprTableRegister	(	Parse *	pParse,
		Table *	pTab,
		int	regBase,
		i16	iCol )

static

Definition at line 119566 of file sqlite3.c.

 {
  Expr *pExpr;
  Column *pCol;
  const char *zColl;
  sqlite3 *db = pParse->db;
 
  pExpr = sqlite3Expr(db, TK_REGISTER, 0);
  if( pExpr ){
    if( iCol>=0 && iCol!=pTab->iPKey ){
      pCol = &pTab->aCol[iCol];
      pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
      pExpr->affExpr = pCol->affinity;
      zColl = pCol->zColl;
      if( zColl==0 ) zColl = db->pDfltColl->zName;
      pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
    }else{

References Table::aCol, Expr::affExpr, Column::affinity, Parse::db, Table::iPKey, Expr::iTable, sqlite3::pDfltColl, sqlite3Expr(), sqlite3ExprAddCollateString(), sqlite3TableColumnToStorage(), SQLITE_AFF_INTEGER, TK_REGISTER, Column::zColl, and CollSeq::zName.

Referenced by fkScanChildren().

◆ exprToRegister()

static void exprToRegister	(	Expr *	pExpr,
		int	iReg )

static

Definition at line 103329 of file sqlite3.c.

103335 {

References EP_Skip, ExprClearProperty, Expr::iTable, Expr::op, Expr::op2, sqlite3ExprSkipCollateAndLikely(), and TK_REGISTER.

Referenced by exprCodeBetween(), and sqlite3ExprCodeTarget().

◆ exprVectorRegister()

static int exprVectorRegister	(	Parse *	pParse,
		Expr *	pVector,
		int	iField,
		int	regSelect,
		Expr **	ppExpr,
		int *	pRegFree )

static

Definition at line 100261 of file sqlite3.c.

 {
  u8 op = pVector->op;
  assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT );
  if( op==TK_REGISTER ){
    *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
    return pVector->iTable+iField;
  }
  if( op==TK_SELECT ){

References ExprList::a, Expr::iTable, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pList, Expr::pSelect, sqlite3ExprCodeTemp(), sqlite3VectorFieldSubexpr(), TK_REGISTER, TK_SELECT, TK_VECTOR, and Expr::x.

Referenced by codeVectorCompare().

◆ fcntlSizeHint()

static int fcntlSizeHint	(	unixFile *	pFile,
		i64	nByte )

static

Definition at line 37393 of file sqlite3.c.

                                                    {
  if( pFile->szChunk>0 ){
    i64 nSize;                    /* Required file size */
    struct stat buf;              /* Used to hold return values of fstat() */
 
    if( osFstat(pFile->h, &buf) ){
      return SQLITE_IOERR_FSTAT;
    }
 
    nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
    if( nSize>(i64)buf.st_size ){
 
#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
      /* The code below is handling the return value of osFallocate()
      ** correctly. posix_fallocate() is defined to "returns zero on success,
      ** or an error number on  failure". See the manpage for details. */
      int err;
      do{
        err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
      }while( err==EINTR );
      if( err && err!=EINVAL ) return SQLITE_IOERR_WRITE;
#else
      /* If the OS does not have posix_fallocate(), fake it. Write a
      ** single byte to the last byte in each block that falls entirely
      ** within the extended region. Then, if required, a single byte
      ** at offset (nSize-1), to set the size of the file correctly.
      ** This is a similar technique to that used by glibc on systems
      ** that do not have a real fallocate() call.
      */
      int nBlk = buf.st_blksize;  /* File-system block size */
      int nWrite = 0;             /* Number of bytes written by seekAndWrite */
      i64 iWrite;                 /* Next offset to write to */
 
      iWrite = (buf.st_size/nBlk)*nBlk + nBlk - 1;
      assert( iWrite>=buf.st_size );
      assert( ((iWrite+1)%nBlk)==0 );
      for(/*no-op*/; iWrite<nSize+nBlk-1; iWrite+=nBlk ){
        if( iWrite>=nSize ) iWrite = nSize - 1;
        nWrite = seekAndWrite(pFile, iWrite, "", 1);
        if( nWrite!=1 ) return SQLITE_IOERR_WRITE;
      }
#endif
    }
  }
 
#if SQLITE_MAX_MMAP_SIZE>0
  if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
    int rc;
    if( pFile->szChunk<=0 ){
      if( robust_ftruncate(pFile->h, nByte) ){
        storeLastErrno(pFile, errno);
        return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
      }
    }
 
    rc = unixMapfile(pFile, nByte);

References unixFile::h, osFallocate, osFstat, robust_ftruncate(), seekAndWrite(), SQLITE_IOERR_FSTAT, SQLITE_IOERR_TRUNCATE, SQLITE_IOERR_WRITE, SQLITE_OK, storeLastErrno(), unixFile::szChunk, unixLogError, and unixFile::zPath.

◆ fetchPayload()

static const void * fetchPayload	(	BtCursor *	pCur,
		u32 *	pAmt )

static

Definition at line 69518 of file sqlite3.c.

 {
  int amt;
  assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
  assert( pCur->eState==CURSOR_VALID );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->ix<pCur->pPage->nCell );
  assert( pCur->info.nSize>0 );
  assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
  assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
  amt = pCur->info.nLocal;
  if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
    /* There is too little space on the page for the expected amount
    ** of local content. Database must be corrupt. */

References MemPage::aData, MemPage::aDataEnd, CORRUPT_DB, CURSOR_VALID, Btree::db, BtCursor::eState, BtCursor::info, BtCursor::iPage, BtCursor::ix, MAX, sqlite3::mutex, MemPage::nCell, CellInfo::nLocal, CellInfo::nSize, BtCursor::pBtree, BtCursor::pPage, CellInfo::pPayload, and sqlite3_mutex_held().

Referenced by sqlite3BtreePayloadFetch().

◆ fileHasMoved()

static int fileHasMoved ( unixFile * pFile )

static

Definition at line 34994 of file sqlite3.c.

                                        {
#if OS_VXWORKS
  return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
#else

Referenced by verifyDbFile().

◆ fillInCell()

static int fillInCell	(	MemPage *	pPage,
		unsigned char *	pCell,
		const BtreePayload *	pX,
		int *	pnSize )

static

Definition at line 70938 of file sqlite3.c.

 {
  int nPayload;
  const u8 *pSrc;
  int nSrc, n, rc, mn;
  int spaceLeft;
  MemPage *pToRelease;
  unsigned char *pPrior;
  unsigned char *pPayload;
  BtShared *pBt;
  Pgno pgnoOvfl;
  int nHeader;
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
 
  /* pPage is not necessarily writeable since pCell might be auxiliary
  ** buffer space that is separate from the pPage buffer area */
  assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
            || sqlite3PagerIswriteable(pPage->pDbPage) );
 
  /* Fill in the header. */
  nHeader = pPage->childPtrSize;
  if( pPage->intKey ){
    nPayload = pX->nData + pX->nZero;
    pSrc = pX->pData;
    nSrc = pX->nData;
    assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */
    nHeader += putVarint32(&pCell[nHeader], nPayload);
    nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey);
  }else{
    assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
    nSrc = nPayload = (int)pX->nKey;
    pSrc = pX->pKey;
    nHeader += putVarint32(&pCell[nHeader], nPayload);
  }
 
  /* Fill in the payload */
  pPayload = &pCell[nHeader];
  if( nPayload<=pPage->maxLocal ){
    /* This is the common case where everything fits on the btree page
    ** and no overflow pages are required. */
    n = nHeader + nPayload;
    testcase( n==3 );
    testcase( n==4 );
    if( n<4 ) n = 4;
    *pnSize = n;
    assert( nSrc<=nPayload );
    testcase( nSrc<nPayload );
    memcpy(pPayload, pSrc, nSrc);
    memset(pPayload+nSrc, 0, nPayload-nSrc);
    return SQLITE_OK;
  }
 
  /* If we reach this point, it means that some of the content will need
  ** to spill onto overflow pages.
  */
  mn = pPage->minLocal;
  n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4);
  testcase( n==pPage->maxLocal );
  testcase( n==pPage->maxLocal+1 );
  if( n > pPage->maxLocal ) n = mn;
  spaceLeft = n;
  *pnSize = n + nHeader + 4;
  pPrior = &pCell[nHeader+n];
  pToRelease = 0;
  pgnoOvfl = 0;
  pBt = pPage->pBt;
 
  /* At this point variables should be set as follows:
  **
  **   nPayload           Total payload size in bytes
  **   pPayload           Begin writing payload here
  **   spaceLeft          Space available at pPayload.  If nPayload>spaceLeft,
  **                      that means content must spill into overflow pages.
  **   *pnSize            Size of the local cell (not counting overflow pages)
  **   pPrior             Where to write the pgno of the first overflow page
  **
  ** Use a call to btreeParseCellPtr() to verify that the values above
  ** were computed correctly.
  */
#ifdef SQLITE_DEBUG
  {
    CellInfo info;
    pPage->xParseCell(pPage, pCell, &info);
    assert( nHeader==(int)(info.pPayload - pCell) );
    assert( info.nKey==pX->nKey );
    assert( *pnSize == info.nSize );
    assert( spaceLeft == info.nLocal );
  }
#endif
 
  /* Write the payload into the local Cell and any extra into overflow pages */
  while( 1 ){
    n = nPayload;
    if( n>spaceLeft ) n = spaceLeft;
 
    /* If pToRelease is not zero than pPayload points into the data area
    ** of pToRelease.  Make sure pToRelease is still writeable. */
    assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
 
    /* If pPayload is part of the data area of pPage, then make sure pPage
    ** is still writeable */
    assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
            || sqlite3PagerIswriteable(pPage->pDbPage) );
 
    if( nSrc>=n ){
      memcpy(pPayload, pSrc, n);
    }else if( nSrc>0 ){
      n = nSrc;
      memcpy(pPayload, pSrc, n);
    }else{
      memset(pPayload, 0, n);
    }
    nPayload -= n;
    if( nPayload<=0 ) break;
    pPayload += n;
    pSrc += n;
    nSrc -= n;
    spaceLeft -= n;
    if( spaceLeft==0 ){
      MemPage *pOvfl = 0;
#ifndef SQLITE_OMIT_AUTOVACUUM
      Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
      if( pBt->autoVacuum ){
        do{
          pgnoOvfl++;
        } while(
          PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
        );
      }
#endif
      rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
#ifndef SQLITE_OMIT_AUTOVACUUM
      /* If the database supports auto-vacuum, and the second or subsequent
      ** overflow page is being allocated, add an entry to the pointer-map
      ** for that page now.
      **
      ** If this is the first overflow page, then write a partial entry
      ** to the pointer-map. If we write nothing to this pointer-map slot,
      ** then the optimistic overflow chain processing in clearCell()
      ** may misinterpret the uninitialized values and delete the
      ** wrong pages from the database.
      */
      if( pBt->autoVacuum && rc==SQLITE_OK ){
        u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
        ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
        if( rc ){
          releasePage(pOvfl);
        }
      }
#endif
      if( rc ){
        releasePage(pToRelease);
        return rc;
      }
 
      /* If pToRelease is not zero than pPrior points into the data area
      ** of pToRelease.  Make sure pToRelease is still writeable. */
      assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
 
      /* If pPrior is part of the data area of pPage, then make sure pPage
      ** is still writeable */
      assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
            || sqlite3PagerIswriteable(pPage->pDbPage) );
 
      put4byte(pPrior, pgnoOvfl);
      releasePage(pToRelease);
      pToRelease = pOvfl;
      pPrior = pOvfl->aData;
      put4byte(pPrior, 0);
      pPayload = &pOvfl->aData[4];

References MemPage::aData, allocateBtreePage(), BtShared::autoVacuum, MemPage::childPtrSize, eType, MemPage::intKey, MemPage::intKeyLeaf, MemPage::maxLocal, MemPage::minLocal, BtShared::mutex, BtreePayload::nData, BtreePayload::nKey, CellInfo::nKey, CellInfo::nLocal, CellInfo::nSize, BtreePayload::nZero, BtShared::pageSize, MemPage::pBt, BtreePayload::pData, MemPage::pDbPage, PENDING_BYTE_PAGE, BtreePayload::pKey, CellInfo::pPayload, PTRMAP_ISPAGE, PTRMAP_OVERFLOW1, PTRMAP_OVERFLOW2, ptrmapPut(), put4byte, putVarint, putVarint32, releasePage(), sqlite3_mutex_held(), SQLITE_OK, testcase, BtShared::usableSize, and MemPage::xParseCell.

Referenced by sqlite3BtreeInsert().

◆ finalDbSize()

static Pgno finalDbSize	(	BtShared *	pBt,
		Pgno	nOrig,
		Pgno	nFree )

static

Definition at line 68326 of file sqlite3.c.

                                                              {
  int nEntry;                     /* Number of entries on one ptrmap page */
  Pgno nPtrmap;                   /* Number of PtrMap pages to be freed */
  Pgno nFin;                      /* Return value */
 
  nEntry = pBt->usableSize/5;
  nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
  nFin = nOrig - nFree - nPtrmap;
  if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
    nFin--;
  }

References PENDING_BYTE_PAGE, PTRMAP_ISPAGE, PTRMAP_PAGENO, and BtShared::usableSize.

Referenced by autoVacuumCommit(), and sqlite3BtreeIncrVacuum().

◆ finalizeAggFunctions()

static void finalizeAggFunctions	(	Parse *	pParse,
		AggInfo *	pAggInfo )

static

Definition at line 134730 of file sqlite3.c.

                                                                  {
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pF;
  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){

Referenced by sqlite3Select().

◆ findBtree()

static Btree * findBtree	(	sqlite3 *	pErrorDb,
		sqlite3 *	pDb,
		const char *	zDb )

static

Definition at line 75132 of file sqlite3.c.

                                                                         {
  int i = sqlite3FindDbName(pDb, zDb);
 
  if( i==1 ){
    Parse sParse;
    int rc = 0;
    memset(&sParse, 0, sizeof(sParse));
    sParse.db = pDb;
    if( sqlite3OpenTempDatabase(&sParse) ){
      sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg);
      rc = SQLITE_ERROR;
    }
    sqlite3DbFree(pErrorDb, sParse.zErrMsg);
    sqlite3ParserReset(&sParse);
    if( rc ){
      return 0;
    }
  }
 
  if( i<0 ){

References sqlite3::aDb, Parse::db, Db::pBt, Parse::rc, sqlite3DbFree(), sqlite3ErrorWithMsg(), sqlite3FindDbName(), sqlite3OpenTempDatabase(), sqlite3ParserReset(), SQLITE_ERROR, and Parse::zErrMsg.

Referenced by sqlite3_backup_init().

◆ findCollSeqEntry()

static CollSeq * findCollSeqEntry	(	sqlite3 *	db,
		const char *	zName,
		int	create )

static

Definition at line 115643 of file sqlite3.c.

 {
  CollSeq *pColl;
  pColl = sqlite3HashFind(&db->aCollSeq, zName);
 
  if( 0==pColl && create ){
    int nName = sqlite3Strlen30(zName) + 1;
    pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName);
    if( pColl ){
      CollSeq *pDel = 0;
      pColl[0].zName = (char*)&pColl[3];
      pColl[0].enc = SQLITE_UTF8;
      pColl[1].zName = (char*)&pColl[3];
      pColl[1].enc = SQLITE_UTF16LE;
      pColl[2].zName = (char*)&pColl[3];
      pColl[2].enc = SQLITE_UTF16BE;
      memcpy(pColl[0].zName, zName, nName);
      pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
 
      /* If a malloc() failure occurred in sqlite3HashInsert(), it will
      ** return the pColl pointer to be deleted (because it wasn't added
      ** to the hash table).
      */
      assert( pDel==0 || pDel==pColl );
      if( pDel!=0 ){
        sqlite3OomFault(db);
        sqlite3DbFree(db, pDel);

References sqlite3::aCollSeq, CollSeq::enc, nName, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3HashFind(), sqlite3HashInsert(), sqlite3OomFault(), sqlite3Strlen30(), SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, CollSeq::zName, and zName.

Referenced by sqlite3FindCollSeq().

◆ findConstInWhere()

static void findConstInWhere	(	WhereConst *	pConst,
		Expr *	pExpr )

static

Definition at line 133557 of file sqlite3.c.

                                                             {
  Expr *pRight, *pLeft;
  if( pExpr==0 ) return;
  if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
  if( pExpr->op==TK_AND ){
    findConstInWhere(pConst, pExpr->pRight);
    findConstInWhere(pConst, pExpr->pLeft);
    return;
  }
  if( pExpr->op!=TK_EQ ) return;
  pRight = pExpr->pRight;
  pLeft = pExpr->pLeft;
  assert( pRight!=0 );
  assert( pLeft!=0 );
  if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){

References constInsert(), EP_FromJoin, ExprHasProperty, findConstInWhere(), Expr::op, Expr::pLeft, Expr::pRight, sqlite3ExprIsConstant(), TK_AND, TK_COLUMN, and TK_EQ.

Referenced by findConstInWhere(), and propagateConstants().

◆ findCreateFileMode()

static int findCreateFileMode	(	const char *	zPath,
		int	flags,
		mode_t *	pMode,
		uid_t *	pUid,
		gid_t *	pGid )

static

Definition at line 39421 of file sqlite3.c.

 {
  int rc = SQLITE_OK;             /* Return Code */
  *pMode = 0;
  *pUid = 0;
  *pGid = 0;
  if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
    char zDb[MAX_PATHNAME+1];     /* Database file path */
    int nDb;                      /* Number of valid bytes in zDb */
 
    /* zPath is a path to a WAL or journal file. The following block derives
    ** the path to the associated database file from zPath. This block handles
    ** the following naming conventions:
    **
    **   "<path to db>-journal"
    **   "<path to db>-wal"
    **   "<path to db>-journalNN"
    **   "<path to db>-walNN"
    **
    ** where NN is a decimal number. The NN naming schemes are
    ** used by the test_multiplex.c module.
    */
    nDb = sqlite3Strlen30(zPath) - 1;
    while( zPath[nDb]!='-' ){
      /* In normal operation, the journal file name will always contain
      ** a '-' character.  However in 8+3 filename mode, or if a corrupt
      ** rollback journal specifies a super-journal with a goofy name, then
      ** the '-' might be missing. */
      if( nDb==0 || zPath[nDb]=='.' ) return SQLITE_OK;
      nDb--;
    }
    memcpy(zDb, zPath, nDb);
    zDb[nDb] = '\0';
 
    rc = getFileMode(zDb, pMode, pUid, pGid);
  }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
    *pMode = 0600;
  }else if( flags & SQLITE_OPEN_URI ){
    /* If this is a main database file and the file was opened using a URI
    ** filename, check for the "modeof" parameter. If present, interpret
    ** its value as a filename and try to copy the mode, uid and gid from
    ** that file.  */
    const char *z = sqlite3_uri_parameter(zPath, "modeof");

References getFileMode(), MAX_PATHNAME, sqlite3_uri_parameter(), sqlite3Strlen30(), SQLITE_OK, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_URI, and SQLITE_OPEN_WAL.

Referenced by unixOpen().

◆ findElementWithHash()

static HashElem * findElementWithHash	(	const Hash *	pH,
		const char *	pKey,
		unsigned int *	pHash )

static

Definition at line 33024 of file sqlite3.c.

 {
  HashElem *elem;                /* Used to loop thru the element list */
  unsigned int count;            /* Number of elements left to test */
  unsigned int h;                /* The computed hash */
  static HashElem nullElement = { 0, 0, 0, 0 };
 
  if( pH->ht ){   /*OPTIMIZATION-IF-TRUE*/
    struct _ht *pEntry;
    h = strHash(pKey) % pH->htsize;
    pEntry = &pH->ht[h];
    elem = pEntry->chain;
    count = pEntry->count;
  }else{
    h = 0;
    elem = pH->first;
    count = pH->count;
  }
  if( pHash ) *pHash = h;
  while( count-- ){
    assert( elem!=0 );
    if( sqlite3StrICmp(elem->pKey,pKey)==0 ){

References Hash::count, Hash::first, Hash::ht, Hash::htsize, HashElem::next, HashElem::pKey, sqlite3StrICmp(), and strHash().

Referenced by sqlite3HashInsert().

◆ findIndexCol()

static int findIndexCol	(	Parse *	pParse,
		ExprList *	pList,
		int	iBase,
		Index *	pIdx,
		int	iCol )

static

Definition at line 146058 of file sqlite3.c.

 {
  int i;
  const char *zColl = pIdx->azColl[iCol];
 
  for(i=0; i<pList->nExpr; i++){
    Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
    if( p->op==TK_COLUMN
     && p->iColumn==pIdx->aiColumn[iCol]
     && p->iTable==iBase
    ){
      CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
      if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
        return i;

References ExprList::a, Index::aiColumn, Index::azColl, Expr::iColumn, Expr::iTable, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, sqlite3ExprNNCollSeq(), sqlite3ExprSkipCollateAndLikely(), sqlite3StrICmp(), TK_COLUMN, and CollSeq::zName.

Referenced by isDistinctRedundant().

◆ findInodeInfo()

static int findInodeInfo	(	unixFile *	pFile,
		unixInodeInfo **	ppInode )

static

Definition at line 34902 of file sqlite3.c.

 {
  int rc;                        /* System call return code */
  int fd;                        /* The file descriptor for pFile */
  struct unixFileId fileId;      /* Lookup key for the unixInodeInfo */
  struct stat statbuf;           /* Low-level file information */
  unixInodeInfo *pInode = 0;     /* Candidate unixInodeInfo object */
 
  assert( unixMutexHeld() );
 
  /* Get low-level information about the file that we can used to
  ** create a unique name for the file.
  */
  fd = pFile->h;
  rc = osFstat(fd, &statbuf);
  if( rc!=0 ){
    storeLastErrno(pFile, errno);
#if defined(EOVERFLOW) && defined(SQLITE_DISABLE_LFS)
    if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
#endif
    return SQLITE_IOERR;
  }
 
#ifdef __APPLE__
  /* On OS X on an msdos filesystem, the inode number is reported
  ** incorrectly for zero-size files.  See ticket #3260.  To work
  ** around this problem (we consider it a bug in OS X, not SQLite)
  ** we always increase the file size to 1 by writing a single byte
  ** prior to accessing the inode number.  The one byte written is
  ** an ASCII 'S' character which also happens to be the first byte
  ** in the header of every SQLite database.  In this way, if there
  ** is a race condition such that another thread has already populated
  ** the first page of the database, no damage is done.
  */
  if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
    do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
    if( rc!=1 ){
      storeLastErrno(pFile, errno);
      return SQLITE_IOERR;
    }
    rc = osFstat(fd, &statbuf);
    if( rc!=0 ){
      storeLastErrno(pFile, errno);
      return SQLITE_IOERR;
    }
  }
#endif
 
  memset(&fileId, 0, sizeof(fileId));
  fileId.dev = statbuf.st_dev;
#if OS_VXWORKS
  fileId.pId = pFile->pId;
#else
  fileId.ino = (u64)statbuf.st_ino;
#endif
  assert( unixMutexHeld() );
  pInode = inodeList;
  while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
    pInode = pInode->pNext;
  }
  if( pInode==0 ){
    pInode = sqlite3_malloc64( sizeof(*pInode) );
    if( pInode==0 ){
      return SQLITE_NOMEM_BKPT;
    }
    memset(pInode, 0, sizeof(*pInode));
    memcpy(&pInode->fileId, &fileId, sizeof(fileId));
    if( sqlite3GlobalConfig.bCoreMutex ){
      pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
      if( pInode->pLockMutex==0 ){
        sqlite3_free(pInode);
        return SQLITE_NOMEM_BKPT;
      }
    }
    pInode->nRef = 1;
    assert( unixMutexHeld() );
    pInode->pNext = inodeList;
    pInode->pPrev = 0;
    if( inodeList ) inodeList->pPrev = pInode;
    inodeList = pInode;

References unixFileId::dev, unixFile::h, unixFileId::ino, inodeList, unixFile::lastErrno, unixInodeInfo::nRef, osFstat, osWrite, unixInodeInfo::pNext, unixInodeInfo::pPrev, sqlite3_free(), sqlite3_malloc64(), sqlite3_mutex_alloc(), sqlite3GlobalConfig, SQLITE_FSFLAGS_IS_MSDOS, SQLITE_IOERR, SQLITE_MUTEX_FAST, SQLITE_NOLFS, SQLITE_NOMEM_BKPT, and storeLastErrno().

◆ findNextHostParameter()

static int findNextHostParameter	(	const char *	zSql,
		int *	pnToken )

static

Definition at line 85064 of file sqlite3.c.

                                                                {
  int tokenType;
  int nTotal = 0;
  int n;
 
  *pnToken = 0;
  while( zSql[0] ){
    n = sqlite3GetToken((u8*)zSql, &tokenType);
    assert( n>0 && tokenType!=TK_ILLEGAL );
    if( tokenType==TK_VARIABLE ){
      *pnToken = n;
      break;

References sqlite3GetToken(), TK_ILLEGAL, and TK_VARIABLE.

Referenced by sqlite3VdbeExpandSql().

◆ findReusableFd()

static UnixUnusedFd * findReusableFd	(	const char *	zPath,
		int	flags )

static

Definition at line 39332 of file sqlite3.c.

                                                                 {
  UnixUnusedFd *pUnused = 0;
 
  /* Do not search for an unused file descriptor on vxworks. Not because
  ** vxworks would not benefit from the change (it might, we're not sure),
  ** but because no way to test it is currently available. It is better
  ** not to risk breaking vxworks support for the sake of such an obscure
  ** feature.  */
#if !OS_VXWORKS
  struct stat sStat;                   /* Results of stat() call */
 
  unixEnterMutex();
 
  /* A stat() call may fail for various reasons. If this happens, it is
  ** almost certain that an open() call on the same path will also fail.
  ** For this reason, if an error occurs in the stat() call here, it is
  ** ignored and -1 is returned. The caller will try to open a new file
  ** descriptor on the same path, fail, and return an error to SQLite.
  **
  ** Even if a subsequent open() call does succeed, the consequences of
  ** not searching for a reusable file descriptor are not dire.  */
  if( inodeList!=0 && 0==osStat(zPath, &sStat) ){
    unixInodeInfo *pInode;
 
    pInode = inodeList;
    while( pInode && (pInode->fileId.dev!=sStat.st_dev
                     || pInode->fileId.ino!=(u64)sStat.st_ino) ){
       pInode = pInode->pNext;
    }
    if( pInode ){
      UnixUnusedFd **pp;
      assert( sqlite3_mutex_notheld(pInode->pLockMutex) );
      sqlite3_mutex_enter(pInode->pLockMutex);
      flags &= (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE);
      for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
      pUnused = *pp;
      if( pUnused ){
        *pp = pUnused->pNext;
      }
      sqlite3_mutex_leave(pInode->pLockMutex);

References unixFileId::dev, unixInodeInfo::fileId, UnixUnusedFd::flags, unixFileId::ino, inodeList, osStat, unixInodeInfo::pLockMutex, UnixUnusedFd::pNext, unixInodeInfo::pNext, unixInodeInfo::pUnused, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_mutex_notheld(), SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, unixEnterMutex(), and unixLeaveMutex().

Referenced by unixOpen().

◆ findRightmost()

static Select * findRightmost ( Select * p )

static

Definition at line 129475 of file sqlite3.c.

Referenced by multiSelect(), and selectPopWith().

◆ first_valueFinalizeFunc()

static void first_valueFinalizeFunc ( sqlite3_context * pCtx )

static

Definition at line 151438 of file sqlite3.c.

                                                          {
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));

◆ first_valueStepFunc()

static void first_valueStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151422 of file sqlite3.c.

 {
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pValue==0 ){
    p->pValue = sqlite3_value_dup(apArg[0]);
    if( !p->pValue ){

◆ fkActionTrigger()

static Trigger * fkActionTrigger	(	Parse *	pParse,
		Table *	pTab,
		FKey *	pFKey,
		ExprList *	pChanges )

static

Definition at line 120283 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;       /* Database handle */
  int action;                     /* One of OE_None, OE_Cascade etc. */
  Trigger *pTrigger;              /* Trigger definition to return */
  int iAction = (pChanges!=0);    /* 1 for UPDATE, 0 for DELETE */
 
  action = pFKey->aAction[iAction];
  if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){
    return 0;
  }
  pTrigger = pFKey->apTrigger[iAction];
 
  if( action!=OE_None && !pTrigger ){
    char const *zFrom;            /* Name of child table */
    int nFrom;                    /* Length in bytes of zFrom */
    Index *pIdx = 0;              /* Parent key index for this FK */
    int *aiCol = 0;               /* child table cols -> parent key cols */
    TriggerStep *pStep = 0;        /* First (only) step of trigger program */
    Expr *pWhere = 0;             /* WHERE clause of trigger step */
    ExprList *pList = 0;          /* Changes list if ON UPDATE CASCADE */
    Select *pSelect = 0;          /* If RESTRICT, "SELECT RAISE(...)" */
    int i;                        /* Iterator variable */
    Expr *pWhen = 0;              /* WHEN clause for the trigger */
 
    if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
    assert( aiCol || pFKey->nCol==1 );
 
    for(i=0; i<pFKey->nCol; i++){
      Token tOld = { "old", 3 };  /* Literal "old" token */
      Token tNew = { "new", 3 };  /* Literal "new" token */
      Token tFromCol;             /* Name of column in child table */
      Token tToCol;               /* Name of column in parent table */
      int iFromCol;               /* Idx of column in child table */
      Expr *pEq;                  /* tFromCol = OLD.tToCol */
 
      iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
      assert( iFromCol>=0 );
      assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
      assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
      sqlite3TokenInit(&tToCol,
                   pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName);
      sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName);
 
      /* Create the expression "OLD.zToCol = zFromCol". It is important
      ** that the "OLD.zToCol" term is on the LHS of the = operator, so
      ** that the affinity and collation sequence associated with the
      ** parent table are used for the comparison. */
      pEq = sqlite3PExpr(pParse, TK_EQ,
          sqlite3PExpr(pParse, TK_DOT,
            sqlite3ExprAlloc(db, TK_ID, &tOld, 0),
            sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)),
          sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0)
      );
      pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
 
      /* For ON UPDATE, construct the next term of the WHEN clause.
      ** The final WHEN clause will be like this:
      **
      **    WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN)
      */
      if( pChanges ){
        pEq = sqlite3PExpr(pParse, TK_IS,
            sqlite3PExpr(pParse, TK_DOT,
              sqlite3ExprAlloc(db, TK_ID, &tOld, 0),
              sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)),
            sqlite3PExpr(pParse, TK_DOT,
              sqlite3ExprAlloc(db, TK_ID, &tNew, 0),
              sqlite3ExprAlloc(db, TK_ID, &tToCol, 0))
            );
        pWhen = sqlite3ExprAnd(pParse, pWhen, pEq);
      }
 
      if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){
        Expr *pNew;
        if( action==OE_Cascade ){
          pNew = sqlite3PExpr(pParse, TK_DOT,
            sqlite3ExprAlloc(db, TK_ID, &tNew, 0),
            sqlite3ExprAlloc(db, TK_ID, &tToCol, 0));
        }else if( action==OE_SetDflt ){
          Column *pCol = pFKey->pFrom->aCol + iFromCol;
          Expr *pDflt;
          if( pCol->colFlags & COLFLAG_GENERATED ){
            testcase( pCol->colFlags & COLFLAG_VIRTUAL );
            testcase( pCol->colFlags & COLFLAG_STORED );
            pDflt = 0;
          }else{
            pDflt = pCol->pDflt;
          }
          if( pDflt ){
            pNew = sqlite3ExprDup(db, pDflt, 0);
          }else{
            pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
          }
        }else{
          pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
        }
        pList = sqlite3ExprListAppend(pParse, pList, pNew);
        sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
      }
    }
    sqlite3DbFree(db, aiCol);
 
    zFrom = pFKey->pFrom->zName;
    nFrom = sqlite3Strlen30(zFrom);
 
    if( action==OE_Restrict ){
      Token tFrom;
      Expr *pRaise;
 
      tFrom.z = zFrom;
      tFrom.n = nFrom;
      pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed");
      if( pRaise ){
        pRaise->affExpr = OE_Abort;
      }
      pSelect = sqlite3SelectNew(pParse,
          sqlite3ExprListAppend(pParse, 0, pRaise),
          sqlite3SrcListAppend(pParse, 0, &tFrom, 0),
          pWhere,
          0, 0, 0, 0, 0
      );
      pWhere = 0;
    }
 
    /* Disable lookaside memory allocation */
    DisableLookaside;
 
    pTrigger = (Trigger *)sqlite3DbMallocZero(db,
        sizeof(Trigger) +         /* struct Trigger */
        sizeof(TriggerStep) +     /* Single step in trigger program */
        nFrom + 1                 /* Space for pStep->zTarget */
    );
    if( pTrigger ){
      pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
      pStep->zTarget = (char *)&pStep[1];
      memcpy((char *)pStep->zTarget, zFrom, nFrom);
 
      pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
      pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
      pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
      if( pWhen ){
        pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0);
        pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
      }
    }
 
    /* Re-enable the lookaside buffer, if it was disabled earlier. */
    EnableLookaside;
 
    sqlite3ExprDelete(db, pWhere);
    sqlite3ExprDelete(db, pWhen);
    sqlite3ExprListDelete(db, pList);
    sqlite3SelectDelete(db, pSelect);
    if( db->mallocFailed==1 ){
      fkTriggerDelete(db, pTrigger);
      return 0;
    }
    assert( pStep!=0 );
    assert( pTrigger!=0 );
 
    switch( action ){
      case OE_Restrict:
        pStep->op = TK_SELECT;
        break;
      case OE_Cascade:
        if( !pChanges ){
          pStep->op = TK_DELETE;
          break;
        }
        /* no break */ deliberate_fall_through
      default:
        pStep->op = TK_UPDATE;
    }
    pStep->pTrig = pTrigger;
    pTrigger->pSchema = pTab->pSchema;
    pTrigger->pTabSchema = pTab->pSchema;

References FKey::aAction, Table::aCol, FKey::aCol, Expr::affExpr, Index::aiColumn, FKey::apTrigger, COLFLAG_GENERATED, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, deliberate_fall_through, DisableLookaside, EnableLookaside, EXPRDUP_REDUCE, fkTriggerDelete(), sqlite3::flags, FKey::sColMap::iFrom, Table::iPKey, sqlite3::mallocFailed, Token::n, Table::nCol, FKey::nCol, OE_Abort, OE_Cascade, OE_None, OE_Restrict, OE_SetDflt, Trigger::op, TriggerStep::op, Column::pDflt, TriggerStep::pExprList, FKey::pFrom, Table::pSchema, Trigger::pSchema, TriggerStep::pSelect, Trigger::pTabSchema, TriggerStep::pTrig, Trigger::pWhen, TriggerStep::pWhere, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3Expr(), sqlite3ExprAlloc(), sqlite3ExprAnd(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListDelete(), sqlite3ExprListDup(), sqlite3ExprListSetName(), sqlite3FkLocateIndex(), sqlite3PExpr(), sqlite3SelectDelete(), sqlite3SelectDup(), sqlite3SelectNew(), sqlite3SrcListAppend(), sqlite3Strlen30(), sqlite3TokenInit(), SQLITE_DeferFKs, Trigger::step_list, testcase, TK_DELETE, TK_DOT, TK_EQ, TK_ID, TK_IS, TK_NOT, TK_NULL, TK_RAISE, TK_SELECT, TK_UPDATE, Token::z, Column::zName, Table::zName, and TriggerStep::zTarget.

◆ fkChildIsModified()

static int fkChildIsModified	(	Table *	pTab,
		FKey *	p,
		int *	aChange,
		int	bChngRowid )

static

Definition at line 119877 of file sqlite3.c.

 {
  int i;
  for(i=0; i<p->nCol; i++){

References FKey::aCol, FKey::sColMap::iFrom, Table::iPKey, and FKey::nCol.

Referenced by sqlite3FkCheck(), and sqlite3FkRequired().

◆ fkLookupParent()

static void fkLookupParent	(	Parse *	pParse,
		int	iDb,
		Table *	pTab,
		Index *	pIdx,
		FKey *	pFKey,
		int *	aiCol,
		int	regData,
		int	nIncr,
		int	isIgnore )

static

Definition at line 119413 of file sqlite3.c.

 {
  int i;                                    /* Iterator variable */
  Vdbe *v = sqlite3GetVdbe(pParse);         /* Vdbe to add code to */
  int iCur = pParse->nTab - 1;              /* Cursor number to use */
  int iOk = sqlite3VdbeMakeLabel(pParse);   /* jump here if parent key found */
 
  sqlite3VdbeVerifyAbortable(v,
    (!pFKey->isDeferred
      && !(pParse->db->flags & SQLITE_DeferFKs)
      && !pParse->pToplevel
      && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);
 
  /* If nIncr is less than zero, then check at runtime if there are any
  ** outstanding constraints to resolve. If there are not, there is no need
  ** to check if deleting this row resolves any outstanding violations.
  **
  ** Check if any of the key columns in the child table row are NULL. If
  ** any are, then the constraint is considered satisfied. No need to
  ** search for a matching row in the parent table.  */
  if( nIncr<0 ){
    sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
    VdbeCoverage(v);
  }
  for(i=0; i<pFKey->nCol; i++){
    int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1;
    sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v);
  }
 
  if( isIgnore==0 ){
    if( pIdx==0 ){
      /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
      ** column of the parent table (table pTab).  */
      int iMustBeInt;               /* Address of MustBeInt instruction */
      int regTemp = sqlite3GetTempReg(pParse);
 
      /* Invoke MustBeInt to coerce the child key value to an integer (i.e.
      ** apply the affinity of the parent key). If this fails, then there
      ** is no matching parent key. Before using MustBeInt, make a copy of
      ** the value. Otherwise, the value inserted into the child key column
      ** will have INTEGER affinity applied to it, which may not be correct.  */
      sqlite3VdbeAddOp2(v, OP_SCopy,
        sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp);
      iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
      VdbeCoverage(v);
 
      /* If the parent table is the same as the child table, and we are about
      ** to increment the constraint-counter (i.e. this is an INSERT operation),
      ** then check if the row being inserted matches itself. If so, do not
      ** increment the constraint-counter.  */
      if( pTab==pFKey->pFrom && nIncr==1 ){
        sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v);
        sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
      }
 
      sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
      sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);
      sqlite3VdbeGoto(v, iOk);
      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
      sqlite3VdbeJumpHere(v, iMustBeInt);
      sqlite3ReleaseTempReg(pParse, regTemp);
    }else{
      int nCol = pFKey->nCol;
      int regTemp = sqlite3GetTempRange(pParse, nCol);
      int regRec = sqlite3GetTempReg(pParse);
 
      sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
      sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
      for(i=0; i<nCol; i++){
        sqlite3VdbeAddOp2(v, OP_Copy,
               sqlite3TableColumnToStorage(pFKey->pFrom, aiCol[i])+1+regData,
               regTemp+i);
      }
 
      /* If the parent table is the same as the child table, and we are about
      ** to increment the constraint-counter (i.e. this is an INSERT operation),
      ** then check if the row being inserted matches itself. If so, do not
      ** increment the constraint-counter.
      **
      ** If any of the parent-key values are NULL, then the row cannot match
      ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any
      ** of the parent-key values are NULL (at this point it is known that
      ** none of the child key values are).
      */
      if( pTab==pFKey->pFrom && nIncr==1 ){
        int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
        for(i=0; i<nCol; i++){
          int iChild = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i])
                              +1+regData;
          int iParent = 1+regData;
          iParent += sqlite3TableColumnToStorage(pIdx->pTable,
                                                 pIdx->aiColumn[i]);
          assert( pIdx->aiColumn[i]>=0 );
          assert( aiCol[i]!=pTab->iPKey );
          if( pIdx->aiColumn[i]==pTab->iPKey ){
            /* The parent key is a composite key that includes the IPK column */
            iParent = regData;
          }
          sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v);
          sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
        }
        sqlite3VdbeGoto(v, iOk);
      }
 
      sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
                        sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
      sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0); VdbeCoverage(v);
 
      sqlite3ReleaseTempReg(pParse, regRec);
      sqlite3ReleaseTempRange(pParse, regTemp, nCol);
    }
  }
 
  if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
   && !pParse->pToplevel
   && !pParse->isMultiWrite
  ){
    /* Special case: If this is an INSERT statement that will insert exactly
    ** one row into the table, raise a constraint immediately instead of
    ** incrementing a counter. This is necessary as the VM code is being
    ** generated for will not open a statement transaction.  */
    assert( nIncr==1 );
    sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
        OE_Abort, 0, P4_STATIC, P5_ConstraintFK);
  }else{
    if( nIncr>0 && pFKey->isDeferred==0 ){
      sqlite3MayAbort(pParse);
    }

References Index::aiColumn, Parse::db, sqlite3::flags, Table::iPKey, FKey::isDeferred, Parse::isMultiWrite, FKey::nCol, Parse::nTab, OE_Abort, OE_Ignore, OP_Close, OP_Copy, OP_Eq, OP_FkCounter, OP_FkIfZero, OP_Found, OP_IsNull, OP_MakeRecord, OP_MustBeInt, OP_Ne, OP_NotExists, OP_OpenRead, OP_SCopy, P4_STATIC, P5_ConstraintFK, FKey::pFrom, Index::pTable, Parse::pToplevel, sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3HaltConstraint(), sqlite3IndexAffinityStr(), sqlite3MayAbort(), sqlite3OpenTable(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3TableColumnToStorage(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeSetP4KeyInfo(), sqlite3VdbeVerifyAbortable, SQLITE_CONSTRAINT_FOREIGNKEY, SQLITE_DeferFKs, SQLITE_JUMPIFNULL, SQLITE_NOTNULL, Index::tnum, and VdbeCoverage.

Referenced by sqlite3FkCheck().

◆ fkParentIsModified()

static int fkParentIsModified	(	Table *	pTab,
		FKey *	p,
		int *	aChange,
		int	bChngRowid )

static

Definition at line 119904 of file sqlite3.c.

 {
  int i;
  for(i=0; i<p->nCol; i++){
    char *zKey = p->aCol[i].zCol;
    int iKey;
    for(iKey=0; iKey<pTab->nCol; iKey++){
      if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
        Column *pCol = &pTab->aCol[iKey];
        if( zKey ){
          if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1;
        }else if( pCol->colFlags & COLFLAG_PRIMKEY ){
          return 1;

References Table::aCol, FKey::aCol, COLFLAG_PRIMKEY, Column::colFlags, Table::iPKey, Table::nCol, FKey::nCol, sqlite3StrICmp(), FKey::sColMap::zCol, and Column::zName.

Referenced by sqlite3FkCheck(), and sqlite3FkRequired().

◆ fkScanChildren()

static void fkScanChildren	(	Parse *	pParse,
		SrcList *	pSrc,
		Table *	pTab,
		Index *	pIdx,
		FKey *	pFKey,
		int *	aiCol,
		int	regData,
		int	nIncr )

static

Definition at line 119645 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;       /* Database handle */
  int i;                          /* Iterator variable */
  Expr *pWhere = 0;               /* WHERE clause to scan with */
  NameContext sNameContext;       /* Context used to resolve WHERE clause */
  WhereInfo *pWInfo;              /* Context used by sqlite3WhereXXX() */
  int iFkIfZero = 0;              /* Address of OP_FkIfZero */
  Vdbe *v = sqlite3GetVdbe(pParse);
 
  assert( pIdx==0 || pIdx->pTable==pTab );
  assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
  assert( pIdx!=0 || pFKey->nCol==1 );
  assert( pIdx!=0 || HasRowid(pTab) );
 
  if( nIncr<0 ){
    iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
    VdbeCoverage(v);
  }
 
  /* Create an Expr object representing an SQL expression like:
  **
  **   <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
  **
  ** The collation sequence used for the comparison should be that of
  ** the parent key columns. The affinity of the parent key column should
  ** be applied to each child key value before the comparison takes place.
  */
  for(i=0; i<pFKey->nCol; i++){
    Expr *pLeft;                  /* Value from parent table row */
    Expr *pRight;                 /* Column ref to child table */
    Expr *pEq;                    /* Expression (pLeft = pRight) */
    i16 iCol;                     /* Index of column in child table */
    const char *zCol;             /* Name of column in child table */
 
    iCol = pIdx ? pIdx->aiColumn[i] : -1;
    pLeft = exprTableRegister(pParse, pTab, regData, iCol);
    iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
    assert( iCol>=0 );
    zCol = pFKey->pFrom->aCol[iCol].zName;
    pRight = sqlite3Expr(db, TK_ID, zCol);
    pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight);
    pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
  }
 
  /* If the child table is the same as the parent table, then add terms
  ** to the WHERE clause that prevent this entry from being scanned.
  ** The added WHERE clause terms are like this:
  **
  **     $current_rowid!=rowid
  **     NOT( $current_a==a AND $current_b==b AND ... )
  **
  ** The first form is used for rowid tables.  The second form is used
  ** for WITHOUT ROWID tables. In the second form, the *parent* key is
  ** (a,b,...). Either the parent or primary key could be used to
  ** uniquely identify the current row, but the parent key is more convenient
  ** as the required values have already been loaded into registers
  ** by the caller.
  */
  if( pTab==pFKey->pFrom && nIncr>0 ){
    Expr *pNe;                    /* Expression (pLeft != pRight) */
    Expr *pLeft;                  /* Value from parent table row */
    Expr *pRight;                 /* Column ref to child table */
    if( HasRowid(pTab) ){
      pLeft = exprTableRegister(pParse, pTab, regData, -1);
      pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
      pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight);
    }else{
      Expr *pEq, *pAll = 0;
      assert( pIdx!=0 );
      for(i=0; i<pIdx->nKeyCol; i++){
        i16 iCol = pIdx->aiColumn[i];
        assert( iCol>=0 );
        pLeft = exprTableRegister(pParse, pTab, regData, iCol);
        pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName);
        pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight);
        pAll = sqlite3ExprAnd(pParse, pAll, pEq);
      }
      pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0);
    }
    pWhere = sqlite3ExprAnd(pParse, pWhere, pNe);
  }
 
  /* Resolve the references in the WHERE clause. */
  memset(&sNameContext, 0, sizeof(NameContext));
  sNameContext.pSrcList = pSrc;
  sNameContext.pParse = pParse;
  sqlite3ResolveExprNames(&sNameContext, pWhere);
 
  /* Create VDBE to loop through the entries in pSrc that match the WHERE
  ** clause. For each row found, increment either the deferred or immediate
  ** foreign key constraint counter. */
  if( pParse->nErr==0 ){
    pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0);
    sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
    if( pWInfo ){
      sqlite3WhereEnd(pWInfo);
    }
  }
 

References SrcList::a, Table::aCol, FKey::aCol, Index::aiColumn, Parse::db, exprTableColumn(), exprTableRegister(), HasRowid, SrcList::SrcList_item::iCursor, FKey::sColMap::iFrom, FKey::isDeferred, FKey::nCol, Parse::nErr, Index::nKeyCol, OP_FkCounter, OP_FkIfZero, FKey::pFrom, NameContext::pParse, NameContext::pSrcList, Index::pTable, sqlite3Expr(), sqlite3ExprAnd(), sqlite3ExprDelete(), sqlite3GetVdbe(), sqlite3PExpr(), sqlite3ResolveExprNames(), sqlite3VdbeAddOp2(), sqlite3VdbeJumpHereOrPopInst(), sqlite3WhereBegin(), sqlite3WhereEnd(), TK_EQ, TK_ID, TK_IS, TK_NE, TK_NOT, VdbeCoverage, and Column::zName.

Referenced by sqlite3FkCheck().

◆ fkTriggerDelete()

static void fkTriggerDelete	(	sqlite3 *	dbMem,
		Trigger *	p )

static

Definition at line 119786 of file sqlite3.c.

                                                       {
  if( p ){
    TriggerStep *pStep = p->step_list;
    sqlite3ExprDelete(dbMem, pStep->pWhere);

References TriggerStep::pExprList, TriggerStep::pSelect, Trigger::pWhen, TriggerStep::pWhere, sqlite3DbFree(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3SelectDelete(), and Trigger::step_list.

Referenced by fkActionTrigger(), and sqlite3FkDelete().

◆ flattenSubquery()

static int flattenSubquery	(	Parse *	pParse,
		Select *	p,
		int	iFrom,
		int	isAgg )

static

Definition at line 133077 of file sqlite3.c.

 {
  const char *zSavedAuthContext = pParse->zAuthContext;
  Select *pParent;    /* Current UNION ALL term of the other query */
  Select *pSub;       /* The inner query or "subquery" */
  Select *pSub1;      /* Pointer to the rightmost select in sub-query */
  SrcList *pSrc;      /* The FROM clause of the outer query */
  SrcList *pSubSrc;   /* The FROM clause of the subquery */
  int iParent;        /* VDBE cursor number of the pSub result set temp table */
  int iNewParent = -1;/* Replacement table for iParent */
  int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */
  int i;              /* Loop counter */
  Expr *pWhere;                    /* The WHERE clause */
  struct SrcList_item *pSubitem;   /* The subquery */
  sqlite3 *db = pParse->db;
  Walker w;                        /* Walker to persist agginfo data */
 
  /* Check to see if flattening is permitted.  Return 0 if not.
  */
  assert( p!=0 );
  assert( p->pPrior==0 );
  if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
  pSrc = p->pSrc;
  assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
  pSubitem = &pSrc->a[iFrom];
  iParent = pSubitem->iCursor;
  pSub = pSubitem->pSelect;
  assert( pSub!=0 );
 
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( p->pWin || pSub->pWin ) return 0;                  /* Restriction (25) */
#endif
 
  pSubSrc = pSub->pSrc;
  assert( pSubSrc );
  /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
  ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET
  ** because they could be computed at compile-time.  But when LIMIT and OFFSET
  ** became arbitrary expressions, we were forced to add restrictions (13)
  ** and (14). */
  if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
  if( pSub->pLimit && pSub->pLimit->pRight ) return 0;   /* Restriction (14) */
  if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
    return 0;                                            /* Restriction (15) */
  }
  if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */
  if( pSub->selFlags & SF_Distinct ) return 0;           /* Restriction (4)  */
  if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
     return 0;         /* Restrictions (8)(9) */
  }
  if( p->pOrderBy && pSub->pOrderBy ){
     return 0;                                           /* Restriction (11) */
  }
  if( isAgg && pSub->pOrderBy ) return 0;                /* Restriction (16) */
  if( pSub->pLimit && p->pWhere ) return 0;              /* Restriction (19) */
  if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
     return 0;         /* Restriction (21) */
  }
  if( pSub->selFlags & (SF_Recursive) ){
    return 0; /* Restrictions (22) */
  }
 
  /*
  ** If the subquery is the right operand of a LEFT JOIN, then the
  ** subquery may not be a join itself (3a). Example of why this is not
  ** allowed:
  **
  **         t1 LEFT OUTER JOIN (t2 JOIN t3)
  **
  ** If we flatten the above, we would get
  **
  **         (t1 LEFT OUTER JOIN t2) JOIN t3
  **
  ** which is not at all the same thing.
  **
  ** If the subquery is the right operand of a LEFT JOIN, then the outer
  ** query cannot be an aggregate. (3c)  This is an artifact of the way
  ** aggregates are processed - there is no mechanism to determine if
  ** the LEFT JOIN table should be all-NULL.
  **
  ** See also tickets #306, #350, and #3300.
  */
  if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){
    isLeftJoin = 1;
    if( pSubSrc->nSrc>1                   /* (3a) */
     || isAgg                             /* (3b) */
     || IsVirtual(pSubSrc->a[0].pTab)     /* (3c) */
     || (p->selFlags & SF_Distinct)!=0    /* (3d) */
    ){
      return 0;
    }
  }
#ifdef SQLITE_EXTRA_IFNULLROW
  else if( iFrom>0 && !isAgg ){
    /* Setting isLeftJoin to -1 causes OP_IfNullRow opcodes to be generated for
    ** every reference to any result column from subquery in a join, even
    ** though they are not necessary.  This will stress-test the OP_IfNullRow
    ** opcode. */
    isLeftJoin = -1;
  }
#endif
 
  /* Restriction (17): If the sub-query is a compound SELECT, then it must
  ** use only the UNION ALL operator. And none of the simple select queries
  ** that make up the compound SELECT are allowed to be aggregate or distinct
  ** queries.
  */
  if( pSub->pPrior ){
    if( pSub->pOrderBy ){
      return 0;  /* Restriction (20) */
    }
    if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
      return 0; /* (17d1), (17d2), or (17d3) */
    }
    for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
      testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
      testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
      assert( pSub->pSrc!=0 );
      assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
      if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0    /* (17b) */
       || (pSub1->pPrior && pSub1->op!=TK_ALL)                 /* (17a) */
       || pSub1->pSrc->nSrc<1                                  /* (17c) */
#ifndef SQLITE_OMIT_WINDOWFUNC
       || pSub1->pWin                                          /* (17e) */
#endif
      ){
        return 0;
      }
      testcase( pSub1->pSrc->nSrc>1 );
    }
 
    /* Restriction (18). */
    if( p->pOrderBy ){
      int ii;
      for(ii=0; ii<p->pOrderBy->nExpr; ii++){
        if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
      }
    }
  }
 
  /* Ex-restriction (23):
  ** The only way that the recursive part of a CTE can contain a compound
  ** subquery is for the subquery to be one term of a join.  But if the
  ** subquery is a join, then the flattening has already been stopped by
  ** restriction (17d3)
  */
  assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 );
 
  /***** If we reach this point, flattening is permitted. *****/
  SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
                   pSub->selId, pSub, iFrom));
 
  /* Authorize the subquery */
  pParse->zAuthContext = pSubitem->zName;
  TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
  testcase( i==SQLITE_DENY );
  pParse->zAuthContext = zSavedAuthContext;
 
  /* If the sub-query is a compound SELECT statement, then (by restrictions
  ** 17 and 18 above) it must be a UNION ALL and the parent query must
  ** be of the form:
  **
  **     SELECT <expr-list> FROM (<sub-query>) <where-clause>
  **
  ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
  ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
  ** OFFSET clauses and joins them to the left-hand-side of the original
  ** using UNION ALL operators. In this case N is the number of simple
  ** select statements in the compound sub-query.
  **
  ** Example:
  **
  **     SELECT a+1 FROM (
  **        SELECT x FROM tab
  **        UNION ALL
  **        SELECT y FROM tab
  **        UNION ALL
  **        SELECT abs(z*2) FROM tab2
  **     ) WHERE a!=5 ORDER BY 1
  **
  ** Transformed into:
  **
  **     SELECT x+1 FROM tab WHERE x+1!=5
  **     UNION ALL
  **     SELECT y+1 FROM tab WHERE y+1!=5
  **     UNION ALL
  **     SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
  **     ORDER BY 1
  **
  ** We call this the "compound-subquery flattening".
  */
  for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
    Select *pNew;
    ExprList *pOrderBy = p->pOrderBy;
    Expr *pLimit = p->pLimit;
    Select *pPrior = p->pPrior;
    p->pOrderBy = 0;
    p->pSrc = 0;
    p->pPrior = 0;
    p->pLimit = 0;
    pNew = sqlite3SelectDup(db, p, 0);
    p->pLimit = pLimit;
    p->pOrderBy = pOrderBy;
    p->pSrc = pSrc;
    p->op = TK_ALL;
    if( pNew==0 ){
      p->pPrior = pPrior;
    }else{
      pNew->pPrior = pPrior;
      if( pPrior ) pPrior->pNext = pNew;
      pNew->pNext = p;
      p->pPrior = pNew;
      SELECTTRACE(2,pParse,p,("compound-subquery flattener"
                              " creates %u as peer\n",pNew->selId));
    }
    if( db->mallocFailed ) return 1;
  }
 
  /* Begin flattening the iFrom-th entry of the FROM clause
  ** in the outer query.
  */
  pSub = pSub1 = pSubitem->pSelect;
 
  /* Delete the transient table structure associated with the
  ** subquery
  */
  sqlite3DbFree(db, pSubitem->zDatabase);
  sqlite3DbFree(db, pSubitem->zName);
  sqlite3DbFree(db, pSubitem->zAlias);
  pSubitem->zDatabase = 0;
  pSubitem->zName = 0;
  pSubitem->zAlias = 0;
  pSubitem->pSelect = 0;
 
  /* Defer deleting the Table object associated with the
  ** subquery until code generation is
  ** complete, since there may still exist Expr.pTab entries that
  ** refer to the subquery even after flattening.  Ticket #3346.
  **
  ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
  */
  if( ALWAYS(pSubitem->pTab!=0) ){
    Table *pTabToDel = pSubitem->pTab;
    if( pTabToDel->nTabRef==1 ){
      Parse *pToplevel = sqlite3ParseToplevel(pParse);
      pTabToDel->pNextZombie = pToplevel->pZombieTab;
      pToplevel->pZombieTab = pTabToDel;
    }else{
      pTabToDel->nTabRef--;
    }
    pSubitem->pTab = 0;
  }
 
  /* The following loop runs once for each term in a compound-subquery
  ** flattening (as described above).  If we are doing a different kind
  ** of flattening - a flattening other than a compound-subquery flattening -
  ** then this loop only runs once.
  **
  ** This loop moves all of the FROM elements of the subquery into the
  ** the FROM clause of the outer query.  Before doing this, remember
  ** the cursor number for the original outer query FROM element in
  ** iParent.  The iParent cursor will never be used.  Subsequent code
  ** will scan expressions looking for iParent references and replace
  ** those references with expressions that resolve to the subquery FROM
  ** elements we are now copying in.
  */
  for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
    int nSubSrc;
    u8 jointype = 0;
    assert( pSub!=0 );
    pSubSrc = pSub->pSrc;     /* FROM clause of subquery */
    nSubSrc = pSubSrc->nSrc;  /* Number of terms in subquery FROM clause */
    pSrc = pParent->pSrc;     /* FROM clause of the outer query */
 
    if( pSrc ){
      assert( pParent==p );  /* First time through the loop */
      jointype = pSubitem->fg.jointype;
    }else{
      assert( pParent!=p );  /* 2nd and subsequent times through the loop */
      pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
      if( pSrc==0 ) break;
      pParent->pSrc = pSrc;
    }
 
    /* The subquery uses a single slot of the FROM clause of the outer
    ** query.  If the subquery has more than one element in its FROM clause,
    ** then expand the outer query to make space for it to hold all elements
    ** of the subquery.
    **
    ** Example:
    **
    **    SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
    **
    ** The outer query has 3 slots in its FROM clause.  One slot of the
    ** outer query (the middle slot) is used by the subquery.  The next
    ** block of code will expand the outer query FROM clause to 4 slots.
    ** The middle slot is expanded to two slots in order to make space
    ** for the two elements in the FROM clause of the subquery.
    */
    if( nSubSrc>1 ){
      pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
      if( pSrc==0 ) break;
      pParent->pSrc = pSrc;
    }
 
    /* Transfer the FROM clause terms from the subquery into the
    ** outer query.
    */
    for(i=0; i<nSubSrc; i++){
      sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
      assert( pSrc->a[i+iFrom].fg.isTabFunc==0 );
      pSrc->a[i+iFrom] = pSubSrc->a[i];
      iNewParent = pSubSrc->a[i].iCursor;
      memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
    }
    pSrc->a[iFrom].fg.jointype = jointype;
 
    /* Now begin substituting subquery result set expressions for
    ** references to the iParent in the outer query.
    **
    ** Example:
    **
    **   SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
    **   \                     \_____________ subquery __________/          /
    **    \_____________________ outer query ______________________________/
    **
    ** We look at every expression in the outer query and every place we see
    ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
    */
    if( pSub->pOrderBy && (pParent->selFlags & SF_NoopOrderBy)==0 ){
      /* At this point, any non-zero iOrderByCol values indicate that the
      ** ORDER BY column expression is identical to the iOrderByCol'th
      ** expression returned by SELECT statement pSub. Since these values
      ** do not necessarily correspond to columns in SELECT statement pParent,
      ** zero them before transfering the ORDER BY clause.
      **
      ** Not doing this may cause an error if a subsequent call to this
      ** function attempts to flatten a compound sub-query into pParent
      ** (the only way this can happen is if the compound sub-query is
      ** currently part of pSub->pSrc). See ticket [d11a6e908f].  */
      ExprList *pOrderBy = pSub->pOrderBy;
      for(i=0; i<pOrderBy->nExpr; i++){
        pOrderBy->a[i].u.x.iOrderByCol = 0;
      }
      assert( pParent->pOrderBy==0 );
      pParent->pOrderBy = pOrderBy;
      pSub->pOrderBy = 0;
    }
    pWhere = pSub->pWhere;
    pSub->pWhere = 0;
    if( isLeftJoin>0 ){
      sqlite3SetJoinExpr(pWhere, iNewParent);
    }
    if( pWhere ){
      if( pParent->pWhere ){
        pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere);
      }else{
        pParent->pWhere = pWhere;
      }
    }
    if( db->mallocFailed==0 ){
      SubstContext x;
      x.pParse = pParse;
      x.iTable = iParent;
      x.iNewTable = iNewParent;
      x.isLeftJoin = isLeftJoin;
      x.pEList = pSub->pEList;
      substSelect(&x, pParent, 0);
    }
 
    /* The flattened query is a compound if either the inner or the
    ** outer query is a compound. */
    pParent->selFlags |= pSub->selFlags & SF_Compound;
    assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */
 
    /*
    ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
    **
    ** One is tempted to try to add a and b to combine the limits.  But this
    ** does not work if either limit is negative.
    */
    if( pSub->pLimit ){
      pParent->pLimit = pSub->pLimit;
      pSub->pLimit = 0;
    }
 
    /* Recompute the SrcList_item.colUsed masks for the flattened
    ** tables. */
    for(i=0; i<nSubSrc; i++){
      recomputeColumnsUsed(pParent, &pSrc->a[i+iFrom]);
    }
  }
 
  /* Finially, delete what is left of the subquery and return
  ** success.
  */
  sqlite3AggInfoPersistWalkerInit(&w, pParse);
  sqlite3WalkSelect(&w,pSub1);
  sqlite3SelectDelete(db, pSub1);
 
#if SELECTTRACE_ENABLED
  if( sqlite3_unsupported_selecttrace & 0x100 ){
    SELECTTRACE(0x100,pParse,p,("After flattening:\n"));

References ExprList::a, SrcList::a, ALWAYS, Parse::db, SrcList::SrcList_item::fg, SrcList::SrcList_item::iCursor, SubstContext::iNewTable, ExprList::ExprList_item::iOrderByCol, SubstContext::isLeftJoin, SrcList::SrcList_item::isTabFunc, IsVirtual, SubstContext::iTable, SrcList::SrcList_item::jointype, JT_OUTER, sqlite3::mallocFailed, ExprList::nExpr, SrcList::nSrc, Table::nTabRef, Select::op, OptimizationDisabled, Select::pEList, SubstContext::pEList, Select::pLimit, Select::pNext, Table::pNextZombie, Select::pOrderBy, SubstContext::pParse, Select::pPrior, Expr::pRight, Select::pSrc, SrcList::SrcList_item::pTab, SrcList::SrcList_item::pUsing, Select::pWhere, Select::pWin, Parse::pZombieTab, recomputeColumnsUsed(), SELECTTRACE, Select::selFlags, Select::selId, SF_Aggregate, SF_Compound, SF_Distinct, SF_NoopOrderBy, SF_Recursive, sqlite3_unsupported_selecttrace, sqlite3AggInfoPersistWalkerInit(), sqlite3AuthCheck(), sqlite3DbFree(), sqlite3IdListDelete(), sqlite3ParseToplevel, sqlite3PExpr(), sqlite3SelectDelete(), sqlite3SelectDup(), sqlite3SetJoinExpr(), sqlite3SrcListAppend(), sqlite3SrcListEnlarge(), sqlite3WalkSelect(), SQLITE_DENY, SQLITE_QueryFlattener, SQLITE_SELECT, substSelect(), testcase, TESTONLY, TK_ALL, TK_AND, ExprList::ExprList_item::u, ExprList::ExprList_item::x, and Parse::zAuthContext.

Referenced by sqlite3Select().

◆ freeEphemeralFunction()

static void freeEphemeralFunction	(	sqlite3 *	db,
		FuncDef *	pDef )

static

Definition at line 78834 of file sqlite3.c.

References FuncDef::funcFlags, sqlite3DbFreeNN(), and SQLITE_FUNC_EPHEM.

Referenced by sqlite3VdbeAddFunctionCall().

◆ freeP4()

static void freeP4	(	sqlite3 *	db,
		int	p4type,
		void *	p4 )

static

Definition at line 78851 of file sqlite3.c.

                                                                          {
  freeEphemeralFunction(db, p->pFunc);
  sqlite3DbFreeNN(db, p);
}
static void freeP4(sqlite3 *db, int p4type, void *p4){
  assert( db );
  switch( p4type ){
    case P4_FUNCCTX: {
      freeP4FuncCtx(db, (sqlite3_context*)p4);
      break;
    }
    case P4_REAL:
    case P4_INT64:
    case P4_DYNAMIC:
    case P4_DYNBLOB:
    case P4_INTARRAY: {
      sqlite3DbFree(db, p4);
      break;
    }
    case P4_KEYINFO: {
      if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
      break;
    }
#ifdef SQLITE_ENABLE_CURSOR_HINTS
    case P4_EXPR: {
      sqlite3ExprDelete(db, (Expr*)p4);
      break;
    }
#endif
    case P4_FUNCDEF: {
      freeEphemeralFunction(db, (FuncDef*)p4);
      break;
    }
    case P4_MEM: {
      if( db->pnBytesFreed==0 ){
        sqlite3ValueFree((sqlite3_value*)p4);
      }else{
        freeP4Mem(db, (Mem*)p4);
      }
      break;
    }

Referenced by sqlite3VdbeAppendP4(), vdbeChangeP4Full(), and vdbeFreeOpArray().

◆ freeP4FuncCtx()

static SQLITE_NOINLINE void freeP4FuncCtx	(	sqlite3 *	db,
		sqlite3_context *	p )

static

Definition at line 78847 of file sqlite3.c.

78849 {

78850 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);

References sqlite3DbFree(), sqlite3_value::szMalloc, and sqlite3_value::zMalloc.

◆ freeP4Mem()

static SQLITE_NOINLINE void freeP4Mem	(	sqlite3 *	db,
		Mem *	p )

static

Definition at line 78843 of file sqlite3.c.

◆ freePage()

static void freePage	(	MemPage *	pPage,
		int *	pRC )

static

Definition at line 70845 of file sqlite3.c.

Referenced by balance_nonroot(), and btreeDropTable().

◆ freePage2()

static int freePage2	(	BtShared *	pBt,
		MemPage *	pMemPage,
		Pgno	iPage )

static

Definition at line 70711 of file sqlite3.c.

                                                                  {
  MemPage *pTrunk = 0;                /* Free-list trunk page */
  Pgno iTrunk = 0;                    /* Page number of free-list trunk page */
  MemPage *pPage1 = pBt->pPage1;      /* Local reference to page 1 */
  MemPage *pPage;                     /* Page being freed. May be NULL. */
  int rc;                             /* Return Code */
  u32 nFree;                          /* Initial number of pages on free-list */
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( CORRUPT_DB || iPage>1 );
  assert( !pMemPage || pMemPage->pgno==iPage );
 
  if( iPage<2 || iPage>pBt->nPage ){
    return SQLITE_CORRUPT_BKPT;
  }
  if( pMemPage ){
    pPage = pMemPage;
    sqlite3PagerRef(pPage->pDbPage);
  }else{
    pPage = btreePageLookup(pBt, iPage);
  }
 
  /* Increment the free page count on pPage1 */
  rc = sqlite3PagerWrite(pPage1->pDbPage);
  if( rc ) goto freepage_out;
  nFree = get4byte(&pPage1->aData[36]);
  put4byte(&pPage1->aData[36], nFree+1);
 
  if( pBt->btsFlags & BTS_SECURE_DELETE ){
    /* If the secure_delete option is enabled, then
    ** always fully overwrite deleted information with zeros.
    */
    if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
     ||            ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0)
    ){
      goto freepage_out;
    }
    memset(pPage->aData, 0, pPage->pBt->pageSize);
  }
 
  /* If the database supports auto-vacuum, write an entry in the pointer-map
  ** to indicate that the page is free.
  */
  if( ISAUTOVACUUM ){
    ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
    if( rc ) goto freepage_out;
  }
 
  /* Now manipulate the actual database free-list structure. There are two
  ** possibilities. If the free-list is currently empty, or if the first
  ** trunk page in the free-list is full, then this page will become a
  ** new free-list trunk page. Otherwise, it will become a leaf of the
  ** first trunk page in the current free-list. This block tests if it
  ** is possible to add the page as a new free-list leaf.
  */
  if( nFree!=0 ){
    u32 nLeaf;                /* Initial number of leaf cells on trunk page */
 
    iTrunk = get4byte(&pPage1->aData[32]);
    if( iTrunk>btreePagecount(pBt) ){
      rc = SQLITE_CORRUPT_BKPT;
      goto freepage_out;
    }
    rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
    if( rc!=SQLITE_OK ){
      goto freepage_out;
    }
 
    nLeaf = get4byte(&pTrunk->aData[4]);
    assert( pBt->usableSize>32 );
    if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
      rc = SQLITE_CORRUPT_BKPT;
      goto freepage_out;
    }
    if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
      /* In this case there is room on the trunk page to insert the page
      ** being freed as a new leaf.
      **
      ** Note that the trunk page is not really full until it contains
      ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
      ** coded.  But due to a coding error in versions of SQLite prior to
      ** 3.6.0, databases with freelist trunk pages holding more than
      ** usableSize/4 - 8 entries will be reported as corrupt.  In order
      ** to maintain backwards compatibility with older versions of SQLite,
      ** we will continue to restrict the number of entries to usableSize/4 - 8
      ** for now.  At some point in the future (once everyone has upgraded
      ** to 3.6.0 or later) we should consider fixing the conditional above
      ** to read "usableSize/4-2" instead of "usableSize/4-8".
      **
      ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still
      ** avoid using the last six entries in the freelist trunk page array in
      ** order that database files created by newer versions of SQLite can be
      ** read by older versions of SQLite.
      */
      rc = sqlite3PagerWrite(pTrunk->pDbPage);
      if( rc==SQLITE_OK ){
        put4byte(&pTrunk->aData[4], nLeaf+1);
        put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
        if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
          sqlite3PagerDontWrite(pPage->pDbPage);
        }
        rc = btreeSetHasContent(pBt, iPage);
      }
      TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
      goto freepage_out;
    }
  }
 
  /* If control flows to this point, then it was not possible to add the
  ** the page being freed as a leaf page of the first trunk in the free-list.
  ** Possibly because the free-list is empty, or possibly because the
  ** first trunk in the free-list is full. Either way, the page being freed
  ** will become the new first trunk page in the free-list.
  */
  if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
    goto freepage_out;
  }
  rc = sqlite3PagerWrite(pPage->pDbPage);
  if( rc!=SQLITE_OK ){
    goto freepage_out;
  }
  put4byte(pPage->aData, iTrunk);
  put4byte(&pPage->aData[4], 0);
  put4byte(&pPage1->aData[32], iPage);
  TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
 
freepage_out:
  if( pPage ){

References MemPage::aData, btreeGetPage(), btreePagecount(), btreePageLookup(), btreeSetHasContent(), BTS_SECURE_DELETE, BtShared::btsFlags, CORRUPT_DB, get4byte, ISAUTOVACUUM, BtShared::mutex, BtShared::nPage, BtShared::pageSize, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, BtShared::pPage1, PTRMAP_FREEPAGE, ptrmapPut(), put4byte, sqlite3_mutex_held(), sqlite3PagerDontWrite(), sqlite3PagerRef(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_OK, TRACE, and BtShared::usableSize.

◆ freeSpace()

static int freeSpace	(	MemPage *	pPage,
		u16	iStart,
		u16	iSize )

static

Definition at line 66185 of file sqlite3.c.

                                                           {
  u16 iPtr;                             /* Address of ptr to next freeblock */
  u16 iFreeBlk;                         /* Address of the next freeblock */
  u8 hdr;                               /* Page header size.  0 or 100 */
  u8 nFrag = 0;                         /* Reduction in fragmentation */
  u16 iOrigSize = iSize;                /* Original value of iSize */
  u16 x;                                /* Offset to cell content area */
  u32 iEnd = iStart + iSize;            /* First byte past the iStart buffer */
  unsigned char *data = pPage->aData;   /* Page content */
 
  assert( pPage->pBt!=0 );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize );
  assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( iSize>=4 );   /* Minimum cell size is 4 */
  assert( iStart<=pPage->pBt->usableSize-4 );
 
  /* The list of freeblocks must be in ascending order.  Find the
  ** spot on the list where iStart should be inserted.
  */
  hdr = pPage->hdrOffset;
  iPtr = hdr + 1;
  if( data[iPtr+1]==0 && data[iPtr]==0 ){
    iFreeBlk = 0;  /* Shortcut for the case when the freelist is empty */
  }else{
    while( (iFreeBlk = get2byte(&data[iPtr]))<iStart ){
      if( iFreeBlk<iPtr+4 ){
        if( iFreeBlk==0 ) break; /* TH3: corrupt082.100 */
        return SQLITE_CORRUPT_PAGE(pPage);
      }
      iPtr = iFreeBlk;
    }
    if( iFreeBlk>pPage->pBt->usableSize-4 ){ /* TH3: corrupt081.100 */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    assert( iFreeBlk>iPtr || iFreeBlk==0 );
 
    /* At this point:
    **    iFreeBlk:   First freeblock after iStart, or zero if none
    **    iPtr:       The address of a pointer to iFreeBlk
    **
    ** Check to see if iFreeBlk should be coalesced onto the end of iStart.
    */
    if( iFreeBlk && iEnd+3>=iFreeBlk ){
      nFrag = iFreeBlk - iEnd;
      if( iEnd>iFreeBlk ) return SQLITE_CORRUPT_PAGE(pPage);
      iEnd = iFreeBlk + get2byte(&data[iFreeBlk+2]);
      if( iEnd > pPage->pBt->usableSize ){
        return SQLITE_CORRUPT_PAGE(pPage);
      }
      iSize = iEnd - iStart;
      iFreeBlk = get2byte(&data[iFreeBlk]);
    }
 
    /* If iPtr is another freeblock (that is, if iPtr is not the freelist
    ** pointer in the page header) then check to see if iStart should be
    ** coalesced onto the end of iPtr.
    */
    if( iPtr>hdr+1 ){
      int iPtrEnd = iPtr + get2byte(&data[iPtr+2]);
      if( iPtrEnd+3>=iStart ){
        if( iPtrEnd>iStart ) return SQLITE_CORRUPT_PAGE(pPage);
        nFrag += iStart - iPtrEnd;
        iSize = iEnd - iPtr;
        iStart = iPtr;
      }
    }
    if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_PAGE(pPage);
    data[hdr+7] -= nFrag;
  }
  x = get2byte(&data[hdr+5]);
  if( iStart<=x ){
    /* The new freeblock is at the beginning of the cell content area,
    ** so just extend the cell content area rather than create another
    ** freelist entry */
    if( iStart<x ) return SQLITE_CORRUPT_PAGE(pPage);
    if( iPtr!=hdr+1 ) return SQLITE_CORRUPT_PAGE(pPage);
    put2byte(&data[hdr+1], iFreeBlk);
    put2byte(&data[hdr+5], iEnd);
  }else{
    /* Insert the new freeblock into the freelist */
    put2byte(&data[iPtr], iStart);
  }
  if( pPage->pBt->btsFlags & BTS_FAST_SECURE ){
    /* Overwrite deleted information with zeros when the secure_delete
    ** option is enabled */
    memset(&data[iStart], 0, iSize);

References MemPage::aData, BTS_FAST_SECURE, BtShared::btsFlags, MemPage::childPtrSize, CORRUPT_DB, get2byte, MemPage::hdrOffset, BtShared::mutex, MemPage::nFree, MemPage::pBt, MemPage::pDbPage, put2byte, sqlite3_mutex_held(), SQLITE_CORRUPT_PAGE, SQLITE_OK, and BtShared::usableSize.

Referenced by dropCell(), and pageFreeArray().

◆ freeTempSpace()

static void freeTempSpace ( BtShared * pBt )

static

Definition at line 67175 of file sqlite3.c.

67181 {

Referenced by lockBtree(), and sqlite3BtreeSetPageSize().

◆ full_fsync()

static int full_fsync	(	int	fd,
		int	fullSync,
		int	dataOnly )

static

Definition at line 37122 of file sqlite3.c.

                                                         {
  int rc;
 
  /* The following "ifdef/elif/else/" block has the same structure as
  ** the one below. It is replicated here solely to avoid cluttering
  ** up the real code with the UNUSED_PARAMETER() macros.
  */
#ifdef SQLITE_NO_SYNC
  UNUSED_PARAMETER(fd);
  UNUSED_PARAMETER(fullSync);
  UNUSED_PARAMETER(dataOnly);
#elif HAVE_FULLFSYNC
  UNUSED_PARAMETER(dataOnly);
#else
  UNUSED_PARAMETER(fullSync);
  UNUSED_PARAMETER(dataOnly);
#endif
 
  /* Record the number of times that we do a normal fsync() and
  ** FULLSYNC.  This is used during testing to verify that this procedure
  ** gets called with the correct arguments.
  */
#ifdef SQLITE_TEST
  if( fullSync ) sqlite3_fullsync_count++;
  sqlite3_sync_count++;
#endif
 
  /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
  ** no-op.  But go ahead and call fstat() to validate the file
  ** descriptor as we need a method to provoke a failure during
  ** coverate testing.
  */
#ifdef SQLITE_NO_SYNC
  {
    struct stat buf;
    rc = osFstat(fd, &buf);
  }
#elif HAVE_FULLFSYNC
  if( fullSync ){
    rc = osFcntl(fd, F_FULLFSYNC, 0);
  }else{
    rc = 1;
  }
  /* If the FULLFSYNC failed, fall back to attempting an fsync().
  ** It shouldn't be possible for fullfsync to fail on the local
  ** file system (on OSX), so failure indicates that FULLFSYNC
  ** isn't supported for this file system. So, attempt an fsync
  ** and (for now) ignore the overhead of a superfluous fcntl call.
  ** It'd be better to detect fullfsync support once and avoid
  ** the fcntl call every time sync is called.
  */
  if( rc ) rc = fsync(fd);
 
#elif defined(__APPLE__)
  /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
  ** so currently we default to the macro that redefines fdatasync to fsync
  */
  rc = fsync(fd);
#else
  rc = fdatasync(fd);
#if OS_VXWORKS
  if( rc==-1 && errno==ENOTSUP ){
    rc = fsync(fd);
  }
#endif /* OS_VXWORKS */
#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */

References fdatasync, OS_VXWORKS, osFcntl, osFstat, and UNUSED_PARAMETER.

Referenced by unixDelete(), and unixSync().

◆ functionDestroy()

static void functionDestroy	(	sqlite3 *	db,
		FuncDef *	p )

static

Definition at line 162127 of file sqlite3.c.

                                                    {
  FuncDestructor *pDestructor = p->u.pDestructor;
  if( pDestructor ){
    pDestructor->nRef--;

References FuncDestructor::nRef, FuncDef::pDestructor, FuncDestructor::pUserData, sqlite3DbFree(), FuncDef::u, and FuncDestructor::xDestroy.

Referenced by sqlite3CreateFunc(), and sqlite3LeaveMutexAndCloseZombie().

◆ gatherSelectWindows()

static void gatherSelectWindows ( Select * p )

static

Definition at line 101132 of file sqlite3.c.

                                                                        {
  return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune;
}
static void gatherSelectWindows(Select *p){
  Walker w;
  w.xExprCallback = gatherSelectWindowsCallback;

◆ gatherSelectWindowsCallback()

static int gatherSelectWindowsCallback	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 101118 of file sqlite3.c.

                                                                    {
  if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
    Select *pSelect = pWalker->u.pSelect;
    Window *pWin = pExpr->y.pWin;
    assert( pWin );

References EP_WinFunc, ExprHasProperty, Expr::op, Walker::pSelect, Expr::pWin, TK_FUNCTION, Walker::u, and Expr::y.

◆ gatherSelectWindowsSelectCallback()

static int gatherSelectWindowsSelectCallback	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 101129 of file sqlite3.c.

◆ generateColumnNames()

static void generateColumnNames	(	Parse *	pParse,
		Select *	pSelect )

static

Definition at line 131162 of file sqlite3.c.

                                    : COLUMN.  Otherwise use zSpan.
**
**    full=ON, short=ANY:       If the result refers directly to a table column,
**                              then the result column name with the table name
**                              prefix, ex: TABLE.COLUMN.  Otherwise use zSpan.
*/
static void generateColumnNames(
  Parse *pParse,      /* Parser context */
  Select *pSelect     /* Generate column names for this SELECT statement */
){
  Vdbe *v = pParse->pVdbe;
  int i;
  Table *pTab;
  SrcList *pTabList;
  ExprList *pEList;
  sqlite3 *db = pParse->db;
  int fullName;    /* TABLE.COLUMN if no AS clause and is a direct table ref */
  int srcName;     /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
 
#ifndef SQLITE_OMIT_EXPLAIN
  /* If this is an EXPLAIN, skip this step */
  if( pParse->explain ){
    return;
  }
#endif
 
  if( pParse->colNamesSet ) return;
  /* Column names are determined by the left-most term of a compound select */
  while( pSelect->pPrior ) pSelect = pSelect->pPrior;
  SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
  pTabList = pSelect->pSrc;
  pEList = pSelect->pEList;
  assert( v!=0 );
  assert( pTabList!=0 );
  pParse->colNamesSet = 1;
  fullName = (db->flags & SQLITE_FullColNames)!=0;
  srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
  sqlite3VdbeSetNumCols(v, pEList->nExpr);
  for(i=0; i<pEList->nExpr; i++){
    Expr *p = pEList->a[i].pExpr;
 
    assert( p!=0 );
    assert( p->op!=TK_AGG_COLUMN );  /* Agg processing has not run yet */
    assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */
    if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){
      /* An AS clause always takes first priority */
      char *zName = pEList->a[i].zEName;
      sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
    }else if( srcName && p->op==TK_COLUMN ){
      char *zCol;
      int iCol = p->iColumn;
      pTab = p->y.pTab;
      assert( pTab!=0 );
      if( iCol<0 ) iCol = pTab->iPKey;
      assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
      if( iCol<0 ){
        zCol = "rowid";
      }else{
        zCol = pTab->aCol[iCol].zName;
      }
      if( fullName ){
        char *zName = 0;
        zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
        sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
      }else{
        sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
      }
    }else{
      const char *z = pEList->a[i].zEName;

References ExprList::a, Table::aCol, COLNAME_NAME, Parse::colNamesSet, Parse::db, ExprList::ExprList_item::eEName, ENAME_NAME, Parse::explain, sqlite3::flags, generateColumnTypes(), Expr::iColumn, Table::iPKey, ExprList::nExpr, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, Select::pPrior, Select::pSrc, Expr::pTab, Parse::pVdbe, SELECTTRACE, sqlite3DbStrDup(), sqlite3MPrintf(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), SQLITE_DYNAMIC, SQLITE_FullColNames, SQLITE_ShortColNames, SQLITE_TRANSIENT, TK_AGG_COLUMN, TK_COLUMN, Expr::y, ExprList::ExprList_item::zEName, Column::zName, Table::zName, and zName.

Referenced by sqlite3Select().

◆ generateColumnTypes()

static void generateColumnTypes	(	Parse *	pParse,
		SrcList *	pTabList,
		ExprList *	pEList )

static

Definition at line 131095 of file sqlite3.c.

 {
#ifndef SQLITE_OMIT_DECLTYPE
  Vdbe *v = pParse->pVdbe;
  int i;
  NameContext sNC;
  sNC.pSrcList = pTabList;
  sNC.pParse = pParse;
  sNC.pNext = 0;
  for(i=0; i<pEList->nExpr; i++){
    Expr *p = pEList->a[i].pExpr;
    const char *zType;
#ifdef SQLITE_ENABLE_COLUMN_METADATA
    const char *zOrigDb = 0;
    const char *zOrigTab = 0;
    const char *zOrigCol = 0;
    zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
 
    /* The vdbe must make its own copy of the column-type and other
    ** column specific strings, in case the schema is reset before this
    ** virtual machine is deleted.
    */
    sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
    sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
    sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
#else

Referenced by generateColumnNames().

◆ generateOutputSubroutine()

static int generateOutputSubroutine	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pIn,
		SelectDest *	pDest,
		int	regReturn,
		int	regPrev,
		KeyInfo *	pKeyInfo,
		int	iBreak )

static

Definition at line 132229 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  int iContinue;
  int addr;
 
  addr = sqlite3VdbeCurrentAddr(v);
  iContinue = sqlite3VdbeMakeLabel(pParse);
 
  /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
  */
  if( regPrev ){
    int addr1, addr2;
    addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
    addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
                              (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr1);
    sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
    sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
  }
  if( pParse->db->mallocFailed ) return 0;
 
  /* Suppress the first OFFSET entries if there is an OFFSET clause
  */
  codeOffset(v, p->iOffset, iContinue);
 
  assert( pDest->eDest!=SRT_Exists );
  assert( pDest->eDest!=SRT_Table );
  switch( pDest->eDest ){
    /* Store the result as data using a unique key.
    */
    case SRT_EphemTab: {
      int r1 = sqlite3GetTempReg(pParse);
      int r2 = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
      sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
      sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
      sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
      sqlite3ReleaseTempReg(pParse, r2);
      sqlite3ReleaseTempReg(pParse, r1);
      break;
    }
 
#ifndef SQLITE_OMIT_SUBQUERY
    /* If we are creating a set for an "expr IN (SELECT ...)".
    */
    case SRT_Set: {
      int r1;
      testcase( pIn->nSdst>1 );
      r1 = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
          r1, pDest->zAffSdst, pIn->nSdst);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
                           pIn->iSdst, pIn->nSdst);
      sqlite3ReleaseTempReg(pParse, r1);
      break;
    }
 
    /* If this is a scalar select that is part of an expression, then
    ** store the results in the appropriate memory cell and break out
    ** of the scan loop.  Note that the select might return multiple columns
    ** if it is the RHS of a row-value IN operator.
    */
    case SRT_Mem: {
      if( pParse->nErr==0 ){
        testcase( pIn->nSdst>1 );
        sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
      }
      /* The LIMIT clause will jump out of the loop for us */
      break;
    }
#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
 
    /* The results are stored in a sequence of registers
    ** starting at pDest->iSdst.  Then the co-routine yields.
    */
    case SRT_Coroutine: {
      if( pDest->iSdst==0 ){
        pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
        pDest->nSdst = pIn->nSdst;
      }
      sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
      sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
      break;
    }
 
    /* If none of the above, then the result destination must be
    ** SRT_Output.  This routine is never called with any other
    ** destination other than the ones handled above or SRT_Output.
    **
    ** For SRT_Output, results are stored in a sequence of registers.
    ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
    ** return the next row of result.
    */
    default: {
      assert( pDest->eDest==SRT_Output );
      sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
      break;
    }
  }
 
  /* Jump to the end of the loop if the LIMIT is reached.
  */
  if( p->iLimit ){
    sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
  }
 
  /* Generate the subroutine return

References codeOffset(), Parse::db, SelectDest::eDest, Select::iLimit, Select::iOffset, SelectDest::iSDParm, SelectDest::iSdst, sqlite3::mallocFailed, Parse::nErr, SelectDest::nSdst, OP_Compare, OP_Copy, OP_DecrJumpZero, OP_IdxInsert, OP_IfNot, OP_Insert, OP_Integer, OP_Jump, OP_MakeRecord, OP_NewRowid, OP_ResultRow, OP_Return, OP_Yield, OPFLAG_APPEND, P4_KEYINFO, Parse::pVdbe, sqlite3ExprCodeMove(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3KeyInfoRef(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SRT_Coroutine, SRT_EphemTab, SRT_Exists, SRT_Mem, SRT_Output, SRT_Set, SRT_Table, testcase, VdbeCoverage, and SelectDest::zAffSdst.

Referenced by multiSelectOrderBy().

◆ generateSortTail()

static void generateSortTail	(	Parse *	pParse,
		Select *	p,
		SortCtx *	pSort,
		int	nColumn,
		SelectDest *	pDest )

static

Definition at line 130727 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;                     /* The prepared statement */
  int addrBreak = pSort->labelDone;            /* Jump here to exit loop */
  int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
  int addr;                       /* Top of output loop. Jump for Next. */
  int addrOnce = 0;
  int iTab;
  ExprList *pOrderBy = pSort->pOrderBy;
  int eDest = pDest->eDest;
  int iParm = pDest->iSDParm;
  int regRow;
  int regRowid;
  int iCol;
  int nKey;                       /* Number of key columns in sorter record */
  int iSortTab;                   /* Sorter cursor to read from */
  int i;
  int bSeq;                       /* True if sorter record includes seq. no. */
  int nRefKey = 0;
  struct ExprList_item *aOutEx = p->pEList->a;
 
  assert( addrBreak<0 );
  if( pSort->labelBkOut ){
    sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
    sqlite3VdbeGoto(v, addrBreak);
    sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
  }
 
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
  /* Open any cursors needed for sorter-reference expressions */
  for(i=0; i<pSort->nDefer; i++){
    Table *pTab = pSort->aDefer[i].pTab;
    int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
    sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
    nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
  }
#endif
 
  iTab = pSort->iECursor;
  if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
    regRowid = 0;
    regRow = pDest->iSdst;
  }else{
    regRowid = sqlite3GetTempReg(pParse);
    if( eDest==SRT_EphemTab || eDest==SRT_Table ){
      regRow = sqlite3GetTempReg(pParse);
      nColumn = 0;
    }else{
      regRow = sqlite3GetTempRange(pParse, nColumn);
    }
  }
  nKey = pOrderBy->nExpr - pSort->nOBSat;
  if( pSort->sortFlags & SORTFLAG_UseSorter ){
    int regSortOut = ++pParse->nMem;
    iSortTab = pParse->nTab++;
    if( pSort->labelBkOut ){
      addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
    }
    sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
        nKey+1+nColumn+nRefKey);
    if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
    addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
    VdbeCoverage(v);
    codeOffset(v, p->iOffset, addrContinue);
    sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
    bSeq = 0;
  }else{
    addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
    codeOffset(v, p->iOffset, addrContinue);
    iSortTab = iTab;
    bSeq = 1;
  }
  for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    if( aOutEx[i].bSorterRef ) continue;
#endif
    if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
  }
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
  if( pSort->nDefer ){
    int iKey = iCol+1;
    int regKey = sqlite3GetTempRange(pParse, nRefKey);
 
    for(i=0; i<pSort->nDefer; i++){
      int iCsr = pSort->aDefer[i].iCsr;
      Table *pTab = pSort->aDefer[i].pTab;
      int nKey = pSort->aDefer[i].nKey;
 
      sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
      if( HasRowid(pTab) ){
        sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
        sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
            sqlite3VdbeCurrentAddr(v)+1, regKey);
      }else{
        int k;
        int iJmp;
        assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
        for(k=0; k<nKey; k++){
          sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
        }
        iJmp = sqlite3VdbeCurrentAddr(v);
        sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
        sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
        sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
      }
    }
    sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
  }
#endif
  for(i=nColumn-1; i>=0; i--){
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    if( aOutEx[i].bSorterRef ){
      sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
    }else
#endif
    {
      int iRead;
      if( aOutEx[i].u.x.iOrderByCol ){
        iRead = aOutEx[i].u.x.iOrderByCol-1;
      }else{
        iRead = iCol--;
      }
      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
      VdbeComment((v, "%s", aOutEx[i].zEName));
    }
  }
  switch( eDest ){
    case SRT_Table:
    case SRT_EphemTab: {
      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
      sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
      sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
      break;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case SRT_Set: {
      assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
      sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
                        pDest->zAffSdst, nColumn);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
      break;
    }
    case SRT_Mem: {
      /* The LIMIT clause will terminate the loop for us */
      break;
    }
#endif
    case SRT_Upfrom: {
      int i2 = pDest->iSDParm2;
      int r1 = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1);
      if( i2<0 ){
        sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow);
      }else{
        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2);
      }
      break;
    }
    default: {
      assert( eDest==SRT_Output || eDest==SRT_Coroutine );
      testcase( eDest==SRT_Output );
      testcase( eDest==SRT_Coroutine );
      if( eDest==SRT_Output ){
        sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
      }else{
        sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
      }
      break;
    }
  }
  if( regRowid ){
    if( eDest==SRT_Set ){
      sqlite3ReleaseTempRange(pParse, regRow, nColumn);
    }else{
      sqlite3ReleaseTempReg(pParse, regRow);
    }
    sqlite3ReleaseTempReg(pParse, regRowid);
  }
  /* The bottom of the loop
  */
  sqlite3VdbeResolveLabel(v, addrContinue);
  if( pSort->sortFlags & SORTFLAG_UseSorter ){
    sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);

References ExprList::a, codeOffset(), Parse::db, SelectDest::eDest, HasRowid, SortCtx::iECursor, Select::iOffset, SelectDest::iSDParm, SelectDest::iSDParm2, SelectDest::iSdst, SortCtx::labelBkOut, SortCtx::labelDone, MAX, ExprList::nExpr, Parse::nMem, SortCtx::nOBSat, Parse::nTab, OP_Column, OP_Gosub, OP_IdxInsert, OP_IdxLE, OP_Insert, OP_MakeRecord, OP_NewRowid, OP_Next, OP_NullRow, OP_Once, OP_OpenPseudo, OP_OpenRead, OP_ResultRow, OP_Return, OP_SeekGE, OP_SeekRowid, OP_Sort, OP_SorterData, OP_SorterNext, OP_SorterSort, OP_Yield, OPFLAG_APPEND, Select::pEList, SortCtx::pOrderBy, Table::pSchema, Parse::pVdbe, SortCtx::regReturn, SORTFLAG_UseSorter, SortCtx::sortFlags, sqlite3ExprCode(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3OpenTable(), sqlite3PrimaryKeyIndex(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3SchemaToIndex(), sqlite3Strlen30(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SRT_Coroutine, SRT_EphemTab, SRT_Mem, SRT_Output, SRT_Set, SRT_Table, SRT_Upfrom, testcase, VdbeComment, VdbeCoverage, and SelectDest::zAffSdst.

Referenced by sqlite3Select().

◆ generateWithRecursiveQuery()

static void generateWithRecursiveQuery	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pDest )

static

Definition at line 131627 of file sqlite3.c.

 {
  SrcList *pSrc = p->pSrc;      /* The FROM clause of the recursive query */
  int nCol = p->pEList->nExpr;  /* Number of columns in the recursive table */
  Vdbe *v = pParse->pVdbe;      /* The prepared statement under construction */
  Select *pSetup = p->pPrior;   /* The setup query */
  int addrTop;                  /* Top of the loop */
  int addrCont, addrBreak;      /* CONTINUE and BREAK addresses */
  int iCurrent = 0;             /* The Current table */
  int regCurrent;               /* Register holding Current table */
  int iQueue;                   /* The Queue table */
  int iDistinct = 0;            /* To ensure unique results if UNION */
  int eDest = SRT_Fifo;         /* How to write to Queue */
  SelectDest destQueue;         /* SelectDest targetting the Queue table */
  int i;                        /* Loop counter */
  int rc;                       /* Result code */
  ExprList *pOrderBy;           /* The ORDER BY clause */
  Expr *pLimit;                 /* Saved LIMIT and OFFSET */
  int regLimit, regOffset;      /* Registers used by LIMIT and OFFSET */
 
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( p->pWin ){
    sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
    return;
  }
#endif
 
  /* Obtain authorization to do a recursive query */
  if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
 
  /* Process the LIMIT and OFFSET clauses, if they exist */
  addrBreak = sqlite3VdbeMakeLabel(pParse);
  p->nSelectRow = 320;  /* 4 billion rows */
  computeLimitRegisters(pParse, p, addrBreak);
  pLimit = p->pLimit;
  regLimit = p->iLimit;
  regOffset = p->iOffset;
  p->pLimit = 0;
  p->iLimit = p->iOffset = 0;
  pOrderBy = p->pOrderBy;
 
  /* Locate the cursor number of the Current table */
  for(i=0; ALWAYS(i<pSrc->nSrc); i++){
    if( pSrc->a[i].fg.isRecursive ){
      iCurrent = pSrc->a[i].iCursor;
      break;
    }
  }
 
  /* Allocate cursors numbers for Queue and Distinct.  The cursor number for
  ** the Distinct table must be exactly one greater than Queue in order
  ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
  iQueue = pParse->nTab++;
  if( p->op==TK_UNION ){
    eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo;
    iDistinct = pParse->nTab++;
  }else{
    eDest = pOrderBy ? SRT_Queue : SRT_Fifo;
  }
  sqlite3SelectDestInit(&destQueue, eDest, iQueue);
 
  /* Allocate cursors for Current, Queue, and Distinct. */
  regCurrent = ++pParse->nMem;
  sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
  if( pOrderBy ){
    KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
    sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
                      (char*)pKeyInfo, P4_KEYINFO);
    destQueue.pOrderBy = pOrderBy;
  }else{
    sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
  }
  VdbeComment((v, "Queue table"));
  if( iDistinct ){
    p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
    p->selFlags |= SF_UsesEphemeral;
  }
 
  /* Detach the ORDER BY clause from the compound SELECT */
  p->pOrderBy = 0;
 
  /* Store the results of the setup-query in Queue. */
  pSetup->pNext = 0;
  ExplainQueryPlan((pParse, 1, "SETUP"));
  rc = sqlite3Select(pParse, pSetup, &destQueue);
  pSetup->pNext = p;
  if( rc ) goto end_of_recursive_query;
 
  /* Find the next row in the Queue and output that row */
  addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
 
  /* Transfer the next row in Queue over to Current */
  sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
  if( pOrderBy ){
    sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
  }else{
    sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
  }
  sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
 
  /* Output the single row in Current */
  addrCont = sqlite3VdbeMakeLabel(pParse);
  codeOffset(v, regOffset, addrCont);
  selectInnerLoop(pParse, p, iCurrent,
      0, 0, pDest, addrCont, addrBreak);
  if( regLimit ){
    sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
    VdbeCoverage(v);
  }
  sqlite3VdbeResolveLabel(v, addrCont);
 
  /* Execute the recursive SELECT taking the single row in Current as
  ** the value for the recursive-table. Store the results in the Queue.
  */
  if( p->selFlags & SF_Aggregate ){
    sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
  }else{
    p->pPrior = 0;
    ExplainQueryPlan((pParse, 1, "RECURSIVE STEP"));
    sqlite3Select(pParse, p, &destQueue);
    assert( p->pPrior==0 );
    p->pPrior = pSetup;
  }
 
  /* Keep running the loop until the Queue is empty */
  sqlite3VdbeGoto(v, addrTop);
  sqlite3VdbeResolveLabel(v, addrBreak);
 

References SrcList::a, Select::addrOpenEphm, ALWAYS, codeOffset(), computeLimitRegisters(), Parse::db, ExplainQueryPlan, SrcList::SrcList_item::fg, SrcList::SrcList_item::iCursor, Select::iLimit, Select::iOffset, SrcList::SrcList_item::isRecursive, multiSelectOrderByKeyInfo(), ExprList::nExpr, Parse::nMem, Select::nSelectRow, Parse::nTab, Select::op, OP_Column, OP_DecrJumpZero, OP_Delete, OP_NullRow, OP_OpenEphemeral, OP_OpenPseudo, OP_Rewind, OP_RowData, P4_KEYINFO, Select::pEList, Select::pLimit, Select::pNext, Select::pOrderBy, SelectDest::pOrderBy, Select::pPrior, Select::pSrc, Parse::pVdbe, Select::pWin, selectInnerLoop(), Select::selFlags, SF_Aggregate, SF_UsesEphemeral, sqlite3AuthCheck(), sqlite3ErrorMsg(), sqlite3ExprListDelete(), sqlite3Select(), sqlite3SelectDestInit(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeGoto(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_RECURSIVE, SRT_DistFifo, SRT_DistQueue, SRT_Fifo, SRT_Queue, TK_UNION, VdbeComment, and VdbeCoverage.

Referenced by multiSelect().

◆ getAndInitPage()

static int getAndInitPage	(	BtShared *	pBt,
		Pgno	pgno,
		MemPage **	ppPage,
		BtCursor *	pCur,
		int	bReadOnly )

static

Definition at line 66639 of file sqlite3.c.

 {
  int rc;
  DbPage *pDbPage;
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( pCur==0 || ppPage==&pCur->pPage );
  assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
  assert( pCur==0 || pCur->iPage>0 );
 
  if( pgno>btreePagecount(pBt) ){
    rc = SQLITE_CORRUPT_BKPT;
    goto getAndInitPage_error1;
  }
  rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
  if( rc ){
    goto getAndInitPage_error1;
  }
  *ppPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
  if( (*ppPage)->isInit==0 ){
    btreePageFromDbPage(pDbPage, pgno, pBt);
    rc = btreeInitPage(*ppPage);
    if( rc!=SQLITE_OK ){
      goto getAndInitPage_error2;
    }
  }
  assert( (*ppPage)->pgno==pgno );
  assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) );
 
  /* If obtaining a child page for a cursor, we must verify that the page is
  ** compatible with the root page. */
  if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
    rc = SQLITE_CORRUPT_PGNO(pgno);
    goto getAndInitPage_error2;
  }
  return SQLITE_OK;
 
getAndInitPage_error2:
  releasePage(*ppPage);
getAndInitPage_error1:
  if( pCur ){
    pCur->iPage--;

References BtCursor::apPage, btreeInitPage(), btreePagecount(), btreePageFromDbPage(), BtCursor::curIntKey, BtCursor::curPagerFlags, BtCursor::iPage, BtShared::mutex, BtCursor::pPage, BtShared::pPager, releasePage(), sqlite3_mutex_held(), sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerGetExtra(), SQLITE_CORRUPT, SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PGNO, SQLITE_OK, and testcase.

Referenced by balance_nonroot(), moveToChild(), and moveToRoot().

◆ getAutoVacuum()

static int getAutoVacuum ( const char * z )

static

Definition at line 125836 of file sqlite3.c.

125842 {

125843 int i;

References BTREE_AUTOVACUUM_FULL, BTREE_AUTOVACUUM_INCR, BTREE_AUTOVACUUM_NONE, sqlite3Atoi(), and sqlite3StrICmp().

Referenced by sqlite3Pragma().

◆ getCellInfo()

static SQLITE_NOINLINE void getCellInfo ( BtCursor * pCur )

static

Definition at line 69023 of file sqlite3.c.

69029 {

69030 if( pCur->info.nSize==0 ){

Referenced by accessPayload(), sqlite3BtreeInsert(), sqlite3BtreeIntegerKey(), sqlite3BtreeMovetoUnpacked(), and sqlite3BtreePayloadSize().

◆ getDigits()

static int getDigits	(	const char *	zDate,
		const char *	zFormat,
			... )

static

Definition at line 21819 of file sqlite3.c.

                                                                 {
  /* The aMx[] array translates the 3rd character of each format
  ** spec into a max size:    a   b   c   d   e     f */
  static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 };
  va_list ap;
  int cnt = 0;
  char nextC;
  va_start(ap, zFormat);
  do{
    char N = zFormat[0] - '0';
    char min = zFormat[1] - '0';
    int val = 0;
    u16 max;
 
    assert( zFormat[2]>='a' && zFormat[2]<='f' );
    max = aMx[zFormat[2] - 'a'];
    nextC = zFormat[3];
    val = 0;
    while( N-- ){
      if( !sqlite3Isdigit(*zDate) ){
        goto end_getDigits;
      }
      val = val*10 + *zDate - '0';
      zDate++;
    }
    if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){
      goto end_getDigits;
    }
    *va_arg(ap,int*) = val;
    zDate++;
    cnt++;
    zFormat += 4;

References sqlite3Isdigit.

Referenced by parseHhMmSs(), parseTimezone(), and parseYyyyMmDd().

◆ getDoubleArg()

static double getDoubleArg ( PrintfArguments * p )

static

Definition at line 28290 of file sqlite3.c.

28292 {

28293 if( p->nArg<=p->nUsed ) return 0;

PrintfArguments::nUsed

int nUsed

Definition sqlite3.c:19447

PrintfArguments::nArg

int nArg

Definition sqlite3.c:19446

References PrintfArguments::nArg, and PrintfArguments::nUsed.

Referenced by sqlite3_str_vappendf().

◆ getFileMode()

static int getFileMode	(	const char *	zFile,
		mode_t *	pMode,
		uid_t *	pUid,
		gid_t *	pGid )

static

Definition at line 39382 of file sqlite3.c.

 {
  struct stat sStat;              /* Output of stat() on database file */
  int rc = SQLITE_OK;
  if( 0==osStat(zFile, &sStat) ){
    *pMode = sStat.st_mode & 0777;
    *pUid = sStat.st_uid;

Referenced by findCreateFileMode().

◆ getIntArg()

static sqlite3_int64 getIntArg ( PrintfArguments * p )

static

Definition at line 28286 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ getLockingMode()

static int getLockingMode ( const char * z )

static

Definition at line 125821 of file sqlite3.c.

125827 {

References PAGER_LOCKINGMODE_EXCLUSIVE, PAGER_LOCKINGMODE_NORMAL, PAGER_LOCKINGMODE_QUERY, and sqlite3StrICmp().

Referenced by sqlite3Pragma().

◆ getOverflowPage()

static int getOverflowPage	(	BtShared *	pBt,
		Pgno	ovfl,
		MemPage **	ppPage,
		Pgno *	pPgnoNext )

static

Definition at line 69141 of file sqlite3.c.

 {
  Pgno next = 0;
  MemPage *pPage = 0;
  int rc = SQLITE_OK;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert(pPgnoNext);
 
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* Try to find the next page in the overflow list using the
  ** autovacuum pointer-map pages. Guess that the next page in
  ** the overflow list is page number (ovfl+1). If that guess turns
  ** out to be wrong, fall back to loading the data of page
  ** number ovfl to determine the next page number.
  */
  if( pBt->autoVacuum ){
    Pgno pgno;
    Pgno iGuess = ovfl+1;
    u8 eType;
 
    while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
      iGuess++;
    }
 
    if( iGuess<=btreePagecount(pBt) ){
      rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
      if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
        next = iGuess;
        rc = SQLITE_DONE;
      }
    }
  }
#endif
 
  assert( next==0 || rc==SQLITE_DONE );
  if( rc==SQLITE_OK ){
    rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0);
    assert( rc==SQLITE_OK || pPage==0 );
    if( rc==SQLITE_OK ){
      next = get4byte(pPage->aData);
    }
  }
 
  *pPgnoNext = next;
  if( ppPage ){

References MemPage::aData, BtShared::autoVacuum, btreeGetPage(), btreePagecount(), eType, get4byte, BtShared::mutex, next, PAGER_GET_READONLY, PENDING_BYTE_PAGE, PTRMAP_ISPAGE, PTRMAP_OVERFLOW2, ptrmapGet(), releasePage(), sqlite3_mutex_held(), SQLITE_DONE, and SQLITE_OK.

Referenced by accessPayload().

◆ getPageError()

static int getPageError	(	Pager *	pPager,
		Pgno	pgno,
		DbPage **	ppPage,
		int	flags )

static

Definition at line 57326 of file sqlite3.c.

57337 {

Referenced by setGetterMethod().

◆ getPageNormal()

static int getPageNormal	(	Pager *	pPager,
		Pgno	pgno,
		DbPage **	ppPage,
		int	flags )

static

Definition at line 57155 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  PgHdr *pPg;
  u8 noContent;                   /* True if PAGER_GET_NOCONTENT is set */
  sqlite3_pcache_page *pBase;
 
  assert( pPager->errCode==SQLITE_OK );
  assert( pPager->eState>=PAGER_READER );
  assert( assert_pager_state(pPager) );
  assert( pPager->hasHeldSharedLock==1 );
 
  if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
  pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
  if( pBase==0 ){
    pPg = 0;
    rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
    if( rc!=SQLITE_OK ) goto pager_acquire_err;
    if( pBase==0 ){
      rc = SQLITE_NOMEM_BKPT;
      goto pager_acquire_err;
    }
  }
  pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
  assert( pPg==(*ppPage) );
  assert( pPg->pgno==pgno );
  assert( pPg->pPager==pPager || pPg->pPager==0 );
 
  noContent = (flags & PAGER_GET_NOCONTENT)!=0;
  if( pPg->pPager && !noContent ){
    /* In this case the pcache already contains an initialized copy of
    ** the page. Return without further ado.  */
    assert( pgno!=PAGER_MJ_PGNO(pPager) );
    pPager->aStat[PAGER_STAT_HIT]++;
    return SQLITE_OK;
 
  }else{
    /* The pager cache has created a new page. Its content needs to
    ** be initialized. But first some error checks:
    **
    ** (*) obsolete.  Was: maximum page number is 2^31
    ** (2) Never try to fetch the locking page
    */
    if( pgno==PAGER_MJ_PGNO(pPager) ){
      rc = SQLITE_CORRUPT_BKPT;
      goto pager_acquire_err;
    }
 
    pPg->pPager = pPager;
 
    assert( !isOpen(pPager->fd) || !MEMDB );
    if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
      if( pgno>pPager->mxPgno ){
        rc = SQLITE_FULL;
        goto pager_acquire_err;
      }
      if( noContent ){
        /* Failure to set the bits in the InJournal bit-vectors is benign.
        ** It merely means that we might do some extra work to journal a
        ** page that does not need to be journaled.  Nevertheless, be sure
        ** to test the case where a malloc error occurs while trying to set
        ** a bit in a bit vector.
        */
        sqlite3BeginBenignMalloc();
        if( pgno<=pPager->dbOrigSize ){
          TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
          testcase( rc==SQLITE_NOMEM );
        }
        TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
        testcase( rc==SQLITE_NOMEM );
        sqlite3EndBenignMalloc();
      }
      memset(pPg->pData, 0, pPager->pageSize);
      IOTRACE(("ZERO %p %d\n", pPager, pgno));
    }else{
      assert( pPg->pPager==pPager );
      pPager->aStat[PAGER_STAT_MISS]++;
      rc = readDbPage(pPg);
      if( rc!=SQLITE_OK ){
        goto pager_acquire_err;
      }
    }
    pager_set_pagehash(pPg);
  }
  return SQLITE_OK;
 
pager_acquire_err:
  assert( rc!=SQLITE_OK );
  if( pPg ){

References addToSavepointBitvecs(), Pager::aStat, Pager::dbSize, Pager::errCode, Pager::eState, Pager::fd, Pager::hasHeldSharedLock, IOTRACE, isOpen, MEMDB, Pager::mxPgno, PAGER_GET_NOCONTENT, PAGER_MJ_PGNO, PAGER_READER, pager_set_pagehash, PAGER_STAT_HIT, PAGER_STAT_MISS, pagerUnlockIfUnused(), Pager::pageSize, PgHdr::pData, PgHdr::pgno, Pager::pInJournal, PgHdr::pPager, Pager::pPCache, readDbPage(), sqlite3BeginBenignMalloc(), sqlite3BitvecSet(), sqlite3EndBenignMalloc(), sqlite3PcacheDrop(), sqlite3PcacheFetch(), sqlite3PcacheFetchFinish(), sqlite3PcacheFetchStress(), SQLITE_CORRUPT_BKPT, SQLITE_FULL, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, and TESTONLY.

Referenced by setGetterMethod().

◆ getPageReferenced()

static int getPageReferenced	(	IntegrityCk *	pCheck,
		Pgno	iPg )

static

Definition at line 74133 of file sqlite3.c.

References IntegrityCk::aPgRef.

Referenced by checkRef(), and sqlite3BtreeIntegrityCheck().

◆ getRowTrigger()

static TriggerPrg * getRowTrigger	(	Parse *	pParse,
		Trigger *	pTrigger,
		Table *	pTab,
		int	orconf )

static

Definition at line 137395 of file sqlite3.c.

 {
  Parse *pRoot = sqlite3ParseToplevel(pParse);
  TriggerPrg *pPrg;
 
  assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
 
  /* It may be that this trigger has already been coded (or is in the
  ** process of being coded). If this is the case, then an entry with
  ** a matching TriggerPrg.pTrigger field will be present somewhere
  ** in the Parse.pTriggerPrg list. Search for such an entry.  */
  for(pPrg=pRoot->pTriggerPrg;
      pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf);
      pPrg=pPrg->pNext
  );
 
  /* If an existing TriggerPrg could not be located, create a new one. */

References codeRowTrigger(), TriggerPrg::orconf, TriggerPrg::pNext, TriggerPrg::pTrigger, Parse::pTriggerPrg, sqlite3ParseToplevel, tableOfTrigger(), and Trigger::zName.

Referenced by sqlite3CodeRowTriggerDirect(), and sqlite3TriggerColmask().

◆ getSafetyLevel()

static u8 getSafetyLevel	(	const char *	z,
		int	omitFull,
		u8	dflt )

static

Definition at line 125783 of file sqlite3.c.

                                                              {
                             /* 123456789 123456789 123 */
  static const char zText[] = "onoffalseyestruextrafull";
  static const u8 iOffset[] = {0, 1, 2,  4,    9,  12,  15,   20};
  static const u8 iLength[] = {2, 2, 3,  5,    3,   4,   5,    4};
  static const u8 iValue[] =  {1, 0, 0,  0,    1,   1,   3,    2};
                            /* on no off false yes true extra full */
  int i, n;
  if( sqlite3Isdigit(*z) ){
    return (u8)sqlite3Atoi(z);
  }
  n = sqlite3Strlen30(z);
  for(i=0; i<ArraySize(iLength); i++){
    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0
     && (!omitFull || iValue[i]<=1)

References ArraySize, sqlite3Atoi(), sqlite3Isdigit, sqlite3Strlen30(), and sqlite3StrNICmp.

Referenced by sqlite3Pragma().

◆ getTempStore()

static int getTempStore ( const char * z )

static

Definition at line 125852 of file sqlite3.c.

                                      {
  if( z[0]>='0' && z[0]<='2' ){
    return z[0] - '0';
  }else if( sqlite3StrICmp(z, "file")==0 ){
    return 1;

References sqlite3StrICmp().

Referenced by changeTempStorage().

◆ getTextArg()

static char * getTextArg ( PrintfArguments * p )

static

Definition at line 28294 of file sqlite3.c.

28296 {

28297 if( p->nArg<=p->nUsed ) return 0.0;

Referenced by sqlite3_str_vappendf().

◆ getToken()

static int getToken ( const unsigned char ** pz )

static

Definition at line 159932 of file sqlite3.c.

                                             {
  const unsigned char *z = *pz;
  int t;                          /* Token type to return */
  do {
    z += sqlite3GetToken(z, &t);
  }while( t==TK_SPACE );
  if( t==TK_ID
   || t==TK_STRING
   || t==TK_JOIN_KW
   || t==TK_WINDOW
   || t==TK_OVER
   || sqlite3ParserFallback(t)==TK_ID

References sqlite3GetToken(), sqlite3ParserFallback(), TK_ID, TK_JOIN_KW, TK_OVER, TK_SPACE, TK_STRING, and TK_WINDOW.

Referenced by analyzeFilterKeyword().

◆ groupConcatFinalize()

static void groupConcatFinalize ( sqlite3_context * context )

static

Definition at line 118825 of file sqlite3.c.

                                                         {
  StrAccum *pAccum;
  pAccum = sqlite3_aggregate_context(context, 0);
  if( pAccum ){
    if( pAccum->accError==SQLITE_TOOBIG ){
      sqlite3_result_error_toobig(context);
    }else if( pAccum->accError==SQLITE_NOMEM ){
      sqlite3_result_error_nomem(context);

Referenced by sqlite3RegisterBuiltinFunctions().

◆ groupConcatInverse()

static void groupConcatInverse	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118794 of file sqlite3.c.

 {
  int n;
  StrAccum *pAccum;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
  /* pAccum is always non-NULL since groupConcatStep() will have always
  ** run frist to initialize it */
  if( ALWAYS(pAccum) ){
    n = sqlite3_value_bytes(argv[0]);
    if( argc==2 ){
      n += sqlite3_value_bytes(argv[1]);
    }else{
      n++;
    }
    if( n>=(int)pAccum->nChar ){
      pAccum->nChar = 0;
    }else{

Referenced by sqlite3RegisterBuiltinFunctions().

◆ groupConcatStep()

static void groupConcatStep	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118761 of file sqlite3.c.

 {
  const char *zVal;
  StrAccum *pAccum;
  const char *zSep;
  int nVal, nSep;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
 
  if( pAccum ){
    sqlite3 *db = sqlite3_context_db_handle(context);
    int firstTerm = pAccum->mxAlloc==0;
    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
    if( !firstTerm ){
      if( argc==2 ){
        zSep = (char*)sqlite3_value_text(argv[1]);
        nSep = sqlite3_value_bytes(argv[1]);
      }else{
        zSep = ",";
        nSep = 1;
      }
      if( zSep ) sqlite3_str_append(pAccum, zSep, nSep);

Referenced by sqlite3RegisterBuiltinFunctions().

◆ groupConcatValue()

static void groupConcatValue ( sqlite3_context * context )

static

Definition at line 118840 of file sqlite3.c.

                                                      {
  sqlite3_str *pAccum;
  pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0);
  if( pAccum ){
    if( pAccum->accError==SQLITE_TOOBIG ){
      sqlite3_result_error_toobig(context);
    }else if( pAccum->accError==SQLITE_NOMEM ){
      sqlite3_result_error_nomem(context);

Referenced by sqlite3RegisterBuiltinFunctions().

◆ growOp3()

static SQLITE_NOINLINE int growOp3	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2,
		int	p3 )

static

Definition at line 77960 of file sqlite3.c.

◆ growOpArray()

static int growOpArray	(	Vdbe *	v,
		int	nOp )

static

Definition at line 77889 of file sqlite3.c.

                                        {
  VdbeOp *pNew;
  Parse *p = v->pParse;
 
  /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
  ** more frequent reallocs and hence provide more opportunities for
  ** simulated OOM faults.  SQLITE_TEST_REALLOC_STRESS is generally used
  ** during testing only.  With SQLITE_TEST_REALLOC_STRESS grow the op array
  ** by the minimum* amount required until the size reaches 512.  Normal
  ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
  ** size of the op array or add 1KB of space, whichever is smaller. */
#ifdef SQLITE_TEST_REALLOC_STRESS
  sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
                        : (sqlite3_int64)v->nOpAlloc+nOp);
#else
  sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
                        : (sqlite3_int64)(1024/sizeof(Op)));
  UNUSED_PARAMETER(nOp);
#endif
 
  /* Ensure that the size of a VDBE does not grow too large */
  if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
    sqlite3OomFault(p->db);
    return SQLITE_NOMEM;
  }
 
  assert( nOp<=(1024/sizeof(Op)) );
  assert( nNew>=(v->nOpAlloc+nOp) );
  pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
  if( pNew ){

References sqlite3::aLimit, Vdbe::aOp, Parse::db, Vdbe::nOpAlloc, Vdbe::pParse, sqlite3DbMallocSize(), sqlite3DbRealloc(), sqlite3OomFault(), SQLITE_LIMIT_VDBE_OP, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, Parse::szOpAlloc, and UNUSED_PARAMETER.

Referenced by sqlite3VdbeAddOp3(), and sqlite3VdbeAddOpList().

◆ growVTrans()

static int growVTrans ( sqlite3 * db )

static

Definition at line 140288 of file sqlite3.c.

                                  {
  const int ARRAY_INCR = 5;
 
  /* Grow the sqlite3.aVTrans array if required */
  if( (db->nVTrans%ARRAY_INCR)==0 ){
    VTable **aVTrans;
    sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*
                                 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
    aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
    if( !aVTrans ){
      return SQLITE_NOMEM_BKPT;
    }

Referenced by sqlite3VtabBegin(), and sqlite3VtabCallCreate().

◆ handleMovedCursor()

static int SQLITE_NOINLINE handleMovedCursor ( VdbeCursor * p )

static

Definition at line 81261 of file sqlite3.c.

                                                           {
  int isDifferentRow, rc;
  assert( p->eCurType==CURTYPE_BTREE );
  assert( p->uc.pCursor!=0 );

References CACHE_STALE, VdbeCursor::cacheStatus, CURTYPE_BTREE, VdbeCursor::eCurType, VdbeCursor::nullRow, VdbeCursor::pCursor, sqlite3BtreeCursorHasMoved(), sqlite3BtreeCursorRestore(), and VdbeCursor::uc.

Referenced by sqlite3VdbeCursorMoveto().

◆ hasColumn()

static int hasColumn	(	const i16 *	aiCol,
		int	nCol,
		int	x )

static

Definition at line 112323 of file sqlite3.c.

                                                       {
  while( nCol-- > 0 ){
    assert( aiCol[0]>=0 );

Referenced by convertToWithoutRowidTable(), and sqlite3CreateIndex().

◆ hasHotJournal()

static int hasHotJournal	(	Pager *	pPager,
		int *	pExists )

static

Definition at line 56754 of file sqlite3.c.

                                                     {
  sqlite3_vfs * const pVfs = pPager->pVfs;
  int rc = SQLITE_OK;           /* Return code */
  int exists = 1;               /* True if a journal file is present */
  int jrnlOpen = !!isOpen(pPager->jfd);
 
  assert( pPager->useJournal );
  assert( isOpen(pPager->fd) );
  assert( pPager->eState==PAGER_OPEN );
 
  assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
    SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
  ));
 
  *pExists = 0;
  if( !jrnlOpen ){
    rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
  }
  if( rc==SQLITE_OK && exists ){
    int locked = 0;             /* True if some process holds a RESERVED lock */
 
    /* Race condition here:  Another process might have been holding the
    ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
    ** call above, but then delete the journal and drop the lock before
    ** we get to the following sqlite3OsCheckReservedLock() call.  If that
    ** is the case, this routine might think there is a hot journal when
    ** in fact there is none.  This results in a false-positive which will
    ** be dealt with by the playback routine.  Ticket #3883.
    */
    rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
    if( rc==SQLITE_OK && !locked ){
      Pgno nPage;                 /* Number of pages in database file */
 
      assert( pPager->tempFile==0 );
      rc = pagerPagecount(pPager, &nPage);
      if( rc==SQLITE_OK ){
        /* If the database is zero pages in size, that means that either (1) the
        ** journal is a remnant from a prior database with the same name where
        ** the database file but not the journal was deleted, or (2) the initial
        ** transaction that populates a new database is being rolled back.
        ** In either case, the journal file can be deleted.  However, take care
        ** not to delete the journal file if it is already open due to
        ** journal_mode=PERSIST.
        */
        if( nPage==0 && !jrnlOpen ){
          sqlite3BeginBenignMalloc();
          if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
            sqlite3OsDelete(pVfs, pPager->zJournal, 0);
            if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
          }
          sqlite3EndBenignMalloc();
        }else{
          /* The journal file exists and no other connection has a reserved
          ** or greater lock on the database file. Now check that there is
          ** at least one non-zero bytes at the start of the journal file.
          ** If there is, then we consider this journal to be hot. If not,
          ** it can be ignored.
          */
          if( !jrnlOpen ){
            int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
            rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
          }
          if( rc==SQLITE_OK ){
            u8 first = 0;
            rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
            if( rc==SQLITE_IOERR_SHORT_READ ){
              rc = SQLITE_OK;
            }
            if( !jrnlOpen ){
              sqlite3OsClose(pPager->jfd);
            }
            *pExists = (first!=0);
          }else if( rc==SQLITE_CANTOPEN ){
            /* If we cannot open the rollback journal file in order to see if
            ** it has a zero header, that might be due to an I/O error, or
            ** it might be due to the race condition described above and in
            ** ticket #3883.  Either way, assume that the journal is hot.
            ** This might be a false positive.  But if it is, then the
            ** automatic journal playback and recovery mechanism will deal
            ** with it under an EXCLUSIVE lock where we do not need to
            ** worry so much with race conditions.
            */
            *pExists = 1;
            rc = SQLITE_OK;
          }
        }

References Pager::eState, Pager::exclusiveMode, Pager::fd, isOpen, Pager::jfd, PAGER_OPEN, pagerLockDb(), pagerPagecount(), pagerUnlockDb(), Pager::pVfs, RESERVED_LOCK, SHARED_LOCK, sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), sqlite3OsAccess(), sqlite3OsCheckReservedLock(), sqlite3OsClose(), sqlite3OsDelete(), sqlite3OsDeviceCharacteristics(), sqlite3OsOpen(), sqlite3OsRead(), SQLITE_ACCESS_EXISTS, SQLITE_CANTOPEN, SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN, SQLITE_IOERR_SHORT_READ, SQLITE_OK, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_READONLY, Pager::tempFile, Pager::useJournal, and Pager::zJournal.

Referenced by sqlite3PagerSharedLock().

◆ havingToWhere()

static void havingToWhere	(	Parse *	pParse,
		Select *	p )

static

Definition at line 134912 of file sqlite3.c.

                                                   {
  Walker sWalker;
  memset(&sWalker, 0, sizeof(sWalker));
  sWalker.pParse = pParse;
  sWalker.xExprCallback = havingToWhereExprCb;
  sWalker.u.pSelect = p;
  sqlite3WalkExpr(&sWalker, p->pHaving);
#if SELECTTRACE_ENABLED

References Walker::eCode, havingToWhereExprCb(), Select::pHaving, Walker::pParse, Walker::pSelect, SELECTTRACE, sqlite3_unsupported_selecttrace, sqlite3WalkExpr(), Walker::u, and Walker::xExprCallback.

Referenced by sqlite3Select().

◆ havingToWhereExprCb()

static int havingToWhereExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 134878 of file sqlite3.c.

                                                            {
  if( pExpr->op!=TK_AND ){
    Select *pS = pWalker->u.pSelect;
    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
      sqlite3 *db = pWalker->pParse->db;
      Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
      if( pNew ){
        Expr *pWhere = pS->pWhere;
        SWAP(Expr, *pNew, *pExpr);
        pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
        pS->pWhere = pNew;
        pWalker->eCode = 1;

References Parse::db, Walker::eCode, Expr::op, Select::pGroupBy, Walker::pParse, Walker::pSelect, Select::pWhere, sqlite3Expr(), sqlite3ExprAnd(), sqlite3ExprIsConstantOrGroupBy(), SWAP, TK_AND, TK_INTEGER, Walker::u, WRC_Continue, and WRC_Prune.

Referenced by havingToWhere().

◆ heightOfExpr()

static void heightOfExpr	(	Expr *	p,
		int *	pnHeight )

static

Definition at line 100400 of file sqlite3.c.

100406 {

Referenced by exprSetHeight(), and heightOfSelect().

◆ heightOfExprList()

static void heightOfExprList	(	ExprList *	p,
		int *	pnHeight )

static

Definition at line 100407 of file sqlite3.c.

         {
    if( p->nHeight>*pnHeight ){
      *pnHeight = p->nHeight;
    }
  }
}
static void heightOfExprList(ExprList *p, int *pnHeight){
  if( p ){

References Expr::nHeight.

Referenced by exprSetHeight().

◆ heightOfSelect()

static void heightOfSelect	(	Select *	pSelect,
		int *	pnHeight )

static

Definition at line 100415 of file sqlite3.c.

                             {
      heightOfExpr(p->a[i].pExpr, pnHeight);
    }
  }
}
static void heightOfSelect(Select *pSelect, int *pnHeight){
  Select *p;
  for(p=pSelect; p; p=p->pPrior){
    heightOfExpr(p->pWhere, pnHeight);
    heightOfExpr(p->pHaving, pnHeight);

References ExprList::a, heightOfExpr(), and ExprList::ExprList_item::pExpr.

Referenced by exprSetHeight().

◆ hexFunc()

static void hexFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118211 of file sqlite3.c.

 {
  int i, n;
  const unsigned char *pBlob;
  char *zHex, *z;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  pBlob = sqlite3_value_blob(argv[0]);
  n = sqlite3_value_bytes(argv[0]);
  assert( pBlob==sqlite3_value_blob(argv[0]) );  /* No encoding change */
  z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
  if( zHex ){
    for(i=0; i<n; i++, pBlob++){
      unsigned char c = *pBlob;
      *(z++) = hexdigits[(c>>4)&0xf];

Referenced by sqlite3RegisterBuiltinFunctions().

◆ identLength()

static int identLength ( const char * z )

static

Definition at line 112152 of file sqlite3.c.

112158 {

Referenced by createTableStmt().

◆ identPut()

static void identPut	(	char *	z,
		int *	pIdx,
		char *	zSignedIdent )

static

Definition at line 112173 of file sqlite3.c.

                                                            {
  unsigned char *zIdent = (unsigned char*)zSignedIdent;
  int i, j, needQuote;
  i = *pIdx;
 
  for(j=0; zIdent[j]; j++){
    if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
  }
  needQuote = sqlite3Isdigit(zIdent[0])
            || sqlite3KeywordCode(zIdent, j)!=TK_ID
            || zIdent[j]!=0
            || j==0;
 
  if( needQuote ) z[i++] = '"';
  for(j=0; zIdent[j]; j++){
    z[i++] = zIdent[j];

References sqlite3Isalnum, sqlite3Isdigit, sqlite3KeywordCode(), and TK_ID.

Referenced by createTableStmt().

◆ impliesNotNullRow()

static int impliesNotNullRow	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 105180 of file sqlite3.c.

                                                          {
  testcase( pExpr->op==TK_AGG_COLUMN );
  testcase( pExpr->op==TK_AGG_FUNCTION );
  if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune;
  switch( pExpr->op ){
    case TK_ISNOT:
    case TK_ISNULL:
    case TK_NOTNULL:
    case TK_IS:
    case TK_OR:
    case TK_VECTOR:
    case TK_CASE:
    case TK_IN:
    case TK_FUNCTION:
    case TK_TRUTH:
      testcase( pExpr->op==TK_ISNOT );
      testcase( pExpr->op==TK_ISNULL );
      testcase( pExpr->op==TK_NOTNULL );
      testcase( pExpr->op==TK_IS );
      testcase( pExpr->op==TK_OR );
      testcase( pExpr->op==TK_VECTOR );
      testcase( pExpr->op==TK_CASE );
      testcase( pExpr->op==TK_IN );
      testcase( pExpr->op==TK_FUNCTION );
      testcase( pExpr->op==TK_TRUTH );
      return WRC_Prune;
    case TK_COLUMN:
      if( pWalker->u.iCur==pExpr->iTable ){
        pWalker->eCode = 1;
        return WRC_Abort;
      }
      return WRC_Prune;
 
    case TK_AND:
      if( pWalker->eCode==0 ){
        sqlite3WalkExpr(pWalker, pExpr->pLeft);
        if( pWalker->eCode ){
          pWalker->eCode = 0;
          sqlite3WalkExpr(pWalker, pExpr->pRight);
        }
      }
      return WRC_Prune;
 
    case TK_BETWEEN:
      if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){
        assert( pWalker->eCode );
        return WRC_Abort;
      }
      return WRC_Prune;
 
    /* Virtual tables are allowed to use constraints like x=NULL.  So
    ** a term of the form x=y does not prove that y is not null if x
    ** is the column of a virtual table */
    case TK_EQ:
    case TK_NE:
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE: {
      Expr *pLeft = pExpr->pLeft;
      Expr *pRight = pExpr->pRight;
      testcase( pExpr->op==TK_EQ );
      testcase( pExpr->op==TK_NE );
      testcase( pExpr->op==TK_LT );
      testcase( pExpr->op==TK_LE );
      testcase( pExpr->op==TK_GT );
      testcase( pExpr->op==TK_GE );
      /* The y.pTab=0 assignment in wherecode.c always happens after the
      ** impliesNotNullRow() test */
      if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0)
                               && IsVirtual(pLeft->y.pTab))
       || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0)
                               && IsVirtual(pRight->y.pTab))
      ){
        return WRC_Prune;
      }

References ALWAYS, deliberate_fall_through, Walker::eCode, EP_FromJoin, ExprHasProperty, Walker::iCur, IsVirtual, Expr::iTable, Expr::op, Expr::pLeft, Expr::pRight, Expr::pTab, sqlite3WalkExpr(), testcase, TK_AGG_COLUMN, TK_AGG_FUNCTION, TK_AND, TK_BETWEEN, TK_CASE, TK_COLUMN, TK_EQ, TK_FUNCTION, TK_GE, TK_GT, TK_IN, TK_IS, TK_ISNOT, TK_ISNULL, TK_LE, TK_LT, TK_NE, TK_NOTNULL, TK_OR, TK_TRUTH, TK_VECTOR, Walker::u, WRC_Abort, WRC_Continue, WRC_Prune, and Expr::y.

Referenced by sqlite3ExprImpliesNonNullRow().

◆ incrAggDepth()

static int incrAggDepth	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 97784 of file sqlite3.c.

◆ incrAggFunctionDepth()

static void incrAggFunctionDepth	(	Expr *	pExpr,
		int	N )

static

Definition at line 97788 of file sqlite3.c.

                                                     {
  if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
  return WRC_Continue;
}
static void incrAggFunctionDepth(Expr *pExpr, int N){
  if( N>0 ){
    Walker w;

References Walker::n, Expr::op, Expr::op2, TK_AGG_FUNCTION, Walker::u, and WRC_Continue.

Referenced by resolveAlias().

◆ incrVacuumStep()

static int incrVacuumStep	(	BtShared *	pBt,
		Pgno	nFin,
		Pgno	iLastPg,
		int	bCommit )

static

Definition at line 68230 of file sqlite3.c.

                                                                              {
  Pgno nFreeList;           /* Number of pages still on the free-list */
  int rc;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( iLastPg>nFin );
 
  if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
    u8 eType;
    Pgno iPtrPage;
 
    nFreeList = get4byte(&pBt->pPage1->aData[36]);
    if( nFreeList==0 ){
      return SQLITE_DONE;
    }
 
    rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( eType==PTRMAP_ROOTPAGE ){
      return SQLITE_CORRUPT_BKPT;
    }
 
    if( eType==PTRMAP_FREEPAGE ){
      if( bCommit==0 ){
        /* Remove the page from the files free-list. This is not required
        ** if bCommit is non-zero. In that case, the free-list will be
        ** truncated to zero after this function returns, so it doesn't
        ** matter if it still contains some garbage entries.
        */
        Pgno iFreePg;
        MemPage *pFreePg;
        rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT);
        if( rc!=SQLITE_OK ){
          return rc;
        }
        assert( iFreePg==iLastPg );
        releasePage(pFreePg);
      }
    } else {
      Pgno iFreePg;             /* Index of free page to move pLastPg to */
      MemPage *pLastPg;
      u8 eMode = BTALLOC_ANY;   /* Mode parameter for allocateBtreePage() */
      Pgno iNear = 0;           /* nearby parameter for allocateBtreePage() */
 
      rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
      if( rc!=SQLITE_OK ){
        return rc;
      }
 
      /* If bCommit is zero, this loop runs exactly once and page pLastPg
      ** is swapped with the first free page pulled off the free list.
      **
      ** On the other hand, if bCommit is greater than zero, then keep
      ** looping until a free-page located within the first nFin pages
      ** of the file is found.
      */
      if( bCommit==0 ){
        eMode = BTALLOC_LE;
        iNear = nFin;
      }
      do {
        MemPage *pFreePg;
        rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode);
        if( rc!=SQLITE_OK ){
          releasePage(pLastPg);
          return rc;
        }
        releasePage(pFreePg);
      }while( bCommit && iFreePg>nFin );
      assert( iFreePg<iLastPg );
 
      rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, bCommit);
      releasePage(pLastPg);
      if( rc!=SQLITE_OK ){
        return rc;
      }
    }
  }
 
  if( bCommit==0 ){
    do {
      iLastPg--;

References MemPage::aData, allocateBtreePage(), BtShared::bDoTruncate, BTALLOC_ANY, BTALLOC_EXACT, BTALLOC_LE, btreeGetPage(), eType, get4byte, BtShared::mutex, BtShared::nPage, PENDING_BYTE_PAGE, BtShared::pPage1, PTRMAP_FREEPAGE, PTRMAP_ISPAGE, PTRMAP_ROOTPAGE, ptrmapGet(), releasePage(), relocatePage(), sqlite3_mutex_held(), SQLITE_CORRUPT_BKPT, SQLITE_DONE, and SQLITE_OK.

Referenced by autoVacuumCommit(), and sqlite3BtreeIncrVacuum().

◆ indexColumnIsBeingUpdated()

static int indexColumnIsBeingUpdated	(	Index *	pIdx,
		int	iCol,
		int *	aXRef,
		int	chngRowid )

static

Definition at line 137688 of file sqlite3.c.

 {
  i16 iIdxCol = pIdx->aiColumn[iCol];
  assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */
  if( iIdxCol>=0 ){
    return aXRef[iIdxCol]>=0;
  }

References ExprList::a, Index::aColExpr, Index::aiColumn, ExprList::ExprList_item::pExpr, sqlite3ExprReferencesUpdatedColumn(), XN_EXPR, and XN_ROWID.

Referenced by sqlite3Update().

◆ indexColumnNotNull()

static int indexColumnNotNull	(	Index *	pIdx,
		int	iCol )

static

Definition at line 146087 of file sqlite3.c.

                                                    {
  int j;
  assert( pIdx!=0 );
  assert( iCol>=0 && iCol<pIdx->nColumn );
  j = pIdx->aiColumn[iCol];
  if( j>=0 ){
    return pIdx->pTable->aCol[j].notNull;
  }else if( j==(-1) ){
    return 1;

Referenced by isDistinctRedundant(), and whereLoopAddBtreeIndex().

◆ indexMightHelpWithOrderBy()

static int indexMightHelpWithOrderBy	(	WhereLoopBuilder *	pBuilder,
		Index *	pIndex,
		int	iCursor )

static

Definition at line 148405 of file sqlite3.c.

 {
  ExprList *pOB;
  ExprList *aColExpr;
  int ii, jj;
 
  if( pIndex->bUnordered ) return 0;
  if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0;
  for(ii=0; ii<pOB->nExpr; ii++){
    Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
    if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){
      if( pExpr->iColumn<0 ) return 1;
      for(jj=0; jj<pIndex->nKeyCol; jj++){
        if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
      }
    }else if( (aColExpr = pIndex->aColExpr)!=0 ){
      for(jj=0; jj<pIndex->nKeyCol; jj++){
        if( pIndex->aiColumn[jj]!=XN_EXPR ) continue;
        if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
          return 1;

References ExprList::a, Index::aColExpr, Index::aiColumn, Index::bUnordered, Expr::iColumn, Expr::iTable, ExprList::nExpr, Index::nKeyCol, Expr::op, ExprList::ExprList_item::pExpr, WhereInfo::pOrderBy, WhereLoopBuilder::pWInfo, sqlite3ExprCompareSkip(), sqlite3ExprSkipCollateAndLikely(), TK_COLUMN, and XN_EXPR.

Referenced by whereLoopAddBtree().

◆ indexWhereClauseMightChange()

static int indexWhereClauseMightChange	(	Index *	pIdx,
		int *	aXRef,
		int	chngRowid )

static

Definition at line 137718 of file sqlite3.c.

References Index::pPartIdxWhere, and sqlite3ExprReferencesUpdatedColumn().

Referenced by sqlite3Update().

◆ initMemArray()

static void initMemArray	(	Mem *	p,
		int	N,
		sqlite3 *	db,
		u16	flags )

static

Definition at line 79598 of file sqlite3.c.

                                                               {
  while( (N--)>0 ){
    p->db = db;
    p->flags = flags;
    p->szMalloc = 0;

Referenced by sqlite3VdbeMakeReady(), and sqlite3VdbeSetNumCols().

◆ innerLoopLoadRow()

static void innerLoopLoadRow	(	Parse *	pParse,
		Select *	pSelect,
		RowLoadInfo *	pInfo )

static

Definition at line 129834 of file sqlite3.c.

 {
  sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
                          0, pInfo->ecelFlags);
#ifdef SQLITE_ENABLE_SORTER_REFERENCES

Referenced by makeSorterRecord(), and selectInnerLoop().

◆ insertCell()

static void insertCell	(	MemPage *	pPage,
		int	i,
		u8 *	pCell,
		int	sz,
		u8 *	pTemp,
		Pgno	iChild,
		int *	pRC )

static

Definition at line 71184 of file sqlite3.c.

 {
  int idx = 0;      /* Where to write new cell content in data[] */
  int j;            /* Loop counter */
  u8 *data;         /* The content of the whole page */
  u8 *pIns;         /* The point in pPage->aCellIdx[] where no cell inserted */
 
  assert( *pRC==SQLITE_OK );
  assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
  assert( MX_CELL(pPage->pBt)<=10921 );
  assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
  assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) );
  assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB );
  assert( pPage->nFree>=0 );
  if( pPage->nOverflow || sz+2>pPage->nFree ){
    if( pTemp ){
      memcpy(pTemp, pCell, sz);
      pCell = pTemp;
    }
    if( iChild ){
      put4byte(pCell, iChild);
    }
    j = pPage->nOverflow++;
    /* Comparison against ArraySize-1 since we hold back one extra slot
    ** as a contingency.  In other words, never need more than 3 overflow
    ** slots but 4 are allocated, just to be safe. */
    assert( j < ArraySize(pPage->apOvfl)-1 );
    pPage->apOvfl[j] = pCell;
    pPage->aiOvfl[j] = (u16)i;
 
    /* When multiple overflows occur, they are always sequential and in
    ** sorted order.  This invariants arise because multiple overflows can
    ** only occur when inserting divider cells into the parent page during
    ** balancing, and the dividers are adjacent and sorted.
    */
    assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
    assert( j==0 || i==pPage->aiOvfl[j-1]+1 );   /* Overflows are sequential */
  }else{
    int rc = sqlite3PagerWrite(pPage->pDbPage);
    if( rc!=SQLITE_OK ){
      *pRC = rc;
      return;
    }
    assert( sqlite3PagerIswriteable(pPage->pDbPage) );
    data = pPage->aData;
    assert( &data[pPage->cellOffset]==pPage->aCellIdx );
    rc = allocateSpace(pPage, sz, &idx);
    if( rc ){ *pRC = rc; return; }
    /* The allocateSpace() routine guarantees the following properties
    ** if it returns successfully */
    assert( idx >= 0 );
    assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB );
    assert( idx+sz <= (int)pPage->pBt->usableSize );
    pPage->nFree -= (u16)(2 + sz);
    if( iChild ){
      /* In a corrupt database where an entry in the cell index section of
      ** a btree page has a value of 3 or less, the pCell value might point
      ** as many as 4 bytes in front of the start of the aData buffer for
      ** the source page.  Make sure this does not cause problems by not
      ** reading the first 4 bytes */
      memcpy(&data[idx+4], pCell+4, sz-4);
      put4byte(&data[idx], iChild);
    }else{
      memcpy(&data[idx], pCell, sz);
    }
    pIns = pPage->aCellIdx + i*2;
    memmove(pIns+2, pIns, 2*(pPage->nCell - i));
    put2byte(pIns, idx);
    pPage->nCell++;
    /* increment the cell count */
    if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++;
    assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pPage->pBt->autoVacuum ){
      /* The cell may contain a pointer to an overflow page. If so, write
      ** the entry for the overflow page into the pointer map.

References MemPage::aCellIdx, MemPage::aData, MemPage::aiOvfl, allocateSpace(), MemPage::apOvfl, ArraySize, BtShared::autoVacuum, MemPage::cellOffset, CORRUPT_DB, get2byte, MemPage::hdrOffset, BtShared::mutex, MX_CELL, MemPage::nCell, MemPage::nFree, MemPage::nOverflow, MemPage::pBt, MemPage::pDbPage, ptrmapPutOvflPtr(), put2byte, put4byte, sqlite3_mutex_held(), sqlite3PagerWrite(), SQLITE_OK, BtShared::usableSize, and MemPage::xCellSize.

Referenced by balance_nonroot(), balance_quick(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ insertElement()

static void insertElement	(	Hash *	pH,
		struct _ht *	pEntry,
		HashElem *	pNew )

static

Definition at line 32949 of file sqlite3.c.

 {
  HashElem *pHead;       /* First element already in pEntry */
  if( pEntry ){
    pHead = pEntry->count ? pEntry->chain : 0;
    pEntry->count++;
    pEntry->chain = pNew;
  }else{
    pHead = 0;
  }
  if( pHead ){
    pNew->next = pHead;
    pNew->prev = pHead->prev;
    if( pHead->prev ){ pHead->prev->next = pNew; }
    else             { pH->first = pNew; }
    pHead->prev = pNew;
  }else{

Referenced by rehash(), and sqlite3HashInsert().

◆ instrFunc()

static void instrFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117239 of file sqlite3.c.

 {
  const unsigned char *zHaystack;
  const unsigned char *zNeedle;
  int nHaystack;
  int nNeedle;
  int typeHaystack, typeNeedle;
  int N = 1;
  int isText;
  unsigned char firstChar;
  sqlite3_value *pC1 = 0;
  sqlite3_value *pC2 = 0;
 
  UNUSED_PARAMETER(argc);
  typeHaystack = sqlite3_value_type(argv[0]);
  typeNeedle = sqlite3_value_type(argv[1]);
  if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;
  nHaystack = sqlite3_value_bytes(argv[0]);
  nNeedle = sqlite3_value_bytes(argv[1]);
  if( nNeedle>0 ){
    if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
      zHaystack = sqlite3_value_blob(argv[0]);
      zNeedle = sqlite3_value_blob(argv[1]);
      isText = 0;
    }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){
      zHaystack = sqlite3_value_text(argv[0]);
      zNeedle = sqlite3_value_text(argv[1]);
      isText = 1;
    }else{
      pC1 = sqlite3_value_dup(argv[0]);
      zHaystack = sqlite3_value_text(pC1);
      if( zHaystack==0 ) goto endInstrOOM;
      nHaystack = sqlite3_value_bytes(pC1);
      pC2 = sqlite3_value_dup(argv[1]);
      zNeedle = sqlite3_value_text(pC2);
      if( zNeedle==0 ) goto endInstrOOM;
      nNeedle = sqlite3_value_bytes(pC2);
      isText = 1;
    }
    if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM;
    firstChar = zNeedle[0];
    while( nNeedle<=nHaystack
       && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0)
    ){
      N++;
      do{
        nHaystack--;
        zHaystack++;
      }while( isText && (zHaystack[0]&0xc0)==0x80 );
    }
    if( nNeedle>nHaystack ) N = 0;
  }
  sqlite3_result_int(context, N);
endInstr:
  sqlite3_value_free(pC1);

References sqlite3_result_error_nomem(), sqlite3_result_int(), sqlite3_value_blob(), sqlite3_value_bytes(), sqlite3_value_dup(), sqlite3_value_free(), sqlite3_value_text(), sqlite3_value_type(), SQLITE_BLOB, SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ integrityCheckResultRow()

static int integrityCheckResultRow ( Vdbe * v )

static

Definition at line 126093 of file sqlite3.c.

                                               :
**
** Generate code to output a single-column result row with a value of the
** string held in register 3.  Decrement the result count in register 1
** and halt if the maximum number of result rows have been issued.
*/
static int integrityCheckResultRow(Vdbe *v){
  int addr;

References OP_Halt, OP_IfPos, OP_ResultRow, sqlite3VdbeAddOp0(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeCurrentAddr(), and VdbeCoverage.

Referenced by sqlite3Pragma().

◆ invalidateAllOverflowCache()

static void invalidateAllOverflowCache ( BtShared * pBt )

static

Definition at line 64987 of file sqlite3.c.

64993 {

References invalidateOverflowCache, BtShared::mutex, BtShared::pCursor, BtCursor::pNext, and sqlite3_mutex_held().

Referenced by autoVacuumCommit(), btreeCreateTable(), and sqlite3BtreeIncrVacuum().

◆ invalidateIncrblobCursors()

static void invalidateIncrblobCursors	(	Btree *	pBtree,
		Pgno	pgnoRoot,
		i64	iRow,
		int	isClearTable )

static

Definition at line 65009 of file sqlite3.c.

 {
  BtCursor *p;
  if( pBtree->hasIncrblobCur==0 ) return;
  assert( sqlite3BtreeHoldsMutex(pBtree) );
  pBtree->hasIncrblobCur = 0;
  for(p=pBtree->pBt->pCursor; p; p=p->pNext){
    if( (p->curFlags & BTCF_Incrblob)!=0 ){
      pBtree->hasIncrblobCur = 1;

References BTCF_Incrblob, BtCursor::curFlags, CURSOR_INVALID, BtCursor::eState, Btree::hasIncrblobCur, BtCursor::info, CellInfo::nKey, Btree::pBt, BtShared::pCursor, BtCursor::pgnoRoot, and BtCursor::pNext.

Referenced by sqlite3BtreeClearTable(), sqlite3BtreeDelete(), and sqlite3BtreeInsert().

◆ invalidateTempStorage()

static int invalidateTempStorage ( Parse * pParse )

static

Definition at line 125870 of file sqlite3.c.

                                               {
  sqlite3 *db = pParse->db;
  if( db->aDb[1].pBt!=0 ){
    if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
      sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
        "from within a transaction");
      return SQLITE_ERROR;
    }

References sqlite3::aDb, sqlite3::autoCommit, Parse::db, Db::pBt, sqlite3BtreeClose(), sqlite3BtreeIsInReadTrans(), sqlite3ErrorMsg(), sqlite3ResetAllSchemasOfConnection(), SQLITE_ERROR, and SQLITE_OK.

Referenced by changeTempStorage(), and sqlite3Pragma().

◆ invokeProfileCallback()

static SQLITE_NOINLINE void invokeProfileCallback	(	sqlite3 *	db,
		Vdbe *	p )

static

Definition at line 83042 of file sqlite3.c.

                                                                       {
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }

References sqlite3::sqlite3InitInfo::busy, sqlite3::init, sqlite3::mTrace, sqlite3::pProfileArg, sqlite3::pTraceArg, sqlite3::pVfs, sqlite3OsCurrentTimeInt64(), SQLITE_TRACE_PROFILE, SQLITE_TRACE_XPROFILE, Vdbe::startTime, sqlite3::trace, sqlite3::xProfile, sqlite3::xV2, and Vdbe::zSql.

◆ invokeValueDestructor()

static int invokeValueDestructor	(	const void *	p,
		void()(void )	xDel,
		sqlite3_context *	pCtx )

static

Definition at line 83363 of file sqlite3.c.

 {
  if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){
    sqlite3_result_error_toobig(pCtx);
  }
}
static int invokeValueDestructor(
  const void *p,             /* Value to destroy */
  void (*xDel)(void*),       /* The destructor */
  sqlite3_context *pCtx      /* Set a SQLITE_TOOBIG error if no NULL */
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( xDel==0 ){
    /* noop */
  }else if( xDel==SQLITE_TRANSIENT ){
    /* noop */

References sqlite3_context::pOut, sqlite3_result_error_toobig(), sqlite3VdbeMemSetStr(), and SQLITE_TOOBIG.

Referenced by sqlite3_bind_double(), and sqlite3_result_double().

◆ IOMETHODS()

IOMETHODS	(	posixIoFinder	,
		posixIoMethods	,
		IOMETHODS(	3,
		unixClose	,
		unixLock	,
		unixUnlock	,
		unixCheckReservedLock	,
		unixShmMap	)

Definition at line 38844 of file sqlite3.c.

 {
  static const struct Mapping {
    const char *zFilesystem;              /* Filesystem type name */
    const sqlite3_io_methods *pMethods;   /* Appropriate locking method */
  } aMap[] = {
    { "hfs",    &posixIoMethods },
    { "ufs",    &posixIoMethods },
    { "afpfs",  &afpIoMethods },
    { "smbfs",  &afpIoMethods },
    { "webdav", &nolockIoMethods },
    { 0, 0 }
  };
  int i;
  struct statfs fsInfo;
  struct flock lockInfo;
 
  if( !filePath ){
    /* If filePath==NULL that means we are dealing with a transient file
    ** that does not need to be locked. */
    return &nolockIoMethods;
  }
  if( statfs(filePath, &fsInfo) != -1 ){
    if( fsInfo.f_flags & MNT_RDONLY ){
      return &nolockIoMethods;
    }
    for(i=0; aMap[i].zFilesystem; i++){
      if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
        return aMap[i].pMethods;
      }
    }
  }
 
  /* Default case. Handles, amongst others, "nfs".
  ** Test byte-range lock using fcntl(). If the call succeeds,
  ** assume that the file-system supports POSIX style locks.
  */
  lockInfo.l_len = 1;
  lockInfo.l_start = 0;
  lockInfo.l_whence = SEEK_SET;
  lockInfo.l_type = F_RDLCK;
  if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
    if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
      return &nfsIoMethods;
    } else {
      return &posixIoMethods;
    }
  }else{
    return &dotlockIoMethods;
  }
}
static const sqlite3_io_methods
  *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
 
#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
 
#if OS_VXWORKS
/*
** This "finder" function for VxWorks checks to see if posix advisory
** locking works.  If it does, then that is what is used.  If it does not
** work, then fallback to named semaphore locking.
*/
static const sqlite3_io_methods *vxworksIoFinderImpl(
  const char *filePath,    /* name of the database file */
  unixFile *pNew           /* the open file object */
){
  struct flock lockInfo;
 
  if( !filePath ){
    /* If filePath==NULL that means we are dealing with a transient file
    ** that does not need to be locked. */
    return &nolockIoMethods;
  }
 
  /* Test if fcntl() is supported and use POSIX style locks.
  ** Otherwise fall back to the named semaphore method.
  */
  lockInfo.l_len = 1;
  lockInfo.l_start = 0;
  lockInfo.l_whence = SEEK_SET;
  lockInfo.l_type = F_RDLCK;
  if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
    return &posixIoMethods;
  }else{
    return &semIoMethods;
  }
}
static const sqlite3_io_methods
  *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl;
 
#endif /* OS_VXWORKS */
 
/*
** An abstract type for a pointer to an IO method finder function:
*/
typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*);
 
 
/****************************************************************************
**************************** sqlite3_vfs methods ****************************
**
** This division contains the implementation of methods on the
** sqlite3_vfs object.
*/
 
/*
** Initialize the contents of the unixFile structure pointed to by pId.
*/
static int fillInUnixFile(
  sqlite3_vfs *pVfs,      /* Pointer to vfs object */
  int h,                  /* Open file descriptor of file being opened */
  sqlite3_file *pId,      /* Write to the unixFile structure here */
  const char *zFilename,  /* Name of the file being opened */
  int ctrlFlags           /* Zero or more UNIXFILE_* values */
){
  const sqlite3_io_methods *pLockingStyle;
  unixFile *pNew = (unixFile *)pId;
  int rc = SQLITE_OK;
 
  assert( pNew->pInode==NULL );
 
  /* No locking occurs in temporary files */
  assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
 
  OSTRACE(("OPEN    %-3d %s\n", h, zFilename));
  pNew->h = h;
  pNew->pVfs = pVfs;
  pNew->zPath = zFilename;
  pNew->ctrlFlags = (u8)ctrlFlags;
#if SQLITE_MAX_MMAP_SIZE>0
  pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
#endif
  if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
                           "psow", SQLITE_POWERSAFE_OVERWRITE) ){
    pNew->ctrlFlags |= UNIXFILE_PSOW;
  }
  if( strcmp(pVfs->zName,"unix-excl")==0 ){
    pNew->ctrlFlags |= UNIXFILE_EXCL;
  }
 
#if OS_VXWORKS
  pNew->pId = vxworksFindFileId(zFilename);
  if( pNew->pId==0 ){
    ctrlFlags |= UNIXFILE_NOLOCK;
    rc = SQLITE_NOMEM_BKPT;
  }
#endif
 
  if( ctrlFlags & UNIXFILE_NOLOCK ){
    pLockingStyle = &nolockIoMethods;
  }else{
    pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
#if SQLITE_ENABLE_LOCKING_STYLE
    /* Cache zFilename in the locking context (AFP and dotlock override) for
    ** proxyLock activation is possible (remote proxy is based on db name)
    ** zFilename remains valid until file is closed, to support */
    pNew->lockingContext = (void*)zFilename;
#endif
  }
 
  if( pLockingStyle == &posixIoMethods
#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
    || pLockingStyle == &nfsIoMethods
#endif
  ){
    unixEnterMutex();
    rc = findInodeInfo(pNew, &pNew->pInode);
    if( rc!=SQLITE_OK ){
      /* If an error occurred in findInodeInfo(), close the file descriptor
      ** immediately, before releasing the mutex. findInodeInfo() may fail
      ** in two scenarios:
      **
      **   (a) A call to fstat() failed.
      **   (b) A malloc failed.
      **
      ** Scenario (b) may only occur if the process is holding no other
      ** file descriptors open on the same file. If there were other file
      ** descriptors on this file, then no malloc would be required by
      ** findInodeInfo(). If this is the case, it is quite safe to close
      ** handle h - as it is guaranteed that no posix locks will be released
      ** by doing so.
      **
      ** If scenario (a) caused the error then things are not so safe. The
      ** implicit assumption here is that if fstat() fails, things are in
      ** such bad shape that dropping a lock or two doesn't matter much.
      */
      robust_close(pNew, h, __LINE__);
      h = -1;
    }
    unixLeaveMutex();
  }
 
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
  else if( pLockingStyle == &afpIoMethods ){
    /* AFP locking uses the file path so it needs to be included in
    ** the afpLockingContext.
    */
    afpLockingContext *pCtx;
    pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
    if( pCtx==0 ){
      rc = SQLITE_NOMEM_BKPT;
    }else{
      /* NB: zFilename exists and remains valid until the file is closed
      ** according to requirement F11141.  So we do not need to make a
      ** copy of the filename. */
      pCtx->dbPath = zFilename;
      pCtx->reserved = 0;
      srandomdev();
      unixEnterMutex();
      rc = findInodeInfo(pNew, &pNew->pInode);
      if( rc!=SQLITE_OK ){
        sqlite3_free(pNew->lockingContext);
        robust_close(pNew, h, __LINE__);
        h = -1;
      }
      unixLeaveMutex();
    }
  }
#endif
 
  else if( pLockingStyle == &dotlockIoMethods ){
    /* Dotfile locking uses the file path so it needs to be included in
    ** the dotlockLockingContext
    */
    char *zLockFile;
    int nFilename;
    assert( zFilename!=0 );
    nFilename = (int)strlen(zFilename) + 6;
    zLockFile = (char *)sqlite3_malloc64(nFilename);
    if( zLockFile==0 ){
      rc = SQLITE_NOMEM_BKPT;
    }else{
      sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
    }
    pNew->lockingContext = zLockFile;
  }
 
#if OS_VXWORKS
  else if( pLockingStyle == &semIoMethods ){
    /* Named semaphore locking uses the file path so it needs to be
    ** included in the semLockingContext
    */
    unixEnterMutex();
    rc = findInodeInfo(pNew, &pNew->pInode);
    if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
      char *zSemName = pNew->pInode->aSemName;
      int n;
      sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
                       pNew->pId->zCanonicalName);
      for( n=1; zSemName[n]; n++ )
        if( zSemName[n]=='/' ) zSemName[n] = '_';
      pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
      if( pNew->pInode->pSem == SEM_FAILED ){
        rc = SQLITE_NOMEM_BKPT;
        pNew->pInode->aSemName[0] = '\0';
      }
    }
    unixLeaveMutex();
  }
#endif
 
  storeLastErrno(pNew, 0);
#if OS_VXWORKS
  if( rc!=SQLITE_OK ){
    if( h>=0 ) robust_close(pNew, h, __LINE__);
    h = -1;
    osUnlink(zFilename);
    pNew->ctrlFlags |= UNIXFILE_DELETE;
  }
#endif
  if( rc!=SQLITE_OK ){
    if( h>=0 ) robust_close(pNew, h, __LINE__);
  }else{

◆ isAllZero()

static int isAllZero	(	const char *	z,
		int	n )

static

Definition at line 81980 of file sqlite3.c.

81986 {

Referenced by sqlite3BlobCompare(), and sqlite3VdbeRecordCompareWithSkip().

◆ isAlterableTable()

static int isAlterableTable	(	Parse *	pParse,
		Table *	pTab )

static

Definition at line 105824 of file sqlite3.c.

                                                       {
  if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
#ifndef SQLITE_OMIT_VIRTUALTABLE
   || ( (pTab->tabFlags & TF_Shadow)!=0
        && sqlite3ReadOnlyShadowTables(pParse->db)
   )
#endif

References Parse::db, sqlite3ErrorMsg(), sqlite3ReadOnlyShadowTables(), sqlite3StrNICmp, Table::tabFlags, TF_Shadow, and Table::zName.

Referenced by sqlite3AlterBeginAddColumn(), and sqlite3AlterRenameColumn().

◆ isAuxiliaryVtabOperator()

static int isAuxiliaryVtabOperator	(	sqlite3 *	db,
		Expr *	pExpr,
		unsigned char *	peOp2,
		Expr **	ppLeft,
		Expr **	ppRight )

static

Definition at line 144336 of file sqlite3.c.

 {
  if( pExpr->op==TK_FUNCTION ){
    static const struct Op2 {
      const char *zOp;
      unsigned char eOp2;
    } aOp[] = {
      { "match",  SQLITE_INDEX_CONSTRAINT_MATCH },
      { "glob",   SQLITE_INDEX_CONSTRAINT_GLOB },
      { "like",   SQLITE_INDEX_CONSTRAINT_LIKE },
      { "regexp", SQLITE_INDEX_CONSTRAINT_REGEXP }
    };
    ExprList *pList;
    Expr *pCol;                     /* Column reference */
    int i;
 
    pList = pExpr->x.pList;
    if( pList==0 || pList->nExpr!=2 ){
      return 0;
    }
 
    /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a
    ** virtual table on their second argument, which is the same as
    ** the left-hand side operand in their in-fix form.
    **
    **       vtab_column MATCH expression
    **       MATCH(expression,vtab_column)
    */
    pCol = pList->a[1].pExpr;
    testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
    if( ExprIsVtab(pCol) ){
      for(i=0; i<ArraySize(aOp); i++){
        if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
          *peOp2 = aOp[i].eOp2;
          *ppRight = pList->a[0].pExpr;
          *ppLeft = pCol;
          return 1;
        }
      }
    }
 
    /* We can also match against the first column of overloaded
    ** functions where xFindFunction returns a value of at least
    ** SQLITE_INDEX_CONSTRAINT_FUNCTION.
    **
    **      OVERLOADED(vtab_column,expression)
    **
    ** Historically, xFindFunction expected to see lower-case function
    ** names.  But for this use case, xFindFunction is expected to deal
    ** with function names in an arbitrary case.
    */
    pCol = pList->a[0].pExpr;
    testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
    if( ExprIsVtab(pCol) ){
      sqlite3_vtab *pVtab;
      sqlite3_module *pMod;
      void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**);
      void *pNotUsed;
      pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
      assert( pVtab!=0 );
      assert( pVtab->pModule!=0 );
      pMod = (sqlite3_module *)pVtab->pModule;
      if( pMod->xFindFunction!=0 ){
        i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
        if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){
          *peOp2 = i;
          *ppRight = pList->a[1].pExpr;
          *ppLeft = pCol;
          return 1;
        }
      }
    }
  }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
    int res = 0;
    Expr *pLeft = pExpr->pLeft;
    Expr *pRight = pExpr->pRight;
    testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 );
    if( ExprIsVtab(pLeft) ){
      res++;
    }
    testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 );
    if( pRight && ExprIsVtab(pRight) ){
      res++;
      SWAP(Expr*, pLeft, pRight);
    }
    *ppLeft = pLeft;
    *ppRight = pRight;
    if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;

Referenced by exprAnalyze().

◆ isCandidateForInOpt()

static Select * isCandidateForInOpt ( Expr * pX )

static

Definition at line 102074 of file sqlite3.c.

                                            {
  Select *p;
  SrcList *pSrc;
  ExprList *pEList;
  Table *pTab;
  int i;
  if( !ExprHasProperty(pX, EP_xIsSelect) ) return 0;  /* Not a subquery */
  if( ExprHasProperty(pX, EP_VarSelect)  ) return 0;  /* Correlated subq */
  p = pX->x.pSelect;
  if( p->pPrior ) return 0;              /* Not a compound SELECT */
  if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
    testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
    testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
    return 0; /* No DISTINCT keyword and no aggregate functions */
  }
  assert( p->pGroupBy==0 );              /* Has no GROUP BY clause */
  if( p->pLimit ) return 0;              /* Has no LIMIT clause */
  if( p->pWhere ) return 0;              /* Has no WHERE clause */
  pSrc = p->pSrc;
  assert( pSrc!=0 );
  if( pSrc->nSrc!=1 ) return 0;          /* Single term in FROM clause */
  if( pSrc->a[0].pSelect ) return 0;     /* FROM is not a subquery or view */
  pTab = pSrc->a[0].pTab;
  assert( pTab!=0 );
  assert( pTab->pSelect==0 );            /* FROM clause is not a view */
  if( IsVirtual(pTab) ) return 0;        /* FROM clause not a virtual table */
  pEList = p->pEList;
  assert( pEList!=0 );
  /* All SELECT results must be columns. */
  for(i=0; i<pEList->nExpr; i++){

References ExprList::a, SrcList::a, EP_VarSelect, EP_xIsSelect, ExprHasProperty, SrcList::SrcList_item::iCursor, IsVirtual, Expr::iTable, ExprList::nExpr, SrcList::nSrc, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, Select::pGroupBy, Select::pLimit, Select::pPrior, Table::pSelect, Expr::pSelect, SrcList::SrcList_item::pSelect, Select::pSrc, SrcList::SrcList_item::pTab, Select::pWhere, Select::selFlags, SF_Aggregate, SF_Distinct, testcase, TK_COLUMN, and Expr::x.

Referenced by sqlite3FindInIndex().

◆ isDate()

static int isDate	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv,
		DateTime *	p )

static

Definition at line 22582 of file sqlite3.c.

 {
  int i, n;
  const unsigned char *z;
  int eType;
  memset(p, 0, sizeof(*p));
  if( argc==0 ){
    return setDateTimeToCurrent(context, p);
  }
  if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
                   || eType==SQLITE_INTEGER ){
    setRawDateNumber(p, sqlite3_value_double(argv[0]));
  }else{
    z = sqlite3_value_text(argv[0]);
    if( !z || parseDateOrTime(context, (char*)z, p) ){
      return 1;
    }
  }
  for(i=1; i<argc; i++){
    z = sqlite3_value_text(argv[i]);
    n = sqlite3_value_bytes(argv[i]);
    if( z==0 || parseModifier(context, (char*)z, n, p) ) return 1;

References computeJD(), eType, DateTime::iJD, DateTime::isError, parseDateOrTime(), parseModifier(), setDateTimeToCurrent(), setRawDateNumber(), sqlite3_value_bytes(), sqlite3_value_double(), sqlite3_value_text(), sqlite3_value_type(), SQLITE_FLOAT, SQLITE_INTEGER, and validJulianDay().

Referenced by dateFunc(), datetimeFunc(), juliandayFunc(), strftimeFunc(), and timeFunc().

◆ isDistinctRedundant()

static int isDistinctRedundant	(	Parse *	pParse,
		SrcList *	pTabList,
		WhereClause *	pWC,
		ExprList *	pDistinct )

static

Definition at line 146110 of file sqlite3.c.

 {
  Table *pTab;
  Index *pIdx;
  int i;
  int iBase;
 
  /* If there is more than one table or sub-select in the FROM clause of
  ** this query, then it will not be possible to show that the DISTINCT
  ** clause is redundant. */
  if( pTabList->nSrc!=1 ) return 0;
  iBase = pTabList->a[0].iCursor;
  pTab = pTabList->a[0].pTab;
 
  /* If any of the expressions is an IPK column on table iBase, then return
  ** true. Note: The (p->iTable==iBase) part of this test may be false if the
  ** current SELECT is a correlated sub-query.
  */
  for(i=0; i<pDistinct->nExpr; i++){
    Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
    if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
  }
 
  /* Loop through all indices on the table, checking each to see if it makes
  ** the DISTINCT qualifier redundant. It does so if:
  **
  **   1. The index is itself UNIQUE, and
  **
  **   2. All of the columns in the index are either part of the pDistinct
  **      list, or else the WHERE clause contains a term of the form "col=X",
  **      where X is a constant value. The collation sequences of the
  **      comparison and select-list expressions must match those of the index.
  **
  **   3. All of those index columns for which the WHERE clause does not
  **      contain a "col=X" term are subject to a NOT NULL constraint.
  */
  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    if( !IsUniqueIndex(pIdx) ) continue;
    for(i=0; i<pIdx->nKeyCol; i++){
      if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){
        if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break;
        if( indexColumnNotNull(pIdx, i)==0 ) break;
      }
    }
    if( i==pIdx->nKeyCol ){
      /* This index implies that the DISTINCT qualifier is redundant. */

References ExprList::a, SrcList::a, findIndexCol(), Expr::iColumn, SrcList::SrcList_item::iCursor, indexColumnNotNull(), IsUniqueIndex, Expr::iTable, ExprList::nExpr, Index::nKeyCol, SrcList::nSrc, Expr::op, ExprList::ExprList_item::pExpr, Table::pIndex, Index::pNext, SrcList::SrcList_item::pTab, sqlite3ExprSkipCollateAndLikely(), sqlite3WhereFindTerm(), TK_COLUMN, and WO_EQ.

Referenced by sqlite3WhereBegin().

◆ isDupColumn()

static int isDupColumn	(	Index *	pIdx,
		int	nKey,
		Index *	pPk,
		int	iCol )

static

Definition at line 112346 of file sqlite3.c.

                                                                   {
  int i, j;
  assert( nKey<=pIdx->nColumn );
  assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
  assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
  assert( pPk->pTable->tabFlags & TF_WithoutRowid );
  assert( pPk->pTable==pIdx->pTable );
  testcase( pPk==pIdx );
  j = pPk->aiColumn[iCol];
  assert( j!=XN_ROWID && j!=XN_EXPR );
  for(i=0; i<nKey; i++){
    assert( pIdx->aiColumn[i]>=0 || j>=0 );
    if( pIdx->aiColumn[i]==j
     && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0

References Index::aiColumn, Index::azColl, Index::idxType, MAX, Index::nColumn, Index::nKeyCol, Index::pTable, sqlite3StrICmp(), SQLITE_IDXTYPE_PRIMARYKEY, Table::tabFlags, testcase, TF_WithoutRowid, XN_EXPR, and XN_ROWID.

Referenced by convertToWithoutRowidTable(), and sqlite3CreateIndex().

◆ isFatalError()

static int isFatalError ( int rc )

static

Definition at line 75268 of file sqlite3.c.

References ALWAYS, SQLITE_BUSY, SQLITE_LOCKED, and SQLITE_OK.

Referenced by backupOnePage(), and backupUpdate().

◆ isLikeOrGlob()

static int isLikeOrGlob	(	Parse *	pParse,
		Expr *	pExpr,
		Expr **	ppPrefix,
		int *	pisComplete,
		int *	pnoCase )

static

Definition at line 144164 of file sqlite3.c.

 {
  const u8 *z = 0;           /* String on RHS of LIKE operator */
  Expr *pRight, *pLeft;      /* Right and left size of LIKE operator */
  ExprList *pList;           /* List of operands to the LIKE operator */
  u8 c;                      /* One character in z[] */
  int cnt;                   /* Number of non-wildcard prefix characters */
  u8 wc[4];                  /* Wildcard characters */
  sqlite3 *db = pParse->db;  /* Database connection */
  sqlite3_value *pVal = 0;
  int op;                    /* Opcode of pRight */
  int rc;                    /* Result code to return */
 
  if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
    return 0;
  }
#ifdef SQLITE_EBCDIC
  if( *pnoCase ) return 0;
#endif
  pList = pExpr->x.pList;
  pLeft = pList->a[1].pExpr;
 
  pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
  op = pRight->op;
  if( op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
    Vdbe *pReprepare = pParse->pReprepare;
    int iCol = pRight->iColumn;
    pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
    if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){
      z = sqlite3_value_text(pVal);
    }
    sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
    assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
  }else if( op==TK_STRING ){
    z = (u8*)pRight->u.zToken;
  }
  if( z ){
 
    /* Count the number of prefix characters prior to the first wildcard */
    cnt = 0;
    while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
      cnt++;
      if( c==wc[3] && z[cnt]!=0 ) cnt++;
    }
 
    /* The optimization is possible only if (1) the pattern does not begin
    ** with a wildcard and if (2) the non-wildcard prefix does not end with
    ** an (illegal 0xff) character, or (3) the pattern does not consist of
    ** a single escape character. The second condition is necessary so
    ** that we can increment the prefix key to find an upper bound for the
    ** range search. The third is because the caller assumes that the pattern
    ** consists of at least one character after all escapes have been
    ** removed.  */
    if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){
      Expr *pPrefix;
 
      /* A "complete" match if the pattern ends with "*" or "%" */
      *pisComplete = c==wc[0] && z[cnt+1]==0;
 
      /* Get the pattern prefix.  Remove all escapes from the prefix. */
      pPrefix = sqlite3Expr(db, TK_STRING, (char*)z);
      if( pPrefix ){
        int iFrom, iTo;
        char *zNew = pPrefix->u.zToken;
        zNew[cnt] = 0;
        for(iFrom=iTo=0; iFrom<cnt; iFrom++){
          if( zNew[iFrom]==wc[3] ) iFrom++;
          zNew[iTo++] = zNew[iFrom];
        }
        zNew[iTo] = 0;
        assert( iTo>0 );
 
        /* If the LHS is not an ordinary column with TEXT affinity, then the
        ** pattern prefix boundaries (both the start and end boundaries) must
        ** not look like a number.  Otherwise the pattern might be treated as
        ** a number, which will invalidate the LIKE optimization.
        **
        ** Getting this right has been a persistent source of bugs in the
        ** LIKE optimization.  See, for example:
        **    2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1
        **    2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28
        **    2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07
        **    2019-06-14 https://sqlite.org/src/info/ce8717f0885af975
        **    2019-09-03 https://sqlite.org/src/info/0f0428096f17252a
        */
        if( pLeft->op!=TK_COLUMN
         || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
         || IsVirtual(pLeft->y.pTab)  /* Value might be numeric */
        ){
          int isNum;
          double rDummy;
          isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8);
          if( isNum<=0 ){
            if( iTo==1 && zNew[0]=='-' ){
              isNum = +1;
            }else{
              zNew[iTo-1]++;
              isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8);
              zNew[iTo-1]--;
            }
          }
          if( isNum>0 ){
            sqlite3ExprDelete(db, pPrefix);
            sqlite3ValueFree(pVal);
            return 0;
          }
        }
      }
      *ppPrefix = pPrefix;
 
      /* If the RHS pattern is a bound parameter, make arrangements to
      ** reprepare the statement when that parameter is rebound */
      if( op==TK_VARIABLE ){
        Vdbe *v = pParse->pVdbe;
        sqlite3VdbeSetVarmask(v, pRight->iColumn);
        if( *pisComplete && pRight->u.zToken[1] ){
          /* If the rhs of the LIKE expression is a variable, and the current
          ** value of the variable means there is no need to invoke the LIKE
          ** function, then no OP_Variable will be added to the program.
          ** This causes problems for the sqlite3_bind_parameter_name()
          ** API. To work around them, add a dummy OP_Variable here.
          */
          int r1 = sqlite3GetTempReg(pParse);
          sqlite3ExprCodeTarget(pParse, pRight, r1);
          sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0);
          sqlite3ReleaseTempReg(pParse, r1);
        }
      }
    }else{
      z = 0;
    }

References ExprList::a, Parse::db, sqlite3::flags, Expr::iColumn, IsVirtual, Expr::op, ExprList::ExprList_item::pExpr, Expr::pList, Parse::pReprepare, Expr::pTab, Parse::pVdbe, sqlite3_value_text(), sqlite3_value_type(), sqlite3AtoF(), sqlite3Expr(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3ExprDelete(), sqlite3ExprSkipCollate(), sqlite3GetTempReg(), sqlite3IsLikeFunction(), sqlite3ReleaseTempReg(), sqlite3ValueFree(), sqlite3VdbeChangeP3(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetBoundValue(), sqlite3VdbeSetVarmask(), SQLITE_AFF_BLOB, SQLITE_AFF_TEXT, SQLITE_EnableQPSG, SQLITE_TEXT, SQLITE_UTF8, TK_COLUMN, TK_REGISTER, TK_STRING, TK_VARIABLE, Expr::u, Expr::x, Expr::y, and Expr::zToken.

Referenced by exprAnalyze().

◆ isLookaside()

static int isLookaside	(	sqlite3 *	db,
		void *	p )

static

Definition at line 27632 of file sqlite3.c.

References sqlite3::lookaside, Lookaside::pEnd, Lookaside::pStart, and SQLITE_WITHIN.

◆ isRealTable()

static int isRealTable	(	Parse *	pParse,
		Table *	pTab )

static

Definition at line 106305 of file sqlite3.c.

                                                  {
  const char *zType = 0;
#ifndef SQLITE_OMIT_VIEW
  if( pTab->pSelect ){
    zType = "view";
  }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    zType = "virtual table";
  }
#endif
  if( zType ){
    sqlite3ErrorMsg(

References IsVirtual, Table::pSelect, sqlite3ErrorMsg(), and Table::zName.

Referenced by sqlite3AlterRenameColumn().

◆ isSelfJoinView()

static struct SrcList_item * isSelfJoinView	(	SrcList *	pTabList,
		struct SrcList_item *	pThis )

static

Definition at line 134932 of file sqlite3.c.

 {
  struct SrcList_item *pItem;
  for(pItem = pTabList->a; pItem<pThis; pItem++){
    Select *pS1;
    if( pItem->pSelect==0 ) continue;
    if( pItem->fg.viaCoroutine ) continue;
    if( pItem->zName==0 ) continue;
    assert( pItem->pTab!=0 );
    assert( pThis->pTab!=0 );
    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
    if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
    pS1 = pItem->pSelect;
    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
      /* The query flattener left two different CTE tables with identical
      ** names in the same FROM clause. */
      continue;
    }
    if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1)
     || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1)
    ){
      /* The view was modified by some other optimization such as
      ** pushDownWhereTerms() */

References SrcList::a, Select::pHaving, Select::pWhere, Select::selId, sqlite3_stricmp(), and sqlite3ExprCompare().

Referenced by sqlite3Select().

◆ isSetNullAction()

static int isSetNullAction	(	Parse *	pParse,
		FKey *	pFKey )

static

Definition at line 119933 of file sqlite3.c.

                                                      {
  Parse *pTop = sqlite3ParseToplevel(pParse);
  if( pTop->pTriggerPrg ){
    Trigger *p = pTop->pTriggerPrg->pTrigger;
    if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull)
     || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull)

References FKey::aAction, FKey::apTrigger, OE_SetNull, TriggerPrg::pTrigger, Parse::pTriggerPrg, and sqlite3ParseToplevel.

Referenced by sqlite3FkCheck().

◆ isSimpleCount()

static Table * isSimpleCount	(	Select *	p,
		AggInfo *	pAggInfo )

static

Definition at line 133861 of file sqlite3.c.

                                                         {
  Table *pTab;
  Expr *pExpr;
 
  assert( !p->pGroupBy );
 
  if( p->pWhere || p->pEList->nExpr!=1
   || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
  ){
    return 0;
  }
  pTab = p->pSrc->a[0].pTab;
  pExpr = p->pEList->a[0].pExpr;
  assert( pTab && !pTab->pSelect && pExpr );
 
  if( IsVirtual(pTab) ) return 0;
  if( pExpr->op!=TK_AGG_FUNCTION ) return 0;

References ExprList::a, SrcList::a, AggInfo::aFunc, EP_Distinct, EP_WinFunc, ExprHasProperty, FuncDef::funcFlags, IsVirtual, NEVER, ExprList::nExpr, AggInfo::nFunc, SrcList::nSrc, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, AggInfo::AggInfo_func::pFunc, Select::pGroupBy, Table::pSelect, SrcList::SrcList_item::pSelect, Select::pSrc, SrcList::SrcList_item::pTab, Select::pWhere, SQLITE_FUNC_COUNT, and TK_AGG_FUNCTION.

Referenced by sqlite3Select().

◆ journalHdrOffset()

static i64 journalHdrOffset ( Pager * pPager )

static

Definition at line 53053 of file sqlite3.c.

                                          {
  i64 offset = 0;
  i64 c = pPager->journalOff;
  if( c ){
    offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);

References JOURNAL_HDR_SZ, and Pager::journalOff.

Referenced by readJournalHdr(), syncJournal(), writeJournalHdr(), and writeSuperJournal().

◆ jrnlBufferSize()

static int jrnlBufferSize ( Pager * pPager )

static

Definition at line 52892 of file sqlite3.c.

                                        {
  assert( !MEMDB );
 
#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
  int dc;                           /* Device characteristics */
 
  assert( isOpen(pPager->fd) );
  dc = sqlite3OsDeviceCharacteristics(pPager->fd);
#else
  UNUSED_PARAMETER(pPager);
#endif
 
#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
  if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
    return -1;
  }
#endif
 
#ifdef SQLITE_ENABLE_ATOMIC_WRITE
  {
    int nSector = pPager->sectorSize;
    int szPage = pPager->pageSize;
 
    assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
    assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
    if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
      return 0;
    }
  }

References Pager::dbSize, Pager::fd, isOpen, JOURNAL_HDR_SZ, JOURNAL_PG_SZ, MEMDB, Pager::pageSize, Pager::sectorSize, sqlite3OsDeviceCharacteristics(), SQLITE_IOCAP_ATOMIC, SQLITE_IOCAP_ATOMIC512, SQLITE_IOCAP_ATOMIC64K, SQLITE_IOCAP_BATCH_ATOMIC, and UNUSED_PARAMETER.

Referenced by pager_open_journal(), and sqlite3PagerCommitPhaseOne().

◆ juliandayFunc()

static void juliandayFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 22625 of file sqlite3.c.

22634 {

22635 DateTime x;

References computeJD(), DateTime::iJD, isDate(), and sqlite3_result_double().

Referenced by sqlite3RegisterDateTimeFunctions().

◆ keywordCode()

static int keywordCode	(	const char *	z,
		int	n,
		int *	pType )

static

Definition at line 159693 of file sqlite3.c.

      : PRECEDING
** 126: UPDATE UNIQUE
*/
/* Check to see if z[0..n-1] is a keyword. If it is, write the
** parser symbol code for that keyword into *pType.  Always
** return the integer n (the length of the token). */
static int keywordCode(const char *z, int n, int *pType){
  int i, j;
  const char *zKW;
  if( n>=2 ){
    i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127;
    for(i=((int)aKWHash[i])-1; i>=0; i=((int)aKWNext[i])-1){
      if( aKWLen[i]!=n ) continue;
      zKW = &zKWText[aKWOffset[i]];
#ifdef SQLITE_ASCII
      if( (z[0]&~0x20)!=zKW[0] ) continue;
      if( (z[1]&~0x20)!=zKW[1] ) continue;
      j = 2;
      while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
#endif
#ifdef SQLITE_EBCDIC
      if( toupper(z[0])!=zKW[0] ) continue;
      if( toupper(z[1])!=zKW[1] ) continue;
      j = 2;
      while( j<n && toupper(z[j])==zKW[j] ){ j++; }
#endif
      if( j<n ) continue;
      testcase( i==0 ); /* REINDEX */
      testcase( i==1 ); /* INDEXED */
      testcase( i==2 ); /* INDEX */
      testcase( i==3 ); /* DESC */
      testcase( i==4 ); /* ESCAPE */
      testcase( i==5 ); /* EACH */
      testcase( i==6 ); /* CHECK */
      testcase( i==7 ); /* KEY */
      testcase( i==8 ); /* BEFORE */
      testcase( i==9 ); /* FOREIGN */
      testcase( i==10 ); /* FOR */
      testcase( i==11 ); /* IGNORE */
      testcase( i==12 ); /* REGEXP */
      testcase( i==13 ); /* EXPLAIN */
      testcase( i==14 ); /* INSTEAD */
      testcase( i==15 ); /* ADD */
      testcase( i==16 ); /* DATABASE */
      testcase( i==17 ); /* AS */
      testcase( i==18 ); /* SELECT */
      testcase( i==19 ); /* TABLE */
      testcase( i==20 ); /* LEFT */
      testcase( i==21 ); /* THEN */
      testcase( i==22 ); /* END */
      testcase( i==23 ); /* DEFERRABLE */
      testcase( i==24 ); /* ELSE */
      testcase( i==25 ); /* EXCLUDE */
      testcase( i==26 ); /* DELETE */
      testcase( i==27 ); /* TEMPORARY */
      testcase( i==28 ); /* TEMP */
      testcase( i==29 ); /* OR */
      testcase( i==30 ); /* ISNULL */
      testcase( i==31 ); /* NULLS */
      testcase( i==32 ); /* SAVEPOINT */
      testcase( i==33 ); /* INTERSECT */
      testcase( i==34 ); /* TIES */
      testcase( i==35 ); /* NOTNULL */
      testcase( i==36 ); /* NOT */
      testcase( i==37 ); /* NO */
      testcase( i==38 ); /* NULL */
      testcase( i==39 ); /* LIKE */
      testcase( i==40 ); /* EXCEPT */
      testcase( i==41 ); /* TRANSACTION */
      testcase( i==42 ); /* ACTION */
      testcase( i==43 ); /* ON */
      testcase( i==44 ); /* NATURAL */
      testcase( i==45 ); /* ALTER */
      testcase( i==46 ); /* RAISE */
      testcase( i==47 ); /* EXCLUSIVE */
      testcase( i==48 ); /* EXISTS */
      testcase( i==49 ); /* CONSTRAINT */
      testcase( i==50 ); /* INTO */
      testcase( i==51 ); /* OFFSET */
      testcase( i==52 ); /* OF */
      testcase( i==53 ); /* SET */
      testcase( i==54 ); /* TRIGGER */
      testcase( i==55 ); /* RANGE */
      testcase( i==56 ); /* GENERATED */
      testcase( i==57 ); /* DETACH */
      testcase( i==58 ); /* HAVING */
      testcase( i==59 ); /* GLOB */
      testcase( i==60 ); /* BEGIN */
      testcase( i==61 ); /* INNER */
      testcase( i==62 ); /* REFERENCES */
      testcase( i==63 ); /* UNIQUE */
      testcase( i==64 ); /* QUERY */
      testcase( i==65 ); /* WITHOUT */
      testcase( i==66 ); /* WITH */
      testcase( i==67 ); /* OUTER */
      testcase( i==68 ); /* RELEASE */
      testcase( i==69 ); /* ATTACH */
      testcase( i==70 ); /* BETWEEN */
      testcase( i==71 ); /* NOTHING */
      testcase( i==72 ); /* GROUPS */
      testcase( i==73 ); /* GROUP */
      testcase( i==74 ); /* CASCADE */
      testcase( i==75 ); /* ASC */
      testcase( i==76 ); /* DEFAULT */
      testcase( i==77 ); /* CASE */
      testcase( i==78 ); /* COLLATE */
      testcase( i==79 ); /* CREATE */
      testcase( i==80 ); /* CURRENT_DATE */
      testcase( i==81 ); /* IMMEDIATE */
      testcase( i==82 ); /* JOIN */
      testcase( i==83 ); /* INSERT */
      testcase( i==84 ); /* MATCH */
      testcase( i==85 ); /* PLAN */
      testcase( i==86 ); /* ANALYZE */
      testcase( i==87 ); /* PRAGMA */
      testcase( i==88 ); /* ABORT */
      testcase( i==89 ); /* UPDATE */
      testcase( i==90 ); /* VALUES */
      testcase( i==91 ); /* VIRTUAL */
      testcase( i==92 ); /* ALWAYS */
      testcase( i==93 ); /* WHEN */
      testcase( i==94 ); /* WHERE */
      testcase( i==95 ); /* RECURSIVE */
      testcase( i==96 ); /* AFTER */
      testcase( i==97 ); /* RENAME */
      testcase( i==98 ); /* AND */
      testcase( i==99 ); /* DEFERRED */
      testcase( i==100 ); /* DISTINCT */
      testcase( i==101 ); /* IS */
      testcase( i==102 ); /* AUTOINCREMENT */
      testcase( i==103 ); /* TO */
      testcase( i==104 ); /* IN */
      testcase( i==105 ); /* CAST */
      testcase( i==106 ); /* COLUMN */
      testcase( i==107 ); /* COMMIT */
      testcase( i==108 ); /* CONFLICT */
      testcase( i==109 ); /* CROSS */
      testcase( i==110 ); /* CURRENT_TIMESTAMP */
      testcase( i==111 ); /* CURRENT_TIME */
      testcase( i==112 ); /* CURRENT */
      testcase( i==113 ); /* PARTITION */
      testcase( i==114 ); /* DROP */
      testcase( i==115 ); /* PRECEDING */
      testcase( i==116 ); /* FAIL */
      testcase( i==117 ); /* LAST */
      testcase( i==118 ); /* FILTER */
      testcase( i==119 ); /* REPLACE */
      testcase( i==120 ); /* FIRST */
      testcase( i==121 ); /* FOLLOWING */
      testcase( i==122 ); /* FROM */
      testcase( i==123 ); /* FULL */
      testcase( i==124 ); /* LIMIT */
      testcase( i==125 ); /* IF */
      testcase( i==126 ); /* ORDER */
      testcase( i==127 ); /* RESTRICT */
      testcase( i==128 ); /* OTHERS */
      testcase( i==129 ); /* OVER */
      testcase( i==130 ); /* RIGHT */
      testcase( i==131 ); /* ROLLBACK */
      testcase( i==132 ); /* ROWS */
      testcase( i==133 ); /* ROW */
      testcase( i==134 ); /* UNBOUNDED */
      testcase( i==135 ); /* UNION */
      testcase( i==136 ); /* USING */
      testcase( i==137 ); /* VACUUM */
      testcase( i==138 ); /* VIEW */
      testcase( i==139 ); /* WINDOW */
      testcase( i==140 ); /* DO */
      testcase( i==141 ); /* BY */
      testcase( i==142 ); /* INITIALLY */
      testcase( i==143 ); /* ALL */
      testcase( i==144 ); /* PRIMARY */

References aKWHash, aKWLen, aKWNext, aKWOffset, charMap, testcase, and zKWText.

Referenced by sqlite3_keyword_name(), and sqlite3GetToken().

◆ last_insert_rowid()

static void last_insert_rowid	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117602 of file sqlite3.c.

117612 {

117613 sqlite3 *db = sqlite3_context_db_handle(context);

Referenced by sqlite3RegisterBuiltinFunctions().

◆ last_valueFinalizeFunc()

static void last_valueFinalizeFunc ( sqlite3_context * pCtx )

static

Definition at line 151689 of file sqlite3.c.

                    {
    sqlite3_result_value(pCtx, p->pVal);
  }
}
static void last_valueFinalizeFunc(sqlite3_context *pCtx){
  struct LastValueCtx *p;
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));

References LastValueCtx::pVal, and sqlite3_result_value().

◆ last_valueInvFunc()

static void last_valueInvFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151665 of file sqlite3.c.

         {
      p->nVal++;
    }
  }
}
static void last_valueInvFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct LastValueCtx *p;
  UNUSED_PARAMETER(nArg);
  UNUSED_PARAMETER(apArg);
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( ALWAYS(p) ){
    p->nVal--;

◆ last_valueStepFunc()

static void last_valueStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151647 of file sqlite3.c.

 {
  struct LastValueCtx *p;
  UNUSED_PARAMETER(nArg);
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    sqlite3_value_free(p->pVal);
    p->pVal = sqlite3_value_dup(apArg[0]);
    if( p->pVal==0 ){

◆ last_valueValueFunc()

static void last_valueValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151682 of file sqlite3.c.

                    {
      sqlite3_value_free(p->pVal);
      p->pVal = 0;
    }
  }
}
static void last_valueValueFunc(sqlite3_context *pCtx){

References LastValueCtx::pVal, and sqlite3_value_free().

◆ lengthFunc()

static void lengthFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117148 of file sqlite3.c.

 {
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  switch( sqlite3_value_type(argv[0]) ){
    case SQLITE_BLOB:
    case SQLITE_INTEGER:
    case SQLITE_FLOAT: {
      sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
      break;
    }
    case SQLITE_TEXT: {
      const unsigned char *z = sqlite3_value_text(argv[0]);
      const unsigned char *z0;
      unsigned char c;
      if( z==0 ) return;
      z0 = z;
      while( (c = *z)!=0 ){
        z++;
        if( c>=0xc0 ){
          while( (*z & 0xc0)==0x80 ){ z++; z0++; }
        }
      }
      sqlite3_result_int(context, (int)(z-z0));
      break;
    }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ likeFunc()

static void likeFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117890 of file sqlite3.c.

 {
  const unsigned char *zA, *zB;
  u32 escape;
  int nPat;
  sqlite3 *db = sqlite3_context_db_handle(context);
  struct compareInfo *pInfo = sqlite3_user_data(context);
  struct compareInfo backupInfo;
 
#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
  if( sqlite3_value_type(argv[0])==SQLITE_BLOB
   || sqlite3_value_type(argv[1])==SQLITE_BLOB
  ){
#ifdef SQLITE_TEST
    sqlite3_like_count++;
#endif
    sqlite3_result_int(context, 0);
    return;
  }
#endif
 
  /* Limit the length of the LIKE or GLOB pattern to avoid problems
  ** of deep recursion and N*N behavior in patternCompare().
  */
  nPat = sqlite3_value_bytes(argv[0]);
  testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
  testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
  if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
    sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
    return;
  }
  if( argc==3 ){
    /* The escape character string must consist of a single UTF-8 character.
    ** Otherwise, return an error.
    */
    const unsigned char *zEsc = sqlite3_value_text(argv[2]);
    if( zEsc==0 ) return;
    if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
      sqlite3_result_error(context,
          "ESCAPE expression must be a single character", -1);
      return;
    }
    escape = sqlite3Utf8Read(&zEsc);
    if( escape==pInfo->matchAll || escape==pInfo->matchOne ){
      memcpy(&backupInfo, pInfo, sizeof(backupInfo));
      pInfo = &backupInfo;
      if( escape==pInfo->matchAll ) pInfo->matchAll = 0;
      if( escape==pInfo->matchOne ) pInfo->matchOne = 0;
    }
  }else{
    escape = pInfo->matchSet;
  }
  zB = sqlite3_value_text(argv[0]);
  zA = sqlite3_value_text(argv[1]);
  if( zA && zB ){
#ifdef SQLITE_TEST

References sqlite3::aLimit, compareInfo::matchAll, compareInfo::matchOne, compareInfo::matchSet, patternCompare(), sqlite3_context_db_handle(), sqlite3_result_error(), sqlite3_result_int(), sqlite3_user_data(), sqlite3_value_bytes(), sqlite3_value_text(), sqlite3_value_type(), sqlite3Utf8CharLen(), sqlite3Utf8Read(), SQLITE_BLOB, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, SQLITE_MATCH, and testcase.

Referenced by sqlite3RegisterLikeFunctions().

◆ loadAnalysis()

static void loadAnalysis	(	Parse *	pParse,
		int	iDb )

static

Definition at line 108887 of file sqlite3.c.

References OP_LoadAnalysis, sqlite3GetVdbe(), and sqlite3VdbeAddOp1().

Referenced by analyzeTable().

◆ loadExt()

static void loadExt	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118520 of file sqlite3.c.

                                                                             {
  const char *zFile = (const char *)sqlite3_value_text(argv[0]);
  const char *zProc;
  sqlite3 *db = sqlite3_context_db_handle(context);
  char *zErrMsg = 0;
 
  /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
  ** flag is set.  See the sqlite3_enable_load_extension() API.
  */
  if( (db->flags & SQLITE_LoadExtFunc)==0 ){
    sqlite3_result_error(context, "not authorized", -1);
    return;
  }
 
  if( argc==2 ){
    zProc = (const char *)sqlite3_value_text(argv[1]);
  }else{
    zProc = 0;

References sqlite3::flags, sqlite3_context_db_handle(), sqlite3_free(), sqlite3_load_extension(), sqlite3_result_error(), sqlite3_value_text(), and SQLITE_LoadExtFunc.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ localtimeOffset()

static sqlite3_int64 localtimeOffset	(	DateTime *	p,
		sqlite3_context *	pCtx,
		int *	pRc )

static

Definition at line 22261 of file sqlite3.c.

 {
  DateTime x, y;
  time_t t;
  struct tm sLocal;
 
  /* Initialize the contents of sLocal to avoid a compiler warning. */
  memset(&sLocal, 0, sizeof(sLocal));
 
  x = *p;
  computeYMD_HMS(&x);
  if( x.Y<1971 || x.Y>=2038 ){
    /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only
    ** works for years between 1970 and 2037. For dates outside this range,
    ** SQLite attempts to map the year into an equivalent year within this
    ** range, do the calculation, then map the year back.
    */
    x.Y = 2000;
    x.M = 1;
    x.D = 1;
    x.h = 0;
    x.m = 0;
    x.s = 0.0;
  } else {
    int s = (int)(x.s + 0.5);
    x.s = s;
  }
  x.tz = 0;
  x.validJD = 0;
  computeJD(&x);
  t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
  if( osLocaltime(&t, &sLocal) ){
    sqlite3_result_error(pCtx, "local time unavailable", -1);
    *pRc = SQLITE_ERROR;
    return 0;
  }
  y.Y = sLocal.tm_year + 1900;
  y.M = sLocal.tm_mon + 1;
  y.D = sLocal.tm_mday;
  y.h = sLocal.tm_hour;
  y.m = sLocal.tm_min;
  y.s = sLocal.tm_sec;
  y.validYMD = 1;
  y.validHMS = 1;
  y.validJD = 0;
  y.rawS = 0;
  y.validTZ = 0;

References computeJD(), computeYMD_HMS(), DateTime::D, DateTime::h, DateTime::iJD, DateTime::isError, DateTime::M, DateTime::m, osLocaltime(), DateTime::rawS, DateTime::s, s, sqlite3_result_error(), SQLITE_ERROR, SQLITE_OK, DateTime::tz, DateTime::validHMS, DateTime::validJD, DateTime::validTZ, DateTime::validYMD, and DateTime::Y.

Referenced by parseModifier().

◆ lockBtree()

static int lockBtree ( BtShared * pBt )

static

Definition at line 67538 of file sqlite3.c.

                                   {
  int rc;              /* Result code from subfunctions */
  MemPage *pPage1;     /* Page 1 of the database file */
  u32 nPage;           /* Number of pages in the database */
  u32 nPageFile = 0;   /* Number of pages in the database file */
  u32 nPageHeader;     /* Number of pages in the database according to hdr */
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( pBt->pPage1==0 );
  rc = sqlite3PagerSharedLock(pBt->pPager);
  if( rc!=SQLITE_OK ) return rc;
  rc = btreeGetPage(pBt, 1, &pPage1, 0);
  if( rc!=SQLITE_OK ) return rc;
 
  /* Do some checking to help insure the file we opened really is
  ** a valid database file.
  */
  nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
  sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
  if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
    nPage = nPageFile;
  }
  if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){
    nPage = 0;
  }
  if( nPage>0 ){
    u32 pageSize;
    u32 usableSize;
    u8 *page1 = pPage1->aData;
    rc = SQLITE_NOTADB;
    /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins
    ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d
    ** 61 74 20 33 00. */
    if( memcmp(page1, zMagicHeader, 16)!=0 ){
      goto page1_init_failed;
    }
 
#ifdef SQLITE_OMIT_WAL
    if( page1[18]>1 ){
      pBt->btsFlags |= BTS_READ_ONLY;
    }
    if( page1[19]>1 ){
      goto page1_init_failed;
    }
#else
    if( page1[18]>2 ){
      pBt->btsFlags |= BTS_READ_ONLY;
    }
    if( page1[19]>2 ){
      goto page1_init_failed;
    }
 
    /* If the write version is set to 2, this database should be accessed
    ** in WAL mode. If the log is not already open, open it now. Then
    ** return SQLITE_OK and return without populating BtShared.pPage1.
    ** The caller detects this and calls this function again. This is
    ** required as the version of page 1 currently in the page1 buffer
    ** may not be the latest version - there may be a newer one in the log
    ** file.
    */
    if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
      int isOpen = 0;
      rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
      if( rc!=SQLITE_OK ){
        goto page1_init_failed;
      }else{
        setDefaultSyncFlag(pBt, SQLITE_DEFAULT_WAL_SYNCHRONOUS+1);
        if( isOpen==0 ){
          releasePageOne(pPage1);
          return SQLITE_OK;
        }
      }
      rc = SQLITE_NOTADB;
    }else{
      setDefaultSyncFlag(pBt, SQLITE_DEFAULT_SYNCHRONOUS+1);
    }
#endif
 
    /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload
    ** fractions and the leaf payload fraction values must be 64, 32, and 32.
    **
    ** The original design allowed these amounts to vary, but as of
    ** version 3.6.0, we require them to be fixed.
    */
    if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
      goto page1_init_failed;
    }
    /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
    ** determined by the 2-byte integer located at an offset of 16 bytes from
    ** the beginning of the database file. */
    pageSize = (page1[16]<<8) | (page1[17]<<16);
    /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two
    ** between 512 and 65536 inclusive. */
    if( ((pageSize-1)&pageSize)!=0
     || pageSize>SQLITE_MAX_PAGE_SIZE
     || pageSize<=256
    ){
      goto page1_init_failed;
    }
    pBt->btsFlags |= BTS_PAGESIZE_FIXED;
    assert( (pageSize & 7)==0 );
    /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte
    ** integer at offset 20 is the number of bytes of space at the end of
    ** each page to reserve for extensions.
    **
    ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is
    ** determined by the one-byte unsigned integer found at an offset of 20
    ** into the database file header. */
    usableSize = pageSize - page1[20];
    if( (u32)pageSize!=pBt->pageSize ){
      /* After reading the first page of the database assuming a page size
      ** of BtShared.pageSize, we have discovered that the page-size is
      ** actually pageSize. Unlock the database, leave pBt->pPage1 at
      ** zero and return SQLITE_OK. The caller will call this function
      ** again with the correct page-size.
      */
      releasePageOne(pPage1);
      pBt->usableSize = usableSize;
      pBt->pageSize = pageSize;
      freeTempSpace(pBt);
      rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
                                   pageSize-usableSize);
      return rc;
    }
    if( sqlite3WritableSchema(pBt->db)==0 && nPage>nPageFile ){
      rc = SQLITE_CORRUPT_BKPT;
      goto page1_init_failed;
    }
    /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to
    ** be less than 480. In other words, if the page size is 512, then the
    ** reserved space size cannot exceed 32. */
    if( usableSize<480 ){
      goto page1_init_failed;
    }
    pBt->pageSize = pageSize;
    pBt->usableSize = usableSize;
#ifndef SQLITE_OMIT_AUTOVACUUM
    pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
    pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
#endif
  }
 
  /* maxLocal is the maximum amount of payload to store locally for
  ** a cell.  Make sure it is small enough so that at least minFanout
  ** cells can will fit on one page.  We assume a 10-byte page header.
  ** Besides the payload, the cell must store:
  **     2-byte pointer to the cell
  **     4-byte child pointer
  **     9-byte nKey value
  **     4-byte nData value
  **     4-byte overflow page pointer
  ** So a cell consists of a 2-byte pointer, a header which is as much as
  ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
  ** page pointer.
  */
  pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
  pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
  pBt->maxLeaf = (u16)(pBt->usableSize - 35);
  pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
  if( pBt->maxLocal>127 ){
    pBt->max1bytePayload = 127;
  }else{
    pBt->max1bytePayload = (u8)pBt->maxLocal;
  }
  assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
  pBt->pPage1 = pPage1;
  pBt->nPage = nPage;
  return SQLITE_OK;

References MemPage::aData, BtShared::autoVacuum, btreeGetPage(), BTS_NO_WAL, BTS_PAGESIZE_FIXED, BTS_READ_ONLY, BtShared::btsFlags, BtShared::db, sqlite3::flags, freeTempSpace(), get4byte, BtShared::incrVacuum, isOpen, BtShared::max1bytePayload, BtShared::maxLeaf, BtShared::maxLocal, BtShared::minLeaf, BtShared::minLocal, BtShared::mutex, MX_CELL_SIZE, BtShared::nPage, BtShared::pageSize, BtShared::pPage1, BtShared::pPager, releasePageOne(), setDefaultSyncFlag, sqlite3_mutex_held(), sqlite3PagerOpenWal(), sqlite3PagerPagecount(), sqlite3PagerSetPagesize(), sqlite3PagerSharedLock(), sqlite3WritableSchema(), SQLITE_CORRUPT_BKPT, SQLITE_DEFAULT_SYNCHRONOUS, SQLITE_DEFAULT_WAL_SYNCHRONOUS, SQLITE_MAX_PAGE_SIZE, SQLITE_NOTADB, SQLITE_OK, SQLITE_ResetDatabase, BtShared::usableSize, and zMagicHeader.

Referenced by sqlite3BtreeBeginTrans().

◆ lockBtreeMutex()

static void lockBtreeMutex ( Btree * p )

static

Definition at line 64193 of file sqlite3.c.

                                    {
  assert( p->locked==0 );
  assert( sqlite3_mutex_notheld(p->pBt->mutex) );

References Btree::db, BtShared::db, Btree::locked, sqlite3::mutex, BtShared::mutex, Btree::pBt, sqlite3_mutex_enter(), sqlite3_mutex_held(), and sqlite3_mutex_notheld().

Referenced by btreeLockCarefully().

◆ logBadConnection()

static void logBadConnection ( const char * zType )

static

Definition at line 32521 of file sqlite3.c.

References sqlite3_log(), and SQLITE_MISUSE.

Referenced by sqlite3SafetyCheckOk().

◆ lookasideMallocSize()

static int lookasideMallocSize	(	sqlite3 *	db,
		void *	p )

static

Definition at line 27647 of file sqlite3.c.

                                             {
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  return sqlite3GlobalConfig.m.xSize(p);
}
static int lookasideMallocSize(sqlite3 *db, void *p){
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

References MEMTYPE_HEAP, sqlite3GlobalConfig, and sqlite3MemdebugHasType.

◆ lookupName()

static int lookupName	(	Parse *	pParse,
		const char *	zDb,
		const char *	zTab,
		const char *	zCol,
		NameContext *	pNC,
		Expr *	pExpr )

static

Definition at line 97986 of file sqlite3.c.

 {
  int i, j;                         /* Loop counters */
  int cnt = 0;                      /* Number of matching column names */
  int cntTab = 0;                   /* Number of matching table names */
  int nSubquery = 0;                /* How many levels of subquery */
  sqlite3 *db = pParse->db;         /* The database connection */
  struct SrcList_item *pItem;       /* Use for looping over pSrcList items */
  struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
  NameContext *pTopNC = pNC;        /* First namecontext in the list */
  Schema *pSchema = 0;              /* Schema of the expression */
  int eNewExprOp = TK_COLUMN;       /* New value for pExpr->op on success */
  Table *pTab = 0;                  /* Table hold the row */
  Column *pCol;                     /* A column of pTab */
 
  assert( pNC );     /* the name context cannot be NULL. */
  assert( zCol );    /* The Z in X.Y.Z cannot be NULL */
  assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
 
  /* Initialize the node to no-match */
  pExpr->iTable = -1;
  ExprSetVVAProperty(pExpr, EP_NoReduce);
 
  /* Translate the schema name in zDb into a pointer to the corresponding
  ** schema.  If not found, pSchema will remain NULL and nothing will match
  ** resulting in an appropriate error message toward the end of this routine
  */
  if( zDb ){
    testcase( pNC->ncFlags & NC_PartIdx );
    testcase( pNC->ncFlags & NC_IsCheck );
    if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
      /* Silently ignore database qualifiers inside CHECK constraints and
      ** partial indices.  Do not raise errors because that might break
      ** legacy and because it does not hurt anything to just ignore the
      ** database name. */
      zDb = 0;
    }else{
      for(i=0; i<db->nDb; i++){
        assert( db->aDb[i].zDbSName );
        if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
          pSchema = db->aDb[i].pSchema;
          break;
        }
      }
      if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
        /* This branch is taken when the main database has been renamed
        ** using SQLITE_DBCONFIG_MAINDBNAME. */
        pSchema = db->aDb[0].pSchema;
        zDb = db->aDb[0].zDbSName;
      }
    }
  }
 
  /* Start at the inner-most context and move outward until a match is found */
  assert( pNC && cnt==0 );
  do{
    ExprList *pEList;
    SrcList *pSrcList = pNC->pSrcList;
 
    if( pSrcList ){
      for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
        u8 hCol;
        pTab = pItem->pTab;
        assert( pTab!=0 && pTab->zName!=0 );
        assert( pTab->nCol>0 );
        if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
          int hit = 0;
          pEList = pItem->pSelect->pEList;
          for(j=0; j<pEList->nExpr; j++){
            if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){
              cnt++;
              cntTab = 2;
              pMatch = pItem;
              pExpr->iColumn = j;
              hit = 1;
            }
          }
          if( hit || zTab==0 ) continue;
        }
        if( zDb && pTab->pSchema!=pSchema ){
          continue;
        }
        if( zTab ){
          const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
          assert( zTabName!=0 );
          if( sqlite3StrICmp(zTabName, zTab)!=0 ){
            continue;
          }
          if( IN_RENAME_OBJECT && pItem->zAlias ){
            sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
          }
        }
        if( 0==(cntTab++) ){
          pMatch = pItem;
        }
        hCol = sqlite3StrIHash(zCol);
        for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
          if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
            /* If there has been exactly one prior match and this match
            ** is for the right-hand table of a NATURAL JOIN or is in a
            ** USING clause, then skip this match.
            */
            if( cnt==1 ){
              if( pItem->fg.jointype & JT_NATURAL ) continue;
              if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
            }
            cnt++;
            pMatch = pItem;
            /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
            pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
            break;
          }
        }
      }
      if( pMatch ){
        pExpr->iTable = pMatch->iCursor;
        pExpr->y.pTab = pMatch->pTab;
        /* RIGHT JOIN not (yet) supported */
        assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
        if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
          ExprSetProperty(pExpr, EP_CanBeNull);
        }
        pSchema = pExpr->y.pTab->pSchema;
      }
    } /* if( pSrcList ) */
 
#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
    /* If we have not already resolved the name, then maybe
    ** it is a new.* or old.* trigger argument reference.  Or
    ** maybe it is an excluded.* from an upsert.
    */
    if( zDb==0 && zTab!=0 && cntTab==0 ){
      pTab = 0;
#ifndef SQLITE_OMIT_TRIGGER
      if( pParse->pTriggerTab!=0 ){
        int op = pParse->eTriggerOp;
        assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
        if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
          pExpr->iTable = 1;
          pTab = pParse->pTriggerTab;
        }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
          pExpr->iTable = 0;
          pTab = pParse->pTriggerTab;
        }
      }
#endif /* SQLITE_OMIT_TRIGGER */
#ifndef SQLITE_OMIT_UPSERT
      if( (pNC->ncFlags & NC_UUpsert)!=0 ){
        Upsert *pUpsert = pNC->uNC.pUpsert;
        if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
          pTab = pUpsert->pUpsertSrc->a[0].pTab;
          pExpr->iTable = EXCLUDED_TABLE_NUMBER;
        }
      }
#endif /* SQLITE_OMIT_UPSERT */
 
      if( pTab ){
        int iCol;
        u8 hCol = sqlite3StrIHash(zCol);
        pSchema = pTab->pSchema;
        cntTab++;
        for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
          if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
            if( iCol==pTab->iPKey ){
              iCol = -1;
            }
            break;
          }
        }
        if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
          /* IMP: R-51414-32910 */
          iCol = -1;
        }
        if( iCol<pTab->nCol ){
          cnt++;
#ifndef SQLITE_OMIT_UPSERT
          if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
            testcase( iCol==(-1) );
            if( IN_RENAME_OBJECT ){
              pExpr->iColumn = iCol;
              pExpr->y.pTab = pTab;
              eNewExprOp = TK_COLUMN;
            }else{
              pExpr->iTable = pNC->uNC.pUpsert->regData +
                 sqlite3TableColumnToStorage(pTab, iCol);
              eNewExprOp = TK_REGISTER;
              ExprSetProperty(pExpr, EP_Alias);
            }
          }else
#endif /* SQLITE_OMIT_UPSERT */
          {
#ifndef SQLITE_OMIT_TRIGGER
            if( iCol<0 ){
              pExpr->affExpr = SQLITE_AFF_INTEGER;
            }else if( pExpr->iTable==0 ){
              testcase( iCol==31 );
              testcase( iCol==32 );
              pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
            }else{
              testcase( iCol==31 );
              testcase( iCol==32 );
              pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
            }
            pExpr->y.pTab = pTab;
            pExpr->iColumn = (i16)iCol;
            eNewExprOp = TK_TRIGGER;
#endif /* SQLITE_OMIT_TRIGGER */
          }
        }
      }
    }
#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
 
    /*
    ** Perhaps the name is a reference to the ROWID
    */
    if( cnt==0
     && cntTab==1
     && pMatch
     && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
     && sqlite3IsRowid(zCol)
     && VisibleRowid(pMatch->pTab)
    ){
      cnt = 1;
      pExpr->iColumn = -1;
      pExpr->affExpr = SQLITE_AFF_INTEGER;
    }
 
    /*
    ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
    ** might refer to an result-set alias.  This happens, for example, when
    ** we are resolving names in the WHERE clause of the following command:
    **
    **     SELECT a+b AS x FROM table WHERE x<10;
    **
    ** In cases like this, replace pExpr with a copy of the expression that
    ** forms the result set entry ("a+b" in the example) and return immediately.
    ** Note that the expression in the result set should have already been
    ** resolved by the time the WHERE clause is resolved.
    **
    ** The ability to use an output result-set column in the WHERE, GROUP BY,
    ** or HAVING clauses, or as part of a larger expression in the ORDER BY
    ** clause is not standard SQL.  This is a (goofy) SQLite extension, that
    ** is supported for backwards compatibility only. Hence, we issue a warning
    ** on sqlite3_log() whenever the capability is used.
    */
    if( (pNC->ncFlags & NC_UEList)!=0
     && cnt==0
     && zTab==0
    ){
      pEList = pNC->uNC.pEList;
      assert( pEList!=0 );
      for(j=0; j<pEList->nExpr; j++){
        char *zAs = pEList->a[j].zEName;
        if( pEList->a[j].eEName==ENAME_NAME
         && sqlite3_stricmp(zAs, zCol)==0
        ){
          Expr *pOrig;
          assert( pExpr->pLeft==0 && pExpr->pRight==0 );
          assert( pExpr->x.pList==0 );
          assert( pExpr->x.pSelect==0 );
          pOrig = pEList->a[j].pExpr;
          if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
            sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
            return WRC_Abort;
          }
          if( ExprHasProperty(pOrig, EP_Win)
           && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
          ){
            sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
            return WRC_Abort;
          }
          if( sqlite3ExprVectorSize(pOrig)!=1 ){
            sqlite3ErrorMsg(pParse, "row value misused");
            return WRC_Abort;
          }
          resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
          cnt = 1;
          pMatch = 0;
          assert( zTab==0 && zDb==0 );
          if( IN_RENAME_OBJECT ){
            sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
          }
          goto lookupname_end;
        }
      }
    }
 
    /* Advance to the next name context.  The loop will exit when either
    ** we have a match (cnt>0) or when we run out of name contexts.
    */
    if( cnt ) break;
    pNC = pNC->pNext;
    nSubquery++;
  }while( pNC );
 
 
  /*
  ** If X and Y are NULL (in other words if only the column name Z is
  ** supplied) and the value of Z is enclosed in double-quotes, then
  ** Z is a string literal if it doesn't match any column names.  In that
  ** case, we need to return right away and not make any changes to
  ** pExpr.
  **
  ** Because no reference was made to outer contexts, the pNC->nRef
  ** fields are not changed in any context.
  */
  if( cnt==0 && zTab==0 ){
    assert( pExpr->op==TK_ID );
    if( ExprHasProperty(pExpr,EP_DblQuoted)
     && areDoubleQuotedStringsEnabled(db, pTopNC)
    ){
      /* If a double-quoted identifier does not match any known column name,
      ** then treat it as a string.
      **
      ** This hack was added in the early days of SQLite in a misguided attempt
      ** to be compatible with MySQL 3.x, which used double-quotes for strings.
      ** I now sorely regret putting in this hack. The effect of this hack is
      ** that misspelled identifier names are silently converted into strings
      ** rather than causing an error, to the frustration of countless
      ** programmers. To all those frustrated programmers, my apologies.
      **
      ** Someday, I hope to get rid of this hack. Unfortunately there is
      ** a huge amount of legacy SQL that uses it. So for now, we just
      ** issue a warning.
      */
      sqlite3_log(SQLITE_WARNING,
        "double-quoted string literal: \"%w\"", zCol);
#ifdef SQLITE_ENABLE_NORMALIZE
      sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
#endif
      pExpr->op = TK_STRING;
      pExpr->y.pTab = 0;
      return WRC_Prune;
    }
    if( sqlite3ExprIdToTrueFalse(pExpr) ){
      return WRC_Prune;
    }
  }
 
  /*
  ** cnt==0 means there was not match.  cnt>1 means there were two or
  ** more matches.  Either way, we have an error.
  */
  if( cnt!=1 ){
    const char *zErr;
    zErr = cnt==0 ? "no such column" : "ambiguous column name";
    if( zDb ){
      sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
    }else if( zTab ){
      sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
    }else{
      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
    }
    pParse->checkSchema = 1;
    pTopNC->nErr++;
  }
 
  /* If a column from a table in pSrcList is referenced, then record
  ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes
  ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  Bit 63 is
  ** set if the 63rd or any subsequent column is used.
  **
  ** The colUsed mask is an optimization used to help determine if an
  ** index is a covering index.  The correct answer is still obtained
  ** if the mask contains extra set bits.  However, it is important to
  ** avoid setting bits beyond the maximum column number of the table.
  ** (See ticket [b92e5e8ec2cdbaa1]).
  **
  ** If a generated column is referenced, set bits for every column
  ** of the table.
  */
  if( pExpr->iColumn>=0 && pMatch!=0 ){
    pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
  }
 
  /* Clean up and return
  */
  sqlite3ExprDelete(db, pExpr->pLeft);
  pExpr->pLeft = 0;
  sqlite3ExprDelete(db, pExpr->pRight);
  pExpr->pRight = 0;
  pExpr->op = eNewExprOp;
  ExprSetProperty(pExpr, EP_Leaf);
lookupname_end:
  if( cnt==1 ){
    assert( pNC!=0 );
    if( !ExprHasProperty(pExpr, EP_Alias) ){
      sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
    }
    /* Increment the nRef value on all name contexts from TopNC up to
    ** the point where the name matched. */
    for(;;){
      assert( pTopNC!=0 );
      pTopNC->nRef++;
      if( pTopNC==pNC ) break;
      pTopNC = pTopNC->pNext;

References ExprList::a, SrcList::a, Table::aCol, sqlite3::aDb, Expr::affExpr, areDoubleQuotedStringsEnabled(), Parse::checkSchema, Parse::db, ExprList::ExprList_item::eEName, ENAME_NAME, EP_Agg, EP_Alias, EP_CanBeNull, EP_DblQuoted, EP_Leaf, EP_NoReduce, EP_Reduced, EP_TokenOnly, EP_Win, Parse::eTriggerOp, EXCLUDED_TABLE_NUMBER, ExprHasProperty, ExprSetProperty, ExprSetVVAProperty, Column::hName, Expr::iColumn, IN_RENAME_OBJECT, Table::iPKey, Expr::iTable, JT_LEFT, JT_NATURAL, JT_RIGHT, nameInUsingClause(), NC_AllowAgg, NC_AllowWin, NC_GenCol, NC_IdxExpr, NC_IsCheck, NC_PartIdx, NC_UEList, NC_UUpsert, NameContext::ncFlags, Table::nCol, sqlite3::nDb, NameContext::nErr, Parse::newmask, ExprList::nExpr, NameContext::nRef, SrcList::nSrc, Parse::oldmask, Expr::op, NameContext::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, NameContext::pNext, Expr::pRight, Db::pSchema, Table::pSchema, Expr::pSelect, NameContext::pSrcList, Expr::pTab, SrcList::SrcList_item::pTab, Parse::pTriggerTab, NameContext::pUpsert, Upsert::pUpsertSrc, Parse::pVdbe, Upsert::regData, resolveAlias(), SF_NestedFrom, sqlite3_log(), sqlite3_stricmp(), sqlite3AuthRead(), sqlite3ErrorMsg(), sqlite3ExprColUsed(), sqlite3ExprDelete(), sqlite3ExprIdToTrueFalse(), sqlite3ExprVectorSize(), sqlite3IsRowid(), sqlite3MatchEName(), sqlite3RenameTokenRemap(), sqlite3StrICmp(), sqlite3StrIHash(), sqlite3TableColumnToStorage(), SQLITE_AFF_INTEGER, SQLITE_WARNING, testcase, TK_COLUMN, TK_DELETE, TK_ID, TK_INSERT, TK_REGISTER, TK_STRING, TK_TRIGGER, TK_UPDATE, NameContext::uNC, VisibleRowid, WRC_Abort, WRC_Prune, Expr::x, Expr::y, Db::zDbSName, ExprList::ExprList_item::zEName, Column::zName, and Table::zName.

Referenced by resolveExprStep().

◆ lowerFunc()

static void lowerFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117519 of file sqlite3.c.

                                                                               {
  char *z1;
  const char *z2;
  int i, n;
  UNUSED_PARAMETER(argc);
  z2 = (char*)sqlite3_value_text(argv[0]);
  n = sqlite3_value_bytes(argv[0]);
  /* Verify that the call to _bytes() does not invalidate the _text() pointer */
  assert( z2==(char*)sqlite3_value_text(argv[0]) );
  if( z2 ){
    z1 = contextMalloc(context, ((i64)n)+1);
    if( z1 ){
      for(i=0; i<n; i++){

Referenced by sqlite3RegisterBuiltinFunctions().

◆ makeColumnPartOfPrimaryKey()

static void makeColumnPartOfPrimaryKey	(	Parse *	pParse,
		Column *	pCol )

static

Definition at line 111903 of file sqlite3.c.

                                                                   {
  pCol->colFlags |= COLFLAG_PRIMKEY;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  if( pCol->colFlags & COLFLAG_GENERATED ){
    testcase( pCol->colFlags & COLFLAG_VIRTUAL );

Referenced by sqlite3AddPrimaryKey().

◆ makeSorterRecord()

static int makeSorterRecord	(	Parse *	pParse,
		SortCtx *	pSort,
		Select *	pSelect,
		int	regBase,
		int	nBase )

static

Definition at line 129855 of file sqlite3.c.

 {
  int nOBSat = pSort->nOBSat;
  Vdbe *v = pParse->pVdbe;
  int regOut = ++pParse->nMem;

References innerLoopLoadRow(), Parse::nMem, SortCtx::nOBSat, OP_MakeRecord, SortCtx::pDeferredRowLoad, Parse::pVdbe, and sqlite3VdbeAddOp3().

◆ mallocWithAlarm()

static void mallocWithAlarm	(	int	n,
		void **	pp )

static

Definition at line 27541 of file sqlite3.c.

                                             {
  void *p;
  int nFull;
  assert( sqlite3_mutex_held(mem0.mutex) );
  assert( n>0 );
 
  /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal
  ** implementation of malloc_good_size(), which must be called in debug
  ** mode and specifically when the DMD "Dark Matter Detector" is enabled
  ** or else a crash results.  Hence, do not attempt to optimize out the
  ** following xRoundup() call. */
  nFull = sqlite3GlobalConfig.m.xRoundup(n);
 
  sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
  if( mem0.alarmThreshold>0 ){
    sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
    if( nUsed >= mem0.alarmThreshold - nFull ){
      AtomicStore(&mem0.nearlyFull, 1);
      sqlite3MallocAlarm(nFull);
      if( mem0.hardLimit ){
        nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
        if( nUsed >= mem0.hardLimit - nFull ){
          *pp = 0;
          return;
        }
      }
    }else{
      AtomicStore(&mem0.nearlyFull, 0);
    }
  }
  p = sqlite3GlobalConfig.m.xMalloc(nFull);
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  if( p==0 && mem0.alarmThreshold>0 ){
    sqlite3MallocAlarm(nFull);
    p = sqlite3GlobalConfig.m.xMalloc(nFull);
  }
#endif
  if( p ){
    nFull = sqlite3MallocSize(p);

References AtomicStore, mem0, sqlite3_mutex_held(), sqlite3GlobalConfig, sqlite3MallocAlarm(), sqlite3MallocSize(), sqlite3StatusHighwater(), sqlite3StatusUp(), sqlite3StatusValue(), SQLITE_STATUS_MALLOC_COUNT, SQLITE_STATUS_MALLOC_SIZE, and SQLITE_STATUS_MEMORY_USED.

Referenced by sqlite3Malloc().

◆ markTermAsChild()

static void markTermAsChild	(	WhereClause *	pWC,
		int	iChild,
		int	iParent )

static

Definition at line 144451 of file sqlite3.c.

Referenced by exprAnalyze(), and exprAnalyzeOrTerm().

◆ matchQuality()

static int matchQuality	(	FuncDef *	p,
		int	nArg,
		u8	enc )

static

Definition at line 115834 of file sqlite3.c.

 {
  int match;
  assert( p->nArg>=-1 );
 
  /* Wrong number of arguments means "no match" */
  if( p->nArg!=nArg ){
    if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH;
    if( p->nArg>=0 ) return 0;
  }
 
  /* Give a better score to a function with a specific number of arguments
  ** than to function that accepts any number of arguments. */
  if( p->nArg==nArg ){
    match = 4;
  }else{
    match = 1;
  }
 
  /* Bonus points if the text encoding matches */
  if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
    match += 2;  /* Exact encoding match */

References FUNC_PERFECT_MATCH, FuncDef::funcFlags, match(), FuncDef::nArg, SQLITE_FUNC_ENCMASK, and FuncDef::xSFunc.

Referenced by sqlite3FindFunction().

◆ measureAllocationSize()

static SQLITE_NOINLINE void measureAllocationSize	(	sqlite3 *	db,
		void *	p )

static

Definition at line 27711 of file sqlite3.c.

References sqlite3::pnBytesFreed, and sqlite3DbMallocSize().

Referenced by sqlite3DbFreeNN().

◆ memIntValue()

static SQLITE_NOINLINE i64 memIntValue ( Mem * pMem )

static

Definition at line 76411 of file sqlite3.c.

◆ memjrnlClose()

static int memjrnlClose ( sqlite3_file * pJfd )

static

Definition at line 97349 of file sqlite3.c.

◆ memjrnlCreateFile()

static int memjrnlCreateFile ( MemJournal * p )

static

Definition at line 97215 of file sqlite3.c.

                                           {
  int rc;
  sqlite3_file *pReal = (sqlite3_file*)p;
  MemJournal copy = *p;
 
  memset(p, 0, sizeof(MemJournal));
  rc = sqlite3OsOpen(copy.pVfs, copy.zJournal, pReal, copy.flags, 0);
  if( rc==SQLITE_OK ){
    int nChunk = copy.nChunkSize;
    i64 iOff = 0;
    FileChunk *pIter;
    for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
      if( iOff + nChunk > copy.endpoint.iOffset ){
        nChunk = copy.endpoint.iOffset - iOff;
      }
      rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
      if( rc ) break;
      iOff += nChunk;
    }
    if( rc==SQLITE_OK ){
      /* No error has occurred. Free the in-memory buffers. */
      memjrnlFreeChunks(&copy);
    }
  }
  if( rc!=SQLITE_OK ){
    /* If an error occurred while creating or writing to the file, restore
    ** the original before returning. This way, SQLite uses the in-memory
    ** journal data to roll back changes made to the internal page-cache

◆ memjrnlFileSize()

static int memjrnlFileSize	(	sqlite3_file *	pJfd,
		sqlite_int64 *	pSize )

static

Definition at line 97369 of file sqlite3.c.

◆ memjrnlFreeChunks()

static void memjrnlFreeChunks ( MemJournal * p )

static

Definition at line 97202 of file sqlite3.c.

                                            {
  FileChunk *pIter;
  FileChunk *pNext;

Referenced by memjrnlTruncate().

◆ memjrnlRead()

static int memjrnlRead	(	sqlite3_file *	pJfd,
		void *	zBuf,
		int	iAmt,
		sqlite_int64	iOfst )

static

Definition at line 97155 of file sqlite3.c.

 {
  MemJournal *p = (MemJournal *)pJfd;
  u8 *zOut = zBuf;
  int nRead = iAmt;
  int iChunkOffset;
  FileChunk *pChunk;
 
  if( (iAmt+iOfst)>p->endpoint.iOffset ){
    return SQLITE_IOERR_SHORT_READ;
  }
  assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 );
  if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
    sqlite3_int64 iOff = 0;
    for(pChunk=p->pFirst;
        ALWAYS(pChunk) && (iOff+p->nChunkSize)<=iOfst;
        pChunk=pChunk->pNext
    ){
      iOff += p->nChunkSize;
    }
  }else{
    pChunk = p->readpoint.pChunk;
    assert( pChunk!=0 );
  }
 
  iChunkOffset = (int)(iOfst%p->nChunkSize);
  do {
    int iSpace = p->nChunkSize - iChunkOffset;
    int nCopy = MIN(nRead, (p->nChunkSize - iChunkOffset));
    memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy);
    zOut += nCopy;
    nRead -= iSpace;
    iChunkOffset = 0;

◆ memjrnlSync()

static int memjrnlSync	(	sqlite3_file *	pJfd,
		int	flags )

static

Definition at line 97361 of file sqlite3.c.

References UNUSED_PARAMETER2.

◆ memjrnlTruncate()

static int memjrnlTruncate	(	sqlite3_file *	pJfd,
		sqlite_int64	size )

static

Definition at line 97333 of file sqlite3.c.

                                                                 {
  MemJournal *p = (MemJournal *)pJfd;
  if( ALWAYS(size==0) ){
    memjrnlFreeChunks(p);
    p->nSize = 0;
    p->endpoint.pChunk = 0;

References ALWAYS, MemJournal::endpoint, FilePoint::iOffset, memjrnlFreeChunks(), MemJournal::nSize, FilePoint::pChunk, and MemJournal::readpoint.

◆ memjrnlWrite()

static int memjrnlWrite	(	sqlite3_file *	pJfd,
		const void *	zBuf,
		int	iAmt,
		sqlite_int64	iOfst )

static

Definition at line 97254 of file sqlite3.c.

 {
  MemJournal *p = (MemJournal *)pJfd;
  int nWrite = iAmt;
  u8 *zWrite = (u8 *)zBuf;
 
  /* If the file should be created now, create it and write the new data
  ** into the file on disk. */
  if( p->nSpill>0 && (iAmt+iOfst)>p->nSpill ){
    int rc = memjrnlCreateFile(p);
    if( rc==SQLITE_OK ){
      rc = sqlite3OsWrite(pJfd, zBuf, iAmt, iOfst);
    }
    return rc;
  }
 
  /* If the contents of this write should be stored in memory */
  else{
    /* An in-memory journal file should only ever be appended to. Random
    ** access writes are not required. The only exception to this is when
    ** the in-memory journal is being used by a connection using the
    ** atomic-write optimization. In this case the first 28 bytes of the
    ** journal file may be written as part of committing the transaction. */
    assert( iOfst==p->endpoint.iOffset || iOfst==0 );
#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
    if( iOfst==0 && p->pFirst ){
      assert( p->nChunkSize>iAmt );
      memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
    }else
#else
    assert( iOfst>0 || p->pFirst==0 );
#endif
    {
      while( nWrite>0 ){
        FileChunk *pChunk = p->endpoint.pChunk;
        int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize);
        int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset);
 
        if( iChunkOffset==0 ){
          /* New chunk is required to extend the file. */
          FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
          if( !pNew ){
            return SQLITE_IOERR_NOMEM_BKPT;
          }
          pNew->pNext = 0;
          if( pChunk ){
            assert( p->pFirst );
            pChunk->pNext = pNew;
          }else{
            assert( !p->pFirst );
            p->pFirst = pNew;
          }
          p->endpoint.pChunk = pNew;
        }
 
        memcpy((u8*)p->endpoint.pChunk->zChunk + iChunkOffset, zWrite, iSpace);
        zWrite += iSpace;
        nWrite -= iSpace;
        p->endpoint.iOffset += iSpace;
      }

◆ memRealValue()

static SQLITE_NOINLINE double memRealValue ( Mem * pMem )

static

Definition at line 76439 of file sqlite3.c.

◆ minMaxFinalize()

static void minMaxFinalize ( sqlite3_context * context )

static

Definition at line 118754 of file sqlite3.c.

                                                 {
  minMaxValueFinalize(context, 1);
}

References minMaxValueFinalize().

Referenced by sqlite3RegisterBuiltinFunctions().

◆ minmaxFunc()

static void minmaxFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117093 of file sqlite3.c.

 {
  int i;
  int mask;    /* 0 for min() or 0xffffffff for max() */
  int iBest;
  CollSeq *pColl;
 
  assert( argc>1 );
  mask = sqlite3_user_data(context)==0 ? 0 : -1;
  pColl = sqlite3GetFuncCollSeq(context);
  assert( pColl );
  assert( mask==-1 || mask==0 );
  iBest = 0;
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  for(i=1; i<argc; i++){
    if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
    if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){

Referenced by sqlite3RegisterBuiltinFunctions().

◆ minMaxQuery()

static u8 minMaxQuery	(	sqlite3 *	db,
		Expr *	pFunc,
		ExprList **	ppMinMax )

static

Definition at line 133819 of file sqlite3.c.

                                                                    {
  int eRet = WHERE_ORDERBY_NORMAL;      /* Return value */
  ExprList *pEList = pFunc->x.pList;    /* Arguments to agg function */
  const char *zFunc;                    /* Name of aggregate function pFunc */
  ExprList *pOrderBy;
  u8 sortFlags = 0;
 
  assert( *ppMinMax==0 );
  assert( pFunc->op==TK_AGG_FUNCTION );
  assert( !IsWindowFunc(pFunc) );
  if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){
    return eRet;
  }
  zFunc = pFunc->u.zToken;
  if( sqlite3StrICmp(zFunc, "min")==0 ){
    eRet = WHERE_ORDERBY_MIN;
    if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
      sortFlags = KEYINFO_ORDER_BIGNULL;
    }
  }else if( sqlite3StrICmp(zFunc, "max")==0 ){
    eRet = WHERE_ORDERBY_MAX;
    sortFlags = KEYINFO_ORDER_DESC;
  }else{
    return eRet;

References ExprList::a, EP_WinFunc, ExprHasProperty, IsWindowFunc, KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, sqlite3::mallocFailed, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Expr::pList, ExprList::ExprList_item::sortFlags, sqlite3ExprCanBeNull(), sqlite3ExprListDup(), sqlite3StrICmp(), TK_AGG_FUNCTION, Expr::u, WHERE_ORDERBY_MAX, WHERE_ORDERBY_MIN, WHERE_ORDERBY_NORMAL, Expr::x, and Expr::zToken.

Referenced by sqlite3Select().

◆ minmaxStep()

static void minmaxStep	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 118699 of file sqlite3.c.

 {
  Mem *pArg  = (Mem *)argv[0];
  Mem *pBest;
  UNUSED_PARAMETER(NotUsed);
 
  pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
  if( !pBest ) return;
 
  if( sqlite3_value_type(pArg)==SQLITE_NULL ){
    if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
  }else if( pBest->flags ){
    int max;
    int cmp;
    CollSeq *pColl = sqlite3GetFuncCollSeq(context);
    /* This step function is used for both the min() and max() aggregates,
    ** the only difference between the two being that the sense of the
    ** comparison is inverted. For the max() aggregate, the
    ** sqlite3_user_data() function returns (void *)-1. For min() it
    ** returns (void *)db, where db is the sqlite3* database pointer.
    ** Therefore the next statement sets variable 'max' to 1 for the max()
    ** aggregate, or 0 for min().
    */
    max = sqlite3_user_data(context)!=0;
    cmp = sqlite3MemCompare(pBest, pArg, pColl);
    if( (max && cmp<0) || (!max && cmp>0) ){
      sqlite3VdbeMemCopy(pBest, pArg);
    }else{
      sqlite3SkipAccumulatorLoad(context);

References sqlite3_value::flags, sqlite3_aggregate_context(), sqlite3_user_data(), sqlite3_value_type(), sqlite3GetFuncCollSeq(), sqlite3MemCompare(), sqlite3SkipAccumulatorLoad(), sqlite3VdbeMemCopy(), SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ minMaxValue()

static void minMaxValue ( sqlite3_context * context )

static

Definition at line 118748 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ minMaxValueFinalize()

static void minMaxValueFinalize	(	sqlite3_context *	context,
		int	bValue )

static

Definition at line 118737 of file sqlite3.c.

       {
    pBest->db = sqlite3_context_db_handle(context);
    sqlite3VdbeMemCopy(pBest, pArg);
  }
}
static void minMaxValueFinalize(sqlite3_context *context, int bValue){
  sqlite3_value *pRes;
  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
  if( pRes ){

Referenced by minMaxFinalize().

◆ mkFullPathname()

static int mkFullPathname	(	const char *	zPath,
		char *	zOut,
		int	nOut )

static

Definition at line 39847 of file sqlite3.c.

 {
  int nPath = sqlite3Strlen30(zPath);
  int iOff = 0;
  if( zPath[0]!='/' ){
    if( osGetcwd(zOut, nOut-2)==0 ){
      return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
    }
    iOff = sqlite3Strlen30(zOut);
    zOut[iOff++] = '/';
  }
  if( (iOff+nPath+1)>nOut ){
    /* SQLite assumes that xFullPathname() nul-terminates the output buffer
    ** even if it returns an error.  */

Referenced by unixFullPathname().

◆ modifyPagePointer()

static int modifyPagePointer	(	MemPage *	pPage,
		Pgno	iFrom,
		Pgno	iTo,
		u8	eType )

static

Definition at line 68075 of file sqlite3.c.

                   : pPage is a btree-page. The pointer points at an overflow
**                   page pointed to by one of the cells on pPage.
**
** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
**                   overflow page in the list.
*/
static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  if( eType==PTRMAP_OVERFLOW2 ){
    /* The pointer is always the first 4 bytes of the page in this case.  */
    if( get4byte(pPage->aData)!=iFrom ){
      return SQLITE_CORRUPT_PAGE(pPage);
    }
    put4byte(pPage->aData, iTo);
  }else{
    int i;
    int nCell;
    int rc;
 
    rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
    if( rc ) return rc;
    nCell = pPage->nCell;
 
    for(i=0; i<nCell; i++){
      u8 *pCell = findCell(pPage, i);
      if( eType==PTRMAP_OVERFLOW1 ){
        CellInfo info;
        pPage->xParseCell(pPage, pCell, &info);
        if( info.nLocal<info.nPayload ){
          if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
            return SQLITE_CORRUPT_PAGE(pPage);
          }
          if( iFrom==get4byte(pCell+info.nSize-4) ){
            put4byte(pCell+info.nSize-4, iTo);
            break;
          }
        }
      }else{
        if( get4byte(pCell)==iFrom ){
          put4byte(pCell, iTo);
          break;
        }
      }
    }
 
    if( i==nCell ){
      if( eType!=PTRMAP_BTREE ||
          get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
        return SQLITE_CORRUPT_PAGE(pPage);

References MemPage::aData, btreeInitPage(), eType, findCell, get4byte, MemPage::hdrOffset, MemPage::isInit, BtShared::mutex, MemPage::nCell, CellInfo::nLocal, CellInfo::nPayload, CellInfo::nSize, MemPage::pBt, MemPage::pDbPage, PTRMAP_BTREE, PTRMAP_OVERFLOW1, PTRMAP_OVERFLOW2, put4byte, sqlite3_mutex_held(), SQLITE_CORRUPT_PAGE, SQLITE_OK, BtShared::usableSize, and MemPage::xParseCell.

Referenced by relocatePage().

◆ moveToChild()

static int moveToChild	(	BtCursor *	pCur,
		u32	newPgno )

static

Definition at line 69571 of file sqlite3.c.

                                                   {
  BtShared *pBt = pCur->pBt;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
  assert( pCur->iPage>=0 );
  if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
    return SQLITE_CORRUPT_BKPT;
  }
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);

References BtCursor::aiIdx, BtCursor::apPage, BTCF_ValidNKey, BTCF_ValidOvfl, BTCURSOR_MAX_DEPTH, BtCursor::curFlags, BtCursor::curPagerFlags, CURSOR_VALID, BtCursor::eState, getAndInitPage(), BtCursor::info, BtCursor::iPage, BtCursor::ix, CellInfo::nSize, BtCursor::pBt, BtCursor::pPage, and SQLITE_CORRUPT_BKPT.

Referenced by btreeNext(), btreePrevious(), moveToLeftmost(), moveToRightmost(), moveToRoot(), sqlite3BtreeCount(), and sqlite3BtreeMovetoUnpacked().

◆ moveToLeftmost()

static int moveToLeftmost ( BtCursor * pCur )

static

Definition at line 69748 of file sqlite3.c.

                                         {
  Pgno pgno;
  int rc = SQLITE_OK;
  MemPage *pPage;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){

References CURSOR_VALID, BtCursor::eState, findCell, get4byte, BtCursor::ix, moveToChild(), MemPage::nCell, BtCursor::pPage, and SQLITE_OK.

Referenced by btreeNext().

◆ moveToParent()

static void moveToParent ( BtCursor * pCur )

static

Definition at line 69620 of file sqlite3.c.

                                        {
  MemPage *pLeaf;
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->iPage>0 );
  assert( pCur->pPage );
  assertParentIndex(
    pCur->apPage[pCur->iPage-1],
    pCur->aiIdx[pCur->iPage-1],
    pCur->pPage->pgno
  );
  testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
  pCur->info.nSize = 0;

References BtCursor::aiIdx, BtCursor::apPage, assertParentIndex, BTCF_ValidNKey, BTCF_ValidOvfl, BtCursor::curFlags, CURSOR_VALID, BtCursor::eState, BtCursor::info, BtCursor::iPage, BtCursor::ix, MemPage::nCell, CellInfo::nSize, MemPage::pgno, BtCursor::pPage, releasePageNotNull(), and testcase.

Referenced by btreeNext(), btreePrevious(), and sqlite3BtreeCount().

◆ moveToRightmost()

static int moveToRightmost ( BtCursor * pCur )

static

Definition at line 69773 of file sqlite3.c.

                                          {
  Pgno pgno;
  int rc = SQLITE_OK;
  MemPage *pPage = 0;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  while( !(pPage = pCur->pPage)->leaf ){
    pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    pCur->ix = pPage->nCell;
    rc = moveToChild(pCur, pgno);
    if( rc ) return rc;

References MemPage::aData, BTCF_ValidNKey, BtCursor::curFlags, CURSOR_VALID, BtCursor::eState, get4byte, MemPage::hdrOffset, BtCursor::info, BtCursor::ix, moveToChild(), MemPage::nCell, CellInfo::nSize, BtCursor::pPage, and SQLITE_OK.

Referenced by btreePrevious().

◆ moveToRoot()

static int moveToRoot ( BtCursor * pCur )

static

Definition at line 69661 of file sqlite3.c.

                                     {
  MemPage *pRoot;
  int rc = SQLITE_OK;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
  assert( CURSOR_VALID   < CURSOR_REQUIRESEEK );
  assert( CURSOR_FAULT   > CURSOR_REQUIRESEEK );
  assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
  assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
 
  if( pCur->iPage>=0 ){
    if( pCur->iPage ){
      releasePageNotNull(pCur->pPage);
      while( --pCur->iPage ){
        releasePageNotNull(pCur->apPage[pCur->iPage]);
      }
      pCur->pPage = pCur->apPage[0];
      goto skip_init;
    }
  }else if( pCur->pgnoRoot==0 ){
    pCur->eState = CURSOR_INVALID;
    return SQLITE_EMPTY;
  }else{
    assert( pCur->iPage==(-1) );
    if( pCur->eState>=CURSOR_REQUIRESEEK ){
      if( pCur->eState==CURSOR_FAULT ){
        assert( pCur->skipNext!=SQLITE_OK );
        return pCur->skipNext;
      }
      sqlite3BtreeClearCursor(pCur);
    }
    rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage,
                        0, pCur->curPagerFlags);
    if( rc!=SQLITE_OK ){
      pCur->eState = CURSOR_INVALID;
      return rc;
    }
    pCur->iPage = 0;
    pCur->curIntKey = pCur->pPage->intKey;
  }
  pRoot = pCur->pPage;
  assert( pRoot->pgno==pCur->pgnoRoot );
 
  /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
  ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
  ** NULL, the caller expects a table b-tree. If this is not the case,
  ** return an SQLITE_CORRUPT error.
  **
  ** Earlier versions of SQLite assumed that this test could not fail
  ** if the root page was already loaded when this function was called (i.e.
  ** if pCur->iPage>=0). But this is not so if the database is corrupted
  ** in such a way that page pRoot is linked into a second b-tree table
  ** (or the freelist).  */
  assert( pRoot->intKey==1 || pRoot->intKey==0 );
  if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
    return SQLITE_CORRUPT_PAGE(pCur->pPage);
  }
 
skip_init:
  pCur->ix = 0;
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
 
  pRoot = pCur->pPage;
  if( pRoot->nCell>0 ){
    pCur->eState = CURSOR_VALID;
  }else if( !pRoot->leaf ){
    Pgno subpage;
    if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
    subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
    pCur->eState = CURSOR_VALID;
    rc = moveToChild(pCur, subpage);

References MemPage::aData, BtCursor::apPage, BTCF_AtLast, BTCF_ValidNKey, BTCF_ValidOvfl, BtCursor::curFlags, BtCursor::curIntKey, BtCursor::curPagerFlags, CURSOR_FAULT, CURSOR_INVALID, CURSOR_REQUIRESEEK, CURSOR_VALID, BtCursor::eState, get4byte, getAndInitPage(), MemPage::hdrOffset, BtCursor::info, MemPage::intKey, BtCursor::iPage, MemPage::isInit, BtCursor::ix, MemPage::leaf, moveToChild(), MemPage::nCell, CellInfo::nSize, Btree::pBt, BtCursor::pBtree, MemPage::pgno, BtCursor::pgnoRoot, BtCursor::pKeyInfo, BtCursor::pPage, releasePageNotNull(), BtCursor::skipNext, sqlite3BtreeClearCursor(), SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PAGE, SQLITE_EMPTY, and SQLITE_OK.

Referenced by sqlite3BtreeCount(), sqlite3BtreeDelete(), and sqlite3BtreeMovetoUnpacked().

◆ multiSelect()

static int multiSelect	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pDest )

static

Definition at line 131852 of file sqlite3.c.

 {
  int rc = SQLITE_OK;   /* Success code from a subroutine */
  Select *pPrior;       /* Another SELECT immediately to our left */
  Vdbe *v;              /* Generate code to this VDBE */
  SelectDest dest;      /* Alternative data destination */
  Select *pDelete = 0;  /* Chain of simple selects to delete */
  sqlite3 *db;          /* Database connection */
 
  /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
  ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
  */
  assert( p && p->pPrior );  /* Calling function guarantees this much */
  assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
  assert( p->selFlags & SF_Compound );
  db = pParse->db;
  pPrior = p->pPrior;
  dest = *pDest;
  if( pPrior->pOrderBy || pPrior->pLimit ){
    sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
      pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op));
    rc = 1;
    goto multi_select_end;
  }
 
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );  /* The VDBE already created by calling function */
 
  /* Create the destination temporary table if necessary
  */
  if( dest.eDest==SRT_EphemTab ){
    assert( p->pEList );
    sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
    dest.eDest = SRT_Table;
  }
 
  /* Special handling for a compound-select that originates as a VALUES clause.
  */
  if( p->selFlags & SF_MultiValue ){
    rc = multiSelectValues(pParse, p, &dest);
    if( rc>=0 ) goto multi_select_end;
    rc = SQLITE_OK;
  }
 
  /* Make sure all SELECTs in the statement have the same number of elements
  ** in their result sets.
  */
  assert( p->pEList && pPrior->pEList );
  assert( p->pEList->nExpr==pPrior->pEList->nExpr );
 
#ifndef SQLITE_OMIT_CTE
  if( p->selFlags & SF_Recursive ){
    generateWithRecursiveQuery(pParse, p, &dest);
  }else
#endif
 
  /* Compound SELECTs that have an ORDER BY clause are handled separately.
  */
  if( p->pOrderBy ){
    return multiSelectOrderBy(pParse, p, pDest);
  }else{
 
#ifndef SQLITE_OMIT_EXPLAIN
    if( pPrior->pPrior==0 ){
      ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
      ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
    }
#endif
 
    /* Generate code for the left and right SELECT statements.
    */
    switch( p->op ){
      case TK_ALL: {
        int addr = 0;
        int nLimit;
        assert( !pPrior->pLimit );
        pPrior->iLimit = p->iLimit;
        pPrior->iOffset = p->iOffset;
        pPrior->pLimit = p->pLimit;
        rc = sqlite3Select(pParse, pPrior, &dest);
        p->pLimit = 0;
        if( rc ){
          goto multi_select_end;
        }
        p->pPrior = 0;
        p->iLimit = pPrior->iLimit;
        p->iOffset = pPrior->iOffset;
        if( p->iLimit ){
          addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
          VdbeComment((v, "Jump ahead if LIMIT reached"));
          if( p->iOffset ){
            sqlite3VdbeAddOp3(v, OP_OffsetLimit,
                              p->iLimit, p->iOffset+1, p->iOffset);
          }
        }
        ExplainQueryPlan((pParse, 1, "UNION ALL"));
        rc = sqlite3Select(pParse, p, &dest);
        testcase( rc!=SQLITE_OK );
        pDelete = p->pPrior;
        p->pPrior = pPrior;
        p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
        if( pPrior->pLimit
         && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit)
         && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
        ){
          p->nSelectRow = sqlite3LogEst((u64)nLimit);
        }
        if( addr ){
          sqlite3VdbeJumpHere(v, addr);
        }
        break;
      }
      case TK_EXCEPT:
      case TK_UNION: {
        int unionTab;    /* Cursor number of the temp table holding result */
        u8 op = 0;       /* One of the SRT_ operations to apply to self */
        int priorOp;     /* The SRT_ operation to apply to prior selects */
        Expr *pLimit;    /* Saved values of p->nLimit  */
        int addr;
        SelectDest uniondest;
 
        testcase( p->op==TK_EXCEPT );
        testcase( p->op==TK_UNION );
        priorOp = SRT_Union;
        if( dest.eDest==priorOp ){
          /* We can reuse a temporary table generated by a SELECT to our
          ** right.
          */
          assert( p->pLimit==0 );      /* Not allowed on leftward elements */
          unionTab = dest.iSDParm;
        }else{
          /* We will need to create our own temporary table to hold the
          ** intermediate results.
          */
          unionTab = pParse->nTab++;
          assert( p->pOrderBy==0 );
          addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
          assert( p->addrOpenEphm[0] == -1 );
          p->addrOpenEphm[0] = addr;
          findRightmost(p)->selFlags |= SF_UsesEphemeral;
          assert( p->pEList );
        }
 
        /* Code the SELECT statements to our left
        */
        assert( !pPrior->pOrderBy );
        sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
        rc = sqlite3Select(pParse, pPrior, &uniondest);
        if( rc ){
          goto multi_select_end;
        }
 
        /* Code the current SELECT statement
        */
        if( p->op==TK_EXCEPT ){
          op = SRT_Except;
        }else{
          assert( p->op==TK_UNION );
          op = SRT_Union;
        }
        p->pPrior = 0;
        pLimit = p->pLimit;
        p->pLimit = 0;
        uniondest.eDest = op;
        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
                          selectOpName(p->op)));
        rc = sqlite3Select(pParse, p, &uniondest);
        testcase( rc!=SQLITE_OK );
        assert( p->pOrderBy==0 );
        pDelete = p->pPrior;
        p->pPrior = pPrior;
        p->pOrderBy = 0;
        if( p->op==TK_UNION ){
          p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
        }
        sqlite3ExprDelete(db, p->pLimit);
        p->pLimit = pLimit;
        p->iLimit = 0;
        p->iOffset = 0;
 
        /* Convert the data in the temporary table into whatever form
        ** it is that we currently need.
        */
        assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
        assert( p->pEList || db->mallocFailed );
        if( dest.eDest!=priorOp && db->mallocFailed==0 ){
          int iCont, iBreak, iStart;
          iBreak = sqlite3VdbeMakeLabel(pParse);
          iCont = sqlite3VdbeMakeLabel(pParse);
          computeLimitRegisters(pParse, p, iBreak);
          sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
          iStart = sqlite3VdbeCurrentAddr(v);
          selectInnerLoop(pParse, p, unionTab,
                          0, 0, &dest, iCont, iBreak);
          sqlite3VdbeResolveLabel(v, iCont);
          sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
          sqlite3VdbeResolveLabel(v, iBreak);
          sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
        }
        break;
      }
      default: assert( p->op==TK_INTERSECT ); {
        int tab1, tab2;
        int iCont, iBreak, iStart;
        Expr *pLimit;
        int addr;
        SelectDest intersectdest;
        int r1;
 
        /* INTERSECT is different from the others since it requires
        ** two temporary tables.  Hence it has its own case.  Begin
        ** by allocating the tables we will need.
        */
        tab1 = pParse->nTab++;
        tab2 = pParse->nTab++;
        assert( p->pOrderBy==0 );
 
        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
        assert( p->addrOpenEphm[0] == -1 );
        p->addrOpenEphm[0] = addr;
        findRightmost(p)->selFlags |= SF_UsesEphemeral;
        assert( p->pEList );
 
        /* Code the SELECTs to our left into temporary table "tab1".
        */
        sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
        rc = sqlite3Select(pParse, pPrior, &intersectdest);
        if( rc ){
          goto multi_select_end;
        }
 
        /* Code the current SELECT into temporary table "tab2"
        */
        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
        assert( p->addrOpenEphm[1] == -1 );
        p->addrOpenEphm[1] = addr;
        p->pPrior = 0;
        pLimit = p->pLimit;
        p->pLimit = 0;
        intersectdest.iSDParm = tab2;
        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
                          selectOpName(p->op)));
        rc = sqlite3Select(pParse, p, &intersectdest);
        testcase( rc!=SQLITE_OK );
        pDelete = p->pPrior;
        p->pPrior = pPrior;
        if( p->nSelectRow>pPrior->nSelectRow ){
          p->nSelectRow = pPrior->nSelectRow;
        }
        sqlite3ExprDelete(db, p->pLimit);
        p->pLimit = pLimit;
 
        /* Generate code to take the intersection of the two temporary
        ** tables.
        */
        if( rc ) break;
        assert( p->pEList );
        iBreak = sqlite3VdbeMakeLabel(pParse);
        iCont = sqlite3VdbeMakeLabel(pParse);
        computeLimitRegisters(pParse, p, iBreak);
        sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
        r1 = sqlite3GetTempReg(pParse);
        iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
        sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
        VdbeCoverage(v);
        sqlite3ReleaseTempReg(pParse, r1);
        selectInnerLoop(pParse, p, tab1,
                        0, 0, &dest, iCont, iBreak);
        sqlite3VdbeResolveLabel(v, iCont);
        sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
        sqlite3VdbeResolveLabel(v, iBreak);
        sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
        sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
        break;
      }
    }
 
  #ifndef SQLITE_OMIT_EXPLAIN
    if( p->pNext==0 ){
      ExplainQueryPlanPop(pParse);
    }
  #endif
  }
  if( pParse->nErr ) goto multi_select_end;
 
  /* Compute collating sequences used by
  ** temporary tables needed to implement the compound select.
  ** Attach the KeyInfo structure to all temporary tables.
  **
  ** This section is run by the right-most SELECT statement only.
  ** SELECT statements to the left always skip this part.  The right-most
  ** SELECT might also skip this part if it has no ORDER BY clause and
  ** no temp tables are required.
  */
  if( p->selFlags & SF_UsesEphemeral ){
    int i;                        /* Loop counter */
    KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
    Select *pLoop;                /* For looping through SELECT statements */
    CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
    int nCol;                     /* Number of columns in result set */
 
    assert( p->pNext==0 );
    nCol = p->pEList->nExpr;
    pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
    if( !pKeyInfo ){
      rc = SQLITE_NOMEM_BKPT;
      goto multi_select_end;
    }
    for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
      *apColl = multiSelectCollSeq(pParse, p, i);
      if( 0==*apColl ){
        *apColl = db->pDfltColl;
      }
    }
 
    for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
      for(i=0; i<2; i++){
        int addr = pLoop->addrOpenEphm[i];
        if( addr<0 ){
          /* If [0] is unused then [1] is also unused.  So we can
          ** always safely abort as soon as the first unused slot is found */
          assert( pLoop->addrOpenEphm[1]<0 );
          break;
        }
        sqlite3VdbeChangeP2(v, addr, nCol);
        sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
                            P4_KEYINFO);
        pLoop->addrOpenEphm[i] = -1;
      }
    }
    sqlite3KeyInfoUnref(pKeyInfo);
  }
 

References KeyInfo::aColl, Select::addrOpenEphm, computeLimitRegisters(), Parse::db, SelectDest::eDest, ExplainQueryPlan, ExplainQueryPlanPop, findRightmost(), generateWithRecursiveQuery(), Select::iLimit, Select::iOffset, SelectDest::iSDParm, SelectDest::iSdst, sqlite3::mallocFailed, multiSelectCollSeq(), multiSelectOrderBy(), multiSelectValues(), Parse::nErr, ExprList::nExpr, SelectDest::nSdst, Select::nSelectRow, Parse::nTab, Select::op, OP_Close, OP_IfNot, OP_Next, OP_NotFound, OP_OffsetLimit, OP_OpenEphemeral, OP_Rewind, OP_RowData, P4_KEYINFO, sqlite3::pDfltColl, Select::pEList, Expr::pLeft, Select::pLimit, Select::pNext, Select::pOrderBy, Select::pPrior, selectInnerLoop(), selectOpName(), Select::selFlags, SF_Compound, SF_MultiValue, SF_Recursive, SF_UsesEphemeral, sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3ExprIsInteger(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3KeyInfoAlloc(), sqlite3KeyInfoRef(), sqlite3KeyInfoUnref(), sqlite3LogEst(), sqlite3LogEstAdd(), sqlite3ReleaseTempReg(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectDestInit(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP2(), sqlite3VdbeChangeP4(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_NOMEM_BKPT, SQLITE_OK, SRT_EphemTab, SRT_Except, SRT_Table, SRT_Union, testcase, TK_ALL, TK_EXCEPT, TK_INTERSECT, TK_UNION, VdbeComment, and VdbeCoverage.

Referenced by sqlite3Select().

◆ multiSelectCollSeq()

static CollSeq * multiSelectCollSeq	(	Parse *	pParse,
		Select *	p,
		int	iCol )

static

Definition at line 131535 of file sqlite3.c.

                                                                      {
  CollSeq *pRet;
  if( p->pPrior ){
    pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
  }else{
    pRet = 0;
  }
  assert( iCol>=0 );
  /* iCol must be less than p->pEList->nExpr.  Otherwise an error would
  ** have been thrown during name resolution and we would not have gotten

References ExprList::a, ALWAYS, multiSelectCollSeq(), ExprList::nExpr, Select::pEList, ExprList::ExprList_item::pExpr, Select::pPrior, and sqlite3ExprCollSeq().

Referenced by multiSelect(), multiSelectCollSeq(), multiSelectOrderBy(), and multiSelectOrderByKeyInfo().

◆ multiSelectOrderBy()

static int multiSelectOrderBy	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pDest )

static

Definition at line 132439 of file sqlite3.c.

 {
  int i, j;             /* Loop counters */
  Select *pPrior;       /* Another SELECT immediately to our left */
  Vdbe *v;              /* Generate code to this VDBE */
  SelectDest destA;     /* Destination for coroutine A */
  SelectDest destB;     /* Destination for coroutine B */
  int regAddrA;         /* Address register for select-A coroutine */
  int regAddrB;         /* Address register for select-B coroutine */
  int addrSelectA;      /* Address of the select-A coroutine */
  int addrSelectB;      /* Address of the select-B coroutine */
  int regOutA;          /* Address register for the output-A subroutine */
  int regOutB;          /* Address register for the output-B subroutine */
  int addrOutA;         /* Address of the output-A subroutine */
  int addrOutB = 0;     /* Address of the output-B subroutine */
  int addrEofA;         /* Address of the select-A-exhausted subroutine */
  int addrEofA_noB;     /* Alternate addrEofA if B is uninitialized */
  int addrEofB;         /* Address of the select-B-exhausted subroutine */
  int addrAltB;         /* Address of the A<B subroutine */
  int addrAeqB;         /* Address of the A==B subroutine */
  int addrAgtB;         /* Address of the A>B subroutine */
  int regLimitA;        /* Limit register for select-A */
  int regLimitB;        /* Limit register for select-A */
  int regPrev;          /* A range of registers to hold previous output */
  int savedLimit;       /* Saved value of p->iLimit */
  int savedOffset;      /* Saved value of p->iOffset */
  int labelCmpr;        /* Label for the start of the merge algorithm */
  int labelEnd;         /* Label for the end of the overall SELECT stmt */
  int addr1;            /* Jump instructions that get retargetted */
  int op;               /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
  KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
  KeyInfo *pKeyMerge;   /* Comparison information for merging rows */
  sqlite3 *db;          /* Database connection */
  ExprList *pOrderBy;   /* The ORDER BY clause */
  int nOrderBy;         /* Number of terms in the ORDER BY clause */
  u32 *aPermute;        /* Mapping from ORDER BY terms to result set columns */
 
  assert( p->pOrderBy!=0 );
  assert( pKeyDup==0 ); /* "Managed" code needs this.  Ticket #3382. */
  db = pParse->db;
  v = pParse->pVdbe;
  assert( v!=0 );       /* Already thrown the error if VDBE alloc failed */
  labelEnd = sqlite3VdbeMakeLabel(pParse);
  labelCmpr = sqlite3VdbeMakeLabel(pParse);
 
 
  /* Patch up the ORDER BY clause
  */
  op = p->op;
  pPrior = p->pPrior;
  assert( pPrior->pOrderBy==0 );
  pOrderBy = p->pOrderBy;
  assert( pOrderBy );
  nOrderBy = pOrderBy->nExpr;
 
  /* For operators other than UNION ALL we have to make sure that
  ** the ORDER BY clause covers every term of the result set.  Add
  ** terms to the ORDER BY clause as necessary.
  */
  if( op!=TK_ALL ){
    for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
      struct ExprList_item *pItem;
      for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
        assert( pItem->u.x.iOrderByCol>0 );
        if( pItem->u.x.iOrderByCol==i ) break;
      }
      if( j==nOrderBy ){
        Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
        if( pNew==0 ) return SQLITE_NOMEM_BKPT;
        pNew->flags |= EP_IntValue;
        pNew->u.iValue = i;
        p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
        if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
      }
    }
  }
 
  /* Compute the comparison permutation and keyinfo that is used with
  ** the permutation used to determine if the next
  ** row of results comes from selectA or selectB.  Also add explicit
  ** collations to the ORDER BY clause terms so that when the subqueries
  ** to the right and the left are evaluated, they use the correct
  ** collation.
  */
  aPermute = sqlite3DbMallocRawNN(db, sizeof(u32)*(nOrderBy + 1));
  if( aPermute ){
    struct ExprList_item *pItem;
    aPermute[0] = nOrderBy;
    for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
      assert( pItem->u.x.iOrderByCol>0 );
      assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
      aPermute[i] = pItem->u.x.iOrderByCol - 1;
    }
    pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
  }else{
    pKeyMerge = 0;
  }
 
  /* Reattach the ORDER BY clause to the query.
  */
  p->pOrderBy = pOrderBy;
  pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
 
  /* Allocate a range of temporary registers and the KeyInfo needed
  ** for the logic that removes duplicate result rows when the
  ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
  */
  if( op==TK_ALL ){
    regPrev = 0;
  }else{
    int nExpr = p->pEList->nExpr;
    assert( nOrderBy>=nExpr || db->mallocFailed );
    regPrev = pParse->nMem+1;
    pParse->nMem += nExpr+1;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
    pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
    if( pKeyDup ){
      assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
      for(i=0; i<nExpr; i++){
        pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
        pKeyDup->aSortFlags[i] = 0;
      }
    }
  }
 
  /* Separate the left and the right query from one another
  */
  p->pPrior = 0;
  pPrior->pNext = 0;
  sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
  if( pPrior->pPrior==0 ){
    sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
  }
 
  /* Compute the limit registers */
  computeLimitRegisters(pParse, p, labelEnd);
  if( p->iLimit && op==TK_ALL ){
    regLimitA = ++pParse->nMem;
    regLimitB = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
                                  regLimitA);
    sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
  }else{
    regLimitA = regLimitB = 0;
  }
  sqlite3ExprDelete(db, p->pLimit);
  p->pLimit = 0;
 
  regAddrA = ++pParse->nMem;
  regAddrB = ++pParse->nMem;
  regOutA = ++pParse->nMem;
  regOutB = ++pParse->nMem;
  sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
  sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
 
  ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
 
  /* Generate a coroutine to evaluate the SELECT statement to the
  ** left of the compound operator - the "A" select.
  */
  addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
  addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
  VdbeComment((v, "left SELECT"));
  pPrior->iLimit = regLimitA;
  ExplainQueryPlan((pParse, 1, "LEFT"));
  sqlite3Select(pParse, pPrior, &destA);
  sqlite3VdbeEndCoroutine(v, regAddrA);
  sqlite3VdbeJumpHere(v, addr1);
 
  /* Generate a coroutine to evaluate the SELECT statement on
  ** the right - the "B" select
  */
  addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
  addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
  VdbeComment((v, "right SELECT"));
  savedLimit = p->iLimit;
  savedOffset = p->iOffset;
  p->iLimit = regLimitB;
  p->iOffset = 0;
  ExplainQueryPlan((pParse, 1, "RIGHT"));
  sqlite3Select(pParse, p, &destB);
  p->iLimit = savedLimit;
  p->iOffset = savedOffset;
  sqlite3VdbeEndCoroutine(v, regAddrB);
 
  /* Generate a subroutine that outputs the current row of the A
  ** select as the next output row of the compound select.
  */
  VdbeNoopComment((v, "Output routine for A"));
  addrOutA = generateOutputSubroutine(pParse,
                 p, &destA, pDest, regOutA,
                 regPrev, pKeyDup, labelEnd);
 
  /* Generate a subroutine that outputs the current row of the B
  ** select as the next output row of the compound select.
  */
  if( op==TK_ALL || op==TK_UNION ){
    VdbeNoopComment((v, "Output routine for B"));
    addrOutB = generateOutputSubroutine(pParse,
                 p, &destB, pDest, regOutB,
                 regPrev, pKeyDup, labelEnd);
  }
  sqlite3KeyInfoUnref(pKeyDup);
 
  /* Generate a subroutine to run when the results from select A
  ** are exhausted and only data in select B remains.
  */
  if( op==TK_EXCEPT || op==TK_INTERSECT ){
    addrEofA_noB = addrEofA = labelEnd;
  }else{
    VdbeNoopComment((v, "eof-A subroutine"));
    addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
    addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
                                     VdbeCoverage(v);
    sqlite3VdbeGoto(v, addrEofA);
    p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
  }
 
  /* Generate a subroutine to run when the results from select B
  ** are exhausted and only data in select A remains.
  */
  if( op==TK_INTERSECT ){
    addrEofB = addrEofA;
    if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
  }else{
    VdbeNoopComment((v, "eof-B subroutine"));
    addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
    sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
    sqlite3VdbeGoto(v, addrEofB);
  }
 
  /* Generate code to handle the case of A<B
  */
  VdbeNoopComment((v, "A-lt-B subroutine"));
  addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
  sqlite3VdbeGoto(v, labelCmpr);
 
  /* Generate code to handle the case of A==B
  */
  if( op==TK_ALL ){
    addrAeqB = addrAltB;
  }else if( op==TK_INTERSECT ){
    addrAeqB = addrAltB;
    addrAltB++;
  }else{
    VdbeNoopComment((v, "A-eq-B subroutine"));
    addrAeqB =
    sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
    sqlite3VdbeGoto(v, labelCmpr);
  }
 
  /* Generate code to handle the case of A>B
  */
  VdbeNoopComment((v, "A-gt-B subroutine"));
  addrAgtB = sqlite3VdbeCurrentAddr(v);
  if( op==TK_ALL || op==TK_UNION ){
    sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
  }
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
  sqlite3VdbeGoto(v, labelCmpr);
 
  /* This code runs once to initialize everything.
  */
  sqlite3VdbeJumpHere(v, addr1);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
 
  /* Implement the main merge loop
  */
  sqlite3VdbeResolveLabel(v, labelCmpr);
  sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
  sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
                         (char*)pKeyMerge, P4_KEYINFO);
  sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
  sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
 
  /* Jump to the this point in order to terminate the query.
  */
  sqlite3VdbeResolveLabel(v, labelEnd);
 
  /* Reassembly the compound query so that it will be freed correctly
  ** by the calling function */
  if( p->pPrior ){
    sqlite3SelectDelete(db, p->pPrior);
  }
  p->pPrior = pPrior;
  pPrior->pNext = p;

References ExprList::a, KeyInfo::aColl, KeyInfo::aSortFlags, computeLimitRegisters(), Parse::db, EP_IntValue, ExplainQueryPlan, ExplainQueryPlanPop, Expr::flags, generateOutputSubroutine(), Select::iLimit, Select::iOffset, ExprList::ExprList_item::iOrderByCol, SelectDest::iSdst, Expr::iValue, sqlite3::mallocFailed, multiSelectCollSeq(), multiSelectOrderByKeyInfo(), Parse::nErr, ExprList::nExpr, Parse::nMem, Select::nSelectRow, Select::op, OP_Compare, OP_Copy, OP_Gosub, OP_InitCoroutine, OP_Integer, OP_Jump, OP_Permutation, OP_Yield, OPFLAG_PERMUTE, P4_INTARRAY, P4_KEYINFO, Select::pEList, Select::pLimit, Select::pNext, Select::pOrderBy, Select::pPrior, Parse::pVdbe, selectOpName(), sqlite3DbMallocRawNN(), sqlite3Expr(), sqlite3ExprDelete(), sqlite3ExprListAppend(), sqlite3ExprListDup(), sqlite3KeyInfoAlloc(), sqlite3KeyInfoUnref(), sqlite3LogEstAdd(), sqlite3ResolveOrderGroupBy(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectDestInit(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeEndCoroutine(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_NOMEM_BKPT, SRT_Coroutine, TK_ALL, TK_EXCEPT, TK_INTEGER, TK_INTERSECT, TK_UNION, Expr::u, ExprList::ExprList_item::u, VdbeComment, VdbeCoverage, VdbeNoopComment, and ExprList::ExprList_item::x.

Referenced by multiSelect().

◆ multiSelectOrderByKeyInfo()

static KeyInfo * multiSelectOrderByKeyInfo	(	Parse *	pParse,
		Select *	p,
		int	nExtra )

static

Definition at line 131561 of file sqlite3.c.

                                                                               {
  ExprList *pOrderBy = p->pOrderBy;
  int nOrderBy = p->pOrderBy->nExpr;
  sqlite3 *db = pParse->db;
  KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
  if( pRet ){
    int i;
    for(i=0; i<nOrderBy; i++){
      struct ExprList_item *pItem = &pOrderBy->a[i];
      Expr *pTerm = pItem->pExpr;
      CollSeq *pColl;
 
      if( pTerm->flags & EP_Collate ){
        pColl = sqlite3ExprCollSeq(pParse, pTerm);
      }else{
        pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
        if( pColl==0 ) pColl = db->pDfltColl;
        pOrderBy->a[i].pExpr =
          sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
      }
      assert( sqlite3KeyInfoIsWriteable(pRet) );
      pRet->aColl[i] = pColl;

References ExprList::a, KeyInfo::aColl, KeyInfo::aSortFlags, Parse::db, EP_Collate, Expr::flags, multiSelectCollSeq(), ExprList::nExpr, sqlite3::pDfltColl, ExprList::ExprList_item::pExpr, Select::pOrderBy, ExprList::ExprList_item::sortFlags, sqlite3ExprAddCollateString(), sqlite3ExprCollSeq(), sqlite3KeyInfoAlloc(), and CollSeq::zName.

Referenced by generateWithRecursiveQuery(), and multiSelectOrderBy().

◆ multiSelectValues()

static int multiSelectValues	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pDest )

static

Definition at line 131789 of file sqlite3.c.

                                             : "SELECT (VALUES(1),(2),(3))").
** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
** Since the limit is exactly 1, we only need to evalutes the left-most VALUES.
*/
static int multiSelectValues(
  Parse *pParse,        /* Parsing context */
  Select *p,            /* The right-most of SELECTs to be coded */
  SelectDest *pDest     /* What to do with query results */
){
  int nRow = 1;
  int rc = 0;
  int bShowAll = p->pLimit==0;
  assert( p->selFlags & SF_MultiValue );
  do{
    assert( p->selFlags & SF_Values );
    assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
    assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( p->pWin ) return -1;
#endif
    if( p->pPrior==0 ) break;
    assert( p->pPrior->pNext==p );
    p = p->pPrior;
    nRow += bShowAll;
  }while(1);
  ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
                    nRow==1 ? "" : "S"));
  while( p ){
    selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);

References ExplainQueryPlan, ExprList::nExpr, Select::nSelectRow, Select::op, Select::pEList, Select::pLimit, Select::pNext, Select::pPrior, Select::pWin, selectInnerLoop(), Select::selFlags, SF_MultiValue, SF_Values, TK_ALL, and TK_SELECT.

Referenced by multiSelect().

◆ nameInUsingClause()

static int nameInUsingClause	(	IdList *	pUsing,
		const char *	zCol )

static

Definition at line 97874 of file sqlite3.c.

                                                              {
  if( pUsing ){
    int k;

References IdList::a, IdList::nId, sqlite3StrICmp(), and IdList::IdList_item::zName.

Referenced by lookupName().

◆ newDatabase()

static int newDatabase ( BtShared * pBt )

static

Definition at line 67762 of file sqlite3.c.

                                     {
  MemPage *pP1;
  unsigned char *data;
  int rc;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  if( pBt->nPage>0 ){
    return SQLITE_OK;
  }
  pP1 = pBt->pPage1;
  assert( pP1!=0 );
  data = pP1->aData;
  rc = sqlite3PagerWrite(pP1->pDbPage);
  if( rc ) return rc;
  memcpy(data, zMagicHeader, sizeof(zMagicHeader));
  assert( sizeof(zMagicHeader)==16 );
  data[16] = (u8)((pBt->pageSize>>8)&0xff);
  data[17] = (u8)((pBt->pageSize>>16)&0xff);
  data[18] = 1;
  data[19] = 1;
  assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
  data[20] = (u8)(pBt->pageSize - pBt->usableSize);
  data[21] = 64;
  data[22] = 32;
  data[23] = 32;
  memset(&data[24], 0, 100-24);
  zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
  pBt->btsFlags |= BTS_PAGESIZE_FIXED;
#ifndef SQLITE_OMIT_AUTOVACUUM
  assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
  assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
  put4byte(&data[36 + 4*4], pBt->autoVacuum);

References MemPage::aData, BtShared::autoVacuum, BTS_PAGESIZE_FIXED, BtShared::btsFlags, BtShared::incrVacuum, BtShared::mutex, BtShared::nPage, BtShared::pageSize, MemPage::pDbPage, BtShared::pPage1, PTF_INTKEY, PTF_LEAF, PTF_LEAFDATA, put4byte, sqlite3_mutex_held(), sqlite3PagerWrite(), SQLITE_OK, BtShared::usableSize, zeroPage(), and zMagicHeader.

Referenced by sqlite3BtreeBeginTrans(), sqlite3BtreeNewDb(), and sqlite3BtreeSavepoint().

◆ nocaseCollatingFunc()

static int nocaseCollatingFunc	(	void *	NotUsed,
		int	nKey1,
		const void *	pKey1,
		int	nKey2,
		const void *	pKey2 )

static

Definition at line 162037 of file sqlite3.c.

 {
  int r = sqlite3StrNICmp(
      (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);

References sqlite3StrNICmp, and UNUSED_PARAMETER.

Referenced by openDatabase().

◆ nolockCheckReservedLock()

static int nolockCheckReservedLock	(	sqlite3_file *	NotUsed,
		int *	pResOut )

static

Definition at line 35714 of file sqlite3.c.

◆ nolockClose()

static int nolockClose ( sqlite3_file * id )

static

Definition at line 35731 of file sqlite3.c.

◆ nolockLock()

static int nolockLock	(	sqlite3_file *	NotUsed,
		int	NotUsed2 )

static

Definition at line 35719 of file sqlite3.c.

                                                                       {
  UNUSED_PARAMETER(NotUsed);
  *pResOut = 0;

References UNUSED_PARAMETER.

Referenced by unixShmBarrier().

◆ nolockUnlock()

static int nolockUnlock	(	sqlite3_file *	NotUsed,
		int	NotUsed2 )

static

Definition at line 35723 of file sqlite3.c.

35725 {

35726 UNUSED_PARAMETER2(NotUsed, NotUsed2);

◆ noopMutexAlloc()

static sqlite3_mutex * noopMutexAlloc ( int id )

static

Definition at line 26045 of file sqlite3.c.

26048 { return SQLITE_OK; }

References SQLITE_OK.

◆ noopMutexEnd()

static int noopMutexEnd ( void )

static

Definition at line 26044 of file sqlite3.c.

◆ noopMutexEnter()

static void noopMutexEnter ( sqlite3_mutex * p )

static

Definition at line 26050 of file sqlite3.c.

26050{

◆ noopMutexFree()

static void noopMutexFree ( sqlite3_mutex * p )

static

Definition at line 26049 of file sqlite3.c.

26049{ return SQLITE_OK; }

References SQLITE_OK.

◆ noopMutexInit()

static int noopMutexInit ( void )

static

Definition at line 26043 of file sqlite3.c.

◆ noopMutexLeave()

static void noopMutexLeave ( sqlite3_mutex * p )

static

Definition at line 26055 of file sqlite3.c.

26055{ UNUSED_PARAMETER(p); return; }

References UNUSED_PARAMETER.

◆ noopMutexTry()

static int noopMutexTry ( sqlite3_mutex * p )

static

Definition at line 26051 of file sqlite3.c.

26054 { UNUSED_PARAMETER(p); return; }

◆ noopStepFunc()

static void noopStepFunc	(	sqlite3_context *	p,
		int	n,
		sqlite3_value **	a )

static

Definition at line 151728 of file sqlite3.c.

Referenced by windowAggStep().

◆ noopValueFunc()

static void noopValueFunc ( sqlite3_context * p )

static

Definition at line 151738 of file sqlite3.c.

151738{ /*NO_TEST*/

References UNUSED_PARAMETER.

◆ notValidImpl()

static void notValidImpl	(	Parse *	pParse,
		NameContext *	pNC,
		const char *	zMsg,
		Expr *	pExpr )

static

Definition at line 98442 of file sqlite3.c.

    {...}
**
** As an optimization, since the conditional is almost always false
** (because errors are rare), the conditional is moved outside of the
** function call using a macro.
*/
static void notValidImpl(
   Parse *pParse,       /* Leave error message here */
   NameContext *pNC,    /* The name context */
   const char *zMsg,    /* Type of error */
   Expr *pExpr          /* Invalidate this expression on error */
){
  const char *zIn = "partial index WHERE clauses";
  if( pNC->ncFlags & NC_IdxExpr )      zIn = "index expressions";
#ifndef SQLITE_OMIT_CHECK
  else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
#endif

References NC_IdxExpr, NC_IsCheck, and NameContext::ncFlags.

◆ nth_valueFinalizeFunc()

static void nth_valueFinalizeFunc ( sqlite3_context * pCtx )

static

Definition at line 151410 of file sqlite3.c.

          :
  sqlite3_result_error(
      pCtx, "second argument to nth_value must be a positive integer", -1
  );
}
static void nth_valueFinalizeFunc(sqlite3_context *pCtx){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0);

◆ nth_valueStepFunc()

static void nth_valueStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151369 of file sqlite3.c.

                   {
  i64 nStep;
  sqlite3_value *pValue;
};
static void nth_valueStepFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    i64 iVal;
    switch( sqlite3_value_numeric_type(apArg[1]) ){
      case SQLITE_INTEGER:
        iVal = sqlite3_value_int64(apArg[1]);
        break;
      case SQLITE_FLOAT: {
        double fVal = sqlite3_value_double(apArg[1]);
        if( ((i64)fVal)!=fVal ) goto error_out;
        iVal = (i64)fVal;
        break;
      }
      default:
        goto error_out;
    }
    if( iVal<=0 ) goto error_out;
 
    p->nStep++;
    if( iVal==p->nStep ){
      p->pValue = sqlite3_value_dup(apArg[0]);
      if( !p->pValue ){
        sqlite3_result_error_nomem(pCtx);
      }
    }
  }
  UNUSED_PARAMETER(nArg);
  UNUSED_PARAMETER(apArg);
  return;

References NthValueCtx::nStep, and NthValueCtx::pValue.

◆ ntileInvFunc()

static void ntileInvFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151601 of file sqlite3.c.

151611 {

◆ ntileStepFunc()

static void ntileStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151581 of file sqlite3.c.

 {
  struct NtileCtx *p;
  assert( nArg==1 ); UNUSED_PARAMETER(nArg);
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nParam = sqlite3_value_int64(apArg[0]);
      if( p->nParam<=0 ){
        sqlite3_result_error(
            pCtx, "argument of ntile must be a positive integer", -1

References NtileCtx::nParam, NtileCtx::nTotal, sqlite3_aggregate_context(), sqlite3_result_error(), sqlite3_value_int64(), and UNUSED_PARAMETER.

◆ ntileValueFunc()

static void ntileValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151612 of file sqlite3.c.

                                                 {
  struct NtileCtx *p;
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->nParam>0 ){
    int nSize = (p->nTotal / p->nParam);
    if( nSize==0 ){
      sqlite3_result_int64(pCtx, p->iRow+1);
    }else{
      i64 nLarge = p->nTotal - p->nParam*nSize;
      i64 iSmall = nLarge*(nSize+1);
      i64 iRow = p->iRow;
 
      assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal );
 
      if( iRow<iSmall ){
        sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));

◆ nullifFunc()

static void nullifFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 117961 of file sqlite3.c.

117971 {

References sqlite3_result_value(), sqlite3GetFuncCollSeq(), sqlite3MemCompare(), and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ numberOfCachePages()

static int numberOfCachePages ( PCache * p )

static

Definition at line 49113 of file sqlite3.c.

                                        {
  if( p->szCache>=0 ){
    /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the
    ** suggested cache size is set to N. */
    return p->szCache;
  }else{
    /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the

Referenced by sqlite3PcacheFetchStress(), and sqlite3PcacheSetSpillsize().

◆ numericType()

static u16 numericType ( Mem * pMem )

static

Definition at line 85696 of file sqlite3.c.

                                 {
  if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal) ){
    testcase( pMem->flags & MEM_Int );
    testcase( pMem->flags & MEM_Real );
    testcase( pMem->flags & MEM_IntReal );
    return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal);
  }
  if( pMem->flags & (MEM_Str|MEM_Blob) ){

References computeNumericType(), sqlite3_value::flags, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Real, MEM_Str, and testcase.

Referenced by sqlite3VdbeExec().

◆ openDatabase()

static int openDatabase	(	const char *	zFilename,
		sqlite3 **	ppDb,
		unsigned int	flags,
		const char *	zVfs )

static

Definition at line 164053 of file sqlite3.c.

 {
  sqlite3 *db;                    /* Store allocated handle here */
  int rc;                         /* Return code */
  int isThreadsafe;               /* True for threadsafe connections */
  char *zOpen = 0;                /* Filename argument to pass to BtreeOpen() */
  char *zErrMsg = 0;              /* Error message from sqlite3ParseUri() */
  int i;                          /* Loop counter */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppDb = 0;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
 
  if( sqlite3GlobalConfig.bCoreMutex==0 ){
    isThreadsafe = 0;
  }else if( flags & SQLITE_OPEN_NOMUTEX ){
    isThreadsafe = 0;
  }else if( flags & SQLITE_OPEN_FULLMUTEX ){
    isThreadsafe = 1;
  }else{
    isThreadsafe = sqlite3GlobalConfig.bFullMutex;
  }
 
  if( flags & SQLITE_OPEN_PRIVATECACHE ){
    flags &= ~SQLITE_OPEN_SHAREDCACHE;
  }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
    flags |= SQLITE_OPEN_SHAREDCACHE;
  }
 
  /* Remove harmful bits from the flags parameter
  **
  ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
  ** dealt with in the previous code block.  Besides these, the only
  ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
  ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
  ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits.  Silently mask
  ** off all other flags.
  */
  flags &=  ~( SQLITE_OPEN_DELETEONCLOSE |
               SQLITE_OPEN_EXCLUSIVE |
               SQLITE_OPEN_MAIN_DB |
               SQLITE_OPEN_TEMP_DB |
               SQLITE_OPEN_TRANSIENT_DB |
               SQLITE_OPEN_MAIN_JOURNAL |
               SQLITE_OPEN_TEMP_JOURNAL |
               SQLITE_OPEN_SUBJOURNAL |
               SQLITE_OPEN_SUPER_JOURNAL |
               SQLITE_OPEN_NOMUTEX |
               SQLITE_OPEN_FULLMUTEX |
               SQLITE_OPEN_WAL
             );
 
  /* Allocate the sqlite data structure */
  db = sqlite3MallocZero( sizeof(sqlite3) );
  if( db==0 ) goto opendb_out;
  if( isThreadsafe
#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS
   || sqlite3GlobalConfig.bCoreMutex
#endif
  ){
    db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
    if( db->mutex==0 ){
      sqlite3_free(db);
      db = 0;
      goto opendb_out;
    }
    if( isThreadsafe==0 ){
      sqlite3MutexWarnOnContention(db->mutex);
    }
  }
  sqlite3_mutex_enter(db->mutex);
  db->errMask = 0xff;
  db->nDb = 2;
  db->magic = SQLITE_MAGIC_BUSY;
  db->aDb = db->aDbStatic;
  db->lookaside.bDisable = 1;
  db->lookaside.sz = 0;
 
  assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
  memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
  db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS;
  db->autoCommit = 1;
  db->nextAutovac = -1;
  db->szMmap = sqlite3GlobalConfig.szMmap;
  db->nextPagesize = 0;
  db->nMaxSorterMmap = 0x7FFFFFFF;
  db->flags |= SQLITE_ShortColNames
                 | SQLITE_EnableTrigger
                 | SQLITE_EnableView
                 | SQLITE_CacheSpill
#if !defined(SQLITE_TRUSTED_SCHEMA) || SQLITE_TRUSTED_SCHEMA+0!=0
                 | SQLITE_TrustedSchema
#endif
/* The SQLITE_DQS compile-time option determines the default settings
** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML.
**
**    SQLITE_DQS     SQLITE_DBCONFIG_DQS_DDL    SQLITE_DBCONFIG_DQS_DML
**    ----------     -----------------------    -----------------------
**     undefined               on                          on
**         3                   on                          on
**         2                   on                         off
**         1                  off                          on
**         0                  off                         off
**
** Legacy behavior is 3 (double-quoted string literals are allowed anywhere)
** and so that is the default.  But developers are encouranged to use
** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible.
*/
#if !defined(SQLITE_DQS)
# define SQLITE_DQS 3
#endif
#if (SQLITE_DQS&1)==1
                 | SQLITE_DqsDML
#endif
#if (SQLITE_DQS&2)==2
                 | SQLITE_DqsDDL
#endif
 
#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
                 | SQLITE_AutoIndex
#endif
#if SQLITE_DEFAULT_CKPTFULLFSYNC
                 | SQLITE_CkptFullFSync
#endif
#if SQLITE_DEFAULT_FILE_FORMAT<4
                 | SQLITE_LegacyFileFmt
#endif
#ifdef SQLITE_ENABLE_LOAD_EXTENSION
                 | SQLITE_LoadExtension
#endif
#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
                 | SQLITE_RecTriggers
#endif
#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
                 | SQLITE_ForeignKeys
#endif
#if defined(SQLITE_REVERSE_UNORDERED_SELECTS)
                 | SQLITE_ReverseOrder
#endif
#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
                 | SQLITE_CellSizeCk
#endif
#if defined(SQLITE_ENABLE_FTS3_TOKENIZER)
                 | SQLITE_Fts3Tokenizer
#endif
#if defined(SQLITE_ENABLE_QPSG)
                 | SQLITE_EnableQPSG
#endif
#if defined(SQLITE_DEFAULT_DEFENSIVE)
                 | SQLITE_Defensive
#endif
#if defined(SQLITE_DEFAULT_LEGACY_ALTER_TABLE)
                 | SQLITE_LegacyAlter
#endif
      ;
  sqlite3HashInit(&db->aCollSeq);
#ifndef SQLITE_OMIT_VIRTUALTABLE
  sqlite3HashInit(&db->aModule);
#endif
 
  /* Add the default collation sequence BINARY. BINARY works for both UTF-8
  ** and UTF-16, so add a version for each to avoid any unnecessary
  ** conversions. The only error that can occur here is a malloc() failure.
  **
  ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating
  ** functions:
  */
  createCollation(db, sqlite3StrBINARY, SQLITE_UTF8, 0, binCollFunc, 0);
  createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0);
  createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0);
  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
  createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0);
  if( db->mallocFailed ){
    goto opendb_out;
  }
 
  /* Parse the filename/URI argument
  **
  ** Only allow sensible combinations of bits in the flags argument.
  ** Throw an error if any non-sense combination is used.  If we
  ** do not block illegal combinations here, it could trigger
  ** assert() statements in deeper layers.  Sensible combinations
  ** are:
  **
  **  1:  SQLITE_OPEN_READONLY
  **  2:  SQLITE_OPEN_READWRITE
  **  6:  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
  */
  db->openFlags = flags;
  assert( SQLITE_OPEN_READONLY  == 0x01 );
  assert( SQLITE_OPEN_READWRITE == 0x02 );
  assert( SQLITE_OPEN_CREATE    == 0x04 );
  testcase( (1<<(flags&7))==0x02 ); /* READONLY */
  testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
  testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
  if( ((1<<(flags&7)) & 0x46)==0 ){
    rc = SQLITE_MISUSE_BKPT;  /* IMP: R-18321-05872 */
  }else{
    rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
  }
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
    sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
    sqlite3_free(zErrMsg);
    goto opendb_out;
  }
 
  /* Open the backend database driver */
  rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
                        flags | SQLITE_OPEN_MAIN_DB);
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_IOERR_NOMEM ){
      rc = SQLITE_NOMEM_BKPT;
    }
    sqlite3Error(db, rc);
    goto opendb_out;
  }
  sqlite3BtreeEnter(db->aDb[0].pBt);
  db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
  if( !db->mallocFailed ){
    sqlite3SetTextEncoding(db, SCHEMA_ENC(db));
  }
  sqlite3BtreeLeave(db->aDb[0].pBt);
  db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
 
  /* The default safety_level for the main database is FULL; for the temp
  ** database it is OFF. This matches the pager layer defaults.
  */
  db->aDb[0].zDbSName = "main";
  db->aDb[0].safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
  db->aDb[1].zDbSName = "temp";
  db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF;
 
  db->magic = SQLITE_MAGIC_OPEN;
  if( db->mallocFailed ){
    goto opendb_out;
  }
 
  /* Register all built-in functions, but do not attempt to read the
  ** database schema yet. This is delayed until the first time the database
  ** is accessed.
  */
  sqlite3Error(db, SQLITE_OK);
  sqlite3RegisterPerConnectionBuiltinFunctions(db);
  rc = sqlite3_errcode(db);
 
 
  /* Load compiled-in extensions */
  for(i=0; rc==SQLITE_OK && i<ArraySize(sqlite3BuiltinExtensions); i++){
    rc = sqlite3BuiltinExtensions[i](db);
  }
 
  /* Load automatic extensions - extensions that have been registered
  ** using the sqlite3_automatic_extension() API.
  */
  if( rc==SQLITE_OK ){
    sqlite3AutoLoadExtensions(db);
    rc = sqlite3_errcode(db);
    if( rc!=SQLITE_OK ){
      goto opendb_out;
    }
  }
 
#ifdef SQLITE_ENABLE_INTERNAL_FUNCTIONS
  /* Testing use only!!! The -DSQLITE_ENABLE_INTERNAL_FUNCTIONS=1 compile-time
  ** option gives access to internal functions by default.
  ** Testing use only!!! */
  db->mDbFlags |= DBFLAG_InternalFunc;
#endif
 
  /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
  ** mode.  -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
  ** mode.  Doing nothing at all also makes NORMAL the default.
  */
#ifdef SQLITE_DEFAULT_LOCKING_MODE
  db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
  sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
                          SQLITE_DEFAULT_LOCKING_MODE);
#endif
 
  if( rc ) sqlite3Error(db, rc);
 
  /* Enable the lookaside-malloc subsystem */
  setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
                        sqlite3GlobalConfig.nLookaside);
 
  sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
 
opendb_out:
  if( db ){
    assert( db->mutex!=0 || isThreadsafe==0
           || sqlite3GlobalConfig.bFullMutex==0 );
    sqlite3_mutex_leave(db->mutex);
  }
  rc = sqlite3_errcode(db);
  assert( db!=0 || rc==SQLITE_NOMEM );
  if( rc==SQLITE_NOMEM ){
    sqlite3_close(db);
    db = 0;
  }else if( rc!=SQLITE_OK ){
    db->magic = SQLITE_MAGIC_SICK;
  }
  *ppDb = db;
#ifdef SQLITE_ENABLE_SQLLOG
  if( sqlite3GlobalConfig.xSqllog ){
    /* Opening a db handle. Fourth parameter is passed 0. */
    void *pArg = sqlite3GlobalConfig.pSqllogArg;

References sqlite3::aCollSeq, sqlite3::aDb, sqlite3::aDbStatic, aHardLimit, sqlite3::aLimit, sqlite3::aModule, ArraySize, sqlite3::autoCommit, Lookaside::bDisable, binCollFunc(), createCollation(), DBFLAG_InternalFunc, sqlite3::dfltLockMode, sqlite3::errMask, sqlite3::flags, sqlite3::lookaside, sqlite3::magic, sqlite3::mallocFailed, sqlite3::mDbFlags, sqlite3::mutex, sqlite3::nDb, sqlite3::nextAutovac, sqlite3::nextPagesize, sqlite3::nMaxSorterMmap, nocaseCollatingFunc(), sqlite3::openFlags, PAGER_SYNCHRONOUS_OFF, Db::pBt, Db::pSchema, sqlite3::pVfs, rtrimCollFunc(), Db::safety_level, SCHEMA_ENC, setupLookaside(), sqlite3_close(), sqlite3_errcode(), sqlite3_free(), sqlite3_free_filename(), sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_wal_autocheckpoint(), sqlite3AutoLoadExtensions(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreeOpen(), sqlite3BtreePager(), sqlite3BuiltinExtensions, sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3GlobalConfig, sqlite3HashInit(), sqlite3MallocZero(), sqlite3MutexAlloc(), sqlite3MutexWarnOnContention, sqlite3OomFault(), sqlite3PagerLockingMode(), sqlite3ParseUri(), sqlite3RegisterPerConnectionBuiltinFunctions(), sqlite3SchemaGet(), sqlite3SetTextEncoding(), sqlite3StrBINARY, SQLITE_AutoIndex, SQLITE_CacheSpill, SQLITE_CellSizeCk, SQLITE_CkptFullFSync, SQLITE_DEFAULT_SYNCHRONOUS, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT, SQLITE_DEFAULT_WORKER_THREADS, SQLITE_Defensive, SQLITE_DqsDDL, SQLITE_DqsDML, SQLITE_EnableQPSG, SQLITE_EnableTrigger, SQLITE_EnableView, SQLITE_ForeignKeys, SQLITE_Fts3Tokenizer, SQLITE_IOERR_NOMEM, SQLITE_LegacyAlter, SQLITE_LegacyFileFmt, SQLITE_LIMIT_WORKER_THREADS, SQLITE_LoadExtension, SQLITE_MAGIC_BUSY, SQLITE_MAGIC_OPEN, SQLITE_MAGIC_SICK, SQLITE_MISUSE_BKPT, SQLITE_MUTEX_RECURSIVE, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_FULLMUTEX, SQLITE_OPEN_MAIN_DB, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_NOMUTEX, SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_OPEN_SHAREDCACHE, SQLITE_OPEN_SUBJOURNAL, SQLITE_OPEN_SUPER_JOURNAL, SQLITE_OPEN_TEMP_DB, SQLITE_OPEN_TEMP_JOURNAL, SQLITE_OPEN_TRANSIENT_DB, SQLITE_OPEN_WAL, SQLITE_RecTriggers, SQLITE_ReverseOrder, SQLITE_ShortColNames, SQLITE_TrustedSchema, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, Lookaside::sz, sqlite3::szMmap, testcase, and Db::zDbSName.

Referenced by sqlite3_open_v2().

◆ openDirectory()

static int openDirectory	(	const char *	zFilename,
		int *	pFd )

static

Definition at line 37218 of file sqlite3.c.

                                                         {
  int ii;
  int fd = -1;
  char zDirname[MAX_PATHNAME+1];
 
  sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
  for(ii=(int)strlen(zDirname); ii>0 && zDirname[ii]!='/'; ii--);
  if( ii>0 ){
    zDirname[ii] = '\0';
  }else{
    if( zDirname[0]!='/' ) zDirname[0] = '.';
    zDirname[1] = 0;
  }
  fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
  if( fd>=0 ){

References MAX_PATHNAME, O_BINARY, OSTRACE, robust_open(), sqlite3_snprintf(), SQLITE_CANTOPEN_BKPT, SQLITE_OK, and unixLogError.

◆ openStatTable()

static void openStatTable	(	Parse *	pParse,
		int	iDb,
		int	iStatCur,
		const char *	zWhere,
		const char *	zWhereType )

static

Definition at line 107709 of file sqlite3.c.

 {
  static const struct {
    const char *zName;
    const char *zCols;
  } aTable[] = {
    { "sqlite_stat1", "tbl,idx,stat" },
#if defined(SQLITE_ENABLE_STAT4)
    { "sqlite_stat4", "tbl,idx,neq,nlt,ndlt,sample" },
#else
    { "sqlite_stat4", 0 },
#endif
    { "sqlite_stat3", 0 },
  };
  int i;
  sqlite3 *db = pParse->db;
  Db *pDb;
  Vdbe *v = sqlite3GetVdbe(pParse);
  u32 aRoot[ArraySize(aTable)];
  u8 aCreateTbl[ArraySize(aTable)];
#ifdef SQLITE_ENABLE_STAT4
  const int nToOpen = OptimizationEnabled(db,SQLITE_Stat4) ? 2 : 1;
#else
  const int nToOpen = 1;
#endif
 
  if( v==0 ) return;
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  assert( sqlite3VdbeDb(v)==db );
  pDb = &db->aDb[iDb];
 
  /* Create new statistic tables if they do not exist, or clear them
  ** if they do already exist.
  */
  for(i=0; i<ArraySize(aTable); i++){
    const char *zTab = aTable[i].zName;
    Table *pStat;
    aCreateTbl[i] = 0;
    if( (pStat = sqlite3FindTable(db, zTab, pDb->zDbSName))==0 ){
      if( i<nToOpen ){
        /* The sqlite_statN table does not exist. Create it. Note that a
        ** side-effect of the CREATE TABLE statement is to leave the rootpage
        ** of the new table in register pParse->regRoot. This is important
        ** because the OpenWrite opcode below will be needing it. */
        sqlite3NestedParse(pParse,
            "CREATE TABLE %Q.%s(%s)", pDb->zDbSName, zTab, aTable[i].zCols
        );
        aRoot[i] = (u32)pParse->regRoot;
        aCreateTbl[i] = OPFLAG_P2ISREG;
      }
    }else{
      /* The table already exists. If zWhere is not NULL, delete all entries
      ** associated with the table zWhere. If zWhere is NULL, delete the
      ** entire contents of the table. */
      aRoot[i] = pStat->tnum;
      sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
      if( zWhere ){
        sqlite3NestedParse(pParse,
           "DELETE FROM %Q.%s WHERE %s=%Q",
           pDb->zDbSName, zTab, zWhereType, zWhere
        );
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
      }else if( db->xPreUpdateCallback ){
        sqlite3NestedParse(pParse, "DELETE FROM %Q.%s", pDb->zDbSName, zTab);
#endif
      }else{
        /* The sqlite_stat[134] table already exists.  Delete all rows. */
        sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
      }
    }
  }
 
  /* Open the sqlite_stat[134] tables for writing. */
  for(i=0; i<nToOpen; i++){

References sqlite3::aDb, ArraySize, Parse::db, OP_Clear, OP_OpenWrite, OPFLAG_P2ISREG, OptimizationEnabled, Parse::regRoot, sqlite3FindTable(), sqlite3GetVdbe(), sqlite3NestedParse(), sqlite3TableLock(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeDb(), SQLITE_Stat4, Table::tnum, VdbeComment, Db::zDbSName, and zName.

Referenced by analyzeTable().

◆ openSubJournal()

static int openSubJournal ( Pager * pPager )

static

Definition at line 56127 of file sqlite3.c.

                                        {
  int rc = SQLITE_OK;
  if( !isOpen(pPager->sjfd) ){
    const int flags =  SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE
      | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE
      | SQLITE_OPEN_DELETEONCLOSE;
    int nStmtSpill = sqlite3Config.nStmtSpill;
    if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){

References isOpen, Pager::journalMode, Sqlite3Config::nStmtSpill, PAGER_JOURNALMODE_MEMORY, Pager::pVfs, Pager::sjfd, sqlite3Config, sqlite3JournalOpen(), SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_SUBJOURNAL, and Pager::subjInMemory.

Referenced by subjournalPage().

◆ operatorMask()

static u16 operatorMask ( int op )

static

Definition at line 144126 of file sqlite3.c.

                               {
  u16 c;
  assert( allowedOp(op) );
  if( op==TK_IN ){
    c = WO_IN;
  }else if( op==TK_ISNULL ){
    c = WO_ISNULL;
  }else if( op==TK_IS ){
    c = WO_IS;
  }else{
    assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
    c = (u16)(WO_EQ<<(op-TK_EQ));
  }
  assert( op!=TK_ISNULL || c==WO_ISNULL );
  assert( op!=TK_IN || c==WO_IN );
  assert( op!=TK_EQ || c==WO_EQ );
  assert( op!=TK_LT || c==WO_LT );

Referenced by exprAnalyze().

◆ osLocaltime()

static int osLocaltime	(	time_t *	t,
		struct tm *	pTm )

static

Definition at line 22222 of file sqlite3.c.

              : R-62172-00036 In this implementation, the standard C
** library function localtime_r() is used to assist in the calculation of
** local time.
*/
static int osLocaltime(time_t *t, struct tm *pTm){
  int rc;
#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S
  struct tm *pX;
#if SQLITE_THREADSAFE>0
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  sqlite3_mutex_enter(mutex);
  pX = localtime(t);
#ifndef SQLITE_UNTESTABLE
  if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
#endif
  if( pX ) *pTm = *pX;
  sqlite3_mutex_leave(mutex);
  rc = pX==0;
#else
#ifndef SQLITE_UNTESTABLE
  if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
#endif
#if HAVE_LOCALTIME_R
  rc = localtime_r(t, pTm)==0;
#else

References mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3GlobalConfig, sqlite3MutexAlloc(), and SQLITE_MUTEX_STATIC_MAIN.

Referenced by localtimeOffset().

◆ out2Prerelease()

static Mem * out2Prerelease	(	Vdbe *	p,
		VdbeOp *	pOp )

static

Definition at line 85960 of file sqlite3.c.

                                                              {
  sqlite3VdbeMemSetNull(pOut);
  pOut->flags = MEM_Int;
  return pOut;
}
static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
  Mem *pOut;
  assert( pOp->p2>0 );
  assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
  pOut = &p->aMem[pOp->p2];
  memAboutToChange(p, pOut);
  if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/

References sqlite3_value::flags, MEM_Int, and sqlite3VdbeMemSetNull().

Referenced by sqlite3VdbeExec().

◆ out2PrereleaseWithClear()

static SQLITE_NOINLINE Mem * out2PrereleaseWithClear ( Mem * pOut )

static

Definition at line 85955 of file sqlite3.c.

◆ pageFindSlot()

static u8 * pageFindSlot	(	MemPage *	pPg,
		int	nByte,
		int *	pRc )

static

Definition at line 66021 of file sqlite3.c.

                                                          {
  const int hdr = pPg->hdrOffset;            /* Offset to page header */
  u8 * const aData = pPg->aData;             /* Page data */
  int iAddr = hdr + 1;                       /* Address of ptr to pc */
  int pc = get2byte(&aData[iAddr]);          /* Address of a free slot */
  int x;                                     /* Excess size of the slot */
  int maxPC = pPg->pBt->usableSize - nByte;  /* Max address for a usable slot */
  int size;                                  /* Size of the free slot */
 
  assert( pc>0 );
  while( pc<=maxPC ){
    /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
    ** freeblock form a big-endian integer which is the size of the freeblock
    ** in bytes, including the 4-byte header. */
    size = get2byte(&aData[pc+2]);
    if( (x = size - nByte)>=0 ){
      testcase( x==4 );
      testcase( x==3 );
      if( x<4 ){
        /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total
        ** number of bytes in fragments may not exceed 60. */
        if( aData[hdr+7]>57 ) return 0;
 
        /* Remove the slot from the free-list. Update the number of
        ** fragmented bytes within the page. */
        memcpy(&aData[iAddr], &aData[pc], 2);
        aData[hdr+7] += (u8)x;
      }else if( x+pc > maxPC ){
        /* This slot extends off the end of the usable part of the page */
        *pRc = SQLITE_CORRUPT_PAGE(pPg);
        return 0;
      }else{
        /* The slot remains on the free-list. Reduce its size to account
        ** for the portion used by the new allocation. */
        put2byte(&aData[pc+2], x);
      }
      return &aData[pc + x];
    }
    iAddr = pc;
    pc = get2byte(&aData[pc]);
    if( pc<=iAddr+size ){
      if( pc ){
        /* The next slot in the chain is not past the end of the current slot */
        *pRc = SQLITE_CORRUPT_PAGE(pPg);
      }
      return 0;
    }
  }

References MemPage::aData, get2byte, MemPage::hdrOffset, MemPage::pBt, put2byte, SQLITE_CORRUPT_PAGE, testcase, and BtShared::usableSize.

Referenced by allocateSpace(), and pageInsertArray().

◆ pageFreeArray()

static int pageFreeArray	(	MemPage *	pPg,
		int	iFirst,
		int	nCell,
		CellArray *	pCArray )

static

Definition at line 71572 of file sqlite3.c.

 {
  u8 * const aData = pPg->aData;
  u8 * const pEnd = &aData[pPg->pBt->usableSize];
  u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
  int nRet = 0;
  int i;
  int iEnd = iFirst + nCell;
  u8 *pFree = 0;
  int szFree = 0;
 
  for(i=iFirst; i<iEnd; i++){
    u8 *pCell = pCArray->apCell[i];
    if( SQLITE_WITHIN(pCell, pStart, pEnd) ){
      int sz;
      /* No need to use cachedCellSize() here.  The sizes of all cells that
      ** are to be freed have already been computing while deciding which
      ** cells need freeing */
      sz = pCArray->szCell[i];  assert( sz>0 );
      if( pFree!=(pCell + sz) ){
        if( pFree ){
          assert( pFree>aData && (pFree - aData)<65536 );
          freeSpace(pPg, (u16)(pFree - aData), szFree);
        }
        pFree = pCell;
        szFree = sz;
        if( pFree+sz>pEnd ) return 0;
      }else{
        pFree = pCell;
        szFree += sz;
      }
      nRet++;
    }
  }

References MemPage::aData, CellArray::apCell, MemPage::childPtrSize, freeSpace(), MemPage::hdrOffset, MemPage::pBt, SQLITE_WITHIN, CellArray::szCell, and BtShared::usableSize.

Referenced by editPage().

◆ pageInsertArray()

static int pageInsertArray	(	MemPage *	pPg,
		u8 *	pBegin,
		u8 **	ppData,
		u8 *	pCellptr,
		int	iFirst,
		int	nCell,
		CellArray *	pCArray )

static

Definition at line 71507 of file sqlite3.c.

 {
  int i = iFirst;                 /* Loop counter - cell index to insert */
  u8 *aData = pPg->aData;         /* Complete page */
  u8 *pData = *ppData;            /* Content area.  A subset of aData[] */
  int iEnd = iFirst + nCell;      /* End of loop. One past last cell to ins */
  int k;                          /* Current slot in pCArray->apEnd[] */
  u8 *pEnd;                       /* Maximum extent of cell data */
  assert( CORRUPT_DB || pPg->hdrOffset==0 );    /* Never called on page 1 */
  if( iEnd<=iFirst ) return 0;
  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){}
  pEnd = pCArray->apEnd[k];
  while( 1 /*Exit by break*/ ){
    int sz, rc;
    u8 *pSlot;
    assert( pCArray->szCell[i]!=0 );
    sz = pCArray->szCell[i];
    if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
      if( (pData - pBegin)<sz ) return 1;
      pData -= sz;
      pSlot = pData;
    }
    /* pSlot and pCArray->apCell[i] will never overlap on a well-formed
    ** database.  But they might for a corrupt database.  Hence use memmove()
    ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */
    assert( (pSlot+sz)<=pCArray->apCell[i]
         || pSlot>=(pCArray->apCell[i]+sz)
         || CORRUPT_DB );
    if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd
     && (uptr)(pCArray->apCell[i])<(uptr)pEnd
    ){
      assert( CORRUPT_DB );
      (void)SQLITE_CORRUPT_BKPT;
      return 1;
    }
    memmove(pSlot, pCArray->apCell[i], sz);
    put2byte(pCellptr, (pSlot - aData));
    pCellptr += 2;
    i++;
    if( i>=iEnd ) break;
    if( pCArray->ixNx[k]<=i ){
      k++;

References MemPage::aData, ALWAYS, CellArray::apCell, CellArray::apEnd, CORRUPT_DB, MemPage::hdrOffset, CellArray::ixNx, NB, pageFindSlot(), put2byte, SQLITE_CORRUPT_BKPT, and CellArray::szCell.

Referenced by editPage().

◆ pager_cksum()

static u32 pager_cksum	(	Pager *	pPager,
		const u8 *	aData )

static

Definition at line 53888 of file sqlite3.c.

                                                      {
  u32 cksum = pPager->cksumInit;         /* Checksum value to return */
  int i = pPager->pageSize-200;          /* Loop counter */

References Pager::cksumInit, and Pager::pageSize.

Referenced by pager_playback_one_page().

◆ pager_delsuper()

static int pager_delsuper	(	Pager *	pPager,
		const char *	zSuper )

static

Definition at line 54182 of file sqlite3.c.

       : This function allocates a single block of memory to load
** the entire contents of the super-journal file. This could be
** a couple of kilobytes or so - potentially larger than the page
** size.
*/
static int pager_delsuper(Pager *pPager, const char *zSuper){
  sqlite3_vfs *pVfs = pPager->pVfs;
  int rc;                   /* Return code */
  sqlite3_file *pSuper;     /* Malloc'd super-journal file descriptor */
  sqlite3_file *pJournal;   /* Malloc'd child-journal file descriptor */
  char *zSuperJournal = 0;  /* Contents of super-journal file */
  i64 nSuperJournal;        /* Size of super-journal file */
  char *zJournal;           /* Pointer to one journal within MJ file */
  char *zSuperPtr;          /* Space to hold super-journal filename */
  int nSuperPtr;            /* Amount of space allocated to zSuperPtr[] */
 
  /* Allocate space for both the pJournal and pSuper file descriptors.
  ** If successful, open the super-journal file for reading.
  */
  pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
  if( !pSuper ){
    rc = SQLITE_NOMEM_BKPT;
    pJournal = 0;
  }else{
    const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
    rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0);
    pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile);
  }
  if( rc!=SQLITE_OK ) goto delsuper_out;
 
  /* Load the entire super-journal file into space obtained from
  ** sqlite3_malloc() and pointed to by zSuperJournal.   Also obtain
  ** sufficient space (in zSuperPtr) to hold the names of super-journal
  ** files extracted from regular rollback-journals.
  */
  rc = sqlite3OsFileSize(pSuper, &nSuperJournal);
  if( rc!=SQLITE_OK ) goto delsuper_out;
  nSuperPtr = pVfs->mxPathname+1;
  zSuperJournal = sqlite3Malloc(nSuperJournal + nSuperPtr + 2);
  if( !zSuperJournal ){
    rc = SQLITE_NOMEM_BKPT;
    goto delsuper_out;
  }
  zSuperPtr = &zSuperJournal[nSuperJournal+2];
  rc = sqlite3OsRead(pSuper, zSuperJournal, (int)nSuperJournal, 0);
  if( rc!=SQLITE_OK ) goto delsuper_out;
  zSuperJournal[nSuperJournal] = 0;
  zSuperJournal[nSuperJournal+1] = 0;
 
  zJournal = zSuperJournal;
  while( (zJournal-zSuperJournal)<nSuperJournal ){
    int exists;
    rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
    if( rc!=SQLITE_OK ){
      goto delsuper_out;
    }
    if( exists ){
      /* One of the journals pointed to by the super-journal exists.
      ** Open it and check if it points at the super-journal. If
      ** so, return without deleting the super-journal file.
      ** NB:  zJournal is really a MAIN_JOURNAL.  But call it a
      ** SUPER_JOURNAL here so that the VFS will not send the zJournal
      ** name into sqlite3_database_file_object().
      */
      int c;
      int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
      rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
      if( rc!=SQLITE_OK ){
        goto delsuper_out;
      }
 
      rc = readSuperJournal(pJournal, zSuperPtr, nSuperPtr);
      sqlite3OsClose(pJournal);
      if( rc!=SQLITE_OK ){
        goto delsuper_out;
      }
 
      c = zSuperPtr[0]!=0 && strcmp(zSuperPtr, zSuper)==0;
      if( c ){
        /* We have a match. Do not delete the super-journal file. */
        goto delsuper_out;
      }
    }
    zJournal += (sqlite3Strlen30(zJournal)+1);
  }
 
  sqlite3OsClose(pSuper);
  rc = sqlite3OsDelete(pVfs, zSuper, 0);
 
delsuper_out:
  sqlite3_free(zSuperJournal);
  if( pSuper ){

References isOpen, sqlite3_vfs::mxPathname, Pager::pVfs, readSuperJournal(), sqlite3_free(), sqlite3Malloc(), sqlite3MallocZero(), sqlite3OsAccess(), sqlite3OsClose(), sqlite3OsDelete(), sqlite3OsFileSize(), sqlite3OsOpen(), sqlite3OsRead(), sqlite3Strlen30(), SQLITE_ACCESS_EXISTS, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_READONLY, SQLITE_OPEN_SUPER_JOURNAL, and sqlite3_vfs::szOsFile.

Referenced by pager_playback().

◆ pager_end_transaction()

static int pager_end_transaction	(	Pager *	pPager,
		int	hasSuper,
		int	bCommit )

static

Definition at line 53707 of file sqlite3.c.

                                                                          {
  int rc = SQLITE_OK;      /* Error code from journal finalization operation */
  int rc2 = SQLITE_OK;     /* Error code from db file unlock operation */
 
  /* Do nothing if the pager does not have an open write transaction
  ** or at least a RESERVED lock. This function may be called when there
  ** is no write-transaction active but a RESERVED or greater lock is
  ** held under two circumstances:
  **
  **   1. After a successful hot-journal rollback, it is called with
  **      eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
  **
  **   2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
  **      lock switches back to locking_mode=normal and then executes a
  **      read-transaction, this function is called with eState==PAGER_READER
  **      and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
  */
  assert( assert_pager_state(pPager) );
  assert( pPager->eState!=PAGER_ERROR );
  if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
    return SQLITE_OK;
  }
 
  releaseAllSavepoints(pPager);
  assert( isOpen(pPager->jfd) || pPager->pInJournal==0
      || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
  );
  if( isOpen(pPager->jfd) ){
    assert( !pagerUseWal(pPager) );
 
    /* Finalize the journal file. */
    if( sqlite3JournalIsInMemory(pPager->jfd) ){
      /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
      sqlite3OsClose(pPager->jfd);
    }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
      if( pPager->journalOff==0 ){
        rc = SQLITE_OK;
      }else{
        rc = sqlite3OsTruncate(pPager->jfd, 0);
        if( rc==SQLITE_OK && pPager->fullSync ){
          /* Make sure the new file size is written into the inode right away.
          ** Otherwise the journal might resurrect following a power loss and
          ** cause the last transaction to roll back.  See
          ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773
          */
          rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
        }
      }
      pPager->journalOff = 0;
    }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
      || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
    ){
      rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile);
      pPager->journalOff = 0;
    }else{
      /* This branch may be executed with Pager.journalMode==MEMORY if
      ** a hot-journal was just rolled back. In this case the journal
      ** file should be closed and deleted. If this connection writes to
      ** the database file, it will do so using an in-memory journal.
      */
      int bDelete = !pPager->tempFile;
      assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
      assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
           || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
           || pPager->journalMode==PAGER_JOURNALMODE_WAL
      );
      sqlite3OsClose(pPager->jfd);
      if( bDelete ){
        rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
      }
    }
  }
 
#ifdef SQLITE_CHECK_PAGES
  sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
  if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
    PgHdr *p = sqlite3PagerLookup(pPager, 1);
    if( p ){
      p->pageHash = 0;
      sqlite3PagerUnrefNotNull(p);
    }
  }
#endif
 
  sqlite3BitvecDestroy(pPager->pInJournal);
  pPager->pInJournal = 0;
  pPager->nRec = 0;
  if( rc==SQLITE_OK ){
    if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){
      sqlite3PcacheCleanAll(pPager->pPCache);
    }else{
      sqlite3PcacheClearWritable(pPager->pPCache);
    }
    sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
  }
 
  if( pagerUseWal(pPager) ){
    /* Drop the WAL write-lock, if any. Also, if the connection was in
    ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
    ** lock held on the database file.
    */
    rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
    assert( rc2==SQLITE_OK );
  }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
    /* This branch is taken when committing a transaction in rollback-journal
    ** mode if the database file on disk is larger than the database image.
    ** At this point the journal has been finalized and the transaction
    ** successfully committed, but the EXCLUSIVE lock is still held on the
    ** file. So it is safe to truncate the database file to its minimum
    ** required size.  */
    assert( pPager->eLock==EXCLUSIVE_LOCK );
    rc = pager_truncate(pPager, pPager->dbSize);
  }
 
  if( rc==SQLITE_OK && bCommit ){
    rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
    if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
  }
 
  if( !pPager->exclusiveMode
   && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
  ){
    rc2 = pagerUnlockDb(pPager, SHARED_LOCK);

References Pager::dbFileSize, Pager::dbSize, Pager::eLock, Pager::eState, EXCLUSIVE_LOCK, Pager::exclusiveMode, Pager::extraSync, Pager::fd, Pager::fullSync, isOpen, Pager::jfd, Pager::journalMode, Pager::journalOff, MEMDB, Pager::nRec, PAGER_ERROR, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_PERSIST, PAGER_JOURNALMODE_TRUNCATE, PAGER_JOURNALMODE_WAL, PAGER_READER, pager_set_pagehash, pager_truncate(), PAGER_WRITER_LOCKED, pagerFlushOnCommit(), pagerUnlockDb(), pagerUseWal, Pager::pInJournal, Pager::pPCache, Pager::pVfs, Pager::pWal, releaseAllSavepoints(), RESERVED_LOCK, Pager::setSuper, SHARED_LOCK, sqlite3BitvecDestroy(), sqlite3JournalIsInMemory(), sqlite3OsClose(), sqlite3OsDelete(), sqlite3OsDeviceCharacteristics(), sqlite3OsFileControl(), sqlite3OsSync(), sqlite3OsTruncate(), sqlite3PagerLookup(), sqlite3PagerUnrefNotNull(), sqlite3PcacheCleanAll(), sqlite3PcacheClearWritable(), sqlite3PcacheRefCount(), sqlite3PcacheTruncate(), sqlite3WalEndWriteTransaction(), sqlite3WalExclusiveMode(), SQLITE_FCNTL_COMMIT_PHASETWO, SQLITE_IOCAP_BATCH_ATOMIC, SQLITE_NOTFOUND, SQLITE_OK, Pager::syncFlags, Pager::tempFile, zeroJournalHdr(), and Pager::zJournal.

Referenced by pager_playback(), pagerUnlockAndRollback(), sqlite3PagerCommitPhaseTwo(), and sqlite3PagerRollback().

◆ pager_error()

static int pager_error	(	Pager *	pPager,
		int	rc )

static

Definition at line 53613 of file sqlite3.c.

                                             {
  int rc2 = rc & 0xff;
  assert( rc==SQLITE_OK || !MEMDB );
  assert(
       pPager->errCode==SQLITE_FULL ||
       pPager->errCode==SQLITE_OK ||
       (pPager->errCode & 0xff)==SQLITE_IOERR
  );
  if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){

References Pager::errCode, Pager::eState, MEMDB, PAGER_ERROR, setGetterMethod(), SQLITE_FULL, SQLITE_IOERR, and SQLITE_OK.

Referenced by pagerStress(), sqlite3PagerClose(), sqlite3PagerCommitPhaseTwo(), sqlite3PagerRollback(), and sqlite3PagerSharedLock().

◆ pager_incr_changecounter()

static int pager_incr_changecounter	(	Pager *	pPager,
		int	isDirectMode )

static

Definition at line 57916 of file sqlite3.c.

                                                                    {
  int rc = SQLITE_OK;
 
  assert( pPager->eState==PAGER_WRITER_CACHEMOD
       || pPager->eState==PAGER_WRITER_DBMOD
  );
  assert( assert_pager_state(pPager) );
 
  /* Declare and initialize constant integer 'isDirect'. If the
  ** atomic-write optimization is enabled in this build, then isDirect
  ** is initialized to the value passed as the isDirectMode parameter
  ** to this function. Otherwise, it is always set to zero.
  **
  ** The idea is that if the atomic-write optimization is not
  ** enabled at compile time, the compiler can omit the tests of
  ** 'isDirect' below, as well as the block enclosed in the
  ** "if( isDirect )" condition.
  */
#ifndef SQLITE_ENABLE_ATOMIC_WRITE
# define DIRECT_MODE 0
  assert( isDirectMode==0 );
  UNUSED_PARAMETER(isDirectMode);
#else
# define DIRECT_MODE isDirectMode
#endif
 
  if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
    PgHdr *pPgHdr;                /* Reference to page 1 */
 
    assert( !pPager->tempFile && isOpen(pPager->fd) );
 
    /* Open page 1 of the file for writing. */
    rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
    assert( pPgHdr==0 || rc==SQLITE_OK );
 
    /* If page one was fetched successfully, and this function is not
    ** operating in direct-mode, make page 1 writable.  When not in
    ** direct mode, page 1 is always held in cache and hence the PagerGet()
    ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
    */
    if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
      rc = sqlite3PagerWrite(pPgHdr);
    }
 
    if( rc==SQLITE_OK ){
      /* Actually do the update of the change counter */
      pager_write_changecounter(pPgHdr);
 
      /* If running in direct mode, write the contents of page 1 to the file. */
      if( DIRECT_MODE ){
        const void *zBuf;
        assert( pPager->dbFileSize>0 );
        zBuf = pPgHdr->pData;
        if( rc==SQLITE_OK ){
          rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
          pPager->aStat[PAGER_STAT_WRITE]++;
        }
        if( rc==SQLITE_OK ){
          /* Update the pager's copy of the change-counter. Otherwise, the
          ** next time a read transaction is opened the cache will be
          ** flushed (as the change-counter values will not match).  */
          const void *pCopy = (const void *)&((const char *)zBuf)[24];
          memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
          pPager->changeCountDone = 1;
        }
      }else{
        pPager->changeCountDone = 1;
      }
    }

References ALWAYS, Pager::aStat, Pager::changeCountDone, Pager::dbFileSize, Pager::dbFileVers, Pager::dbSize, DIRECT_MODE, Pager::eState, Pager::fd, isOpen, PAGER_STAT_WRITE, pager_write_changecounter(), PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, Pager::pageSize, PgHdr::pData, sqlite3OsWrite(), sqlite3PagerGet(), sqlite3PagerUnref(), sqlite3PagerWrite(), SQLITE_OK, Pager::tempFile, and UNUSED_PARAMETER.

Referenced by sqlite3PagerCommitPhaseOne().

◆ pager_open_journal()

static int pager_open_journal ( Pager * pPager )

static

Definition at line 57432 of file sqlite3.c.

                                            {
  int rc = SQLITE_OK;                        /* Return code */
  sqlite3_vfs * const pVfs = pPager->pVfs;   /* Local cache of vfs pointer */
 
  assert( pPager->eState==PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  assert( pPager->pInJournal==0 );
 
  /* If already in the error state, this function is a no-op.  But on
  ** the other hand, this routine is never called if we are already in
  ** an error state. */
  if( NEVER(pPager->errCode) ) return pPager->errCode;
 
  if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
    pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
    if( pPager->pInJournal==0 ){
      return SQLITE_NOMEM_BKPT;
    }
 
    /* Open the journal file if it is not already open. */
    if( !isOpen(pPager->jfd) ){
      if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
        sqlite3MemJournalOpen(pPager->jfd);
      }else{
        int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
        int nSpill;
 
        if( pPager->tempFile ){
          flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
          nSpill = sqlite3Config.nStmtSpill;
        }else{
          flags |= SQLITE_OPEN_MAIN_JOURNAL;
          nSpill = jrnlBufferSize(pPager);
        }
 
        /* Verify that the database still has the same name as it did when
        ** it was originally opened. */
        rc = databaseIsUnmoved(pPager);
        if( rc==SQLITE_OK ){
          rc = sqlite3JournalOpen (
              pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
          );
        }
      }
      assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
    }
 
 
    /* Write the first journal header to the journal file and open
    ** the sub-journal if necessary.
    */
    if( rc==SQLITE_OK ){
      /* TODO: Check if all of these are really required. */
      pPager->nRec = 0;
      pPager->journalOff = 0;
      pPager->setSuper = 0;
      pPager->journalHdr = 0;
      rc = writeJournalHdr(pPager);
    }
  }
 
  if( rc!=SQLITE_OK ){
    sqlite3BitvecDestroy(pPager->pInJournal);
    pPager->pInJournal = 0;
  }else{

References databaseIsUnmoved(), Pager::dbSize, Pager::errCode, Pager::eState, isOpen, Pager::jfd, Pager::journalHdr, Pager::journalMode, Pager::journalOff, jrnlBufferSize(), NEVER, Pager::nRec, Sqlite3Config::nStmtSpill, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_WRITER_CACHEMOD, PAGER_WRITER_LOCKED, pagerUseWal, Pager::pInJournal, Pager::pVfs, Pager::setSuper, sqlite3BitvecCreate(), sqlite3BitvecDestroy(), sqlite3Config, sqlite3JournalOpen(), sqlite3MemJournalOpen(), SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_READWRITE, SQLITE_OPEN_TEMP_JOURNAL, Pager::tempFile, writeJournalHdr(), and Pager::zJournal.

Referenced by pager_write().

◆ pager_playback()

static int pager_playback	(	Pager *	pPager,
		int	isHot )

static

Definition at line 54440 of file sqlite3.c.

                                                   {
  sqlite3_vfs *pVfs = pPager->pVfs;
  i64 szJ;                 /* Size of the journal file in bytes */
  u32 nRec;                /* Number of Records in the journal */
  u32 u;                   /* Unsigned loop counter */
  Pgno mxPg = 0;           /* Size of the original file in pages */
  int rc;                  /* Result code of a subroutine */
  int res = 1;             /* Value returned by sqlite3OsAccess() */
  char *zSuper = 0;        /* Name of super-journal file if any */
  int needPagerReset;      /* True to reset page prior to first page rollback */
  int nPlayback = 0;       /* Total number of pages restored from journal */
  u32 savedPageSize = pPager->pageSize;
 
  /* Figure out how many records are in the journal.  Abort early if
  ** the journal is empty.
  */
  assert( isOpen(pPager->jfd) );
  rc = sqlite3OsFileSize(pPager->jfd, &szJ);
  if( rc!=SQLITE_OK ){
    goto end_playback;
  }
 
  /* Read the super-journal name from the journal, if it is present.
  ** If a super-journal file name is specified, but the file is not
  ** present on disk, then the journal is not hot and does not need to be
  ** played back.
  **
  ** TODO: Technically the following is an error because it assumes that
  ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
  ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
  ** mxPathname is 512, which is the same as the minimum allowable value
  ** for pageSize.
  */
  zSuper = pPager->pTmpSpace;
  rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
  if( rc==SQLITE_OK && zSuper[0] ){
    rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
  }
  zSuper = 0;
  if( rc!=SQLITE_OK || !res ){
    goto end_playback;
  }
  pPager->journalOff = 0;
  needPagerReset = isHot;
 
  /* This loop terminates either when a readJournalHdr() or
  ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
  ** occurs.
  */
  while( 1 ){
    /* Read the next journal header from the journal file.  If there are
    ** not enough bytes left in the journal file for a complete header, or
    ** it is corrupted, then a process must have failed while writing it.
    ** This indicates nothing more needs to be rolled back.
    */
    rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
    if( rc!=SQLITE_OK ){
      if( rc==SQLITE_DONE ){
        rc = SQLITE_OK;
      }
      goto end_playback;
    }
 
    /* If nRec is 0xffffffff, then this journal was created by a process
    ** working in no-sync mode. This means that the rest of the journal
    ** file consists of pages, there are no more journal headers. Compute
    ** the value of nRec based on this assumption.
    */
    if( nRec==0xffffffff ){
      assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
      nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
    }
 
    /* If nRec is 0 and this rollback is of a transaction created by this
    ** process and if this is the final header in the journal, then it means
    ** that this part of the journal was being filled but has not yet been
    ** synced to disk.  Compute the number of pages based on the remaining
    ** size of the file.
    **
    ** The third term of the test was added to fix ticket #2565.
    ** When rolling back a hot journal, nRec==0 always means that the next
    ** chunk of the journal contains zero pages to be rolled back.  But
    ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
    ** the journal, it means that the journal might contain additional
    ** pages that need to be rolled back and that the number of pages
    ** should be computed based on the journal file size.
    */
    if( nRec==0 && !isHot &&
        pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
      nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
    }
 
    /* If this is the first header read from the journal, truncate the
    ** database file back to its original size.
    */
    if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
      rc = pager_truncate(pPager, mxPg);
      if( rc!=SQLITE_OK ){
        goto end_playback;
      }
      pPager->dbSize = mxPg;
    }
 
    /* Copy original pages out of the journal and back into the
    ** database file and/or page cache.
    */
    for(u=0; u<nRec; u++){
      if( needPagerReset ){
        pager_reset(pPager);
        needPagerReset = 0;
      }
      rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
      if( rc==SQLITE_OK ){
        nPlayback++;
      }else{
        if( rc==SQLITE_DONE ){
          pPager->journalOff = szJ;
          break;
        }else if( rc==SQLITE_IOERR_SHORT_READ ){
          /* If the journal has been truncated, simply stop reading and
          ** processing the journal. This might happen if the journal was
          ** not completely written and synced prior to a crash.  In that
          ** case, the database should have never been written in the
          ** first place so it is OK to simply abandon the rollback. */
          rc = SQLITE_OK;
          goto end_playback;
        }else{
          /* If we are unable to rollback, quit and return the error
          ** code.  This will cause the pager to enter the error state
          ** so that no further harm will be done.  Perhaps the next
          ** process to come along will be able to rollback the database.
          */
          goto end_playback;
        }
      }
    }
  }
  /*NOTREACHED*/
  assert( 0 );
 
end_playback:
  if( rc==SQLITE_OK ){
    rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1);
  }
  /* Following a rollback, the database file should be back in its original
  ** state prior to the start of the transaction, so invoke the
  ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
  ** assertion that the transaction counter was modified.
  */
#ifdef SQLITE_DEBUG
  sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
#endif
 
  /* If this playback is happening automatically as a result of an IO or
  ** malloc error that occurred after the change-counter was updated but
  ** before the transaction was committed, then the change-counter
  ** modification may just have been reverted. If this happens in exclusive
  ** mode, then subsequent transactions performed by the connection will not
  ** update the change-counter at all. This may lead to cache inconsistency
  ** problems for other processes at some point in the future. So, just
  ** in case this has happened, clear the changeCountDone flag now.
  */
  pPager->changeCountDone = pPager->tempFile;
 
  if( rc==SQLITE_OK ){
    zSuper = pPager->pTmpSpace;
    rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
    testcase( rc!=SQLITE_OK );
  }
  if( rc==SQLITE_OK
   && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
  ){
    rc = sqlite3PagerSync(pPager, 0);
  }
  if( rc==SQLITE_OK ){
    rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0);
    testcase( rc!=SQLITE_OK );
  }
  if( rc==SQLITE_OK && zSuper[0] && res ){
    /* If there was a super-journal and this routine will return success,
    ** see if it is possible to delete the super-journal.
    */
    rc = pager_delsuper(pPager, zSuper);
    testcase( rc!=SQLITE_OK );
  }
  if( isHot && nPlayback ){
    sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s",
                nPlayback, pPager->zJournal);
  }
 
  /* The Pager.sectorSize variable may have been updated while rolling

References Pager::changeCountDone, Pager::dbSize, Pager::eState, Pager::fd, isOpen, Pager::jfd, JOURNAL_HDR_SZ, JOURNAL_PG_SZ, Pager::journalHdr, Pager::journalOff, sqlite3_vfs::mxPathname, pager_delsuper(), pager_end_transaction(), PAGER_OPEN, pager_playback_one_page(), pager_reset(), pager_truncate(), PAGER_WRITER_DBMOD, Pager::pageSize, Pager::pTmpSpace, Pager::pVfs, readJournalHdr(), readSuperJournal(), setSectorSize(), sqlite3_log(), sqlite3OsAccess(), sqlite3OsFileControlHint(), sqlite3OsFileSize(), sqlite3PagerSetPagesize(), sqlite3PagerSync(), SQLITE_ACCESS_EXISTS, SQLITE_DONE, SQLITE_FCNTL_DB_UNCHANGED, SQLITE_IOERR_SHORT_READ, SQLITE_NOTICE_RECOVER_ROLLBACK, SQLITE_OK, Pager::tempFile, testcase, and Pager::zJournal.

Referenced by sqlite3PagerRollback(), and sqlite3PagerSharedLock().

◆ pager_playback_one_page()

static int pager_playback_one_page	(	Pager *	pPager,
		i64 *	pOffset,
		Bitvec *	pDone,
		int	isMainJrnl,
		int	isSavepnt )

static

Definition at line 53935 of file sqlite3.c.

 {
  int rc;
  PgHdr *pPg;                   /* An existing page in the cache */
  Pgno pgno;                    /* The page number of a page in journal */
  u32 cksum;                    /* Checksum used for sanity checking */
  char *aData;                  /* Temporary storage for the page */
  sqlite3_file *jfd;            /* The file descriptor for the journal file */
  int isSynced;                 /* True if journal page is synced */
 
  assert( (isMainJrnl&~1)==0 );      /* isMainJrnl is 0 or 1 */
  assert( (isSavepnt&~1)==0 );       /* isSavepnt is 0 or 1 */
  assert( isMainJrnl || pDone );     /* pDone always used on sub-journals */
  assert( isSavepnt || pDone==0 );   /* pDone never used on non-savepoint */
 
  aData = pPager->pTmpSpace;
  assert( aData );         /* Temp storage must have already been allocated */
  assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
 
  /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
  ** or savepoint rollback done at the request of the caller) or this is
  ** a hot-journal rollback. If it is a hot-journal rollback, the pager
  ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
  ** only reads from the main journal, not the sub-journal.
  */
  assert( pPager->eState>=PAGER_WRITER_CACHEMOD
       || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
  );
  assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
 
  /* Read the page number and page data from the journal or sub-journal
  ** file. Return an error code to the caller if an IO error occurs.
  */
  jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
  rc = read32bits(jfd, *pOffset, &pgno);
  if( rc!=SQLITE_OK ) return rc;
  rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
  if( rc!=SQLITE_OK ) return rc;
  *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
 
  /* Sanity checking on the page.  This is more important that I originally
  ** thought.  If a power failure occurs while the journal is being written,
  ** it could cause invalid data to be written into the journal.  We need to
  ** detect this invalid data (with high probability) and ignore it.
  */
  if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
    assert( !isSavepnt );
    return SQLITE_DONE;
  }
  if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
    return SQLITE_OK;
  }
  if( isMainJrnl ){
    rc = read32bits(jfd, (*pOffset)-4, &cksum);
    if( rc ) return rc;
    if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
      return SQLITE_DONE;
    }
  }
 
  /* If this page has already been played back before during the current
  ** rollback, then don't bother to play it back again.
  */
  if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
    return rc;
  }
 
  /* When playing back page 1, restore the nReserve setting
  */
  if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
    pPager->nReserve = ((u8*)aData)[20];
  }
 
  /* If the pager is in CACHEMOD state, then there must be a copy of this
  ** page in the pager cache. In this case just update the pager cache,
  ** not the database file. The page is left marked dirty in this case.
  **
  ** An exception to the above rule: If the database is in no-sync mode
  ** and a page is moved during an incremental vacuum then the page may
  ** not be in the pager cache. Later: if a malloc() or IO error occurs
  ** during a Movepage() call, then the page may not be in the cache
  ** either. So the condition described in the above paragraph is not
  ** assert()able.
  **
  ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
  ** pager cache if it exists and the main file. The page is then marked
  ** not dirty. Since this code is only executed in PAGER_OPEN state for
  ** a hot-journal rollback, it is guaranteed that the page-cache is empty
  ** if the pager is in OPEN state.
  **
  ** Ticket #1171:  The statement journal might contain page content that is
  ** different from the page content at the start of the transaction.
  ** This occurs when a page is changed prior to the start of a statement
  ** then changed again within the statement.  When rolling back such a
  ** statement we must not write to the original database unless we know
  ** for certain that original page contents are synced into the main rollback
  ** journal.  Otherwise, a power loss might leave modified data in the
  ** database file without an entry in the rollback journal that can
  ** restore the database to its original form.  Two conditions must be
  ** met before writing to the database files. (1) the database must be
  ** locked.  (2) we know that the original page content is fully synced
  ** in the main journal either because the page is not in cache or else
  ** the page is marked as needSync==0.
  **
  ** 2008-04-14:  When attempting to vacuum a corrupt database file, it
  ** is possible to fail a statement on a database that does not yet exist.
  ** Do not attempt to write if database file has never been opened.
  */
  if( pagerUseWal(pPager) ){
    pPg = 0;
  }else{
    pPg = sqlite3PagerLookup(pPager, pgno);
  }
  assert( pPg || !MEMDB );
  assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
  PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
           PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
           (isMainJrnl?"main-journal":"sub-journal")
  ));
  if( isMainJrnl ){
    isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
  }else{
    isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
  }
  if( isOpen(pPager->fd)
   && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
   && isSynced
  ){
    i64 ofst = (pgno-1)*(i64)pPager->pageSize;
    testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
    assert( !pagerUseWal(pPager) );
 
    /* Write the data read from the journal back into the database file.
    ** This is usually safe even for an encrypted database - as the data
    ** was encrypted before it was written to the journal file. The exception
    ** is if the data was just read from an in-memory sub-journal. In that
    ** case it must be encrypted here before it is copied into the database
    ** file.  */
    rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
 
    if( pgno>pPager->dbFileSize ){
      pPager->dbFileSize = pgno;
    }
    if( pPager->pBackup ){
      sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
    }
  }else if( !isMainJrnl && pPg==0 ){
    /* If this is a rollback of a savepoint and data was not written to
    ** the database and the page is not in-memory, there is a potential
    ** problem. When the page is next fetched by the b-tree layer, it
    ** will be read from the database file, which may or may not be
    ** current.
    **
    ** There are a couple of different ways this can happen. All are quite
    ** obscure. When running in synchronous mode, this can only happen
    ** if the page is on the free-list at the start of the transaction, then
    ** populated, then moved using sqlite3PagerMovepage().
    **
    ** The solution is to add an in-memory page to the cache containing
    ** the data just read from the sub-journal. Mark the page as dirty
    ** and if the pager requires a journal-sync, then mark the page as
    ** requiring a journal-sync before it is written.
    */
    assert( isSavepnt );
    assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
    pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
    rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
    assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
    pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
    if( rc!=SQLITE_OK ) return rc;
    sqlite3PcacheMakeDirty(pPg);
  }
  if( pPg ){
    /* No page should ever be explicitly rolled back that is in use, except
    ** for page 1 which is held in use in order to keep the lock on the
    ** database active. However such a page may be rolled back as a result
    ** of an internal error resulting in an automatic call to
    ** sqlite3PagerRollback().
    */
    void *pData;
    pData = pPg->pData;
    memcpy(pData, (u8*)aData, pPager->pageSize);
    pPager->xReiniter(pPg);
    /* It used to be that sqlite3PcacheMakeClean(pPg) was called here.  But
    ** that call was dangerous and had no detectable benefit since the cache
    ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so
    ** has been removed. */
    pager_set_pagehash(pPg);
 
    /* If this was page 1, then restore the value of Pager.dbFileVers.
    ** Do this before any decoding. */
    if( pgno==1 ){

References Pager::dbFileSize, Pager::dbFileVers, Pager::dbSize, Pager::doNotSpill, Pager::eLock, Pager::eState, EXCLUSIVE_LOCK, Pager::fd, PgHdr::flags, isOpen, Pager::jfd, Pager::journalHdr, MEMDB, Pager::noSync, Pager::nReserve, pager_cksum(), pager_datahash, PAGER_MJ_PGNO, PAGER_OPEN, pager_set_pagehash, PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGERID, PAGERTRACE, pagerUseWal, Pager::pageSize, Pager::pBackup, PgHdr::pData, PGHDR_NEED_SYNC, Pager::pTmpSpace, read32bits(), Pager::sjfd, SPILLFLAG_ROLLBACK, sqlite3BackupUpdate(), sqlite3BitvecSet(), sqlite3BitvecTest(), sqlite3OsRead(), sqlite3OsWrite(), sqlite3PagerGet(), sqlite3PagerLookup(), sqlite3PcacheMakeDirty(), sqlite3PcacheRelease(), SQLITE_DONE, SQLITE_OK, Pager::tempFile, testcase, and Pager::xReiniter.

Referenced by pager_playback(), and pagerPlaybackSavepoint().

◆ pager_reset()

static void pager_reset ( Pager * pPager )

static

Definition at line 53447 of file sqlite3.c.

Referenced by pager_playback(), pager_unlock(), pagerBeginReadTransaction(), sqlite3PagerClose(), sqlite3PagerSetPagesize(), and sqlite3PagerSharedLock().

◆ pager_truncate()

static int pager_truncate	(	Pager *	pPager,
		Pgno	nPage )

static

Definition at line 54297 of file sqlite3.c.

                                                    {
  int rc = SQLITE_OK;
  assert( pPager->eState!=PAGER_ERROR );
  assert( pPager->eState!=PAGER_READER );
 
  if( isOpen(pPager->fd)
   && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
  ){
    i64 currentSize, newSize;
    int szPage = pPager->pageSize;
    assert( pPager->eLock==EXCLUSIVE_LOCK );
    /* TODO: Is it safe to use Pager.dbFileSize here? */
    rc = sqlite3OsFileSize(pPager->fd, &currentSize);
    newSize = szPage*(i64)nPage;
    if( rc==SQLITE_OK && currentSize!=newSize ){
      if( currentSize>newSize ){
        rc = sqlite3OsTruncate(pPager->fd, newSize);
      }else if( (currentSize+szPage)<=newSize ){
        char *pTmp = pPager->pTmpSpace;
        memset(pTmp, 0, szPage);
        testcase( (newSize-szPage) == currentSize );
        testcase( (newSize-szPage) >  currentSize );
        rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
      }
      if( rc==SQLITE_OK ){

References Pager::dbFileSize, Pager::eLock, Pager::eState, EXCLUSIVE_LOCK, Pager::fd, isOpen, PAGER_ERROR, PAGER_OPEN, PAGER_READER, PAGER_WRITER_DBMOD, Pager::pageSize, Pager::pTmpSpace, sqlite3OsFileSize(), sqlite3OsTruncate(), sqlite3OsWrite(), SQLITE_OK, and testcase.

Referenced by pager_end_transaction(), pager_playback(), and sqlite3PagerCommitPhaseOne().

◆ pager_unlock()

static void pager_unlock ( Pager * pPager )

static

Definition at line 53516 of file sqlite3.c.

                                       {
 
  assert( pPager->eState==PAGER_READER
       || pPager->eState==PAGER_OPEN
       || pPager->eState==PAGER_ERROR
  );
 
  sqlite3BitvecDestroy(pPager->pInJournal);
  pPager->pInJournal = 0;
  releaseAllSavepoints(pPager);
 
  if( pagerUseWal(pPager) ){
    assert( !isOpen(pPager->jfd) );
    sqlite3WalEndReadTransaction(pPager->pWal);
    pPager->eState = PAGER_OPEN;
  }else if( !pPager->exclusiveMode ){
    int rc;                       /* Error code returned by pagerUnlockDb() */
    int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
 
    /* If the operating system support deletion of open files, then
    ** close the journal file when dropping the database lock.  Otherwise
    ** another connection with journal_mode=delete might delete the file
    ** out from under us.
    */
    assert( (PAGER_JOURNALMODE_MEMORY   & 5)!=1 );
    assert( (PAGER_JOURNALMODE_OFF      & 5)!=1 );
    assert( (PAGER_JOURNALMODE_WAL      & 5)!=1 );
    assert( (PAGER_JOURNALMODE_DELETE   & 5)!=1 );
    assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
    assert( (PAGER_JOURNALMODE_PERSIST  & 5)==1 );
    if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
     || 1!=(pPager->journalMode & 5)
    ){
      sqlite3OsClose(pPager->jfd);
    }
 
    /* If the pager is in the ERROR state and the call to unlock the database
    ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
    ** above the #define for UNKNOWN_LOCK for an explanation of why this
    ** is necessary.
    */
    rc = pagerUnlockDb(pPager, NO_LOCK);
    if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
      pPager->eLock = UNKNOWN_LOCK;
    }
 
    /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
    ** without clearing the error code. This is intentional - the error
    ** code is cleared and the cache reset in the block below.
    */
    assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
    pPager->eState = PAGER_OPEN;
  }
 
  /* If Pager.errCode is set, the contents of the pager cache cannot be
  ** trusted. Now that there are no outstanding references to the pager,
  ** it can safely move back to PAGER_OPEN state. This happens in both
  ** normal and exclusive-locking mode.
  */
  assert( pPager->errCode==SQLITE_OK || !MEMDB );
  if( pPager->errCode ){
    if( pPager->tempFile==0 ){
      pager_reset(pPager);
      pPager->changeCountDone = 0;
      pPager->eState = PAGER_OPEN;
    }else{
      pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
    }
    if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
    pPager->errCode = SQLITE_OK;
    setGetterMethod(pPager);

References Pager::changeCountDone, Pager::eLock, Pager::errCode, Pager::eState, Pager::exclusiveMode, Pager::fd, isOpen, Pager::jfd, Pager::journalHdr, Pager::journalMode, Pager::journalOff, MEMDB, NO_LOCK, PAGER_ERROR, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_PERSIST, PAGER_JOURNALMODE_TRUNCATE, PAGER_JOURNALMODE_WAL, PAGER_OPEN, PAGER_READER, pager_reset(), pagerUnlockDb(), pagerUseWal, Pager::pInJournal, Pager::pWal, releaseAllSavepoints(), setGetterMethod(), Pager::setSuper, sqlite3BitvecDestroy(), sqlite3OsClose(), sqlite3OsDeviceCharacteristics(), sqlite3OsUnfetch(), sqlite3WalEndReadTransaction(), SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN, SQLITE_OK, Pager::tempFile, UNKNOWN_LOCK, and USEFETCH.

Referenced by pagerUnlockAndRollback(), sqlite3PagerClose(), sqlite3PagerSetJournalMode(), and sqlite3PagerSharedLock().

◆ pager_wait_on_lock()

static int pager_wait_on_lock	(	Pager *	pPager,
		int	locktype )

static

Definition at line 55563 of file sqlite3.c.

                                                          {
  int rc;                              /* Return code */
 
  /* Check that this is either a no-op (because the requested lock is
  ** already held), or one of the transitions that the busy-handler
  ** may be invoked during, according to the comment above
  ** sqlite3PagerSetBusyhandler().
  */
  assert( (pPager->eLock>=locktype)
       || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
       || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
  );

References Pager::eLock, EXCLUSIVE_LOCK, NO_LOCK, pagerLockDb(), Pager::pBusyHandlerArg, RESERVED_LOCK, SHARED_LOCK, SQLITE_BUSY, and Pager::xBusyHandler.

Referenced by sqlite3PagerBegin(), sqlite3PagerExclusiveLock(), and sqlite3PagerSharedLock().

◆ pager_write()

static int pager_write ( PgHdr * pPg )

static

Definition at line 57647 of file sqlite3.c.

                                  {
  Pager *pPager = pPg->pPager;
  int rc = SQLITE_OK;
 
  /* This routine is not called unless a write-transaction has already
  ** been started. The journal file may or may not be open at this point.
  ** It is never called in the ERROR state.
  */
  assert( pPager->eState==PAGER_WRITER_LOCKED
       || pPager->eState==PAGER_WRITER_CACHEMOD
       || pPager->eState==PAGER_WRITER_DBMOD
  );
  assert( assert_pager_state(pPager) );
  assert( pPager->errCode==0 );
  assert( pPager->readOnly==0 );
  CHECK_PAGE(pPg);
 
  /* The journal file needs to be opened. Higher level routines have already
  ** obtained the necessary locks to begin the write-transaction, but the
  ** rollback journal might not yet be open. Open it now if this is the case.
  **
  ** This is done before calling sqlite3PcacheMakeDirty() on the page.
  ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
  ** an error might occur and the pager would end up in WRITER_LOCKED state
  ** with pages marked as dirty in the cache.
  */
  if( pPager->eState==PAGER_WRITER_LOCKED ){
    rc = pager_open_journal(pPager);
    if( rc!=SQLITE_OK ) return rc;
  }
  assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
  assert( assert_pager_state(pPager) );
 
  /* Mark the page that is about to be modified as dirty. */
  sqlite3PcacheMakeDirty(pPg);
 
  /* If a rollback journal is in use, them make sure the page that is about
  ** to change is in the rollback journal, or if the page is a new page off
  ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
  */
  assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
  if( pPager->pInJournal!=0
   && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
  ){
    assert( pagerUseWal(pPager)==0 );
    if( pPg->pgno<=pPager->dbOrigSize ){
      rc = pagerAddPageToRollbackJournal(pPg);
      if( rc!=SQLITE_OK ){
        return rc;
      }
    }else{
      if( pPager->eState!=PAGER_WRITER_DBMOD ){
        pPg->flags |= PGHDR_NEED_SYNC;
      }
      PAGERTRACE(("APPEND %d page %d needSync=%d\n",
              PAGERID(pPager), pPg->pgno,
             ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
    }
  }
 
  /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
  ** and before writing the page into the rollback journal.  Wait until now,
  ** after the page has been successfully journalled, before setting the
  ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified.
  */
  pPg->flags |= PGHDR_WRITEABLE;
 
  /* If the statement journal is open and the page is not in it,
  ** then write the page into the statement journal.
  */
  if( pPager->nSavepoint>0 ){
    rc = subjournalPageIfRequired(pPg);
  }
 

References CHECK_PAGE, Pager::dbOrigSize, Pager::dbSize, Pager::errCode, Pager::eState, PgHdr::flags, isOpen, Pager::jfd, Pager::nSavepoint, pager_open_journal(), PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGER_WRITER_LOCKED, pagerAddPageToRollbackJournal(), PAGERID, PAGERTRACE, pagerUseWal, PGHDR_NEED_SYNC, PGHDR_WRITEABLE, PgHdr::pgno, Pager::pInJournal, PgHdr::pPager, Pager::readOnly, sqlite3BitvecTestNotNull(), sqlite3PcacheMakeDirty(), SQLITE_OK, and subjournalPageIfRequired().

Referenced by pagerWriteLargeSector(), and sqlite3PagerWrite().

◆ pager_write_changecounter()

static void pager_write_changecounter ( PgHdr * pPg )

static

Definition at line 54714 of file sqlite3.c.

                                                 {
  u32 change_counter;
 
  /* Increment the value just read and write it back to byte 24. */
  change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
  put32bits(((char*)pPg->pData)+24, change_counter);
 

References Pager::dbFileVers, PgHdr::pData, PgHdr::pPager, put32bits, sqlite3Get4byte(), and SQLITE_VERSION_NUMBER.

Referenced by pager_incr_changecounter(), pager_write_pagelist(), and pagerWalFrames().

◆ pager_write_pagelist()

static int pager_write_pagelist	(	Pager *	pPager,
		PgHdr *	pList )

static

Definition at line 56036 of file sqlite3.c.

                                                            {
  int rc = SQLITE_OK;                  /* Return code */
 
  /* This function is only called for rollback pagers in WRITER_DBMOD state. */
  assert( !pagerUseWal(pPager) );
  assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
  assert( pPager->eLock==EXCLUSIVE_LOCK );
  assert( isOpen(pPager->fd) || pList->pDirty==0 );
 
  /* If the file is a temp-file has not yet been opened, open it now. It
  ** is not possible for rc to be other than SQLITE_OK if this branch
  ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
  */
  if( !isOpen(pPager->fd) ){
    assert( pPager->tempFile && rc==SQLITE_OK );
    rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
  }
 
  /* Before the first write, give the VFS a hint of what the final
  ** file size will be.
  */
  assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
  if( rc==SQLITE_OK
   && pPager->dbHintSize<pPager->dbSize
   && (pList->pDirty || pList->pgno>pPager->dbHintSize)
  ){
    sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
    sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
    pPager->dbHintSize = pPager->dbSize;
  }
 
  while( rc==SQLITE_OK && pList ){
    Pgno pgno = pList->pgno;
 
    /* If there are dirty pages in the page cache with page numbers greater
    ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
    ** make the file smaller (presumably by auto-vacuum code). Do not write
    ** any such pages to the file.
    **
    ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
    ** set (set by sqlite3PagerDontWrite()).
    */
    if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
      i64 offset = (pgno-1)*(i64)pPager->pageSize;   /* Offset to write */
      char *pData;                                   /* Data to write */
 
      assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
      if( pList->pgno==1 ) pager_write_changecounter(pList);
 
      pData = pList->pData;
 
      /* Write out the page data. */
      rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
 
      /* If page 1 was just written, update Pager.dbFileVers to match
      ** the value now stored in the database file. If writing this
      ** page caused the database file to grow, update dbFileSize.
      */
      if( pgno==1 ){
        memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
      }
      if( pgno>pPager->dbFileSize ){
        pPager->dbFileSize = pgno;
      }
      pPager->aStat[PAGER_STAT_WRITE]++;
 
      /* Update any backup objects copying the contents of this pager. */
      sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
 
      PAGERTRACE(("STORE %d page %d hash(%08x)\n",
                   PAGERID(pPager), pgno, pager_pagehash(pList)));
      IOTRACE(("PGOUT %p %d\n", pPager, pgno));
      PAGER_INCR(sqlite3_pager_writedb_count);
    }else{
      PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
    }

References Pager::aStat, Pager::dbFileSize, Pager::dbFileVers, Pager::dbHintSize, Pager::dbSize, Pager::eLock, Pager::eState, EXCLUSIVE_LOCK, Pager::fd, PgHdr::flags, IOTRACE, isOpen, PAGER_INCR, pager_pagehash, pager_set_pagehash, PAGER_STAT_WRITE, pager_write_changecounter(), PAGER_WRITER_DBMOD, PAGERID, pagerOpentemp(), PAGERTRACE, pagerUseWal, Pager::pageSize, Pager::pBackup, PgHdr::pData, PgHdr::pDirty, PGHDR_DONT_WRITE, PGHDR_NEED_SYNC, PgHdr::pgno, sqlite3BackupUpdate(), sqlite3OsFileControlHint(), sqlite3OsWrite(), SQLITE_FCNTL_SIZE_HINT, SQLITE_OK, Pager::tempFile, and Pager::vfsFlags.

Referenced by pagerStress(), and sqlite3PagerCommitPhaseOne().

◆ pagerAddPageToRollbackJournal()

static SQLITE_NOINLINE int pagerAddPageToRollbackJournal ( PgHdr * pPg )

static

Definition at line 57590 of file sqlite3.c.

                                                                    {
  Pager *pPager = pPg->pPager;
  int rc;
  u32 cksum;
  char *pData2;
  i64 iOff = pPager->journalOff;
 
  /* We should never write to the journal file the page that
  ** contains the database locks.  The following assert verifies
  ** that we do not. */
  assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
 
  assert( pPager->journalHdr<=pPager->journalOff );
  pData2 = pPg->pData;
  cksum = pager_cksum(pPager, (u8*)pData2);
 
  /* Even if an IO or diskfull error occurs while journalling the
  ** page in the block above, set the need-sync flag for the page.
  ** Otherwise, when the transaction is rolled back, the logic in
  ** playback_one_page() will think that the page needs to be restored
  ** in the database file. And if an IO error occurs while doing so,
  ** then corruption may follow.
  */
  pPg->flags |= PGHDR_NEED_SYNC;
 
  rc = write32bits(pPager->jfd, iOff, pPg->pgno);
  if( rc!=SQLITE_OK ) return rc;
  rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
  if( rc!=SQLITE_OK ) return rc;
  rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
  if( rc!=SQLITE_OK ) return rc;
 
  IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
           pPager->journalOff, pPager->pageSize));
  PAGER_INCR(sqlite3_pager_writej_count);
  PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
       PAGERID(pPager), pPg->pgno,
       ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
 
  pPager->journalOff += 8 + pPager->pageSize;
  pPager->nRec++;
  assert( pPager->pInJournal!=0 );
  rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);

Referenced by pager_write().

◆ pagerBeginReadTransaction()

static int pagerBeginReadTransaction ( Pager * pPager )

static

Definition at line 54875 of file sqlite3.c.

                                                   {
  int rc;                         /* Return code */
  int changed = 0;                /* True if cache must be reset */
 
  assert( pagerUseWal(pPager) );
  assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
 
  /* sqlite3WalEndReadTransaction() was not called for the previous
  ** transaction in locking_mode=EXCLUSIVE.  So call it now.  If we
  ** are in locking_mode=NORMAL and EndRead() was previously called,
  ** the duplicate call is harmless.
  */
  sqlite3WalEndReadTransaction(pPager->pWal);
 
  rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
  if( rc!=SQLITE_OK || changed ){

References Pager::eState, Pager::fd, PAGER_OPEN, PAGER_READER, pager_reset(), pagerUseWal, Pager::pWal, sqlite3OsUnfetch(), sqlite3WalBeginReadTransaction(), sqlite3WalEndReadTransaction(), SQLITE_OK, and USEFETCH.

Referenced by sqlite3PagerSharedLock().

◆ pageReinit()

static void pageReinit ( DbPage * pData )

static

Definition at line 66759 of file sqlite3.c.

                                     {
  MemPage *pPage;
  pPage = (MemPage *)sqlite3PagerGetExtra(pData);
  assert( sqlite3PagerPageRefcount(pData)>0 );
  if( pPage->isInit ){
    assert( sqlite3_mutex_held(pPage->pBt->mutex) );
    pPage->isInit = 0;
    if( sqlite3PagerPageRefcount(pData)>1 ){
      /* pPage might not be a btree page;  it might be an overflow page
      ** or ptrmap page or a free page.  In those cases, the following
      ** call to btreeInitPage() will likely return SQLITE_CORRUPT.
      ** But no harm is done by this.  And it is very important that

References btreeInitPage(), MemPage::isInit, BtShared::mutex, MemPage::pBt, sqlite3_mutex_held(), sqlite3PagerGetExtra(), and sqlite3PagerPageRefcount().

Referenced by sqlite3BtreeOpen().

◆ pagerExclusiveLock()

static int pagerExclusiveLock ( Pager * pPager )

static

Definition at line 59133 of file sqlite3.c.

                                            {
  int rc;                         /* Return code */
 
  assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
  rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
  if( rc!=SQLITE_OK ){
    /* If the attempt to grab the exclusive lock failed, release the

Referenced by pagerOpenWal(), and sqlite3PagerCloseWal().

◆ pagerFixMaplimit()

static void pagerFixMaplimit ( Pager * pPager )

static

Definition at line 55162 of file sqlite3.c.

                                           {
#if SQLITE_MAX_MMAP_SIZE>0
  sqlite3_file *fd = pPager->fd;
  if( isOpen(fd) && fd->pMethods->iVersion>=3 ){
    sqlite3_int64 sz;
    sz = pPager->szMmap;

Referenced by pagerOpenWal(), sqlite3PagerCloseWal(), and sqlite3PagerSetPagesize().

◆ pagerFlushOnCommit()

static int pagerFlushOnCommit	(	Pager *	pPager,
		int	bCommit )

static

Definition at line 53647 of file sqlite3.c.

References Pager::fd, isOpen, Pager::pPCache, sqlite3PCachePercentDirty(), and Pager::tempFile.

Referenced by pager_end_transaction(), and sqlite3PagerCommitPhaseOne().

◆ pagerFreeMapHdrs()

static void pagerFreeMapHdrs ( Pager * pPager )

static

Definition at line 55737 of file sqlite3.c.

55743 {

55744 PgHdr *p;

Referenced by sqlite3PagerClose().

◆ pagerLockDb()

static int pagerLockDb	(	Pager *	pPager,
		int	eLock )

static

Definition at line 52859 of file sqlite3.c.

                                                {
  int rc = SQLITE_OK;
 
  assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
  if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
    rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
    if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){

References Pager::eLock, EXCLUSIVE_LOCK, Pager::fd, IOTRACE, Pager::noLock, RESERVED_LOCK, SHARED_LOCK, sqlite3OsLock(), SQLITE_OK, and UNKNOWN_LOCK.

Referenced by hasHotJournal(), pager_wait_on_lock(), sqlite3PagerBegin(), sqlite3PagerCloseWal(), sqlite3PagerSetJournalMode(), and sqlite3PagerSharedLock().

◆ pagerOpenSavepoint()

static SQLITE_NOINLINE int pagerOpenSavepoint	(	Pager *	pPager,
		int	nSavepoint )

static

Definition at line 58511 of file sqlite3.c.

                                                                            {
  int rc = SQLITE_OK;                       /* Return code */
  int nCurrent = pPager->nSavepoint;        /* Current number of savepoints */
  int ii;                                   /* Iterator variable */
  PagerSavepoint *aNew;                     /* New Pager.aSavepoint array */
 
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  assert( nSavepoint>nCurrent && pPager->useJournal );
 
  /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
  ** if the allocation fails. Otherwise, zero the new portion in case a
  ** malloc failure occurs while populating it in the for(...) loop below.
  */
  aNew = (PagerSavepoint *)sqlite3Realloc(
      pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
  );
  if( !aNew ){
    return SQLITE_NOMEM_BKPT;
  }
  memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
  pPager->aSavepoint = aNew;
 
  /* Populate the PagerSavepoint structures just allocated. */
  for(ii=nCurrent; ii<nSavepoint; ii++){
    aNew[ii].nOrig = pPager->dbSize;
    if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
      aNew[ii].iOffset = pPager->journalOff;
    }else{
      aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
    }
    aNew[ii].iSubRec = pPager->nSubRec;
    aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
    if( !aNew[ii].pInSavepoint ){
      return SQLITE_NOMEM_BKPT;
    }
    if( pagerUseWal(pPager) ){
      sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
    }

References Pager::aSavepoint, PagerSavepoint::aWalData, Pager::dbSize, Pager::eState, PagerSavepoint::iOffset, isOpen, PagerSavepoint::iSubRec, Pager::jfd, JOURNAL_HDR_SZ, Pager::journalOff, PagerSavepoint::nOrig, Pager::nSavepoint, Pager::nSubRec, PAGER_WRITER_LOCKED, pagerUseWal, PagerSavepoint::pInSavepoint, Pager::pWal, sqlite3BitvecCreate(), sqlite3Realloc(), sqlite3WalSavepoint(), SQLITE_NOMEM_BKPT, SQLITE_OK, and Pager::useJournal.

◆ pagerOpentemp()

static int pagerOpentemp	(	Pager *	pPager,
		sqlite3_file *	pFile,
		int	vfsFlags )

static

Definition at line 55302 of file sqlite3.c.

 {
  int rc;               /* Return code */
 
#ifdef SQLITE_TEST
  sqlite3_opentemp_count++;  /* Used for testing and analysis only */
#endif
 

References isOpen, Pager::pVfs, sqlite3OsOpen(), SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, and SQLITE_OPEN_READWRITE.

Referenced by pager_write_pagelist().

◆ pagerOpenWal()

static int pagerOpenWal ( Pager * pPager )

static

Definition at line 59153 of file sqlite3.c.

                                      {
  int rc = SQLITE_OK;
 
  assert( pPager->pWal==0 && pPager->tempFile==0 );
  assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
 
  /* If the pager is already in exclusive-mode, the WAL module will use
  ** heap-memory for the wal-index instead of the VFS shared-memory
  ** implementation. Take the exclusive lock now, before opening the WAL
  ** file, to make sure this is safe.
  */
  if( pPager->exclusiveMode ){
    rc = pagerExclusiveLock(pPager);
  }
 
  /* Open the connection to the log file. If this operation fails,
  ** (e.g. due to malloc() failure), return an error code.
  */
  if( rc==SQLITE_OK ){
    rc = sqlite3WalOpen(pPager->pVfs,
        pPager->fd, pPager->zWal, pPager->exclusiveMode,
        pPager->journalSizeLimit, &pPager->pWal

References Pager::eLock, EXCLUSIVE_LOCK, Pager::exclusiveMode, Pager::fd, Pager::journalSizeLimit, pagerExclusiveLock(), pagerFixMaplimit(), Pager::pVfs, Pager::pWal, SHARED_LOCK, sqlite3WalOpen(), SQLITE_OK, Pager::tempFile, and Pager::zWal.

Referenced by sqlite3PagerCloseWal(), and sqlite3PagerOpenWal().

◆ pagerOpenWalIfPresent()

static int pagerOpenWalIfPresent ( Pager * pPager )

static

Definition at line 54968 of file sqlite3.c.

                                               {
  int rc = SQLITE_OK;
  assert( pPager->eState==PAGER_OPEN );
  assert( pPager->eLock>=SHARED_LOCK );
 
  if( !pPager->tempFile ){
    int isWal;                    /* True if WAL file exists */
    rc = sqlite3OsAccess(
        pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
    );
    if( rc==SQLITE_OK ){
      if( isWal ){
        Pgno nPage;                   /* Size of the database file */
 
        rc = pagerPagecount(pPager, &nPage);
        if( rc ) return rc;
        if( nPage==0 ){
          rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
        }else{
          testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
          rc = sqlite3PagerOpenWal(pPager, 0);
        }
      }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){

References Pager::eLock, Pager::eState, Pager::journalMode, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_WAL, PAGER_OPEN, pagerPagecount(), Pager::pPCache, Pager::pVfs, SHARED_LOCK, sqlite3OsAccess(), sqlite3OsDelete(), sqlite3PagerOpenWal(), sqlite3PcachePagecount(), SQLITE_ACCESS_EXISTS, SQLITE_OK, Pager::tempFile, testcase, and Pager::zWal.

Referenced by sqlite3PagerSharedLock().

◆ pagerPagecount()

static int pagerPagecount	(	Pager *	pPager,
		Pgno *	pnPage )

static

Definition at line 54908 of file sqlite3.c.

                                                      {
  Pgno nPage;                     /* Value to return via *pnPage */
 
  /* Query the WAL sub-system for the database size. The WalDbsize()
  ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
  ** if the database size is not available. The database size is not
  ** available from the WAL sub-system if the log file is empty or
  ** contains no valid committed transactions.
  */
  assert( pPager->eState==PAGER_OPEN );
  assert( pPager->eLock>=SHARED_LOCK );
  assert( isOpen(pPager->fd) );
  assert( pPager->tempFile==0 );
  nPage = sqlite3WalDbsize(pPager->pWal);
 
  /* If the number of pages in the database is not available from the
  ** WAL sub-system, determine the page count based on the size of
  ** the database file.  If the size of the database file is not an
  ** integer multiple of the page-size, round up the result.
  */
  if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
    i64 n = 0;                    /* Size of db file in bytes */
    int rc = sqlite3OsFileSize(pPager->fd, &n);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
  }
 
  /* If the current number of pages in the file is greater than the
  ** configured maximum pager number, increase the allowed limit so
  ** that the file can be read.
  */
  if( nPage>pPager->mxPgno ){

References ALWAYS, Pager::eLock, Pager::eState, Pager::fd, isOpen, Pager::mxPgno, PAGER_OPEN, Pager::pageSize, Pager::pWal, SHARED_LOCK, sqlite3OsFileSize(), sqlite3WalDbsize(), SQLITE_OK, and Pager::tempFile.

Referenced by hasHotJournal(), pagerOpenWalIfPresent(), and sqlite3PagerSharedLock().

◆ pagerPlaybackSavepoint()

static int pagerPlaybackSavepoint	(	Pager *	pPager,
		PagerSavepoint *	pSavepoint )

static

Definition at line 55035 of file sqlite3.c.

                                                                            {
  i64 szJ;                 /* Effective size of the main journal */
  i64 iHdrOff;             /* End of first segment of main-journal records */
  int rc = SQLITE_OK;      /* Return code */
  Bitvec *pDone = 0;       /* Bitvec to ensure pages played back only once */
 
  assert( pPager->eState!=PAGER_ERROR );
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
 
  /* Allocate a bitvec to use to store the set of pages rolled back */
  if( pSavepoint ){
    pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
    if( !pDone ){
      return SQLITE_NOMEM_BKPT;
    }
  }
 
  /* Set the database size back to the value it was before the savepoint
  ** being reverted was opened.
  */
  pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
  pPager->changeCountDone = pPager->tempFile;
 
  if( !pSavepoint && pagerUseWal(pPager) ){
    return pagerRollbackWal(pPager);
  }
 
  /* Use pPager->journalOff as the effective size of the main rollback
  ** journal.  The actual file might be larger than this in
  ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST.  But anything
  ** past pPager->journalOff is off-limits to us.
  */
  szJ = pPager->journalOff;
  assert( pagerUseWal(pPager)==0 || szJ==0 );
 
  /* Begin by rolling back records from the main journal starting at
  ** PagerSavepoint.iOffset and continuing to the next journal header.
  ** There might be records in the main journal that have a page number
  ** greater than the current database size (pPager->dbSize) but those
  ** will be skipped automatically.  Pages are added to pDone as they
  ** are played back.
  */
  if( pSavepoint && !pagerUseWal(pPager) ){
    iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
    pPager->journalOff = pSavepoint->iOffset;
    while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
      rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
    }
    assert( rc!=SQLITE_DONE );
  }else{
    pPager->journalOff = 0;
  }
 
  /* Continue rolling back records out of the main journal starting at
  ** the first journal header seen and continuing until the effective end
  ** of the main journal file.  Continue to skip out-of-range pages and
  ** continue adding pages rolled back to pDone.
  */
  while( rc==SQLITE_OK && pPager->journalOff<szJ ){
    u32 ii;            /* Loop counter */
    u32 nJRec = 0;     /* Number of Journal Records */
    u32 dummy;
    rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
    assert( rc!=SQLITE_DONE );
 
    /*
    ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
    ** test is related to ticket #2565.  See the discussion in the
    ** pager_playback() function for additional information.
    */
    if( nJRec==0
     && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
    ){
      nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
    }
    for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
      rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
    }
    assert( rc!=SQLITE_DONE );
  }
  assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
 
  /* Finally,  rollback pages from the sub-journal.  Page that were
  ** previously rolled back out of the main journal (and are hence in pDone)
  ** will be skipped.  Out-of-range pages are also skipped.
  */
  if( pSavepoint ){
    u32 ii;            /* Loop counter */
    i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
 
    if( pagerUseWal(pPager) ){
      rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
    }
    for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
      assert( offset==(i64)ii*(4+pPager->pageSize) );
      rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
    }
    assert( rc!=SQLITE_DONE );
  }
 
  sqlite3BitvecDestroy(pDone);

References PagerSavepoint::aWalData, Pager::changeCountDone, Pager::dbOrigSize, Pager::dbSize, dummy, Pager::eState, PagerSavepoint::iHdrOffset, PagerSavepoint::iOffset, PagerSavepoint::iSubRec, JOURNAL_HDR_SZ, JOURNAL_PG_SZ, Pager::journalHdr, Pager::journalOff, PagerSavepoint::nOrig, Pager::nSubRec, PAGER_ERROR, pager_playback_one_page(), PAGER_WRITER_LOCKED, pagerRollbackWal(), pagerUseWal, Pager::pageSize, Pager::pWal, readJournalHdr(), sqlite3BitvecCreate(), sqlite3BitvecDestroy(), sqlite3WalSavepointUndo(), SQLITE_DONE, SQLITE_NOMEM_BKPT, SQLITE_OK, and Pager::tempFile.

Referenced by sqlite3PagerSavepoint().

◆ pagerReleaseMapPage()

static void pagerReleaseMapPage ( PgHdr * pPg )

static

Definition at line 55724 of file sqlite3.c.

                                           {
  Pager *pPager = pPg->pPager;
  pPager->nMmapOut--;

References Pager::fd, sqlite3_io_methods::iVersion, Pager::nMmapOut, PgHdr::pDirty, sqlite3_file::pMethods, Pager::pMmapFreelist, and PgHdr::pPager.

Referenced by sqlite3PagerUnrefNotNull().

◆ pagerRollbackWal()

static int pagerRollbackWal ( Pager * pPager )

static

Definition at line 54776 of file sqlite3.c.

                                          {
  int rc;                         /* Return Code */
  PgHdr *pList;                   /* List of dirty pages to revert */
 
  /* For all pages in the cache that are currently dirty or have already
  ** been written (but not committed) to the log file, do one of the
  ** following:
  **
  **   + Discard the cached page (if refcount==0), or
  **   + Reload page content from the database (if refcount>0).
  */
  pPager->dbSize = pPager->dbOrigSize;
  rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
  pList = sqlite3PcacheDirtyList(pPager->pPCache);
  while( pList && rc==SQLITE_OK ){
    PgHdr *pNext = pList->pDirty;

Referenced by pagerPlaybackSavepoint().

◆ pagerStress()

static int pagerStress	(	void *	p,
		PgHdr *	pPg )

static

Definition at line 56216 of file sqlite3.c.

                                           {
  Pager *pPager = (Pager *)p;
  int rc = SQLITE_OK;
 
  assert( pPg->pPager==pPager );
  assert( pPg->flags&PGHDR_DIRTY );
 
  /* The doNotSpill NOSYNC bit is set during times when doing a sync of
  ** journal (and adding a new header) is not allowed.  This occurs
  ** during calls to sqlite3PagerWrite() while trying to journal multiple
  ** pages belonging to the same sector.
  **
  ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
  ** regardless of whether or not a sync is required.  This is set during
  ** a rollback or by user request, respectively.
  **
  ** Spilling is also prohibited when in an error state since that could
  ** lead to database corruption.   In the current implementation it
  ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3
  ** while in the error state, hence it is impossible for this routine to
  ** be called in the error state.  Nevertheless, we include a NEVER()
  ** test for the error state as a safeguard against future changes.
  */
  if( NEVER(pPager->errCode) ) return SQLITE_OK;
  testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
  testcase( pPager->doNotSpill & SPILLFLAG_OFF );
  testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
  if( pPager->doNotSpill
   && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
      || (pPg->flags & PGHDR_NEED_SYNC)!=0)
  ){
    return SQLITE_OK;
  }
 
  pPager->aStat[PAGER_STAT_SPILL]++;
  pPg->pDirty = 0;
  if( pagerUseWal(pPager) ){
    /* Write a single frame for this page to the log. */
    rc = subjournalPageIfRequired(pPg);
    if( rc==SQLITE_OK ){
      rc = pagerWalFrames(pPager, pPg, 0, 0);
    }
  }else{
 
#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
    if( pPager->tempFile==0 ){
      rc = sqlite3JournalCreate(pPager->jfd);
      if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
    }
#endif
 
    /* Sync the journal file if required. */
    if( pPg->flags&PGHDR_NEED_SYNC
     || pPager->eState==PAGER_WRITER_CACHEMOD
    ){
      rc = syncJournal(pPager, 1);
    }
 
    /* Write the contents of the page out to the database file. */
    if( rc==SQLITE_OK ){
      assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
      rc = pager_write_pagelist(pPager, pPg);
    }
  }
 
  /* Mark the page as clean. */
  if( rc==SQLITE_OK ){

References Pager::aStat, Pager::doNotSpill, Pager::errCode, Pager::eState, PgHdr::flags, Pager::jfd, NEVER, pager_error(), PAGER_STAT_SPILL, pager_write_pagelist(), PAGER_WRITER_CACHEMOD, PAGERID, PAGERTRACE, pagerUseWal, pagerWalFrames(), PgHdr::pDirty, PGHDR_DIRTY, PGHDR_NEED_SYNC, PgHdr::pgno, PgHdr::pPager, SPILLFLAG_NOSYNC, SPILLFLAG_OFF, SPILLFLAG_ROLLBACK, sqlite3PcacheMakeClean(), SQLITE_OK, subjournalPageIfRequired(), syncJournal(), Pager::tempFile, and testcase.

Referenced by sqlite3PagerOpen().

◆ pagerSyncHotJournal()

static int pagerSyncHotJournal ( Pager * pPager )

static

Definition at line 55658 of file sqlite3.c.

                                             {
  int rc = SQLITE_OK;
  if( !pPager->noSync ){
    rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);

References Pager::jfd, Pager::journalHdr, Pager::noSync, sqlite3OsFileSize(), sqlite3OsSync(), SQLITE_OK, and SQLITE_SYNC_NORMAL.

Referenced by sqlite3PagerClose(), and sqlite3PagerSharedLock().

◆ pagerUndoCallback()

static int pagerUndoCallback	(	void *	pCtx,
		Pgno	iPg )

static

Definition at line 54741 of file sqlite3.c.

                                                  {
  int rc = SQLITE_OK;
  Pager *pPager = (Pager *)pCtx;
  PgHdr *pPg;
 
  assert( pagerUseWal(pPager) );
  pPg = sqlite3PagerLookup(pPager, iPg);
  if( pPg ){
    if( sqlite3PcachePageRefcount(pPg)==1 ){
      sqlite3PcacheDrop(pPg);
    }else{
      rc = readDbPage(pPg);
      if( rc==SQLITE_OK ){
        pPager->xReiniter(pPg);
      }
      sqlite3PagerUnrefNotNull(pPg);
    }
  }
 
  /* Normally, if a transaction is rolled back, any backup processes are
  ** updated as data is copied out of the rollback journal and into the
  ** database. This is not generally possible with a WAL database, as
  ** rollback involves simply truncating the log file. Therefore, if one
  ** or more frames have already been written to the log (and therefore
  ** also copied into the backup databases) as part of this transaction,

References pagerUseWal, Pager::pBackup, readDbPage(), sqlite3BackupRestart(), sqlite3PagerLookup(), sqlite3PagerUnrefNotNull(), sqlite3PcacheDrop(), sqlite3PcachePageRefcount(), SQLITE_OK, and Pager::xReiniter.

◆ pagerUnlockAndRollback()

static void pagerUnlockAndRollback ( Pager * pPager )

static

Definition at line 53854 of file sqlite3.c.

                                                 {
  if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
    assert( assert_pager_state(pPager) );
    if( pPager->eState>=PAGER_WRITER_LOCKED ){
      sqlite3BeginBenignMalloc();
      sqlite3PagerRollback(pPager);
      sqlite3EndBenignMalloc();
    }else if( !pPager->exclusiveMode ){

References Pager::eState, Pager::exclusiveMode, pager_end_transaction(), PAGER_ERROR, PAGER_OPEN, PAGER_READER, pager_unlock(), PAGER_WRITER_LOCKED, sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), and sqlite3PagerRollback().

Referenced by pagerUnlockIfUnused(), and sqlite3PagerClose().

◆ pagerUnlockDb()

static int pagerUnlockDb	(	Pager *	pPager,
		int	eLock )

static

Definition at line 52831 of file sqlite3.c.

                                                  {
  int rc = SQLITE_OK;
 
  assert( !pPager->exclusiveMode || pPager->eLock==eLock );
  assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
  assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
  if( isOpen(pPager->fd) ){
    assert( pPager->eLock>=eLock );
    rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
    if( pPager->eLock!=UNKNOWN_LOCK ){
      pPager->eLock = (u8)eLock;

References Pager::changeCountDone, Pager::eLock, Pager::exclusiveMode, Pager::fd, IOTRACE, isOpen, NO_LOCK, Pager::noLock, pagerUseWal, SHARED_LOCK, sqlite3OsUnlock(), SQLITE_OK, Pager::tempFile, and UNKNOWN_LOCK.

Referenced by hasHotJournal(), pager_end_transaction(), pager_unlock(), sqlite3PagerCloseWal(), sqlite3PagerSetJournalMode(), and sqlite3PagerSharedLock().

◆ pagerUnlockIfUnused()

static void pagerUnlockIfUnused ( Pager * pPager )

static

Definition at line 57091 of file sqlite3.c.

References Pager::nMmapOut, pagerUnlockAndRollback(), Pager::pPCache, and sqlite3PcacheRefCount().

Referenced by getPageNormal().

◆ pagerWalFrames()

static int pagerWalFrames	(	Pager *	pPager,
		PgHdr *	pList,
		Pgno	nTruncate,
		int	isCommit )

static

Definition at line 54808 of file sqlite3.c.

 {
  int rc;                         /* Return code */
  int nList;                      /* Number of pages in pList */
  PgHdr *p;                       /* For looping over pages */
 
  assert( pPager->pWal );
  assert( pList );
#ifdef SQLITE_DEBUG
  /* Verify that the page list is in accending order */
  for(p=pList; p && p->pDirty; p=p->pDirty){
    assert( p->pgno < p->pDirty->pgno );
  }
#endif
 
  assert( pList->pDirty==0 || isCommit );
  if( isCommit ){
    /* If a WAL transaction is being committed, there is no point in writing
    ** any pages with page numbers greater than nTruncate into the WAL file.
    ** They will never be read by any client. So remove them from the pDirty
    ** list here. */
    PgHdr **ppNext = &pList;
    nList = 0;
    for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
      if( p->pgno<=nTruncate ){
        ppNext = &p->pDirty;
        nList++;
      }
    }
    assert( pList );
  }else{
    nList = 1;
  }
  pPager->aStat[PAGER_STAT_WRITE] += nList;
 
  if( pList->pgno==1 ) pager_write_changecounter(pList);
  rc = sqlite3WalFrames(pPager->pWal,
      pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
  );
  if( rc==SQLITE_OK && pPager->pBackup ){
    for(p=pList; p; p=p->pDirty){
      sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
    }
  }
 
#ifdef SQLITE_CHECK_PAGES
  pList = sqlite3PcacheDirtyList(pPager->pPCache);
  for(p=pList; p; p=p->pDirty){

References Pager::aStat, pager_set_pagehash, PAGER_STAT_WRITE, pager_write_changecounter(), Pager::pageSize, Pager::pBackup, PgHdr::pData, PgHdr::pDirty, PgHdr::pgno, Pager::pPCache, Pager::pWal, sqlite3BackupUpdate(), sqlite3PcacheDirtyList(), sqlite3WalFrames(), SQLITE_OK, and Pager::walSyncFlags.

Referenced by pagerStress(), and sqlite3PagerCommitPhaseOne().

◆ pagerWriteLargeSector()

static SQLITE_NOINLINE int pagerWriteLargeSector ( PgHdr * pPg )

static

Definition at line 57739 of file sqlite3.c.

                                                            {
  int rc = SQLITE_OK;          /* Return code */
  Pgno nPageCount;             /* Total number of pages in database file */
  Pgno pg1;                    /* First page of the sector pPg is located on. */
  int nPage = 0;               /* Number of pages starting at pg1 to journal */
  int ii;                      /* Loop counter */
  int needSync = 0;            /* True if any page has PGHDR_NEED_SYNC */
  Pager *pPager = pPg->pPager; /* The pager that owns pPg */
  Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
 
  /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
  ** a journal header to be written between the pages journaled by
  ** this function.
  */
  assert( !MEMDB );
  assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
  pPager->doNotSpill |= SPILLFLAG_NOSYNC;
 
  /* This trick assumes that both the page-size and sector-size are
  ** an integer power of 2. It sets variable pg1 to the identifier
  ** of the first page of the sector pPg is located on.
  */
  pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
 
  nPageCount = pPager->dbSize;
  if( pPg->pgno>nPageCount ){
    nPage = (pPg->pgno - pg1)+1;
  }else if( (pg1+nPagePerSector-1)>nPageCount ){
    nPage = nPageCount+1-pg1;
  }else{
    nPage = nPagePerSector;
  }
  assert(nPage>0);
  assert(pg1<=pPg->pgno);
  assert((pg1+nPage)>pPg->pgno);
 
  for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
    Pgno pg = pg1+ii;
    PgHdr *pPage;
    if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
      if( pg!=PAGER_MJ_PGNO(pPager) ){
        rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
        if( rc==SQLITE_OK ){
          rc = pager_write(pPage);
          if( pPage->flags&PGHDR_NEED_SYNC ){
            needSync = 1;
          }
          sqlite3PagerUnrefNotNull(pPage);
        }
      }
    }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
      if( pPage->flags&PGHDR_NEED_SYNC ){
        needSync = 1;
      }
      sqlite3PagerUnrefNotNull(pPage);
    }
  }
 
  /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
  ** starting at pg1, then it needs to be set for all of them. Because
  ** writing to any of these nPage pages may damage the others, the
  ** journal file must contain sync()ed copies of all of them
  ** before any of them can be written out to the database file.
  */
  if( rc==SQLITE_OK && needSync ){
    assert( !MEMDB );
    for(ii=0; ii<nPage; ii++){
      PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
      if( pPage ){
        pPage->flags |= PGHDR_NEED_SYNC;
        sqlite3PagerUnrefNotNull(pPage);
      }
    }

References Pager::dbSize, Pager::doNotSpill, PgHdr::flags, MEMDB, PAGER_MJ_PGNO, pager_write(), Pager::pageSize, PGHDR_NEED_SYNC, PgHdr::pgno, Pager::pInJournal, PgHdr::pPager, Pager::sectorSize, SPILLFLAG_NOSYNC, sqlite3BitvecTest(), sqlite3PagerGet(), sqlite3PagerLookup(), sqlite3PagerUnrefNotNull(), and SQLITE_OK.

Referenced by sqlite3PagerWrite().

◆ parseDateOrTime()

static int parseDateOrTime	(	sqlite3_context *	context,
		const char *	zDate,
		DateTime *	p )

static

Definition at line 22088 of file sqlite3.c.

     :SS.FFF") is option.  The year and date can be omitted as long
** as there is a time string.  The time string can be omitted as long
** as there is a year and date.
*/
static int parseDateOrTime(
  sqlite3_context *context,
  const char *zDate,
  DateTime *p
){
  double r;
  if( parseYyyyMmDd(zDate,p)==0 ){
    return 0;
  }else if( parseHhMmSs(zDate, p)==0 ){
    return 0;
  }else if( sqlite3StrICmp(zDate,"now")==0 && sqlite3NotPureFunc(context) ){
    return setDateTimeToCurrent(context, p);
  }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8)>0 ){

References parseHhMmSs(), parseYyyyMmDd(), setDateTimeToCurrent(), setRawDateNumber(), sqlite3AtoF(), sqlite3NotPureFunc(), sqlite3StrICmp(), sqlite3Strlen30(), and SQLITE_UTF8.

Referenced by isDate().

◆ parseHhMmSs()

static int parseHhMmSs	(	const char *	zDate,
		DateTime *	p )

static

Definition at line 21909 of file sqlite3.c.

                                                      {
  int h, m, s;
  double ms = 0.0;
  if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){
    return 1;
  }
  zDate += 5;
  if( *zDate==':' ){
    zDate++;
    if( getDigits(zDate, "20e", &s)!=1 ){
      return 1;
    }
    zDate += 2;
    if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){
      double rScale = 1.0;
      zDate++;
      while( sqlite3Isdigit(*zDate) ){
        ms = ms*10.0 + *zDate - '0';
        rScale *= 10.0;
        zDate++;
      }
      ms /= rScale;
    }
  }else{
    s = 0;
  }
  p->validJD = 0;
  p->rawS = 0;
  p->validHMS = 1;
  p->h = h;
  p->m = m;

References getDigits(), DateTime::h, DateTime::m, parseTimezone(), DateTime::rawS, DateTime::s, s, sqlite3Isdigit, DateTime::tz, DateTime::validHMS, DateTime::validJD, and DateTime::validTZ.

Referenced by parseDateOrTime(), parseModifier(), and parseYyyyMmDd().

◆ parseModifier()

static int parseModifier	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n,
		DateTime *	p )

static

Definition at line 22365 of file sqlite3.c.

 {
  int rc = 1;
  double r;
  switch(sqlite3UpperToLower[(u8)z[0]] ){
#ifndef SQLITE_OMIT_LOCALTIME
    case 'l': {
      /*    localtime
      **
      ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
      ** show local time.
      */
      if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
        computeJD(p);
        p->iJD += localtimeOffset(p, pCtx, &rc);
        clearYMD_HMS_TZ(p);
      }
      break;
    }
#endif
    case 'u': {
      /*
      **    unixepoch
      **
      ** Treat the current value of p->s as the number of
      ** seconds since 1970.  Convert to a real julian day number.
      */
      if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){
        r = p->s*1000.0 + 210866760000000.0;
        if( r>=0.0 && r<464269060800000.0 ){
          clearYMD_HMS_TZ(p);
          p->iJD = (sqlite3_int64)(r + 0.5);
          p->validJD = 1;
          p->rawS = 0;
          rc = 0;
        }
      }
#ifndef SQLITE_OMIT_LOCALTIME
      else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){
        if( p->tzSet==0 ){
          sqlite3_int64 c1;
          computeJD(p);
          c1 = localtimeOffset(p, pCtx, &rc);
          if( rc==SQLITE_OK ){
            p->iJD -= c1;
            clearYMD_HMS_TZ(p);
            p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
          }
          p->tzSet = 1;
        }else{
          rc = SQLITE_OK;
        }
      }
#endif
      break;
    }
    case 'w': {
      /*
      **    weekday N
      **
      ** Move the date to the same time on the next occurrence of
      ** weekday N where 0==Sunday, 1==Monday, and so forth.  If the
      ** date is already on the appropriate weekday, this is a no-op.
      */
      if( sqlite3_strnicmp(z, "weekday ", 8)==0
               && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)>0
               && (n=(int)r)==r && n>=0 && r<7 ){
        sqlite3_int64 Z;
        computeYMD_HMS(p);
        p->validTZ = 0;
        p->validJD = 0;
        computeJD(p);
        Z = ((p->iJD + 129600000)/86400000) % 7;
        if( Z>n ) Z -= 7;
        p->iJD += (n - Z)*86400000;
        clearYMD_HMS_TZ(p);
        rc = 0;
      }
      break;
    }
    case 's': {
      /*
      **    start of TTTTT
      **
      ** Move the date backwards to the beginning of the current day,
      ** or month or year.
      */
      if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break;
      if( !p->validJD && !p->validYMD && !p->validHMS ) break;
      z += 9;
      computeYMD(p);
      p->validHMS = 1;
      p->h = p->m = 0;
      p->s = 0.0;
      p->rawS = 0;
      p->validTZ = 0;
      p->validJD = 0;
      if( sqlite3_stricmp(z,"month")==0 ){
        p->D = 1;
        rc = 0;
      }else if( sqlite3_stricmp(z,"year")==0 ){
        p->M = 1;
        p->D = 1;
        rc = 0;
      }else if( sqlite3_stricmp(z,"day")==0 ){
        rc = 0;
      }
      break;
    }
    case '+':
    case '-':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9': {
      double rRounder;
      int i;
      for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){}
      if( sqlite3AtoF(z, &r, n, SQLITE_UTF8)<=0 ){
        rc = 1;
        break;
      }
      if( z[n]==':' ){
        /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
        ** specified number of hours, minutes, seconds, and fractional seconds
        ** to the time.  The ".FFF" may be omitted.  The ":SS.FFF" may be
        ** omitted.
        */
        const char *z2 = z;
        DateTime tx;
        sqlite3_int64 day;
        if( !sqlite3Isdigit(*z2) ) z2++;
        memset(&tx, 0, sizeof(tx));
        if( parseHhMmSs(z2, &tx) ) break;
        computeJD(&tx);
        tx.iJD -= 43200000;
        day = tx.iJD/86400000;
        tx.iJD -= day*86400000;
        if( z[0]=='-' ) tx.iJD = -tx.iJD;
        computeJD(p);
        clearYMD_HMS_TZ(p);
        p->iJD += tx.iJD;
        rc = 0;
        break;
      }
 
      /* If control reaches this point, it means the transformation is
      ** one of the forms like "+NNN days".  */
      z += n;
      while( sqlite3Isspace(*z) ) z++;
      n = sqlite3Strlen30(z);
      if( n>10 || n<3 ) break;
      if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--;
      computeJD(p);
      rc = 1;
      rRounder = r<0 ? -0.5 : +0.5;
      for(i=0; i<ArraySize(aXformType); i++){
        if( aXformType[i].nName==n
         && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
         && r>-aXformType[i].rLimit && r<aXformType[i].rLimit
        ){
          switch( aXformType[i].eType ){
            case 1: { /* Special processing to add months */
              int x;
              computeYMD_HMS(p);
              p->M += (int)r;
              x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
              p->Y += x;
              p->M -= x*12;
              p->validJD = 0;
              r -= (int)r;
              break;
            }
            case 2: { /* Special processing to add years */
              int y = (int)r;
              computeYMD_HMS(p);
              p->Y += y;
              p->validJD = 0;
              r -= (int)r;
              break;
            }
          }
          computeJD(p);
          p->iJD += (sqlite3_int64)(r*aXformType[i].rXform + rRounder);
          rc = 0;
          break;
        }
      }
      clearYMD_HMS_TZ(p);
      break;
    }
    default: {

References ArraySize, aXformType, clearYMD_HMS_TZ(), computeJD(), computeYMD(), computeYMD_HMS(), DateTime::D, eType, DateTime::h, DateTime::iJD, localtimeOffset(), DateTime::M, DateTime::m, nName, parseHhMmSs(), DateTime::rawS, rXform, DateTime::s, sqlite3_stricmp(), sqlite3_strnicmp(), sqlite3AtoF(), sqlite3Isdigit, sqlite3Isspace, sqlite3NotPureFunc(), sqlite3Strlen30(), sqlite3UpperToLower, SQLITE_OK, SQLITE_UTF8, DateTime::tzSet, DateTime::validHMS, DateTime::validJD, DateTime::validTZ, DateTime::validYMD, DateTime::Y, and zName.

Referenced by isDate().

◆ parserAddExprIdListTerm()

static ExprList * parserAddExprIdListTerm	(	Parse *	pParse,
		ExprList *	pPrior,
		Token *	pIdToken,
		int	hasCollate,
		int	sortOrder )

static

Definition at line 154393 of file sqlite3.c.

   {
    ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
    if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED)
        && pParse->db->init.busy==0
    ){

References sqlite3::sqlite3InitInfo::busy, Parse::db, sqlite3::init, Token::n, sqlite3ErrorMsg(), sqlite3ExprListAppend(), sqlite3ExprListSetName(), SQLITE_SO_UNDEFINED, and Token::z.

Referenced by yy_reduce().

◆ parserDoubleLinkSelect()

static void parserDoubleLinkSelect	(	Parse *	pParse,
		Select *	p )

static

Definition at line 154321 of file sqlite3.c.

                                                              {
    assert( p!=0 );
    if( p->pPrior ){
      Select *pNext = 0, *pLoop;
      int mxSelect, cnt = 0;
      for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
        pLoop->pNext = pNext;
        pLoop->selFlags |= SF_Compound;
      }
      if( (p->selFlags & SF_MultiValue)==0 &&
        (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&

References sqlite3::aLimit, Parse::db, Select::pPrior, Select::selFlags, SF_Compound, SF_MultiValue, sqlite3ErrorMsg(), and SQLITE_LIMIT_COMPOUND_SELECT.

Referenced by yy_reduce().

◆ parseTimezone()

static int parseTimezone	(	const char *	zDate,
		DateTime *	p )

static

Definition at line 21873 of file sqlite3.c.

                                                        {
  int sgn = 0;
  int nHr, nMn;
  int c;
  while( sqlite3Isspace(*zDate) ){ zDate++; }
  p->tz = 0;
  c = *zDate;
  if( c=='-' ){
    sgn = -1;
  }else if( c=='+' ){
    sgn = +1;
  }else if( c=='Z' || c=='z' ){
    zDate++;
    goto zulu_time;
  }else{
    return c!=0;
  }
  zDate++;
  if( getDigits(zDate, "20b:20e", &nHr, &nMn)!=2 ){
    return 1;
  }
  zDate += 5;
  p->tz = sgn*(nMn + nHr*60);

References getDigits(), sqlite3Isspace, DateTime::tz, and DateTime::tzSet.

Referenced by parseHhMmSs().

◆ parseYyyyMmDd()

static int parseYyyyMmDd	(	const char *	zDate,
		DateTime *	p )

static

Definition at line 22010 of file sqlite3.c.

                                                        {
  int Y, M, D, neg;
 
  if( zDate[0]=='-' ){
    zDate++;
    neg = 1;
  }else{
    neg = 0;
  }
  if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){
    return 1;
  }
  zDate += 10;
  while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
  if( parseHhMmSs(zDate, p)==0 ){
    /* We got the time */
  }else if( *zDate==0 ){
    p->validHMS = 0;
  }else{
    return 1;
  }
  p->validJD = 0;
  p->validYMD = 1;
  p->Y = neg ? -Y : Y;
  p->M = M;
  p->D = D;

References computeJD(), DateTime::D, getDigits(), DateTime::M, parseHhMmSs(), sqlite3Isspace, DateTime::validHMS, DateTime::validJD, DateTime::validTZ, DateTime::validYMD, and DateTime::Y.

Referenced by parseDateOrTime().

◆ patternCompare()

static int patternCompare	(	const u8 *	zPattern,
		const u8 *	zString,
		const struct compareInfo *	pInfo,
		u32	matchOther )

static

Definition at line 117724 of file sqlite3.c.

 {
  u32 c, c2;                       /* Next pattern and input string chars */
  u32 matchOne = pInfo->matchOne;  /* "?" or "_" */
  u32 matchAll = pInfo->matchAll;  /* "*" or "%" */
  u8 noCase = pInfo->noCase;       /* True if uppercase==lowercase */
  const u8 *zEscaped = 0;          /* One past the last escaped input char */
 
  while( (c = Utf8Read(zPattern))!=0 ){
    if( c==matchAll ){  /* Match "*" */
      /* Skip over multiple "*" characters in the pattern.  If there
      ** are also "?" characters, skip those as well, but consume a
      ** single character of the input string for each "?" skipped */
      while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){
        if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
          return SQLITE_NOWILDCARDMATCH;
        }
      }
      if( c==0 ){
        return SQLITE_MATCH;   /* "*" at the end of the pattern matches */
      }else if( c==matchOther ){
        if( pInfo->matchSet==0 ){
          c = sqlite3Utf8Read(&zPattern);
          if( c==0 ) return SQLITE_NOWILDCARDMATCH;
        }else{
          /* "[...]" immediately follows the "*".  We have to do a slow
          ** recursive search in this case, but it is an unusual case. */
          assert( matchOther<0x80 );  /* '[' is a single-byte character */
          while( *zString ){
            int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther);
            if( bMatch!=SQLITE_NOMATCH ) return bMatch;
            SQLITE_SKIP_UTF8(zString);
          }
          return SQLITE_NOWILDCARDMATCH;
        }
      }
 
      /* At this point variable c contains the first character of the
      ** pattern string past the "*".  Search in the input string for the
      ** first matching character and recursively continue the match from
      ** that point.
      **
      ** For a case-insensitive search, set variable cx to be the same as
      ** c but in the other case and search the input string for either
      ** c or cx.
      */
      if( c<=0x80 ){
        char zStop[3];
        int bMatch;
        if( noCase ){
          zStop[0] = sqlite3Toupper(c);
          zStop[1] = sqlite3Tolower(c);
          zStop[2] = 0;
        }else{
          zStop[0] = c;
          zStop[1] = 0;
        }
        while(1){
          zString += strcspn((const char*)zString, zStop);
          if( zString[0]==0 ) break;
          zString++;
          bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
          if( bMatch!=SQLITE_NOMATCH ) return bMatch;
        }
      }else{
        int bMatch;
        while( (c2 = Utf8Read(zString))!=0 ){
          if( c2!=c ) continue;
          bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
          if( bMatch!=SQLITE_NOMATCH ) return bMatch;
        }
      }
      return SQLITE_NOWILDCARDMATCH;
    }
    if( c==matchOther ){
      if( pInfo->matchSet==0 ){
        c = sqlite3Utf8Read(&zPattern);
        if( c==0 ) return SQLITE_NOMATCH;
        zEscaped = zPattern;
      }else{
        u32 prior_c = 0;
        int seen = 0;
        int invert = 0;
        c = sqlite3Utf8Read(&zString);
        if( c==0 ) return SQLITE_NOMATCH;
        c2 = sqlite3Utf8Read(&zPattern);
        if( c2=='^' ){
          invert = 1;
          c2 = sqlite3Utf8Read(&zPattern);
        }
        if( c2==']' ){
          if( c==']' ) seen = 1;
          c2 = sqlite3Utf8Read(&zPattern);
        }
        while( c2 && c2!=']' ){
          if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
            c2 = sqlite3Utf8Read(&zPattern);
            if( c>=prior_c && c<=c2 ) seen = 1;
            prior_c = 0;
          }else{
            if( c==c2 ){
              seen = 1;
            }
            prior_c = c2;
          }
          c2 = sqlite3Utf8Read(&zPattern);
        }
        if( c2==0 || (seen ^ invert)==0 ){
          return SQLITE_NOMATCH;
        }
        continue;
      }
    }
    c2 = Utf8Read(zString);
    if( c==c2 ) continue;
    if( noCase  && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){
      continue;

References compareInfo::matchAll, compareInfo::matchOne, compareInfo::matchSet, compareInfo::noCase, patternCompare(), sqlite3Tolower, sqlite3Toupper, sqlite3Utf8Read(), SQLITE_MATCH, SQLITE_NOMATCH, SQLITE_NOWILDCARDMATCH, SQLITE_SKIP_UTF8, and Utf8Read.

Referenced by likeFunc(), and patternCompare().

◆ pcache1Alloc()

static void * pcache1Alloc ( int nByte )

static

Definition at line 50091 of file sqlite3.c.

                                    {
  void *p = 0;
  assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
  if( nByte<=pcache1.szSlot ){
    sqlite3_mutex_enter(pcache1.mutex);
    p = (PgHdr1 *)pcache1.pFree;
    if( p ){
      pcache1.pFree = pcache1.pFree->pNext;
      pcache1.nFreeSlot--;
      pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
      assert( pcache1.nFreeSlot>=0 );
      sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
      sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1);
    }
    sqlite3_mutex_leave(pcache1.mutex);
  }
  if( p==0 ){
    /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool.  Get
    ** it from sqlite3Malloc instead.
    */
    p = sqlite3Malloc(nByte);
#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
    if( p ){
      int sz = sqlite3MallocSize(p);
      sqlite3_mutex_enter(pcache1.mutex);
      sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
      sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
      sqlite3_mutex_leave(pcache1.mutex);

References MEMTYPE_PCACHE, pcache1, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_mutex_notheld(), sqlite3Malloc(), sqlite3MallocSize(), sqlite3MemdebugSetType, sqlite3StatusHighwater(), sqlite3StatusUp(), SQLITE_STATUS_PAGECACHE_OVERFLOW, SQLITE_STATUS_PAGECACHE_SIZE, and SQLITE_STATUS_PAGECACHE_USED.

◆ pcache1AllocPage()

static PgHdr1 * pcache1AllocPage	(	PCache1 *	pCache,
		int	benignMalloc )

static

Definition at line 50179 of file sqlite3.c.

                                                                  {
  PgHdr1 *p = 0;
  void *pPg;
 
  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){
    assert( pCache->pFree!=0 );
    p = pCache->pFree;
    pCache->pFree = p->pNext;
    p->pNext = 0;
  }else{
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    /* The group mutex must be released before pcache1Alloc() is called. This
    ** is because it might call sqlite3_release_memory(), which assumes that
    ** this mutex is not held. */
    assert( pcache1.separateCache==0 );
    assert( pCache->pGroup==&pcache1.grp );
    pcache1LeaveMutex(pCache->pGroup);
#endif
    if( benignMalloc ){ sqlite3BeginBenignMalloc(); }
#ifdef SQLITE_PCACHE_SEPARATE_HEADER
    pPg = pcache1Alloc(pCache->szPage);
    p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra);
    if( !pPg || !p ){
      pcache1Free(pPg);
      sqlite3_free(p);
      pPg = 0;
    }
#else
    pPg = pcache1Alloc(pCache->szAlloc);
#endif
    if( benignMalloc ){ sqlite3EndBenignMalloc(); }
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    pcache1EnterMutex(pCache->pGroup);
#endif
    if( pPg==0 ) return 0;
#ifndef SQLITE_PCACHE_SEPARATE_HEADER
    p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
#endif
    p->page.pBuf = pPg;
    p->page.pExtra = &p[1];

Referenced by pcache1FetchStage2().

◆ pcache1Cachesize()

static void pcache1Cachesize	(	sqlite3_pcache *	p,
		int	nMax )

static

Definition at line 50575 of file sqlite3.c.

                                                         {
  PCache1 *pCache = (PCache1 *)p;
  if( pCache->bPurgeable ){
    PGroup *pGroup = pCache->pGroup;
    pcache1EnterMutex(pGroup);
    pGroup->nMaxPage += (nMax - pCache->nMax);
    pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;

References PCache1::bPurgeable, PGroup::mxPinned, PCache1::n90pct, PCache1::nMax, PGroup::nMaxPage, PGroup::nMinPage, pcache1EnforceMaxPage(), pcache1EnterMutex, pcache1LeaveMutex, and PCache1::pGroup.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1Create()

static sqlite3_pcache * pcache1Create	(	int	szPage,
		int	szExtra,
		int	bPurgeable )

static

Definition at line 50525 of file sqlite3.c.

                                                                             {
  PCache1 *pCache;      /* The newly created page cache */
  PGroup *pGroup;       /* The group the new page cache will belong to */
  int sz;               /* Bytes of memory required to allocate the new cache */
 
  assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
  assert( szExtra < 300 );
 
  sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache;
  pCache = (PCache1 *)sqlite3MallocZero(sz);
  if( pCache ){
    if( pcache1.separateCache ){
      pGroup = (PGroup*)&pCache[1];
      pGroup->mxPinned = 10;
    }else{
      pGroup = &pcache1.grp;
    }
    pcache1EnterMutex(pGroup);
    if( pGroup->lru.isAnchor==0 ){
      pGroup->lru.isAnchor = 1;
      pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru;
    }
    pCache->pGroup = pGroup;
    pCache->szPage = szPage;
    pCache->szExtra = szExtra;
    pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1));
    pCache->bPurgeable = (bPurgeable ? 1 : 0);
    pcache1ResizeHash(pCache);
    if( bPurgeable ){
      pCache->nMin = 10;
      pGroup->nMinPage += pCache->nMin;
      pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
      pCache->pnPurgeable = &pGroup->nPurgeable;
    }else{
      pCache->pnPurgeable = &pCache->nPurgeableDummy;
    }
    pcache1LeaveMutex(pGroup);
    if( pCache->nHash==0 ){

References PCache1::bPurgeable, PgHdr1::isAnchor, PGroup::lru, PGroup::mxPinned, PCache1::nHash, PGroup::nMaxPage, PCache1::nMin, PGroup::nMinPage, PGroup::nPurgeable, PCache1::nPurgeableDummy, pcache1, pcache1Destroy(), pcache1EnterMutex, pcache1LeaveMutex, pcache1ResizeHash(), PCache1::pGroup, PgHdr1::pLruNext, PgHdr1::pLruPrev, PCache1::pnPurgeable, ROUND8, sqlite3MallocZero(), PCache1::szAlloc, PCache1::szExtra, and PCache1::szPage.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1Destroy()

static void pcache1Destroy ( sqlite3_pcache * p )

static

Definition at line 50923 of file sqlite3.c.

                                             {
  PCache1 *pCache = (PCache1 *)p;
  PGroup *pGroup = pCache->pGroup;
  assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
  pcache1EnterMutex(pGroup);
  if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0);
  assert( pGroup->nMaxPage >= pCache->nMax );
  pGroup->nMaxPage -= pCache->nMax;
  assert( pGroup->nMinPage >= pCache->nMin );
  pGroup->nMinPage -= pCache->nMin;
  pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;

References PCache1::apHash, PCache1::bPurgeable, PGroup::mxPinned, PCache1::nMax, PGroup::nMaxPage, PCache1::nMin, PGroup::nMinPage, PCache1::nPage, PCache1::pBulk, pcache1EnforceMaxPage(), pcache1EnterMutex, pcache1LeaveMutex, pcache1TruncateUnsafe(), PCache1::pGroup, and sqlite3_free().

Referenced by pcache1Create(), and sqlite3PCacheSetDefault().

◆ pcache1EnforceMaxPage()

static void pcache1EnforceMaxPage ( PCache1 * pCache )

static

Definition at line 50382 of file sqlite3.c.

                                                  {
  PGroup *pGroup = pCache->pGroup;
  PgHdr1 *p;
  assert( sqlite3_mutex_held(pGroup->mutex) );
  while( pGroup->nPurgeable>pGroup->nMaxPage
      && (p=pGroup->lru.pLruPrev)->isAnchor==0
  ){
    assert( p->pCache->pGroup==pGroup );
    assert( PAGE_IS_UNPINNED(p) );
    pcache1PinPage(p);
    pcache1RemoveFromHash(p, 1);

Referenced by pcache1Cachesize(), pcache1Destroy(), and pcache1Shrink().

◆ pcache1Fetch()

static sqlite3_pcache_page * pcache1Fetch	(	sqlite3_pcache *	p,
		unsigned int	iKey,
		int	createFlag )

static

Definition at line 50802 of file sqlite3.c.

 {
#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG)
  PCache1 *pCache = (PCache1 *)p;
#endif
 
  assert( offsetof(PgHdr1,page)==0 );
  assert( pCache->bPurgeable || createFlag!=1 );
  assert( pCache->bPurgeable || pCache->nMin==0 );
  assert( pCache->bPurgeable==0 || pCache->nMin==10 );
  assert( pCache->nMin==0 || pCache->bPurgeable );
  assert( pCache->nHash>0 );
#if PCACHE1_MIGHT_USE_GROUP_MUTEX
  if( pCache->pGroup->mutex ){
    return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag);

Referenced by sqlite3PCacheSetDefault().

◆ pcache1FetchNoMutex()

static PgHdr1 * pcache1FetchNoMutex	(	sqlite3_pcache *	p,
		unsigned int	iKey,
		int	createFlag )

static

Definition at line 50757 of file sqlite3.c.

 {
  PCache1 *pCache = (PCache1 *)p;
  PgHdr1 *pPage = 0;
 
  /* Step 1: Search the hash table for an existing entry. */
  pPage = pCache->apHash[iKey % pCache->nHash];
  while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; }
 
  /* Step 2: If the page was found in the hash table, then return it.
  ** If the page was not in the hash table and createFlag is 0, abort.
  ** Otherwise (page not in hash and createFlag!=0) continue with
  ** subsequent steps to try to create the page. */
  if( pPage ){
    if( PAGE_IS_UNPINNED(pPage) ){
      return pcache1PinPage(pPage);
    }else{
      return pPage;
    }
  }else if( createFlag ){

References PCache1::apHash, PgHdr1::iKey, PCache1::nHash, PAGE_IS_UNPINNED, pcache1FetchStage2(), pcache1PinPage(), and PgHdr1::pNext.

◆ pcache1FetchStage2()

static SQLITE_NOINLINE PgHdr1 * pcache1FetchStage2	(	PCache1 *	pCache,
		unsigned int	iKey,
		int	createFlag )

static

Definition at line 50629 of file sqlite3.c.

 {
  unsigned int nPinned;
  PGroup *pGroup = pCache->pGroup;
  PgHdr1 *pPage = 0;
 
  /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
  assert( pCache->nPage >= pCache->nRecyclable );
  nPinned = pCache->nPage - pCache->nRecyclable;
  assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
  assert( pCache->n90pct == pCache->nMax*9/10 );
  if( createFlag==1 && (
        nPinned>=pGroup->mxPinned
     || nPinned>=pCache->n90pct
     || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclable<nPinned)
  )){
    return 0;
  }
 
  if( pCache->nPage>=pCache->nHash ) pcache1ResizeHash(pCache);
  assert( pCache->nHash>0 && pCache->apHash );
 
  /* Step 4. Try to recycle a page. */
  if( pCache->bPurgeable
   && !pGroup->lru.pLruPrev->isAnchor
   && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache))
  ){
    PCache1 *pOther;
    pPage = pGroup->lru.pLruPrev;
    assert( PAGE_IS_UNPINNED(pPage) );
    pcache1RemoveFromHash(pPage, 0);
    pcache1PinPage(pPage);
    pOther = pPage->pCache;
    if( pOther->szAlloc != pCache->szAlloc ){
      pcache1FreePage(pPage);
      pPage = 0;
    }else{
      pGroup->nPurgeable -= (pOther->bPurgeable - pCache->bPurgeable);
    }
  }
 
  /* Step 5. If a usable page buffer has still not been found,
  ** attempt to allocate a new one.
  */
  if( !pPage ){
    pPage = pcache1AllocPage(pCache, createFlag==1);
  }
 
  if( pPage ){
    unsigned int h = iKey % pCache->nHash;
    pCache->nPage++;
    pPage->iKey = iKey;
    pPage->pNext = pCache->apHash[h];
    pPage->pCache = pCache;
    pPage->pLruNext = 0;
    /* pPage->pLruPrev = 0;
    ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */
    *(void **)pPage->page.pExtra = 0;
    pCache->apHash[h] = pPage;

References PCache1::apHash, PCache1::bPurgeable, PgHdr1::iKey, PCache1::iMaxKey, PgHdr1::isAnchor, PGroup::lru, PGroup::mxPinned, PCache1::n90pct, PCache1::nHash, PCache1::nMax, PGroup::nMaxPage, PGroup::nMinPage, PCache1::nPage, PGroup::nPurgeable, PCache1::nRecyclable, PgHdr1::page, PAGE_IS_UNPINNED, PgHdr1::pCache, pcache1AllocPage(), pcache1FreePage(), pcache1PinPage(), pcache1RemoveFromHash(), pcache1ResizeHash(), pcache1UnderMemoryPressure(), sqlite3_pcache_page::pExtra, PCache1::pGroup, PgHdr1::pLruNext, PgHdr1::pLruPrev, PgHdr1::pNext, and PCache1::szAlloc.

Referenced by pcache1FetchNoMutex().

◆ pcache1Free()

static void pcache1Free ( void * p )

static

Definition at line 50129 of file sqlite3.c.

                                {
  if( p==0 ) return;
  if( SQLITE_WITHIN(p, pcache1.pStart, pcache1.pEnd) ){
    PgFreeslot *pSlot;
    sqlite3_mutex_enter(pcache1.mutex);
    sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_USED, 1);
    pSlot = (PgFreeslot*)p;
    pSlot->pNext = pcache1.pFree;
    pcache1.pFree = pSlot;
    pcache1.nFreeSlot++;
    pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
    assert( pcache1.nFreeSlot<=pcache1.nSlot );
    sqlite3_mutex_leave(pcache1.mutex);
  }else{
    assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
    {
      int nFreed = 0;
      nFreed = sqlite3MallocSize(p);
      sqlite3_mutex_enter(pcache1.mutex);
      sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_OVERFLOW, nFreed);

◆ pcache1FreePage()

static void pcache1FreePage ( PgHdr1 * p )

static

Definition at line 50230 of file sqlite3.c.

                                      {
  PCache1 *pCache;
  assert( p!=0 );
  pCache = p->pCache;
  assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
  if( p->isBulkLocal ){
    p->pNext = pCache->pFree;
    pCache->pFree = p;
  }else{
    pcache1Free(p->page.pBuf);

Referenced by pcache1FetchStage2(), pcache1RemoveFromHash(), and pcache1TruncateUnsafe().

◆ pcache1Init()

static int pcache1Init ( void * NotUsed )

static

Definition at line 50458 of file sqlite3.c.

                                     {
  UNUSED_PARAMETER(NotUsed);
  assert( pcache1.isInit==0 );
  memset(&pcache1, 0, sizeof(pcache1));
 
 
  /*
  ** The pcache1.separateCache variable is true if each PCache has its own
  ** private PGroup (mode-1).  pcache1.separateCache is false if the single
  ** PGroup in pcache1.grp is used for all page caches (mode-2).
  **
  **   *  Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
  **
  **   *  Use a unified cache in single-threaded applications that have
  **      configured a start-time buffer for use as page-cache memory using
  **      sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL
  **      pBuf argument.
  **
  **   *  Otherwise use separate caches (mode-1)
  */
#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
  pcache1.separateCache = 0;
#elif SQLITE_THREADSAFE
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0
                          || sqlite3GlobalConfig.bCoreMutex>0;
#else
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0;
#endif
 
#if SQLITE_THREADSAFE
  if( sqlite3GlobalConfig.bCoreMutex ){
    pcache1.grp.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU);
    pcache1.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PMEM);
  }
#endif
  if( pcache1.separateCache
   && sqlite3GlobalConfig.nPage!=0
   && sqlite3GlobalConfig.pPage==0
  ){
    pcache1.nInitPage = sqlite3GlobalConfig.nPage;
  }else{

References pcache1, sqlite3GlobalConfig, sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_LRU, SQLITE_MUTEX_STATIC_PMEM, SQLITE_OK, and UNUSED_PARAMETER.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1InitBulk()

static int pcache1InitBulk ( PCache1 * pCache )

static

Definition at line 50048 of file sqlite3.c.

                                           {
  i64 szBulk;
  char *zBulk;
  if( pcache1.nInitPage==0 ) return 0;
  /* Do not bother with a bulk allocation if the cache size very small */
  if( pCache->nMax<3 ) return 0;
  sqlite3BeginBenignMalloc();
  if( pcache1.nInitPage>0 ){
    szBulk = pCache->szAlloc * (i64)pcache1.nInitPage;
  }else{
    szBulk = -1024 * (i64)pcache1.nInitPage;
  }
  if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){
    szBulk = pCache->szAlloc*(i64)pCache->nMax;
  }
  zBulk = pCache->pBulk = sqlite3Malloc( szBulk );
  sqlite3EndBenignMalloc();
  if( zBulk ){
    int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc;
    do{
      PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
      pX->page.pBuf = zBulk;
      pX->page.pExtra = &pX[1];
      pX->isBulkLocal = 1;
      pX->isAnchor = 0;
      pX->pNext = pCache->pFree;
      pX->pLruPrev = 0;           /* Initializing this saves a valgrind error */

◆ pcache1Pagecount()

static int pcache1Pagecount ( sqlite3_pcache * p )

static

Definition at line 50611 of file sqlite3.c.

50617 {

50618 int n;

Referenced by sqlite3PCacheSetDefault().

◆ pcache1PinPage()

static PgHdr1 * pcache1PinPage ( PgHdr1 * pPage )

static

Definition at line 50339 of file sqlite3.c.

                                            {
  assert( pPage!=0 );
  assert( PAGE_IS_UNPINNED(pPage) );
  assert( pPage->pLruNext );
  assert( pPage->pLruPrev );
  assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) );
  pPage->pLruPrev->pLruNext = pPage->pLruNext;
  pPage->pLruNext->pLruPrev = pPage->pLruPrev;
  pPage->pLruNext = 0;
  /* pPage->pLruPrev = 0;

References PgHdr1::isAnchor, PGroup::lru, PGroup::mutex, PCache1::nRecyclable, PAGE_IS_UNPINNED, PgHdr1::pCache, PCache1::pGroup, PgHdr1::pLruNext, PgHdr1::pLruPrev, and sqlite3_mutex_held().

Referenced by pcache1FetchNoMutex(), pcache1FetchStage2(), and pcache1TruncateUnsafe().

◆ pcache1Rekey()

static void pcache1Rekey	(	sqlite3_pcache *	p,
		sqlite3_pcache_page *	pPg,
		unsigned int	iOld,
		unsigned int	iNew )

static

Definition at line 50868 of file sqlite3.c.

 {
  PCache1 *pCache = (PCache1 *)p;
  PgHdr1 *pPage = (PgHdr1 *)pPg;
  PgHdr1 **pp;
  unsigned int h;
  assert( pPage->iKey==iOld );
  assert( pPage->pCache==pCache );
 
  pcache1EnterMutex(pCache->pGroup);
 
  h = iOld%pCache->nHash;
  pp = &pCache->apHash[h];
  while( (*pp)!=pPage ){
    pp = &(*pp)->pNext;
  }
  *pp = pPage->pNext;
 
  h = iNew%pCache->nHash;
  pPage->iKey = iNew;
  pPage->pNext = pCache->apHash[h];
  pCache->apHash[h] = pPage;

Referenced by sqlite3PCacheSetDefault().

◆ pcache1RemoveFromHash()

static void pcache1RemoveFromHash	(	PgHdr1 *	pPage,
		int	freeFlag )

static

Definition at line 50364 of file sqlite3.c.

                                                              {
  unsigned int h;
  PCache1 *pCache = pPage->pCache;
  PgHdr1 **pp;
 
  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  h = pPage->iKey % pCache->nHash;

References PCache1::apHash, PgHdr1::iKey, PGroup::mutex, PCache1::nHash, PCache1::nPage, PgHdr1::pCache, pcache1FreePage(), PCache1::pGroup, PgHdr1::pNext, and sqlite3_mutex_held().

Referenced by pcache1FetchStage2(), and pcache1Unpin().

◆ pcache1ResizeHash()

static void pcache1ResizeHash ( PCache1 * p )

static

Definition at line 50298 of file sqlite3.c.

                                         {
  PgHdr1 **apNew;
  unsigned int nNew;
  unsigned int i;
 
  assert( sqlite3_mutex_held(p->pGroup->mutex) );
 
  nNew = p->nHash*2;
  if( nNew<256 ){
    nNew = 256;
  }
 
  pcache1LeaveMutex(p->pGroup);
  if( p->nHash ){ sqlite3BeginBenignMalloc(); }
  apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
  if( p->nHash ){ sqlite3EndBenignMalloc(); }
  pcache1EnterMutex(p->pGroup);
  if( apNew ){
    for(i=0; i<p->nHash; i++){
      PgHdr1 *pPage;
      PgHdr1 *pNext = p->apHash[i];
      while( (pPage = pNext)!=0 ){
        unsigned int h = pPage->iKey % nNew;
        pNext = pPage->pNext;
        pPage->pNext = apNew[h];
        apNew[h] = pPage;
      }

References PCache1::apHash, PgHdr1::iKey, PGroup::mutex, PCache1::nHash, pcache1EnterMutex, pcache1LeaveMutex, PCache1::pGroup, PgHdr1::pNext, sqlite3_free(), sqlite3_mutex_held(), sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), and sqlite3MallocZero().

Referenced by pcache1Create(), and pcache1FetchStage2().

◆ pcache1Shrink()

static void pcache1Shrink ( sqlite3_pcache * p )

static

Definition at line 50594 of file sqlite3.c.

                                            {
  PCache1 *pCache = (PCache1*)p;
  if( pCache->bPurgeable ){
    PGroup *pGroup = pCache->pGroup;
    int savedMaxPage;
    pcache1EnterMutex(pGroup);
    savedMaxPage = pGroup->nMaxPage;

References PCache1::bPurgeable, PGroup::nMaxPage, pcache1EnforceMaxPage(), pcache1EnterMutex, pcache1LeaveMutex, and PCache1::pGroup.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1Shutdown()

static void pcache1Shutdown ( void * NotUsed )

static

Definition at line 50511 of file sqlite3.c.

References pcache1, and UNUSED_PARAMETER.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1Truncate()

static void pcache1Truncate	(	sqlite3_pcache *	p,
		unsigned int	iLimit )

static

Definition at line 50908 of file sqlite3.c.

                                                                   {
  PCache1 *pCache = (PCache1 *)p;
  pcache1EnterMutex(pCache->pGroup);

References PCache1::iMaxKey, pcache1EnterMutex, pcache1LeaveMutex, pcache1TruncateUnsafe(), and PCache1::pGroup.

Referenced by sqlite3PCacheSetDefault().

◆ pcache1TruncateUnsafe()

static void pcache1TruncateUnsafe	(	PCache1 *	pCache,
		unsigned int	iLimit )

static

Definition at line 50407 of file sqlite3.c.

 {
  TESTONLY( int nPage = 0; )  /* To assert pCache->nPage is correct */
  unsigned int h, iStop;
  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  assert( pCache->iMaxKey >= iLimit );
  assert( pCache->nHash > 0 );
  if( pCache->iMaxKey - iLimit < pCache->nHash ){
    /* If we are just shaving the last few pages off the end of the
    ** cache, then there is no point in scanning the entire hash table.
    ** Only scan those hash slots that might contain pages that need to
    ** be removed. */
    h = iLimit % pCache->nHash;
    iStop = pCache->iMaxKey % pCache->nHash;
    TESTONLY( nPage = -10; )  /* Disable the pCache->nPage validity check */
  }else{
    /* This is the general case where many pages are being removed.
    ** It is necessary to scan the entire hash table */
    h = pCache->nHash/2;
    iStop = h - 1;
  }
  for(;;){
    PgHdr1 **pp;
    PgHdr1 *pPage;
    assert( h<pCache->nHash );
    pp = &pCache->apHash[h];
    while( (pPage = *pp)!=0 ){
      if( pPage->iKey>=iLimit ){
        pCache->nPage--;
        *pp = pPage->pNext;
        if( PAGE_IS_UNPINNED(pPage) ) pcache1PinPage(pPage);
        pcache1FreePage(pPage);
      }else{
        pp = &pPage->pNext;
        TESTONLY( if( nPage>=0 ) nPage++; )
      }

References PCache1::apHash, PgHdr1::iKey, PCache1::iMaxKey, PGroup::mutex, PCache1::nHash, PCache1::nPage, PAGE_IS_UNPINNED, pcache1FreePage(), pcache1PinPage(), PCache1::pGroup, PgHdr1::pNext, sqlite3_mutex_held(), and TESTONLY.

Referenced by pcache1Destroy(), and pcache1Truncate().

◆ pcache1UnderMemoryPressure()

static int pcache1UnderMemoryPressure ( PCache1 * pCache )

static

Definition at line 50281 of file sqlite3.c.

50287 {

References pcache1, sqlite3HeapNearlyFull(), PCache1::szExtra, and PCache1::szPage.

Referenced by pcache1FetchStage2().

◆ pcache1Unpin()

static void pcache1Unpin	(	sqlite3_pcache *	p,
		sqlite3_pcache_page *	pPg,
		int	reuseUnlikely )

static

Definition at line 50833 of file sqlite3.c.

 {
  PCache1 *pCache = (PCache1 *)p;
  PgHdr1 *pPage = (PgHdr1 *)pPg;
  PGroup *pGroup = pCache->pGroup;
 
  assert( pPage->pCache==pCache );
  pcache1EnterMutex(pGroup);
 
  /* It is an error to call this function if the page is already
  ** part of the PGroup LRU list.
  */
  assert( pPage->pLruNext==0 );
  assert( PAGE_IS_PINNED(pPage) );
 
  if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){
    pcache1RemoveFromHash(pPage, 1);
  }else{
    /* Add the page to the PGroup LRU list. */
    PgHdr1 **ppFirst = &pGroup->lru.pLruNext;
    pPage->pLruPrev = &pGroup->lru;
    (pPage->pLruNext = *ppFirst)->pLruPrev = pPage;

References PGroup::lru, PGroup::nMaxPage, PGroup::nPurgeable, PCache1::nRecyclable, PAGE_IS_PINNED, PgHdr1::pCache, pcache1EnterMutex, pcache1RemoveFromHash(), PCache1::pGroup, PgHdr1::pLruNext, and PgHdr1::pLruPrev.

Referenced by sqlite3PCacheSetDefault().

◆ pcacheFetchFinishWithInit()

static SQLITE_NOINLINE PgHdr * pcacheFetchFinishWithInit	(	PCache *	pCache,
		Pgno	pgno,
		sqlite3_pcache_page *	pPage )

static

Definition at line 49333 of file sqlite3.c.

 {
  PgHdr *pPgHdr;
  assert( pPage!=0 );
  pPgHdr = (PgHdr*)pPage->pExtra;
  assert( pPgHdr->pPage==0 );
  memset(&pPgHdr->pDirty, 0, sizeof(PgHdr) - offsetof(PgHdr,pDirty));
  pPgHdr->pPage = pPage;
  pPgHdr->pData = pPage->pBuf;
  pPgHdr->pExtra = (void *)&pPgHdr[1];

References PgHdr::flags, offsetof, sqlite3_pcache_page::pBuf, PgHdr::pCache, PgHdr::pData, PgHdr::pDirty, sqlite3_pcache_page::pExtra, PgHdr::pExtra, PGHDR_CLEAN, PgHdr::pgno, PgHdr::pPage, and sqlite3PcacheFetchFinish().

Referenced by sqlite3PcacheFetchFinish().

◆ pcacheManageDirtyList()

static void pcacheManageDirtyList	(	PgHdr *	pPage,
		u8	addRemove )

static

Definition at line 49031 of file sqlite3.c.

                                                             {
  PCache *p = pPage->pCache;
 
  pcacheTrace(("%p.DIRTYLIST.%s %d\n", p,
                addRemove==1 ? "REMOVE" : addRemove==2 ? "ADD" : "FRONT",
                pPage->pgno));
  if( addRemove & PCACHE_DIRTYLIST_REMOVE ){
    assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
    assert( pPage->pDirtyPrev || pPage==p->pDirty );
 
    /* Update the PCache1.pSynced variable if necessary. */
    if( p->pSynced==pPage ){
      p->pSynced = pPage->pDirtyPrev;
    }
 
    if( pPage->pDirtyNext ){
      pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
    }else{
      assert( pPage==p->pDirtyTail );
      p->pDirtyTail = pPage->pDirtyPrev;
    }
    if( pPage->pDirtyPrev ){
      pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
    }else{
      /* If there are now no dirty pages in the cache, set eCreate to 2.
      ** This is an optimization that allows sqlite3PcacheFetch() to skip
      ** searching for a dirty page to eject from the cache when it might
      ** otherwise have to.  */
      assert( pPage==p->pDirty );
      p->pDirty = pPage->pDirtyNext;
      assert( p->bPurgeable || p->eCreate==2 );
      if( p->pDirty==0 ){         /*OPTIMIZATION-IF-TRUE*/
        assert( p->bPurgeable==0 || p->eCreate==1 );
        p->eCreate = 2;
      }
    }
  }
  if( addRemove & PCACHE_DIRTYLIST_ADD ){
    pPage->pDirtyPrev = 0;
    pPage->pDirtyNext = p->pDirty;
    if( pPage->pDirtyNext ){
      assert( pPage->pDirtyNext->pDirtyPrev==0 );
      pPage->pDirtyNext->pDirtyPrev = pPage;
    }else{
      p->pDirtyTail = pPage;
      if( p->bPurgeable ){
        assert( p->eCreate==2 );
        p->eCreate = 1;
      }
    }
    p->pDirty = pPage;
 
    /* If pSynced is NULL and this page has a clear NEED_SYNC flag, set
    ** pSynced to point to it. Checking the NEED_SYNC flag is an
    ** optimization, as if pSynced points to a page with the NEED_SYNC
    ** flag set sqlite3PcacheFetchStress() searches through all newer
    ** entries of the dirty-list for a page with NEED_SYNC clear anyway.  */
    if( !p->pSynced
     && 0==(pPage->flags&PGHDR_NEED_SYNC)   /*OPTIMIZATION-IF-FALSE*/

References PCache::bPurgeable, PCache::eCreate, PgHdr::flags, PgHdr::pCache, PCACHE_DIRTYLIST_ADD, PCACHE_DIRTYLIST_REMOVE, pcacheDump, pcacheTrace, PCache::pDirty, PgHdr::pDirtyNext, PgHdr::pDirtyPrev, PCache::pDirtyTail, PGHDR_NEED_SYNC, PgHdr::pgno, and PCache::pSynced.

Referenced by sqlite3PcacheDrop().

◆ pcacheMergeDirtyList()

static PgHdr * pcacheMergeDirtyList	(	PgHdr *	pA,
		PgHdr *	pB )

static

Definition at line 49565 of file sqlite3.c.

                                                        {
  PgHdr result, *pTail;
  pTail = &result;
  assert( pA!=0 && pB!=0 );
  for(;;){
    if( pA->pgno<pB->pgno ){
      pTail->pDirty = pA;
      pTail = pA;
      pA = pA->pDirty;
      if( pA==0 ){
        pTail->pDirty = pB;
        break;
      }
    }else{
      pTail->pDirty = pB;
      pTail = pB;
      pB = pB->pDirty;
      if( pB==0 ){
        pTail->pDirty = pA;

Referenced by pcacheSortDirtyList().

◆ pcacheSortDirtyList()

static PgHdr * pcacheSortDirtyList ( PgHdr * pIn )

static

Definition at line 49602 of file sqlite3.c.

                                             {
  PgHdr *a[N_SORT_BUCKET], *p;
  int i;
  memset(a, 0, sizeof(a));
  while( pIn ){
    p = pIn;
    pIn = p->pDirty;
    p->pDirty = 0;
    for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){
      if( a[i]==0 ){
        a[i] = p;
        break;
      }else{
        p = pcacheMergeDirtyList(a[i], p);
        a[i] = 0;
      }
    }
    if( NEVER(i==N_SORT_BUCKET-1) ){
      /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
      ** the input list.  But that is impossible.
      */
      a[i] = pcacheMergeDirtyList(a[i], p);
    }
  }
  p = a[0];

References ALWAYS, N_SORT_BUCKET, NEVER, pcacheMergeDirtyList(), and PgHdr::pDirty.

◆ pcacheUnpin()

static void pcacheUnpin ( PgHdr * p )

static

Definition at line 49101 of file sqlite3.c.

49107 {

◆ percent_rankInvFunc()

static void percent_rankInvFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151500 of file sqlite3.c.

         {
    p->nTotal++;
  }
}
static void percent_rankInvFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){

◆ percent_rankStepFunc()

static void percent_rankStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151487 of file sqlite3.c.

 {
  struct CallCount *p;
  UNUSED_PARAMETER(nArg); assert( nArg==0 );

References UNUSED_PARAMETER.

◆ percent_rankValueFunc()

static void percent_rankValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151511 of file sqlite3.c.

                                                        {
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    p->nValue = p->nStep;
    if( p->nTotal>1 ){
      double r = (double)p->nValue / (double)(p->nTotal-1);

◆ populateCellCache()

static void populateCellCache	(	CellArray *	p,
		int	idx,
		int	N )

static

Definition at line 71373 of file sqlite3.c.

                                                           {
  assert( idx>=0 && idx+N<=p->nCell );
  while( N>0 ){
    assert( p->apCell[idx]!=0 );
    if( p->szCell[idx]==0 ){
      p->szCell[idx] = p->pRef->xCellSize(p->pRef, p->apCell[idx]);
    }else{
      assert( CORRUPT_DB ||

Referenced by editPage().

◆ posixOpen()

static int posixOpen	(	const char *	zFile,
		int	flags,
		int	mode )

static

Definition at line 33911 of file sqlite3.c.

◆ posixUnlock()

static int posixUnlock	(	sqlite3_file *	id,
		int	eFileLock,
		int	handleNFSUnlock )

static

Definition at line 35446 of file sqlite3.c.

                                                                            {
  unixFile *pFile = (unixFile*)id;
  unixInodeInfo *pInode;
  struct flock lock;
  int rc = SQLITE_OK;
 
  assert( pFile );
  OSTRACE(("UNLOCK  %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
      pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
      osGetpid(0)));
 
  assert( eFileLock<=SHARED_LOCK );
  if( pFile->eFileLock<=eFileLock ){
    return SQLITE_OK;
  }
  pInode = pFile->pInode;
  sqlite3_mutex_enter(pInode->pLockMutex);
  assert( pInode->nShared!=0 );
  if( pFile->eFileLock>SHARED_LOCK ){
    assert( pInode->eFileLock==pFile->eFileLock );
 
#ifdef SQLITE_DEBUG
    /* When reducing a lock such that other processes can start
    ** reading the database file again, make sure that the
    ** transaction counter was updated if any part of the database
    ** file changed.  If the transaction counter is not updated,
    ** other connections to the same file might not realize that
    ** the file has changed and hence might not know to flush their
    ** cache.  The use of a stale cache can lead to database corruption.
    */
    pFile->inNormalWrite = 0;
#endif
 
    /* downgrading to a shared lock on NFS involves clearing the write lock
    ** before establishing the readlock - to avoid a race condition we downgrade
    ** the lock in 2 blocks, so that part of the range will be covered by a
    ** write lock until the rest is covered by a read lock:
    **  1:   [WWWWW]
    **  2:   [....W]
    **  3:   [RRRRW]
    **  4:   [RRRR.]
    */
    if( eFileLock==SHARED_LOCK ){
#if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE
      (void)handleNFSUnlock;
      assert( handleNFSUnlock==0 );
#endif
#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
      if( handleNFSUnlock ){
        int tErrno;               /* Error code from system call errors */
        off_t divSize = SHARED_SIZE - 1;
 
        lock.l_type = F_UNLCK;
        lock.l_whence = SEEK_SET;
        lock.l_start = SHARED_FIRST;
        lock.l_len = divSize;
        if( unixFileLock(pFile, &lock)==(-1) ){
          tErrno = errno;
          rc = SQLITE_IOERR_UNLOCK;
          storeLastErrno(pFile, tErrno);
          goto end_unlock;
        }
        lock.l_type = F_RDLCK;
        lock.l_whence = SEEK_SET;
        lock.l_start = SHARED_FIRST;
        lock.l_len = divSize;
        if( unixFileLock(pFile, &lock)==(-1) ){
          tErrno = errno;
          rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
          if( IS_LOCK_ERROR(rc) ){
            storeLastErrno(pFile, tErrno);
          }
          goto end_unlock;
        }
        lock.l_type = F_UNLCK;
        lock.l_whence = SEEK_SET;
        lock.l_start = SHARED_FIRST+divSize;
        lock.l_len = SHARED_SIZE-divSize;
        if( unixFileLock(pFile, &lock)==(-1) ){
          tErrno = errno;
          rc = SQLITE_IOERR_UNLOCK;
          storeLastErrno(pFile, tErrno);
          goto end_unlock;
        }
      }else
#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
      {
        lock.l_type = F_RDLCK;
        lock.l_whence = SEEK_SET;
        lock.l_start = SHARED_FIRST;
        lock.l_len = SHARED_SIZE;
        if( unixFileLock(pFile, &lock) ){
          /* In theory, the call to unixFileLock() cannot fail because another
          ** process is holding an incompatible lock. If it does, this
          ** indicates that the other process is not following the locking
          ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
          ** SQLITE_BUSY would confuse the upper layer (in practice it causes
          ** an assert to fail). */
          rc = SQLITE_IOERR_RDLOCK;
          storeLastErrno(pFile, errno);
          goto end_unlock;
        }
      }
    }
    lock.l_type = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = PENDING_BYTE;
    lock.l_len = 2L;  assert( PENDING_BYTE+1==RESERVED_BYTE );
    if( unixFileLock(pFile, &lock)==0 ){
      pInode->eFileLock = SHARED_LOCK;
    }else{
      rc = SQLITE_IOERR_UNLOCK;
      storeLastErrno(pFile, errno);
      goto end_unlock;
    }
  }
  if( eFileLock==NO_LOCK ){
    /* Decrement the shared lock counter.  Release the lock using an
    ** OS call only when all threads in this same process have released
    ** the lock.
    */
    pInode->nShared--;
    if( pInode->nShared==0 ){
      lock.l_type = F_UNLCK;
      lock.l_whence = SEEK_SET;
      lock.l_start = lock.l_len = 0L;
      if( unixFileLock(pFile, &lock)==0 ){
        pInode->eFileLock = NO_LOCK;
      }else{
        rc = SQLITE_IOERR_UNLOCK;
        storeLastErrno(pFile, errno);
        pInode->eFileLock = NO_LOCK;
        pFile->eFileLock = NO_LOCK;
      }
    }
 
    /* Decrement the count of locks against this same file.  When the
    ** count reaches zero, close any other file descriptors whose close
    ** was deferred because of outstanding locks.
    */
    pInode->nLock--;
    assert( pInode->nLock>=0 );
    if( pInode->nLock==0 ) closePendingFds(pFile);
  }
 
end_unlock:

References closePendingFds(), unixFile::eFileLock, unixInodeInfo::eFileLock, unixFile::h, IS_LOCK_ERROR, unixInodeInfo::nLock, NO_LOCK, unixInodeInfo::nShared, osGetpid, OSTRACE, PENDING_BYTE, unixFile::pInode, unixInodeInfo::pLockMutex, RESERVED_BYTE, SHARED_FIRST, SHARED_LOCK, SHARED_SIZE, sqlite3_mutex_enter(), sqlite3_mutex_leave(), SQLITE_IOERR_RDLOCK, SQLITE_IOERR_UNLOCK, SQLITE_OK, sqliteErrorFromPosixError(), storeLastErrno(), and unixFileLock().

Referenced by unixUnlock().

◆ pragmaFunclistLine()

static void pragmaFunclistLine	(	Vdbe *	v,
		FuncDef *	p,
		int	isBuiltin,
		int	showInternFuncs )

static

Definition at line 126041 of file sqlite3.c.

 {
  for(; p; p=p->pNext){
    const char *zType;
    static const u32 mask =
        SQLITE_DETERMINISTIC |
        SQLITE_DIRECTONLY |
        SQLITE_SUBTYPE |
        SQLITE_INNOCUOUS |
        SQLITE_FUNC_INTERNAL
    ;
    static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" };
 
    assert( SQLITE_FUNC_ENCMASK==0x3 );
    assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 );
 
    if( p->xSFunc==0 ) continue;
    if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0
     && showInternFuncs==0
    ){
      continue;
    }
    if( p->xValue!=0 ){
      zType = "w";
    }else if( p->xFinalize!=0 ){
      zType = "a";
    }else{
      zType = "s";
    }
    sqlite3VdbeMultiLoad(v, 1, "sissii",
       p->zName, isBuiltin,

Referenced by sqlite3Pragma().

◆ pragmaLocate()

static const PragmaName * pragmaLocate ( const char * zName )

static

Definition at line 126020 of file sqlite3.c.

                                                        {
  int upr, lwr, mid = 0, rc;
  lwr = 0;
  upr = ArraySize(aPragmaName)-1;
  while( lwr<=upr ){
    mid = (lwr+upr)/2;
    rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
    if( rc==0 ) break;
    if( rc<0 ){
      upr = mid - 1;

Referenced by sqlite3Pragma(), and sqlite3PragmaVtabRegister().

◆ pragmaVtabBestIndex()

static int pragmaVtabBestIndex	(	sqlite3_vtab *	tab,
		sqlite3_index_info *	pIdxInfo )

static

Definition at line 128118 of file sqlite3.c.

                                                                               {
  PragmaVtab *pTab = (PragmaVtab*)tab;
  const struct sqlite3_index_constraint *pConstraint;
  int i, j;
  int seen[2];
 
  pIdxInfo->estimatedCost = (double)1;
  if( pTab->nHidden==0 ){ return SQLITE_OK; }
  pConstraint = pIdxInfo->aConstraint;
  seen[0] = 0;
  seen[1] = 0;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->usable==0 ) continue;
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pConstraint->iColumn < pTab->iHidden ) continue;
    j = pConstraint->iColumn - pTab->iHidden;
    assert( j < 2 );
    seen[j] = i+1;
  }
  if( seen[0]==0 ){
    pIdxInfo->estimatedCost = (double)2147483647;
    pIdxInfo->estimatedRows = 2147483647;
    return SQLITE_OK;
  }
  j = seen[0]-1;
  pIdxInfo->aConstraintUsage[j].argvIndex = 1;
  pIdxInfo->aConstraintUsage[j].omit = 1;
  if( seen[1]==0 ) return SQLITE_OK;
  pIdxInfo->estimatedCost = (double)20;

References sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::sqlite3_index_constraint_usage::argvIndex, sqlite3_index_info::estimatedCost, sqlite3_index_info::estimatedRows, sqlite3_index_info::sqlite3_index_constraint::iColumn, PragmaVtab::iHidden, sqlite3_index_info::nConstraint, PragmaVtab::nHidden, sqlite3_index_info::sqlite3_index_constraint_usage::omit, SQLITE_INDEX_CONSTRAINT_EQ, and SQLITE_OK.

◆ pragmaVtabClose()

static int pragmaVtabClose ( sqlite3_vtab_cursor * cur )

static

Definition at line 128177 of file sqlite3.c.

◆ pragmaVtabColumn()

static int pragmaVtabColumn	(	sqlite3_vtab_cursor *	pVtabCursor,
		sqlite3_context *	ctx,
		int	i )

static

Definition at line 128261 of file sqlite3.c.

 {
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
  if( i<pTab->iHidden ){

◆ pragmaVtabConnect()

static int pragmaVtabConnect	(	sqlite3 *	db,
		void *	pAux,
		int	argc,
		const char const	argv,
		sqlite3_vtab **	ppVtab,
		char **	pzErr )

static

Definition at line 128043 of file sqlite3.c.

 {
  const PragmaName *pPragma = (const PragmaName*)pAux;
  PragmaVtab *pTab = 0;
  int rc;
  int i, j;
  char cSep = '(';
  StrAccum acc;
  char zBuf[200];
 
  UNUSED_PARAMETER(argc);
  UNUSED_PARAMETER(argv);
  sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
  sqlite3_str_appendall(&acc, "CREATE TABLE x");
  for(i=0, j=pPragma->iPragCName; i<pPragma->nPragCName; i++, j++){
    sqlite3_str_appendf(&acc, "%c\"%s\"", cSep, pragCName[j]);
    cSep = ',';
  }
  if( i==0 ){
    sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
    i++;
  }
  j = 0;
  if( pPragma->mPragFlg & PragFlg_Result1 ){
    sqlite3_str_appendall(&acc, ",arg HIDDEN");
    j++;
  }
  if( pPragma->mPragFlg & (PragFlg_SchemaOpt|PragFlg_SchemaReq) ){
    sqlite3_str_appendall(&acc, ",schema HIDDEN");
    j++;
  }
  sqlite3_str_append(&acc, ")", 1);
  sqlite3StrAccumFinish(&acc);
  assert( strlen(zBuf) < sizeof(zBuf)-1 );
  rc = sqlite3_declare_vtab(db, zBuf);
  if( rc==SQLITE_OK ){
    pTab = (PragmaVtab*)sqlite3_malloc(sizeof(PragmaVtab));
    if( pTab==0 ){
      rc = SQLITE_NOMEM;
    }else{
      memset(pTab, 0, sizeof(PragmaVtab));
      pTab->pName = pPragma;
      pTab->db = db;
      pTab->iHidden = i;
      pTab->nHidden = j;
    }
  }else{

◆ pragmaVtabCursorClear()

static void pragmaVtabCursorClear ( PragmaVtabCursor * pCsr )

static

Definition at line 128166 of file sqlite3.c.

                                                         {
  int i;
  sqlite3_finalize(pCsr->pPragma);

◆ pragmaVtabDisconnect()

static int pragmaVtabDisconnect ( sqlite3_vtab * pVtab )

static

Definition at line 128105 of file sqlite3.c.

◆ pragmaVtabEof()

static int pragmaVtabEof ( sqlite3_vtab_cursor * pVtabCursor )

static

Definition at line 128253 of file sqlite3.c.

◆ pragmaVtabFilter()

static int pragmaVtabFilter	(	sqlite3_vtab_cursor *	pVtabCursor,
		int	idxNum,
		const char *	idxStr,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 128203 of file sqlite3.c.

 {
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
  int rc;
  int i, j;
  StrAccum acc;
  char *zSql;
 
  UNUSED_PARAMETER(idxNum);
  UNUSED_PARAMETER(idxStr);
  pragmaVtabCursorClear(pCsr);
  j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1;
  for(i=0; i<argc; i++, j++){
    const char *zText = (const char*)sqlite3_value_text(argv[i]);
    assert( j<ArraySize(pCsr->azArg) );
    assert( pCsr->azArg[j]==0 );
    if( zText ){
      pCsr->azArg[j] = sqlite3_mprintf("%s", zText);
      if( pCsr->azArg[j]==0 ){
        return SQLITE_NOMEM;
      }
    }
  }
  sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]);
  sqlite3_str_appendall(&acc, "PRAGMA ");
  if( pCsr->azArg[1] ){
    sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
  }
  sqlite3_str_appendall(&acc, pTab->pName->zName);
  if( pCsr->azArg[0] ){
    sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
  }
  zSql = sqlite3StrAccumFinish(&acc);
  if( zSql==0 ) return SQLITE_NOMEM;
  rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
  sqlite3_free(zSql);

◆ pragmaVtabNext()

static int pragmaVtabNext ( sqlite3_vtab_cursor * pVtabCursor )

static

Definition at line 128185 of file sqlite3.c.

                                                           {
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  int rc = SQLITE_OK;
 
  /* Increment the xRowid value */
  pCsr->iRowid++;
  assert( pCsr->pPragma );
  if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){

◆ pragmaVtabOpen()

static int pragmaVtabOpen	(	sqlite3_vtab *	pVtab,
		sqlite3_vtab_cursor **	ppCursor )

static

Definition at line 128155 of file sqlite3.c.

                                                                              {
  PragmaVtabCursor *pCsr;
  pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));

◆ pragmaVtabRowid()

static int pragmaVtabRowid	(	sqlite3_vtab_cursor *	pVtabCursor,
		sqlite_int64 *	p )

static

Definition at line 128279 of file sqlite3.c.

◆ preserveExpr()

static void preserveExpr	(	IdxExprTrans *	pTrans,
		Expr *	pExpr )

static

Definition at line 142639 of file sqlite3.c.

                                                           {
  WhereExprMod *pNew;
  pNew = sqlite3DbMallocRaw(pTrans->db, sizeof(*pNew));

Referenced by whereIndexExprTransNode().

◆ printfFunc()

static void printfFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117307 of file sqlite3.c.

 {
  PrintfArguments x;
  StrAccum str;
  const char *zFormat;
  int n;
  sqlite3 *db = sqlite3_context_db_handle(context);
 
  if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
    x.nArg = argc-1;
    x.nUsed = 0;
    x.apArg = argv+1;
    sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
    str.printfFlags = SQLITE_PRINTF_SQLFUNC;

Referenced by sqlite3RegisterBuiltinFunctions().

◆ printfTempBuf()

static char * printfTempBuf	(	sqlite3_str *	pAccum,
		sqlite3_int64	n )

static

Definition at line 28308 of file sqlite3.c.

                                                                {
  char *z;
  if( pAccum->accError ) return 0;
  if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){
    setStrAccumError(pAccum, SQLITE_TOOBIG);
    return 0;
  }

References sqlite3_str::accError, sqlite3_str::db, sqlite3_str::mxAlloc, sqlite3_str::nAlloc, setStrAccumError(), sqlite3DbMallocRaw(), SQLITE_NOMEM, and SQLITE_TOOBIG.

Referenced by sqlite3_str_vappendf().

◆ propagateConstantExprRewrite()

static int propagateConstantExprRewrite	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 133585 of file sqlite3.c.

                                                                     {
  int i;
  WhereConst *pConst;
  if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
  if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
    testcase( ExprHasProperty(pExpr, EP_FixedCol) );
    testcase( ExprHasProperty(pExpr, EP_FromJoin) );
    return WRC_Continue;
  }
  pConst = pWalker->u.pConst;
  for(i=0; i<pConst->nConst; i++){
    Expr *pColumn = pConst->apExpr[i*2];
    if( pColumn==pExpr ) continue;
    if( pColumn->iTable!=pExpr->iTable ) continue;
    if( pColumn->iColumn!=pExpr->iColumn ) continue;
    /* A match is found.  Add the EP_FixedCol property */
    pConst->nChng++;
    ExprClearProperty(pExpr, EP_Leaf);
    ExprSetProperty(pExpr, EP_FixedCol);

References WhereConst::apExpr, Parse::db, EP_FixedCol, EP_FromJoin, EP_Leaf, ExprClearProperty, ExprHasProperty, ExprSetProperty, Expr::iColumn, Expr::iTable, WhereConst::nChng, WhereConst::nConst, Expr::op, Walker::pConst, Expr::pLeft, WhereConst::pParse, sqlite3ExprDup(), testcase, TK_COLUMN, Walker::u, WRC_Continue, and WRC_Prune.

Referenced by propagateConstants().

◆ propagateConstants()

static int propagateConstants	(	Parse *	pParse,
		Select *	p )

static

Definition at line 133647 of file sqlite3.c.

 {
  WhereConst x;
  Walker w;
  int nChng = 0;
  x.pParse = pParse;
  do{
    x.nConst = 0;
    x.nChng = 0;
    x.apExpr = 0;
    findConstInWhere(&x, p->pWhere);
    if( x.nConst ){
      memset(&w, 0, sizeof(w));
      w.pParse = pParse;
      w.xExprCallback = propagateConstantExprRewrite;
      w.xSelectCallback = sqlite3SelectWalkNoop;
      w.xSelectCallback2 = 0;
      w.walkerDepth = 0;
      w.u.pConst = &x;
      sqlite3WalkExpr(&w, p->pWhere);

References WhereConst::apExpr, Parse::db, findConstInWhere(), WhereConst::nChng, WhereConst::nConst, Walker::pConst, Walker::pParse, WhereConst::pParse, propagateConstantExprRewrite(), Select::pWhere, sqlite3DbFree(), sqlite3SelectWalkNoop(), sqlite3WalkExpr(), Walker::u, Walker::walkerDepth, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3Select().

◆ pthreadMutexAlloc()

static sqlite3_mutex * pthreadMutexAlloc ( int iType )

static

Definition at line 26376 of file sqlite3.c.

                                                  {
  static sqlite3_mutex staticMutexes[] = {
    SQLITE3_MUTEX_INITIALIZER(2),
    SQLITE3_MUTEX_INITIALIZER(3),
    SQLITE3_MUTEX_INITIALIZER(4),
    SQLITE3_MUTEX_INITIALIZER(5),
    SQLITE3_MUTEX_INITIALIZER(6),
    SQLITE3_MUTEX_INITIALIZER(7),
    SQLITE3_MUTEX_INITIALIZER(8),
    SQLITE3_MUTEX_INITIALIZER(9),
    SQLITE3_MUTEX_INITIALIZER(10),
    SQLITE3_MUTEX_INITIALIZER(11),
    SQLITE3_MUTEX_INITIALIZER(12),
    SQLITE3_MUTEX_INITIALIZER(13)
  };
  sqlite3_mutex *p;
  switch( iType ){
    case SQLITE_MUTEX_RECURSIVE: {
      p = sqlite3MallocZero( sizeof(*p) );
      if( p ){
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
        /* If recursive mutexes are not available, we will have to
        ** build our own.  See below. */
        pthread_mutex_init(&p->mutex, 0);
#else
        /* Use a recursive mutex if it is available */
        pthread_mutexattr_t recursiveAttr;
        pthread_mutexattr_init(&recursiveAttr);
        pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&p->mutex, &recursiveAttr);
        pthread_mutexattr_destroy(&recursiveAttr);
#endif
#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
        p->id = SQLITE_MUTEX_RECURSIVE;
#endif
      }
      break;
    }
    case SQLITE_MUTEX_FAST: {
      p = sqlite3MallocZero( sizeof(*p) );
      if( p ){
        pthread_mutex_init(&p->mutex, 0);
#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
        p->id = SQLITE_MUTEX_FAST;
#endif
      }
      break;
    }
    default: {
#ifdef SQLITE_ENABLE_API_ARMOR
      if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){
        (void)SQLITE_MISUSE_BKPT;
        return 0;
      }
#endif
      p = &staticMutexes[iType-2];
      break;
    }
  }

References ArraySize, sqlite3_mutex::mutex, SQLITE3_MUTEX_INITIALIZER, sqlite3MallocZero(), SQLITE_MISUSE_BKPT, SQLITE_MUTEX_FAST, and SQLITE_MUTEX_RECURSIVE.

◆ pthreadMutexEnd()

static int pthreadMutexEnd ( void )

static

Definition at line 26326 of file sqlite3.c.

References SQLITE_OK.

◆ pthreadMutexEnter()

static void pthreadMutexEnter ( sqlite3_mutex * p )

static

Definition at line 26474 of file sqlite3.c.

                                               {
  assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
 
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
  /* If recursive mutexes are not available, then we have to grow
  ** our own.  This implementation assumes that pthread_equal()
  ** is atomic - that it cannot be deceived into thinking self
  ** and p->owner are equal if p->owner changes between two values
  ** that are not equal to self while the comparison is taking place.
  ** This implementation also assumes a coherent cache - that
  ** separate processes cannot read different values from the same
  ** address at the same time.  If either of these two conditions
  ** are not met, then the mutexes will fail and problems will result.
  */
  {
    pthread_t self = pthread_self();
    if( p->nRef>0 && pthread_equal(p->owner, self) ){
      p->nRef++;
    }else{
      pthread_mutex_lock(&p->mutex);
      assert( p->nRef==0 );
      p->owner = self;
      p->nRef = 1;
    }
  }
#else
  /* Use the built-in recursive mutexes if they are available.
  */
  pthread_mutex_lock(&p->mutex);
#if SQLITE_MUTEX_NREF
  assert( p->nRef>0 || p->owner==0 );
  p->owner = pthread_self();
  p->nRef++;
#endif
#endif
 
#ifdef SQLITE_DEBUG

References sqlite3_mutex::mutex, and SQLITE_MUTEX_RECURSIVE.

◆ pthreadMutexFree()

static void pthreadMutexFree ( sqlite3_mutex * p )

static

Definition at line 26447 of file sqlite3.c.

                                              {
  assert( p->nRef==0 );
#if SQLITE_ENABLE_API_ARMOR
  if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE )
#endif
  {
    pthread_mutex_destroy(&p->mutex);
    sqlite3_free(p);
  }
#ifdef SQLITE_ENABLE_API_ARMOR

References sqlite3_mutex::mutex, sqlite3_free(), SQLITE_MISUSE_BKPT, SQLITE_MUTEX_FAST, and SQLITE_MUTEX_RECURSIVE.

◆ pthreadMutexInit()

static int pthreadMutexInit ( void )

static

Definition at line 26325 of file sqlite3.c.

◆ pthreadMutexLeave()

static void pthreadMutexLeave ( sqlite3_mutex * p )

static

Definition at line 26573 of file sqlite3.c.

                                               {
  assert( pthreadMutexHeld(p) );
#if SQLITE_MUTEX_NREF
  p->nRef--;
  if( p->nRef==0 ) p->owner = 0;
#endif
  assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
 
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
  if( p->nRef==0 ){
    pthread_mutex_unlock(&p->mutex);
  }
#else
  pthread_mutex_unlock(&p->mutex);
#endif
 
#ifdef SQLITE_DEBUG

References sqlite3_mutex::mutex, and SQLITE_MUTEX_RECURSIVE.

◆ pthreadMutexTry()

static int pthreadMutexTry ( sqlite3_mutex * p )

static

Definition at line 26516 of file sqlite3.c.

                {
    printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
  }
#endif
}
static int pthreadMutexTry(sqlite3_mutex *p){
  int rc;
  assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
 
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
  /* If recursive mutexes are not available, then we have to grow
  ** our own.  This implementation assumes that pthread_equal()
  ** is atomic - that it cannot be deceived into thinking self
  ** and p->owner are equal if p->owner changes between two values
  ** that are not equal to self while the comparison is taking place.
  ** This implementation also assumes a coherent cache - that
  ** separate processes cannot read different values from the same
  ** address at the same time.  If either of these two conditions
  ** are not met, then the mutexes will fail and problems will result.
  */
  {
    pthread_t self = pthread_self();
    if( p->nRef>0 && pthread_equal(p->owner, self) ){
      p->nRef++;
      rc = SQLITE_OK;
    }else if( pthread_mutex_trylock(&p->mutex)==0 ){
      assert( p->nRef==0 );
      p->owner = self;
      p->nRef = 1;
      rc = SQLITE_OK;
    }else{
      rc = SQLITE_BUSY;
    }
  }
#else
  /* Use the built-in recursive mutexes if they are available.
  */
  if( pthread_mutex_trylock(&p->mutex)==0 ){
#if SQLITE_MUTEX_NREF
    p->owner = pthread_self();
    p->nRef++;
#endif
    rc = SQLITE_OK;
  }else{
    rc = SQLITE_BUSY;
  }
#endif
 
#ifdef SQLITE_DEBUG
  if( rc==SQLITE_OK && p->trace ){

References printf.

◆ ptrmapGet()

static int ptrmapGet	(	BtShared *	pBt,
		Pgno	key,
		u8 *	pEType,
		Pgno *	pPgno )

static

Definition at line 65522 of file sqlite3.c.

                                                                      {
  DbPage *pDbPage;   /* The pointer map page */
  int iPtrmap;       /* Pointer map page index */
  u8 *pPtrmap;       /* Pointer map page data */
  int offset;        /* Offset of entry in pointer map */
  int rc;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
 
  iPtrmap = PTRMAP_PAGENO(pBt, key);
  rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
  if( rc!=0 ){
    return rc;
  }
  pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
 
  offset = PTRMAP_PTROFFSET(iPtrmap, key);
  if( offset<0 ){
    sqlite3PagerUnref(pDbPage);
    return SQLITE_CORRUPT_BKPT;
  }
  assert( offset <= (int)pBt->usableSize-5 );
  assert( pEType!=0 );
  *pEType = pPtrmap[offset];

References get4byte, BtShared::mutex, BtShared::pPager, PTRMAP_PAGENO, PTRMAP_PTROFFSET, sqlite3_mutex_held(), sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerUnref(), SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PGNO, SQLITE_OK, and BtShared::usableSize.

Referenced by allocateBtreePage(), btreeCreateTable(), checkPtrmap(), getOverflowPage(), and incrVacuumStep().

◆ ptrmapPageno()

static Pgno ptrmapPageno	(	BtShared *	pBt,
		Pgno	pgno )

static

Definition at line 65439 of file sqlite3.c.

                                                  {
  int nPagesPerMapPage;
  Pgno iPtrMap, ret;
  assert( sqlite3_mutex_held(pBt->mutex) );
  if( pgno<2 ) return 0;
  nPagesPerMapPage = (pBt->usableSize/5)+1;
  iPtrMap = (pgno-2)/nPagesPerMapPage;

References BtShared::mutex, PENDING_BYTE_PAGE, sqlite3_mutex_held(), and BtShared::usableSize.

◆ ptrmapPut()

static void ptrmapPut	(	BtShared *	pBt,
		Pgno	key,
		u8	eType,
		Pgno	parent,
		int *	pRC )

static

Definition at line 65463 of file sqlite3.c.

                                                                               {
  DbPage *pDbPage;  /* The pointer map page */
  u8 *pPtrmap;      /* The pointer map data */
  Pgno iPtrmap;     /* The pointer map page number */
  int offset;       /* Offset in pointer map page */
  int rc;           /* Return code from subfunctions */
 
  if( *pRC ) return;
 
  assert( sqlite3_mutex_held(pBt->mutex) );
  /* The super-journal page number must never be used as a pointer map page */
  assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
 
  assert( pBt->autoVacuum );
  if( key==0 ){
    *pRC = SQLITE_CORRUPT_BKPT;
    return;
  }
  iPtrmap = PTRMAP_PAGENO(pBt, key);
  rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
  if( rc!=SQLITE_OK ){
    *pRC = rc;
    return;
  }
  if( ((char*)sqlite3PagerGetExtra(pDbPage))[0]!=0 ){
    /* The first byte of the extra data is the MemPage.isInit byte.
    ** If that byte is set, it means this page is also being used
    ** as a btree page. */
    *pRC = SQLITE_CORRUPT_BKPT;
    goto ptrmap_exit;
  }
  offset = PTRMAP_PTROFFSET(iPtrmap, key);
  if( offset<0 ){
    *pRC = SQLITE_CORRUPT_BKPT;
    goto ptrmap_exit;
  }
  assert( offset <= (int)pBt->usableSize-5 );
  pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
 
  if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
    TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
    *pRC= rc = sqlite3PagerWrite(pDbPage);
    if( rc==SQLITE_OK ){
      pPtrmap[offset] = eType;
      put4byte(&pPtrmap[offset+1], parent);

References BtShared::autoVacuum, eType, get4byte, BtShared::mutex, PENDING_BYTE_PAGE, BtShared::pPager, PTRMAP_ISPAGE, PTRMAP_PAGENO, PTRMAP_PTROFFSET, put4byte, sqlite3_mutex_held(), sqlite3PagerGet(), sqlite3PagerGetData(), sqlite3PagerGetExtra(), sqlite3PagerUnref(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_OK, TRACE, and BtShared::usableSize.

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), btreeCreateTable(), fillInCell(), freePage2(), ptrmapPutOvflPtr(), relocatePage(), and setChildPtrmaps().

◆ ptrmapPutOvflPtr()

static void ptrmapPutOvflPtr	(	MemPage *	pPage,
		MemPage *	pSrc,
		u8 *	pCell,
		int *	pRC )

static

Definition at line 65854 of file sqlite3.c.

                                                                               {
  CellInfo info;
  if( *pRC ) return;
  assert( pCell!=0 );
  pPage->xParseCell(pPage, pCell, &info);
  if( info.nLocal<info.nPayload ){
    Pgno ovfl;
    if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
      testcase( pSrc!=pPage );
      *pRC = SQLITE_CORRUPT_BKPT;

References MemPage::aDataEnd, get4byte, CellInfo::nLocal, CellInfo::nPayload, CellInfo::nSize, MemPage::pBt, MemPage::pgno, PTRMAP_OVERFLOW1, ptrmapPut(), SQLITE_CORRUPT_BKPT, SQLITE_WITHIN, testcase, and MemPage::xParseCell.

Referenced by balance_nonroot(), balance_quick(), insertCell(), and setChildPtrmaps().

◆ pushDownWhereTerms()

static int pushDownWhereTerms	(	Parse *	pParse,
		Select *	pSubq,
		Expr *	pWhere,
		int	iCursor,
		int	isLeftJoin )

static

Definition at line 133730 of file sqlite3.c.

 {
  Expr *pNew;
  int nChng = 0;
  Select *pSel;
  if( pWhere==0 ) return 0;
  if( pSubq->selFlags & SF_Recursive ) return 0;  /* restriction (2) */
 
#ifndef SQLITE_OMIT_WINDOWFUNC
  for(pSel=pSubq; pSel; pSel=pSel->pPrior){
    if( pSel->pWin ) return 0;    /* restriction (6) */
  }
#endif
 
#ifdef SQLITE_DEBUG
  /* Only the first term of a compound can have a WITH clause.  But make
  ** sure no other terms are marked SF_Recursive in case something changes
  ** in the future.
  */
  {
    Select *pX;
    for(pX=pSubq; pX; pX=pX->pPrior){
      assert( (pX->selFlags & (SF_Recursive))==0 );
    }
  }
#endif
 
  if( pSubq->pLimit!=0 ){
    return 0; /* restriction (3) */
  }
  while( pWhere->op==TK_AND ){
    nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight,
                                iCursor, isLeftJoin);
    pWhere = pWhere->pLeft;
  }
  if( isLeftJoin
   && (ExprHasProperty(pWhere,EP_FromJoin)==0
         || pWhere->iRightJoinTable!=iCursor)
  ){
    return 0; /* restriction (4) */
  }
  if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
    return 0; /* restriction (5) */
  }
  if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
    nChng++;
    while( pSubq ){
      SubstContext x;
      pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
      unsetJoinExpr(pNew, -1);
      x.pParse = pParse;
      x.iTable = iCursor;
      x.iNewTable = iCursor;
      x.isLeftJoin = 0;
      x.pEList = pSubq->pEList;
      pNew = substExpr(&x, pNew);
      if( pSubq->selFlags & SF_Aggregate ){
        pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
      }else{
        pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);

References Parse::db, EP_FromJoin, ExprHasProperty, SubstContext::iNewTable, Expr::iRightJoinTable, SubstContext::isLeftJoin, SubstContext::iTable, Expr::op, Select::pEList, SubstContext::pEList, Select::pHaving, Expr::pLeft, Select::pLimit, SubstContext::pParse, Select::pPrior, Expr::pRight, pushDownWhereTerms(), Select::pWhere, Select::pWin, Select::selFlags, SF_Aggregate, SF_Recursive, sqlite3ExprAnd(), sqlite3ExprDup(), sqlite3ExprIsTableConstant(), substExpr(), TK_AND, and unsetJoinExpr().

Referenced by pushDownWhereTerms(), and sqlite3Select().

◆ pushOntoSorter()

static void pushOntoSorter	(	Parse *	pParse,
		SortCtx *	pSort,
		Select *	pSelect,
		int	regData,
		int	regOrigData,
		int	nData,
		int	nPrefixReg )

static

Definition at line 129876 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;                         /* Stmt under construction */
  int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);
  int nExpr = pSort->pOrderBy->nExpr;              /* No. of ORDER BY terms */
  int nBase = nExpr + bSeq + nData;                /* Fields in sorter record */
  int regBase;                                     /* Regs for sorter record */
  int regRecord = 0;                               /* Assembled sorter record */
  int nOBSat = pSort->nOBSat;                      /* ORDER BY terms to skip */
  int op;                            /* Opcode to add sorter record to sorter */
  int iLimit;                        /* LIMIT counter */
  int iSkip = 0;                     /* End of the sorter insert loop */
 
  assert( bSeq==0 || bSeq==1 );
 
  /* Three cases:
  **   (1) The data to be sorted has already been packed into a Record
  **       by a prior OP_MakeRecord.  In this case nData==1 and regData
  **       will be completely unrelated to regOrigData.
  **   (2) All output columns are included in the sort record.  In that
  **       case regData==regOrigData.
  **   (3) Some output columns are omitted from the sort record due to
  **       the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the
  **       SQLITE_ECEL_OMITREF optimization, or due to the
  **       SortCtx.pDeferredRowLoad optimiation.  In any of these cases
  **       regOrigData is 0 to prevent this routine from trying to copy
  **       values that might not yet exist.
  */
  assert( nData==1 || regData==regOrigData || regOrigData==0 );
 
  if( nPrefixReg ){
    assert( nPrefixReg==nExpr+bSeq );
    regBase = regData - nPrefixReg;
  }else{
    regBase = pParse->nMem + 1;
    pParse->nMem += nBase;
  }
  assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
  iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
  pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
  sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
                          SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));
  if( bSeq ){
    sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
  }
  if( nPrefixReg==0 && nData>0 ){
    sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);
  }
  if( nOBSat>0 ){
    int regPrevKey;   /* The first nOBSat columns of the previous row */
    int addrFirst;    /* Address of the OP_IfNot opcode */
    int addrJmp;      /* Address of the OP_Jump opcode */
    VdbeOp *pOp;      /* Opcode that opens the sorter */
    int nKey;         /* Number of sorting key columns, including OP_Sequence */
    KeyInfo *pKI;     /* Original KeyInfo on the sorter table */
 
    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
    regPrevKey = pParse->nMem+1;
    pParse->nMem += pSort->nOBSat;
    nKey = nExpr - pSort->nOBSat + bSeq;
    if( bSeq ){
      addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
    }else{
      addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
    }
    VdbeCoverage(v);
    sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
    pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
    if( pParse->db->mallocFailed ) return;
    pOp->p2 = nKey + nData;
    pKI = pOp->p4.pKeyInfo;
    memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */
    sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
    testcase( pKI->nAllField > pKI->nKeyField+2 );
    pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
                                           pKI->nAllField-pKI->nKeyField-1);
    pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */
    addrJmp = sqlite3VdbeCurrentAddr(v);
    sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
    pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
    pSort->regReturn = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
    sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
    if( iLimit ){
      sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
      VdbeCoverage(v);
    }
    sqlite3VdbeJumpHere(v, addrFirst);
    sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
    sqlite3VdbeJumpHere(v, addrJmp);
  }
  if( iLimit ){
    /* At this point the values for the new sorter entry are stored
    ** in an array of registers. They need to be composed into a record
    ** and inserted into the sorter if either (a) there are currently
    ** less than LIMIT+OFFSET items or (b) the new record is smaller than
    ** the largest record currently in the sorter. If (b) is true and there
    ** are already LIMIT+OFFSET items in the sorter, delete the largest
    ** entry before inserting the new one. This way there are never more
    ** than LIMIT+OFFSET items in the sorter.
    **
    ** If the new record does not need to be inserted into the sorter,
    ** jump to the next iteration of the loop. If the pSort->labelOBLopt
    ** value is not zero, then it is a label of where to jump.  Otherwise,
    ** just bypass the row insert logic.  See the header comment on the
    ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
    */
    int iCsr = pSort->iECursor;
    sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
    VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
    iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
                                 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
    VdbeCoverage(v);
    sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
  }
  if( regRecord==0 ){
    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
  }
  if( pSort->sortFlags & SORTFLAG_UseSorter ){
    op = OP_SorterInsert;
  }else{
    op = OP_IdxInsert;
  }
  sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,

Referenced by selectInnerLoop().

◆ putVarint64()

static int SQLITE_NOINLINE putVarint64	(	unsigned char *	p,
		u64	v )

static

Definition at line 32093 of file sqlite3.c.

                                                               {
  int i, j, n;
  u8 buf[10];
  if( v & (((u64)0xff000000)<<32) ){
    p[8] = (u8)v;
    v >>= 8;
    for(i=7; i>=0; i--){
      p[i] = (u8)((v & 0x7f) | 0x80);
      v >>= 7;
    }
    return 9;
  }
  n = 0;
  do{
    buf[n++] = (u8)((v & 0x7f) | 0x80);
    v >>= 7;
  }while( v!=0 );
  buf[0] &= 0x7f;

◆ querySharedCacheTableLock()

static int querySharedCacheTableLock	(	Btree *	p,
		Pgno	iTab,
		u8	eLock )

static

Definition at line 64754 of file sqlite3.c.

                                                                   {
  BtShared *pBt = p->pBt;
  BtLock *pIter;
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
  assert( p->db!=0 );
  assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 );
 
  /* If requesting a write-lock, then the Btree must have an open write
  ** transaction on this file. And, obviously, for this to be so there
  ** must be an open write transaction on the file itself.
  */
  assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
  assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
 
  /* This routine is a no-op if the shared-cache is not enabled */
  if( !p->sharable ){
    return SQLITE_OK;
  }
 
  /* If some other connection is holding an exclusive lock, the
  ** requested lock may not be obtained.
  */
  if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
    sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
    return SQLITE_LOCKED_SHAREDCACHE;
  }
 
  for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
    /* The condition (pIter->eLock!=eLock) in the following if(...)
    ** statement is a simplification of:
    **
    **   (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
    **
    ** since we know that if eLock==WRITE_LOCK, then no other connection
    ** may hold a WRITE_LOCK on any table in this file (since there can
    ** only be a single writer).
    */
    assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
    assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
    if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
      sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
      if( eLock==WRITE_LOCK ){
        assert( p==pBt->pWriter );
        pBt->btsFlags |= BTS_PENDING;

References BTS_EXCLUSIVE, BTS_PENDING, BtShared::btsFlags, Btree::db, BtLock::eLock, sqlite3::flags, Btree::inTrans, BtShared::inTransaction, BtLock::iTable, Btree::pBt, BtLock::pBtree, BtShared::pLock, BtLock::pNext, BtShared::pWriter, READ_LOCK, Btree::sharable, sqlite3ConnectionBlocked, SQLITE_LOCKED_SHAREDCACHE, SQLITE_OK, SQLITE_ReadUncommit, TRANS_WRITE, and WRITE_LOCK.

Referenced by setSharedCacheTableLock(), sqlite3BtreeBeginTrans(), sqlite3BtreeGetMeta(), sqlite3BtreeLockTable(), and sqlite3BtreeSchemaLocked().

◆ quoteFunc()

static void quoteFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118079 of file sqlite3.c.

                                                                               {
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  switch( sqlite3_value_type(argv[0]) ){
    case SQLITE_FLOAT: {
      double r1, r2;
      char zBuf[50];
      r1 = sqlite3_value_double(argv[0]);
      sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
      sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8);
      if( r1!=r2 ){
        sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
      }
      sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
      break;
    }
    case SQLITE_INTEGER: {
      sqlite3_result_value(context, argv[0]);
      break;
    }
    case SQLITE_BLOB: {
      char *zText = 0;
      char const *zBlob = sqlite3_value_blob(argv[0]);
      int nBlob = sqlite3_value_bytes(argv[0]);
      assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
      zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);
      if( zText ){
        int i;
        for(i=0; i<nBlob; i++){
          zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
          zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
        }
        zText[(nBlob*2)+2] = '\'';
        zText[(nBlob*2)+3] = '\0';
        zText[0] = 'X';
        zText[1] = '\'';
        sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
        sqlite3_free(zText);
      }
      break;
    }
    case SQLITE_TEXT: {
      int i,j;
      u64 n;
      const unsigned char *zArg = sqlite3_value_text(argv[0]);
      char *z;
 
      if( zArg==0 ) return;
      for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
      z = contextMalloc(context, ((i64)i)+((i64)n)+3);
      if( z ){
        z[0] = '\'';
        for(i=0, j=1; zArg[i]; i++){
          z[j++] = zArg[i];
          if( zArg[i]=='\'' ){
            z[j++] = '\'';
          }
        }
        z[j++] = '\'';
        z[j] = 0;
        sqlite3_result_text(context, z, j, sqlite3_free);
      }
      break;
    }
    default: {

References contextMalloc(), hexdigits, sqlite3_free(), sqlite3_result_text(), sqlite3_result_value(), sqlite3_snprintf(), sqlite3_value_blob(), sqlite3_value_bytes(), sqlite3_value_double(), sqlite3_value_text(), sqlite3_value_type(), sqlite3AtoF(), SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_STATIC, SQLITE_TEXT, SQLITE_TRANSIENT, SQLITE_UTF8, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ randomBlob()

static void randomBlob	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117578 of file sqlite3.c.

 {
  sqlite3_int64 n;
  unsigned char *p;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  n = sqlite3_value_int64(argv[0]);
  if( n<1 ){
    n = 1;
  }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ randomFunc()

static void randomFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117552 of file sqlite3.c.

 {
  sqlite_int64 r;
  UNUSED_PARAMETER2(NotUsed, NotUsed2);
  sqlite3_randomness(sizeof(r), &r);
  if( r<0 ){
    /* We need to prevent a random number of 0x8000000000000000
    ** (or -9223372036854775808) since when you do abs() of that
    ** number of you get the same value back again.  To do this
    ** in a way that is testable, mask the sign bit off of negative
    ** values, resulting in a positive value.  Then take the
    ** 2s complement of that positive value.  The end result can

References LARGEST_INT64, sqlite3_randomness(), sqlite3_result_int64(), and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ rankStepFunc()

static void rankStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151456 of file sqlite3.c.

 {
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    p->nStep++;
    if( p->nValue==0 ){

References CallCount::nStep, CallCount::nValue, and sqlite3_aggregate_context().

◆ rankValueFunc()

static void rankValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151472 of file sqlite3.c.

151478 {

151479 struct CallCount *p;

◆ read32bits()

static int read32bits	(	sqlite3_file *	fd,
		i64	offset,
		u32 *	pRes )

static

Definition at line 52797 of file sqlite3.c.

52803 {

52804 unsigned char ac[4];

References sqlite3Get4byte(), sqlite3OsRead(), and SQLITE_OK.

Referenced by pager_playback_one_page(), readJournalHdr(), and readSuperJournal().

◆ readDbPage()

static int readDbPage ( PgHdr * pPg )

static

Definition at line 54651 of file sqlite3.c.

                                 {
  Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
  int rc = SQLITE_OK;          /* Return code */
 
#ifndef SQLITE_OMIT_WAL
  u32 iFrame = 0;              /* Frame of WAL containing pgno */
 
  assert( pPager->eState>=PAGER_READER && !MEMDB );
  assert( isOpen(pPager->fd) );
 
  if( pagerUseWal(pPager) ){
    rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
    if( rc ) return rc;
  }
  if( iFrame ){
    rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
  }else
#endif
  {
    i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
    rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
    if( rc==SQLITE_IOERR_SHORT_READ ){
      rc = SQLITE_OK;
    }
  }
 
  if( pPg->pgno==1 ){
    if( rc ){
      /* If the read is unsuccessful, set the dbFileVers[] to something
      ** that will never be a valid file version.  dbFileVers[] is a copy
      ** of bytes 24..39 of the database.  Bytes 28..31 should always be
      ** zero or the size of the database in page. Bytes 32..35 and 35..39
      ** should be page numbers which are never 0xffffffff.  So filling
      ** pPager->dbFileVers[] with all 0xff bytes should suffice.
      **
      ** For an encrypted database, the situation is more complex:  bytes
      ** 24..39 of the database are white noise.  But the probability of
      ** white noise equaling 16 bytes of 0xff is vanishingly small so
      ** we should still be ok.
      */
      memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
    }else{
      u8 *dbFileVers = &((u8*)pPg->pData)[24];
      memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
    }
  }
  PAGER_INCR(sqlite3_pager_readdb_count);
  PAGER_INCR(pPager->nRead);

References Pager::dbFileVers, Pager::eState, Pager::fd, IOTRACE, isOpen, MEMDB, PAGER_INCR, pager_pagehash, PAGER_READER, PAGERID, PAGERTRACE, pagerUseWal, Pager::pageSize, PgHdr::pData, PgHdr::pgno, PgHdr::pPager, Pager::pWal, sqlite3OsRead(), sqlite3WalFindFrame(), sqlite3WalReadFrame(), SQLITE_IOERR_SHORT_READ, and SQLITE_OK.

Referenced by getPageNormal(), and pagerUndoCallback().

◆ readJournalHdr()

static int readJournalHdr	(	Pager *	pPager,
		int	isHot,
		i64	journalSize,
		u32 *	pNRec,
		u32 *	pDbSize )

static

Definition at line 53254 of file sqlite3.c.

 {
  int rc;                      /* Return code */
  unsigned char aMagic[8];     /* A buffer to hold the magic header */
  i64 iHdrOff;                 /* Offset of journal header being read */
 
  assert( isOpen(pPager->jfd) );      /* Journal file must be open. */
 
  /* Advance Pager.journalOff to the start of the next sector. If the
  ** journal file is too small for there to be a header stored at this
  ** point, return SQLITE_DONE.
  */
  pPager->journalOff = journalHdrOffset(pPager);
  if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
    return SQLITE_DONE;
  }
  iHdrOff = pPager->journalOff;
 
  /* Read in the first 8 bytes of the journal header. If they do not match
  ** the  magic string found at the start of each journal header, return
  ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
  ** proceed.
  */
  if( isHot || iHdrOff!=pPager->journalHdr ){
    rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
    if( rc ){
      return rc;
    }
    if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
      return SQLITE_DONE;
    }
  }
 
  /* Read the first three 32-bit fields of the journal header: The nRec
  ** field, the checksum-initializer and the database size at the start
  ** of the transaction. Return an error code if anything goes wrong.
  */
  if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
   || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
   || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
  ){
    return rc;
  }
 
  if( pPager->journalOff==0 ){
    u32 iPageSize;               /* Page-size field of journal header */
    u32 iSectorSize;             /* Sector-size field of journal header */
 
    /* Read the page-size and sector-size journal header fields. */
    if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
     || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
    ){
      return rc;
    }
 
    /* Versions of SQLite prior to 3.5.8 set the page-size field of the
    ** journal header to zero. In this case, assume that the Pager.pageSize
    ** variable is already set to the correct page size.
    */
    if( iPageSize==0 ){
      iPageSize = pPager->pageSize;
    }
 
    /* Check that the values read from the page-size and sector-size fields
    ** are within range. To be 'in range', both values need to be a power
    ** of two greater than or equal to 512 or 32, and not greater than their
    ** respective compile time maximum limits.
    */
    if( iPageSize<512                  || iSectorSize<32
     || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
     || ((iPageSize-1)&iPageSize)!=0   || ((iSectorSize-1)&iSectorSize)!=0
    ){
      /* If the either the page-size or sector-size in the journal-header is
      ** invalid, then the process that wrote the journal-header must have
      ** crashed before the header was synced. In this case stop reading
      ** the journal file here.
      */
      return SQLITE_DONE;
    }
 
    /* Update the page-size to match the value read from the journal.
    ** Use a testcase() macro to make sure that malloc failure within
    ** PagerSetPagesize() is tested.
    */
    rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
    testcase( rc!=SQLITE_OK );
 
    /* Update the assumed sector-size to match the value used by
    ** the process that created this journal. If this journal was
    ** created by a process other than this one, then this routine
    ** is being called from within pager_playback(). The local value
    ** of Pager.sectorSize is restored at the end of that routine.
    */

References aJournalMagic, Pager::cksumInit, isOpen, Pager::jfd, JOURNAL_HDR_SZ, Pager::journalHdr, journalHdrOffset(), Pager::journalOff, MAX_SECTOR_SIZE, Pager::pageSize, read32bits(), Pager::sectorSize, sqlite3OsRead(), sqlite3PagerSetPagesize(), SQLITE_DONE, SQLITE_MAX_PAGE_SIZE, SQLITE_OK, and testcase.

Referenced by pager_playback(), and pagerPlaybackSavepoint().

◆ readsTable()

static int readsTable	(	Parse *	p,
		int	iDb,
		Table *	pTab )

static

Definition at line 120717 of file sqlite3.c.

                                                     {
  Vdbe *v = sqlite3GetVdbe(p);
  int i;
  int iEnd = sqlite3VdbeCurrentAddr(v);
#ifndef SQLITE_OMIT_VIRTUALTABLE
  VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
#endif
 
  for(i=1; i<iEnd; i++){
    VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
    assert( pOp!=0 );
    if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
      Index *pIndex;
      Pgno tnum = pOp->p2;
      if( tnum==pTab->tnum ){
        return 1;
      }
      for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
        if( tnum==pIndex->tnum ){
          return 1;
        }
      }
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
      assert( pOp->p4.pVtab!=0 );
      assert( pOp->p4type==P4_VTAB );

References Parse::db, IsVirtual, OP_OpenRead, OP_VOpen, VdbeOp::opcode, VdbeOp::p2, VdbeOp::p3, VdbeOp::p4, P4_VTAB, VdbeOp::p4type, Table::pIndex, Index::pNext, VdbeOp::p4union::pVtab, sqlite3GetVdbe(), sqlite3GetVTable(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), Table::tnum, and Index::tnum.

Referenced by sqlite3Insert().

◆ readSuperJournal()

static int readSuperJournal	(	sqlite3_file *	pJrnl,
		char *	zSuper,
		u32	nSuper )

static

Definition at line 52997 of file sqlite3.c.

                                                                          {
  int rc;                    /* Return code */
  u32 len;                   /* Length in bytes of super-journal name */
  i64 szJ;                   /* Total size in bytes of journal file pJrnl */
  u32 cksum;                 /* MJ checksum value read from journal */
  u32 u;                     /* Unsigned loop counter */
  unsigned char aMagic[8];   /* A buffer to hold the magic header */
  zSuper[0] = '\0';
 
  if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
   || szJ<16
   || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
   || len>=nSuper
   || len>szJ-16
   || len==0
   || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
   || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
   || memcmp(aMagic, aJournalMagic, 8)
   || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len))
  ){
    return rc;
  }
 
  /* See if the checksum matches the super-journal name */
  for(u=0; u<len; u++){
    cksum -= zSuper[u];
  }
  if( cksum ){
    /* If the checksum doesn't add up, then one or more of the disk sectors
    ** containing the super-journal filename is corrupted. This means
    ** definitely roll back, so just return SQLITE_OK and report a (nul)
    ** super-journal filename.
    */
    len = 0;

References aJournalMagic, read32bits(), sqlite3OsFileSize(), sqlite3OsRead(), and SQLITE_OK.

Referenced by pager_delsuper(), and pager_playback().

◆ rebuildPage()

static int rebuildPage	(	CellArray *	pCArray,
		int	iFirst,
		int	nCell,
		MemPage *	pPg )

static

Definition at line 71416 of file sqlite3.c.

 {
  const int hdr = pPg->hdrOffset;          /* Offset of header on pPg */
  u8 * const aData = pPg->aData;           /* Pointer to data for pPg */
  const int usableSize = pPg->pBt->usableSize;
  u8 * const pEnd = &aData[usableSize];
  int i = iFirst;                 /* Which cell to copy from pCArray*/
  u32 j;                          /* Start of cell content area */
  int iEnd = i+nCell;             /* Loop terminator */
  u8 *pCellptr = pPg->aCellIdx;
  u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
  u8 *pData;
  int k;                          /* Current slot in pCArray->apEnd[] */
  u8 *pSrcEnd;                    /* Current pCArray->apEnd[k] value */
 
  assert( i<iEnd );
  j = get2byte(&aData[hdr+5]);
  if( NEVER(j>(u32)usableSize) ){ j = 0; }
  memcpy(&pTmp[j], &aData[j], usableSize - j);
 
  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){}
  pSrcEnd = pCArray->apEnd[k];
 
  pData = pEnd;
  while( 1/*exit by break*/ ){
    u8 *pCell = pCArray->apCell[i];
    u16 sz = pCArray->szCell[i];
    assert( sz>0 );
    if( SQLITE_WITHIN(pCell,aData,pEnd) ){
      if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT;
      pCell = &pTmp[pCell - aData];
    }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd
           && (uptr)(pCell)<(uptr)pSrcEnd
    ){
      return SQLITE_CORRUPT_BKPT;
    }
 
    pData -= sz;
    put2byte(pCellptr, (pData - aData));
    pCellptr += 2;
    if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT;
    memcpy(pData, pCell, sz);
    assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
    testcase( sz!=pPg->xCellSize(pPg,pCell) )
    i++;
    if( i>=iEnd ) break;
    if( pCArray->ixNx[k]<=i ){
      k++;
      pSrcEnd = pCArray->apEnd[k];
    }
  }
 
  /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
  pPg->nCell = nCell;
  pPg->nOverflow = 0;
 

References MemPage::aCellIdx, MemPage::aData, ALWAYS, CellArray::apCell, CellArray::apEnd, CORRUPT_DB, get2byte, MemPage::hdrOffset, CellArray::ixNx, NB, MemPage::nCell, NEVER, MemPage::nOverflow, MemPage::pBt, BtShared::pPager, put2byte, sqlite3PagerTempSpace(), SQLITE_CORRUPT_BKPT, SQLITE_OK, SQLITE_WITHIN, CellArray::szCell, testcase, BtShared::usableSize, and MemPage::xCellSize.

Referenced by balance_quick(), and editPage().

◆ recomputeColumnsNotIndexed()

static void recomputeColumnsNotIndexed ( Index * pIdx )

static

Definition at line 112385 of file sqlite3.c.

                                                   {
  Bitmask m = 0;
  int j;
  Table *pTab = pIdx->pTable;
  for(j=pIdx->nColumn-1; j>=0; j--){
    int x = pIdx->aiColumn[j];
    if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
      testcase( x==BMS-1 );
      testcase( x==BMS-2 );

References Table::aCol, Index::aiColumn, BMS, COLFLAG_VIRTUAL, Column::colFlags, Index::colNotIdxed, MASKBIT, Index::nColumn, Index::pTable, and testcase.

Referenced by convertToWithoutRowidTable(), and sqlite3CreateIndex().

◆ recomputeColumnsUsed()

static void recomputeColumnsUsed	(	Select *	pSelect,
		struct SrcList_item *	pSrcItem )

static

Definition at line 132906 of file sqlite3.c.

 {
  Walker w;
  if( NEVER(pSrcItem->pTab==0) ) return;
  memset(&w, 0, sizeof(w));

Referenced by flattenSubquery().

◆ recomputeColumnsUsedExpr()

static int recomputeColumnsUsedExpr	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 132897 of file sqlite3.c.

                                                                 {
  struct SrcList_item *pItem;
  if( pExpr->op!=TK_COLUMN ) return WRC_Continue;

References Expr::op, TK_COLUMN, and WRC_Continue.

◆ rehash()

static int rehash	(	Hash *	pH,
		unsigned int	new_size )

static

Definition at line 32983 of file sqlite3.c.

                                                  {
  struct _ht *new_ht;            /* The new hash table */
  HashElem *elem, *next_elem;    /* For looping over existing elements */
 
#if SQLITE_MALLOC_SOFT_LIMIT>0
  if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
    new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
  }
  if( new_size==pH->htsize ) return 0;
#endif
 
  /* The inability to allocates space for a larger hash table is
  ** a performance hit but it is not a fatal error.  So mark the
  ** allocation as a benign. Use sqlite3Malloc()/memset(0) instead of
  ** sqlite3MallocZero() to make the allocation, as sqlite3MallocZero()
  ** only zeroes the requested number of bytes whereas this module will
  ** use the actual amount of space allocated for the hash table (which
  ** may be larger than the requested amount).
  */
  sqlite3BeginBenignMalloc();
  new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) );
  sqlite3EndBenignMalloc();
 
  if( new_ht==0 ) return 0;
  sqlite3_free(pH->ht);
  pH->ht = new_ht;
  pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
  memset(new_ht, 0, new_size*sizeof(struct _ht));
  for(elem=pH->first, pH->first=0; elem; elem = next_elem){

References Hash::first, Hash::ht, Hash::htsize, insertElement(), HashElem::next, HashElem::pKey, sqlite3_free(), sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), sqlite3Malloc(), sqlite3MallocSize(), SQLITE_MALLOC_SOFT_LIMIT, and strHash().

Referenced by sqlite3HashInsert().

◆ reindexDatabases()

static void reindexDatabases	(	Parse *	pParse,
		char const *	zColl )

static

Definition at line 115334 of file sqlite3.c.

                                                              {
  Db *pDb;                    /* A single database */
  int iDb;                    /* The database index number */
  sqlite3 *db = pParse->db;   /* The database connection */
  HashElem *k;                /* For looping over tables in pDb */
  Table *pTab;                /* A table in the database */
 
  assert( sqlite3BtreeHoldsAllMutexes(db) );  /* Needed for schema access */
  for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
    assert( pDb!=0 );

References sqlite3::aDb, Parse::db, sqlite3::nDb, Db::pSchema, reindexTable(), sqliteHashData, sqliteHashFirst, sqliteHashNext, and Schema::tblHash.

Referenced by sqlite3Reindex().

◆ reindexTable()

static void reindexTable	(	Parse *	pParse,
		Table *	pTab,
		char const *	zColl )

static

Definition at line 115313 of file sqlite3.c.

                                                                       {
  if( !IsVirtual(pTab) ){
    Index *pIndex;              /* An index associated with pTab */
 
    for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
      if( zColl==0 || collationMatch(zColl, pIndex) ){
        int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);

References collationMatch(), Parse::db, IsVirtual, Table::pIndex, Index::pNext, Table::pSchema, sqlite3BeginWriteOperation(), sqlite3RefillIndex(), and sqlite3SchemaToIndex().

Referenced by reindexDatabases(), and sqlite3Reindex().

◆ releaseAllSavepoints()

static void releaseAllSavepoints ( Pager * pPager )

static

Definition at line 53465 of file sqlite3.c.

                                               {
  int ii;               /* Iterator for looping through Pager.aSavepoint */
  for(ii=0; ii<pPager->nSavepoint; ii++){
    sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
  }
  if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
    sqlite3OsClose(pPager->sjfd);

References Pager::aSavepoint, Pager::exclusiveMode, Pager::nSavepoint, Pager::nSubRec, PagerSavepoint::pInSavepoint, Pager::sjfd, sqlite3_free(), sqlite3BitvecDestroy(), sqlite3JournalIsInMemory(), and sqlite3OsClose().

Referenced by pager_end_transaction(), and pager_unlock().

◆ releaseInodeInfo()

static void releaseInodeInfo ( unixFile * pFile )

static

Definition at line 34865 of file sqlite3.c.

                                             {
  unixInodeInfo *pInode = pFile->pInode;
  assert( unixMutexHeld() );
  assert( unixFileMutexNotheld(pFile) );
  if( ALWAYS(pInode) ){
    pInode->nRef--;
    if( pInode->nRef==0 ){
      assert( pInode->pShmNode==0 );
      sqlite3_mutex_enter(pInode->pLockMutex);
      closePendingFds(pFile);
      sqlite3_mutex_leave(pInode->pLockMutex);
      if( pInode->pPrev ){
        assert( pInode->pPrev->pNext==pInode );
        pInode->pPrev->pNext = pInode->pNext;
      }else{
        assert( inodeList==pInode );
        inodeList = pInode->pNext;
      }
      if( pInode->pNext ){
        assert( pInode->pNext->pPrev==pInode );
        pInode->pNext->pPrev = pInode->pPrev;

References ALWAYS, closePendingFds(), inodeList, unixInodeInfo::nRef, unixFile::pInode, unixInodeInfo::pLockMutex, unixInodeInfo::pNext, unixInodeInfo::pPrev, unixInodeInfo::pShmNode, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_free(), and sqlite3_mutex_leave().

◆ releaseMemArray()

static void releaseMemArray	(	Mem *	p,
		int	N )

static

Definition at line 79613 of file sqlite3.c.

                                          {
  if( p && N ){
    Mem *pEnd = &p[N];
    sqlite3 *db = p->db;
    if( db->pnBytesFreed ){
      do{
        if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
      }while( (++p)<pEnd );
      return;
    }
    do{
      assert( (&p[1])==pEnd || p[0].db==p[1].db );
      assert( sqlite3VdbeCheckMemInvariants(p) );
 
      /* This block is really an inlined version of sqlite3VdbeMemRelease()
      ** that takes advantage of the fact that the memory cell value is
      ** being set to NULL after releasing any dynamic resources.
      **
      ** The justification for duplicating code is that according to
      ** callgrind, this causes a certain test case to hit the CPU 4.7
      ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
      ** sqlite3MemRelease() were called from here. With -O2, this jumps
      ** to 6.6 percent. The test case is inserting 1000 rows into a table
      ** with no indexes using a single prepared INSERT statement, bind()
      ** and reset(). Inserts are grouped into a transaction.
      */
      testcase( p->flags & MEM_Agg );
      testcase( p->flags & MEM_Dyn );
      testcase( p->xDel==sqlite3VdbeFrameMemDel );
      if( p->flags&(MEM_Agg|MEM_Dyn) ){
        sqlite3VdbeMemRelease(p);
      }else if( p->szMalloc ){
        sqlite3DbFreeNN(db, p->zMalloc);
        p->szMalloc = 0;

Referenced by closeAllCursors(), sqlite3VdbeClearObject(), sqlite3VdbeFrameDelete(), sqlite3VdbeList(), and sqlite3VdbeSetNumCols().

◆ releasePage()

static void releasePage ( MemPage * pPage )

static

Definition at line 66707 of file sqlite3.c.

Referenced by allocateBtreePage(), balance(), balance_deeper(), balance_nonroot(), balance_quick(), btreeCreateTable(), btreeDropTable(), btreeGetUnusedPage(), checkTreePage(), fillInCell(), getAndInitPage(), getOverflowPage(), incrVacuumStep(), relocatePage(), and sqlite3BtreeDelete().

◆ releasePageNotNull()

static void releasePageNotNull ( MemPage * pPage )

static

Definition at line 66698 of file sqlite3.c.

                                              {
  assert( pPage->aData );
  assert( pPage->pBt );

References MemPage::aData, and MemPage::pBt.

Referenced by moveToParent(), moveToRoot(), and sqlite3BtreeDelete().

◆ releasePageOne()

static void releasePageOne ( MemPage * pPage )

static

Definition at line 66710 of file sqlite3.c.

                                       {
  if( pPage ) releasePageNotNull(pPage);
}
static void releasePageOne(MemPage *pPage){
  assert( pPage!=0 );
  assert( pPage->aData );
  assert( pPage->pBt );

Referenced by lockBtree(), sqlite3BtreeRollback(), and unlockBtreeIfUnused().

◆ relocatePage()

static int relocatePage	(	BtShared *	pBt,
		MemPage *	pDbPage,
		u8	eType,
		Pgno	iPtrPage,
		Pgno	iFreePage,
		int	isCommit )

static

Definition at line 68136 of file sqlite3.c.

 {
  MemPage *pPtrPage;   /* The page that contains a pointer to pDbPage */
  Pgno iDbPage = pDbPage->pgno;
  Pager *pPager = pBt->pPager;
  int rc;
 
  assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
      eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( pDbPage->pBt==pBt );
  if( iDbPage<3 ) return SQLITE_CORRUPT_BKPT;
 
  /* Move page iDbPage from its current location to page number iFreePage */
  TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
      iDbPage, iFreePage, iPtrPage, eType));
  rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  pDbPage->pgno = iFreePage;
 
  /* If pDbPage was a btree-page, then it may have child pages and/or cells
  ** that point to overflow pages. The pointer map entries for all these
  ** pages need to be changed.
  **
  ** If pDbPage is an overflow page, then the first 4 bytes may store a
  ** pointer to a subsequent overflow page. If this is the case, then
  ** the pointer map needs to be updated for the subsequent overflow page.
  */
  if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
    rc = setChildPtrmaps(pDbPage);
    if( rc!=SQLITE_OK ){
      return rc;
    }
  }else{
    Pgno nextOvfl = get4byte(pDbPage->aData);
    if( nextOvfl!=0 ){
      ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
      if( rc!=SQLITE_OK ){
        return rc;
      }
    }
  }
 
  /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
  ** that it points at iFreePage. Also fix the pointer map entry for
  ** iPtrPage.
  */
  if( eType!=PTRMAP_ROOTPAGE ){
    rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    rc = sqlite3PagerWrite(pPtrPage->pDbPage);
    if( rc!=SQLITE_OK ){
      releasePage(pPtrPage);
      return rc;
    }
    rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
    releasePage(pPtrPage);

References MemPage::aData, btreeGetPage(), eType, get4byte, modifyPagePointer(), BtShared::mutex, MemPage::pBt, MemPage::pDbPage, MemPage::pgno, BtShared::pPager, PTRMAP_BTREE, PTRMAP_OVERFLOW1, PTRMAP_OVERFLOW2, PTRMAP_ROOTPAGE, ptrmapPut(), releasePage(), setChildPtrmaps(), sqlite3_mutex_held(), sqlite3PagerMovepage(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_OK, and TRACE.

Referenced by btreeCreateTable(), btreeDropTable(), and incrVacuumStep().

◆ removeElementGivenHash()

static void removeElementGivenHash	(	Hash *	pH,
		HashElem *	elem,
		unsigned int	h )

static

Definition at line 33059 of file sqlite3.c.

 {
  struct _ht *pEntry;
  if( elem->prev ){
    elem->prev->next = elem->next;
  }else{
    pH->first = elem->next;
  }
  if( elem->next ){
    elem->next->prev = elem->prev;
  }
  if( pH->ht ){
    pEntry = &pH->ht[h];
    if( pEntry->chain==elem ){
      pEntry->chain = elem->next;
    }
    assert( pEntry->count>0 );
    pEntry->count--;
  }
  sqlite3_free( elem );
  pH->count--;

Referenced by sqlite3HashInsert().

◆ removeFromSharingList()

static int removeFromSharingList ( BtShared * pBt )

static

Definition at line 67107 of file sqlite3.c.

                                               {
#ifndef SQLITE_OMIT_SHARED_CACHE
  MUTEX_LOGIC( sqlite3_mutex *pMainMtx; )
  BtShared *pList;
  int removed = 0;
 
  assert( sqlite3_mutex_notheld(pBt->mutex) );
  MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(pMainMtx);
  pBt->nRef--;
  if( pBt->nRef<=0 ){
    if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
      GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
    }else{
      pList = GLOBAL(BtShared*,sqlite3SharedCacheList);
      while( ALWAYS(pList) && pList->pNext!=pBt ){
        pList=pList->pNext;
      }
      if( ALWAYS(pList) ){
        pList->pNext = pBt->pNext;
      }
    }
    if( SQLITE_THREADSAFE ){
      sqlite3_mutex_free(pBt->mutex);
    }
    removed = 1;
  }

References ALWAYS, GLOBAL, BtShared::mutex, MUTEX_LOGIC, BtShared::nRef, BtShared::pNext, sqlite3_mutex_enter(), sqlite3_mutex_free(), sqlite3_mutex_leave(), sqlite3_mutex_notheld(), sqlite3MutexAlloc(), sqlite3SharedCacheList, SQLITE_MUTEX_STATIC_MAIN, and SQLITE_THREADSAFE.

◆ removeUnindexableInClauseTerms()

static Expr * removeUnindexableInClauseTerms	(	Parse *	pParse,
		int	iEq,
		WhereLoop *	pLoop,
		Expr *	pX )

static

Definition at line 141927 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  Expr *pNew;
  pNew = sqlite3ExprDup(db, pX, 0);
  if( db->mallocFailed==0 ){
    ExprList *pOrigRhs = pNew->x.pSelect->pEList;  /* Original unmodified RHS */
    ExprList *pOrigLhs = pNew->pLeft->x.pList;     /* Original unmodified LHS */
    ExprList *pRhs = 0;         /* New RHS after modifications */
    ExprList *pLhs = 0;         /* New LHS after mods */
    int i;                      /* Loop counter */
    Select *pSelect;            /* Pointer to the SELECT on the RHS */
 
    for(i=iEq; i<pLoop->nLTerm; i++){
      if( pLoop->aLTerm[i]->pExpr==pX ){
        int iField = pLoop->aLTerm[i]->iField - 1;
        if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
        pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
        pOrigRhs->a[iField].pExpr = 0;
        assert( pOrigLhs->a[iField].pExpr!=0 );
        pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr);
        pOrigLhs->a[iField].pExpr = 0;
      }
    }
    sqlite3ExprListDelete(db, pOrigRhs);
    sqlite3ExprListDelete(db, pOrigLhs);
    pNew->pLeft->x.pList = pLhs;
    pNew->x.pSelect->pEList = pRhs;
    if( pLhs && pLhs->nExpr==1 ){
      /* Take care here not to generate a TK_VECTOR containing only a
      ** single value. Since the parser never creates such a vector, some
      ** of the subroutines do not handle this case.  */
      Expr *p = pLhs->a[0].pExpr;
      pLhs->a[0].pExpr = 0;
      sqlite3ExprDelete(db, pNew->pLeft);
      pNew->pLeft = p;
    }
    pSelect = pNew->x.pSelect;
    if( pSelect->pOrderBy ){
      /* If the SELECT statement has an ORDER BY clause, zero the
      ** iOrderByCol variables. These are set to non-zero when an
      ** ORDER BY term exactly matches one of the terms of the
      ** result-set. Since the result-set of the SELECT statement may
      ** have been modified or reordered, these variables are no longer
      ** set correctly.  Since setting them is just an optimization,
      ** it's easiest just to zero them here.  */
      ExprList *pOrderBy = pSelect->pOrderBy;
      for(i=0; i<pOrderBy->nExpr; i++){
        pOrderBy->a[i].u.x.iOrderByCol = 0;
      }
    }
 
#if 0
    printf("For indexing, change the IN expr:\n");
    sqlite3TreeViewExpr(0, pX, 0);

References ExprList::a, WhereLoop::aLTerm, Parse::db, WhereTerm::iField, ExprList::ExprList_item::iOrderByCol, sqlite3::mallocFailed, ExprList::nExpr, WhereLoop::nLTerm, Select::pEList, ExprList::ExprList_item::pExpr, WhereTerm::pExpr, Expr::pLeft, Expr::pList, Select::pOrderBy, printf, Expr::pSelect, sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListDelete(), ExprList::ExprList_item::u, Expr::x, and ExprList::ExprList_item::x.

Referenced by codeEqualityTerm().

◆ renameColumnElistNames()

static void renameColumnElistNames	(	Parse *	pParse,
		RenameCtx *	pCtx,
		ExprList *	pEList,
		const char *	zOld )

static

Definition at line 106772 of file sqlite3.c.

 {
  if( pEList ){
    int i;
    for(i=0; i<pEList->nExpr; i++){
      char *zName = pEList->a[i].zEName;
      if( ALWAYS(pEList->a[i].eEName==ENAME_NAME)
       && ALWAYS(zName!=0)
       && 0==sqlite3_stricmp(zName, zOld)

References ExprList::a, ALWAYS, ExprList::ExprList_item::eEName, ENAME_NAME, ExprList::nExpr, renameTokenFind(), sqlite3_stricmp(), ExprList::ExprList_item::zEName, and zName.

Referenced by renameColumnFunc().

◆ renameColumnExprCb()

static int renameColumnExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 106701 of file sqlite3.c.

                                                           {
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_TRIGGER
   && pExpr->iColumn==p->iCol
   && pWalker->pParse->pTriggerTab==p->pTab
  ){
    renameTokenFind(pWalker->pParse, p, (void*)pExpr);
  }else if( pExpr->op==TK_COLUMN
   && pExpr->iColumn==p->iCol

References RenameCtx::iCol, Expr::iColumn, Expr::op, Walker::pParse, Walker::pRename, Expr::pTab, RenameCtx::pTab, Parse::pTriggerTab, renameTokenFind(), TK_COLUMN, TK_TRIGGER, Walker::u, WRC_Continue, and Expr::y.

Referenced by renameColumnFunc().

◆ renameColumnFunc()

static void renameColumnFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 107107 of file sqlite3.c.

 {
  sqlite3 *db = sqlite3_context_db_handle(context);
  RenameCtx sCtx;
  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
  const char *zDb = (const char*)sqlite3_value_text(argv[3]);
  const char *zTable = (const char*)sqlite3_value_text(argv[4]);
  int iCol = sqlite3_value_int(argv[5]);
  const char *zNew = (const char*)sqlite3_value_text(argv[6]);
  int bQuote = sqlite3_value_int(argv[7]);
  int bTemp = sqlite3_value_int(argv[8]);
  const char *zOld;
  int rc;
  Parse sParse;
  Walker sWalker;
  Index *pIdx;
  int i;
  Table *pTab;
#ifndef SQLITE_OMIT_AUTHORIZATION
  sqlite3_xauth xAuth = db->xAuth;
#endif
 
  UNUSED_PARAMETER(NotUsed);
  if( zSql==0 ) return;
  if( zTable==0 ) return;
  if( zNew==0 ) return;
  if( iCol<0 ) return;
  sqlite3BtreeEnterAll(db);
  pTab = sqlite3FindTable(db, zTable, zDb);
  if( pTab==0 || iCol>=pTab->nCol ){
    sqlite3BtreeLeaveAll(db);
    return;
  }
  zOld = pTab->aCol[iCol].zName;
  memset(&sCtx, 0, sizeof(sCtx));
  sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  db->xAuth = 0;
#endif
  rc = renameParseSql(&sParse, zDb, db, zSql, bTemp);
 
  /* Find tokens that need to be replaced. */
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = &sParse;
  sWalker.xExprCallback = renameColumnExprCb;
  sWalker.xSelectCallback = renameColumnSelectCb;
  sWalker.u.pRename = &sCtx;
 
  sCtx.pTab = pTab;
  if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
  if( sParse.pNewTable ){
    Select *pSelect = sParse.pNewTable->pSelect;
    if( pSelect ){
      pSelect->selFlags &= ~SF_View;
      sParse.rc = SQLITE_OK;
      sqlite3SelectPrep(&sParse, pSelect, 0);
      rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc);
      if( rc==SQLITE_OK ){
        sqlite3WalkSelect(&sWalker, pSelect);
      }
      if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
    }else{
      /* A regular table */
      int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
      FKey *pFKey;
      assert( sParse.pNewTable->pSelect==0 );
      sCtx.pTab = sParse.pNewTable;
      if( bFKOnly==0 ){
        renameTokenFind(
            &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName
        );
        if( sCtx.iCol<0 ){
          renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey);
        }
        sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck);
        for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){
          sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
        }
        for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
          sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
        }
      }
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
      for(i=0; i<sParse.pNewTable->nCol; i++){
        sqlite3WalkExpr(&sWalker, sParse.pNewTable->aCol[i].pDflt);
      }
#endif
 
      for(pFKey=sParse.pNewTable->pFKey; pFKey; pFKey=pFKey->pNextFrom){
        for(i=0; i<pFKey->nCol; i++){
          if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
            renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]);
          }
          if( 0==sqlite3_stricmp(pFKey->zTo, zTable)
           && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld)
          ){
            renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol);
          }
        }
      }
    }
  }else if( sParse.pNewIndex ){
    sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr);
    sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
  }else{
    /* A trigger */
    TriggerStep *pStep;
    rc = renameResolveTrigger(&sParse);
    if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
 
    for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){
      if( pStep->zTarget ){
        Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb);
        if( pTarget==pTab ){
          if( pStep->pUpsert ){
            ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet;
            renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld);
          }
          renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld);
          renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld);
        }
      }
    }
 
 
    /* Find tokens to edit in UPDATE OF clause */
    if( sParse.pTriggerTab==pTab ){
      renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld);
    }
 
    /* Find tokens to edit in various expressions and selects */
    renameWalkTrigger(&sWalker, sParse.pNewTrigger);
  }
 
  assert( rc==SQLITE_OK );
  rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote);
 
renameColumnFunc_done:
  if( rc!=SQLITE_OK ){
    if( sParse.zErrMsg ){
      renameColumnParseError(context, 0, argv[1], argv[2], &sParse);
    }else{
      sqlite3_result_error_code(context, rc);
    }
  }
 
  renameParseCleanup(&sParse);

References Table::aCol, FKey::aCol, Index::aColExpr, RenameCtx::iCol, FKey::sColMap::iFrom, Table::iPKey, sqlite3::mallocFailed, Table::nCol, FKey::nCol, Table::pCheck, Trigger::pColumns, Column::pDflt, TriggerStep::pExprList, Table::pFKey, TriggerStep::pIdList, Table::pIndex, RenameCtx::pList, Parse::pNewIndex, Parse::pNewTable, Parse::pNewTrigger, Index::pNext, TriggerStep::pNext, FKey::pNextFrom, Walker::pParse, Index::pPartIdxWhere, Walker::pRename, Table::pSelect, RenameCtx::pTab, Parse::pTriggerTab, TriggerStep::pUpsert, Upsert::pUpsertSet, Parse::rc, renameColumnElistNames(), renameColumnExprCb(), renameColumnIdlistNames(), renameColumnParseError(), renameColumnSelectCb(), renameEditSql(), renameParseCleanup(), renameParseSql(), renameResolveTrigger(), renameTokenFind(), renameTokenFree(), renameWalkTrigger(), Select::selFlags, sqlite3_context_db_handle(), sqlite3_result_error_code(), sqlite3_stricmp(), sqlite3_value_int(), sqlite3_value_text(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3FindTable(), sqlite3LocateTable(), sqlite3SelectPrep(), sqlite3WalkExpr(), sqlite3WalkExprList(), sqlite3WalkSelect(), SQLITE_NOMEM, SQLITE_OK, Trigger::step_list, Walker::u, UNUSED_PARAMETER, sqlite3::xAuth, Walker::xExprCallback, Walker::xSelectCallback, FKey::sColMap::zCol, Parse::zErrMsg, Column::zName, Table::zName, TriggerStep::zTarget, and FKey::zTo.

◆ renameColumnIdlistNames()

static void renameColumnIdlistNames	(	Parse *	pParse,
		RenameCtx *	pCtx,
		IdList *	pIdList,
		const char *	zOld )

static

Definition at line 106797 of file sqlite3.c.

 {
  if( pIdList ){
    int i;
    for(i=0; i<pIdList->nId; i++){
      char *zName = pIdList->a[i].zName;

References IdList::a, IdList::nId, renameTokenFind(), sqlite3_stricmp(), IdList::IdList_item::zName, and zName.

Referenced by renameColumnFunc().

◆ renameColumnParseError()

static void renameColumnParseError	(	sqlite3_context *	pCtx,
		int	bPost,
		sqlite3_value *	pType,
		sqlite3_value *	pObject,
		Parse *	pParse )

static

Definition at line 106747 of file sqlite3.c.

 {
  const char *zT = (const char*)sqlite3_value_text(pType);
  const char *zN = (const char*)sqlite3_value_text(pObject);
  char *zErr;
 
  zErr = sqlite3_mprintf("error in %s %s%s: %s",

References sqlite3_free(), sqlite3_mprintf(), sqlite3_result_error(), sqlite3_value_text(), and Parse::zErrMsg.

Referenced by renameColumnFunc(), renameTableFunc(), and renameTableTest().

◆ renameColumnSelectCb()

static int renameColumnSelectCb	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 106686 of file sqlite3.c.

References renameWalkWith(), Select::selFlags, SF_View, WRC_Continue, and WRC_Prune.

Referenced by renameColumnFunc().

◆ renameColumnTokenNext()

static RenameToken * renameColumnTokenNext ( RenameCtx * pCtx )

static

Definition at line 106726 of file sqlite3.c.

                                                          {
  RenameToken *pBest = pCtx->pList;
  RenameToken *pToken;
  RenameToken **pp;
 
  for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){
    if( pToken->t.z>pBest->t.z ) pBest = pToken;

References RenameCtx::pList, RenameToken::pNext, RenameToken::t, and Token::z.

Referenced by renameEditSql().

◆ renameEditSql()

static int renameEditSql	(	sqlite3_context *	pCtx,
		RenameCtx *	pRename,
		const char *	zSql,
		const char *	zNew,
		int	bQuote )

static

Definition at line 106874 of file sqlite3.c.

 {
  int nNew = sqlite3Strlen30(zNew);
  int nSql = sqlite3Strlen30(zSql);
  sqlite3 *db = sqlite3_context_db_handle(pCtx);
  int rc = SQLITE_OK;
  char *zQuot;
  char *zOut;
  int nQuot;
 
  /* Set zQuot to point to a buffer containing a quoted copy of the
  ** identifier zNew. If the corresponding identifier in the original
  ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to
  ** point to zQuot so that all substitutions are made using the
  ** quoted version of the new column name.  */
  zQuot = sqlite3MPrintf(db, "\"%w\"", zNew);
  if( zQuot==0 ){
    return SQLITE_NOMEM;
  }else{
    nQuot = sqlite3Strlen30(zQuot);
  }
  if( bQuote ){
    zNew = zQuot;
    nNew = nQuot;
  }
 
  /* At this point pRename->pList contains a list of RenameToken objects
  ** corresponding to all tokens in the input SQL that must be replaced
  ** with the new column name. All that remains is to construct and
  ** return the edited SQL string. */
  assert( nQuot>=nNew );
  zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
  if( zOut ){
    int nOut = nSql;
    memcpy(zOut, zSql, nSql);
    while( pRename->pList ){
      int iOff;                   /* Offset of token to replace in zOut */
      RenameToken *pBest = renameColumnTokenNext(pRename);
 
      u32 nReplace;
      const char *zReplace;
      if( sqlite3IsIdChar(*pBest->t.z) ){
        nReplace = nNew;
        zReplace = zNew;
      }else{
        nReplace = nQuot;
        zReplace = zQuot;
      }
 
      iOff = pBest->t.z - zSql;
      if( pBest->t.n!=nReplace ){
        memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n],
            nOut - (iOff + pBest->t.n)
        );
        nOut += nReplace - pBest->t.n;
        zOut[nOut] = '\0';
      }
      memcpy(&zOut[iOff], zReplace, nReplace);
      sqlite3DbFree(db, pBest);
    }
 
    sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
    sqlite3DbFree(db, zOut);
  }else{

References Token::n, RenameCtx::nList, RenameCtx::pList, renameColumnTokenNext(), sqlite3_context_db_handle(), sqlite3_free(), sqlite3_result_text(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3IsIdChar(), sqlite3MPrintf(), sqlite3Strlen30(), SQLITE_NOMEM, SQLITE_OK, SQLITE_TRANSIENT, RenameToken::t, and Token::z.

Referenced by renameColumnFunc(), and renameTableFunc().

◆ renameParseCleanup()

static void renameParseCleanup ( Parse * pParse )

static

Definition at line 107067 of file sqlite3.c.

                                             {
  sqlite3 *db = pParse->db;
  Index *pIdx;
  if( pParse->pVdbe ){
    sqlite3VdbeFinalize(pParse->pVdbe);
  }
  sqlite3DeleteTable(db, pParse->pNewTable);
  while( (pIdx = pParse->pNewIndex)!=0 ){
    pParse->pNewIndex = pIdx->pNext;
    sqlite3FreeIndex(db, pIdx);

Referenced by renameColumnFunc(), renameTableFunc(), and renameTableTest().

◆ renameParseSql()

static int renameParseSql	(	Parse *	p,
		const char *	zDb,
		sqlite3 *	db,
		const char *	zSql,
		int	bTemp )

static

Definition at line 106819 of file sqlite3.c.

 {
  int rc;
  char *zErr = 0;
 
  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
 
  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
  memset(p, 0, sizeof(Parse));
  p->eParseMode = PARSE_MODE_RENAME;
  p->db = db;
  p->nQueryLoop = 1;
  rc = sqlite3RunParser(p, zSql, &zErr);
  assert( p->zErrMsg==0 );
  assert( rc!=SQLITE_OK || zErr==0 );
  p->zErrMsg = zErr;
  if( db->mallocFailed ) rc = SQLITE_NOMEM;
  if( rc==SQLITE_OK
   && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0
  ){
    rc = SQLITE_CORRUPT_BKPT;
  }
 
#ifdef SQLITE_DEBUG
  /* Ensure that all mappings in the Parse.pRename list really do map to
  ** a part of the input string.  */
  if( rc==SQLITE_OK ){
    int nSql = sqlite3Strlen30(zSql);
    RenameToken *pToken;
    for(pToken=p->pRename; pToken; pToken=pToken->pNext){
      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
    }

References Parse::db, Parse::eParseMode, sqlite3::sqlite3InitInfo::iDb, sqlite3::init, sqlite3::mallocFailed, Token::n, Parse::nQueryLoop, PARSE_MODE_RENAME, Parse::pNewIndex, Parse::pNewTable, Parse::pNewTrigger, RenameToken::pNext, Parse::pRename, sqlite3FindDbName(), sqlite3RunParser(), sqlite3Strlen30(), SQLITE_CORRUPT_BKPT, SQLITE_NOMEM, SQLITE_OK, RenameToken::t, Token::z, and Parse::zErrMsg.

Referenced by renameColumnFunc(), renameTableFunc(), and renameTableTest().

◆ renameReloadSchema()

static void renameReloadSchema	(	Parse *	pParse,
		int	iDb )

static

Definition at line 105872 of file sqlite3.c.

105878 {

105879 Vdbe *v = pParse->pVdbe;

Referenced by sqlite3AlterFinishAddColumn(), and sqlite3AlterRenameColumn().

◆ renameResolveTrigger()

static int renameResolveTrigger ( Parse * pParse )

static

Definition at line 106956 of file sqlite3.c.

                                              {
  sqlite3 *db = pParse->db;
  Trigger *pNew = pParse->pNewTrigger;
  TriggerStep *pStep;
  NameContext sNC;
  int rc = SQLITE_OK;
 
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pParse;
  assert( pNew->pTabSchema );
  pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
      db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName
  );
  pParse->eTriggerOp = pNew->op;
  /* ALWAYS() because if the table of the trigger does not exist, the
  ** error would have been hit before this point */
  if( ALWAYS(pParse->pTriggerTab) ){
    rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab);
  }
 
  /* Resolve symbols in WHEN clause */
  if( rc==SQLITE_OK && pNew->pWhen ){
    rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen);
  }
 
  for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
    if( pStep->pSelect ){
      sqlite3SelectPrep(pParse, pStep->pSelect, &sNC);
      if( pParse->nErr ) rc = pParse->rc;
    }
    if( rc==SQLITE_OK && pStep->zTarget ){
      SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep);
      if( pSrc ){
        int i;
        for(i=0; i<pSrc->nSrc && rc==SQLITE_OK; i++){
          struct SrcList_item *p = &pSrc->a[i];
          p->pTab = sqlite3LocateTableItem(pParse, 0, p);
          p->iCursor = pParse->nTab++;
          if( p->pTab==0 ){
            rc = SQLITE_ERROR;
          }else{
            p->pTab->nTabRef++;
            rc = sqlite3ViewGetColumnNames(pParse, p->pTab);
          }
        }
        sNC.pSrcList = pSrc;
        if( rc==SQLITE_OK && pStep->pWhere ){
          rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere);
        }
        if( rc==SQLITE_OK ){
          rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList);
        }
        assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) );
        if( pStep->pUpsert ){
          Upsert *pUpsert = pStep->pUpsert;
          assert( rc==SQLITE_OK );
          pUpsert->pUpsertSrc = pSrc;
          sNC.uNC.pUpsert = pUpsert;
          sNC.ncFlags = NC_UUpsert;
          rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
          if( rc==SQLITE_OK ){
            ExprList *pUpsertSet = pUpsert->pUpsertSet;
            rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet);
          }
          if( rc==SQLITE_OK ){
            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere);
          }
          if( rc==SQLITE_OK ){
            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
          }
          sNC.ncFlags = 0;
        }
        sNC.pSrcList = 0;
        sqlite3SrcListDelete(db, pSrc);
      }else{

References SrcList::a, sqlite3::aDb, ALWAYS, Parse::db, Parse::eTriggerOp, NC_UUpsert, NameContext::ncFlags, Parse::nErr, SrcList::nSrc, Parse::nTab, Trigger::op, TriggerStep::pExprList, Parse::pNewTrigger, TriggerStep::pNext, NameContext::pParse, TriggerStep::pSelect, NameContext::pSrcList, SrcList::SrcList_item::pTab, Trigger::pTabSchema, Parse::pTriggerTab, NameContext::pUpsert, TriggerStep::pUpsert, Upsert::pUpsertSet, Upsert::pUpsertSrc, Upsert::pUpsertTarget, Upsert::pUpsertTargetWhere, Upsert::pUpsertWhere, Trigger::pWhen, TriggerStep::pWhere, Parse::rc, sqlite3FindTable(), sqlite3LocateTableItem(), sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), sqlite3SchemaToIndex(), sqlite3SelectPrep(), sqlite3SrcListDelete(), sqlite3TriggerStepSrc(), sqlite3ViewGetColumnNames(), SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, Trigger::step_list, Trigger::table, NameContext::uNC, Db::zDbSName, and TriggerStep::zTarget.

Referenced by renameColumnFunc(), renameTableFunc(), and renameTableTest().

◆ renameTableExprCb()

static int renameTableExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 107268 of file sqlite3.c.

107274 {

Referenced by renameTableFunc().

◆ renameTableFunc()

static void renameTableFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 107319 of file sqlite3.c.

                                                   :
**
** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0)
**       -> 'CREATE TABLE t1(a REFERENCES t3)'
*/
static void renameTableFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  const char *zDb = (const char*)sqlite3_value_text(argv[0]);
  const char *zInput = (const char*)sqlite3_value_text(argv[3]);
  const char *zOld = (const char*)sqlite3_value_text(argv[4]);
  const char *zNew = (const char*)sqlite3_value_text(argv[5]);
  int bTemp = sqlite3_value_int(argv[6]);
  UNUSED_PARAMETER(NotUsed);
 
  if( zInput && zOld && zNew ){
    Parse sParse;
    int rc;
    int bQuote = 1;
    RenameCtx sCtx;
    Walker sWalker;
 
#ifndef SQLITE_OMIT_AUTHORIZATION
    sqlite3_xauth xAuth = db->xAuth;
    db->xAuth = 0;
#endif
 
    sqlite3BtreeEnterAll(db);
 
    memset(&sCtx, 0, sizeof(RenameCtx));
    sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
    memset(&sWalker, 0, sizeof(Walker));
    sWalker.pParse = &sParse;
    sWalker.xExprCallback = renameTableExprCb;
    sWalker.xSelectCallback = renameTableSelectCb;
    sWalker.u.pRename = &sCtx;
 
    rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
 
    if( rc==SQLITE_OK ){
      int isLegacy = (db->flags & SQLITE_LegacyAlter);
      if( sParse.pNewTable ){
        Table *pTab = sParse.pNewTable;
 
        if( pTab->pSelect ){
          if( isLegacy==0 ){
            Select *pSelect = pTab->pSelect;
            NameContext sNC;
            memset(&sNC, 0, sizeof(sNC));
            sNC.pParse = &sParse;
 
            assert( pSelect->selFlags & SF_View );
            pSelect->selFlags &= ~SF_View;
            sqlite3SelectPrep(&sParse, pTab->pSelect, &sNC);
            if( sParse.nErr ){
              rc = sParse.rc;
            }else{
              sqlite3WalkSelect(&sWalker, pTab->pSelect);
            }
          }
        }else{
          /* Modify any FK definitions to point to the new table. */
#ifndef SQLITE_OMIT_FOREIGN_KEY
          if( isLegacy==0 || (db->flags & SQLITE_ForeignKeys) ){
            FKey *pFKey;
            for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
              if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){
                renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo);
              }
            }
          }
#endif
 
          /* If this is the table being altered, fix any table refs in CHECK
          ** expressions. Also update the name that appears right after the
          ** "CREATE [VIRTUAL] TABLE" bit. */
          if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
            sCtx.pTab = pTab;
            if( isLegacy==0 ){
              sqlite3WalkExprList(&sWalker, pTab->pCheck);
            }
            renameTokenFind(&sParse, &sCtx, pTab->zName);
          }
        }
      }
 
      else if( sParse.pNewIndex ){
        renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
        if( isLegacy==0 ){
          sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
        }
      }
 
#ifndef SQLITE_OMIT_TRIGGER
      else{
        Trigger *pTrigger = sParse.pNewTrigger;
        TriggerStep *pStep;
        if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld)
            && sCtx.pTab->pSchema==pTrigger->pTabSchema
          ){
          renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table);
        }
 
        if( isLegacy==0 ){
          rc = renameResolveTrigger(&sParse);
          if( rc==SQLITE_OK ){
            renameWalkTrigger(&sWalker, pTrigger);
            for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
              if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){
                renameTokenFind(&sParse, &sCtx, pStep->zTarget);
              }
            }
          }
        }
      }
#endif
    }
 
    if( rc==SQLITE_OK ){
      rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote);
    }
    if( rc!=SQLITE_OK ){
      if( sParse.zErrMsg ){
        renameColumnParseError(context, 0, argv[1], argv[2], &sParse);
      }else{
        sqlite3_result_error_code(context, rc);
      }
    }
 
    renameParseCleanup(&sParse);
    renameTokenFree(db, sCtx.pList);
    sqlite3BtreeLeaveAll(db);
#ifndef SQLITE_OMIT_AUTHORIZATION

References sqlite3::flags, Parse::nErr, Table::pCheck, Table::pFKey, RenameCtx::pList, Parse::pNewIndex, Parse::pNewTable, Parse::pNewTrigger, TriggerStep::pNext, FKey::pNextFrom, NameContext::pParse, Walker::pParse, Index::pPartIdxWhere, Walker::pRename, Table::pSchema, Table::pSelect, RenameCtx::pTab, Trigger::pTabSchema, Parse::rc, renameColumnParseError(), renameEditSql(), renameParseCleanup(), renameParseSql(), renameResolveTrigger(), renameTableExprCb(), renameTableSelectCb(), renameTokenFind(), renameTokenFree(), renameWalkTrigger(), Select::selFlags, SF_View, sqlite3_context_db_handle(), sqlite3_result_error_code(), sqlite3_stricmp(), sqlite3_value_int(), sqlite3_value_text(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3FindTable(), sqlite3SelectPrep(), sqlite3WalkExpr(), sqlite3WalkExprList(), sqlite3WalkSelect(), SQLITE_ForeignKeys, SQLITE_LegacyAlter, SQLITE_OK, Trigger::step_list, Trigger::table, Walker::u, UNUSED_PARAMETER, sqlite3::xAuth, Walker::xExprCallback, Walker::xSelectCallback, Parse::zErrMsg, Table::zName, Index::zName, TriggerStep::zTarget, and FKey::zTo.

◆ renameTableSelectCb()

static int renameTableSelectCb	(	Walker *	pWalker,
		Select *	pSelect )

static

Definition at line 107279 of file sqlite3.c.

                                                                {
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  if( pSelect->selFlags & SF_View ) return WRC_Prune;
  if( pSrc==0 ){
    assert( pWalker->pParse->db->mallocFailed );
    return WRC_Abort;
  }
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);

Referenced by renameTableFunc().

◆ renameTableTest()

static void renameTableTest	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 107476 of file sqlite3.c.

                             :
**
**   * the SQL argument creates a trigger, and
**   * the table that the trigger is attached to is in database zDb.
*/
static void renameTableTest(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  char const *zDb = (const char*)sqlite3_value_text(argv[0]);
  char const *zInput = (const char*)sqlite3_value_text(argv[1]);
  int bTemp = sqlite3_value_int(argv[4]);
  int isLegacy = (db->flags & SQLITE_LegacyAlter);
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  sqlite3_xauth xAuth = db->xAuth;
  db->xAuth = 0;
#endif
 
  UNUSED_PARAMETER(NotUsed);
  if( zDb && zInput ){
    int rc;
    Parse sParse;
    rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
    if( rc==SQLITE_OK ){
      if( isLegacy==0 && sParse.pNewTable && sParse.pNewTable->pSelect ){
        NameContext sNC;
        memset(&sNC, 0, sizeof(sNC));
        sNC.pParse = &sParse;
        sqlite3SelectPrep(&sParse, sParse.pNewTable->pSelect, &sNC);
        if( sParse.nErr ) rc = sParse.rc;
      }
 
      else if( sParse.pNewTrigger ){
        if( isLegacy==0 ){
          rc = renameResolveTrigger(&sParse);
        }
        if( rc==SQLITE_OK ){
          int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema);
          int i2 = sqlite3FindDbName(db, zDb);
          if( i1==i2 ) sqlite3_result_int(context, 1);
        }
      }
    }
 
    if( rc!=SQLITE_OK ){
      renameColumnParseError(context, 1, argv[2], argv[3], &sParse);
    }
    renameParseCleanup(&sParse);

References sqlite3::flags, Parse::nErr, Parse::pNewTable, Parse::pNewTrigger, NameContext::pParse, Table::pSelect, Trigger::pTabSchema, Parse::rc, renameColumnParseError(), renameParseCleanup(), renameParseSql(), renameResolveTrigger(), sqlite3_context_db_handle(), sqlite3_result_int(), sqlite3_value_int(), sqlite3_value_text(), sqlite3FindDbName(), sqlite3SchemaToIndex(), sqlite3SelectPrep(), SQLITE_LegacyAlter, SQLITE_OK, UNUSED_PARAMETER, and sqlite3::xAuth.

◆ renameTestSchema()

static void renameTestSchema	(	Parse *	pParse,
		const char *	zDb,
		int	bTemp )

static

Definition at line 105845 of file sqlite3.c.

                                                                       {
  sqlite3NestedParse(pParse,
      "SELECT 1 "
      "FROM \"%w\"." DFLT_SCHEMA_TABLE " "
      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
      zDb,
      zDb, bTemp
  );
 
  if( bTemp==0 ){
    sqlite3NestedParse(pParse,
        "SELECT 1 "
        "FROM temp." DFLT_SCHEMA_TABLE " "
        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

References DFLT_SCHEMA_TABLE, and sqlite3NestedParse().

Referenced by sqlite3AlterRenameColumn().

◆ renameTokenFind()

static void renameTokenFind	(	Parse *	pParse,
		struct RenameCtx *	pCtx,
		void *	pPtr )

static

Definition at line 106666 of file sqlite3.c.

                                                                              {
  RenameToken **pp;
  assert( pPtr!=0 );
  for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
    if( (*pp)->p==pPtr ){
      RenameToken *pToken = *pp;
      *pp = pToken->pNext;
      pToken->pNext = pCtx->pList;

References RenameCtx::nList, RenameCtx::pList, RenameToken::pNext, and Parse::pRename.

Referenced by renameColumnElistNames(), renameColumnExprCb(), renameColumnFunc(), renameColumnIdlistNames(), and renameTableFunc().

◆ renameTokenFree()

static void renameTokenFree	(	sqlite3 *	db,
		RenameToken *	pToken )

static

Definition at line 106651 of file sqlite3.c.

106657 {

106658 RenameToken *pNext;

Referenced by renameColumnFunc(), and renameTableFunc().

◆ renameUnmapExprCb()

static int renameUnmapExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 106543 of file sqlite3.c.

◆ renameUnmapSelectCb()

static int renameUnmapSelectCb	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 106587 of file sqlite3.c.

                                                          {
  Parse *pParse = pWalker->pParse;
  int i;
  if( pParse->nErr ) return WRC_Abort;
  if( NEVER(p->selFlags & SF_View) ) return WRC_Prune;
  if( ALWAYS(p->pEList) ){
    ExprList *pList = p->pEList;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
      }
    }
  }
  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
    SrcList *pSrc = p->pSrc;
    for(i=0; i<pSrc->nSrc; i++){
      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
      if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
      unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);

◆ renameWalkTrigger()

static void renameWalkTrigger	(	Walker *	pWalker,
		Trigger *	pTrigger )

static

Definition at line 107042 of file sqlite3.c.

                                                                 {
  TriggerStep *pStep;
 
  /* Find tokens to edit in WHEN clause */
  sqlite3WalkExpr(pWalker, pTrigger->pWhen);
 
  /* Find tokens to edit in trigger steps */
  for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
    sqlite3WalkSelect(pWalker, pStep->pSelect);
    sqlite3WalkExpr(pWalker, pStep->pWhere);
    sqlite3WalkExprList(pWalker, pStep->pExprList);
    if( pStep->pUpsert ){
      Upsert *pUpsert = pStep->pUpsert;
      sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget);

Referenced by renameColumnFunc(), and renameTableFunc().

◆ renameWalkWith()

static void renameWalkWith	(	Walker *	pWalker,
		Select *	pSelect )

static

Definition at line 106553 of file sqlite3.c.

                                                            {
  With *pWith = pSelect->pWith;
  if( pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      Select *p = pWith->a[i].pSelect;
      NameContext sNC;
      memset(&sNC, 0, sizeof(sNC));
      sNC.pParse = pWalker->pParse;

Referenced by renameColumnSelectCb().

◆ renderLogMsg()

static void renderLogMsg	(	int	iErrCode,
		const char *	zFormat,
		va_list	ap )

static

Definition at line 29386 of file sqlite3.c.

                                                                       {
  StrAccum acc;                          /* String accumulator */
  char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */

References sqlite3_str_vappendf(), sqlite3GlobalConfig, sqlite3StrAccumInit(), and SQLITE_PRINT_BUF_SIZE.

◆ replaceFunc()

static void replaceFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118262 of file sqlite3.c.

 {
  const unsigned char *zStr;        /* The input string A */
  const unsigned char *zPattern;    /* The pattern string B */
  const unsigned char *zRep;        /* The replacement string C */
  unsigned char *zOut;              /* The output */
  int nStr;                /* Size of zStr */
  int nPattern;            /* Size of zPattern */
  int nRep;                /* Size of zRep */
  i64 nOut;                /* Maximum size of zOut */
  int loopLimit;           /* Last zStr[] that might match zPattern[] */
  int i, j;                /* Loop counters */
  unsigned cntExpand;      /* Number zOut expansions */
  sqlite3 *db = sqlite3_context_db_handle(context);
 
  assert( argc==3 );
  UNUSED_PARAMETER(argc);
  zStr = sqlite3_value_text(argv[0]);
  if( zStr==0 ) return;
  nStr = sqlite3_value_bytes(argv[0]);
  assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
  zPattern = sqlite3_value_text(argv[1]);
  if( zPattern==0 ){
    assert( sqlite3_value_type(argv[1])==SQLITE_NULL
            || sqlite3_context_db_handle(context)->mallocFailed );
    return;
  }
  if( zPattern[0]==0 ){
    assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
    sqlite3_result_value(context, argv[0]);
    return;
  }
  nPattern = sqlite3_value_bytes(argv[1]);
  assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */
  zRep = sqlite3_value_text(argv[2]);
  if( zRep==0 ) return;
  nRep = sqlite3_value_bytes(argv[2]);
  assert( zRep==sqlite3_value_text(argv[2]) );
  nOut = nStr + 1;
  assert( nOut<SQLITE_MAX_LENGTH );
  zOut = contextMalloc(context, (i64)nOut);
  if( zOut==0 ){
    return;
  }
  loopLimit = nStr - nPattern;
  cntExpand = 0;
  for(i=j=0; i<=loopLimit; i++){
    if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
      zOut[j++] = zStr[i];
    }else{
      if( nRep>nPattern ){
        nOut += nRep - nPattern;
        testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
        testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
        if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
          sqlite3_result_error_toobig(context);
          sqlite3_free(zOut);
          return;
        }
        cntExpand++;
        if( (cntExpand&(cntExpand-1))==0 ){
          /* Grow the size of the output buffer only on substitutions
          ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
          u8 *zOld;
          zOld = zOut;
          zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
          if( zOut==0 ){
            sqlite3_result_error_nomem(context);
            sqlite3_free(zOld);
            return;
          }
        }
      }
      memcpy(&zOut[j], zRep, nRep);
      j += nRep;
      i += nPattern-1;
    }
  }
  assert( j+nStr-i+1<=nOut );

References sqlite3::aLimit, contextMalloc(), sqlite3_context_db_handle(), sqlite3_free(), sqlite3_result_error_nomem(), sqlite3_result_error_toobig(), sqlite3_result_text(), sqlite3_result_value(), sqlite3_value_bytes(), sqlite3_value_text(), sqlite3_value_type(), sqlite3Realloc(), SQLITE_LIMIT_LENGTH, SQLITE_MAX_LENGTH, SQLITE_NULL, testcase, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ resetAccumulator()

static void resetAccumulator	(	Parse *	pParse,
		AggInfo *	pAggInfo )

static

Definition at line 134688 of file sqlite3.c.

                                                              {
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pFunc;
  int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
  if( nReg==0 ) return;
  if( pParse->nErr || pParse->db->mallocFailed ) return;
#ifdef SQLITE_DEBUG
  /* Verify that all AggInfo registers are within the range specified by
  ** AggInfo.mnReg..AggInfo.mxReg */
  assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
  for(i=0; i<pAggInfo->nColumn; i++){
    assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
  }
  for(i=0; i<pAggInfo->nFunc; i++){
    assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
  }
#endif
  sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
  for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
    if( pFunc->iDistinct>=0 ){
      Expr *pE = pFunc->pFExpr;
      assert( !ExprHasProperty(pE, EP_xIsSelect) );
      if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
        sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
           "argument");
        pFunc->iDistinct = -1;
      }else{
        KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);

References AggInfo::aCol, AggInfo::aFunc, Parse::db, EP_xIsSelect, ExprHasProperty, AggInfo::AggInfo_col::iMem, AggInfo::AggInfo_func::iMem, sqlite3::mallocFailed, AggInfo::mnReg, AggInfo::mxReg, AggInfo::nColumn, Parse::nErr, ExprList::nExpr, AggInfo::nFunc, OP_Null, OP_OpenEphemeral, P4_KEYINFO, Expr::pList, Parse::pVdbe, sqlite3ErrorMsg(), sqlite3KeyInfoFromExprList(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), and Expr::x.

Referenced by sqlite3Select().

◆ resizeIndexObject()

static int resizeIndexObject	(	sqlite3 *	db,
		Index *	pIdx,
		int	N )

static

Definition at line 112269 of file sqlite3.c.

                                                             {
  char *zExtra;
  int nByte;
  if( pIdx->nColumn>=N ) return SQLITE_OK;
  assert( pIdx->isResized==0 );
  nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
  zExtra = sqlite3DbMallocZero(db, nByte);
  if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
  memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
  pIdx->azColl = (const char**)zExtra;
  zExtra += sizeof(char*)*N;
  memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
  pIdx->aiColumn = (i16*)zExtra;
  zExtra += sizeof(i16)*N;

Referenced by convertToWithoutRowidTable().

◆ resizeResolveLabel()

static SQLITE_NOINLINE void resizeResolveLabel	(	Parse *	p,
		Vdbe *	v,
		int	j )

static

Definition at line 78281 of file sqlite3.c.

                                                                        {
  int nNewSize = 10 - p->nLabel;
  p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
                     nNewSize*sizeof(p->aLabel[0]));
  if( p->aLabel==0 ){
    p->nLabelAlloc = 0;
  }else{
#ifdef SQLITE_DEBUG
    int i;

References Parse::aLabel, Parse::db, Parse::nLabel, Parse::nLabelAlloc, and sqlite3DbReallocOrFree().

◆ resolveAlias()

static void resolveAlias	(	Parse *	pParse,
		ExprList *	pEList,
		int	iCol,
		Expr *	pExpr,
		const char *	zType,
		int	nSubquery )

static

Definition at line 97817 of file sqlite3.c.

 {
  Expr *pOrig;           /* The iCol-th column of the result set */
  Expr *pDup;            /* Copy of pOrig */
  sqlite3 *db;           /* The database connection */
 
  assert( iCol>=0 && iCol<pEList->nExpr );
  pOrig = pEList->a[iCol].pExpr;
  assert( pOrig!=0 );
  db = pParse->db;
  pDup = sqlite3ExprDup(db, pOrig, 0);
  if( pDup!=0 ){
    if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
    if( pExpr->op==TK_COLLATE ){
      pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
    }
 
    /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
    ** prevents ExprDelete() from deleting the Expr structure itself,
    ** allowing it to be repopulated by the memcpy() on the following line.
    ** The pExpr->u.zToken might point into memory that will be freed by the
    ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
    ** make a copy of the token before doing the sqlite3DbFree().
    */
    ExprSetProperty(pExpr, EP_Static);
    sqlite3ExprDelete(db, pExpr);
    memcpy(pExpr, pDup, sizeof(*pExpr));
    if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
      assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
      pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
      pExpr->flags |= EP_MemToken;
    }
    if( ExprHasProperty(pExpr, EP_WinFunc) ){
      if( pExpr->y.pWin!=0 ){
        pExpr->y.pWin->pOwner = pExpr;
      }else{
        assert( db->mallocFailed );

References ExprList::a, Parse::db, EP_Alias, EP_IntValue, EP_MemToken, EP_Reduced, EP_Static, EP_TokenOnly, EP_WinFunc, ExprHasProperty, ExprSetProperty, Expr::flags, incrAggFunctionDepth(), sqlite3::mallocFailed, Expr::op, ExprList::ExprList_item::pExpr, Window::pOwner, Expr::pWin, sqlite3DbFree(), sqlite3DbStrDup(), sqlite3ExprAddCollateString(), sqlite3ExprDelete(), sqlite3ExprDup(), TK_COLLATE, Expr::u, Expr::y, and Expr::zToken.

Referenced by lookupName(), and sqlite3ResolveOrderGroupBy().

◆ resolveAsName()

static int resolveAsName	(	Parse *	pParse,
		ExprList *	pEList,
		Expr *	pE )

static

Definition at line 98888 of file sqlite3.c.

 {
  int i;             /* Loop counter */
 
  UNUSED_PARAMETER(pParse);
 
  if( pE->op==TK_ID ){
    char *zCol = pE->u.zToken;
    for(i=0; i<pEList->nExpr; i++){
      if( pEList->a[i].eEName==ENAME_NAME
       && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
      ){

References ExprList::a, ExprList::ExprList_item::eEName, ENAME_NAME, ExprList::nExpr, Expr::op, sqlite3_stricmp(), TK_ID, Expr::u, UNUSED_PARAMETER, ExprList::ExprList_item::zEName, and Expr::zToken.

Referenced by resolveCompoundOrderBy(), and resolveOrderGroupBy().

◆ resolveAttachExpr()

static int resolveAttachExpr	(	NameContext *	pName,
		Expr *	pExpr )

static

Definition at line 109523 of file sqlite3.c.

                                                                :
**
**     ATTACH DATABASE abc||def AS 'db2'
**
** will fail because neither abc or def can be resolved.
*/
static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
{
  int rc = SQLITE_OK;
  if( pExpr ){
    if( pExpr->op!=TK_ID ){
      rc = sqlite3ResolveExprNames(pName, pExpr);

References Expr::op, sqlite3ResolveExprNames(), SQLITE_OK, TK_ID, and TK_STRING.

◆ resolveCompoundOrderBy()

static int resolveCompoundOrderBy	(	Parse *	pParse,
		Select *	pSelect )

static

Definition at line 99001 of file sqlite3.c.

 {
  int i;
  ExprList *pOrderBy;
  ExprList *pEList;
  sqlite3 *db;
  int moreToDo = 1;
 
  pOrderBy = pSelect->pOrderBy;
  if( pOrderBy==0 ) return 0;
  db = pParse->db;
  if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
    return 1;
  }
  for(i=0; i<pOrderBy->nExpr; i++){
    pOrderBy->a[i].done = 0;
  }
  pSelect->pNext = 0;
  while( pSelect->pPrior ){
    pSelect->pPrior->pNext = pSelect;
    pSelect = pSelect->pPrior;
  }
  while( pSelect && moreToDo ){
    struct ExprList_item *pItem;
    moreToDo = 0;
    pEList = pSelect->pEList;
    assert( pEList!=0 );
    for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
      int iCol = -1;
      Expr *pE, *pDup;
      if( pItem->done ) continue;
      pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
      if( sqlite3ExprIsInteger(pE, &iCol) ){
        if( iCol<=0 || iCol>pEList->nExpr ){
          resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
          return 1;
        }
      }else{
        iCol = resolveAsName(pParse, pEList, pE);
        if( iCol==0 ){
          /* Now test if expression pE matches one of the values returned
          ** by pSelect. In the usual case this is done by duplicating the
          ** expression, resolving any symbols in it, and then comparing
          ** it against each expression returned by the SELECT statement.
          ** Once the comparisons are finished, the duplicate expression
          ** is deleted.
          **
          ** Or, if this is running as part of an ALTER TABLE operation,
          ** resolve the symbols in the actual expression, not a duplicate.
          ** And, if one of the comparisons is successful, leave the expression
          ** as is instead of transforming it to an integer as in the usual
          ** case. This allows the code in alter.c to modify column
          ** refererences within the ORDER BY expression as required.  */
          if( IN_RENAME_OBJECT ){
            pDup = pE;
          }else{
            pDup = sqlite3ExprDup(db, pE, 0);
          }
          if( !db->mallocFailed ){
            assert(pDup);
            iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
          }
          if( !IN_RENAME_OBJECT ){
            sqlite3ExprDelete(db, pDup);
          }
        }
      }
      if( iCol>0 ){
        /* Convert the ORDER BY term into an integer column number iCol,
        ** taking care to preserve the COLLATE clause if it exists */
        if( !IN_RENAME_OBJECT ){
          Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
          if( pNew==0 ) return 1;
          pNew->flags |= EP_IntValue;
          pNew->u.iValue = iCol;
          if( pItem->pExpr==pE ){
            pItem->pExpr = pNew;
          }else{
            Expr *pParent = pItem->pExpr;
            assert( pParent->op==TK_COLLATE );
            while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
            assert( pParent->pLeft==pE );
            pParent->pLeft = pNew;
          }
          sqlite3ExprDelete(db, pE);
          pItem->u.x.iOrderByCol = (u16)iCol;
        }
        pItem->done = 1;
      }else{
        moreToDo = 1;
      }
    }
    pSelect = pSelect->pNext;
  }
  for(i=0; i<pOrderBy->nExpr; i++){
    if( pOrderBy->a[i].done==0 ){
      sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "

References ExprList::a, sqlite3::aLimit, Parse::db, ExprList::ExprList_item::done, EP_IntValue, Expr::flags, IN_RENAME_OBJECT, Expr::iValue, sqlite3::mallocFailed, ExprList::nExpr, Expr::op, Select::pEList, Expr::pLeft, Select::pNext, Select::pOrderBy, Select::pPrior, resolveAsName(), resolveOrderByTermToExprList(), resolveOutOfRangeError(), sqlite3ErrorMsg(), sqlite3Expr(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIsInteger(), sqlite3ExprSkipCollateAndLikely(), SQLITE_LIMIT_COLUMN, TK_COLLATE, TK_INTEGER, and Expr::u.

◆ resolveExprStep()

static int resolveExprStep	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 98488 of file sqlite3.c.

                                                        {
  NameContext *pNC;
  Parse *pParse;
 
  pNC = pWalker->u.pNC;
  assert( pNC!=0 );
  pParse = pNC->pParse;
  assert( pParse==pWalker->pParse );
 
#ifndef NDEBUG
  if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
    SrcList *pSrcList = pNC->pSrcList;
    int i;
    for(i=0; i<pNC->pSrcList->nSrc; i++){
      assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
    }
  }
#endif
  switch( pExpr->op ){
 
    /* The special operator TK_ROW means use the rowid for the first
    ** column in the FROM clause.  This is used by the LIMIT and ORDER BY
    ** clause processing on UPDATE and DELETE statements, and by
    ** UPDATE ... FROM statement processing.
    */
    case TK_ROW: {
      SrcList *pSrcList = pNC->pSrcList;
      struct SrcList_item *pItem;
      assert( pSrcList && pSrcList->nSrc>=1 );
      pItem = pSrcList->a;
      pExpr->op = TK_COLUMN;
      pExpr->y.pTab = pItem->pTab;
      pExpr->iTable = pItem->iCursor;
      pExpr->iColumn--;
      pExpr->affExpr = SQLITE_AFF_INTEGER;
      break;
    }
 
    /* A column name:                    ID
    ** Or table name and column name:    ID.ID
    ** Or a database, table and column:  ID.ID.ID
    **
    ** The TK_ID and TK_OUT cases are combined so that there will only
    ** be one call to lookupName().  Then the compiler will in-line
    ** lookupName() for a size reduction and performance increase.
    */
    case TK_ID:
    case TK_DOT: {
      const char *zColumn;
      const char *zTable;
      const char *zDb;
      Expr *pRight;
 
      if( pExpr->op==TK_ID ){
        zDb = 0;
        zTable = 0;
        zColumn = pExpr->u.zToken;
      }else{
        Expr *pLeft = pExpr->pLeft;
        testcase( pNC->ncFlags & NC_IdxExpr );
        testcase( pNC->ncFlags & NC_GenCol );
        sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
                               NC_IdxExpr|NC_GenCol, 0);
        pRight = pExpr->pRight;
        if( pRight->op==TK_ID ){
          zDb = 0;
        }else{
          assert( pRight->op==TK_DOT );
          zDb = pLeft->u.zToken;
          pLeft = pRight->pLeft;
          pRight = pRight->pRight;
        }
        zTable = pLeft->u.zToken;
        zColumn = pRight->u.zToken;
        if( IN_RENAME_OBJECT ){
          sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
          sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
        }
      }
      return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
    }
 
    /* Resolve function names
    */
    case TK_FUNCTION: {
      ExprList *pList = pExpr->x.pList;    /* The argument list */
      int n = pList ? pList->nExpr : 0;    /* Number of arguments */
      int no_such_func = 0;       /* True if no such function exists */
      int wrong_num_args = 0;     /* True if wrong number of arguments */
      int is_agg = 0;             /* True if is an aggregate function */
      int nId;                    /* Number of characters in function name */
      const char *zId;            /* The function name. */
      FuncDef *pDef;              /* Information about the function */
      u8 enc = ENC(pParse->db);   /* The database encoding */
      int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
#ifndef SQLITE_OMIT_WINDOWFUNC
      Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
#endif
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      zId = pExpr->u.zToken;
      nId = sqlite3Strlen30(zId);
      pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
      if( pDef==0 ){
        pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
        if( pDef==0 ){
          no_such_func = 1;
        }else{
          wrong_num_args = 1;
        }
      }else{
        is_agg = pDef->xFinalize!=0;
        if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
          ExprSetProperty(pExpr, EP_Unlikely);
          if( n==2 ){
            pExpr->iTable = exprProbability(pList->a[1].pExpr);
            if( pExpr->iTable<0 ){
              sqlite3ErrorMsg(pParse,
                "second argument to likelihood() must be a "
                "constant between 0.0 and 1.0");
              pNC->nErr++;
            }
          }else{
            /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
            ** equivalent to likelihood(X, 0.0625).
            ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
            ** short-hand for likelihood(X,0.0625).
            ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
            ** for likelihood(X,0.9375).
            ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
            ** to likelihood(X,0.9375). */
            /* TUNING: unlikely() probability is 0.0625.  likely() is 0.9375 */
            pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
          }
        }
#ifndef SQLITE_OMIT_AUTHORIZATION
        {
          int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
          if( auth!=SQLITE_OK ){
            if( auth==SQLITE_DENY ){
              sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
                                      pDef->zName);
              pNC->nErr++;
            }
            pExpr->op = TK_NULL;
            return WRC_Prune;
          }
        }
#endif
        if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
          /* For the purposes of the EP_ConstFunc flag, date and time
          ** functions and other functions that change slowly are considered
          ** constant because they are constant for the duration of one query.
          ** This allows them to be factored out of inner loops. */
          ExprSetProperty(pExpr,EP_ConstFunc);
        }
        if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
          /* Clearly non-deterministic functions like random(), but also
          ** date/time functions that use 'now', and other functions like
          ** sqlite_version() that might change over time cannot be used
          ** in an index or generated column.  Curiously, they can be used
          ** in a CHECK constraint.  SQLServer, MySQL, and PostgreSQL all
          ** all this. */
          sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
                                 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0);
        }else{
          assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */
          pExpr->op2 = pNC->ncFlags & NC_SelfRef;
          if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
        }
        if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
         && pParse->nested==0
         && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
        ){
          /* Internal-use-only functions are disallowed unless the
          ** SQL is being compiled using sqlite3NestedParse() or
          ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
          ** used to activate internal functionsn for testing purposes */
          no_such_func = 1;
          pDef = 0;
        }else
        if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
         && !IN_RENAME_OBJECT
        ){
          sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
        }
      }
 
      if( 0==IN_RENAME_OBJECT ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
          || (pDef->xValue==0 && pDef->xInverse==0)
          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
        );
        if( pDef && pDef->xValue==0 && pWin ){
          sqlite3ErrorMsg(pParse,
              "%.*s() may not be used as a window function", nId, zId
          );
          pNC->nErr++;
        }else if(
              (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
           || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
           || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
        ){
          const char *zType;
          if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
            zType = "window";
          }else{
            zType = "aggregate";
          }
          sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
          pNC->nErr++;
          is_agg = 0;
        }
#else
        if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
          sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
          pNC->nErr++;
          is_agg = 0;
        }
#endif
        else if( no_such_func && pParse->db->init.busy==0
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
                  && pParse->explain==0
#endif
        ){
          sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
          pNC->nErr++;
        }else if( wrong_num_args ){
          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
               nId, zId);
          pNC->nErr++;
        }
#ifndef SQLITE_OMIT_WINDOWFUNC
        else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
          sqlite3ErrorMsg(pParse,
              "FILTER may not be used with non-aggregate %.*s()",
              nId, zId
          );
          pNC->nErr++;
        }
#endif
        if( is_agg ){
          /* Window functions may not be arguments of aggregate functions.
          ** Or arguments of other window functions. But aggregate functions
          ** may be arguments for window functions.  */
#ifndef SQLITE_OMIT_WINDOWFUNC
          pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
#else
          pNC->ncFlags &= ~NC_AllowAgg;
#endif
        }
      }
#ifndef SQLITE_OMIT_WINDOWFUNC
      else if( ExprHasProperty(pExpr, EP_WinFunc) ){
        is_agg = 1;
      }
#endif
      sqlite3WalkExprList(pWalker, pList);
      if( is_agg ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        if( pWin ){
          Select *pSel = pNC->pWinSelect;
          assert( pWin==pExpr->y.pWin );
          if( IN_RENAME_OBJECT==0 ){
            sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
          }
          sqlite3WalkExprList(pWalker, pWin->pPartition);
          sqlite3WalkExprList(pWalker, pWin->pOrderBy);
          sqlite3WalkExpr(pWalker, pWin->pFilter);
          sqlite3WindowLink(pSel, pWin);
          pNC->ncFlags |= NC_HasWin;
        }else
#endif /* SQLITE_OMIT_WINDOWFUNC */
        {
          NameContext *pNC2 = pNC;
          pExpr->op = TK_AGG_FUNCTION;
          pExpr->op2 = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
          if( ExprHasProperty(pExpr, EP_WinFunc) ){
            sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
          }
#endif
          while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
            pExpr->op2++;
            pNC2 = pNC2->pNext;
          }
          assert( pDef!=0 || IN_RENAME_OBJECT );
          if( pNC2 && pDef ){
            assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
            testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
            pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);
 
          }
        }
        pNC->ncFlags |= savedAllowFlags;
      }
      /* FIX ME:  Compute pExpr->affinity based on the expected return
      ** type of the function
      */
      return WRC_Prune;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT:
    case TK_EXISTS:  testcase( pExpr->op==TK_EXISTS );
#endif
    case TK_IN: {
      testcase( pExpr->op==TK_IN );
      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        int nRef = pNC->nRef;
        testcase( pNC->ncFlags & NC_IsCheck );
        testcase( pNC->ncFlags & NC_PartIdx );
        testcase( pNC->ncFlags & NC_IdxExpr );
        testcase( pNC->ncFlags & NC_GenCol );
        sqlite3ResolveNotValid(pParse, pNC, "subqueries",
                 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
        sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
        assert( pNC->nRef>=nRef );
        if( nRef!=pNC->nRef ){
          ExprSetProperty(pExpr, EP_VarSelect);
          pNC->ncFlags |= NC_VarSelect;
        }
      }
      break;
    }
    case TK_VARIABLE: {
      testcase( pNC->ncFlags & NC_IsCheck );
      testcase( pNC->ncFlags & NC_PartIdx );
      testcase( pNC->ncFlags & NC_IdxExpr );
      testcase( pNC->ncFlags & NC_GenCol );
      sqlite3ResolveNotValid(pParse, pNC, "parameters",
               NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
      break;
    }
    case TK_IS:
    case TK_ISNOT: {
      Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
      assert( !ExprHasProperty(pExpr, EP_Reduced) );
      /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
      ** and "x IS NOT FALSE". */
      if( pRight && pRight->op==TK_ID ){
        int rc = resolveExprStep(pWalker, pRight);
        if( rc==WRC_Abort ) return WRC_Abort;
        if( pRight->op==TK_TRUEFALSE ){
          pExpr->op2 = pExpr->op;
          pExpr->op = TK_TRUTH;
          return WRC_Continue;
        }
      }
      /* no break */ deliberate_fall_through
    }
    case TK_BETWEEN:
    case TK_EQ:
    case TK_NE:
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE: {
      int nLeft, nRight;
      if( pParse->db->mallocFailed ) break;
      assert( pExpr->pLeft!=0 );
      nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
      if( pExpr->op==TK_BETWEEN ){
        nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
        if( nRight==nLeft ){
          nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
        }
      }else{
        assert( pExpr->pRight!=0 );
        nRight = sqlite3ExprVectorSize(pExpr->pRight);
      }
      if( nLeft!=nRight ){
        testcase( pExpr->op==TK_EQ );
        testcase( pExpr->op==TK_NE );
        testcase( pExpr->op==TK_LT );
        testcase( pExpr->op==TK_LE );
        testcase( pExpr->op==TK_GT );
        testcase( pExpr->op==TK_GE );
        testcase( pExpr->op==TK_IS );
        testcase( pExpr->op==TK_ISNOT );
        testcase( pExpr->op==TK_BETWEEN );
        sqlite3ErrorMsg(pParse, "row value misused");

References ExprList::a, SrcList::a, Expr::affExpr, sqlite3::sqlite3InitInfo::busy, Parse::db, DBFLAG_InternalFunc, deliberate_fall_through, ENC, EP_ConstFunc, EP_FromDDL, EP_Reduced, EP_Unlikely, EP_VarSelect, EP_WinFunc, EP_xIsSelect, Parse::explain, ExprHasProperty, exprProbability(), ExprSetProperty, FuncDef::funcFlags, Expr::iColumn, SrcList::SrcList_item::iCursor, IN_RENAME_OBJECT, sqlite3::init, IsWindowFunc, Expr::iTable, lookupName(), sqlite3::mallocFailed, sqlite3::mDbFlags, SrcList::nAlloc, NC_AllowAgg, NC_AllowWin, NC_FromDDL, NC_GenCol, NC_HasAgg, NC_HasWin, NC_IdxExpr, NC_IsCheck, NC_MinMaxAgg, NC_PartIdx, NC_SelfRef, NC_VarSelect, NameContext::ncFlags, NameContext::nErr, Parse::nErr, Parse::nested, ExprList::nExpr, NameContext::nRef, SrcList::nSrc, Parse::nTab, Expr::op, Expr::op2, ExprList::ExprList_item::pExpr, Window::pFilter, Expr::pLeft, Expr::pList, Walker::pNC, NameContext::pNext, Window::pOrderBy, NameContext::pParse, Walker::pParse, Window::pPartition, Expr::pRight, Expr::pSelect, NameContext::pSrcList, Expr::pTab, Expr::pWin, Select::pWinDefn, NameContext::pWinSelect, resolveExprStep(), sqlite3AuthCheck(), sqlite3ErrorMsg(), sqlite3ExprFunctionUsable(), sqlite3ExprSkipCollateAndLikely(), sqlite3ExprVectorSize(), sqlite3FindFunction(), sqlite3FunctionUsesThisSrc(), sqlite3RenameTokenRemap(), sqlite3ResolveNotValid, sqlite3Strlen30(), sqlite3WalkExpr(), sqlite3WalkExprList(), sqlite3WalkSelect(), sqlite3WindowLink(), sqlite3WindowUpdate(), SQLITE_AFF_INTEGER, SQLITE_DENY, SQLITE_FUNC_CONSTANT, SQLITE_FUNC_DIRECT, SQLITE_FUNC_INTERNAL, SQLITE_FUNC_MINMAX, SQLITE_FUNC_SLOCHNG, SQLITE_FUNC_UNLIKELY, SQLITE_FUNC_UNSAFE, SQLITE_FUNC_WINDOW, SQLITE_FUNCTION, SQLITE_OK, testcase, TK_AGG_FUNCTION, TK_BETWEEN, TK_COLUMN, TK_DOT, TK_EQ, TK_EXISTS, TK_FUNCTION, TK_GE, TK_GT, TK_ID, TK_IN, TK_IS, TK_ISNOT, TK_LE, TK_LT, TK_NE, TK_NULL, TK_ROW, TK_SELECT, TK_TRUEFALSE, TK_TRUTH, TK_VARIABLE, Expr::u, Walker::u, WRC_Abort, WRC_Continue, WRC_Prune, Expr::x, FuncDef::xFinalize, FuncDef::xInverse, FuncDef::xSFunc, FuncDef::xValue, Expr::y, FuncDef::zName, and Expr::zToken.

Referenced by resolveExprStep(), sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), and sqlite3ResolveSelectNames().

◆ resolveOrderByTermToExprList()

static int resolveOrderByTermToExprList	(	Parse *	pParse,
		Select *	pSelect,
		Expr *	pE )

static

Definition at line 98928 of file sqlite3.c.

 {
  int i;             /* Loop counter */
  ExprList *pEList;  /* The columns of the result set */
  NameContext nc;    /* Name context for resolving pE */
  sqlite3 *db;       /* Database connection */
  int rc;            /* Return code from subprocedures */
  u8 savedSuppErr;   /* Saved value of db->suppressErr */
 
  assert( sqlite3ExprIsInteger(pE, &i)==0 );
  pEList = pSelect->pEList;
 
  /* Resolve all names in the ORDER BY term expression
  */
  memset(&nc, 0, sizeof(nc));
  nc.pParse = pParse;
  nc.pSrcList = pSelect->pSrc;
  nc.uNC.pEList = pEList;
  nc.ncFlags = NC_AllowAgg|NC_UEList;
  nc.nErr = 0;
  db = pParse->db;
  savedSuppErr = db->suppressErr;
  if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
  rc = sqlite3ResolveExprNames(&nc, pE);
  db->suppressErr = savedSuppErr;
  if( rc ) return 0;
 
  /* Try to match the ORDER BY expression against an expression
  ** in the result set.  Return an 1-based index of the matching
  ** result-set entry.
  */
  for(i=0; i<pEList->nExpr; i++){
    if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
      return i+1;

References ExprList::a, Parse::db, IN_RENAME_OBJECT, NC_AllowAgg, NC_UEList, NameContext::ncFlags, NameContext::nErr, ExprList::nExpr, NameContext::pEList, Select::pEList, ExprList::ExprList_item::pExpr, NameContext::pParse, Select::pSrc, NameContext::pSrcList, sqlite3ExprCompare(), sqlite3ExprIsInteger(), sqlite3ResolveExprNames(), sqlite3::suppressErr, and NameContext::uNC.

Referenced by resolveCompoundOrderBy().

◆ resolveOrderGroupBy()

static int resolveOrderGroupBy	(	NameContext *	pNC,
		Select *	pSelect,
		ExprList *	pOrderBy,
		const char *	zType )

static

Definition at line 99197 of file sqlite3.c.

 {
  int i, j;                      /* Loop counters */
  int iCol;                      /* Column number */
  struct ExprList_item *pItem;   /* A term of the ORDER BY clause */
  Parse *pParse;                 /* Parsing context */
  int nResult;                   /* Number of terms in the result set */
 
  if( pOrderBy==0 ) return 0;
  nResult = pSelect->pEList->nExpr;
  pParse = pNC->pParse;
  for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
    Expr *pE = pItem->pExpr;
    Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE);
    if( zType[0]!='G' ){
      iCol = resolveAsName(pParse, pSelect->pEList, pE2);
      if( iCol>0 ){
        /* If an AS-name match is found, mark this ORDER BY column as being
        ** a copy of the iCol-th result-set column.  The subsequent call to
        ** sqlite3ResolveOrderGroupBy() will convert the expression to a
        ** copy of the iCol-th result-set expression. */
        pItem->u.x.iOrderByCol = (u16)iCol;
        continue;
      }
    }
    if( sqlite3ExprIsInteger(pE2, &iCol) ){
      /* The ORDER BY term is an integer constant.  Again, set the column
      ** number so that sqlite3ResolveOrderGroupBy() will convert the
      ** order-by term to a copy of the result-set expression */
      if( iCol<1 || iCol>0xffff ){
        resolveOutOfRangeError(pParse, zType, i+1, nResult);
        return 1;
      }
      pItem->u.x.iOrderByCol = (u16)iCol;
      continue;
    }
 
    /* Otherwise, treat the ORDER BY term as an ordinary expression */
    pItem->u.x.iOrderByCol = 0;
    if( sqlite3ResolveExprNames(pNC, pE) ){
      return 1;
    }
    for(j=0; j<pSelect->pEList->nExpr; j++){
      if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
        /* Since this expresion is being changed into a reference
        ** to an identical expression in the result set, remove all Window
        ** objects belonging to the expression from the Select.pWin list. */
        windowRemoveExprFromSelect(pSelect, pE);

References ExprList::a, ExprList::nExpr, Select::pEList, ExprList::ExprList_item::pExpr, NameContext::pParse, resolveAsName(), resolveOutOfRangeError(), sqlite3ExprCompare(), sqlite3ExprIsInteger(), sqlite3ExprSkipCollateAndLikely(), sqlite3ResolveExprNames(), and windowRemoveExprFromSelect().

◆ resolveOutOfRangeError()

static void resolveOutOfRangeError	(	Parse *	pParse,
		const char *	zType,
		int	i,
		int	mx )

static

Definition at line 98975 of file sqlite3.c.

Referenced by resolveCompoundOrderBy(), resolveOrderGroupBy(), and sqlite3ResolveOrderGroupBy().

◆ resolveP2Values()

static void resolveP2Values	(	Vdbe *	p,
		int *	pMaxFuncArgs )

static

Definition at line 78521 of file sqlite3.c.

                                                       {
  int nMaxArgs = *pMaxFuncArgs;
  Op *pOp;
  Parse *pParse = p->pParse;
  int *aLabel = pParse->aLabel;
  p->readOnly = 1;
  p->bIsReader = 0;
  pOp = &p->aOp[p->nOp-1];
  while(1){
 
    /* Only JUMP opcodes and the short list of special opcodes in the switch
    ** below need to be considered.  The mkopcodeh.tcl generator script groups
    ** all these opcodes together near the front of the opcode list.  Skip
    ** any opcode that does not need processing by virtual of the fact that
    ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization.
    */
    if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){
      /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
      ** cases from this switch! */
      switch( pOp->opcode ){
        case OP_Transaction: {
          if( pOp->p2!=0 ) p->readOnly = 0;
          /* no break */ deliberate_fall_through
        }
        case OP_AutoCommit:
        case OP_Savepoint: {
          p->bIsReader = 1;
          break;
        }
#ifndef SQLITE_OMIT_WAL
        case OP_Checkpoint:
#endif
        case OP_Vacuum:
        case OP_JournalMode: {
          p->readOnly = 0;
          p->bIsReader = 1;
          break;
        }
        case OP_Next:
        case OP_SorterNext: {
          pOp->p4.xAdvance = sqlite3BtreeNext;
          pOp->p4type = P4_ADVANCE;
          /* The code generator never codes any of these opcodes as a jump
          ** to a label.  They are always coded as a jump backwards to a
          ** known address */
          assert( pOp->p2>=0 );
          break;
        }
        case OP_Prev: {
          pOp->p4.xAdvance = sqlite3BtreePrevious;
          pOp->p4type = P4_ADVANCE;
          /* The code generator never codes any of these opcodes as a jump
          ** to a label.  They are always coded as a jump backwards to a
          ** known address */
          assert( pOp->p2>=0 );
          break;
        }
#ifndef SQLITE_OMIT_VIRTUALTABLE
        case OP_VUpdate: {
          if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
          break;
        }
        case OP_VFilter: {
          int n;
          assert( (pOp - p->aOp) >= 3 );
          assert( pOp[-1].opcode==OP_Integer );
          n = pOp[-1].p1;
          if( n>nMaxArgs ) nMaxArgs = n;
          /* Fall through into the default case */
          /* no break */ deliberate_fall_through
        }
#endif
        default: {
          if( pOp->p2<0 ){
            /* The mkopcodeh.tcl script has so arranged things that the only
            ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
            ** have non-negative values for P2. */
            assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
            assert( ADDR(pOp->p2)<-pParse->nLabel );
            pOp->p2 = aLabel[ADDR(pOp->p2)];
          }
          break;
        }
      }
      /* The mkopcodeh.tcl script has so arranged things that the only
      ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
      ** have non-negative values for P2. */
      assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
    }
    if( pOp==p->aOp ) break;
    pOp--;
  }

References ADDR, Parse::aLabel, Vdbe::aOp, Vdbe::bIsReader, Vdbe::db, deliberate_fall_through, Parse::nLabel, Vdbe::nOp, OP_AutoCommit, OP_Checkpoint, OP_Integer, OP_JournalMode, OP_Next, OP_Prev, OP_Savepoint, OP_SorterNext, OP_Transaction, OP_Vacuum, OP_VFilter, OP_VUpdate, VdbeOp::opcode, OPFLG_JUMP, VdbeOp::p1, VdbeOp::p2, VdbeOp::p4, P4_ADVANCE, VdbeOp::p4type, Vdbe::pParse, Vdbe::readOnly, sqlite3BtreeNext(), sqlite3BtreePrevious(), sqlite3DbFree(), sqlite3OpcodeProperty, SQLITE_MX_JUMP_OPCODE, and VdbeOp::p4union::xAdvance.

Referenced by sqlite3VdbeMakeReady(), and sqlite3VdbeTakeOpArray().

◆ resolveRemoveWindowsCb()

static int resolveRemoveWindowsCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 99153 of file sqlite3.c.

99159 {

99160 UNUSED_PARAMETER(pWalker);

◆ resolveSelectStep()

static int resolveSelectStep	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 99259 of file sqlite3.c.

                                                        {
  NameContext *pOuterNC;  /* Context that contains this SELECT */
  NameContext sNC;        /* Name context of this SELECT */
  int isCompound;         /* True if p is a compound select */
  int nCompound;          /* Number of compound terms processed so far */
  Parse *pParse;          /* Parsing context */
  int i;                  /* Loop counter */
  ExprList *pGroupBy;     /* The GROUP BY clause */
  Select *pLeftmost;      /* Left-most of SELECT of a compound */
  sqlite3 *db;            /* Database connection */
 
 
  assert( p!=0 );
  if( p->selFlags & SF_Resolved ){
    return WRC_Prune;
  }
  pOuterNC = pWalker->u.pNC;
  pParse = pWalker->pParse;
  db = pParse->db;
 
  /* Normally sqlite3SelectExpand() will be called first and will have
  ** already expanded this SELECT.  However, if this is a subquery within
  ** an expression, sqlite3ResolveExprNames() will be called without a
  ** prior call to sqlite3SelectExpand().  When that happens, let
  ** sqlite3SelectPrep() do all of the processing for this SELECT.
  ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
  ** this routine in the correct order.
  */
  if( (p->selFlags & SF_Expanded)==0 ){
    sqlite3SelectPrep(pParse, p, pOuterNC);
    return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
  }
 
  isCompound = p->pPrior!=0;
  nCompound = 0;
  pLeftmost = p;
  while( p ){
    assert( (p->selFlags & SF_Expanded)!=0 );
    assert( (p->selFlags & SF_Resolved)==0 );
    p->selFlags |= SF_Resolved;
 
    /* Resolve the expressions in the LIMIT and OFFSET clauses. These
    ** are not allowed to refer to any names, so pass an empty NameContext.
    */
    memset(&sNC, 0, sizeof(sNC));
    sNC.pParse = pParse;
    sNC.pWinSelect = p;
    if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
      return WRC_Abort;
    }
 
    /* If the SF_Converted flags is set, then this Select object was
    ** was created by the convertCompoundSelectToSubquery() function.
    ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
    ** as if it were part of the sub-query, not the parent. This block
    ** moves the pOrderBy down to the sub-query. It will be moved back
    ** after the names have been resolved.  */
    if( p->selFlags & SF_Converted ){
      Select *pSub = p->pSrc->a[0].pSelect;
      assert( p->pSrc->nSrc==1 && p->pOrderBy );
      assert( pSub->pPrior && pSub->pOrderBy==0 );
      pSub->pOrderBy = p->pOrderBy;
      p->pOrderBy = 0;
    }
 
    /* Recursively resolve names in all subqueries
    */
    for(i=0; i<p->pSrc->nSrc; i++){
      struct SrcList_item *pItem = &p->pSrc->a[i];
      if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
        NameContext *pNC;         /* Used to iterate name contexts */
        int nRef = 0;             /* Refcount for pOuterNC and outer contexts */
        const char *zSavedContext = pParse->zAuthContext;
 
        /* Count the total number of references to pOuterNC and all of its
        ** parent contexts. After resolving references to expressions in
        ** pItem->pSelect, check if this value has changed. If so, then
        ** SELECT statement pItem->pSelect must be correlated. Set the
        ** pItem->fg.isCorrelated flag if this is the case. */
        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
 
        if( pItem->zName ) pParse->zAuthContext = pItem->zName;
        sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
        pParse->zAuthContext = zSavedContext;
        if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
 
        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
        assert( pItem->fg.isCorrelated==0 && nRef<=0 );
        pItem->fg.isCorrelated = (nRef!=0);
      }
    }
 
    /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
    ** resolve the result-set expression list.
    */
    sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
    sNC.pSrcList = p->pSrc;
    sNC.pNext = pOuterNC;
 
    /* Resolve names in the result set. */
    if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
    sNC.ncFlags &= ~NC_AllowWin;
 
    /* If there are no aggregate functions in the result-set, and no GROUP BY
    ** expression, do not allow aggregates in any of the other expressions.
    */
    assert( (p->selFlags & SF_Aggregate)==0 );
    pGroupBy = p->pGroupBy;
    if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
      assert( NC_MinMaxAgg==SF_MinMaxAgg );
      p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
    }else{
      sNC.ncFlags &= ~NC_AllowAgg;
    }
 
    /* If a HAVING clause is present, then there must be a GROUP BY clause.
    */
    if( p->pHaving && !pGroupBy ){
      sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
      return WRC_Abort;
    }
 
    /* Add the output column list to the name-context before parsing the
    ** other expressions in the SELECT statement. This is so that
    ** expressions in the WHERE clause (etc.) can refer to expressions by
    ** aliases in the result set.
    **
    ** Minor point: If this is the case, then the expression will be
    ** re-evaluated for each reference to it.
    */
    assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 );
    sNC.uNC.pEList = p->pEList;
    sNC.ncFlags |= NC_UEList;
    if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
 
    /* Resolve names in table-valued-function arguments */
    for(i=0; i<p->pSrc->nSrc; i++){
      struct SrcList_item *pItem = &p->pSrc->a[i];
      if( pItem->fg.isTabFunc
       && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
      ){
        return WRC_Abort;
      }
    }
 
    /* The ORDER BY and GROUP BY clauses may not refer to terms in
    ** outer queries
    */
    sNC.pNext = 0;
    sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
 
    /* If this is a converted compound query, move the ORDER BY clause from
    ** the sub-query back to the parent query. At this point each term
    ** within the ORDER BY clause has been transformed to an integer value.
    ** These integers will be replaced by copies of the corresponding result
    ** set expressions by the call to resolveOrderGroupBy() below.  */
    if( p->selFlags & SF_Converted ){
      Select *pSub = p->pSrc->a[0].pSelect;
      p->pOrderBy = pSub->pOrderBy;
      pSub->pOrderBy = 0;
    }
 
    /* Process the ORDER BY clause for singleton SELECT statements.
    ** The ORDER BY clause for compounds SELECT statements is handled
    ** below, after all of the result-sets for all of the elements of
    ** the compound have been resolved.
    **
    ** If there is an ORDER BY clause on a term of a compound-select other
    ** than the right-most term, then that is a syntax error.  But the error
    ** is not detected until much later, and so we need to go ahead and
    ** resolve those symbols on the incorrect ORDER BY for consistency.
    */
    if( isCompound<=nCompound  /* Defer right-most ORDER BY of a compound */
     && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
    ){
      return WRC_Abort;
    }
    if( db->mallocFailed ){
      return WRC_Abort;
    }
    sNC.ncFlags &= ~NC_AllowWin;
 
    /* Resolve the GROUP BY clause.  At the same time, make sure
    ** the GROUP BY clause does not contain aggregate functions.
    */
    if( pGroupBy ){
      struct ExprList_item *pItem;
 
      if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
        return WRC_Abort;
      }
      for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
        if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
          sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
              "the GROUP BY clause");
          return WRC_Abort;
        }
      }
    }
 
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( IN_RENAME_OBJECT ){
      Window *pWin;
      for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
        if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
         || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
        ){
          return WRC_Abort;
        }
      }
    }
#endif
 
    /* If this is part of a compound SELECT, check that it has the right
    ** number of expressions in the select list. */
    if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
      sqlite3SelectWrongNumTermsError(pParse, p->pNext);
      return WRC_Abort;
    }
 
    /* Advance to the next term of the compound
    */
    p = p->pPrior;
    nCompound++;
  }
 
  /* Resolve the ORDER BY on a compound SELECT after all terms of
  ** the compound have been resolved.
  */

Referenced by sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), and sqlite3ResolveSelectNames().

◆ returnSingleInt()

static void returnSingleInt	(	Vdbe *	v,
		i64	value )

static

Definition at line 125926 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ returnSingleText()

static void returnSingleText	(	Vdbe *	v,
		const char *	zValue )

static

Definition at line 125934 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ robust_close()

static void robust_close	(	unixFile *	pFile,
		int	h,
		int	lineno )

static

Definition at line 34828 of file sqlite3.c.

References osClose, SQLITE_IOERR_CLOSE, unixLogErrorAtLine(), and unixFile::zPath.

Referenced by closeUnixFile(), unixDelete(), unixOpen(), unixRandomness(), unixShmPurge(), and unixSync().

◆ robust_ftruncate()

static int robust_ftruncate	(	int	h,
		sqlite3_int64	sz )

static

Definition at line 34379 of file sqlite3.c.

                                                    {
  int rc;
#ifdef __ANDROID__
  /* On Android, ftruncate() always uses 32-bit offsets, even if
  ** _FILE_OFFSET_BITS=64 is defined. This means it is unsafe to attempt to
  ** truncate a file to any size larger than 2GiB. Silently ignore any
  ** such attempts.  */
  if( sz>(sqlite3_int64)0x7FFFFFFF ){

References osFtruncate, and SQLITE_OK.

Referenced by fcntlSizeHint(), and unixLockSharedMemory().

◆ robust_open()

static int robust_open	(	const char *	z,
		int	f,
		mode_t	m )

static

Definition at line 34216 of file sqlite3.c.

                                                      {
  int fd;
  mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;
  while(1){
#if defined(O_CLOEXEC)
    fd = osOpen(z,f|O_CLOEXEC,m2);
#else
    fd = osOpen(z,f,m2);
#endif
    if( fd<0 ){
      if( errno==EINTR ) continue;
      break;
    }
    if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;
    osClose(fd);
    sqlite3_log(SQLITE_WARNING,
                "attempt to open \"%s\" as file descriptor %d", z, fd);
    fd = -1;
    if( osOpen("/dev/null", O_RDONLY, m)<0 ) break;
  }
  if( fd>=0 ){
    if( m!=0 ){
      struct stat statbuf;
      if( osFstat(fd, &statbuf)==0
       && statbuf.st_size==0
       && (statbuf.st_mode&0777)!=m
      ){
        osFchmod(fd, m);
      }
    }

References osClose, osFchmod, osFcntl, osFstat, osOpen, sqlite3_log(), SQLITE_DEFAULT_FILE_PERMISSIONS, SQLITE_MINIMUM_FILE_DESCRIPTOR, and SQLITE_WARNING.

Referenced by openDirectory(), unixOpen(), unixOpenSharedMemory(), and unixRandomness().

◆ robustFchown()

static int robustFchown	(	int	fd,
		uid_t	uid,
		gid_t	gid )

static

Definition at line 34099 of file sqlite3.c.

34105 {

References osFchown, and osGeteuid.

Referenced by unixOpen(), and unixOpenSharedMemory().

◆ roundFunc()

static void roundFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117438 of file sqlite3.c.

                                                                               {
  int n = 0;
  double r;
  char *zBuf;
  assert( argc==1 || argc==2 );
  if( argc==2 ){
    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
    n = sqlite3_value_int(argv[1]);
    if( n>30 ) n = 30;
    if( n<0 ) n = 0;
  }
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  r = sqlite3_value_double(argv[0]);
  /* If Y==0 and X will fit in a 64-bit int,
  ** handle the rounding directly,
  ** otherwise use printf.
  */
  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
    /* The value has no fractional part so there is nothing to round */
  }else if( n==0 ){
    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
  }else{
    zBuf = sqlite3_mprintf("%.*f",n,r);
    if( zBuf==0 ){
      sqlite3_result_error_nomem(context);
      return;

Referenced by sqlite3RegisterBuiltinFunctions().

◆ row_numberStepFunc()

static void row_numberStepFunc	(	sqlite3_context *	pCtx,
		int	nArg,
		sqlite3_value **	apArg )

static

Definition at line 151306 of file sqlite3.c.

◆ row_numberValueFunc()

static void row_numberValueFunc ( sqlite3_context * pCtx )

static

Definition at line 151316 of file sqlite3.c.

 {
  i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ) (*p)++;
  UNUSED_PARAMETER(nArg);

References sqlite3_aggregate_context(), and UNUSED_PARAMETER.

◆ rowSetEntryAlloc()

static struct RowSetEntry * rowSetEntryAlloc ( RowSet * p )

static

Definition at line 51223 of file sqlite3.c.

                                                      {
  assert( p!=0 );
  if( p->nFresh==0 ){  /*OPTIMIZATION-IF-FALSE*/
    /* We could allocate a fresh RowSetEntry each time one is needed, but it
    ** is more efficient to pull a preallocated entry from the pool */
    struct RowSetChunk *pNew;
    pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
    if( pNew==0 ){
      return 0;
    }
    pNew->pNextChunk = p->pChunk;
    p->pChunk = pNew;

References RowSetChunk::aEntry, RowSet::db, RowSet::nFresh, RowSet::pChunk, RowSet::pFresh, RowSetChunk::pNextChunk, ROWSET_ENTRY_PER_CHUNK, and sqlite3DbMallocRawNN().

Referenced by sqlite3RowSetInsert(), and sqlite3RowSetTest().

◆ rowSetEntryMerge()

static struct RowSetEntry * rowSetEntryMerge	(	struct RowSetEntry *	pA,
		struct RowSetEntry *	pB )

static

Definition at line 51279 of file sqlite3.c.

 {
  struct RowSetEntry head;
  struct RowSetEntry *pTail;
 
  pTail = &head;
  assert( pA!=0 && pB!=0 );
  for(;;){
    assert( pA->pRight==0 || pA->v<=pA->pRight->v );
    assert( pB->pRight==0 || pB->v<=pB->pRight->v );
    if( pA->v<=pB->v ){
      if( pA->v<pB->v ) pTail = pTail->pRight = pA;
      pA = pA->pRight;
      if( pA==0 ){
        pTail->pRight = pB;
        break;
      }
    }else{
      pTail = pTail->pRight = pB;
      pB = pB->pRight;
      if( pB==0 ){
        pTail->pRight = pA;

References RowSetEntry::pRight, and RowSetEntry::v.

Referenced by sqlite3RowSetTest().

◆ rowSetEntrySort()

static struct RowSetEntry * rowSetEntrySort ( struct RowSetEntry * pIn )

static

Definition at line 51314 of file sqlite3.c.

                                                                   {
  unsigned int i;
  struct RowSetEntry *pNext, *aBucket[40];
 
  memset(aBucket, 0, sizeof(aBucket));
  while( pIn ){
    pNext = pIn->pRight;
    pIn->pRight = 0;
    for(i=0; aBucket[i]; i++){
      pIn = rowSetEntryMerge(aBucket[i], pIn);
      aBucket[i] = 0;
    }
    aBucket[i] = pIn;
    pIn = pNext;
  }
  pIn = aBucket[0];

Referenced by sqlite3RowSetNext(), and sqlite3RowSetTest().

◆ rowSetListToTree()

static struct RowSetEntry * rowSetListToTree ( struct RowSetEntry * pList )

static

Definition at line 51414 of file sqlite3.c.

                                                                      {
  int iDepth;           /* Depth of the tree so far */
  struct RowSetEntry *p;       /* Current tree root */
  struct RowSetEntry *pLeft;   /* Left subtree */
 
  assert( pList!=0 );
  p = pList;
  pList = p->pRight;
  p->pLeft = p->pRight = 0;
  for(iDepth=1; pList; iDepth++){
    pLeft = p;
    p = pList;

Referenced by sqlite3RowSetTest().

◆ rowSetNDeepTree()

static struct RowSetEntry * rowSetNDeepTree	(	struct RowSetEntry **	ppList,
		int	iDepth )

static

Definition at line 51378 of file sqlite3.c.

 {
  struct RowSetEntry *p;         /* Root of the new tree */
  struct RowSetEntry *pLeft;     /* Left subtree */
  if( *ppList==0 ){ /*OPTIMIZATION-IF-TRUE*/
    /* Prevent unnecessary deep recursion when we run out of entries */
    return 0;
  }
  if( iDepth>1 ){   /*OPTIMIZATION-IF-TRUE*/
    /* This branch causes a *balanced* tree to be generated.  A valid tree
    ** is still generated without this branch, but the tree is wildly
    ** unbalanced and inefficient. */
    pLeft = rowSetNDeepTree(ppList, iDepth-1);
    p = *ppList;
    if( p==0 ){     /*OPTIMIZATION-IF-FALSE*/
      /* It is safe to always return here, but the resulting tree
      ** would be unbalanced */
      return pLeft;
    }
    p->pLeft = pLeft;
    *ppList = p->pRight;
    p->pRight = rowSetNDeepTree(ppList, iDepth-1);
  }else{

References RowSetEntry::pLeft, RowSetEntry::pRight, and rowSetNDeepTree().

Referenced by rowSetNDeepTree().

◆ rowSetTreeToList()

static void rowSetTreeToList	(	struct RowSetEntry *	pIn,
		struct RowSetEntry **	ppFirst,
		struct RowSetEntry **	ppLast )

static

Definition at line 51343 of file sqlite3.c.

 {
  assert( pIn!=0 );
  if( pIn->pLeft ){
    struct RowSetEntry *p;
    rowSetTreeToList(pIn->pLeft, ppFirst, &p);
    p->pRight = pIn;
  }else{
    *ppFirst = pIn;
  }
  if( pIn->pRight ){

References RowSetEntry::pLeft, RowSetEntry::pRight, and rowSetTreeToList().

Referenced by rowSetTreeToList(), and sqlite3RowSetTest().

◆ rtrimCollFunc()

static int rtrimCollFunc	(	void *	pUser,
		int	nKey1,
		const void *	pKey1,
		int	nKey2,
		const void *	pKey2 )

static

Definition at line 162008 of file sqlite3.c.

162018 {

Referenced by openDatabase().

◆ saveAllCursors()

static int saveAllCursors	(	BtShared *	pBt,
		Pgno	iRoot,
		BtCursor *	pExcept )

static

Definition at line 65224 of file sqlite3.c.

                      :  This routine merely checks to see if any cursors
** need to be saved.  It calls out to saveCursorsOnList() in the (unusual)
** event that cursors are in need to being saved.
*/
static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
  BtCursor *p;
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( pExcept==0 || pExcept->pBt==pBt );
  for(p=pBt->pCursor; p; p=p->pNext){

References BtCursor::curFlags, BtShared::mutex, BtCursor::pBt, BtShared::pCursor, BtCursor::pgnoRoot, BtCursor::pNext, saveCursorsOnList(), sqlite3_mutex_held(), and SQLITE_OK.

Referenced by autoVacuumCommit(), btreeCreateTable(), sqlite3BtreeClearTable(), sqlite3BtreeDelete(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreePutData(), sqlite3BtreeRollback(), and sqlite3BtreeSavepoint().

◆ saveCursorKey()

static int saveCursorKey ( BtCursor * pCur )

static

Definition at line 65132 of file sqlite3.c.

                                        {
  int rc = SQLITE_OK;
  assert( CURSOR_VALID==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );
 
  if( pCur->curIntKey ){
    /* Only the rowid is required for a table btree */
    pCur->nKey = sqlite3BtreeIntegerKey(pCur);
  }else{
    /* For an index btree, save the complete key content. It is possible
    ** that the current key is corrupt. In that case, it is possible that
    ** the sqlite3VdbeRecordUnpack() function may overread the buffer by
    ** up to the size of 1 varint plus 1 8-byte value when the cursor
    ** position is restored. Hence the 17 bytes of padding allocated
    ** below. */
    void *pKey;
    pCur->nKey = sqlite3BtreePayloadSize(pCur);
    pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
    if( pKey ){
      rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
      if( rc==SQLITE_OK ){
        memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
        pCur->pKey = pKey;
      }else{
        sqlite3_free(pKey);
      }
    }else{

References BtCursor::curIntKey, CURSOR_VALID, BtCursor::eState, BtCursor::nKey, BtCursor::pKey, sqlite3_free(), sqlite3BtreeIntegerKey(), sqlite3BtreePayload(), sqlite3BtreePayloadSize(), sqlite3Malloc(), SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by saveCursorPosition(), and sqlite3BtreeDelete().

◆ saveCursorPosition()

static int saveCursorPosition ( BtCursor * pCur )

static

Definition at line 65174 of file sqlite3.c.

                                             {
  int rc;
 
  assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );
 
  if( pCur->curFlags & BTCF_Pinned ){
    return SQLITE_CONSTRAINT_PINNED;
  }
  if( pCur->eState==CURSOR_SKIPNEXT ){
    pCur->eState = CURSOR_VALID;
  }else{
    pCur->skipNext = 0;
  }
 
  rc = saveCursorKey(pCur);
  if( rc==SQLITE_OK ){
    btreeReleaseAllCursorPages(pCur);

References BTCF_AtLast, BTCF_Pinned, BTCF_ValidNKey, BTCF_ValidOvfl, btreeReleaseAllCursorPages(), BtCursor::curFlags, CURSOR_REQUIRESEEK, CURSOR_SKIPNEXT, CURSOR_VALID, BtCursor::eState, BtCursor::pKey, saveCursorKey(), BtCursor::skipNext, SQLITE_CONSTRAINT_PINNED, and SQLITE_OK.

Referenced by saveCursorsOnList(), and sqlite3BtreeTripAllCursors().

◆ saveCursorsOnList()

static int SQLITE_NOINLINE saveCursorsOnList	(	BtCursor *	p,
		Pgno	iRoot,
		BtCursor *	pExcept )

static

Definition at line 65241 of file sqlite3.c.

 {
  do{
    if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){
      if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
        int rc = saveCursorPosition(p);
        if( SQLITE_OK!=rc ){
          return rc;
        }
      }else{
        testcase( p->iPage>=0 );
        btreeReleaseAllCursorPages(p);

References btreeReleaseAllCursorPages(), CURSOR_SKIPNEXT, CURSOR_VALID, BtCursor::eState, BtCursor::iPage, BtCursor::pgnoRoot, BtCursor::pNext, saveCursorPosition(), SQLITE_OK, and testcase.

Referenced by saveAllCursors().

◆ schemaIsValid()

static void schemaIsValid ( Parse * pParse )

static

Definition at line 128803 of file sqlite3.c.

                                        {
  sqlite3 *db = pParse->db;
  int iDb;
  int rc;
  int cookie;
 
  assert( pParse->checkSchema );
  assert( sqlite3_mutex_held(db->mutex) );
  for(iDb=0; iDb<db->nDb; iDb++){
    int openedTransaction = 0;         /* True if a transaction is opened */
    Btree *pBt = db->aDb[iDb].pBt;     /* Btree database to read cookie from */
    if( pBt==0 ) continue;
 
    /* If there is not already a read-only (or read-write) transaction opened
    ** on the b-tree database, open one now. If a transaction is opened, it
    ** will be closed immediately after reading the meta-value. */
    if( !sqlite3BtreeIsInReadTrans(pBt) ){
      rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
      if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
        sqlite3OomFault(db);
      }
      if( rc!=SQLITE_OK ) return;
      openedTransaction = 1;
    }
 
    /* Read the schema cookie from the database. If it does not match the
    ** value stored as part of the in-memory schema representation,
    ** set Parse.rc to SQLITE_SCHEMA. */
    sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
      sqlite3ResetOneSchema(db, iDb);
      pParse->rc = SQLITE_SCHEMA;
    }
 

References sqlite3::aDb, BTREE_SCHEMA_VERSION, Parse::checkSchema, Parse::db, sqlite3::mutex, sqlite3::nDb, Db::pBt, Db::pSchema, Parse::rc, Schema::schema_cookie, sqlite3_mutex_held(), sqlite3BtreeBeginTrans(), sqlite3BtreeCommit(), sqlite3BtreeGetMeta(), sqlite3BtreeIsInReadTrans(), sqlite3OomFault(), sqlite3ResetOneSchema(), SQLITE_IOERR_NOMEM, SQLITE_NOMEM, SQLITE_OK, and SQLITE_SCHEMA.

◆ searchWith()

static struct Cte * searchWith	(	With *	pWith,
		struct SrcList_item *	pItem,
		With **	ppContext )

static

Definition at line 134015 of file sqlite3.c.

 {
  const char *zName;
  if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
    With *p;
    for(p=pWith; p; p=p->pOuter){
      int i;
      for(i=0; i<p->nCte; i++){
        if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
          *ppContext = p;
          return &p->a[i];

References With::a, With::nCte, With::pOuter, sqlite3StrICmp(), With::Cte::zName, and zName.

Referenced by withExpand().

◆ seekAndRead()

static int seekAndRead	(	unixFile *	id,
		sqlite3_int64	offset,
		void *	pBuf,
		int	cnt )

static

Definition at line 36824 of file sqlite3.c.

                                                                               {
  int got;
  int prior = 0;
#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
  i64 newOffset;
#endif
  TIMER_START;
  assert( cnt==(cnt&0x1ffff) );
  assert( id->h>2 );
  do{
#if defined(USE_PREAD)
    got = osPread(id->h, pBuf, cnt, offset);
    SimulateIOError( got = -1 );
#elif defined(USE_PREAD64)
    got = osPread64(id->h, pBuf, cnt, offset);
    SimulateIOError( got = -1 );
#else
    newOffset = lseek(id->h, offset, SEEK_SET);
    SimulateIOError( newOffset = -1 );
    if( newOffset<0 ){
      storeLastErrno((unixFile*)id, errno);
      return -1;
    }
    got = osRead(id->h, pBuf, cnt);
#endif
    if( got==cnt ) break;
    if( got<0 ){
      if( errno==EINTR ){ got = 1; continue; }
      prior = 0;
      storeLastErrno((unixFile*)id,  errno);
      break;
    }else if( got>0 ){
      cnt -= got;
      offset += got;
      prior += got;
      pBuf = (void*)(got + (char*)pBuf);
    }

References unixFile::h, osPread, osPread64, osRead, OSTRACE, SimulateIOError, storeLastErrno(), TIMER_ELAPSED, TIMER_END, and TIMER_START.

Referenced by unixRead(), and unixWrite().

◆ seekAndWrite()

static int seekAndWrite	(	unixFile *	id,
		i64	offset,
		const void *	pBuf,
		int	cnt )

static

Definition at line 36978 of file sqlite3.c.

References unixFile::h, unixFile::lastErrno, and seekAndWriteFd().

Referenced by fcntlSizeHint(), and unixWrite().

◆ seekAndWriteFd()

static int seekAndWriteFd	(	int	fd,
		i64	iOff,
		const void *	pBuf,
		int	nBuf,
		int *	piErrno )

static

Definition at line 36932 of file sqlite3.c.

 {
  int rc = 0;                     /* Value returned by system call */
 
  assert( nBuf==(nBuf&0x1ffff) );
  assert( fd>2 );
  assert( piErrno!=0 );
  nBuf &= 0x1ffff;
  TIMER_START;
 
#if defined(USE_PREAD)
  do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );
#elif defined(USE_PREAD64)
  do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);
#else
  do{
    i64 iSeek = lseek(fd, iOff, SEEK_SET);
    SimulateIOError( iSeek = -1 );
    if( iSeek<0 ){
      rc = -1;
      break;
    }
    rc = osWrite(fd, pBuf, nBuf);
  }while( rc<0 && errno==EINTR );
#endif
 

References osPwrite, osPwrite64, OSTRACE, osWrite, SimulateIOError, TIMER_ELAPSED, TIMER_END, and TIMER_START.

Referenced by seekAndWrite(), and unixShmMap().

◆ selectAddSubqueryTypeInfo()

static void selectAddSubqueryTypeInfo	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 134606 of file sqlite3.c.

                                                                 {
  Parse *pParse;
  int i;
  SrcList *pTabList;
  struct SrcList_item *pFrom;
 
  assert( p->selFlags & SF_Resolved );
  if( p->selFlags & SF_HasTypeInfo ) return;
  p->selFlags |= SF_HasTypeInfo;
  pParse = pWalker->pParse;
  pTabList = p->pSrc;
  for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
    Table *pTab = pFrom->pTab;
    assert( pTab!=0 );
    if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
      /* A sub-query in the FROM clause of a SELECT */
      Select *pSel = pFrom->pSelect;
      if( pSel ){
        while( pSel->pPrior ) pSel = pSel->pPrior;

References SrcList::a, SrcList::nSrc, Walker::pParse, Select::pPrior, Select::pSrc, Select::selFlags, SF_HasTypeInfo, SF_Resolved, sqlite3SelectAddColumnTypeAndCollation(), SQLITE_AFF_NONE, Table::tabFlags, and TF_Ephemeral.

Referenced by sqlite3SelectAddTypeInfo().

◆ selectExpander()

static int selectExpander	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 134266 of file sqlite3.c.

                                                     {
  Parse *pParse = pWalker->pParse;
  int i, j, k;
  SrcList *pTabList;
  ExprList *pEList;
  struct SrcList_item *pFrom;
  sqlite3 *db = pParse->db;
  Expr *pE, *pRight, *pExpr;
  u16 selFlags = p->selFlags;
  u32 elistFlags = 0;
 
  p->selFlags |= SF_Expanded;
  if( db->mallocFailed  ){
    return WRC_Abort;
  }
  assert( p->pSrc!=0 );
  if( (selFlags & SF_Expanded)!=0 ){
    return WRC_Prune;
  }
  if( pWalker->eCode ){
    /* Renumber selId because it has been copied from a view */
    p->selId = ++pParse->nSelect;
  }
  pTabList = p->pSrc;
  pEList = p->pEList;
  sqlite3WithPush(pParse, p->pWith, 0);
 
  /* Make sure cursor numbers have been assigned to all entries in
  ** the FROM clause of the SELECT statement.
  */
  sqlite3SrcListAssignCursors(pParse, pTabList);
 
  /* Look up every table named in the FROM clause of the select.  If
  ** an entry of the FROM clause is a subquery instead of a table or view,
  ** then create a transient table structure to describe the subquery.
  */
  for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
    Table *pTab;
    assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
    if( pFrom->pTab ) continue;
    assert( pFrom->fg.isRecursive==0 );
#ifndef SQLITE_OMIT_CTE
    if( withExpand(pWalker, pFrom) ) return WRC_Abort;
    if( pFrom->pTab ) {} else
#endif
    if( pFrom->zName==0 ){
#ifndef SQLITE_OMIT_SUBQUERY
      Select *pSel = pFrom->pSelect;
      /* A sub-query in the FROM clause of a SELECT */
      assert( pSel!=0 );
      assert( pFrom->pTab==0 );
      if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
      if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
#endif
    }else{
      /* An ordinary table or view name in the FROM clause */
      assert( pFrom->pTab==0 );
      pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
      if( pTab==0 ) return WRC_Abort;
      if( pTab->nTabRef>=0xffff ){
        sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
           pTab->zName);
        pFrom->pTab = 0;
        return WRC_Abort;
      }
      pTab->nTabRef++;
      if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
        return WRC_Abort;
      }
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
      if( IsVirtual(pTab) || pTab->pSelect ){
        i16 nCol;
        u8 eCodeOrig = pWalker->eCode;
        if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
        assert( pFrom->pSelect==0 );
        if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){
          sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
            pTab->zName);
        }
#ifndef SQLITE_OMIT_VIRTUALTABLE
        if( IsVirtual(pTab)
         && pFrom->fg.fromDDL
         && ALWAYS(pTab->pVTable!=0)
         && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
        ){
          sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
                                  pTab->zName);
        }
#endif
        pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
        nCol = pTab->nCol;
        pTab->nCol = -1;
        pWalker->eCode = 1;  /* Turn on Select.selId renumbering */
        sqlite3WalkSelect(pWalker, pFrom->pSelect);
        pWalker->eCode = eCodeOrig;
        pTab->nCol = nCol;
      }
#endif
    }
 
    /* Locate the index named by the INDEXED BY clause, if any. */
    if( sqlite3IndexedByLookup(pParse, pFrom) ){
      return WRC_Abort;
    }
  }
 
  /* Process NATURAL keywords, and ON and USING clauses of joins.
  */
  if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){
    return WRC_Abort;
  }
 
  /* For every "*" that occurs in the column list, insert the names of
  ** all columns in all tables.  And for every TABLE.* insert the names
  ** of all columns in TABLE.  The parser inserted a special expression
  ** with the TK_ASTERISK operator for each "*" that it found in the column
  ** list.  The following code just has to locate the TK_ASTERISK
  ** expressions and expand each one to the list of all columns in
  ** all tables.
  **
  ** The first loop just checks to see if there are any "*" operators
  ** that need expanding.
  */
  for(k=0; k<pEList->nExpr; k++){
    pE = pEList->a[k].pExpr;
    if( pE->op==TK_ASTERISK ) break;
    assert( pE->op!=TK_DOT || pE->pRight!=0 );
    assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
    if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break;
    elistFlags |= pE->flags;
  }
  if( k<pEList->nExpr ){
    /*
    ** If we get here it means the result set contains one or more "*"
    ** operators that need to be expanded.  Loop through each expression
    ** in the result set and expand them one by one.
    */
    struct ExprList_item *a = pEList->a;
    ExprList *pNew = 0;
    int flags = pParse->db->flags;
    int longNames = (flags & SQLITE_FullColNames)!=0
                      && (flags & SQLITE_ShortColNames)==0;
 
    for(k=0; k<pEList->nExpr; k++){
      pE = a[k].pExpr;
      elistFlags |= pE->flags;
      pRight = pE->pRight;
      assert( pE->op!=TK_DOT || pRight!=0 );
      if( pE->op!=TK_ASTERISK
       && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
      ){
        /* This particular expression does not need to be expanded.
        */
        pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
        if( pNew ){
          pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
          pNew->a[pNew->nExpr-1].eEName = a[k].eEName;
          a[k].zEName = 0;
        }
        a[k].pExpr = 0;
      }else{
        /* This expression is a "*" or a "TABLE.*" and needs to be
        ** expanded. */
        int tableSeen = 0;      /* Set to 1 when TABLE matches */
        char *zTName = 0;       /* text of name of TABLE */
        if( pE->op==TK_DOT ){
          assert( pE->pLeft!=0 );
          assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
          zTName = pE->pLeft->u.zToken;
        }
        for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
          Table *pTab = pFrom->pTab;
          Select *pSub = pFrom->pSelect;
          char *zTabName = pFrom->zAlias;
          const char *zSchemaName = 0;
          int iDb;
          if( zTabName==0 ){
            zTabName = pTab->zName;
          }
          if( db->mallocFailed ) break;
          if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
            pSub = 0;
            if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
              continue;
            }
            iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
            zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
          }
          for(j=0; j<pTab->nCol; j++){
            char *zName = pTab->aCol[j].zName;
            char *zColname;  /* The computed column name */
            char *zToFree;   /* Malloced string that needs to be freed */
            Token sColname;  /* Computed column name as a token */
 
            assert( zName );
            if( zTName && pSub
             && sqlite3MatchEName(&pSub->pEList->a[j], 0, zTName, 0)==0
            ){
              continue;
            }
 
            /* If a column is marked as 'hidden', omit it from the expanded
            ** result-set list unless the SELECT has the SF_IncludeHidden
            ** bit set.
            */
            if( (p->selFlags & SF_IncludeHidden)==0
             && IsHiddenColumn(&pTab->aCol[j])
            ){
              continue;
            }
            tableSeen = 1;
 
            if( i>0 && zTName==0 ){
              if( (pFrom->fg.jointype & JT_NATURAL)!=0
                && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
              ){
                /* In a NATURAL join, omit the join columns from the
                ** table to the right of the join */
                continue;
              }
              if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
                /* In a join with a USING clause, omit columns in the
                ** using clause from the table on the right. */
                continue;
              }
            }
            pRight = sqlite3Expr(db, TK_ID, zName);
            zColname = zName;
            zToFree = 0;
            if( longNames || pTabList->nSrc>1 ){
              Expr *pLeft;
              pLeft = sqlite3Expr(db, TK_ID, zTabName);
              pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
              if( zSchemaName ){
                pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
                pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
              }
              if( longNames ){
                zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
                zToFree = zColname;
              }
            }else{
              pExpr = pRight;
            }
            pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
            sqlite3TokenInit(&sColname, zColname);
            sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
            if( pNew && (p->selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){
              struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
              sqlite3DbFree(db, pX->zEName);
              if( pSub ){
                pX->zEName = sqlite3DbStrDup(db, pSub->pEList->a[j].zEName);
                testcase( pX->zEName==0 );
              }else{
                pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
                                           zSchemaName, zTabName, zColname);
                testcase( pX->zEName==0 );
              }
              pX->eEName = ENAME_TAB;
            }
            sqlite3DbFree(db, zToFree);
          }
        }
        if( !tableSeen ){
          if( zTName ){
            sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
          }else{
            sqlite3ErrorMsg(pParse, "no tables specified");
          }
        }
      }
    }
    sqlite3ExprListDelete(db, pEList);
    p->pEList = pNew;
  }
  if( p->pEList ){
    if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
      sqlite3ErrorMsg(pParse, "too many columns in result set");
      return WRC_Abort;
    }

References ExprList::a, SrcList::a, Table::aCol, sqlite3::aDb, sqlite3::aLimit, ALWAYS, cannotBeFunction(), Parse::db, Walker::eCode, ExprList::ExprList_item::eEName, ENAME_TAB, EP_HasFunc, EP_IntValue, EP_Subquery, VTable::eVtabRisk, ExprHasProperty, sqlite3::flags, Expr::flags, IN_RENAME_OBJECT, IsHiddenColumn, IsVirtual, JT_NATURAL, sqlite3::mallocFailed, Table::nCol, Parse::nErr, ExprList::nExpr, Parse::nSelect, SrcList::nSrc, Table::nTabRef, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Walker::pParse, Expr::pRight, Table::pSchema, Table::pSelect, Select::pSrc, Table::pVTable, Select::pWith, Select::selFlags, Select::selId, SF_ComplexResult, SF_Expanded, SF_IncludeHidden, SF_NestedFrom, sqlite3DbFree(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3ExpandSubquery(), sqlite3Expr(), sqlite3ExprListAppend(), sqlite3ExprListDelete(), sqlite3ExprListSetName(), sqlite3IdListIndex(), sqlite3IndexedByLookup(), sqlite3LocateTableItem(), sqlite3MatchEName(), sqlite3MPrintf(), sqlite3PExpr(), sqlite3SchemaToIndex(), sqlite3SelectDup(), sqlite3SrcListAssignCursors(), sqlite3StrICmp(), sqlite3TokenInit(), sqlite3ViewGetColumnNames(), sqlite3WalkSelect(), sqlite3WithPush(), SQLITE_EnableView, SQLITE_FullColNames, SQLITE_LIMIT_COLUMN, SQLITE_ShortColNames, SQLITE_TrustedSchema, sqliteProcessJoin(), tableAndColumnIndex(), testcase, TK_ASTERISK, TK_DOT, TK_ID, Expr::u, withExpand(), WRC_Abort, WRC_Continue, WRC_Prune, Db::zDbSName, ExprList::ExprList_item::zEName, Column::zName, Table::zName, zName, and Expr::zToken.

Referenced by sqlite3SelectExpand().

◆ selectInnerLoop()

static void selectInnerLoop	(	Parse *	pParse,
		Select *	p,
		int	srcTab,
		SortCtx *	pSort,
		DistinctCtx *	pDistinct,
		SelectDest *	pDest,
		int	iContinue,
		int	iBreak )

static

Definition at line 130147 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  int i;
  int hasDistinct;            /* True if the DISTINCT keyword is present */
  int eDest = pDest->eDest;   /* How to dispose of results */
  int iParm = pDest->iSDParm; /* First argument to disposal method */
  int nResultCol;             /* Number of result columns */
  int nPrefixReg = 0;         /* Number of extra registers before regResult */
  RowLoadInfo sRowLoadInfo;   /* Info for deferred row loading */
 
  /* Usually, regResult is the first cell in an array of memory cells
  ** containing the current result row. In this case regOrig is set to the
  ** same value. However, if the results are being sent to the sorter, the
  ** values for any expressions that are also part of the sort-key are omitted
  ** from this array. In this case regOrig is set to zero.  */
  int regResult;              /* Start of memory holding current results */
  int regOrig;                /* Start of memory holding full result (or 0) */
 
  assert( v );
  assert( p->pEList!=0 );
  hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
  if( pSort && pSort->pOrderBy==0 ) pSort = 0;
  if( pSort==0 && !hasDistinct ){
    assert( iContinue!=0 );
    codeOffset(v, p->iOffset, iContinue);
  }
 
  /* Pull the requested columns.
  */
  nResultCol = p->pEList->nExpr;
 
  if( pDest->iSdst==0 ){
    if( pSort ){
      nPrefixReg = pSort->pOrderBy->nExpr;
      if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;
      pParse->nMem += nPrefixReg;
    }
    pDest->iSdst = pParse->nMem+1;
    pParse->nMem += nResultCol;
  }else if( pDest->iSdst+nResultCol > pParse->nMem ){
    /* This is an error condition that can result, for example, when a SELECT
    ** on the right-hand side of an INSERT contains more result columns than
    ** there are columns in the table on the left.  The error will be caught
    ** and reported later.  But we need to make sure enough memory is allocated
    ** to avoid other spurious errors in the meantime. */
    pParse->nMem += nResultCol;
  }
  pDest->nSdst = nResultCol;
  regOrig = regResult = pDest->iSdst;
  if( srcTab>=0 ){
    for(i=0; i<nResultCol; i++){
      sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
      VdbeComment((v, "%s", p->pEList->a[i].zEName));
    }
  }else if( eDest!=SRT_Exists ){
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    ExprList *pExtra = 0;
#endif
    /* If the destination is an EXISTS(...) expression, the actual
    ** values returned by the SELECT are not required.
    */
    u8 ecelFlags;    /* "ecel" is an abbreviation of "ExprCodeExprList" */
    ExprList *pEList;
    if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){
      ecelFlags = SQLITE_ECEL_DUP;
    }else{
      ecelFlags = 0;
    }
    if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){
      /* For each expression in p->pEList that is a copy of an expression in
      ** the ORDER BY clause (pSort->pOrderBy), set the associated
      ** iOrderByCol value to one more than the index of the ORDER BY
      ** expression within the sort-key that pushOntoSorter() will generate.
      ** This allows the p->pEList field to be omitted from the sorted record,
      ** saving space and CPU cycles.  */
      ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);
 
      for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
        int j;
        if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
          p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
        }
      }
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
      selectExprDefer(pParse, pSort, p->pEList, &pExtra);
      if( pExtra && pParse->db->mallocFailed==0 ){
        /* If there are any extra PK columns to add to the sorter records,
        ** allocate extra memory cells and adjust the OpenEphemeral
        ** instruction to account for the larger records. This is only
        ** required if there are one or more WITHOUT ROWID tables with
        ** composite primary keys in the SortCtx.aDefer[] array.  */
        VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
        pOp->p2 += (pExtra->nExpr - pSort->nDefer);
        pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
        pParse->nMem += pExtra->nExpr;
      }
#endif
 
      /* Adjust nResultCol to account for columns that are omitted
      ** from the sorter by the optimizations in this branch */
      pEList = p->pEList;
      for(i=0; i<pEList->nExpr; i++){
        if( pEList->a[i].u.x.iOrderByCol>0
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
         || pEList->a[i].bSorterRef
#endif
        ){
          nResultCol--;
          regOrig = 0;
        }
      }
 
      testcase( regOrig );
      testcase( eDest==SRT_Set );
      testcase( eDest==SRT_Mem );
      testcase( eDest==SRT_Coroutine );
      testcase( eDest==SRT_Output );
      assert( eDest==SRT_Set || eDest==SRT_Mem
           || eDest==SRT_Coroutine || eDest==SRT_Output
           || eDest==SRT_Upfrom );
    }
    sRowLoadInfo.regResult = regResult;
    sRowLoadInfo.ecelFlags = ecelFlags;
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    sRowLoadInfo.pExtra = pExtra;
    sRowLoadInfo.regExtraResult = regResult + nResultCol;
    if( pExtra ) nResultCol += pExtra->nExpr;
#endif
    if( p->iLimit
     && (ecelFlags & SQLITE_ECEL_OMITREF)!=0
     && nPrefixReg>0
    ){
      assert( pSort!=0 );
      assert( hasDistinct==0 );
      pSort->pDeferredRowLoad = &sRowLoadInfo;
      regOrig = 0;
    }else{
      innerLoopLoadRow(pParse, p, &sRowLoadInfo);
    }
  }
 
  /* If the DISTINCT keyword was present on the SELECT statement
  ** and this row has been seen before, then do not make this row
  ** part of the result.
  */
  if( hasDistinct ){
    switch( pDistinct->eTnctType ){
      case WHERE_DISTINCT_ORDERED: {
        VdbeOp *pOp;            /* No longer required OpenEphemeral instr. */
        int iJump;              /* Jump destination */
        int regPrev;            /* Previous row content */
 
        /* Allocate space for the previous row */
        regPrev = pParse->nMem+1;
        pParse->nMem += nResultCol;
 
        /* Change the OP_OpenEphemeral coded earlier to an OP_Null
        ** sets the MEM_Cleared bit on the first register of the
        ** previous value.  This will cause the OP_Ne below to always
        ** fail on the first iteration of the loop even if the first
        ** row is all NULLs.
        */
        sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
        pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
        pOp->opcode = OP_Null;
        pOp->p1 = 1;
        pOp->p2 = regPrev;
        pOp = 0;  /* Ensure pOp is not used after sqlite3VdbeAddOp() */
 
        iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
        for(i=0; i<nResultCol; i++){
          CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
          if( i<nResultCol-1 ){
            sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
            VdbeCoverage(v);
          }else{
            sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
            VdbeCoverage(v);
           }
          sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
          sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
        }
        assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
        sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
        break;
      }
 
      case WHERE_DISTINCT_UNIQUE: {
        sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
        break;
      }
 
      default: {
        assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
        codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,
                     regResult);
        break;
      }
    }
    if( pSort==0 ){
      codeOffset(v, p->iOffset, iContinue);
    }
  }
 
  switch( eDest ){
    /* In this mode, write each query result to the key of the temporary
    ** table iParm.
    */
#ifndef SQLITE_OMIT_COMPOUND_SELECT
    case SRT_Union: {
      int r1;
      r1 = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
      sqlite3ReleaseTempReg(pParse, r1);
      break;
    }
 
    /* Construct a record from the query result, but instead of
    ** saving that record, use it as a key to delete elements from
    ** the temporary table iParm.
    */
    case SRT_Except: {
      sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
      break;
    }
#endif /* SQLITE_OMIT_COMPOUND_SELECT */
 
    /* Store the result as data using a unique key.
    */
    case SRT_Fifo:
    case SRT_DistFifo:
    case SRT_Table:
    case SRT_EphemTab: {
      int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);
      testcase( eDest==SRT_Table );
      testcase( eDest==SRT_EphemTab );
      testcase( eDest==SRT_Fifo );
      testcase( eDest==SRT_DistFifo );
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
#ifndef SQLITE_OMIT_CTE
      if( eDest==SRT_DistFifo ){
        /* If the destination is DistFifo, then cursor (iParm+1) is open
        ** on an ephemeral index. If the current row is already present
        ** in the index, do not write it to the output. If not, add the
        ** current row to the index and proceed with writing it to the
        ** output table as well.  */
        int addr = sqlite3VdbeCurrentAddr(v) + 4;
        sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
        VdbeCoverage(v);
        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
        assert( pSort==0 );
      }
#endif
      if( pSort ){
        assert( regResult==regOrig );
        pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
      }else{
        int r2 = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
        sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
        sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
        sqlite3ReleaseTempReg(pParse, r2);
      }
      sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);
      break;
    }
 
    case SRT_Upfrom: {
      if( pSort ){
        pushOntoSorter(
            pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
      }else{
        int i2 = pDest->iSDParm2;
        int r1 = sqlite3GetTempReg(pParse);
 
        /* If the UPDATE FROM join is an aggregate that matches no rows, it
        ** might still be trying to return one row, because that is what
        ** aggregates do.  Don't record that empty row in the output table. */
        sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v);
 
        sqlite3VdbeAddOp3(v, OP_MakeRecord,
                          regResult+(i2<0), nResultCol-(i2<0), r1);
        if( i2<0 ){
          sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult);
        }else{
          sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2);
        }
      }
      break;
    }
 
#ifndef SQLITE_OMIT_SUBQUERY
    /* If we are creating a set for an "expr IN (SELECT ...)" construct,
    ** then there should be a single item on the stack.  Write this
    ** item into the set table with bogus data.
    */
    case SRT_Set: {
      if( pSort ){
        /* At first glance you would think we could optimize out the
        ** ORDER BY in this case since the order of entries in the set
        ** does not matter.  But there might be a LIMIT clause, in which
        ** case the order does matter */
        pushOntoSorter(
            pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
      }else{
        int r1 = sqlite3GetTempReg(pParse);
        assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
        sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
            r1, pDest->zAffSdst, nResultCol);
        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
        sqlite3ReleaseTempReg(pParse, r1);
      }
      break;
    }
 
 
    /* If any row exist in the result set, record that fact and abort.
    */
    case SRT_Exists: {
      sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
      /* The LIMIT clause will terminate the loop for us */
      break;
    }
 
    /* If this is a scalar select that is part of an expression, then
    ** store the results in the appropriate memory cell or array of
    ** memory cells and break out of the scan loop.
    */
    case SRT_Mem: {
      if( pSort ){
        assert( nResultCol<=pDest->nSdst );
        pushOntoSorter(
            pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
      }else{
        assert( nResultCol==pDest->nSdst );
        assert( regResult==iParm );
        /* The LIMIT clause will jump out of the loop for us */
      }
      break;
    }
#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
 
    case SRT_Coroutine:       /* Send data to a co-routine */
    case SRT_Output: {        /* Return the results */
      testcase( eDest==SRT_Coroutine );
      testcase( eDest==SRT_Output );
      if( pSort ){
        pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,
                       nPrefixReg);
      }else if( eDest==SRT_Coroutine ){
        sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
      }else{
        sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
      }
      break;
    }
 
#ifndef SQLITE_OMIT_CTE
    /* Write the results into a priority queue that is order according to
    ** pDest->pOrderBy (in pSO).  pDest->iSDParm (in iParm) is the cursor for an
    ** index with pSO->nExpr+2 columns.  Build a key using pSO for the first
    ** pSO->nExpr columns, then make sure all keys are unique by adding a
    ** final OP_Sequence column.  The last column is the record as a blob.
    */
    case SRT_DistQueue:
    case SRT_Queue: {
      int nKey;
      int r1, r2, r3;
      int addrTest = 0;
      ExprList *pSO;
      pSO = pDest->pOrderBy;
      assert( pSO );
      nKey = pSO->nExpr;
      r1 = sqlite3GetTempReg(pParse);
      r2 = sqlite3GetTempRange(pParse, nKey+2);
      r3 = r2+nKey+1;
      if( eDest==SRT_DistQueue ){
        /* If the destination is DistQueue, then cursor (iParm+1) is open
        ** on a second ephemeral index that holds all values every previously
        ** added to the queue. */
        addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
                                        regResult, nResultCol);
        VdbeCoverage(v);
      }
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
      if( eDest==SRT_DistQueue ){
        sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
        sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
      }
      for(i=0; i<nKey; i++){
        sqlite3VdbeAddOp2(v, OP_SCopy,
                          regResult + pSO->a[i].u.x.iOrderByCol - 1,
                          r2+i);
      }
      sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
      if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
      sqlite3ReleaseTempReg(pParse, r1);
      sqlite3ReleaseTempRange(pParse, r2, nKey+2);
      break;
    }
#endif /* SQLITE_OMIT_CTE */
 
 
 
#if !defined(SQLITE_OMIT_TRIGGER)
    /* Discard the results.  This is used for SELECT statements inside
    ** the body of a TRIGGER.  The purpose of such selects is to call
    ** user-defined functions that have side effects.  We do not care
    ** about the actual results of the select.
    */
    default: {
      assert( eDest==SRT_Discard );
      break;
    }
#endif
  }
 
  /* Jump to the end of the loop if the LIMIT is reached.  Except, if
  ** there is a sorter, in which case the sorter has already limited

References ExprList::a, SortCtx::addrSortIndex, DistinctCtx::addrTnct, ExprList::ExprList_item::bSorterRef, codeDistinct(), codeOffset(), Parse::db, RowLoadInfo::ecelFlags, SelectDest::eDest, DistinctCtx::eTnctType, Select::iLimit, innerLoopLoadRow(), Select::iOffset, ExprList::ExprList_item::iOrderByCol, SelectDest::iSDParm, SelectDest::iSDParm2, SelectDest::iSdst, sqlite3::mallocFailed, KeyInfo::nAllField, ExprList::nExpr, Parse::nMem, SortCtx::nOBSat, SelectDest::nSdst, OP_Column, OP_Copy, OP_DecrJumpZero, OP_Eq, OP_Found, OP_IdxDelete, OP_IdxInsert, OP_Insert, OP_Integer, OP_IsNull, OP_MakeRecord, OP_Ne, OP_NewRowid, OP_Null, OP_ResultRow, OP_SCopy, OP_Sequence, OP_Yield, VdbeOp::opcode, OPFLAG_APPEND, OPFLAG_USESEEKRESULT, VdbeOp::p1, VdbeOp::p2, VdbeOp::p4, P4_COLLSEQ, SortCtx::pDeferredRowLoad, Select::pEList, ExprList::ExprList_item::pExpr, VdbeOp::p4union::pKeyInfo, SelectDest::pOrderBy, SortCtx::pOrderBy, pushOntoSorter(), Parse::pVdbe, RowLoadInfo::regResult, SORTFLAG_UseSorter, SortCtx::sortFlags, sqlite3ExprCollSeq(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3Strlen30(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), sqlite3VdbeJumpHere(), SQLITE_ECEL_DUP, SQLITE_ECEL_OMITREF, SQLITE_ECEL_REF, SQLITE_NULLEQ, SRT_Coroutine, SRT_Discard, SRT_DistFifo, SRT_DistQueue, SRT_EphemTab, SRT_Except, SRT_Exists, SRT_Fifo, SRT_Mem, SRT_Output, SRT_Queue, SRT_Set, SRT_Table, SRT_Union, SRT_Upfrom, DistinctCtx::tabTnct, testcase, ExprList::ExprList_item::u, VdbeComment, VdbeCoverage, WHERE_DISTINCT_NOOP, WHERE_DISTINCT_ORDERED, WHERE_DISTINCT_UNIQUE, WHERE_DISTINCT_UNORDERED, ExprList::ExprList_item::x, SelectDest::zAffSdst, and ExprList::ExprList_item::zEName.

Referenced by generateWithRecursiveQuery(), multiSelect(), multiSelectValues(), and sqlite3Select().

◆ selectOpName()

static const char * selectOpName ( int id )

static

Definition at line 130679 of file sqlite3.c.

                                       {
  char *z;
  switch( id ){
    case TK_ALL:       z = "UNION ALL";   break;

Referenced by multiSelect(), multiSelectOrderBy(), and sqlite3SelectWrongNumTermsError().

◆ selectPopWith()

static void selectPopWith	(	Walker *	pWalker,
		Select *	p )

static

Definition at line 134199 of file sqlite3.c.

                                                     {
  Parse *pParse = pWalker->pParse;
  if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
    With *pWith = findRightmost(p)->pWith;

References findRightmost(), Parse::nErr, OK_IF_ALWAYS_TRUE, With::pOuter, Walker::pParse, Select::pPrior, Select::pWith, and Parse::pWith.

Referenced by sqlite3SelectExpand().

◆ selectSrcCount()

static int selectSrcCount	(	Walker *	pWalker,
		Select *	pSel )

static

Definition at line 105380 of file sqlite3.c.

105386 {

References SrcList::a, ALWAYS, SrcList::SrcList_item::iCursor, SrcCount::iSrcInner, SrcList::nSrc, Select::pSrc, Walker::pSrcCount, and Walker::u.

Referenced by sqlite3FunctionUsesThisSrc().

◆ selectWindowRewriteEList()

static void selectWindowRewriteEList	(	Parse *	pParse,
		Window *	pWin,
		SrcList *	pSrc,
		ExprList *	pEList,
		Table *	pTab,
		ExprList **	ppSub )

static

Definition at line 152015 of file sqlite3.c.

 {
  Walker sWalker;
  WindowRewrite sRewrite;
 
  assert( pWin!=0 );
  memset(&sWalker, 0, sizeof(Walker));
  memset(&sRewrite, 0, sizeof(WindowRewrite));
 
  sRewrite.pSub = *ppSub;
  sRewrite.pWin = pWin;
  sRewrite.pSrc = pSrc;
  sRewrite.pTab = pTab;
 
  sWalker.pParse = pParse;
  sWalker.xExprCallback = selectWindowRewriteExprCb;
  sWalker.xSelectCallback = selectWindowRewriteSelectCb;

References Walker::pParse, Walker::pRewrite, WindowRewrite::pSrc, WindowRewrite::pSub, WindowRewrite::pTab, WindowRewrite::pWin, selectWindowRewriteExprCb(), selectWindowRewriteSelectCb(), sqlite3WalkExprList(), Walker::u, Walker::xExprCallback, and Walker::xSelectCallback.

Referenced by sqlite3WindowRewrite().

◆ selectWindowRewriteExprCb()

static int selectWindowRewriteExprCb	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 151907 of file sqlite3.c.

                                                                  {
  struct WindowRewrite *p = pWalker->u.pRewrite;
  Parse *pParse = pWalker->pParse;
  assert( p!=0 );
  assert( p->pWin!=0 );
 
  /* If this function is being called from within a scalar sub-select
  ** that used by the SELECT statement being processed, only process
  ** TK_COLUMN expressions that refer to it (the outer SELECT). Do
  ** not process aggregates or window functions at all, as they belong
  ** to the scalar sub-select.  */
  if( p->pSubSelect ){
    if( pExpr->op!=TK_COLUMN ){
      return WRC_Continue;
    }else{
      int nSrc = p->pSrc->nSrc;
      int i;
      for(i=0; i<nSrc; i++){
        if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
      }
      if( i==nSrc ) return WRC_Continue;
    }
  }
 
  switch( pExpr->op ){
 
    case TK_FUNCTION:
      if( !ExprHasProperty(pExpr, EP_WinFunc) ){
        break;
      }else{
        Window *pWin;
        for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){
          if( pExpr->y.pWin==pWin ){
            assert( pWin->pOwner==pExpr );
            return WRC_Prune;
          }
        }
      }
      /* no break */ deliberate_fall_through
 
    case TK_AGG_FUNCTION:
    case TK_COLUMN: {
      int iCol = -1;
      if( p->pSub ){
        int i;
        for(i=0; i<p->pSub->nExpr; i++){
          if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
            iCol = i;
            break;
          }
        }
      }
      if( iCol<0 ){
        Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
        if( pDup && pDup->op==TK_AGG_FUNCTION ) pDup->op = TK_FUNCTION;
        p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup);
      }
      if( p->pSub ){
        int f = pExpr->flags & EP_Collate;
        assert( ExprHasProperty(pExpr, EP_Static)==0 );
        ExprSetProperty(pExpr, EP_Static);
        sqlite3ExprDelete(pParse->db, pExpr);
        ExprClearProperty(pExpr, EP_Static);
        memset(pExpr, 0, sizeof(Expr));
 
        pExpr->op = TK_COLUMN;
        pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
        pExpr->iTable = p->pWin->iEphCsr;
        pExpr->y.pTab = p->pTab;
        pExpr->flags = f;
      }
      if( pParse->db->mallocFailed ) return WRC_Abort;
      break;
    }
 

References ExprList::a, SrcList::a, Parse::db, deliberate_fall_through, EP_Collate, EP_Static, EP_WinFunc, ExprClearProperty, ExprHasProperty, ExprSetProperty, Expr::flags, Expr::iColumn, SrcList::SrcList_item::iCursor, Window::iEphCsr, Expr::iTable, sqlite3::mallocFailed, ExprList::nExpr, SrcList::nSrc, Expr::op, ExprList::ExprList_item::pExpr, Window::pNextWin, Window::pOwner, Walker::pParse, Walker::pRewrite, WindowRewrite::pSrc, WindowRewrite::pSub, WindowRewrite::pSubSelect, Expr::pTab, WindowRewrite::pTab, Expr::pWin, WindowRewrite::pWin, sqlite3ExprCompare(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListAppend(), TK_AGG_FUNCTION, TK_COLUMN, TK_FUNCTION, Walker::u, WRC_Abort, WRC_Continue, WRC_Prune, and Expr::y.

Referenced by selectWindowRewriteEList().

◆ selectWindowRewriteSelectCb()

static int selectWindowRewriteSelectCb	(	Walker *	pWalker,
		Select *	pSelect )

static

Definition at line 151988 of file sqlite3.c.

           : /* no-op */
      break;
  }
 
  return WRC_Continue;
}
static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){
  struct WindowRewrite *p = pWalker->u.pRewrite;
  Select *pSave = p->pSubSelect;
  if( pSave==pSelect ){
    return WRC_Continue;
  }else{

Referenced by selectWindowRewriteEList().

◆ serialGet()

static u32 serialGet	(	const unsigned char *	buf,
		u32	serial_type,
		Mem *	pMem )

static

Definition at line 81587 of file sqlite3.c.

 {
  u64 x = FOUR_BYTE_UINT(buf);
  u32 y = FOUR_BYTE_UINT(buf+4);
  x = (x<<32) + y;
  if( serial_type==6 ){
    /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
    ** twos-complement integer. */
    pMem->u.i = *(i64*)&x;
    pMem->flags = MEM_Int;
    testcase( pMem->u.i<0 );
  }else{
    /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
    ** floating point number. */
#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
    /* Verify that integers and floating point values use the same
    ** byte order.  Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
    ** defined that 64-bit floating point values really are mixed
    ** endian.
    */
    static const u64 t1 = ((u64)0x3ff00000)<<32;
    static const double r1 = 1.0;
    u64 t2 = t1;
    swapMixedEndianFloat(t2);
    assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
#endif
    assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );

References sqlite3_value::flags, FOUR_BYTE_UINT, sqlite3_value::MemValue::i, MEM_Int, sqlite3_value::MemValue::r, swapMixedEndianFloat, testcase, and sqlite3_value::u.

◆ setAllPagerFlags()

static void setAllPagerFlags ( sqlite3 * db )

static

Definition at line 125950 of file sqlite3.c.

                                         {
  if( db->autoCommit ){
    Db *pDb = db->aDb;
    int n = db->nDb;
    assert( SQLITE_FullFSync==PAGER_FULLFSYNC );
    assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC );
    assert( SQLITE_CacheSpill==PAGER_CACHESPILL );
    assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)
             ==  PAGER_FLAGS_MASK );
    assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
    while( (n--) > 0 ){
      if( pDb->pBt ){
        sqlite3BtreeSetPagerFlags(pDb->pBt,

References sqlite3::aDb, sqlite3::autoCommit, sqlite3::flags, sqlite3::nDb, PAGER_CACHESPILL, PAGER_CKPT_FULLFSYNC, PAGER_FLAGS_MASK, PAGER_FULLFSYNC, PAGER_SYNCHRONOUS_MASK, Db::pBt, Db::safety_level, sqlite3BtreeSetPagerFlags(), SQLITE_CacheSpill, SQLITE_CkptFullFSync, and SQLITE_FullFSync.

Referenced by sqlite3Pragma().

◆ setChildPtrmaps()

static int setChildPtrmaps ( MemPage * pPage )

static

Definition at line 68030 of file sqlite3.c.

                                          {
  int i;                             /* Counter variable */
  int nCell;                         /* Number of cells in page pPage */
  int rc;                            /* Return code */
  BtShared *pBt = pPage->pBt;
  Pgno pgno = pPage->pgno;
 
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
  if( rc!=SQLITE_OK ) return rc;
  nCell = pPage->nCell;
 
  for(i=0; i<nCell; i++){
    u8 *pCell = findCell(pPage, i);
 
    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);
 
    if( !pPage->leaf ){
      Pgno childPgno = get4byte(pCell);
      ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
    }
  }
 
  if( !pPage->leaf ){

References MemPage::aData, btreeInitPage(), findCell, get4byte, MemPage::hdrOffset, MemPage::isInit, MemPage::leaf, BtShared::mutex, MemPage::nCell, MemPage::pBt, MemPage::pgno, PTRMAP_BTREE, ptrmapPut(), ptrmapPutOvflPtr(), sqlite3_mutex_held(), and SQLITE_OK.

Referenced by copyNodeContent(), and relocatePage().

◆ setDateTimeToCurrent()

static int setDateTimeToCurrent	(	sqlite3_context *	context,
		DateTime *	p )

static

Definition at line 22047 of file sqlite3.c.

                                                                      {
  p->iJD = sqlite3StmtCurrentTime(context);
  if( p->iJD>0 ){
    p->validJD = 1;

References DateTime::iJD, sqlite3StmtCurrentTime(), and DateTime::validJD.

Referenced by isDate(), and parseDateOrTime().

◆ setDestPgsz()

static int setDestPgsz ( sqlite3_backup * p )

static

Definition at line 75163 of file sqlite3.c.

◆ setDeviceCharacteristics()

static void setDeviceCharacteristics ( unixFile * pFd )

static

Definition at line 37604 of file sqlite3.c.

                                                   {
  assert( pFd->deviceCharacteristics==0 || pFd->sectorSize!=0 );
  if( pFd->sectorSize==0 ){
#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
    int res;
    u32 f = 0;
 
    /* Check for support for F2FS atomic batch writes. */
    res = osIoctl(pFd->h, F2FS_IOC_GET_FEATURES, &f);
    if( res==0 && (f & F2FS_FEATURE_ATOMIC_WRITE) ){
      pFd->deviceCharacteristics = SQLITE_IOCAP_BATCH_ATOMIC;
    }
#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
 
    /* Set the POWERSAFE_OVERWRITE flag if requested. */
    if( pFd->ctrlFlags & UNIXFILE_PSOW ){

References unixFile::ctrlFlags, unixFile::deviceCharacteristics, unixFile::h, unixFile::sectorSize, SQLITE_DEFAULT_SECTOR_SIZE, SQLITE_IOCAP_BATCH_ATOMIC, SQLITE_IOCAP_POWERSAFE_OVERWRITE, and UNIXFILE_PSOW.

Referenced by unixDeviceCharacteristics(), and unixSectorSize().

◆ setDoNotMergeFlagOnCopy()

static void setDoNotMergeFlagOnCopy ( Vdbe * v )

static

Definition at line 103376 of file sqlite3.c.

Referenced by sqlite3ExprCodeTarget().

◆ setGetterMethod()

static void setGetterMethod ( Pager * pPager )

static

Definition at line 52746 of file sqlite3.c.

                                          {
  if( pPager->errCode ){
    pPager->xGet = getPageError;
#if SQLITE_MAX_MMAP_SIZE>0
  }else if( USEFETCH(pPager) ){

References Pager::errCode, getPageError(), getPageNormal(), USEFETCH, and Pager::xGet.

Referenced by pager_error(), pager_unlock(), sqlite3PagerOpen(), sqlite3PagerRollback(), and sqlite3PagerSavepoint().

◆ setPageReferenced()

static void setPageReferenced	(	IntegrityCk *	pCheck,
		Pgno	iPg )

static

Definition at line 74141 of file sqlite3.c.

Referenced by checkRef(), and sqlite3BtreeIntegrityCheck().

◆ setPendingFd()

static void setPendingFd ( unixFile * pFile )

static

Definition at line 35423 of file sqlite3.c.

                                         {
  unixInodeInfo *pInode = pFile->pInode;
  UnixUnusedFd *p = pFile->pPreallocatedUnused;

◆ setPragmaResultColumnNames()

static void setPragmaResultColumnNames	(	Vdbe *	v,
		const PragmaName *	pPragma )

static

Definition at line 125907 of file sqlite3.c.

 {
  u8 n = pPragma->nPragCName;
  sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);
  if( n==0 ){
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
  }else{

Referenced by sqlite3Pragma().

◆ setRawDateNumber()

static void setRawDateNumber	(	DateTime *	p,
		double	r )

static

Definition at line 22063 of file sqlite3.c.

                                                   {
  p->s = r;
  p->rawS = 1;

References DateTime::iJD, DateTime::rawS, DateTime::s, and DateTime::validJD.

Referenced by isDate(), and parseDateOrTime().

◆ setResultStrOrError()

static void setResultStrOrError	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n,
		u8	enc,
		void()(void )	xDel )

static

Definition at line 83352 of file sqlite3.c.

Referenced by sqlite3_result_blob64(), sqlite3_result_text16be(), sqlite3_result_text16le(), sqlite3_result_text64(), and sqlite3_result_value().

◆ setSectorSize()

static void setSectorSize ( Pager * pPager )

static

Definition at line 54367 of file sqlite3.c.

                                        {
  assert( isOpen(pPager->fd) || pPager->tempFile );
 
  if( pPager->tempFile
   || (sqlite3OsDeviceCharacteristics(pPager->fd) &
              SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0
  ){
    /* Sector size doesn't matter for temporary files. Also, the file
    ** may not have been opened yet, in which case the OsSectorSize()

References Pager::fd, isOpen, Pager::sectorSize, sqlite3OsDeviceCharacteristics(), sqlite3SectorSize(), SQLITE_IOCAP_POWERSAFE_OVERWRITE, and Pager::tempFile.

Referenced by pager_playback(), and sqlite3PagerOpen().

◆ setSharedCacheTableLock()

static int setSharedCacheTableLock	(	Btree *	p,
		Pgno	iTable,
		u8	eLock )

static

Definition at line 64826 of file sqlite3.c.

                                                                   {
  BtShared *pBt = p->pBt;
  BtLock *pLock = 0;
  BtLock *pIter;
 
  assert( sqlite3BtreeHoldsMutex(p) );
  assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
  assert( p->db!=0 );
 
  /* A connection with the read-uncommitted flag set will never try to
  ** obtain a read-lock using this function. The only read-lock obtained
  ** by a connection in read-uncommitted mode is on the sqlite_schema
  ** table, and that lock is obtained in BtreeBeginTrans().  */
  assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK );
 
  /* This function should only be called on a sharable b-tree after it
  ** has been determined that no other b-tree holds a conflicting lock.  */
  assert( p->sharable );
  assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
 
  /* First search the list for an existing lock on this table. */
  for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
    if( pIter->iTable==iTable && pIter->pBtree==p ){
      pLock = pIter;
      break;
    }
  }
 
  /* If the above search did not find a BtLock struct associating Btree p
  ** with table iTable, allocate one and link it into the list.
  */
  if( !pLock ){
    pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
    if( !pLock ){
      return SQLITE_NOMEM_BKPT;
    }
    pLock->iTable = iTable;
    pLock->pBtree = p;
    pLock->pNext = pBt->pLock;
    pBt->pLock = pLock;
  }
 
  /* Set the BtLock.eLock variable to the maximum of the current lock
  ** and the requested lock. This means if a write-lock was already held
  ** and a read-lock requested, we don't incorrectly downgrade the lock.
  */
  assert( WRITE_LOCK>READ_LOCK );

References Btree::db, BtLock::eLock, sqlite3::flags, BtLock::iTable, Btree::pBt, BtLock::pBtree, BtShared::pLock, BtLock::pNext, querySharedCacheTableLock(), READ_LOCK, Btree::sharable, sqlite3MallocZero(), SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_ReadUncommit, and WRITE_LOCK.

Referenced by sqlite3BtreeLockTable().

◆ setStrAccumError()

static void setStrAccumError	(	StrAccum *	p,
		u8	eError )

static

Definition at line 28276 of file sqlite3.c.

Referenced by printfTempBuf(), and sqlite3StrAccumEnlarge().

◆ setupLookaside()

static int setupLookaside	(	sqlite3 *	db,
		void *	pBuf,
		int	sz,
		int	cnt )

static

Definition at line 161743 of file sqlite3.c.

                                                                   {
#ifndef SQLITE_OMIT_LOOKASIDE
  void *pStart;
  sqlite3_int64 szAlloc = sz*(sqlite3_int64)cnt;
  int nBig;   /* Number of full-size slots */
  int nSm;    /* Number smaller LOOKASIDE_SMALL-byte slots */
 
  if( sqlite3LookasideUsed(db,0)>0 ){
    return SQLITE_BUSY;
  }
  /* Free any existing lookaside buffer for this handle before
  ** allocating a new one so we don't have to have space for
  ** both at the same time.
  */
  if( db->lookaside.bMalloced ){
    sqlite3_free(db->lookaside.pStart);
  }
  /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
  ** than a pointer to be useful.
  */
  sz = ROUNDDOWN8(sz);  /* IMP: R-33038-09382 */
  if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
  if( cnt<0 ) cnt = 0;
  if( sz==0 || cnt==0 ){
    sz = 0;
    pStart = 0;
  }else if( pBuf==0 ){
    sqlite3BeginBenignMalloc();
    pStart = sqlite3Malloc( szAlloc );  /* IMP: R-61949-35727 */
    sqlite3EndBenignMalloc();
    if( pStart ) szAlloc = sqlite3MallocSize(pStart);
  }else{
    pStart = pBuf;
  }
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
  if( sz>=LOOKASIDE_SMALL*3 ){
    nBig = szAlloc/(3*LOOKASIDE_SMALL+sz);
    nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL;
  }else if( sz>=LOOKASIDE_SMALL*2 ){
    nBig = szAlloc/(LOOKASIDE_SMALL+sz);
    nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL;
  }else
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
  if( sz>0 ){
    nBig = szAlloc/sz;
    nSm = 0;
  }else{
    nBig = nSm = 0;
  }
  db->lookaside.pStart = pStart;
  db->lookaside.pInit = 0;
  db->lookaside.pFree = 0;
  db->lookaside.sz = (u16)sz;
  db->lookaside.szTrue = (u16)sz;
  if( pStart ){
    int i;
    LookasideSlot *p;
    assert( sz > (int)sizeof(LookasideSlot*) );
    p = (LookasideSlot*)pStart;
    for(i=0; i<nBig; i++){
      p->pNext = db->lookaside.pInit;
      db->lookaside.pInit = p;
      p = (LookasideSlot*)&((u8*)p)[sz];
    }
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
    db->lookaside.pSmallInit = 0;
    db->lookaside.pSmallFree = 0;
    db->lookaside.pMiddle = p;
    for(i=0; i<nSm; i++){
      p->pNext = db->lookaside.pSmallInit;
      db->lookaside.pSmallInit = p;
      p = (LookasideSlot*)&((u8*)p)[LOOKASIDE_SMALL];
    }
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
    assert( ((uptr)p)<=szAlloc + (uptr)pStart );
    db->lookaside.pEnd = p;
    db->lookaside.bDisable = 0;
    db->lookaside.bMalloced = pBuf==0 ?1:0;
    db->lookaside.nSlot = nBig+nSm;
  }else{
    db->lookaside.pStart = db;
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
    db->lookaside.pSmallInit = 0;
    db->lookaside.pSmallFree = 0;
    db->lookaside.pMiddle = db;
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
    db->lookaside.pEnd = db;
    db->lookaside.bDisable = 1;
    db->lookaside.sz = 0;
    db->lookaside.bMalloced = 0;

References Lookaside::bDisable, Lookaside::bMalloced, sqlite3::lookaside, LOOKASIDE_SMALL, Lookaside::nSlot, Lookaside::pEnd, Lookaside::pFree, Lookaside::pInit, Lookaside::pMiddle, LookasideSlot::pNext, Lookaside::pSmallFree, Lookaside::pSmallInit, Lookaside::pStart, ROUNDDOWN8, sqlite3_free(), sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), sqlite3LookasideUsed(), sqlite3Malloc(), sqlite3MallocSize(), SQLITE_BUSY, Lookaside::sz, and Lookaside::szTrue.

Referenced by openDatabase().

◆ sourceidFunc()

static void sourceidFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117993 of file sqlite3.c.

References sqlite3_result_text(), sqlite3_sourceid(), SQLITE_STATIC, and UNUSED_PARAMETER2.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sqlite2BtreeKeyCompare()

int sqlite2BtreeKeyCompare	(	BtCursor *	,
		const void *	,
		int	,
		int	,
		int *	)

◆ sqlite3_aggregate_context()

SQLITE_API void * sqlite3_aggregate_context	(	sqlite3_context *	p,
		int	nBytes )

Definition at line 83867 of file sqlite3.c.

                                                                         {
  assert( p && p->pFunc && p->pFunc->xFinalize );
  assert( sqlite3_mutex_held(p->pOut->db->mutex) );
  testcase( nByte<0 );

References createAggContext(), sqlite3_value::db, sqlite3_value::flags, MEM_Agg, sqlite3::mutex, sqlite3_context::pFunc, sqlite3_context::pMem, sqlite3_context::pOut, sqlite3_mutex_held(), testcase, FuncDef::xFinalize, and sqlite3_value::z.

Referenced by countInverse(), db_sql_finalize_function(), db_sql_normal_function(), minmaxStep(), ntileStepFunc(), rankStepFunc(), row_numberValueFunc(), and sumStep().

◆ sqlite3_aggregate_count()

SQLITE_API int sqlite3_aggregate_count ( sqlite3_context * p )

Definition at line 83969 of file sqlite3.c.

References sqlite3_value::n, sqlite3_context::pFunc, sqlite3_context::pMem, and FuncDef::xFinalize.

Referenced by lcontext_aggregate_count().

◆ sqlite3_auto_extension()

SQLITE_API int sqlite3_auto_extension ( void(*)(void) xEntryPoint )

Definition at line 124953 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ){
    return rc;
  }else
#endif
  {
    u32 i;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    for(i=0; i<wsdAutoext.nExt; i++){
      if( wsdAutoext.aExt[i]==xInit ) break;
    }
    if( i==wsdAutoext.nExt ){
      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
      void (**aNew)(void);
      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
      if( aNew==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        wsdAutoext.aExt = aNew;
        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
        wsdAutoext.nExt++;
      }

References mutex, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_realloc64(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, SQLITE_NOMEM_BKPT, SQLITE_OK, wsdAutoext, and wsdAutoextInit.

◆ sqlite3_backup_finish()

SQLITE_API int sqlite3_backup_finish ( sqlite3_backup * p )

Definition at line 75625 of file sqlite3.c.

                                                       {
  sqlite3_backup **pp;                 /* Ptr to head of pagers backup list */
  sqlite3 *pSrcDb;                     /* Source database connection */
  int rc;                              /* Value to return */
 
  /* Enter the mutexes */
  if( p==0 ) return SQLITE_OK;
  pSrcDb = p->pSrcDb;
  sqlite3_mutex_enter(pSrcDb->mutex);
  sqlite3BtreeEnter(p->pSrc);
  if( p->pDestDb ){
    sqlite3_mutex_enter(p->pDestDb->mutex);
  }
 
  /* Detach this backup from the source pager. */
  if( p->pDestDb ){
    p->pSrc->nBackup--;
  }
  if( p->isAttached ){
    pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
    assert( pp!=0 );
    while( *pp!=p ){
      pp = &(*pp)->pNext;
      assert( pp!=0 );
    }
    *pp = p->pNext;
  }
 
  /* If a transaction is still open on the Btree, roll it back. */
  sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
 
  /* Set the error code of the destination database handle. */
  rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
  if( p->pDestDb ){
    sqlite3Error(p->pDestDb, rc);
 
    /* Exit the mutexes and free the backup context structure. */
    sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
  }
  sqlite3BtreeLeave(p->pSrc);
  if( p->pDestDb ){
    /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
    ** call to sqlite3_backup_init() and is destroyed by a call to

Referenced by cleanupbu(), and sqlite3BtreeCopyFile().

◆ sqlite3_backup_init()

SQLITE_API sqlite3_backup * sqlite3_backup_init	(	sqlite3 *	pDest,
		const char *	zDestName,
		sqlite3 *	pSource,
		const char *	zSourceName )

Definition at line 75191 of file sqlite3.c.

 {
  sqlite3_backup *p;                    /* Value to return */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  /* Lock the source database handle. The destination database
  ** handle is not locked in this routine, but it is locked in
  ** sqlite3_backup_step(). The user is required to ensure that no
  ** other thread accesses the destination handle for the duration
  ** of the backup operation.  Any attempt to use the destination
  ** database connection while a backup is in progress may cause
  ** a malfunction or a deadlock.
  */
  sqlite3_mutex_enter(pSrcDb->mutex);
  sqlite3_mutex_enter(pDestDb->mutex);
 
  if( pSrcDb==pDestDb ){
    sqlite3ErrorWithMsg(
        pDestDb, SQLITE_ERROR, "source and destination must be distinct"
    );
    p = 0;
  }else {
    /* Allocate space for a new sqlite3_backup object...
    ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
    ** call to sqlite3_backup_init() and is destroyed by a call to
    ** sqlite3_backup_finish(). */
    p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup));
    if( !p ){
      sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT);
    }
  }
 
  /* If the allocation succeeded, populate the new object. */
  if( p ){
    p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
    p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
    p->pDestDb = pDestDb;
    p->pSrcDb = pSrcDb;
    p->iNext = 1;
    p->isAttached = 0;
 
    if( 0==p->pSrc || 0==p->pDest
     || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
     ){
      /* One (or both) of the named databases did not exist or an OOM
      ** error was hit. Or there is a transaction open on the destination
      ** database. The error has already been written into the pDestDb
      ** handle. All that is left to do here is free the sqlite3_backup
      ** structure.  */
      sqlite3_free(p);
      p = 0;
    }
  }
  if( p ){
    p->pSrc->nBackup++;

References checkReadTransaction(), findBtree(), sqlite3_backup::iNext, sqlite3_backup::isAttached, sqlite3::mutex, Btree::nBackup, sqlite3_backup::pDest, sqlite3_backup::pDestDb, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3MallocZero(), sqlite3SafetyCheckOk(), SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by lsqlite_backup_init().

◆ sqlite3_backup_pagecount()

SQLITE_API int sqlite3_backup_pagecount ( sqlite3_backup * p )

Definition at line 75693 of file sqlite3.c.

                                                          {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ){

Referenced by dbbu_pagecount().

◆ sqlite3_backup_remaining()

SQLITE_API int sqlite3_backup_remaining ( sqlite3_backup * p )

Definition at line 75679 of file sqlite3.c.

                                                          {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ){

Referenced by dbbu_remaining().

◆ sqlite3_backup_step()

SQLITE_API int sqlite3_backup_step	(	sqlite3_backup *	p,
		int	nPage )

Definition at line 75371 of file sqlite3.c.

                                                                {
  int rc;
  int destMode;       /* Destination journal mode */
  int pgszSrc = 0;    /* Source page size */
  int pgszDest = 0;   /* Destination page size */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(p->pSrcDb->mutex);
  sqlite3BtreeEnter(p->pSrc);
  if( p->pDestDb ){
    sqlite3_mutex_enter(p->pDestDb->mutex);
  }
 
  rc = p->rc;
  if( !isFatalError(rc) ){
    Pager * const pSrcPager = sqlite3BtreePager(p->pSrc);     /* Source pager */
    Pager * const pDestPager = sqlite3BtreePager(p->pDest);   /* Dest pager */
    int ii;                            /* Iterator variable */
    int nSrcPage = -1;                 /* Size of source db in pages */
    int bCloseTrans = 0;               /* True if src db requires unlocking */
 
    /* If the source pager is currently in a write-transaction, return
    ** SQLITE_BUSY immediately.
    */
    if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
      rc = SQLITE_BUSY;
    }else{
      rc = SQLITE_OK;
    }
 
    /* If there is no open read-transaction on the source database, open
    ** one now. If a transaction is opened here, then it will be closed
    ** before this function exits.
    */
    if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
      rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0);
      bCloseTrans = 1;
    }
 
    /* If the destination database has not yet been locked (i.e. if this
    ** is the first call to backup_step() for the current backup operation),
    ** try to set its page size to the same as the source database. This
    ** is especially important on ZipVFS systems, as in that case it is
    ** not possible to create a database file that uses one page size by
    ** writing to it with another.  */
    if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){
      rc = SQLITE_NOMEM;
    }
 
    /* Lock the destination database, if it is not locked already. */
    if( SQLITE_OK==rc && p->bDestLocked==0
     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
                                                (int*)&p->iDestSchema))
    ){
      p->bDestLocked = 1;
    }
 
    /* Do not allow backup if the destination database is in WAL mode
    ** and the page sizes are different between source and destination */
    pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
    pgszDest = sqlite3BtreeGetPageSize(p->pDest);
    destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
    if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
      rc = SQLITE_READONLY;
    }
 
    /* Now that there is a read-lock on the source database, query the
    ** source pager for the number of pages in the database.
    */
    nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
    assert( nSrcPage>=0 );
    for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
      const Pgno iSrcPg = p->iNext;                 /* Source page number */
      if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
        DbPage *pSrcPg;                             /* Source page object */
        rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY);
        if( rc==SQLITE_OK ){
          rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);
          sqlite3PagerUnref(pSrcPg);
        }
      }
      p->iNext++;
    }
    if( rc==SQLITE_OK ){
      p->nPagecount = nSrcPage;
      p->nRemaining = nSrcPage+1-p->iNext;
      if( p->iNext>(Pgno)nSrcPage ){
        rc = SQLITE_DONE;
      }else if( !p->isAttached ){
        attachBackupObject(p);
      }
    }
 
    /* Update the schema version field in the destination database. This
    ** is to make sure that the schema-version really does change in
    ** the case where the source and destination databases have the
    ** same schema version.
    */
    if( rc==SQLITE_DONE ){
      if( nSrcPage==0 ){
        rc = sqlite3BtreeNewDb(p->pDest);
        nSrcPage = 1;
      }
      if( rc==SQLITE_OK || rc==SQLITE_DONE ){
        rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
      }
      if( rc==SQLITE_OK ){
        if( p->pDestDb ){
          sqlite3ResetAllSchemasOfConnection(p->pDestDb);
        }
        if( destMode==PAGER_JOURNALMODE_WAL ){
          rc = sqlite3BtreeSetVersion(p->pDest, 2);
        }
      }
      if( rc==SQLITE_OK ){
        int nDestTruncate;
        /* Set nDestTruncate to the final number of pages in the destination
        ** database. The complication here is that the destination page
        ** size may be different to the source page size.
        **
        ** If the source page size is smaller than the destination page size,
        ** round up. In this case the call to sqlite3OsTruncate() below will
        ** fix the size of the file. However it is important to call
        ** sqlite3PagerTruncateImage() here so that any pages in the
        ** destination file that lie beyond the nDestTruncate page mark are
        ** journalled by PagerCommitPhaseOne() before they are destroyed
        ** by the file truncation.
        */
        assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
        assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
        if( pgszSrc<pgszDest ){
          int ratio = pgszDest/pgszSrc;
          nDestTruncate = (nSrcPage+ratio-1)/ratio;
          if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
            nDestTruncate--;
          }
        }else{
          nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
        }
        assert( nDestTruncate>0 );
 
        if( pgszSrc<pgszDest ){
          /* If the source page-size is smaller than the destination page-size,
          ** two extra things may need to happen:
          **
          **   * The destination may need to be truncated, and
          **
          **   * Data stored on the pages immediately following the
          **     pending-byte page in the source database may need to be
          **     copied into the destination database.
          */
          const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
          sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
          Pgno iPg;
          int nDstPage;
          i64 iOff;
          i64 iEnd;
 
          assert( pFile );
          assert( nDestTruncate==0
              || (i64)nDestTruncate*(i64)pgszDest >= iSize || (
                nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
             && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
          ));
 
          /* This block ensures that all data required to recreate the original
          ** database has been stored in the journal for pDestPager and the
          ** journal synced to disk. So at this point we may safely modify
          ** the database file in any way, knowing that if a power failure
          ** occurs, the original database will be reconstructed from the
          ** journal file.  */
          sqlite3PagerPagecount(pDestPager, &nDstPage);
          for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
            if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
              DbPage *pPg;
              rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0);
              if( rc==SQLITE_OK ){
                rc = sqlite3PagerWrite(pPg);
                sqlite3PagerUnref(pPg);
              }
            }
          }
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1);
          }
 
          /* Write the extra pages and truncate the database file as required */
          iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
          for(
            iOff=PENDING_BYTE+pgszSrc;
            rc==SQLITE_OK && iOff<iEnd;
            iOff+=pgszSrc
          ){
            PgHdr *pSrcPg = 0;
            const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
            rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg, 0);
            if( rc==SQLITE_OK ){
              u8 *zData = sqlite3PagerGetData(pSrcPg);
              rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
            }
            sqlite3PagerUnref(pSrcPg);
          }
          if( rc==SQLITE_OK ){
            rc = backupTruncateFile(pFile, iSize);
          }
 
          /* Sync the database file to disk. */
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerSync(pDestPager, 0);
          }
        }else{
          sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
          rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
        }
 
        /* Finish committing the transaction to the destination database. */
        if( SQLITE_OK==rc
         && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
        ){
          rc = SQLITE_DONE;
        }
      }
    }
 
    /* If bCloseTrans is true, then this function opened a read transaction
    ** on the source database. Close the read transaction here. There is
    ** no need to check the return values of the btree methods here, as
    ** "committing" a read-only transaction cannot fail.
    */
    if( bCloseTrans ){
      TESTONLY( int rc2 );
      TESTONLY( rc2  = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
      TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
      assert( rc2==SQLITE_OK );
    }
 
    if( rc==SQLITE_IOERR_NOMEM ){
      rc = SQLITE_NOMEM_BKPT;
    }
    p->rc = rc;
  }
  if( p->pDestDb ){

Referenced by dbbu_step(), and sqlite3BtreeCopyFile().

◆ sqlite3_bind_blob()

SQLITE_API int sqlite3_bind_blob	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	n,
		void()(void )	xDel )

Definition at line 84390 of file sqlite3.c.

Referenced by dbvm_bind_blob().

◆ sqlite3_bind_blob64()

SQLITE_API int sqlite3_bind_blob64	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		sqlite3_uint64	nData,
		void()(void )	xDel )

Definition at line 84402 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( nData<0 ) return SQLITE_MISUSE_BKPT;
#endif
  return bindText(pStmt, i, zData, nData, xDel, 0);
}
SQLITE_API int sqlite3_bind_blob64(
  sqlite3_stmt *pStmt,
  int i,
  const void *zData,
  sqlite3_uint64 nData,
  void (*xDel)(void*)
){
  assert( xDel!=SQLITE_DYNAMIC );

References bindText(), and SQLITE_MISUSE_BKPT.

◆ sqlite3_bind_double()

SQLITE_API int sqlite3_bind_double	(	sqlite3_stmt *	pStmt,
		int	i,
		double	rValue )

Definition at line 84416 of file sqlite3.c.

                        {
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    return bindText(pStmt, i, zData, (int)nData, xDel, 0);
  }
}
SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);

References invokeValueDestructor().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_int()

SQLITE_API int sqlite3_bind_int	(	sqlite3_stmt *	p,
		int	i,
		int	iValue )

Definition at line 84426 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
    sqlite3_mutex_leave(p->db->mutex);

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetDouble().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_int64()

SQLITE_API int sqlite3_bind_int64	(	sqlite3_stmt *	pStmt,
		int	i,
		sqlite3_int64	iValue )

Definition at line 84429 of file sqlite3.c.

                                                                   {
  return sqlite3_bind_int64(p, i, (i64)iValue);
}
SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);

Referenced by dbvm_bind_index().

◆ sqlite3_bind_null()

SQLITE_API int sqlite3_bind_null	(	sqlite3_stmt *	pStmt,
		int	i )

Definition at line 84439 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetInt64().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_parameter_count()

SQLITE_API int sqlite3_bind_parameter_count ( sqlite3_stmt * pStmt )

Definition at line 84562 of file sqlite3.c.

Referenced by dbvm_bind_names(), dbvm_bind_parameter_count(), dbvm_bind_values(), and dbvm_check_bind_index().

◆ sqlite3_bind_parameter_index()

SQLITE_API int sqlite3_bind_parameter_index	(	sqlite3_stmt *	pStmt,
		const char *	zName )

Definition at line 84588 of file sqlite3.c.

84590 {

References nName, Vdbe::pVList, sqlite3VListNameToNum(), and zName.

◆ sqlite3_bind_parameter_name()

SQLITE_API const char * sqlite3_bind_parameter_name	(	sqlite3_stmt *	pStmt,
		int	i )

Definition at line 84573 of file sqlite3.c.

References Vdbe::pVList, and sqlite3VListNumToName().

Referenced by dbvm_bind_names(), and dbvm_bind_parameter_name().

◆ sqlite3_bind_pointer()

SQLITE_API int sqlite3_bind_pointer	(	sqlite3_stmt *	pStmt,
		int	i,
		void *	pPtr,
		const char *	zPTtype,
		void()(void )	xDestructor )

Definition at line 84448 of file sqlite3.c.

                     {
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_pointer(
  sqlite3_stmt *pStmt,
  int i,
  void *pPtr,
  const char *zPTtype,
  void (*xDestructor)(void*)
){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);

◆ sqlite3_bind_text()

SQLITE_API int sqlite3_bind_text	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		int	nData,
		void()(void )	xDel )

Definition at line 84466 of file sqlite3.c.

                         {
    xDestructor(pPtr);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_text(
  sqlite3_stmt *pStmt,
  int i,

Referenced by dbvm_bind_index().

◆ sqlite3_bind_text16()

SQLITE_API int sqlite3_bind_text16	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	nData,
		void()(void )	xDel )

Definition at line 84492 of file sqlite3.c.

       {
    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
    return bindText(pStmt, i, zData, (int)nData, xDel, enc);
  }
}
#ifndef SQLITE_OMIT_UTF16
SQLITE_API int sqlite3_bind_text16(
  sqlite3_stmt *pStmt,
  int i,

◆ sqlite3_bind_text64()

SQLITE_API int sqlite3_bind_text64	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		sqlite3_uint64	nData,
		void()(void )	xDel,
		unsigned char	encoding )

Definition at line 84475 of file sqlite3.c.

 {
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
}
SQLITE_API int sqlite3_bind_text64(
  sqlite3_stmt *pStmt,
  int i,
  const char *zData,
  sqlite3_uint64 nData,
  void (*xDel)(void*),
  unsigned char enc
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( nData>0x7fffffff ){

References bindText(), and SQLITE_UTF8.

◆ sqlite3_bind_value()

SQLITE_API int sqlite3_bind_value	(	sqlite3_stmt *	pStmt,
		int	i,
		const sqlite3_value *	pValue )

Definition at line 84502 of file sqlite3.c.

 {
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
}
#endif /* SQLITE_OMIT_UTF16 */
SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
  int rc;
  switch( sqlite3_value_type((sqlite3_value*)pValue) ){
    case SQLITE_INTEGER: {
      rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
      break;
    }
    case SQLITE_FLOAT: {
      rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
      break;
    }
    case SQLITE_BLOB: {
      if( pValue->flags & MEM_Zero ){
        rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
      }else{
        rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
      }
      break;
    }
    case SQLITE_TEXT: {
      rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                              pValue->enc);
      break;
    }
    default: {

References bindText(), and SQLITE_UTF16NATIVE.

◆ sqlite3_bind_zeroblob()

SQLITE_API int sqlite3_bind_zeroblob	(	sqlite3_stmt *	pStmt,
		int	i,
		int	n )

Definition at line 84533 of file sqlite3.c.

                                                                       {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);

◆ sqlite3_bind_zeroblob64()

SQLITE_API int sqlite3_bind_zeroblob64	(	sqlite3_stmt *	pStmt,
		int	i,
		sqlite3_uint64	n )

Definition at line 84543 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  sqlite3_mutex_enter(p->db->mutex);
  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
    rc = SQLITE_TOOBIG;
  }else{
    assert( (n & 0x7FFFFFFF)==n );

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetZeroBlob().

◆ sqlite3_blob_bytes()

SQLITE_API int sqlite3_blob_bytes ( sqlite3_blob * pBlob )

Definition at line 93830 of file sqlite3.c.

References Incrblob::nByte, and Incrblob::pStmt.

◆ sqlite3_blob_close()

SQLITE_API int sqlite3_blob_close ( sqlite3_blob * pBlob )

Definition at line 93719 of file sqlite3.c.

                                                      {
  Incrblob *p = (Incrblob *)pBlob;
  int rc;
  sqlite3 *db;
 
  if( p ){
    sqlite3_stmt *pStmt = p->pStmt;
    db = p->db;
    sqlite3_mutex_enter(db->mutex);
    sqlite3DbFree(db, p);
    sqlite3_mutex_leave(db->mutex);

◆ sqlite3_blob_open()

SQLITE_API int sqlite3_blob_open	(	sqlite3 *	db,
		const char *	zDb,
		const char *	zTable,
		const char *	zColumn,
		sqlite3_int64	iRow,
		int	flags,
		sqlite3_blob **	ppBlob )

Definition at line 93486 of file sqlite3.c.

 {
  int nAttempt = 0;
  int iCol;               /* Index of zColumn in row-record */
  int rc = SQLITE_OK;
  char *zErr = 0;
  Table *pTab;
  Incrblob *pBlob = 0;
  Parse sParse;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppBlob==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  *ppBlob = 0;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zTable==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  wrFlag = !!wrFlag;                /* wrFlag = (wrFlag ? 1 : 0); */
 
  sqlite3_mutex_enter(db->mutex);
 
  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
  do {
    memset(&sParse, 0, sizeof(Parse));
    if( !pBlob ) goto blob_open_out;
    sParse.db = db;
    sqlite3DbFree(db, zErr);
    zErr = 0;
 
    sqlite3BtreeEnterAll(db);
    pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
    if( pTab && IsVirtual(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable);
    }
    if( pTab && !HasRowid(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable);
    }
#ifndef SQLITE_OMIT_VIEW
    if( pTab && pTab->pSelect ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
    }
#endif
    if( !pTab ){
      if( sParse.zErrMsg ){
        sqlite3DbFree(db, zErr);
        zErr = sParse.zErrMsg;
        sParse.zErrMsg = 0;
      }
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }
    pBlob->pTab = pTab;
    pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
 
    /* Now search pTab for the exact column. */
    for(iCol=0; iCol<pTab->nCol; iCol++) {
      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
        break;
      }
    }
    if( iCol==pTab->nCol ){
      sqlite3DbFree(db, zErr);
      zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }
 
    /* If the value is being opened for writing, check that the
    ** column is not indexed, and that it is not part of a foreign key.
    */
    if( wrFlag ){
      const char *zFault = 0;
      Index *pIdx;
#ifndef SQLITE_OMIT_FOREIGN_KEY
      if( db->flags&SQLITE_ForeignKeys ){
        /* Check that the column is not part of an FK child key definition. It
        ** is not necessary to check if it is part of a parent key, as parent
        ** key columns must be indexed. The check below will pick up this
        ** case.  */
        FKey *pFKey;
        for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
          int j;
          for(j=0; j<pFKey->nCol; j++){
            if( pFKey->aCol[j].iFrom==iCol ){
              zFault = "foreign key";
            }
          }
        }
      }
#endif
      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
        int j;
        for(j=0; j<pIdx->nKeyCol; j++){
          /* FIXME: Be smarter about indexes that use expressions */
          if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
            zFault = "indexed";
          }
        }
      }
      if( zFault ){
        sqlite3DbFree(db, zErr);
        zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
        rc = SQLITE_ERROR;
        sqlite3BtreeLeaveAll(db);
        goto blob_open_out;
      }
    }
 
    pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse);
    assert( pBlob->pStmt || db->mallocFailed );
    if( pBlob->pStmt ){
 
      /* This VDBE program seeks a btree cursor to the identified
      ** db/table/row entry. The reason for using a vdbe program instead
      ** of writing code to use the b-tree layer directly is that the
      ** vdbe program will take advantage of the various transaction,
      ** locking and error handling infrastructure built into the vdbe.
      **
      ** After seeking the cursor, the vdbe executes an OP_ResultRow.
      ** Code external to the Vdbe then "borrows" the b-tree cursor and
      ** uses it to implement the blob_read(), blob_write() and
      ** blob_bytes() functions.
      **
      ** The sqlite3_blob_close() function finalizes the vdbe program,
      ** which closes the b-tree cursor and (possibly) commits the
      ** transaction.
      */
      static const int iLn = VDBE_OFFSET_LINENO(2);
      static const VdbeOpList openBlob[] = {
        {OP_TableLock,      0, 0, 0},  /* 0: Acquire a read or write lock */
        {OP_OpenRead,       0, 0, 0},  /* 1: Open a cursor */
        /* blobSeekToRow() will initialize r[1] to the desired rowid */
        {OP_NotExists,      0, 5, 1},  /* 2: Seek the cursor to rowid=r[1] */
        {OP_Column,         0, 0, 1},  /* 3  */
        {OP_ResultRow,      1, 0, 0},  /* 4  */
        {OP_Halt,           0, 0, 0},  /* 5  */
      };
      Vdbe *v = (Vdbe *)pBlob->pStmt;
      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      VdbeOp *aOp;
 
      sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
                           pTab->pSchema->schema_cookie,
                           pTab->pSchema->iGeneration);
      sqlite3VdbeChangeP5(v, 1);
      assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
      aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
 
      /* Make sure a mutex is held on the table to be accessed */
      sqlite3VdbeUsesBtree(v, iDb);
 
      if( db->mallocFailed==0 ){
        assert( aOp!=0 );
        /* Configure the OP_TableLock instruction */
#ifdef SQLITE_OMIT_SHARED_CACHE
        aOp[0].opcode = OP_Noop;
#else
        aOp[0].p1 = iDb;
        aOp[0].p2 = pTab->tnum;
        aOp[0].p3 = wrFlag;
        sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
      }
      if( db->mallocFailed==0 ){
#endif
 
        /* Remove either the OP_OpenWrite or OpenRead. Set the P2
        ** parameter of the other to pTab->tnum.  */
        if( wrFlag ) aOp[1].opcode = OP_OpenWrite;
        aOp[1].p2 = pTab->tnum;
        aOp[1].p3 = iDb;
 
        /* Configure the number of columns. Configure the cursor to
        ** think that the table has one more column than it really
        ** does. An OP_Column to retrieve this imaginary column will
        ** always return an SQL NULL. This is useful because it means
        ** we can invoke OP_Column to fill in the vdbe cursors type
        ** and offset cache without causing any IO.
        */
        aOp[1].p4type = P4_INT32;
        aOp[1].p4.i = pTab->nCol+1;
        aOp[3].p2 = pTab->nCol;
 
        sParse.nVar = 0;
        sParse.nMem = 1;
        sParse.nTab = 1;
        sqlite3VdbeMakeReady(v, &sParse);
      }
    }
 
    pBlob->iCol = iCol;
    pBlob->db = db;
    sqlite3BtreeLeaveAll(db);
    if( db->mallocFailed ){
      goto blob_open_out;
    }
    rc = blobSeekToRow(pBlob, iRow, &zErr);
  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
 
blob_open_out:
  if( rc==SQLITE_OK && db->mallocFailed==0 ){
    *ppBlob = (sqlite3_blob *)pBlob;
  }else{
    if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
    sqlite3DbFree(db, pBlob);
  }
  sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);

◆ sqlite3_blob_read()

SQLITE_API int sqlite3_blob_read	(	sqlite3_blob *	pBlob,
		void *	Z,
		int	N,
		int	iOffset )

Definition at line 93813 of file sqlite3.c.

◆ sqlite3_blob_reopen()

SQLITE_API int sqlite3_blob_reopen	(	sqlite3_blob *	pBlob,
		sqlite3_int64	iRow )

Definition at line 93845 of file sqlite3.c.

                                                                           {
  int rc;
  Incrblob *p = (Incrblob *)pBlob;
  sqlite3 *db;
 
  if( p==0 ) return SQLITE_MISUSE_BKPT;
  db = p->db;
  sqlite3_mutex_enter(db->mutex);
 
  if( p->pStmt==0 ){
    /* If there is no statement handle, then the blob-handle has
    ** already been invalidated. Return SQLITE_ABORT in this case.
    */
    rc = SQLITE_ABORT;
  }else{
    char *zErr;
    rc = blobSeekToRow(p, iRow, &zErr);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
      sqlite3DbFree(db, zErr);
    }
    assert( rc!=SQLITE_SCHEMA );
  }

References blobSeekToRow(), Incrblob::db, sqlite3::mutex, Incrblob::pStmt, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3ErrorWithMsg(), SQLITE_ABORT, SQLITE_MISUSE_BKPT, SQLITE_OK, and SQLITE_SCHEMA.

◆ sqlite3_blob_write()

SQLITE_API int sqlite3_blob_write	(	sqlite3_blob *	pBlob,
		const void *	z,
		int	n,
		int	iOffset )

Definition at line 93820 of file sqlite3.c.

◆ sqlite3_busy_handler()

SQLITE_API int sqlite3_busy_handler	(	sqlite3 *	db,
		int()(void , int)	xBusy,
		void *	pArg )

Definition at line 162677 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->busyHandler.xBusyHandler = xBusy;

Referenced by db_busy_handler(), and sqlite3_busy_timeout().

◆ sqlite3_busy_timeout()

SQLITE_API int sqlite3_busy_timeout	(	sqlite3 *	db,
		int	ms )

Definition at line 162731 of file sqlite3.c.

                                                        {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( ms>0 ){
    sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback,
                             (void*)db);

References sqlite3_busy_handler(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, and sqliteDefaultBusyCallback().

Referenced by db_busy_timeout(), and sqlite3Pragma().

◆ sqlite3_cancel_auto_extension()

SQLITE_API int sqlite3_cancel_auto_extension ( void(*)(void) xEntryPoint )

Definition at line 125000 of file sqlite3.c.

 {
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  int i;
  int n = 0;
  wsdAutoextInit;
  sqlite3_mutex_enter(mutex);
  for(i=(int)wsdAutoext.nExt-1; i>=0; i--){
    if( wsdAutoext.aExt[i]==xInit ){
      wsdAutoext.nExt--;
      wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt];
      n++;

References mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, wsdAutoext, and wsdAutoextInit.

◆ sqlite3_changes()

SQLITE_API int sqlite3_changes ( sqlite3 * db )

Definition at line 162082 of file sqlite3.c.

                                           {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by changes(), and db_changes().

◆ sqlite3_clear_bindings()

SQLITE_API int sqlite3_clear_bindings ( sqlite3_stmt * pStmt )

Definition at line 83128 of file sqlite3.c.

                                                          {
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
    sqlite3VdbeMemRelease(&p->aVar[i]);
    p->aVar[i].flags = MEM_Null;
  }
  assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );

◆ sqlite3_close()

SQLITE_API int sqlite3_close ( sqlite3 * db )

Definition at line 162246 of file sqlite3.c.

Referenced by cleanupdb(), and openDatabase().

◆ sqlite3_close_v2()

SQLITE_API int sqlite3_close_v2 ( sqlite3 * db )

Definition at line 162247 of file sqlite3.c.

References sqlite3Close().

◆ sqlite3_collation_needed()

SQLITE_API int sqlite3_collation_needed	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void()(void , sqlite3 , int eTextRep, const char )	xCollNeeded )

Definition at line 164507 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

◆ sqlite3_collation_needed16()

SQLITE_API int sqlite3_collation_needed16	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void()(void , sqlite3 , int eTextRep, const void )	xCollNeeded16 )

Definition at line 164528 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

◆ sqlite3_column_blob()

SQLITE_API const void * sqlite3_column_blob	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84091 of file sqlite3.c.

                                                                      {
  const void *val;
  val = sqlite3_value_blob( columnMem(pStmt,i) );
  /* Even though there is no encoding conversion, value_blob() might

Referenced by vm_push_column().

◆ sqlite3_column_bytes()

SQLITE_API int sqlite3_column_bytes	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84101 of file sqlite3.c.

Referenced by vm_push_column().

◆ sqlite3_column_bytes16()

SQLITE_API int sqlite3_column_bytes16	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84106 of file sqlite3.c.

                                                               {
  int val = sqlite3_value_bytes( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_count()

SQLITE_API int sqlite3_column_count ( sqlite3_stmt * pStmt )

Definition at line 83978 of file sqlite3.c.

Referenced by columnName(), dbvm_columns(), dbvm_get_named_types(), dbvm_get_names(), dbvm_get_types(), dbvm_get_unames(), dbvm_get_utypes(), and sqlite3_exec().

◆ sqlite3_column_database_name()

SQLITE_API const char * sqlite3_column_database_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_database_name16()

SQLITE_API const void * sqlite3_column_database_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_decltype()

SQLITE_API const char * sqlite3_column_decltype	(	sqlite3_stmt *	pStmt,
		int	N )

Definition at line 84241 of file sqlite3.c.

Referenced by dbvm_get_named_types(), dbvm_get_type(), dbvm_get_types(), and dbvm_get_utypes().

◆ sqlite3_column_decltype16()

SQLITE_API const void * sqlite3_column_decltype16	(	sqlite3_stmt *	pStmt,
		int	N )

Definition at line 84245 of file sqlite3.c.

84247 {

References COLNAME_DECLTYPE, and columnName().

◆ sqlite3_column_double()

SQLITE_API double sqlite3_column_double	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84111 of file sqlite3.c.

                                                                 {
  int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

Referenced by vm_push_column().

◆ sqlite3_column_int()

SQLITE_API int sqlite3_column_int	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84116 of file sqlite3.c.

                                                                   {
  double val = sqlite3_value_double( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_int64()

SQLITE_API sqlite_int64 sqlite3_column_int64	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84121 of file sqlite3.c.

                                                             {
  int val = sqlite3_value_int( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

Referenced by vm_push_column().

◆ sqlite3_column_name()

SQLITE_API const char * sqlite3_column_name	(	sqlite3_stmt *	pStmt,
		int	N )

Definition at line 84218 of file sqlite3.c.

Referenced by db_do_next_row(), dbvm_get_name(), dbvm_get_named_types(), dbvm_get_named_values(), dbvm_get_names(), dbvm_get_unames(), and sqlite3_exec().

◆ sqlite3_column_name16()

SQLITE_API const void * sqlite3_column_name16	(	sqlite3_stmt *	pStmt,
		int	N )

Definition at line 84222 of file sqlite3.c.

84224 {

References COLNAME_NAME, and columnName().

◆ sqlite3_column_origin_name()

SQLITE_API const char * sqlite3_column_origin_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_origin_name16()

SQLITE_API const void * sqlite3_column_origin_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_table_name()

SQLITE_API const char * sqlite3_column_table_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_table_name16()

SQLITE_API const void * sqlite3_column_table_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_text()

SQLITE_API const unsigned char * sqlite3_column_text	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84126 of file sqlite3.c.

                                                                        {
  sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

Referenced by execSql(), sqlite3_exec(), and vm_push_column().

◆ sqlite3_column_text16()

SQLITE_API const void * sqlite3_column_text16	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84141 of file sqlite3.c.

◆ sqlite3_column_type()

SQLITE_API int sqlite3_column_type	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84147 of file sqlite3.c.

                                                                        {
  const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;
}

References columnMallocFailure(), columnMem(), and sqlite3_value_text16().

Referenced by sqlite3_exec(), and vm_push_column().

◆ sqlite3_column_value()

SQLITE_API sqlite3_value * sqlite3_column_value	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84131 of file sqlite3.c.

                                                                               {
  const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;
}
SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
  Mem *pOut = columnMem(pStmt, i);
  if( pOut->flags&MEM_Static ){

◆ sqlite3_commit_hook()

SQLITE_API void * sqlite3_commit_hook	(	sqlite3 *	db,
		int()(void )	xCallback,
		void *	pArg )

Definition at line 163156 of file sqlite3.c.

 {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3::pCommitArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, and sqlite3::xCommitCallback.

Referenced by db_commit_hook().

◆ sqlite3_compileoption_get()

SQLITE_API const char * sqlite3_compileoption_get ( int N )

Definition at line 165586 of file sqlite3.c.

                                                       {
  int nOpt;
  const char **azCompileOpt;

Referenced by sqlite3Pragma().

◆ sqlite3_compileoption_used()

SQLITE_API int sqlite3_compileoption_used ( const char * zOptName )

Definition at line 165553 of file sqlite3.c.

                                                               {
  int i, n;
  int nOpt;
  const char **azCompileOpt;
 
#if SQLITE_ENABLE_API_ARMOR
  if( zOptName==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  azCompileOpt = sqlite3CompileOptions(&nOpt);
 
  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);
 
  /* Since nOpt is normally in single digits, a linear search is
  ** adequate. No need for a binary search. */
  for(i=0; i<nOpt; i++){
    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
     && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0

References sqlite3CompileOptions(), sqlite3IsIdChar(), sqlite3Strlen30(), sqlite3StrNICmp, and SQLITE_MISUSE_BKPT.

Referenced by compileoptionusedFunc().

◆ sqlite3_complete()

SQLITE_API int sqlite3_complete ( const char * sql )

Definition at line 160710 of file sqlite3.c.

                                                 {
  u8 state = 0;   /* Current state, using numbers defined in header comment */
  u8 token;       /* Value of the next token */
 
#ifndef SQLITE_OMIT_TRIGGER
  /* A complex statement machine used to detect the end of a CREATE TRIGGER
  ** statement.  This is the normal case.
  */
  static const u8 trans[8][8] = {
                     /* Token:                                                */
     /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
     /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
     /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
     /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
     /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
     /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
     /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
     /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
     /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
  };
#else
  /* If triggers are not supported by this compile then the statement machine
  ** used to detect the end of a statement is much simpler
  */
  static const u8 trans[3][3] = {
                     /* Token:           */
     /* State:       **  SEMI  WS  OTHER */
     /* 0 INVALID: */ {    1,  0,     2, },
     /* 1   START: */ {    1,  1,     2, },
     /* 2  NORMAL: */ {    1,  2,     2, },
  };
#endif /* SQLITE_OMIT_TRIGGER */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zSql==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  while( *zSql ){
    switch( *zSql ){
      case ';': {  /* A semicolon */
        token = tkSEMI;
        break;
      }
      case ' ':
      case '\r':
      case '\t':
      case '\n':
      case '\f': {  /* White space is ignored */
        token = tkWS;
        break;
      }
      case '/': {   /* C-style comments */
        if( zSql[1]!='*' ){
          token = tkOTHER;
          break;
        }
        zSql += 2;
        while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
        if( zSql[0]==0 ) return 0;
        zSql++;
        token = tkWS;
        break;
      }
      case '-': {   /* SQL-style comments from "--" to end of line */
        if( zSql[1]!='-' ){
          token = tkOTHER;
          break;
        }
        while( *zSql && *zSql!='\n' ){ zSql++; }
        if( *zSql==0 ) return state==1;
        token = tkWS;
        break;
      }
      case '[': {   /* Microsoft-style identifiers in [...] */
        zSql++;
        while( *zSql && *zSql!=']' ){ zSql++; }
        if( *zSql==0 ) return 0;
        token = tkOTHER;
        break;
      }
      case '`':     /* Grave-accent quoted symbols used by MySQL */
      case '"':     /* single- and double-quoted strings */
      case '\'': {
        int c = *zSql;
        zSql++;
        while( *zSql && *zSql!=c ){ zSql++; }
        if( *zSql==0 ) return 0;
        token = tkOTHER;
        break;
      }
      default: {
#ifdef SQLITE_EBCDIC
        unsigned char c;
#endif
        if( IdChar((u8)*zSql) ){
          /* Keywords and unquoted identifiers */
          int nId;
          for(nId=1; IdChar(zSql[nId]); nId++){}
#ifdef SQLITE_OMIT_TRIGGER
          token = tkOTHER;
#else
          switch( *zSql ){
            case 'c': case 'C': {
              if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
                token = tkCREATE;
              }else{
                token = tkOTHER;
              }
              break;
            }
            case 't': case 'T': {
              if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
                token = tkTRIGGER;
              }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
                token = tkTEMP;
              }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
                token = tkTEMP;
              }else{
                token = tkOTHER;
              }
              break;
            }
            case 'e':  case 'E': {
              if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
                token = tkEND;
              }else
#ifndef SQLITE_OMIT_EXPLAIN
              if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
                token = tkEXPLAIN;
              }else
#endif
              {
                token = tkOTHER;
              }
              break;
            }
            default: {
              token = tkOTHER;
              break;
            }
          }
#endif /* SQLITE_OMIT_TRIGGER */
          zSql += nId-1;
        }else{
          /* Operators and special symbols */
          token = tkOTHER;
        }
        break;
      }

References IdChar, sqlite3StrNICmp, SQLITE_MISUSE_BKPT, tkCREATE, tkEND, tkEXPLAIN, tkOTHER, tkSEMI, tkTEMP, tkTRIGGER, and tkWS.

Referenced by lsqlite_complete(), and sqlite3_complete16().

◆ sqlite3_complete16()

SQLITE_API int sqlite3_complete16 ( const void * sql )

Definition at line 160875 of file sqlite3.c.

                                                   {
  sqlite3_value *pVal;
  char const *zSql8;
  int rc;
 
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  pVal = sqlite3ValueNew(0);
  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
  if( zSql8 ){
    rc = sqlite3_complete(zSql8);

References sqlite3_complete(), sqlite3_initialize(), sqlite3ValueFree(), sqlite3ValueNew(), sqlite3ValueSetStr(), sqlite3ValueText(), SQLITE_NOMEM_BKPT, SQLITE_STATIC, SQLITE_UTF16NATIVE, and SQLITE_UTF8.

◆ sqlite3_config()

SQLITE_API int sqlite3_config	(	int	op,
			... )

Definition at line 161425 of file sqlite3.c.

                                          {
  va_list ap;
  int rc = SQLITE_OK;
 
  /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
  ** the SQLite library is in use. */
  if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
 
  va_start(ap, op);
  switch( op ){
 
    /* Mutex configuration options are only available in a threadsafe
    ** compile.
    */
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0  /* IMP: R-54466-46756 */
    case SQLITE_CONFIG_SINGLETHREAD: {
      /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
      ** Single-thread. */
      sqlite3GlobalConfig.bCoreMutex = 0;  /* Disable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
    case SQLITE_CONFIG_MULTITHREAD: {
      /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
      ** Multi-thread. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
    case SQLITE_CONFIG_SERIALIZED: {
      /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
      ** Serialized. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 1;  /* Enable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
    case SQLITE_CONFIG_MUTEX: {
      /* Specify an alternative mutex implementation */
      sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
    case SQLITE_CONFIG_GETMUTEX: {
      /* Retrieve the current mutex implementation */
      *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
      break;
    }
#endif
 
    case SQLITE_CONFIG_MALLOC: {
      /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The argument specifies alternative
      ** low-level memory allocation routines to be used in place of the memory
      ** allocation routines built into SQLite. */
      sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
      break;
    }
    case SQLITE_CONFIG_GETMALLOC: {
      /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
      ** filled with the currently defined memory allocation routines. */
      if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
      *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
      break;
    }
    case SQLITE_CONFIG_MEMSTATUS: {
      /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
      ** single argument of type int, interpreted as a boolean, which enables
      ** or disables the collection of memory allocation statistics. */
      sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_SMALL_MALLOC: {
      sqlite3GlobalConfig.bSmallMalloc = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PAGECACHE: {
      /* EVIDENCE-OF: R-18761-36601 There are three arguments to
      ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
      ** the size of each page cache line (sz), and the number of cache lines
      ** (N). */
      sqlite3GlobalConfig.pPage = va_arg(ap, void*);
      sqlite3GlobalConfig.szPage = va_arg(ap, int);
      sqlite3GlobalConfig.nPage = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PCACHE_HDRSZ: {
      /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
      ** a single parameter which is a pointer to an integer and writes into
      ** that integer the number of extra bytes per page required for each page
      ** in SQLITE_CONFIG_PAGECACHE. */
      *va_arg(ap, int*) =
          sqlite3HeaderSizeBtree() +
          sqlite3HeaderSizePcache() +
          sqlite3HeaderSizePcache1();
      break;
    }
 
    case SQLITE_CONFIG_PCACHE: {
      /* no-op */
      break;
    }
    case SQLITE_CONFIG_GETPCACHE: {
      /* now an error */
      rc = SQLITE_ERROR;
      break;
    }
 
    case SQLITE_CONFIG_PCACHE2: {
      /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. This object specifies the interface to a custom page cache
      ** implementation. */
      sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
      break;
    }
    case SQLITE_CONFIG_GETPCACHE2: {
      /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. SQLite copies of the current page cache implementation into
      ** that object. */
      if( sqlite3GlobalConfig.pcache2.xInit==0 ){
        sqlite3PCacheSetDefault();
      }
      *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
      break;
    }
 
/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
    case SQLITE_CONFIG_HEAP: {
      /* EVIDENCE-OF: R-19854-42126 There are three arguments to
      ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
      ** number of bytes in the memory buffer, and the minimum allocation size.
      */
      sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      sqlite3GlobalConfig.mnReq = va_arg(ap, int);
 
      if( sqlite3GlobalConfig.mnReq<1 ){
        sqlite3GlobalConfig.mnReq = 1;
      }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
        /* cap min request size at 2^12 */
        sqlite3GlobalConfig.mnReq = (1<<12);
      }
 
      if( sqlite3GlobalConfig.pHeap==0 ){
        /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
        ** is NULL, then SQLite reverts to using its default memory allocator
        ** (the system malloc() implementation), undoing any prior invocation of
        ** SQLITE_CONFIG_MALLOC.
        **
        ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
        ** revert to its default implementation when sqlite3_initialize() is run
        */
        memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
      }else{
        /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
        ** alternative memory allocator is engaged to handle all of SQLites
        ** memory allocation needs. */
#ifdef SQLITE_ENABLE_MEMSYS3
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
#endif
#ifdef SQLITE_ENABLE_MEMSYS5
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
#endif
      }
      break;
    }
#endif
 
    case SQLITE_CONFIG_LOOKASIDE: {
      sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
      sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
      break;
    }
 
    /* Record a pointer to the logger function and its first argument.
    ** The default is NULL.  Logging is disabled if the function pointer is
    ** NULL.
    */
    case SQLITE_CONFIG_LOG: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
      */
      typedef void(*LOGFUNC_t)(void*,int,const char*);
      sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
      sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
      break;
    }
 
    /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
    ** can be changed at start-time using the
    ** sqlite3_config(SQLITE_CONFIG_URI,1) or
    ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
    */
    case SQLITE_CONFIG_URI: {
      /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
      ** argument of type int. If non-zero, then URI handling is globally
      ** enabled. If the parameter is zero, then URI handling is globally
      ** disabled. */
      sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
      break;
    }
 
    case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
      /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
      ** option takes a single integer argument which is interpreted as a
      ** boolean in order to enable or disable the use of covering indices for
      ** full table scans in the query optimizer. */
      sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
      break;
    }
 
#ifdef SQLITE_ENABLE_SQLLOG
    case SQLITE_CONFIG_SQLLOG: {
      typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
      sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
      sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
      break;
    }
#endif
 
    case SQLITE_CONFIG_MMAP_SIZE: {
      /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
      ** integer (sqlite3_int64) values that are the default mmap size limit
      ** (the default setting for PRAGMA mmap_size) and the maximum allowed
      ** mmap size limit. */
      sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
      sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
      /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
      ** negative, then that argument is changed to its compile-time default.
      **
      ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
      ** silently truncated if necessary so that it does not exceed the
      ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
      ** compile-time option.
      */
      if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
        mxMmap = SQLITE_MAX_MMAP_SIZE;
      }
      if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
      if( szMmap>mxMmap) szMmap = mxMmap;
      sqlite3GlobalConfig.mxMmap = mxMmap;
      sqlite3GlobalConfig.szMmap = szMmap;
      break;
    }
 
#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
    case SQLITE_CONFIG_WIN32_HEAPSIZE: {
      /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
      ** unsigned integer value that specifies the maximum size of the created
      ** heap. */
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      break;
    }
#endif
 
    case SQLITE_CONFIG_PMASZ: {
      sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
      break;
    }
 
    case SQLITE_CONFIG_STMTJRNL_SPILL: {
      sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int);
      break;
    }
 
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    case SQLITE_CONFIG_SORTERREF_SIZE: {
      int iVal = va_arg(ap, int);
      if( iVal<0 ){
        iVal = SQLITE_DEFAULT_SORTERREF_SIZE;
      }
      sqlite3GlobalConfig.szSorterRef = (u32)iVal;
      break;
    }
#endif /* SQLITE_ENABLE_SORTER_REFERENCES */
 
#ifdef SQLITE_ENABLE_DESERIALIZE
    case SQLITE_CONFIG_MEMDB_MAXSIZE: {
      sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
      break;
    }
#endif /* SQLITE_ENABLE_DESERIALIZE */
 
    default: {
      rc = SQLITE_ERROR;

References sqlite3GlobalConfig, sqlite3HeaderSizeBtree(), sqlite3HeaderSizePcache(), sqlite3HeaderSizePcache1(), sqlite3MemSetDefault(), sqlite3PCacheSetDefault(), SQLITE_CONFIG_COVERING_INDEX_SCAN, SQLITE_CONFIG_GETMALLOC, SQLITE_CONFIG_GETMUTEX, SQLITE_CONFIG_GETPCACHE, SQLITE_CONFIG_GETPCACHE2, SQLITE_CONFIG_HEAP, SQLITE_CONFIG_LOG, SQLITE_CONFIG_LOOKASIDE, SQLITE_CONFIG_MALLOC, SQLITE_CONFIG_MEMDB_MAXSIZE, SQLITE_CONFIG_MEMSTATUS, SQLITE_CONFIG_MMAP_SIZE, SQLITE_CONFIG_MULTITHREAD, SQLITE_CONFIG_MUTEX, SQLITE_CONFIG_PAGECACHE, SQLITE_CONFIG_PCACHE, SQLITE_CONFIG_PCACHE2, SQLITE_CONFIG_PCACHE_HDRSZ, SQLITE_CONFIG_PMASZ, SQLITE_CONFIG_SERIALIZED, SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_SMALL_MALLOC, SQLITE_CONFIG_SORTERREF_SIZE, SQLITE_CONFIG_SQLLOG, SQLITE_CONFIG_STMTJRNL_SPILL, SQLITE_CONFIG_URI, SQLITE_CONFIG_WIN32_HEAPSIZE, SQLITE_DEFAULT_MMAP_SIZE, SQLITE_DEFAULT_SORTERREF_SIZE, SQLITE_ERROR, SQLITE_MAX_MMAP_SIZE, SQLITE_MISUSE_BKPT, and SQLITE_OK.

Referenced by sqlite3MemSetDefault().

◆ sqlite3_context_db_handle()

SQLITE_API sqlite3 * sqlite3_context_db_handle ( sqlite3_context * p )

Definition at line 83794 of file sqlite3.c.

                    : R-46798-50301 The sqlite3_context_db_handle() interface
** returns a copy of the pointer to the database connection (the 1st
** parameter) of the sqlite3_create_function() and
** sqlite3_create_function16() routines that originally registered the

References sqlite3_value::db, and sqlite3_context::pOut.

Referenced by attachFunc(), changes(), contextMalloc(), detachFunc(), likeFunc(), loadExt(), renameColumnFunc(), renameEditSql(), renameTableFunc(), renameTableTest(), replaceFunc(), statInit(), strftimeFunc(), and substrFunc().

◆ sqlite3_create_collation()

SQLITE_API int sqlite3_create_collation	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare )

Definition at line 164439 of file sqlite3.c.

◆ sqlite3_create_collation16()

SQLITE_API int sqlite3_create_collation16	(	sqlite3 *	db,
		const void *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare )

Definition at line 164477 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  char *zName8;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
  if( zName8 ){
    rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);

◆ sqlite3_create_collation_v2()

SQLITE_API int sqlite3_create_collation_v2	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int()(void , int, const void , int, const void )	xCompare,
		void()(void )	xDestroy )

Definition at line 164452 of file sqlite3.c.

 {
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

Referenced by db_create_collation().

◆ sqlite3_create_filename()

SQLITE_API char * sqlite3_create_filename	(	const char *	zDatabase,
		const char *	zJournal,
		const char *	zWal,
		int	nParam,
		const char **	azParam )

Definition at line 165241 of file sqlite3.c.

 {
  sqlite3_int64 nByte;
  int i;
  char *pResult, *p;
  nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10;
  for(i=0; i<nParam*2; i++){
    nByte += strlen(azParam[i])+1;
  }
  pResult = p = sqlite3_malloc64( nByte );
  if( p==0 ) return 0;
  memset(p, 0, 4);
  p += 4;
  p = appendText(p, zDatabase);
  for(i=0; i<nParam*2; i++){
    p = appendText(p, azParam[i]);
  }
  *(p++) = 0;
  p = appendText(p, zJournal);

References appendText(), and sqlite3_malloc64().

◆ sqlite3_create_function()

SQLITE_API int sqlite3_create_function	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal )

Definition at line 162936 of file sqlite3.c.

Referenced by db_register_function().

◆ sqlite3_create_function16()

SQLITE_API int sqlite3_create_function16	(	sqlite3 *	db,
		const void *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal )

Definition at line 162980 of file sqlite3.c.

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
                                    xFinal, xValue, xInverse, xDestroy);
}
 
#ifndef SQLITE_OMIT_UTF16
SQLITE_API int sqlite3_create_function16(
  sqlite3 *db,
  const void *zFunctionName,
  int nArg,
  int eTextRep,
  void *p,
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*)
){
  int rc;
  char *zFunc8;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);

References createFunctionApi().

◆ sqlite3_create_function_v2()

SQLITE_API int sqlite3_create_function_v2	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(void )	xDestroy )

Definition at line 162949 of file sqlite3.c.

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
                                    xFinal, 0, 0, 0);
}
SQLITE_API int sqlite3_create_function_v2(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
  void (*xStep)(sqlite3_context*,int,sqlite3_value **),

References createFunctionApi().

Referenced by sqlite3_overload_function().

◆ sqlite3_create_module()

SQLITE_API int sqlite3_create_module	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData )

Definition at line 139679 of file sqlite3.c.

◆ sqlite3_create_module_v2()

SQLITE_API int sqlite3_create_module_v2	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData,
		void()(void )	xDestroy )

Definition at line 139694 of file sqlite3.c.

◆ sqlite3_create_window_function()

SQLITE_API int sqlite3_create_window_function	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(sqlite3_context )	xValue,
		void()(sqlite3_context , int, sqlite3_value **)	xInverse,
		void()(void )	xDestroy )

Definition at line 162963 of file sqlite3.c.

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
                                    xFinal, 0, 0, xDestroy);
}
SQLITE_API int sqlite3_create_window_function(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
  void (*xFinal)(sqlite3_context*),
  void (*xValue)(sqlite3_context*),

References createFunctionApi().

◆ sqlite3_data_count()

SQLITE_API int sqlite3_data_count ( sqlite3_stmt * pStmt )

Definition at line 83987 of file sqlite3.c.

Referenced by db_do_next_row(), and dbvm_step().

◆ sqlite3_database_file_object()

SQLITE_API sqlite3_file * sqlite3_database_file_object ( const char * zName )

Definition at line 56713 of file sqlite3.c.

56719 {

56720 Pager *pPager;

References Pager::fd, and zName.

◆ sqlite3_db_cacheflush()

SQLITE_API int sqlite3_db_cacheflush ( sqlite3 * db )

Definition at line 161881 of file sqlite3.c.

                                                 {
  int i;
  int rc = SQLITE_OK;
  int bSeenBusy = 0;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( pBt && sqlite3BtreeIsInTrans(pBt) ){
      Pager *pPager = sqlite3BtreePager(pBt);
      rc = sqlite3PagerFlush(pPager);
      if( rc==SQLITE_BUSY ){
        bSeenBusy = 1;
        rc = SQLITE_OK;
      }

◆ sqlite3_db_config()

SQLITE_API int sqlite3_db_config	(	sqlite3 *	db,
		int	op,
			... )

Definition at line 161910 of file sqlite3.c.

                                                     : rc);
}
 
/*
** Configuration settings for an individual database connection
*/
SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
  va_list ap;
  int rc;
  va_start(ap, op);
  switch( op ){
    case SQLITE_DBCONFIG_MAINDBNAME: {
      /* IMP: R-06824-28531 */
      /* IMP: R-36257-52125 */
      db->aDb[0].zDbSName = va_arg(ap,char*);
      rc = SQLITE_OK;
      break;
    }
    case SQLITE_DBCONFIG_LOOKASIDE: {
      void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
      int sz = va_arg(ap, int);       /* IMP: R-47871-25994 */
      int cnt = va_arg(ap, int);      /* IMP: R-04460-53386 */
      rc = setupLookaside(db, pBuf, sz, cnt);
      break;
    }
    default: {
      static const struct {
        int op;      /* The opcode */
        u32 mask;    /* Mask of the bit in sqlite3.flags to set/clear */
      } aFlagOp[] = {
        { SQLITE_DBCONFIG_ENABLE_FKEY,           SQLITE_ForeignKeys    },
        { SQLITE_DBCONFIG_ENABLE_TRIGGER,        SQLITE_EnableTrigger  },
        { SQLITE_DBCONFIG_ENABLE_VIEW,           SQLITE_EnableView     },
        { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer  },
        { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension  },
        { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,      SQLITE_NoCkptOnClose  },
        { SQLITE_DBCONFIG_ENABLE_QPSG,           SQLITE_EnableQPSG     },
        { SQLITE_DBCONFIG_TRIGGER_EQP,           SQLITE_TriggerEQP     },
        { SQLITE_DBCONFIG_RESET_DATABASE,        SQLITE_ResetDatabase  },
        { SQLITE_DBCONFIG_DEFENSIVE,             SQLITE_Defensive      },
        { SQLITE_DBCONFIG_WRITABLE_SCHEMA,       SQLITE_WriteSchema|
                                                 SQLITE_NoSchemaError  },
        { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,    SQLITE_LegacyAlter    },
        { SQLITE_DBCONFIG_DQS_DDL,               SQLITE_DqsDDL         },
        { SQLITE_DBCONFIG_DQS_DML,               SQLITE_DqsDML         },
        { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,    SQLITE_LegacyFileFmt  },
        { SQLITE_DBCONFIG_TRUSTED_SCHEMA,        SQLITE_TrustedSchema  },
      };
      unsigned int i;
      rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
      for(i=0; i<ArraySize(aFlagOp); i++){
        if( aFlagOp[i].op==op ){
          int onoff = va_arg(ap, int);
          int *pRes = va_arg(ap, int*);
          u64 oldFlags = db->flags;
          if( onoff>0 ){
            db->flags |= aFlagOp[i].mask;
          }else if( onoff==0 ){
            db->flags &= ~(u64)aFlagOp[i].mask;
          }
          if( oldFlags!=db->flags ){
            sqlite3ExpirePreparedStatements(db, 0);
          }
          if( pRes ){
            *pRes = (db->flags & aFlagOp[i].mask)!=0;
          }
          rc = SQLITE_OK;
          break;
        }
      }

◆ sqlite3_db_filename()

SQLITE_API const char * sqlite3_db_filename	(	sqlite3 *	db,
		const char *	zDbName )

Definition at line 165384 of file sqlite3.c.

                                                                            {
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;

Referenced by db_db_filename().

◆ sqlite3_db_handle()

SQLITE_API sqlite3 * sqlite3_db_handle ( sqlite3_stmt * pStmt )

Definition at line 84646 of file sqlite3.c.

◆ sqlite3_db_mutex()

SQLITE_API sqlite3_mutex * sqlite3_db_mutex ( sqlite3 * db )

Definition at line 161843 of file sqlite3.c.

                                                       {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

◆ sqlite3_db_readonly()

SQLITE_API int sqlite3_db_readonly	(	sqlite3 *	db,
		const char *	zDbName )

Definition at line 165400 of file sqlite3.c.

                                                                    {
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;

◆ sqlite3_db_release_memory()

SQLITE_API int sqlite3_db_release_memory ( sqlite3 * db )

Definition at line 161857 of file sqlite3.c.

                                                     {
  int i;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      Pager *pPager = sqlite3BtreePager(pBt);
      sqlite3PagerShrink(pPager);

Referenced by sqlite3Pragma().

◆ sqlite3_db_status()

SQLITE_API int sqlite3_db_status	(	sqlite3 *	db,
		int	op,
		int *	pCur,
		int *	pHiwtr,
		int	resetFlg )

Definition at line 21515 of file sqlite3.c.

 {
  int rc = SQLITE_OK;   /* Return code */
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  switch( op ){
    case SQLITE_DBSTATUS_LOOKASIDE_USED: {
      *pCurrent = sqlite3LookasideUsed(db, pHighwater);
      if( resetFlag ){
        LookasideSlot *p = db->lookaside.pFree;
        if( p ){
          while( p->pNext ) p = p->pNext;
          p->pNext = db->lookaside.pInit;
          db->lookaside.pInit = db->lookaside.pFree;
          db->lookaside.pFree = 0;
        }
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
        p = db->lookaside.pSmallFree;
        if( p ){
          while( p->pNext ) p = p->pNext;
          p->pNext = db->lookaside.pSmallInit;
          db->lookaside.pSmallInit = db->lookaside.pSmallFree;
          db->lookaside.pSmallFree = 0;
        }
#endif
      }
      break;
    }
 
    case SQLITE_DBSTATUS_LOOKASIDE_HIT:
    case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
    case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
      assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
      assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
      *pCurrent = 0;
      *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
      if( resetFlag ){
        db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
      }
      break;
    }
 
    /*
    ** Return an approximation for the amount of memory currently used
    ** by all pagers associated with the given database connection.  The
    ** highwater mark is meaningless and is returned as zero.
    */
    case SQLITE_DBSTATUS_CACHE_USED_SHARED:
    case SQLITE_DBSTATUS_CACHE_USED: {
      int totalUsed = 0;
      int i;
      sqlite3BtreeEnterAll(db);
      for(i=0; i<db->nDb; i++){
        Btree *pBt = db->aDb[i].pBt;
        if( pBt ){
          Pager *pPager = sqlite3BtreePager(pBt);
          int nByte = sqlite3PagerMemUsed(pPager);
          if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){
            nByte = nByte / sqlite3BtreeConnectionCount(pBt);
          }
          totalUsed += nByte;
        }
      }
      sqlite3BtreeLeaveAll(db);
      *pCurrent = totalUsed;
      *pHighwater = 0;
      break;
    }
 
    /*
    ** *pCurrent gets an accurate estimate of the amount of memory used
    ** to store the schema for all databases (main, temp, and any ATTACHed
    ** databases.  *pHighwater is set to zero.
    */
    case SQLITE_DBSTATUS_SCHEMA_USED: {
      int i;                      /* Used to iterate through schemas */
      int nByte = 0;              /* Used to accumulate return value */
 
      sqlite3BtreeEnterAll(db);
      db->pnBytesFreed = &nByte;
      for(i=0; i<db->nDb; i++){
        Schema *pSchema = db->aDb[i].pSchema;
        if( ALWAYS(pSchema!=0) ){
          HashElem *p;
 
          nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
              pSchema->tblHash.count
            + pSchema->trigHash.count
            + pSchema->idxHash.count
            + pSchema->fkeyHash.count
          );
          nByte += sqlite3_msize(pSchema->tblHash.ht);
          nByte += sqlite3_msize(pSchema->trigHash.ht);
          nByte += sqlite3_msize(pSchema->idxHash.ht);
          nByte += sqlite3_msize(pSchema->fkeyHash.ht);
 
          for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
            sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
          }
          for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
            sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
          }
        }
      }
      db->pnBytesFreed = 0;
      sqlite3BtreeLeaveAll(db);
 
      *pHighwater = 0;
      *pCurrent = nByte;
      break;
    }
 
    /*
    ** *pCurrent gets an accurate estimate of the amount of memory used
    ** to store all prepared statements.
    ** *pHighwater is set to zero.
    */
    case SQLITE_DBSTATUS_STMT_USED: {
      struct Vdbe *pVdbe;         /* Used to iterate through VMs */
      int nByte = 0;              /* Used to accumulate return value */
 
      db->pnBytesFreed = &nByte;
      for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
        sqlite3VdbeClearObject(db, pVdbe);
        sqlite3DbFree(db, pVdbe);
      }
      db->pnBytesFreed = 0;
 
      *pHighwater = 0;  /* IMP: R-64479-57858 */
      *pCurrent = nByte;
 
      break;
    }
 
    /*
    ** Set *pCurrent to the total cache hits or misses encountered by all
    ** pagers the database handle is connected to. *pHighwater is always set
    ** to zero.
    */
    case SQLITE_DBSTATUS_CACHE_SPILL:
      op = SQLITE_DBSTATUS_CACHE_WRITE+1;
      /* no break */ deliberate_fall_through
    case SQLITE_DBSTATUS_CACHE_HIT:
    case SQLITE_DBSTATUS_CACHE_MISS:
    case SQLITE_DBSTATUS_CACHE_WRITE:{
      int i;
      int nRet = 0;
      assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
      assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 );
 
      for(i=0; i<db->nDb; i++){
        if( db->aDb[i].pBt ){
          Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
          sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
        }
      }
      *pHighwater = 0; /* IMP: R-42420-56072 */
                       /* IMP: R-54100-20147 */
                       /* IMP: R-29431-39229 */
      *pCurrent = nRet;
      break;
    }
 
    /* Set *pCurrent to non-zero if there are unresolved deferred foreign
    ** key constraints.  Set *pCurrent to zero if all foreign key constraints
    ** have been satisfied.  The *pHighwater is always set to zero.
    */
    case SQLITE_DBSTATUS_DEFERRED_FKS: {
      *pHighwater = 0;  /* IMP: R-11967-56545 */
      *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
      break;
    }
 
    default: {
      rc = SQLITE_ERROR;

◆ sqlite3_declare_vtab()

SQLITE_API int sqlite3_declare_vtab	(	sqlite3 *	db,
		const char *	zSQL )

Definition at line 140366 of file sqlite3.c.

                                                                          {
  VtabCtx *pCtx;
  int rc = SQLITE_OK;
  Table *pTab;
  char *zErr = 0;
  Parse sParse;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pCtx = db->pVtabCtx;
  if( !pCtx || pCtx->bDeclared ){
    sqlite3Error(db, SQLITE_MISUSE);
    sqlite3_mutex_leave(db->mutex);
    return SQLITE_MISUSE_BKPT;
  }
  pTab = pCtx->pTab;
  assert( IsVirtual(pTab) );
 
  memset(&sParse, 0, sizeof(sParse));
  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
  sParse.db = db;
  sParse.nQueryLoop = 1;
  if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr)
   && sParse.pNewTable
   && !db->mallocFailed
   && !sParse.pNewTable->pSelect
   && !IsVirtual(sParse.pNewTable)
  ){
    if( !pTab->aCol ){
      Table *pNew = sParse.pNewTable;
      Index *pIdx;
      pTab->aCol = pNew->aCol;
      pTab->nCol = pNew->nCol;
      pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
      pNew->nCol = 0;
      pNew->aCol = 0;
      assert( pTab->pIndex==0 );
      assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
      if( !HasRowid(pNew)
       && pCtx->pVTable->pMod->pModule->xUpdate!=0
       && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
      ){
        /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
        ** or else must have a single-column PRIMARY KEY */
        rc = SQLITE_ERROR;
      }
      pIdx = pNew->pIndex;
      if( pIdx ){
        assert( pIdx->pNext==0 );
        pTab->pIndex = pIdx;
        pNew->pIndex = 0;
        pIdx->pTable = pTab;
      }
    }
    pCtx->bDeclared = 1;
  }else{
    sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
    sqlite3DbFree(db, zErr);
    rc = SQLITE_ERROR;
  }
  sParse.eParseMode = PARSE_MODE_NORMAL;
 
  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  sqlite3ParserReset(&sParse);

References Table::aCol, VtabCtx::bDeclared, Parse::db, Parse::eParseMode, HasRowid, IsVirtual, sqlite3::mallocFailed, sqlite3::mutex, Table::nCol, Parse::nQueryLoop, PARSE_MODE_DECLARE_VTAB, PARSE_MODE_NORMAL, Table::pIndex, VTable::pMod, Module::pModule, Parse::pNewTable, Index::pNext, Table::pSelect, VtabCtx::pTab, Index::pTable, Parse::pVdbe, sqlite3::pVtabCtx, VtabCtx::pVTable, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3ParserReset(), sqlite3PrimaryKeyIndex(), sqlite3RunParser(), sqlite3SafetyCheckOk(), sqlite3VdbeFinalize(), SQLITE_ERROR, SQLITE_MISUSE, SQLITE_MISUSE_BKPT, SQLITE_OK, Table::tabFlags, TF_NoVisibleRowid, TF_WithoutRowid, and sqlite3_module::xUpdate.

◆ sqlite3_deserialize()

SQLITE_API int sqlite3_deserialize	(	sqlite3 *	db,
		const char *	zSchema,
		unsigned char *	pData,
		sqlite3_int64	szDb,
		sqlite3_int64	szBuf,
		unsigned	mFlags )

◆ sqlite3_drop_modules()

SQLITE_API int sqlite3_drop_modules	(	sqlite3 *	db,
		const char **	azKeep )

Definition at line 139711 of file sqlite3.c.

                                                                      {
  HashElem *pThis, *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
    Module *pMod = (Module*)sqliteHashData(pThis);
    pNext = sqliteHashNext(pThis);
    if( azNames ){
      int ii;
      for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}

◆ sqlite3_enable_load_extension()

SQLITE_API int sqlite3_enable_load_extension	(	sqlite3 *	db,
		int	onoff )

Definition at line 124907 of file sqlite3.c.

                                                                    {
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;

Referenced by db_load_extension().

◆ sqlite3_enable_shared_cache()

SQLITE_API int sqlite3_enable_shared_cache ( int enable )

Definition at line 64566 of file sqlite3.c.

References sqlite3GlobalConfig, and SQLITE_OK.

◆ sqlite3_errcode()

SQLITE_API int sqlite3_errcode ( sqlite3 * db )

Definition at line 163553 of file sqlite3.c.

                                           {
  if( db && !sqlite3SafetyCheckSickOrOk(db) ){
    return SQLITE_MISUSE_BKPT;

References sqlite3SafetyCheckSickOrOk(), and SQLITE_MISUSE_BKPT.

Referenced by db_errcode(), db_prepare(), dbvm_reset(), lsqlite_do_open(), and openDatabase().

◆ sqlite3_errmsg()

SQLITE_API const char * sqlite3_errmsg ( sqlite3 * db )

Definition at line 163483 of file sqlite3.c.

                                                  {
  const char *z;
  if( !db ){
    return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }else{
    testcase( db->pErr==0 );
    z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
    assert( !db->mallocFailed );
    if( z==0 ){

Referenced by blobSeekToRow(), db_do_next_row(), db_do_rows(), db_errmsg(), execSqlF(), lsqlite_do_open(), sqlite3_exec(), and sqlite3InitCallback().

◆ sqlite3_errmsg16()

SQLITE_API const void * sqlite3_errmsg16 ( sqlite3 * db )

Definition at line 163511 of file sqlite3.c.

                                                    {
  static const u16 outOfMem[] = {
    'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
  };
  static const u16 misuse[] = {
    'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ',
    'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
    'm', 'i', 's', 'u', 's', 'e', 0
  };
 
  const void *z;
  if( !db ){
    return (void *)outOfMem;
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return (void *)misuse;
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = (void *)outOfMem;
  }else{
    z = sqlite3_value_text16(db->pErr);
    if( z==0 ){
      sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
      z = sqlite3_value_text16(db->pErr);
    }
    /* A malloc() may have failed within the call to sqlite3_value_text16()
    ** above. If this is the case, then the db->mallocFailed flag needs to
    ** be cleared before returning. Do this directly, instead of via
    ** sqlite3ApiExit(), to avoid setting the database handle error message.

References sqlite3::errCode, sqlite3::mallocFailed, sqlite3::mutex, sqlite3::pErr, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_value_text16(), sqlite3ErrorWithMsg(), sqlite3ErrStr(), sqlite3OomClear(), and sqlite3SafetyCheckSickOrOk().

◆ sqlite3_errstr()

SQLITE_API const char * sqlite3_errstr ( int rc )

Definition at line 163580 of file sqlite3.c.

References sqlite3ErrStr().

◆ sqlite3_exec()

SQLITE_API int sqlite3_exec	(	sqlite3 *	db,
		const char *	sql,
		int()(void , int, char , char )	callback,
		void *	pArg,
		char **	errmsg )

Definition at line 123455 of file sqlite3.c.

 {
  int rc = SQLITE_OK;         /* Return code */
  const char *zLeftover;      /* Tail of unprocessed SQL */
  sqlite3_stmt *pStmt = 0;    /* The current SQL statement */
  char **azCols = 0;          /* Names of result columns */
  int callbackIsInit;         /* True if callback data is initialized */
 
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  if( zSql==0 ) zSql = "";
 
  sqlite3_mutex_enter(db->mutex);
  sqlite3Error(db, SQLITE_OK);
  while( rc==SQLITE_OK && zSql[0] ){
    int nCol = 0;
    char **azVals = 0;
 
    pStmt = 0;
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
    assert( rc==SQLITE_OK || pStmt==0 );
    if( rc!=SQLITE_OK ){
      continue;
    }
    if( !pStmt ){
      /* this happens for a comment or white-space */
      zSql = zLeftover;
      continue;
    }
    callbackIsInit = 0;
 
    while( 1 ){
      int i;
      rc = sqlite3_step(pStmt);
 
      /* Invoke the callback function if required */
      if( xCallback && (SQLITE_ROW==rc ||
          (SQLITE_DONE==rc && !callbackIsInit
                           && db->flags&SQLITE_NullCallback)) ){
        if( !callbackIsInit ){
          nCol = sqlite3_column_count(pStmt);
          azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
          if( azCols==0 ){
            goto exec_out;
          }
          for(i=0; i<nCol; i++){
            azCols[i] = (char *)sqlite3_column_name(pStmt, i);
            /* sqlite3VdbeSetColName() installs column names as UTF8
            ** strings so there is no way for sqlite3_column_name() to fail. */
            assert( azCols[i]!=0 );
          }
          callbackIsInit = 1;
        }
        if( rc==SQLITE_ROW ){
          azVals = &azCols[nCol];
          for(i=0; i<nCol; i++){
            azVals[i] = (char *)sqlite3_column_text(pStmt, i);
            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
              sqlite3OomFault(db);
              goto exec_out;
            }
          }
          azVals[i] = 0;
        }
        if( xCallback(pArg, nCol, azVals, azCols) ){
          /* EVIDENCE-OF: R-38229-40159 If the callback function to
          ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
          ** return SQLITE_ABORT. */
          rc = SQLITE_ABORT;
          sqlite3VdbeFinalize((Vdbe *)pStmt);
          pStmt = 0;
          sqlite3Error(db, SQLITE_ABORT);
          goto exec_out;
        }
      }
 
      if( rc!=SQLITE_ROW ){
        rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
        pStmt = 0;
        zSql = zLeftover;
        while( sqlite3Isspace(zSql[0]) ) zSql++;
        break;
      }
    }
 
    sqlite3DbFree(db, azCols);
    azCols = 0;
  }
 
exec_out:
  if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
  sqlite3DbFree(db, azCols);
 
  rc = sqlite3ApiExit(db, rc);
  if( rc!=SQLITE_OK && pzErrMsg ){
    *pzErrMsg = sqlite3DbStrDup(0, sqlite3_errmsg(db));
    if( *pzErrMsg==0 ){
      rc = SQLITE_NOMEM_BKPT;
      sqlite3Error(db, SQLITE_NOMEM);
    }
  }else if( pzErrMsg ){
    *pzErrMsg = 0;

References sqlite3::errMask, sqlite3::flags, sqlite3::mutex, sqlite3_column_count(), sqlite3_column_name(), sqlite3_column_text(), sqlite3_column_type(), sqlite3_errmsg(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_prepare_v2(), sqlite3_step(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DbMallocRaw(), sqlite3DbStrDup(), sqlite3Error(), sqlite3Isspace, sqlite3OomFault(), sqlite3SafetyCheckOk(), sqlite3VdbeFinalize(), SQLITE_ABORT, SQLITE_DONE, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_NULL, SQLITE_NullCallback, SQLITE_OK, and SQLITE_ROW.

Referenced by db_exec(), lsqlite_open_ptr(), sqlite3_get_table(), sqlite3AnalysisLoad(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3_expanded_sql()

SQLITE_API char * sqlite3_expanded_sql ( sqlite3_stmt * pStmt )

Definition at line 84745 of file sqlite3.c.

                                                          {
#ifdef SQLITE_OMIT_TRACE
  return 0;
#else
  char *z = 0;
  const char *zSql = sqlite3_sql(pStmt);
  if( zSql ){
    Vdbe *p = (Vdbe *)pStmt;
    sqlite3_mutex_enter(p->db->mutex);

References Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_sql(), and sqlite3VdbeExpandSql().

◆ sqlite3_expired()

SQLITE_API int sqlite3_expired ( sqlite3_stmt * pStmt )

Definition at line 83009 of file sqlite3.c.

References Vdbe::expired.

◆ sqlite3_extended_errcode()

SQLITE_API int sqlite3_extended_errcode ( sqlite3 * db )

Definition at line 163562 of file sqlite3.c.

                               {
    return SQLITE_NOMEM_BKPT;
  }
  return db->errCode & db->errMask;
}
SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){
  if( db && !sqlite3SafetyCheckSickOrOk(db) ){
    return SQLITE_MISUSE_BKPT;

◆ sqlite3_extended_result_codes()

SQLITE_API int sqlite3_extended_result_codes	(	sqlite3 *	db,
		int	onoff )

Definition at line 164768 of file sqlite3.c.

                                                                    {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;

◆ sqlite3_file_control()

SQLITE_API int sqlite3_file_control	(	sqlite3 *	db,
		const char *	zDbName,
		int	op,
		void *	pArg )

Definition at line 164781 of file sqlite3.c.

                                                                                         {
  int rc = SQLITE_ERROR;
  Btree *pBtree;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  pBtree = sqlite3DbNameToBtree(db, zDbName);
  if( pBtree ){
    Pager *pPager;
    sqlite3_file *fd;
    sqlite3BtreeEnter(pBtree);
    pPager = sqlite3BtreePager(pBtree);
    assert( pPager!=0 );
    fd = sqlite3PagerFile(pPager);
    assert( fd!=0 );
    if( op==SQLITE_FCNTL_FILE_POINTER ){
      *(sqlite3_file**)pArg = fd;
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_VFS_POINTER ){
      *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
      *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_DATA_VERSION ){
      *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){
      int iNew = *(int*)pArg;
      *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree);
      if( iNew>=0 && iNew<=255 ){
        sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0);
      }
      rc = SQLITE_OK;
    }else{
      rc = sqlite3OsFileControl(fd, op, pArg);

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ sqlite3_filename_database()

SQLITE_API const char * sqlite3_filename_database ( const char * zFilename )

Definition at line 165350 of file sqlite3.c.

◆ sqlite3_filename_journal()

SQLITE_API const char * sqlite3_filename_journal ( const char * zFilename )

Definition at line 165353 of file sqlite3.c.

                                                                       {
  return databaseName(zFilename);
}
SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){
  zFilename = databaseName(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;

References databaseName().

◆ sqlite3_filename_wal()

SQLITE_API const char * sqlite3_filename_wal ( const char * zFilename )

Definition at line 165362 of file sqlite3.c.

                       {
    zFilename += sqlite3Strlen30(zFilename) + 1;
    zFilename += sqlite3Strlen30(zFilename) + 1;
  }
  return zFilename + 1;
}
SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){
#ifdef SQLITE_OMIT_WAL
  return 0;

References sqlite3Strlen30().

◆ sqlite3_finalize()

SQLITE_API int sqlite3_finalize ( sqlite3_stmt * pStmt )

Definition at line 83080 of file sqlite3.c.

                                                    {
  int rc;
  if( pStmt==0 ){
    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
    ** pointer is a harmless no-op. */
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);

References checkProfileCallback, Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3ApiExit(), sqlite3LeaveMutexAndCloseZombie(), sqlite3VdbeFinalize(), SQLITE_MISUSE_BKPT, SQLITE_OK, and vdbeSafety().

Referenced by blobSeekToRow(), cleanupvm(), db_close_vm(), db_do_next_row(), and sqlite3InitCallback().

◆ sqlite3_free()

SQLITE_API void sqlite3_free ( void * p )

Definition at line 27692 of file sqlite3.c.

                                     {
  if( p==0 ) return;  /* IMP: R-49053-54554 */
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
  if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
    sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
    sqlite3GlobalConfig.m.xFree(p);

Referenced by attachFunc(), btreeRestoreCursorPosition(), charFunc(), clearAllSharedCacheTableLocks(), closeUnixFile(), createFunctionApi(), db_load_extension(), findInodeInfo(), loadExt(), lsqlite_temp_directory(), openDatabase(), pager_delsuper(), pcache1Destroy(), pcache1ResizeHash(), pthreadMutexFree(), quoteFunc(), rehash(), releaseAllSavepoints(), releaseInodeInfo(), renameColumnParseError(), renameEditSql(), replaceFunc(), saveCursorKey(), setupLookaside(), sqlite3_backup_init(), sqlite3_free_filename(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3_overload_function(), sqlite3AnalysisLoad(), sqlite3AutoLoadExtensions(), sqlite3BitvecBuiltinTest(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3InvalidFunction(), sqlite3LeaveMutexAndCloseZombie(), sqlite3LoadExtension(), sqlite3NotPureFunc(), sqlite3OsInit(), sqlite3PagerClose(), sqlite3PagerOpen(), sqlite3Pragma(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3VdbeMemGrow(), sqlite3VtabImportErrmsg(), sqlite3WalOpen(), statGet(), unixFullPathname(), unixOpen(), unixOpenSharedMemory(), unixShmPurge(), unixShmUnmap(), vdbePmaWriterFinish(), vdbeSorterListToPMA(), vtabBestIndex(), vtabCallConstructor(), walBeginShmUnreliable(), walIndexRecover(), walIteratorInit(), walRewriteChecksums(), whereLoopAddVirtual(), and whereLoopAddVirtualOne().

◆ sqlite3_free_filename()

SQLITE_API void sqlite3_free_filename ( char * p )

Definition at line 165277 of file sqlite3.c.

References databaseName(), and sqlite3_free().

Referenced by attachFunc(), openDatabase(), and sqlite3ParseUri().

◆ sqlite3_free_table()

SQLITE_API void sqlite3_free_table ( char ** result )

Definition at line 136368 of file sqlite3.c.

 {
  if( azResult ){
    int i, n;
    azResult--;

Referenced by sqlite3_get_table().

◆ sqlite3_get_autocommit()

SQLITE_API int sqlite3_get_autocommit ( sqlite3 * db )

Definition at line 164561 of file sqlite3.c.

                                                  {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

References sqlite3::autoCommit, sqlite3SafetyCheckOk(), and SQLITE_MISUSE_BKPT.

◆ sqlite3_get_auxdata()

SQLITE_API void * sqlite3_get_auxdata	(	sqlite3_context *	pCtx,
		int	N )

Definition at line 83888 of file sqlite3.c.

                        :  If iArg is negative then access a cache of
** auxiliary data pointers that is available to all functions within a
** single prepared statement.  The iArg values must match.
*/
SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
  AuxData *pAuxData;
 
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#if SQLITE_ENABLE_STAT4
  if( pCtx->pVdbe==0 ) return 0;
#else
  assert( pCtx->pVdbe!=0 );
#endif
  for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){

References sqlite3_value::db, AuxData::iAuxArg, AuxData::iAuxOp, sqlite3_context::iOp, sqlite3::mutex, AuxData::pAux, Vdbe::pAuxData, AuxData::pNextAux, sqlite3_context::pOut, sqlite3_context::pVdbe, and sqlite3_mutex_held().

◆ sqlite3_get_table()

SQLITE_API int sqlite3_get_table	(	sqlite3 *	db,
		const char *	zSql,
		char ***	pazResult,
		int *	pnRow,
		int *	pnColumn,
		char **	pzErrmsg )

Definition at line 136299 of file sqlite3.c.

 {
  int rc;
  TabResult res;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *pazResult = 0;
  if( pnColumn ) *pnColumn = 0;
  if( pnRow ) *pnRow = 0;
  if( pzErrMsg ) *pzErrMsg = 0;
  res.zErrMsg = 0;
  res.nRow = 0;
  res.nColumn = 0;
  res.nData = 1;
  res.nAlloc = 20;
  res.rc = SQLITE_OK;
  res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc );
  if( res.azResult==0 ){
     db->errCode = SQLITE_NOMEM;
     return SQLITE_NOMEM_BKPT;
  }
  res.azResult[0] = 0;
  rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
  assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
  res.azResult[0] = SQLITE_INT_TO_PTR(res.nData);
  if( (rc&0xff)==SQLITE_ABORT ){
    sqlite3_free_table(&res.azResult[1]);
    if( res.zErrMsg ){
      if( pzErrMsg ){
        sqlite3_free(*pzErrMsg);
        *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
      }
      sqlite3_free(res.zErrMsg);
    }
    db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
    return res.rc;
  }
  sqlite3_free(res.zErrMsg);
  if( rc!=SQLITE_OK ){
    sqlite3_free_table(&res.azResult[1]);
    return rc;
  }
  if( res.nAlloc>res.nData ){
    char **azNew;
    azNew = sqlite3Realloc( res.azResult, sizeof(char*)*res.nData );
    if( azNew==0 ){
      sqlite3_free_table(&res.azResult[1]);
      db->errCode = SQLITE_NOMEM;
      return SQLITE_NOMEM_BKPT;
    }
    res.azResult = azNew;

References TabResult::azResult, sqlite3::errCode, TabResult::nAlloc, TabResult::nColumn, TabResult::nData, TabResult::nRow, TabResult::rc, sqlite3_exec(), sqlite3_free(), sqlite3_free_table(), sqlite3_get_table_cb(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3Realloc(), sqlite3SafetyCheckOk(), SQLITE_ABORT, SQLITE_INT_TO_PTR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, and TabResult::zErrMsg.

◆ sqlite3_get_table_cb()

static int sqlite3_get_table_cb	(	void *	pArg,
		int	nCol,
		char **	argv,
		char **	colv )

static

Definition at line 136225 of file sqlite3.c.

                                                                               {
  TabResult *p = (TabResult*)pArg;  /* Result accumulator */
  int need;                         /* Slots needed in p->azResult[] */
  int i;                            /* Loop counter */
  char *z;                          /* A single column of result */
 
  /* Make sure there is enough space in p->azResult to hold everything
  ** we need to remember from this invocation of the callback.
  */
  if( p->nRow==0 && argv!=0 ){
    need = nCol*2;
  }else{
    need = nCol;
  }
  if( p->nData + need > p->nAlloc ){
    char **azNew;
    p->nAlloc = p->nAlloc*2 + need;
    azNew = sqlite3Realloc( p->azResult, sizeof(char*)*p->nAlloc );
    if( azNew==0 ) goto malloc_failed;
    p->azResult = azNew;
  }
 
  /* If this is the first row, then generate an extra row containing
  ** the names of all columns.
  */
  if( p->nRow==0 ){
    p->nColumn = nCol;
    for(i=0; i<nCol; i++){
      z = sqlite3_mprintf("%s", colv[i]);
      if( z==0 ) goto malloc_failed;
      p->azResult[p->nData++] = z;
    }
  }else if( (int)p->nColumn!=nCol ){
    sqlite3_free(p->zErrMsg);
    p->zErrMsg = sqlite3_mprintf(
       "sqlite3_get_table() called with two or more incompatible queries"
    );
    p->rc = SQLITE_ERROR;
    return 1;
  }
 
  /* Copy over the row data
  */
  if( argv!=0 ){
    for(i=0; i<nCol; i++){
      if( argv[i]==0 ){
        z = 0;
      }else{
        int n = sqlite3Strlen30(argv[i])+1;
        z = sqlite3_malloc64( n );
        if( z==0 ) goto malloc_failed;
        memcpy(z, argv[i], n);
      }
      p->azResult[p->nData++] = z;
    }
    p->nRow++;
  }

References TabResult::azResult, TabResult::nAlloc, TabResult::nColumn, TabResult::nData, TabResult::nRow, TabResult::rc, sqlite3_free(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3Realloc(), sqlite3Strlen30(), SQLITE_ERROR, SQLITE_NOMEM_BKPT, and TabResult::zErrMsg.

Referenced by sqlite3_get_table().

◆ sqlite3_global_recover()

SQLITE_API int sqlite3_global_recover ( void )

Definition at line 164550 of file sqlite3.c.

References SQLITE_OK.

◆ sqlite3_hard_heap_limit64()

SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64 ( sqlite3_int64 N )

Definition at line 27449 of file sqlite3.c.

                                                                   {
  sqlite3_int64 priorLimit;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.hardLimit;
  if( n>=0 ){
    mem0.hardLimit = n;
    if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){
      mem0.alarmThreshold = n;

References mem0, sqlite3_initialize(), sqlite3_mutex_enter(), and sqlite3_mutex_leave().

Referenced by sqlite3Pragma().

◆ sqlite3_initialize()

SQLITE_API int sqlite3_initialize ( void )

Definition at line 161196 of file sqlite3.c.

                                       {
  MUTEX_LOGIC( sqlite3_mutex *pMainMtx; )      /* The main static mutex */
  int rc;                                      /* Result code */
#ifdef SQLITE_EXTRA_INIT
  int bRunExtraInit = 0;                       /* Extra initialization needed */
#endif
 
#ifdef SQLITE_OMIT_WSD
  rc = sqlite3_wsd_init(4096, 24);
  if( rc!=SQLITE_OK ){
    return rc;
  }
#endif
 
  /* If the following assert() fails on some obscure processor/compiler
  ** combination, the work-around is to set the correct pointer
  ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
  assert( SQLITE_PTRSIZE==sizeof(char*) );
 
  /* If SQLite is already completely initialized, then this call
  ** to sqlite3_initialize() should be a no-op.  But the initialization
  ** must be complete.  So isInit must not be set until the very end
  ** of this routine.
  */
  if( sqlite3GlobalConfig.isInit ){
    sqlite3MemoryBarrier();
    return SQLITE_OK;
  }
 
  /* Make sure the mutex subsystem is initialized.  If unable to
  ** initialize the mutex subsystem, return early with the error.
  ** If the system is so sick that we are unable to allocate a mutex,
  ** there is not much SQLite is going to be able to do.
  **
  ** The mutex subsystem must take care of serializing its own
  ** initialization.
  */
  rc = sqlite3MutexInit();
  if( rc ) return rc;
 
  /* Initialize the malloc() system and the recursive pInitMutex mutex.
  ** This operation is protected by the STATIC_MAIN mutex.  Note that
  ** MutexAlloc() is called for a static mutex prior to initializing the
  ** malloc subsystem - this implies that the allocation of a static
  ** mutex must not require support from the malloc subsystem.
  */
  MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(pMainMtx);
  sqlite3GlobalConfig.isMutexInit = 1;
  if( !sqlite3GlobalConfig.isMallocInit ){
    rc = sqlite3MallocInit();
  }
  if( rc==SQLITE_OK ){
    sqlite3GlobalConfig.isMallocInit = 1;
    if( !sqlite3GlobalConfig.pInitMutex ){
      sqlite3GlobalConfig.pInitMutex =
           sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
      if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
        rc = SQLITE_NOMEM_BKPT;
      }
    }
  }
  if( rc==SQLITE_OK ){
    sqlite3GlobalConfig.nRefInitMutex++;
  }
  sqlite3_mutex_leave(pMainMtx);
 
  /* If rc is not SQLITE_OK at this point, then either the malloc
  ** subsystem could not be initialized or the system failed to allocate
  ** the pInitMutex mutex. Return an error in either case.  */
  if( rc!=SQLITE_OK ){
    return rc;
  }
 
  /* Do the rest of the initialization under the recursive mutex so
  ** that we will be able to handle recursive calls into
  ** sqlite3_initialize().  The recursive calls normally come through
  ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
  ** recursive calls might also be possible.
  **
  ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
  ** to the xInit method, so the xInit method need not be threadsafe.
  **
  ** The following mutex is what serializes access to the appdef pcache xInit
  ** methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
  ** call to sqlite3PcacheInitialize().
  */
  sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
  if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
    sqlite3GlobalConfig.inProgress = 1;
#ifdef SQLITE_ENABLE_SQLLOG
    {
      extern void sqlite3_init_sqllog(void);
      sqlite3_init_sqllog();
    }
#endif
    memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions));
    sqlite3RegisterBuiltinFunctions();
    if( sqlite3GlobalConfig.isPCacheInit==0 ){
      rc = sqlite3PcacheInitialize();
    }
    if( rc==SQLITE_OK ){
      sqlite3GlobalConfig.isPCacheInit = 1;
      rc = sqlite3OsInit();
    }
#ifdef SQLITE_ENABLE_DESERIALIZE
    if( rc==SQLITE_OK ){
      rc = sqlite3MemdbInit();
    }
#endif
    if( rc==SQLITE_OK ){
      sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
          sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
      sqlite3MemoryBarrier();
      sqlite3GlobalConfig.isInit = 1;
#ifdef SQLITE_EXTRA_INIT
      bRunExtraInit = 1;
#endif
    }
    sqlite3GlobalConfig.inProgress = 0;
  }
  sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
 
  /* Go back under the static mutex and clean up the recursive
  ** mutex to prevent a resource leak.
  */
  sqlite3_mutex_enter(pMainMtx);
  sqlite3GlobalConfig.nRefInitMutex--;
  if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
    assert( sqlite3GlobalConfig.nRefInitMutex==0 );
    sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
    sqlite3GlobalConfig.pInitMutex = 0;
  }
  sqlite3_mutex_leave(pMainMtx);
 
  /* The following is just a sanity check to make sure SQLite has
  ** been compiled correctly.  It is important to run this code, but
  ** we don't want to run it too often and soak up CPU cycles for no
  ** reason.  So we run it once during initialization.
  */
#ifndef NDEBUG
#ifndef SQLITE_OMIT_FLOATING_POINT
  /* This section of code's only "output" is via assert() statements. */
  if( rc==SQLITE_OK ){
    u64 x = (((u64)1)<<63)-1;
    double y;
    assert(sizeof(x)==8);
    assert(sizeof(x)==sizeof(y));
    memcpy(&y, &x, 8);
    assert( sqlite3IsNaN(y) );
  }
#endif
#endif
 
  /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
  ** compile-time option.
  */
#ifdef SQLITE_EXTRA_INIT
  if( bRunExtraInit ){
    int SQLITE_EXTRA_INIT(const char*);

References MUTEX_LOGIC, sqlite3_mutex_enter(), sqlite3_mutex_free(), sqlite3_mutex_leave(), sqlite3BuiltinFunctions, sqlite3GlobalConfig, sqlite3IsNaN(), sqlite3MallocInit(), sqlite3MemoryBarrier(), sqlite3MutexAlloc(), sqlite3MutexInit(), sqlite3OsInit(), sqlite3PCacheBufferSetup(), sqlite3PcacheInitialize(), sqlite3RegisterBuiltinFunctions(), SQLITE_MUTEX_RECURSIVE, SQLITE_MUTEX_STATIC_MAIN, SQLITE_NOMEM_BKPT, SQLITE_OK, and SQLITE_PTRSIZE.

Referenced by openDatabase(), sqlite3_auto_extension(), sqlite3_complete16(), sqlite3_hard_heap_limit64(), sqlite3_soft_heap_limit64(), sqlite3_vfs_find(), and sqlite3_vfs_register().

◆ sqlite3_interrupt()

SQLITE_API void sqlite3_interrupt ( sqlite3 * db )

Definition at line 162748 of file sqlite3.c.

                                              {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) && (db==0 || db->magic!=SQLITE_MAGIC_ZOMBIE) ){

Referenced by db_interrupt(), and sqlite3VdbeExec().

◆ sqlite3_keyword_check()

SQLITE_API int sqlite3_keyword_check	(	const char *	zName,
		int	nName )

Definition at line 159878 of file sqlite3.c.

◆ sqlite3_keyword_count()

SQLITE_API int sqlite3_keyword_count ( void )

Definition at line 159877 of file sqlite3.c.

159877{

◆ sqlite3_keyword_name()

SQLITE_API int sqlite3_keyword_name	(	int	i,
		const char **	pzName,
		int *	pnName )

Definition at line 159871 of file sqlite3.c.

                                                                    {
  int id = TK_ID;
  keywordCode((char*)z, n, &id);
  return id;
}
#define SQLITE_N_KEYWORD 145

References keywordCode(), and TK_ID.

◆ sqlite3_last_insert_rowid()

SQLITE_API sqlite_int64 sqlite3_last_insert_rowid ( sqlite3 * db )

Definition at line 162054 of file sqlite3.c.

                                                              {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by db_last_insert_rowid(), and dbvm_last_insert_rowid().

◆ sqlite3_libversion()

SQLITE_API const char * sqlite3_libversion ( void )

Definition at line 161104 of file sqlite3.c.

References sqlite3_version.

Referenced by lsqlite_version().

◆ sqlite3_libversion_number()

SQLITE_API int sqlite3_libversion_number ( void )

Definition at line 161117 of file sqlite3.c.

◆ sqlite3_limit()

SQLITE_API int sqlite3_limit	(	sqlite3 *	db,
		int	id,
		int	newVal )

Definition at line 163728 of file sqlite3.c.

                                                                    {
  int oldLimit;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return -1;
  }
#endif
 
  /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
  ** there is a hard upper bound set at compile-time by a C preprocessor
  ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
  ** "_MAX_".)
  */
  assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
  assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
  assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
  assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
  assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
  assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
  assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
                                               SQLITE_MAX_LIKE_PATTERN_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
  assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
  assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
  assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
 
 
  if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
    return -1;
  }
  oldLimit = db->aLimit[limitId];
  if( newLimit>=0 ){                   /* IMP: R-52476-28732 */
    if( newLimit>aHardLimit[limitId] ){

References aHardLimit, sqlite3::aLimit, sqlite3SafetyCheckOk(), SQLITE_LIMIT_ATTACHED, SQLITE_LIMIT_COLUMN, SQLITE_LIMIT_COMPOUND_SELECT, SQLITE_LIMIT_EXPR_DEPTH, SQLITE_LIMIT_FUNCTION_ARG, SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, SQLITE_LIMIT_SQL_LENGTH, SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_LIMIT_VARIABLE_NUMBER, SQLITE_LIMIT_VDBE_OP, SQLITE_LIMIT_WORKER_THREADS, SQLITE_MAX_ATTACHED, SQLITE_MAX_COLUMN, SQLITE_MAX_COMPOUND_SELECT, SQLITE_MAX_EXPR_DEPTH, SQLITE_MAX_FUNCTION_ARG, SQLITE_MAX_LENGTH, SQLITE_MAX_LIKE_PATTERN_LENGTH, SQLITE_MAX_SQL_LENGTH, SQLITE_MAX_TRIGGER_DEPTH, SQLITE_MAX_VARIABLE_NUMBER, SQLITE_MAX_VDBE_OP, SQLITE_MAX_WORKER_THREADS, SQLITE_MISUSE_BKPT, and SQLITE_N_LIMIT.

Referenced by sqlite3Pragma().

◆ sqlite3_load_extension()

SQLITE_API int sqlite3_load_extension	(	sqlite3 *	db,
		const char *	zFile,
		const char *	zProc,
		char **	pzErrMsg )

Definition at line 124876 of file sqlite3.c.

124887 {

124888 int rc;

Referenced by db_load_extension(), and loadExt().

◆ sqlite3_log()

SQLITE_API void sqlite3_log	(	int	iErrCode,
		const char *	zFormat,
			... )

Definition at line 29399 of file sqlite3.c.

29405 {

29406 va_list ap; /* Vararg list */

Referenced by constructAutomaticIndex(), errlogFunc(), logBadConnection(), lookupName(), pager_playback(), robust_open(), sqlite3CorruptError(), sqlite3MemMalloc(), sqlite3MemRealloc(), sqlite3PcacheFetchStress(), sqlite3RunParser(), sqlite3VdbeExec(), unixLogErrorAtLine(), vdbeCommit(), vdbeUnbind(), verifyDbFile(), and walIndexRecover().

◆ sqlite3_malloc()

SQLITE_API void * sqlite3_malloc ( int n )

Definition at line 27615 of file sqlite3.c.

27620 {

Referenced by sqlite3OsInit(), unixFullPathname(), and walRewriteChecksums().

◆ sqlite3_malloc64()

SQLITE_API void * sqlite3_malloc64 ( sqlite3_uint64 n )

Definition at line 27621 of file sqlite3.c.

                  : sqlite3Malloc(n);
}
SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){

Referenced by charFunc(), findInodeInfo(), sqlite3_create_filename(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3BitvecBuiltinTest(), sqlite3LoadExtension(), sqlite3ParseUri(), unixOpen(), unixOpenSharedMemory(), unixShmMap(), walBeginShmUnreliable(), walIndexRecover(), and walIteratorInit().

◆ sqlite3_memory_alarm() [1/2]

SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm	(	void()(void , sqlite3_int64, int)	,
		void *	,
		sqlite3_int64	)

◆ sqlite3_memory_alarm() [2/2]

SQLITE_API int sqlite3_memory_alarm	(	void()(void pArg, sqlite3_int64 used, int N)	xCallback,
		void *	pArg,
		sqlite3_int64	iThreshold )

Definition at line 27384 of file sqlite3.c.

27393 {

References SQLITE_OK.

◆ sqlite3_memory_highwater()

SQLITE_API sqlite3_int64 sqlite3_memory_highwater ( int resetFlag )

Definition at line 27521 of file sqlite3.c.

References sqlite3_status64(), and SQLITE_STATUS_MEMORY_USED.

◆ sqlite3_memory_used()

SQLITE_API sqlite3_int64 sqlite3_memory_used ( void )

Definition at line 27510 of file sqlite3.c.

◆ sqlite3_mprintf()

SQLITE_API char * sqlite3_mprintf	(	const char *	zFormat,
			... )

Definition at line 29323 of file sqlite3.c.

                                                          {
  va_list ap;
  char *z;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;

Referenced by lsqlite_temp_directory(), renameColumnParseError(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3_overload_function(), sqlite3AuthReadCol(), sqlite3InvalidFunction(), sqlite3LoadExtension(), sqlite3NotPureFunc(), sqlite3ParseUri(), sqlite3Pragma(), and unixOpen().

◆ sqlite3_msize()

SQLITE_API sqlite3_uint64 sqlite3_msize ( void * p )

Definition at line 27683 of file sqlite3.c.

◆ sqlite3_mutex_alloc()

SQLITE_API sqlite3_mutex * sqlite3_mutex_alloc ( int id )

Definition at line 25922 of file sqlite3.c.

                                                     {
#ifndef SQLITE_OMIT_AUTOINIT
  if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;

Referenced by findInodeInfo(), and unixOpenSharedMemory().

◆ sqlite3_mutex_enter()

SQLITE_API void sqlite3_mutex_enter ( sqlite3_mutex * p )

Definition at line 25954 of file sqlite3.c.

25959 {

References sqlite3GlobalConfig.

Referenced by backupUpdate(), columnMem(), columnName(), createFunctionApi(), createModule(), findReusableFd(), lockBtreeMutex(), openDatabase(), osLocaltime(), pcache1Alloc(), posixUnlock(), releaseInodeInfo(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_blob_reopen(), sqlite3_cancel_auto_extension(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_declare_vtab(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_expanded_sql(), sqlite3_finalize(), sqlite3_hard_heap_limit64(), sqlite3_initialize(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_reset(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vtab_config(), sqlite3AutoLoadExtensions(), sqlite3BtreeOpen(), sqlite3Malloc(), sqlite3Prepare16(), sqlite3RunParser(), unixCheckReservedLock(), unixLeaveMutex(), unixLock(), unixOpenSharedMemory(), unixShmLock(), unixShmMap(), unixShmUnmap(), and vdbeUnbind().

◆ sqlite3_mutex_free()

SQLITE_API void sqlite3_mutex_free ( sqlite3_mutex * p )

Definition at line 25943 of file sqlite3.c.

25948 {

Referenced by releaseInodeInfo(), removeFromSharingList(), sqlite3_initialize(), sqlite3LeaveMutexAndCloseZombie(), and unixShmPurge().

◆ sqlite3_mutex_held()

SQLITE_API int sqlite3_mutex_held ( sqlite3_mutex * )

Referenced by allocateBtreePage(), allocateSpace(), autoVacuumCommit(), backupUpdate(), balance_deeper(), balance_nonroot(), balance_quick(), btreeEnterAll(), btreeGetPage(), btreeInitPage(), btreePageLookup(), btreeParseCellPtrNoPayload(), columnMallocFailure(), decodeFlags(), defragmentPage(), dropCell(), fetchPayload(), fillInCell(), freePage2(), freeSpace(), getAndInitPage(), getOverflowPage(), incrVacuumStep(), insertCell(), invalidateAllOverflowCache(), lockBtree(), lockBtreeMutex(), mallocWithAlarm(), modifyPagePointer(), newDatabase(), pageReinit(), pcache1PinPage(), pcache1RemoveFromHash(), pcache1ResizeHash(), pcache1TruncateUnsafe(), ptrmapGet(), ptrmapPageno(), ptrmapPut(), relocatePage(), saveAllCursors(), schemaIsValid(), setChildPtrmaps(), sqlite3_aggregate_context(), sqlite3_get_auxdata(), sqlite3_result_blob64(), sqlite3_result_error16(), sqlite3_result_int(), sqlite3_result_text(), sqlite3_result_text16be(), sqlite3_result_text16le(), sqlite3_result_text64(), sqlite3_result_value(), sqlite3_set_auxdata(), sqlite3ApiExit(), sqlite3BackupRestart(), sqlite3BtreeEnter(), sqlite3BtreeGetReserveNoMutex(), sqlite3BtreeIsInBackup(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3BtreePutData(), sqlite3BtreeRowCountEst(), sqlite3BtreeSchemaLocked(), sqlite3BtreeSetCacheSize(), sqlite3BtreeSetPagerFlags(), sqlite3BtreeSetSpillSize(), sqlite3Checkpoint(), sqlite3CreateFunc(), sqlite3DbFreeNN(), sqlite3DbRealloc(), sqlite3Init(), sqlite3InitCallback(), sqlite3InitOne(), sqlite3Reprepare(), sqlite3ResultIntReal(), sqlite3RollbackAll(), sqlite3SchemaToIndex(), sqlite3StatusHighwater(), sqlite3StatusUp(), sqlite3StatusValue(), sqlite3ValueText(), sqlite3VdbeChangeEncoding(), sqlite3VdbeMemAggValue(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemFinalize(), sqlite3VdbeMemMakeWriteable(), sqlite3VdbeMemMove(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTranslate(), sqlite3VtabDisconnect(), sqlite3VtabUnlockList(), unixFileLock(), unixShmSystemLock(), unlockBtreeIfUnused(), valueToText(), and vdbeMemClearExternAndSetNull().

◆ sqlite3_mutex_leave()

SQLITE_API void sqlite3_mutex_leave ( sqlite3_mutex * p )

Definition at line 25980 of file sqlite3.c.

25985 {

References sqlite3GlobalConfig.

Referenced by backupUpdate(), columnMallocFailure(), columnName(), createFunctionApi(), createModule(), findReusableFd(), openDatabase(), osLocaltime(), pcache1Alloc(), posixUnlock(), releaseInodeInfo(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_bind_int(), sqlite3_bind_null(), sqlite3_bind_zeroblob64(), sqlite3_blob_reopen(), sqlite3_cancel_auto_extension(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_declare_vtab(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_expanded_sql(), sqlite3_hard_heap_limit64(), sqlite3_initialize(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_reset(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vtab_config(), sqlite3AutoLoadExtensions(), sqlite3BtreeOpen(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Malloc(), sqlite3Prepare16(), sqlite3RunParser(), unixCheckReservedLock(), unixLock(), unixOpenSharedMemory(), unixShmLock(), unixShmMap(), unixShmUnmap(), and vdbeUnbind().

◆ sqlite3_mutex_notheld()

SQLITE_API int sqlite3_mutex_notheld ( sqlite3_mutex * )

Referenced by findReusableFd(), lockBtreeMutex(), pcache1Alloc(), removeFromSharingList(), and unixLeaveMutex().

◆ sqlite3_mutex_try()

SQLITE_API int sqlite3_mutex_try ( sqlite3_mutex * p )

Definition at line 25965 of file sqlite3.c.

                                                  {
  int rc = SQLITE_OK;
  if( p ){

References sqlite3GlobalConfig, and SQLITE_OK.

Referenced by btreeLockCarefully().

◆ sqlite3_next_stmt()

SQLITE_API sqlite3_stmt * sqlite3_next_stmt	(	sqlite3 *	pDb,
		sqlite3_stmt *	pStmt )

Definition at line 84680 of file sqlite3.c.

                                                                             {
  sqlite3_stmt *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(pDb) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(pDb->mutex);
  if( pStmt==0 ){
    pNext = (sqlite3_stmt*)pDb->pVdbe;

References sqlite3::mutex, sqlite3::pVdbe, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), and SQLITE_MISUSE_BKPT.

◆ sqlite3_normalized_sql()

SQLITE_API const char * sqlite3_normalized_sql ( sqlite3_stmt * pStmt )

◆ sqlite3_open()

SQLITE_API int sqlite3_open	(	const char *	filename,
		sqlite3 **	ppDb )

Definition at line 164380 of file sqlite3.c.

◆ sqlite3_open16()

SQLITE_API int sqlite3_open16	(	const void *	filename,
		sqlite3 **	ppDb )

Definition at line 164400 of file sqlite3.c.

 {
  char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
  sqlite3_value *pVal;
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppDb = 0;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  if( zFilename==0 ) zFilename = "\000\000";
  pVal = sqlite3ValueNew(0);
  sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
  if( zFilename8 ){
    rc = openDatabase(zFilename8, ppDb,
                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
    assert( *ppDb || rc==SQLITE_NOMEM );
    if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
      SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
    }
  }else{

◆ sqlite3_open_v2()

SQLITE_API int sqlite3_open_v2	(	const char *	filename,
		sqlite3 **	ppDb,
		int	flags,
		const char *	zVfs )

Definition at line 164387 of file sqlite3.c.

 {
  return openDatabase(zFilename, ppDb,
                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
}
SQLITE_API int sqlite3_open_v2(
  const char *filename,   /* Database filename (UTF-8) */

References openDatabase(), SQLITE_OPEN_CREATE, and SQLITE_OPEN_READWRITE.

◆ sqlite3_os_end()

SQLITE_API int sqlite3_os_end ( void )

Definition at line 41473 of file sqlite3.c.

References SQLITE_OK, and unixBigLock.

Referenced by sqlite3_shutdown().

◆ sqlite3_os_init()

SQLITE_API int sqlite3_os_init ( void )

Definition at line 41373 of file sqlite3.c.

                                    {
  /*
  ** The following macro defines an initializer for an sqlite3_vfs object.
  ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
  ** to the "finder" function.  (pAppData is a pointer to a pointer because
  ** silly C90 rules prohibit a void* from being cast to a function pointer
  ** and so we have to go through the intermediate pointer to avoid problems
  ** when compiling with -pedantic-errors on GCC.)
  **
  ** The FINDER parameter to this macro is the name of the pointer to the
  ** finder-function.  The finder-function returns a pointer to the
  ** sqlite_io_methods object that implements the desired locking
  ** behaviors.  See the division above that contains the IOMETHODS
  ** macro for addition information on finder-functions.
  **
  ** Most finders simply return a pointer to a fixed sqlite3_io_methods
  ** object.  But the "autolockIoFinder" available on MacOSX does a little
  ** more than that; it looks at the filesystem type that hosts the
  ** database file and tries to choose an locking method appropriate for
  ** that filesystem time.
  */
  #define UNIXVFS(VFSNAME, FINDER) {                        \
    3,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
    unixSetSystemCall,    /* xSetSystemCall */              \
    unixGetSystemCall,    /* xGetSystemCall */              \
    unixNextSystemCall,   /* xNextSystemCall */             \
  }
 
  /*
  ** All default VFSes for unix are contained in the following array.
  **
  ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
  ** by the SQLite core when the VFS is registered.  So the following
  ** array cannot be const.
  */
  static sqlite3_vfs aVfs[] = {
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    UNIXVFS("unix",          autolockIoFinder ),
#elif OS_VXWORKS
    UNIXVFS("unix",          vxworksIoFinder ),
#else
    UNIXVFS("unix",          posixIoFinder ),
#endif
    UNIXVFS("unix-none",     nolockIoFinder ),
    UNIXVFS("unix-dotfile",  dotlockIoFinder ),
    UNIXVFS("unix-excl",     posixIoFinder ),
#if OS_VXWORKS
    UNIXVFS("unix-namedsem", semIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS
    UNIXVFS("unix-posix",    posixIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
    UNIXVFS("unix-flock",    flockIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    UNIXVFS("unix-afp",      afpIoFinder ),
    UNIXVFS("unix-nfs",      nfsIoFinder ),
    UNIXVFS("unix-proxy",    proxyIoFinder ),
#endif
  };
  unsigned int i;          /* Loop counter */
 
  /* Double-check that the aSyscall[] array has been constructed
  ** correctly.  See ticket [bb3a86e890c8e96ab] */
  assert( ArraySize(aSyscall)==29 );
 
  /* Register all VFSes defined in the aVfs[] array */

References ArraySize, aSyscall, sqlite3_vfs_register(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_VFS1, SQLITE_OK, unixBigLock, and UNIXVFS.

Referenced by sqlite3OsInit().

◆ sqlite3_overload_function()

SQLITE_API int sqlite3_overload_function	(	sqlite3 *	db,
		const char *	zFuncName,
		int	nArg )

Definition at line 163042 of file sqlite3.c.

 {
  int rc;
  char *zCopy;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
  sqlite3_mutex_leave(db->mutex);

References sqlite3::mutex, sqlite3_create_function_v2(), sqlite3_free(), sqlite3_mprintf(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3FindFunction(), sqlite3InvalidFunction(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_OK, SQLITE_UTF8, and zName.

Referenced by sqlite3RegisterPerConnectionBuiltinFunctions().

◆ sqlite3_prepare()

SQLITE_API int sqlite3_prepare	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

Definition at line 129134 of file sqlite3.c.

◆ sqlite3_prepare16()

SQLITE_API int sqlite3_prepare16	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

Definition at line 129250 of file sqlite3.c.

◆ sqlite3_prepare16_v2()

SQLITE_API int sqlite3_prepare16_v2	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

Definition at line 129262 of file sqlite3.c.

 {
  int rc;
  rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare16_v2(
  sqlite3 *db,              /* Database handle. */
  const void *zSql,         /* UTF-16 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const void **pzTail       /* OUT: End of parsed string */

References sqlite3Prepare16(), and SQLITE_OK.

◆ sqlite3_prepare16_v3()

SQLITE_API int sqlite3_prepare16_v3	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		unsigned int	prepFlags,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

Definition at line 129274 of file sqlite3.c.

 {
  int rc;
  rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare16_v3(
  sqlite3 *db,              /* Database handle. */
  const void *zSql,         /* UTF-16 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  unsigned int prepFlags,   /* Zero or more SQLITE_PREPARE_* flags */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const void **pzTail       /* OUT: End of parsed string */
){
  int rc;

References sqlite3Prepare16(), SQLITE_OK, and SQLITE_PREPARE_SAVESQL.

◆ sqlite3_prepare_v2()

SQLITE_API int sqlite3_prepare_v2	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

Definition at line 129146 of file sqlite3.c.

 {
  int rc;
  rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare_v2(
  sqlite3 *db,              /* Database handle. */
  const char *zSql,         /* UTF-8 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const char **pzTail       /* OUT: End of parsed string */
){
  int rc;
  /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
  ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags
  ** parameter.
  **

References sqlite3LockAndPrepare(), and SQLITE_OK.

Referenced by db_do_rows(), db_prepare(), execSql(), and sqlite3_exec().

◆ sqlite3_prepare_v3()

SQLITE_API int sqlite3_prepare_v3	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		unsigned int	prepFlags,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

Definition at line 129164 of file sqlite3.c.

 {
  int rc;
  /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
  ** sqlite3_prepare_v2() only in having the extra prepFlags parameter,
  ** which is a bit array consisting of zero or more of the
  ** SQLITE_PREPARE_* flags.
  **
  ** Proof by comparison to the implementation of sqlite3_prepare_v2()
  ** directly above. */

◆ sqlite3_profile()

SQLITE_API void * sqlite3_profile	(	sqlite3 *	db,
		void()(void , const char *, sqlite3_uint64)	xProfile,
		void *	pArg )

Definition at line 163126 of file sqlite3.c.

 {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;
  db->xProfile = xProfile;

References sqlite3::mTrace, sqlite3::mutex, sqlite3::pProfileArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_TRACE_NONLEGACY_MASK, SQLITE_TRACE_XPROFILE, and sqlite3::xProfile.

◆ sqlite3_progress_handler()

SQLITE_API void sqlite3_progress_handler	(	sqlite3 *	db,
		int	nOps,
		int()(void )	xProgress,
		void *	pArg )

Definition at line 162700 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( nOps>0 ){
    db->xProgress = xProgress;
    db->nProgressOps = (unsigned)nOps;
    db->pProgressArg = pArg;
  }else{

References sqlite3::mutex, sqlite3::nProgressOps, sqlite3::pProgressArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, and sqlite3::xProgress.

Referenced by db_progress_handler().

◆ sqlite3_randomness()

SQLITE_API void sqlite3_randomness	(	int	N,
		void *	P )

Definition at line 30261 of file sqlite3.c.

                                                     {
  unsigned char t;
  unsigned char *zBuf = pBuf;
 
  /* The "wsdPrng" macro will resolve to the pseudo-random number generator
  ** state vector.  If writable static data is unsupported on the target,
  ** we have to locate the state vector at run-time.  In the more common
  ** case where writable static data is supported, wsdPrng can refer directly
  ** to the "sqlite3Prng" state vector declared above.
  */
#ifdef SQLITE_OMIT_WSD
  struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
# define wsdPrng p[0]
#else
# define wsdPrng sqlite3Prng
#endif
 
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
 
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return;
#endif
 
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
#endif
 
  sqlite3_mutex_enter(mutex);
  if( N<=0 || pBuf==0 ){
    wsdPrng.isInit = 0;
    sqlite3_mutex_leave(mutex);
    return;
  }
 
  /* Initialize the state of the random number generator once,
  ** the first time this routine is called.  The seed value does
  ** not need to contain a lot of randomness since we are not
  ** trying to do secure encryption or anything like that...
  **
  ** Nothing in this file or anywhere else in SQLite does any kind of
  ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
  ** number generator) not as an encryption device.
  */
  if( !wsdPrng.isInit ){
    int i;
    char k[256];
    wsdPrng.j = 0;
    wsdPrng.i = 0;
    sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
    for(i=0; i<256; i++){
      wsdPrng.s[i] = (u8)i;
    }
    for(i=0; i<256; i++){
      wsdPrng.j += wsdPrng.s[i] + k[i];
      t = wsdPrng.s[wsdPrng.j];
      wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
      wsdPrng.s[i] = t;
    }
    wsdPrng.isInit = 1;
  }
 
  assert( N>0 );
  do{
    wsdPrng.i++;
    t = wsdPrng.s[wsdPrng.i];
    wsdPrng.j += t;
    wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];

Referenced by randomFunc(), sqlite3BitvecBuiltinTest(), sqlite3ColumnsFromExprList(), sqlite3VdbeExec(), unixGetTempname(), unixOpen(), vdbeCommit(), walCheckpoint(), walRestartLog(), and writeJournalHdr().

◆ sqlite3_realloc()

SQLITE_API void * sqlite3_realloc	(	void *	pOld,
		int	n )

Definition at line 27819 of file sqlite3.c.

27824 {

27825#ifndef SQLITE_OMIT_AUTOINIT

Referenced by unixShmMap().

◆ sqlite3_realloc64()

SQLITE_API void * sqlite3_realloc64	(	void *	pOld,
		sqlite3_uint64	n )

Definition at line 27826 of file sqlite3.c.

27831 {

Referenced by sqlite3_auto_extension().

◆ sqlite3_release_memory()

SQLITE_API int sqlite3_release_memory ( int n )

Definition at line 27335 of file sqlite3.c.

                                            {
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  return sqlite3PcacheReleaseMemory(n);
#else
  /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
  ** is a no-op returning zero if SQLite is not compiled with

References UNUSED_PARAMETER.

◆ sqlite3_reset()

SQLITE_API int sqlite3_reset ( sqlite3_stmt * pStmt )

Definition at line 83107 of file sqlite3.c.

                                                 {
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeRewind(v);

References checkProfileCallback, Vdbe::db, sqlite3::errMask, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3VdbeReset(), sqlite3VdbeRewind(), and SQLITE_OK.

Referenced by db_do_next_row(), dbvm_reset(), sqlite3_step(), and sqlite3Step().

◆ sqlite3_reset_auto_extension()

SQLITE_API void sqlite3_reset_auto_extension ( void )

Definition at line 125025 of file sqlite3.c.

                                                  {
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize()==SQLITE_OK )
#endif
  {
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);

Referenced by sqlite3_shutdown().

◆ sqlite3_result_blob()

SQLITE_API void sqlite3_result_blob	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel )

Definition at line 83379 of file sqlite3.c.

       {
    xDel((void*)p);
  }
  if( pCtx ) sqlite3_result_error_toobig(pCtx);
  return SQLITE_TOOBIG;
}
SQLITE_API void sqlite3_result_blob(
  sqlite3_context *pCtx,
  const void *z,
  int n,

Referenced by lcontext_result_blob(), and statGet().

◆ sqlite3_result_blob64()

SQLITE_API void sqlite3_result_blob64	(	sqlite3_context *	pCtx,
		const void *	z,
		sqlite3_uint64	n,
		void()(void )	xDel )

Definition at line 83389 of file sqlite3.c.

 {
  assert( n>=0 );
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, 0, xDel);
}
SQLITE_API void sqlite3_result_blob64(
  sqlite3_context *pCtx,
  const void *z,
  sqlite3_uint64 n,
  void (*xDel)(void *)
){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), and sqlite3_mutex_held().

Referenced by substrFunc().

◆ sqlite3_result_double()

SQLITE_API void sqlite3_result_double	(	sqlite3_context *	pCtx,
		double	rVal )

Definition at line 83403 of file sqlite3.c.

                    {
    (void)invokeValueDestructor(z, xDel, pCtx);
  }else{
    setResultStrOrError(pCtx, z, (int)n, 0, xDel);

References invokeValueDestructor().

Referenced by absFunc(), juliandayFunc(), lcontext_result(), and lcontext_result_double().

◆ sqlite3_result_error()

SQLITE_API void sqlite3_result_error	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n )

Definition at line 83407 of file sqlite3.c.

                                                                         {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);

Referenced by absFunc(), attachFunc(), db_sql_finalize_function(), db_sql_normal_function(), detachFunc(), lcontext_result_error(), likeFunc(), loadExt(), localtimeOffset(), ntileStepFunc(), renameColumnParseError(), sqlite3InvalidFunction(), and sqlite3NotPureFunc().

◆ sqlite3_result_error16()

SQLITE_API void sqlite3_result_error16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n )

Definition at line 83413 of file sqlite3.c.

                                                                                 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}

References sqlite3_value::db, sqlite3_context::isError, sqlite3::mutex, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3VdbeMemSetStr(), SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF8.

◆ sqlite3_result_error_code()

SQLITE_API void sqlite3_result_error_code	(	sqlite3_context *	pCtx,
		int	errCode )

Definition at line 83520 of file sqlite3.c.

                                                    {
    return SQLITE_TOOBIG;
  }
  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
  return SQLITE_OK;
}
SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
  pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
  if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;

References SQLITE_TOOBIG.

Referenced by attachFunc(), renameColumnFunc(), and renameTableFunc().

◆ sqlite3_result_error_nomem()

SQLITE_API void sqlite3_result_error_nomem ( sqlite3_context * pCtx )

Definition at line 83540 of file sqlite3.c.

Referenced by charFunc(), contextMalloc(), instrFunc(), replaceFunc(), statGet(), statInit(), and strftimeFunc().

◆ sqlite3_result_error_toobig()

SQLITE_API void sqlite3_result_error_toobig ( sqlite3_context * pCtx )

Definition at line 83532 of file sqlite3.c.

Referenced by contextMalloc(), invokeValueDestructor(), replaceFunc(), and strftimeFunc().

◆ sqlite3_result_int()

SQLITE_API void sqlite3_result_int	(	sqlite3_context *	pCtx,
		int	iVal )

Definition at line 83419 of file sqlite3.c.

                                                                                   {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

References sqlite3_value::db, sqlite3_context::isError, sqlite3::mutex, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3VdbeMemSetStr(), SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF16NATIVE.

Referenced by changes(), compileoptionusedFunc(), instrFunc(), lcontext_result_int(), likeFunc(), and renameTableTest().

◆ sqlite3_result_int64()

SQLITE_API void sqlite3_result_int64	(	sqlite3_context *	pCtx,
		sqlite3_int64	iVal )

Definition at line 83423 of file sqlite3.c.

83425 {

83426 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

Referenced by absFunc(), countInverse(), lcontext_result(), randomFunc(), and statGet().

◆ sqlite3_result_null()

SQLITE_API void sqlite3_result_null ( sqlite3_context * pCtx )

Definition at line 83427 of file sqlite3.c.

83429 {

83430 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

Referenced by absFunc(), lcontext_result(), and lcontext_result_null().

◆ sqlite3_result_pointer()

SQLITE_API void sqlite3_result_pointer	(	sqlite3_context *	pCtx,
		void *	pPtr,
		const char *	zPType,
		void()(void )	xDestructor )

Definition at line 83431 of file sqlite3.c.

                                                          {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetNull(pCtx->pOut);
}
SQLITE_API void sqlite3_result_pointer(
  sqlite3_context *pCtx,
  void *pPtr,
  const char *zPType,
  void (*xDestructor)(void*)
){

◆ sqlite3_result_subtype()

SQLITE_API void sqlite3_result_subtype	(	sqlite3_context *	pCtx,
		unsigned int	eSubtype )

Definition at line 83443 of file sqlite3.c.

◆ sqlite3_result_text()

SQLITE_API void sqlite3_result_text	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n,
		void()(void )	xDel )

Definition at line 83449 of file sqlite3.c.

                                                                                    {
  Mem *pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );
  pOut->eSubtype = eSubtype & 0xff;
  pOut->flags |= MEM_Subtype;
}
SQLITE_API void sqlite3_result_text(
  sqlite3_context *pCtx,
  const char *z,

References sqlite3_value::db, sqlite3_value::eSubtype, sqlite3_value::flags, MEM_Subtype, sqlite3::mutex, sqlite3_context::pOut, and sqlite3_mutex_held().

Referenced by dateFunc(), datetimeFunc(), lcontext_result(), lcontext_result_text(), quoteFunc(), renameEditSql(), replaceFunc(), sourceidFunc(), statGet(), strftimeFunc(), and timeFunc().

◆ sqlite3_result_text16()

SQLITE_API void sqlite3_result_text16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel )

Definition at line 83475 of file sqlite3.c.

       {
    setResultStrOrError(pCtx, z, (int)n, enc, xDel);
  }
}
#ifndef SQLITE_OMIT_UTF16
SQLITE_API void sqlite3_result_text16(
  sqlite3_context *pCtx,
  const void *z,

◆ sqlite3_result_text16be()

SQLITE_API void sqlite3_result_text16be	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel )

Definition at line 83484 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
}
SQLITE_API void sqlite3_result_text16be(
  sqlite3_context *pCtx,
  const void *z,

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16NATIVE.

◆ sqlite3_result_text16le()

SQLITE_API void sqlite3_result_text16le	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void()(void )	xDel )

Definition at line 83493 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
}
SQLITE_API void sqlite3_result_text16le(
  sqlite3_context *pCtx,
  const void *z,

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16BE.

◆ sqlite3_result_text64()

SQLITE_API void sqlite3_result_text64	(	sqlite3_context *	pCtx,
		const char *	z,
		sqlite3_uint64	n,
		void()(void )	xDel,
		unsigned char	encoding )

Definition at line 83458 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
}
SQLITE_API void sqlite3_result_text64(
  sqlite3_context *pCtx,
  const char *z,
  sqlite3_uint64 n,
  void (*xDel)(void *),
  unsigned char enc
){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );
  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF8.

Referenced by charFunc(), and substrFunc().

◆ sqlite3_result_value()

SQLITE_API void sqlite3_result_value	(	sqlite3_context *	pCtx,
		sqlite3_value *	pValue )

Definition at line 83503 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16LE.

Referenced by last_valueFinalizeFunc(), nullifFunc(), quoteFunc(), and replaceFunc().

◆ sqlite3_result_zeroblob()

SQLITE_API void sqlite3_result_zeroblob	(	sqlite3_context *	pCtx,
		int	n )

Definition at line 83507 of file sqlite3.c.

83509 {

83510 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

◆ sqlite3_result_zeroblob64()

SQLITE_API int sqlite3_result_zeroblob64	(	sqlite3_context *	pCtx,
		sqlite3_uint64	n )

Definition at line 83511 of file sqlite3.c.

                                                                     {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
}
SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
  Mem *pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );

◆ sqlite3_rollback_hook()

SQLITE_API void * sqlite3_rollback_hook	(	sqlite3 *	db,
		void()(void )	xCallback,
		void *	pArg )

Definition at line 163206 of file sqlite3.c.

 {
  void *pRet;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);

Referenced by db_rollback_hook().

◆ sqlite3_rtree_geometry_callback()

SQLITE_API int sqlite3_rtree_geometry_callback	(	sqlite3 *	db,
		const char *	zGeom,
		int()(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int )	xGeom,
		void *	pContext )

◆ sqlite3_rtree_query_callback()

SQLITE_API int sqlite3_rtree_query_callback	(	sqlite3 *	db,
		const char *	zQueryFunc,
		int()(sqlite3_rtree_query_info )	xQueryFunc,
		void *	pContext,
		void()(void )	xDestructor )

◆ sqlite3_serialize()

SQLITE_API unsigned char * sqlite3_serialize	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_int64 *	piSize,
		unsigned int	mFlags )

◆ sqlite3_set_authorizer()

SQLITE_API int sqlite3_set_authorizer	(	sqlite3 *	db,
		int()(void , int, const char , const char , const char , const char )	xAuth,
		void *	pUserData )

Definition at line 110182 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3::pAuthArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ExpirePreparedStatements(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, and sqlite3::xAuth.

◆ sqlite3_set_auxdata()

SQLITE_API void sqlite3_set_auxdata	(	sqlite3_context *	pCtx,
		int	N,
		void *	pAux,
		void()(void )	xDelete )

Definition at line 83916 of file sqlite3.c.

                        :  If iArg is negative then make the data available
** to all functions within the current prepared statement using iArg as an
** access code.
*/
SQLITE_API void sqlite3_set_auxdata(
  sqlite3_context *pCtx,
  int iArg,
  void *pAux,
  void (*xDelete)(void*)
){
  AuxData *pAuxData;
  Vdbe *pVdbe = pCtx->pVdbe;
 
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#ifdef SQLITE_ENABLE_STAT4
  if( pVdbe==0 ) goto failed;
#else
  assert( pVdbe!=0 );
#endif
 
  for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
    if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
      break;
    }
  }
  if( pAuxData==0 ){
    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
    if( !pAuxData ) goto failed;
    pAuxData->iAuxOp = pCtx->iOp;
    pAuxData->iAuxArg = iArg;
    pAuxData->pNextAux = pVdbe->pAuxData;
    pVdbe->pAuxData = pAuxData;
    if( pCtx->isError==0 ) pCtx->isError = -1;
  }else if( pAuxData->xDeleteAux ){
    pAuxData->xDeleteAux(pAuxData->pAux);
  }
 
  pAuxData->pAux = pAux;
  pAuxData->xDeleteAux = xDelete;
  return;

References sqlite3_value::db, Vdbe::db, AuxData::iAuxArg, AuxData::iAuxOp, sqlite3_context::iOp, sqlite3_context::isError, sqlite3::mutex, AuxData::pAux, Vdbe::pAuxData, AuxData::pNextAux, sqlite3_context::pOut, sqlite3_context::pVdbe, sqlite3_mutex_held(), sqlite3DbMallocZero(), and AuxData::xDeleteAux.

◆ sqlite3_set_last_insert_rowid()

SQLITE_API void sqlite3_set_last_insert_rowid	(	sqlite3 *	db,
		sqlite3_int64	iRowid )

Definition at line 162067 of file sqlite3.c.

                                                                                {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return;

◆ sqlite3_shutdown()

SQLITE_API int sqlite3_shutdown ( void )

Definition at line 161371 of file sqlite3.c.

                                     {
#ifdef SQLITE_OMIT_WSD
  int rc = sqlite3_wsd_init(4096, 24);
  if( rc!=SQLITE_OK ){
    return rc;
  }
#endif
 
  if( sqlite3GlobalConfig.isInit ){
#ifdef SQLITE_EXTRA_SHUTDOWN
    void SQLITE_EXTRA_SHUTDOWN(void);
    SQLITE_EXTRA_SHUTDOWN();
#endif
    sqlite3_os_end();
    sqlite3_reset_auto_extension();
    sqlite3GlobalConfig.isInit = 0;
  }
  if( sqlite3GlobalConfig.isPCacheInit ){
    sqlite3PcacheShutdown();
    sqlite3GlobalConfig.isPCacheInit = 0;
  }
  if( sqlite3GlobalConfig.isMallocInit ){
    sqlite3MallocEnd();
    sqlite3GlobalConfig.isMallocInit = 0;
 
#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
    /* The heap subsystem has now been shutdown and these values are supposed
    ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
    ** which would rely on that heap subsystem; therefore, make sure these
    ** values cannot refer to heap memory that was just invalidated when the
    ** heap subsystem was shutdown.  This is only done if the current call to
    ** this function resulted in the heap subsystem actually being shutdown.
    */
    sqlite3_data_directory = 0;
    sqlite3_temp_directory = 0;
#endif
  }
  if( sqlite3GlobalConfig.isMutexInit ){

References sqlite3_data_directory, sqlite3_os_end(), sqlite3_reset_auto_extension(), sqlite3_temp_directory, sqlite3GlobalConfig, sqlite3MallocEnd(), sqlite3MutexEnd(), sqlite3PcacheShutdown(), and SQLITE_OK.

◆ sqlite3_sleep()

SQLITE_API int sqlite3_sleep ( int ms )

Definition at line 164752 of file sqlite3.c.

                                    {
  sqlite3_vfs *pVfs;
  int rc;
  pVfs = sqlite3_vfs_find(0);
  if( pVfs==0 ) return 0;
 

◆ sqlite3_snapshot_cmp()

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp	(	sqlite3_snapshot *	p1,
		sqlite3_snapshot *	p2 )

◆ sqlite3_snapshot_free()

SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free ( sqlite3_snapshot * )

◆ sqlite3_snapshot_get()

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_snapshot **	ppSnapshot )

◆ sqlite3_snapshot_open()

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_snapshot *	pSnapshot )

◆ sqlite3_snapshot_recover()

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover	(	sqlite3 *	db,
		const char *	zDb )

◆ sqlite3_snprintf()

SQLITE_API char * sqlite3_snprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
			... )

Definition at line 29363 of file sqlite3.c.

29369 {

29370 char *z;

Referenced by createTableStmt(), dateFunc(), datetimeFunc(), detachFunc(), openDirectory(), quoteFunc(), sqlite3LoadExtension(), sqlite3VdbeReset(), statGet(), strftimeFunc(), timeFunc(), unixGetTempname(), unixOpenSharedMemory(), and vdbeCommit().

◆ sqlite3_soft_heap_limit()

SQLITE_API void sqlite3_soft_heap_limit ( int N )

Definition at line 27432 of file sqlite3.c.

◆ sqlite3_soft_heap_limit64()

SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64 ( sqlite3_int64 N )

Definition at line 27407 of file sqlite3.c.

                                                                   {
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
  sqlite3_int64 nUsed;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  if( n<0 ){
    sqlite3_mutex_leave(mem0.mutex);
    return priorLimit;
  }
  if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){
    n = mem0.hardLimit;
  }
  mem0.alarmThreshold = n;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed);

References AtomicStore, mem0, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3StatusValue(), and SQLITE_STATUS_MEMORY_USED.

Referenced by sqlite3Pragma().

◆ sqlite3_sourceid()

SQLITE_API const char * sqlite3_sourceid ( void )

Definition at line 230510 of file sqlite3.c.

References SQLITE_SOURCE_ID.

Referenced by sourceidFunc(), and sqlite3CorruptError().

◆ sqlite3_sql()

SQLITE_API const char * sqlite3_sql ( sqlite3_stmt * pStmt )

Definition at line 84731 of file sqlite3.c.

Referenced by sqlite3_expanded_sql(), and sqlite3Reprepare().

◆ sqlite3_status()

SQLITE_API int sqlite3_status	(	int	op,
		int *	pCurrent,
		int *	pHighwater,
		int	resetFlag )

Definition at line 21472 of file sqlite3.c.

                                                                                    {
  sqlite3_int64 iCur = 0, iHwtr = 0;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){

◆ sqlite3_status64()

SQLITE_API int sqlite3_status64	(	int	op,
		sqlite3_int64 *	pCurrent,
		sqlite3_int64 *	pHighwater,
		int	resetFlag )

Definition at line 21447 of file sqlite3.c.

 {
  sqlite3_mutex *pMutex;
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
  sqlite3_mutex_enter(pMutex);
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];

Referenced by sqlite3_memory_highwater().

◆ sqlite3_step()

SQLITE_API int sqlite3_step ( sqlite3_stmt * pStmt )

Definition at line 83730 of file sqlite3.c.

                                                {
  int rc = SQLITE_OK;      /* Result from sqlite3Step() */
  Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
  sqlite3 *db;             /* The database connection */
 
  if( vdbeSafetyNotNull(v) ){
    return SQLITE_MISUSE_BKPT;
  }
  db = v->db;
  sqlite3_mutex_enter(db->mutex);
  v->doingRerun = 0;
  while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
         && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
    int savedPc = v->pc;
    rc = sqlite3Reprepare(v);
    if( rc!=SQLITE_OK ){
      /* This case occurs after failing to recompile an sql statement.
      ** The error message from the SQL compiler has already been loaded
      ** into the database handle. This block copies the error message
      ** from the database handle into the statement and sets the statement
      ** program counter to 0 to ensure that when the statement is
      ** finalized or reset the parser error message is available via
      ** sqlite3_errmsg() and sqlite3_errcode().
      */
      const char *zErr = (const char *)sqlite3_value_text(db->pErr);
      sqlite3DbFree(db, v->zErrMsg);
      if( !db->mallocFailed ){
        v->zErrMsg = sqlite3DbStrDup(db, zErr);
        v->rc = rc = sqlite3ApiExit(db, rc);
      } else {
        v->zErrMsg = 0;
        v->rc = rc = SQLITE_NOMEM_BKPT;
      }
      break;
    }
    sqlite3_reset(pStmt);

References Vdbe::db, Vdbe::doingRerun, Vdbe::expired, sqlite3::mallocFailed, sqlite3::mutex, Vdbe::pc, sqlite3::pErr, Vdbe::rc, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_reset(), sqlite3_value_text(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DbStrDup(), sqlite3Reprepare(), sqlite3Step(), SQLITE_MAX_SCHEMA_RETRY, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_SCHEMA, vdbeSafetyNotNull(), and Vdbe::zErrMsg.

Referenced by blobSeekToRow(), execSql(), sqlite3_exec(), and stepvm().

◆ sqlite3_stmt_busy()

SQLITE_API int sqlite3_stmt_busy ( sqlite3_stmt * pStmt )

Definition at line 84669 of file sqlite3.c.

◆ sqlite3_stmt_isexplain()

SQLITE_API int sqlite3_stmt_isexplain ( sqlite3_stmt * pStmt )

Definition at line 84662 of file sqlite3.c.

◆ sqlite3_stmt_readonly()

SQLITE_API int sqlite3_stmt_readonly ( sqlite3_stmt * pStmt )

Definition at line 84654 of file sqlite3.c.

◆ sqlite3_stmt_scanstatus()

SQLITE_API int sqlite3_stmt_scanstatus	(	sqlite3_stmt *	pStmt,
		int	idx,
		int	iScanStatusOp,
		void *	pOut )

◆ sqlite3_stmt_scanstatus_reset()

SQLITE_API void sqlite3_stmt_scanstatus_reset ( sqlite3_stmt * )

◆ sqlite3_stmt_status()

SQLITE_API int sqlite3_stmt_status	(	sqlite3_stmt *	pStmt,
		int	op,
		int	resetFlg )

Definition at line 84701 of file sqlite3.c.

                                                                              {
  Vdbe *pVdbe = (Vdbe*)pStmt;
  u32 v;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !pStmt
   || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
  ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  if( op==SQLITE_STMTSTATUS_MEMUSED ){
    sqlite3 *db = pVdbe->db;
    sqlite3_mutex_enter(db->mutex);
    v = 0;
    db->pnBytesFreed = (int*)&v;
    sqlite3VdbeClearObject(db, pVdbe);
    sqlite3DbFree(db, pVdbe);
    db->pnBytesFreed = 0;
    sqlite3_mutex_leave(db->mutex);

◆ sqlite3_str_append()

SQLITE_API void sqlite3_str_append	(	sqlite3_str *	p,
		const char *	zIn,
		int	N )

Definition at line 29123 of file sqlite3.c.

                                                                        {
  assert( z!=0 || N==0 );
  assert( p->zText!=0 || p->nChar==0 || p->accError );
  assert( N>=0 );
  assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
  if( p->nChar+N >= p->nAlloc ){
    enlargeAndAppend(p,z,N);

Referenced by explainAppendTerm(), explainIndexRange(), sqlite3_str_vappendf(), sqlite3RunParser(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), and sqlite3WhereExplainOneScan().

◆ sqlite3_str_appendall()

SQLITE_API void sqlite3_str_appendall	(	sqlite3_str *	p,
		const char *	zIn )

Definition at line 29140 of file sqlite3.c.

Referenced by explainAppendTerm(), sqlite3_str_vappendf(), sqlite3VdbeDisplayP4(), and sqlite3WhereExplainOneScan().

◆ sqlite3_str_appendchar()

SQLITE_API void sqlite3_str_appendchar	(	sqlite3_str *	p,
		int	N,
		char	C )

Definition at line 29095 of file sqlite3.c.

29101 {

Referenced by sqlite3_str_vappendf().

◆ sqlite3_str_appendf()

SQLITE_API void sqlite3_str_appendf	(	sqlite3_str *	p,
		const char *	zFormat,
			... )

Definition at line 29440 of file sqlite3.c.

References sqlite3_str_vappendf().

Referenced by explainIndexRange(), sqlite3RunParser(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), sqlite3WhereExplainOneScan(), and vdbeMemRenderNum().

◆ sqlite3_str_errcode()

SQLITE_API int sqlite3_str_errcode ( sqlite3_str * p )

Definition at line 29197 of file sqlite3.c.

◆ sqlite3_str_finish()

SQLITE_API char * sqlite3_str_finish ( sqlite3_str * p )

Definition at line 29185 of file sqlite3.c.

                                   {
   0, 0, 0, 0, 0, SQLITE_NOMEM, 0
};
 
/* Finalize a string created using sqlite3_str_new().
*/
SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){
  char *z;
  if( p!=0 && p!=&sqlite3OomStr ){
    z = sqlite3StrAccumFinish(p);

References SQLITE_NOMEM.

Referenced by sqlite3RunParser().

◆ sqlite3_str_length()

SQLITE_API int sqlite3_str_length ( sqlite3_str * p )

Definition at line 29202 of file sqlite3.c.

29203 {

29204 return p ? p->accError : SQLITE_NOMEM;

References sqlite3_str::accError, and SQLITE_NOMEM.

◆ sqlite3_str_new()

SQLITE_API sqlite3_str * sqlite3_str_new ( sqlite3 * db )

Definition at line 29251 of file sqlite3.c.

                                                    {
  sqlite3_str *p = sqlite3_malloc64(sizeof(*p));
  if( p ){
    sqlite3StrAccumInit(p, 0, 0, 0,

Referenced by sqlite3RunParser().

◆ sqlite3_str_reset()

SQLITE_API void sqlite3_str_reset ( sqlite3_str * p )

Definition at line 29216 of file sqlite3.c.

                                              {
  if( isMalloced(p) ){
    sqlite3DbFree(p->db, p->zText);

Referenced by sqlite3BtreeIntegrityCheck(), sqlite3StrAccumEnlarge(), and sqlite3VdbeExpandSql().

◆ sqlite3_str_value()

SQLITE_API char * sqlite3_str_value ( sqlite3_str * p )

Definition at line 29207 of file sqlite3.c.

                                                 {
  return p ? p->nChar : 0;
}
 

References sqlite3_str::nChar.

◆ sqlite3_str_vappendf()

SQLITE_API void sqlite3_str_vappendf	(	sqlite3_str *	pAccum,
		const char *	zFormat,
		va_list	ap )

Definition at line 28341 of file sqlite3.c.

 {
  int c;                     /* Next character in the format string */
  char *bufpt;               /* Pointer to the conversion buffer */
  int precision;             /* Precision of the current field */
  int length;                /* Length of the field */
  int idx;                   /* A general purpose loop counter */
  int width;                 /* Width of the current field */
  etByte flag_leftjustify;   /* True if "-" flag is present */
  etByte flag_prefix;        /* '+' or ' ' or 0 for prefix */
  etByte flag_alternateform; /* True if "#" flag is present */
  etByte flag_altform2;      /* True if "!" flag is present */
  etByte flag_zeropad;       /* True if field width constant starts with zero */
  etByte flag_long;          /* 1 for the "l" flag, 2 for "ll", 0 by default */
  etByte done;               /* Loop termination flag */
  etByte cThousand;          /* Thousands separator for %d and %u */
  etByte xtype = etINVALID;  /* Conversion paradigm */
  u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */
  char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
  sqlite_uint64 longvalue;   /* Value for integer types */
  LONGDOUBLE_TYPE realvalue; /* Value for real types */
  const et_info *infop;      /* Pointer to the appropriate info structure */
  char *zOut;                /* Rendering buffer */
  int nOut;                  /* Size of the rendering buffer */
  char *zExtra = 0;          /* Malloced memory used by some conversion */
#ifndef SQLITE_OMIT_FLOATING_POINT
  int  exp, e2;              /* exponent of real numbers */
  int nsd;                   /* Number of significant digits returned */
  double rounder;            /* Used for rounding floating point values */
  etByte flag_dp;            /* True if decimal point should be shown */
  etByte flag_rtz;           /* True if trailing zeros should be removed */
#endif
  PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
  char buf[etBUFSIZE];       /* Conversion buffer */
 
  /* pAccum never starts out with an empty buffer that was obtained from
  ** malloc().  This precondition is required by the mprintf("%z...")
  ** optimization. */
  assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
 
  bufpt = 0;
  if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){
    pArgList = va_arg(ap, PrintfArguments*);
    bArgList = 1;
  }else{
    bArgList = 0;
  }
  for(; (c=(*fmt))!=0; ++fmt){
    if( c!='%' ){
      bufpt = (char *)fmt;
#if HAVE_STRCHRNUL
      fmt = strchrnul(fmt, '%');
#else
      do{ fmt++; }while( *fmt && *fmt != '%' );
#endif
      sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt));
      if( *fmt==0 ) break;
    }
    if( (c=(*++fmt))==0 ){
      sqlite3_str_append(pAccum, "%", 1);
      break;
    }
    /* Find out what flags are present */
    flag_leftjustify = flag_prefix = cThousand =
     flag_alternateform = flag_altform2 = flag_zeropad = 0;
    done = 0;
    width = 0;
    flag_long = 0;
    precision = -1;
    do{
      switch( c ){
        case '-':   flag_leftjustify = 1;     break;
        case '+':   flag_prefix = '+';        break;
        case ' ':   flag_prefix = ' ';        break;
        case '#':   flag_alternateform = 1;   break;
        case '!':   flag_altform2 = 1;        break;
        case '0':   flag_zeropad = 1;         break;
        case ',':   cThousand = ',';          break;
        default:    done = 1;                 break;
        case 'l': {
          flag_long = 1;
          c = *++fmt;
          if( c=='l' ){
            c = *++fmt;
            flag_long = 2;
          }
          done = 1;
          break;
        }
        case '1': case '2': case '3': case '4': case '5':
        case '6': case '7': case '8': case '9': {
          unsigned wx = c - '0';
          while( (c = *++fmt)>='0' && c<='9' ){
            wx = wx*10 + c - '0';
          }
          testcase( wx>0x7fffffff );
          width = wx & 0x7fffffff;
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
            width = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( c!='.' && c!='l' ){
            done = 1;
          }else{
            fmt--;
          }
          break;
        }
        case '*': {
          if( bArgList ){
            width = (int)getIntArg(pArgList);
          }else{
            width = va_arg(ap,int);
          }
          if( width<0 ){
            flag_leftjustify = 1;
            width = width >= -2147483647 ? -width : 0;
          }
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
            width = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( (c = fmt[1])!='.' && c!='l' ){
            c = *++fmt;
            done = 1;
          }
          break;
        }
        case '.': {
          c = *++fmt;
          if( c=='*' ){
            if( bArgList ){
              precision = (int)getIntArg(pArgList);
            }else{
              precision = va_arg(ap,int);
            }
            if( precision<0 ){
              precision = precision >= -2147483647 ? -precision : -1;
            }
            c = *++fmt;
          }else{
            unsigned px = 0;
            while( c>='0' && c<='9' ){
              px = px*10 + c - '0';
              c = *++fmt;
            }
            testcase( px>0x7fffffff );
            precision = px & 0x7fffffff;
          }
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
            precision = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( c=='l' ){
            --fmt;
          }else{
            done = 1;
          }
          break;
        }
      }
    }while( !done && (c=(*++fmt))!=0 );
 
    /* Fetch the info entry for the field */
    infop = &fmtinfo[0];
    xtype = etINVALID;
    for(idx=0; idx<ArraySize(fmtinfo); idx++){
      if( c==fmtinfo[idx].fmttype ){
        infop = &fmtinfo[idx];
        xtype = infop->type;
        break;
      }
    }
 
    /*
    ** At this point, variables are initialized as follows:
    **
    **   flag_alternateform          TRUE if a '#' is present.
    **   flag_altform2               TRUE if a '!' is present.
    **   flag_prefix                 '+' or ' ' or zero
    **   flag_leftjustify            TRUE if a '-' is present or if the
    **                               field width was negative.
    **   flag_zeropad                TRUE if the width began with 0.
    **   flag_long                   1 for "l", 2 for "ll"
    **   width                       The specified field width.  This is
    **                               always non-negative.  Zero is the default.
    **   precision                   The specified precision.  The default
    **                               is -1.
    **   xtype                       The class of the conversion.
    **   infop                       Pointer to the appropriate info struct.
    */
    assert( width>=0 );
    assert( precision>=(-1) );
    switch( xtype ){
      case etPOINTER:
        flag_long = sizeof(char*)==sizeof(i64) ? 2 :
                     sizeof(char*)==sizeof(long int) ? 1 : 0;
        /* no break */ deliberate_fall_through
      case etORDINAL:
      case etRADIX:
        cThousand = 0;
        /* no break */ deliberate_fall_through
      case etDECIMAL:
        if( infop->flags & FLAG_SIGNED ){
          i64 v;
          if( bArgList ){
            v = getIntArg(pArgList);
          }else if( flag_long ){
            if( flag_long==2 ){
              v = va_arg(ap,i64) ;
            }else{
              v = va_arg(ap,long int);
            }
          }else{
            v = va_arg(ap,int);
          }
          if( v<0 ){
            if( v==SMALLEST_INT64 ){
              longvalue = ((u64)1)<<63;
            }else{
              longvalue = -v;
            }
            prefix = '-';
          }else{
            longvalue = v;
            prefix = flag_prefix;
          }
        }else{
          if( bArgList ){
            longvalue = (u64)getIntArg(pArgList);
          }else if( flag_long ){
            if( flag_long==2 ){
              longvalue = va_arg(ap,u64);
            }else{
              longvalue = va_arg(ap,unsigned long int);
            }
          }else{
            longvalue = va_arg(ap,unsigned int);
          }
          prefix = 0;
        }
        if( longvalue==0 ) flag_alternateform = 0;
        if( flag_zeropad && precision<width-(prefix!=0) ){
          precision = width-(prefix!=0);
        }
        if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
          nOut = etBUFSIZE;
          zOut = buf;
        }else{
          u64 n;
          n = (u64)precision + 10;
          if( cThousand ) n += precision/3;
          zOut = zExtra = printfTempBuf(pAccum, n);
          if( zOut==0 ) return;
          nOut = (int)n;
        }
        bufpt = &zOut[nOut-1];
        if( xtype==etORDINAL ){
          static const char zOrd[] = "thstndrd";
          int x = (int)(longvalue % 10);
          if( x>=4 || (longvalue/10)%10==1 ){
            x = 0;
          }
          *(--bufpt) = zOrd[x*2+1];
          *(--bufpt) = zOrd[x*2];
        }
        {
          const char *cset = &aDigits[infop->charset];
          u8 base = infop->base;
          do{                                           /* Convert to ascii */
            *(--bufpt) = cset[longvalue%base];
            longvalue = longvalue/base;
          }while( longvalue>0 );
        }
        length = (int)(&zOut[nOut-1]-bufpt);
        while( precision>length ){
          *(--bufpt) = '0';                             /* Zero pad */
          length++;
        }
        if( cThousand ){
          int nn = (length - 1)/3;  /* Number of "," to insert */
          int ix = (length - 1)%3 + 1;
          bufpt -= nn;
          for(idx=0; nn>0; idx++){
            bufpt[idx] = bufpt[idx+nn];
            ix--;
            if( ix==0 ){
              bufpt[++idx] = cThousand;
              nn--;
              ix = 3;
            }
          }
        }
        if( prefix ) *(--bufpt) = prefix;               /* Add sign */
        if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
          const char *pre;
          char x;
          pre = &aPrefix[infop->prefix];
          for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
        }
        length = (int)(&zOut[nOut-1]-bufpt);
        break;
      case etFLOAT:
      case etEXP:
      case etGENERIC:
        if( bArgList ){
          realvalue = getDoubleArg(pArgList);
        }else{
          realvalue = va_arg(ap,double);
        }
#ifdef SQLITE_OMIT_FLOATING_POINT
        length = 0;
#else
        if( precision<0 ) precision = 6;         /* Set default precision */
#ifdef SQLITE_FP_PRECISION_LIMIT
        if( precision>SQLITE_FP_PRECISION_LIMIT ){
          precision = SQLITE_FP_PRECISION_LIMIT;
        }
#endif
        if( realvalue<0.0 ){
          realvalue = -realvalue;
          prefix = '-';
        }else{
          prefix = flag_prefix;
        }
        if( xtype==etGENERIC && precision>0 ) precision--;
        testcase( precision>0xfff );
        idx = precision & 0xfff;
        rounder = arRound[idx%10];
        while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; }
        if( xtype==etFLOAT ){
          double rx = (double)realvalue;
          sqlite3_uint64 u;
          int ex;
          memcpy(&u, &rx, sizeof(u));
          ex = -1023 + (int)((u>>52)&0x7ff);
          if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16;
          realvalue += rounder;
        }
        /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
        exp = 0;
        if( sqlite3IsNaN((double)realvalue) ){
          bufpt = "NaN";
          length = 3;
          break;
        }
        if( realvalue>0.0 ){
          LONGDOUBLE_TYPE scale = 1.0;
          while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;}
          while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; }
          while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; }
          realvalue /= scale;
          while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
          while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
          if( exp>350 ){
            bufpt = buf;
            buf[0] = prefix;
            memcpy(buf+(prefix!=0),"Inf",4);
            length = 3+(prefix!=0);
            break;
          }
        }
        bufpt = buf;
        /*
        ** If the field type is etGENERIC, then convert to either etEXP
        ** or etFLOAT, as appropriate.
        */
        if( xtype!=etFLOAT ){
          realvalue += rounder;
          if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
        }
        if( xtype==etGENERIC ){
          flag_rtz = !flag_alternateform;
          if( exp<-4 || exp>precision ){
            xtype = etEXP;
          }else{
            precision = precision - exp;
            xtype = etFLOAT;
          }
        }else{
          flag_rtz = flag_altform2;
        }
        if( xtype==etEXP ){
          e2 = 0;
        }else{
          e2 = exp;
        }
        {
          i64 szBufNeeded;           /* Size of a temporary buffer needed */
          szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15;
          if( szBufNeeded > etBUFSIZE ){
            bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded);
            if( bufpt==0 ) return;
          }
        }
        zOut = bufpt;
        nsd = 16 + flag_altform2*10;
        flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
        /* The sign in front of the number */
        if( prefix ){
          *(bufpt++) = prefix;
        }
        /* Digits prior to the decimal point */
        if( e2<0 ){
          *(bufpt++) = '0';
        }else{
          for(; e2>=0; e2--){
            *(bufpt++) = et_getdigit(&realvalue,&nsd);
          }
        }
        /* The decimal point */
        if( flag_dp ){
          *(bufpt++) = '.';
        }
        /* "0" digits after the decimal point but before the first
        ** significant digit of the number */
        for(e2++; e2<0; precision--, e2++){
          assert( precision>0 );
          *(bufpt++) = '0';
        }
        /* Significant digits after the decimal point */
        while( (precision--)>0 ){
          *(bufpt++) = et_getdigit(&realvalue,&nsd);
        }
        /* Remove trailing zeros and the "." if no digits follow the "." */
        if( flag_rtz && flag_dp ){
          while( bufpt[-1]=='0' ) *(--bufpt) = 0;
          assert( bufpt>zOut );
          if( bufpt[-1]=='.' ){
            if( flag_altform2 ){
              *(bufpt++) = '0';
            }else{
              *(--bufpt) = 0;
            }
          }
        }
        /* Add the "eNNN" suffix */
        if( xtype==etEXP ){
          *(bufpt++) = aDigits[infop->charset];
          if( exp<0 ){
            *(bufpt++) = '-'; exp = -exp;
          }else{
            *(bufpt++) = '+';
          }
          if( exp>=100 ){
            *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
            exp %= 100;
          }
          *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
          *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
        }
        *bufpt = 0;
 
        /* The converted number is in buf[] and zero terminated. Output it.
        ** Note that the number is in the usual order, not reversed as with
        ** integer conversions. */
        length = (int)(bufpt-zOut);
        bufpt = zOut;
 
        /* Special case:  Add leading zeros if the flag_zeropad flag is
        ** set and we are not left justified */
        if( flag_zeropad && !flag_leftjustify && length < width){
          int i;
          int nPad = width - length;
          for(i=width; i>=nPad; i--){
            bufpt[i] = bufpt[i-nPad];
          }
          i = prefix!=0;
          while( nPad-- ) bufpt[i++] = '0';
          length = width;
        }
#endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
        break;
      case etSIZE:
        if( !bArgList ){
          *(va_arg(ap,int*)) = pAccum->nChar;
        }
        length = width = 0;
        break;
      case etPERCENT:
        buf[0] = '%';
        bufpt = buf;
        length = 1;
        break;
      case etCHARX:
        if( bArgList ){
          bufpt = getTextArg(pArgList);
          length = 1;
          if( bufpt ){
            buf[0] = c = *(bufpt++);
            if( (c&0xc0)==0xc0 ){
              while( length<4 && (bufpt[0]&0xc0)==0x80 ){
                buf[length++] = *(bufpt++);
              }
            }
          }else{
            buf[0] = 0;
          }
        }else{
          unsigned int ch = va_arg(ap,unsigned int);
          if( ch<0x00080 ){
            buf[0] = ch & 0xff;
            length = 1;
          }else if( ch<0x00800 ){
            buf[0] = 0xc0 + (u8)((ch>>6)&0x1f);
            buf[1] = 0x80 + (u8)(ch & 0x3f);
            length = 2;
          }else if( ch<0x10000 ){
            buf[0] = 0xe0 + (u8)((ch>>12)&0x0f);
            buf[1] = 0x80 + (u8)((ch>>6) & 0x3f);
            buf[2] = 0x80 + (u8)(ch & 0x3f);
            length = 3;
          }else{
            buf[0] = 0xf0 + (u8)((ch>>18) & 0x07);
            buf[1] = 0x80 + (u8)((ch>>12) & 0x3f);
            buf[2] = 0x80 + (u8)((ch>>6) & 0x3f);
            buf[3] = 0x80 + (u8)(ch & 0x3f);
            length = 4;
          }
        }
        if( precision>1 ){
          width -= precision-1;
          if( width>1 && !flag_leftjustify ){
            sqlite3_str_appendchar(pAccum, width-1, ' ');
            width = 0;
          }
          while( precision-- > 1 ){
            sqlite3_str_append(pAccum, buf, length);
          }
        }
        bufpt = buf;
        flag_altform2 = 1;
        goto adjust_width_for_utf8;
      case etSTRING:
      case etDYNSTRING:
        if( bArgList ){
          bufpt = getTextArg(pArgList);
          xtype = etSTRING;
        }else{
          bufpt = va_arg(ap,char*);
        }
        if( bufpt==0 ){
          bufpt = "";
        }else if( xtype==etDYNSTRING ){
          if( pAccum->nChar==0
           && pAccum->mxAlloc
           && width==0
           && precision<0
           && pAccum->accError==0
          ){
            /* Special optimization for sqlite3_mprintf("%z..."):
            ** Extend an existing memory allocation rather than creating
            ** a new one. */
            assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
            pAccum->zText = bufpt;
            pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt);
            pAccum->nChar = 0x7fffffff & (int)strlen(bufpt);
            pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED;
            length = 0;
            break;
          }
          zExtra = bufpt;
        }
        if( precision>=0 ){
          if( flag_altform2 ){
            /* Set length to the number of bytes needed in order to display
            ** precision characters */
            unsigned char *z = (unsigned char*)bufpt;
            while( precision-- > 0 && z[0] ){
              SQLITE_SKIP_UTF8(z);
            }
            length = (int)(z - (unsigned char*)bufpt);
          }else{
            for(length=0; length<precision && bufpt[length]; length++){}
          }
        }else{
          length = 0x7fffffff & (int)strlen(bufpt);
        }
      adjust_width_for_utf8:
        if( flag_altform2 && width>0 ){
          /* Adjust width to account for extra bytes in UTF-8 characters */
          int ii = length - 1;
          while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++;
        }
        break;
      case etSQLESCAPE:           /* %q: Escape ' characters */
      case etSQLESCAPE2:          /* %Q: Escape ' and enclose in '...' */
      case etSQLESCAPE3: {        /* %w: Escape " characters */
        int i, j, k, n, isnull;
        int needQuote;
        char ch;
        char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
        char *escarg;
 
        if( bArgList ){
          escarg = getTextArg(pArgList);
        }else{
          escarg = va_arg(ap,char*);
        }
        isnull = escarg==0;
        if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
        /* For %q, %Q, and %w, the precision is the number of bytes (or
        ** characters if the ! flags is present) to use from the input.
        ** Because of the extra quoting characters inserted, the number
        ** of output characters may be larger than the precision.
        */
        k = precision;
        for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
          if( ch==q )  n++;
          if( flag_altform2 && (ch&0xc0)==0xc0 ){
            while( (escarg[i+1]&0xc0)==0x80 ){ i++; }
          }
        }
        needQuote = !isnull && xtype==etSQLESCAPE2;
        n += i + 3;
        if( n>etBUFSIZE ){
          bufpt = zExtra = printfTempBuf(pAccum, n);
          if( bufpt==0 ) return;
        }else{
          bufpt = buf;
        }
        j = 0;
        if( needQuote ) bufpt[j++] = q;
        k = i;
        for(i=0; i<k; i++){
          bufpt[j++] = ch = escarg[i];
          if( ch==q ) bufpt[j++] = ch;
        }
        if( needQuote ) bufpt[j++] = q;
        bufpt[j] = 0;
        length = j;
        goto adjust_width_for_utf8;
      }
      case etTOKEN: {
        Token *pToken;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        pToken = va_arg(ap, Token*);
        assert( bArgList==0 );
        if( pToken && pToken->n ){
          sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
        }
        length = width = 0;
        break;
      }
      case etSRCLIST: {
        SrcList *pSrc;
        int k;
        struct SrcList_item *pItem;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        pSrc = va_arg(ap, SrcList*);
        k = va_arg(ap, int);
        pItem = &pSrc->a[k];
        assert( bArgList==0 );
        assert( k>=0 && k<pSrc->nSrc );
        if( pItem->zDatabase ){
          sqlite3_str_appendall(pAccum, pItem->zDatabase);
          sqlite3_str_append(pAccum, ".", 1);
        }
        sqlite3_str_appendall(pAccum, pItem->zName);
        length = width = 0;
        break;
      }
      default: {
        assert( xtype==etINVALID );
        return;
      }
    }/* End switch over the format type */
    /*
    ** The text of the conversion is pointed to by "bufpt" and is
    ** "length" characters long.  The field width is "width".  Do
    ** the output.  Both length and width are in bytes, not characters,
    ** at this point.  If the "!" flag was present on string conversions
    ** indicating that width and precision should be expressed in characters,
    ** then the values have been translated prior to reaching this point.
    */
    width -= length;
    if( width>0 ){
      if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
      sqlite3_str_append(pAccum, bufpt, length);
      if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
    }else{
      sqlite3_str_append(pAccum, bufpt, length);
    }
 

References SrcList::a, sqlite3_str::accError, aDigits, aPrefix, ArraySize, arRound, et_info::base, et_info::charset, sqlite3_str::db, deliberate_fall_through, et_getdigit(), etBUFSIZE, etCHARX, etDECIMAL, etDYNSTRING, etEXP, etFLOAT, etGENERIC, etINVALID, etORDINAL, etPERCENT, etPOINTER, etRADIX, etSIZE, etSQLESCAPE, etSQLESCAPE2, etSQLESCAPE3, etSRCLIST, etSTRING, etTOKEN, FLAG_SIGNED, et_info::flags, fmtinfo, getDoubleArg(), getIntArg(), getTextArg(), LONGDOUBLE_TYPE, MAX, sqlite3_str::mxAlloc, Token::n, sqlite3_str::nAlloc, sqlite3_str::nChar, et_info::prefix, sqlite3_str::printfFlags, printfTempBuf(), SMALLEST_INT64, sqlite3_str_append(), sqlite3_str_appendall(), sqlite3_str_appendchar(), sqlite3DbFree(), sqlite3DbMallocSize(), sqlite3IsNaN(), SQLITE_FP_PRECISION_LIMIT, SQLITE_PRINTF_INTERNAL, SQLITE_PRINTF_MALLOCED, SQLITE_PRINTF_SQLFUNC, SQLITE_SKIP_UTF8, testcase, et_info::type, Token::z, and sqlite3_str::zText.

Referenced by renderLogMsg(), and sqlite3_str_appendf().

◆ sqlite3_strglob()

SQLITE_API int sqlite3_strglob	(	const char *	zGlob,
		const char *	zStr )

Definition at line 117856 of file sqlite3.c.

Referenced by decodeIntArray().

◆ sqlite3_stricmp()

SQLITE_API int sqlite3_stricmp	(	const char *	zLeft,
		const char *	zRight )

Definition at line 31460 of file sqlite3.c.

                    : R-30243-02494 The sqlite3_stricmp() and
** sqlite3_strnicmp() APIs allow applications and extensions to compare
** the contents of two buffers containing UTF-8 strings in a
** case-independent fashion, using the same definition of "case
** independence" that SQLite uses internally when comparing identifiers.
*/
SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
  if( zLeft==0 ){

Referenced by analysisLoader(), isSelfJoinView(), lookupName(), parseModifier(), renameColumnElistNames(), renameColumnFunc(), renameColumnIdlistNames(), renameTableFunc(), resolveAsName(), sqlite3AddColumn(), sqlite3CheckObjectName(), sqlite3ExprCompare(), sqlite3FindDbName(), sqlite3FkCheck(), sqlite3FkRequired(), sqlite3GenerateRowDelete(), sqlite3Pragma(), sqlite3Select(), xferCompatibleIndex(), and xferOptimization().

◆ sqlite3_strlike()

SQLITE_API int sqlite3_strlike	(	const char *	zGlob,
		const char *	zStr,
		unsigned int	cEsc )

Definition at line 117864 of file sqlite3.c.

Referenced by analyzeOneTable(), and sqlite3VdbeExec().

◆ sqlite3_strnicmp()

SQLITE_API int sqlite3_strnicmp	(	const char *	zLeft,
		const char *	zRight,
		int	N )

Definition at line 31487 of file sqlite3.c.

                                                                             {
  register unsigned char *a, *b;
  if( zLeft==0 ){
    return zRight ? -1 : 0;
  }else if( zRight==0 ){
    return 1;

Referenced by codeInteger(), execSql(), parseModifier(), sqlite3InitCallback(), sqlite3IsShadowTableOf(), sqlite3LoadExtension(), sqlite3LocateTable(), sqlite3PragmaVtabRegister(), and yy_reduce().

◆ sqlite3_system_errno()

SQLITE_API int sqlite3_system_errno ( sqlite3 * db )

Definition at line 163571 of file sqlite3.c.

163572 {

163573 return SQLITE_NOMEM_BKPT;

◆ sqlite3_table_column_metadata()

SQLITE_API int sqlite3_table_column_metadata	(	sqlite3 *	db,
		const char *	zDbName,
		const char *	zTableName,
		const char *	zColumnName,
		char const **	pzDataType,
		char const **	pzCollSeq,
		int *	pNotNull,
		int *	pPrimaryKey,
		int *	pAutoinc )

Definition at line 164634 of file sqlite3.c.

 {
  int rc;
  char *zErrMsg = 0;
  Table *pTab = 0;
  Column *pCol = 0;
  int iCol = 0;
  char const *zDataType = 0;
  char const *zCollSeq = 0;
  int notnull = 0;
  int primarykey = 0;
  int autoinc = 0;
 
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
 
  /* Ensure the database schema has been loaded */
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  rc = sqlite3Init(db, &zErrMsg);
  if( SQLITE_OK!=rc ){
    goto error_out;
  }
 
  /* Locate the table in question */
  pTab = sqlite3FindTable(db, zTableName, zDbName);
  if( !pTab || pTab->pSelect ){
    pTab = 0;
    goto error_out;
  }
 
  /* Find the column for which info is requested */
  if( zColumnName==0 ){
    /* Query for existance of table only */
  }else{
    for(iCol=0; iCol<pTab->nCol; iCol++){
      pCol = &pTab->aCol[iCol];
      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
        break;
      }
    }
    if( iCol==pTab->nCol ){
      if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
        iCol = pTab->iPKey;
        pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
      }else{
        pTab = 0;
        goto error_out;
      }
    }
  }
 
  /* The following block stores the meta information that will be returned
  ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
  ** and autoinc. At this point there are two possibilities:
  **
  **     1. The specified column name was rowid", "oid" or "_rowid_"
  **        and there is no explicitly declared IPK column.
  **
  **     2. The table is not a view and the column name identified an
  **        explicitly declared column. Copy meta information from *pCol.
  */
  if( pCol ){
    zDataType = sqlite3ColumnType(pCol,0);
    zCollSeq = pCol->zColl;
    notnull = pCol->notNull!=0;
    primarykey  = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
    autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
  }else{
    zDataType = "INTEGER";
    primarykey = 1;
  }
  if( !zCollSeq ){
    zCollSeq = sqlite3StrBINARY;
  }
 
error_out:
  sqlite3BtreeLeaveAll(db);
 
  /* Whether the function call succeeded or failed, set the output parameters
  ** to whatever their local counterparts contain. If an error did occur,
  ** this has the effect of zeroing all output parameters.
  */
  if( pzDataType ) *pzDataType = zDataType;
  if( pzCollSeq ) *pzCollSeq = zCollSeq;
  if( pNotNull ) *pNotNull = notnull;
  if( pPrimaryKey ) *pPrimaryKey = primarykey;
  if( pAutoinc ) *pAutoinc = autoinc;
 
  if( SQLITE_OK==rc && !pTab ){
    sqlite3DbFree(db, zErrMsg);
    zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
        zColumnName);
    rc = SQLITE_ERROR;
  }

References Table::aCol, COLFLAG_PRIMKEY, Column::colFlags, HasRowid, Table::iPKey, sqlite3::mutex, Table::nCol, Column::notNull, Table::pSelect, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3ColumnType(), sqlite3DbFree(), sqlite3ErrorWithMsg(), sqlite3FindTable(), sqlite3Init(), sqlite3IsRowid(), sqlite3MPrintf(), sqlite3SafetyCheckOk(), sqlite3StrBINARY, sqlite3StrICmp(), SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_OK, Table::tabFlags, TF_Autoincrement, Column::zColl, and Column::zName.

◆ sqlite3_test_control()

SQLITE_API int sqlite3_test_control	(	int	op,
			... )

Definition at line 164829 of file sqlite3.c.

                                                {
  int rc = 0;
#ifdef SQLITE_UNTESTABLE
  UNUSED_PARAMETER(op);
#else
  va_list ap;
  va_start(ap, op);
  switch( op ){
 
    /*
    ** Save the current state of the PRNG.
    */
    case SQLITE_TESTCTRL_PRNG_SAVE: {
      sqlite3PrngSaveState();
      break;
    }
 
    /*
    ** Restore the state of the PRNG to the last state saved using
    ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
    ** this verb acts like PRNG_RESET.
    */
    case SQLITE_TESTCTRL_PRNG_RESTORE: {
      sqlite3PrngRestoreState();
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db);
    **
    ** Control the seed for the pseudo-random number generator (PRNG) that
    ** is built into SQLite.  Cases:
    **
    **    x!=0 && db!=0       Seed the PRNG to the current value of the
    **                        schema cookie in the main database for db, or
    **                        x if the schema cookie is zero.  This case
    **                        is convenient to use with database fuzzers
    **                        as it allows the fuzzer some control over the
    **                        the PRNG seed.
    **
    **    x!=0 && db==0       Seed the PRNG to the value of x.
    **
    **    x==0 && db==0       Revert to default behavior of using the
    **                        xRandomness method on the primary VFS.
    **
    ** This test-control also resets the PRNG so that the new seed will
    ** be used for the next call to sqlite3_randomness().
    */
#ifndef SQLITE_OMIT_WSD
    case SQLITE_TESTCTRL_PRNG_SEED: {
      int x = va_arg(ap, int);
      int y;
      sqlite3 *db = va_arg(ap, sqlite3*);
      assert( db==0 || db->aDb[0].pSchema!=0 );
      if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; }
      sqlite3Config.iPrngSeed = x;
      sqlite3_randomness(0,0);
      break;
    }
#endif
 
    /*
    **  sqlite3_test_control(BITVEC_TEST, size, program)
    **
    ** Run a test against a Bitvec object of size.  The program argument
    ** is an array of integers that defines the test.  Return -1 on a
    ** memory allocation error, 0 on success, or non-zero for an error.
    ** See the sqlite3BitvecBuiltinTest() for additional information.
    */
    case SQLITE_TESTCTRL_BITVEC_TEST: {
      int sz = va_arg(ap, int);
      int *aProg = va_arg(ap, int*);
      rc = sqlite3BitvecBuiltinTest(sz, aProg);
      break;
    }
 
    /*
    **  sqlite3_test_control(FAULT_INSTALL, xCallback)
    **
    ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
    ** if xCallback is not NULL.
    **
    ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
    ** is called immediately after installing the new callback and the return
    ** value from sqlite3FaultSim(0) becomes the return from
    ** sqlite3_test_control().
    */
    case SQLITE_TESTCTRL_FAULT_INSTALL: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
      */
      typedef int(*TESTCALLBACKFUNC_t)(int);
      sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
      rc = sqlite3FaultSim(0);
      break;
    }
 
    /*
    **  sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
    **
    ** Register hooks to call to indicate which malloc() failures
    ** are benign.
    */
    case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
      typedef void (*void_function)(void);
      void_function xBenignBegin;
      void_function xBenignEnd;
      xBenignBegin = va_arg(ap, void_function);
      xBenignEnd = va_arg(ap, void_function);
      sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
      break;
    }
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
    **
    ** Set the PENDING byte to the value in the argument, if X>0.
    ** Make no changes if X==0.  Return the value of the pending byte
    ** as it existing before this routine was called.
    **
    ** IMPORTANT:  Changing the PENDING byte from 0x40000000 results in
    ** an incompatible database file format.  Changing the PENDING byte
    ** while any database connection is open results in undefined and
    ** deleterious behavior.
    */
    case SQLITE_TESTCTRL_PENDING_BYTE: {
      rc = PENDING_BYTE;
#ifndef SQLITE_OMIT_WSD
      {
        unsigned int newVal = va_arg(ap, unsigned int);
        if( newVal ) sqlite3PendingByte = newVal;
      }
#endif
      break;
    }
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
    **
    ** This action provides a run-time test to see whether or not
    ** assert() was enabled at compile-time.  If X is true and assert()
    ** is enabled, then the return value is true.  If X is true and
    ** assert() is disabled, then the return value is zero.  If X is
    ** false and assert() is enabled, then the assertion fires and the
    ** process aborts.  If X is false and assert() is disabled, then the
    ** return value is zero.
    */
    case SQLITE_TESTCTRL_ASSERT: {
      volatile int x = 0;
      assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
      rc = x;
      break;
    }
 
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
    **
    ** This action provides a run-time test to see how the ALWAYS and
    ** NEVER macros were defined at compile-time.
    **
    ** The return value is ALWAYS(X) if X is true, or 0 if X is false.
    **
    ** The recommended test is X==2.  If the return value is 2, that means
    ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
    ** default setting.  If the return value is 1, then ALWAYS() is either
    ** hard-coded to true or else it asserts if its argument is false.
    ** The first behavior (hard-coded to true) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
    ** behavior (assert if the argument to ALWAYS() is false) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
    **
    ** The run-time test procedure might look something like this:
    **
    **    if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
    **      // ALWAYS() and NEVER() are no-op pass-through macros
    **    }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
    **      // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
    **    }else{
    **      // ALWAYS(x) is a constant 1.  NEVER(x) is a constant 0.
    **    }
    */
    case SQLITE_TESTCTRL_ALWAYS: {
      int x = va_arg(ap,int);
      rc = x ? ALWAYS(x) : 0;
      break;
    }
 
    /*
    **   sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
    **
    ** The integer returned reveals the byte-order of the computer on which
    ** SQLite is running:
    **
    **       1     big-endian,    determined at run-time
    **      10     little-endian, determined at run-time
    **  432101     big-endian,    determined at compile-time
    **  123410     little-endian, determined at compile-time
    */
    case SQLITE_TESTCTRL_BYTEORDER: {
      rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
    **
    ** Enable or disable various optimizations for testing purposes.  The
    ** argument N is a bitmask of optimizations to be disabled.  For normal
    ** operation N should be 0.  The idea is that a test program (like the
    ** SQL Logic Test or SLT test module) can run the same SQL multiple times
    ** with various optimizations disabled to verify that the same answer
    ** is obtained in every case.
    */
    case SQLITE_TESTCTRL_OPTIMIZATIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, subsequent calls to localtime()
    ** and its variants fail. If onoff is zero, undo this setting.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, sqlite3*);
    **
    ** Toggle the ability to use internal functions on or off for
    ** the database connection given in the argument.
    */
    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->mDbFlags ^= DBFLAG_InternalFunc;
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
    **
    ** Set or clear a flag that indicates that the database file is always well-
    ** formed and never corrupt.  This flag is clear by default, indicating that
    ** database files might have arbitrary corruption.  Setting the flag during
    ** testing causes certain assert() statements in the code to be activated
    ** that demonstrat invariants on well-formed database files.
    */
    case SQLITE_TESTCTRL_NEVER_CORRUPT: {
      sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, int);
    **
    ** Set or clear a flag that causes SQLite to verify that type, name,
    ** and tbl_name fields of the sqlite_schema table.  This is normally
    ** on, but it is sometimes useful to turn it off for testing.
    **
    ** 2020-07-22:  Disabling EXTRA_SCHEMA_CHECKS also disables the
    ** verification of rootpage numbers when parsing the schema.  This
    ** is useful to make it easier to reach strange internal error states
    ** during testing.  The EXTRA_SCHEMA_CHECKS setting is always enabled
    ** in production.
    */
    case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: {
      sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int);
      break;
    }
 
    /* Set the threshold at which OP_Once counters reset back to zero.
    ** By default this is 0x7ffffffe (over 2 billion), but that value is
    ** too big to test in a reasonable amount of time, so this control is
    ** provided to set a small and easily reachable reset value.
    */
    case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: {
      sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
    **
    ** Set the VDBE coverage callback function to xCallback with context
    ** pointer ptr.
    */
    case SQLITE_TESTCTRL_VDBE_COVERAGE: {
#ifdef SQLITE_VDBE_COVERAGE
      typedef void (*branch_callback)(void*,unsigned int,
                                      unsigned char,unsigned char);
      sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
      sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
#endif
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
    case SQLITE_TESTCTRL_SORTER_MMAP: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->nMaxSorterMmap = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
    **
    ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
    ** not.
    */
    case SQLITE_TESTCTRL_ISINIT: {
      if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
    **
    ** This test control is used to create imposter tables.  "db" is a pointer
    ** to the database connection.  dbName is the database name (ex: "main" or
    ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
    ** or off.  "tnum" is the root page of the b-tree to which the imposter
    ** table should connect.
    **
    ** Enable imposter mode only when the schema has already been parsed.  Then
    ** run a single CREATE TABLE statement to construct the imposter table in
    ** the parsed schema.  Then turn imposter mode back off again.
    **
    ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
    ** the schema to be reparsed the next time it is needed.  This has the
    ** effect of erasing all imposter tables.
    */
    case SQLITE_TESTCTRL_IMPOSTER: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      sqlite3_mutex_enter(db->mutex);
      db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
      db->init.busy = db->init.imposterTable = va_arg(ap,int);
      db->init.newTnum = va_arg(ap,int);
      if( db->init.busy==0 && db->init.newTnum>0 ){
        sqlite3ResetAllSchemasOfConnection(db);
      }
      sqlite3_mutex_leave(db->mutex);
      break;
    }
 
#if defined(YYCOVERAGE)
    /*  sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
    **
    ** This test control (only available when SQLite is compiled with
    ** -DYYCOVERAGE) writes a report onto "out" that shows all
    ** state/lookahead combinations in the parser state machine
    ** which are never exercised.  If any state is missed, make the
    ** return code SQLITE_ERROR.
    */
    case SQLITE_TESTCTRL_PARSER_COVERAGE: {
      FILE *out = va_arg(ap, FILE*);
      if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR;
      break;
    }
#endif /* defined(YYCOVERAGE) */
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*);
    **
    ** This test-control causes the most recent sqlite3_result_int64() value
    ** to be interpreted as a MEM_IntReal instead of as an MEM_Int.  Normally,
    ** MEM_IntReal values only arise during an INSERT operation of integer
    ** values into a REAL column, so they can be challenging to test.  This
    ** test-control enables us to write an intreal() SQL function that can
    ** inject an intreal() value at arbitrary places in an SQL statement,
    ** for testing purposes.
    */
    case SQLITE_TESTCTRL_RESULT_INTREAL: {
      sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
      sqlite3ResultIntReal(pCtx);
      break;

◆ sqlite3_thread_cleanup()

SQLITE_API void sqlite3_thread_cleanup ( void )

Definition at line 164626 of file sqlite3.c.

◆ sqlite3_threadsafe()

SQLITE_API int sqlite3_threadsafe ( void )

Definition at line 161123 of file sqlite3.c.

161123{ return SQLITE_VERSION_NUMBER; }

SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER

Definition sqlite3.c:1175

References SQLITE_VERSION_NUMBER.

◆ sqlite3_total_changes()

SQLITE_API int sqlite3_total_changes ( sqlite3 * db )

Definition at line 162095 of file sqlite3.c.

                                                 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by db_total_changes().

◆ sqlite3_trace()

SQLITE_API void * sqlite3_trace	(	sqlite3 *	db,
		void()(void , const char *)	xTrace,
		void *	pArg )

Definition at line 163075 of file sqlite3.c.

                                                                                         {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pTraceArg;

References sqlite3::mTrace, sqlite3::mutex, sqlite3::pTraceArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_TRACE_LEGACY, sqlite3::trace, and sqlite3::xLegacy.

Referenced by db_trace().

◆ sqlite3_trace_v2()

SQLITE_API int sqlite3_trace_v2	(	sqlite3 *	db,
		unsigned	uMask,
		int()(unsigned, void , void , void )	xCallback,
		void *	pCtx )

Definition at line 163096 of file sqlite3.c.

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( mTrace==0 ) xTrace = 0;
  if( xTrace==0 ) mTrace = 0;

◆ sqlite3_transfer_bindings()

SQLITE_API int sqlite3_transfer_bindings	(	sqlite3_stmt *	pFromStmt,
		sqlite3_stmt *	pToStmt )

Definition at line 84622 of file sqlite3.c.

                                                                                        {
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  if( pFrom->nVar!=pTo->nVar ){
    return SQLITE_ERROR;
  }
  assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
  if( pTo->expmask ){
    pTo->expired = 1;
  }

References Vdbe::expired, Vdbe::expmask, Vdbe::nVar, Vdbe::prepFlags, sqlite3TransferBindings(), SQLITE_ERROR, and SQLITE_PREPARE_SAVESQL.

◆ sqlite3_unlock_notify()

SQLITE_API int sqlite3_unlock_notify	(	sqlite3 *	pBlocked,
		void()(void *apArg, int nArg)	xNotify,
		void *	pNotifyArg )

◆ sqlite3_update_hook()

SQLITE_API void * sqlite3_update_hook	(	sqlite3 *	db,
		void()(void , int,char const , char const , sqlite3_int64)	xCallback,
		void *	pArg )

Definition at line 163181 of file sqlite3.c.

 {
  void *pRet;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);

Referenced by db_update_hook().

◆ sqlite3_uri_boolean()

SQLITE_API int sqlite3_uri_boolean	(	const char *	zFile,
		const char *	zParam,
		int	bDefault )

Definition at line 165318 of file sqlite3.c.

                                  : 0;
}
 
/*
** Return a boolean value for a query parameter.

Referenced by sqlite3PagerOpen(), and unixOpenSharedMemory().

◆ sqlite3_uri_int64()

SQLITE_API sqlite3_int64 sqlite3_uri_int64	(	const char *	zFilename,
		const char *	zParam,
		sqlite3_int64	bDflt )

Definition at line 165327 of file sqlite3.c.

                                         : bDflt;
}
 
/*
** Return a 64-bit integer value for a query parameter.
*/
SQLITE_API sqlite3_int64 sqlite3_uri_int64(
  const char *zFilename,    /* Filename as passed to xOpen */
  const char *zParam,       /* URI parameter sought */
  sqlite3_int64 bDflt       /* return if parameter is missing */
){
  const char *z = sqlite3_uri_parameter(zFilename, zParam);

◆ sqlite3_uri_key()

SQLITE_API const char * sqlite3_uri_key	(	const char *	zFilename,
		int	N )

Definition at line 165304 of file sqlite3.c.

                                                                    {
  if( zFilename==0 || N<0 ) return 0;
  zFilename = databaseName(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;

◆ sqlite3_uri_parameter()

SQLITE_API const char * sqlite3_uri_parameter	(	const char *	zFilename,
		const char *	zParam )

Definition at line 165295 of file sqlite3.c.

References databaseName().

Referenced by findCreateFileMode().

◆ sqlite3_user_data()

SQLITE_API void * sqlite3_user_data ( sqlite3_context * p )

Definition at line 83779 of file sqlite3.c.

References sqlite3_context::pFunc, and FuncDef::pUserData.

Referenced by db_sql_finalize_function(), db_sql_normal_function(), lcontext_check_aggregate(), lcontext_user_data(), likeFunc(), minmaxStep(), and sqlite3InvalidFunction().

◆ sqlite3_value_blob()

SQLITE_API const void * sqlite3_value_blob ( sqlite3_value * pVal )

Definition at line 83153 of file sqlite3.c.

                                                              {
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(p)!=SQLITE_OK ){
      assert( p->flags==MEM_Null && p->z==0 );
      return 0;
    }

References ExpandBlob, sqlite3_value::flags, MEM_Blob, MEM_Null, MEM_Str, SQLITE_OK, and sqlite3_value::z.

Referenced by db_push_value(), instrFunc(), quoteFunc(), statGet(), statPush(), and substrFunc().

◆ sqlite3_value_bytes()

SQLITE_API int sqlite3_value_bytes ( sqlite3_value * pVal )

Definition at line 83166 of file sqlite3.c.

83167 : 0;

83168 }else{

Referenced by db_push_value(), instrFunc(), isDate(), likeFunc(), quoteFunc(), replaceFunc(), statPush(), and substrFunc().

◆ sqlite3_value_bytes16()

SQLITE_API int sqlite3_value_bytes16 ( sqlite3_value * pVal )

Definition at line 83169 of file sqlite3.c.

◆ sqlite3_value_double()

SQLITE_API double sqlite3_value_double ( sqlite3_value * pVal )

Definition at line 83172 of file sqlite3.c.

                                                       {
  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
}

References sqlite3ValueBytes(), and SQLITE_UTF8.

Referenced by absFunc(), db_push_value(), isDate(), and quoteFunc().

◆ sqlite3_value_dup()

SQLITE_API sqlite3_value * sqlite3_value_dup ( const sqlite3_value * pOrig )

Definition at line 83313 of file sqlite3.c.

                                                          {
  return (pVal->flags&MEM_FromBind)!=0;
}
 
/* Make a copy of an sqlite3_value object
*/
SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
  sqlite3_value *pNew;
  if( pOrig==0 ) return 0;
  pNew = sqlite3_malloc( sizeof(*pNew) );
  if( pNew==0 ) return 0;
  memset(pNew, 0, sizeof(*pNew));
  memcpy(pNew, pOrig, MEMCELLSIZE);
  pNew->flags &= ~MEM_Dyn;
  pNew->db = 0;
  if( pNew->flags&(MEM_Str|MEM_Blob) ){
    pNew->flags &= ~(MEM_Static|MEM_Dyn);
    pNew->flags |= MEM_Ephem;
    if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){

References sqlite3_value::flags, and MEM_FromBind.

Referenced by instrFunc().

◆ sqlite3_value_free()

SQLITE_API void sqlite3_value_free ( sqlite3_value * pOld )

Definition at line 83336 of file sqlite3.c.

Referenced by instrFunc(), and last_valueValueFunc().

◆ sqlite3_value_frombind()

SQLITE_API int sqlite3_value_frombind ( sqlite3_value * pVal )

Definition at line 83307 of file sqlite3.c.

83308 {

83309 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);

References sqlite3_value::flags, MEM_Null, and MEM_Zero.

◆ sqlite3_value_int()

SQLITE_API int sqlite3_value_int ( sqlite3_value * pVal )

Definition at line 83175 of file sqlite3.c.

                                                         {
  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueBytes(), and SQLITE_UTF16NATIVE.

Referenced by compileoptiongetFunc(), errlogFunc(), renameColumnFunc(), renameTableFunc(), renameTableTest(), statGet(), statInit(), statPush(), substrFunc(), and windowExprGtZero().

◆ sqlite3_value_int64()

SQLITE_API sqlite_int64 sqlite3_value_int64 ( sqlite3_value * pVal )

Definition at line 83178 of file sqlite3.c.

                                                           {
  return sqlite3VdbeRealValue((Mem*)pVal);
}

References sqlite3VdbeRealValue().

Referenced by absFunc(), charFunc(), db_push_value(), ntileStepFunc(), statInit(), statPush(), and sumStep().

◆ sqlite3_value_nochange()

SQLITE_API int sqlite3_value_nochange ( sqlite3_value * pVal )

Definition at line 83302 of file sqlite3.c.

Referenced by sqlite3_vtab_nochange(), and sqlite3VdbeMemExpandBlob().

◆ sqlite3_value_numeric_type()

SQLITE_API int sqlite3_value_numeric_type ( sqlite3_value * pVal )

Definition at line 85640 of file sqlite3.c.

                                                              {
  int eType = sqlite3_value_type(pVal);
  if( eType==SQLITE_TEXT ){

References applyNumericAffinity(), eType, sqlite3_value_type(), and SQLITE_TEXT.

Referenced by sumStep().

◆ sqlite3_value_pointer()

SQLITE_API void * sqlite3_value_pointer	(	sqlite3_value *	pVal,
		const char *	zPType )

Definition at line 83185 of file sqlite3.c.

                                                                  {
  Mem *pMem = (Mem*)pVal;
  return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
}
SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
  Mem *p = (Mem*)pVal;
  if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
                 (MEM_Null|MEM_Term|MEM_Subtype)
   && zPType!=0
   && p->eSubtype=='p'
   && strcmp(p->u.zPType, zPType)==0

◆ sqlite3_value_subtype()

SQLITE_API unsigned int sqlite3_value_subtype ( sqlite3_value * pVal )

Definition at line 83181 of file sqlite3.c.

                                                     {
  return (int)sqlite3VdbeIntValue((Mem*)pVal);
}
SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

References sqlite3VdbeIntValue().

◆ sqlite3_value_text()

SQLITE_API const unsigned char * sqlite3_value_text ( sqlite3_value * pVal )

Definition at line 83198 of file sqlite3.c.

   {
    return (void*)p->z;
  }else{

References sqlite3_value::z.

Referenced by attachFunc(), columnName(), compileoptionusedFunc(), db_push_value(), detachFunc(), errlogFunc(), exprCompareVariable(), instrFunc(), isDate(), isLikeOrGlob(), likeFunc(), loadExt(), quoteFunc(), renameColumnFunc(), renameColumnParseError(), renameTableFunc(), renameTableTest(), replaceFunc(), sqlite3_step(), sqlite3VdbeExec(), strftimeFunc(), and substrFunc().

◆ sqlite3_value_text16()

SQLITE_API const void * sqlite3_value_text16 ( sqlite3_value * pVal )

Definition at line 83202 of file sqlite3.c.

83204 {

Referenced by columnName(), sqlite3_column_type(), and sqlite3_errmsg16().

◆ sqlite3_value_text16be()

SQLITE_API const void * sqlite3_value_text16be ( sqlite3_value * pVal )

Definition at line 83205 of file sqlite3.c.

◆ sqlite3_value_text16le()

SQLITE_API const void * sqlite3_value_text16le ( sqlite3_value * pVal )

Definition at line 83208 of file sqlite3.c.

                                                                {
  return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueText(), and SQLITE_UTF16NATIVE.

◆ sqlite3_value_type()

SQLITE_API int sqlite3_value_type ( sqlite3_value * pVal )

Definition at line 83216 of file sqlite3.c.

                                                      {
  static const u8 aType[] = {
     SQLITE_BLOB,     /* 0x00 (not possible) */
     SQLITE_NULL,     /* 0x01 NULL */
     SQLITE_TEXT,     /* 0x02 TEXT */
     SQLITE_NULL,     /* 0x03 (not possible) */
     SQLITE_INTEGER,  /* 0x04 INTEGER */
     SQLITE_NULL,     /* 0x05 (not possible) */
     SQLITE_INTEGER,  /* 0x06 INTEGER + TEXT */
     SQLITE_NULL,     /* 0x07 (not possible) */
     SQLITE_FLOAT,    /* 0x08 FLOAT */
     SQLITE_NULL,     /* 0x09 (not possible) */
     SQLITE_FLOAT,    /* 0x0a FLOAT + TEXT */
     SQLITE_NULL,     /* 0x0b (not possible) */
     SQLITE_INTEGER,  /* 0x0c (not possible) */
     SQLITE_NULL,     /* 0x0d (not possible) */
     SQLITE_INTEGER,  /* 0x0e (not possible) */
     SQLITE_NULL,     /* 0x0f (not possible) */
     SQLITE_BLOB,     /* 0x10 BLOB */
     SQLITE_NULL,     /* 0x11 (not possible) */
     SQLITE_TEXT,     /* 0x12 (not possible) */
     SQLITE_NULL,     /* 0x13 (not possible) */
     SQLITE_INTEGER,  /* 0x14 INTEGER + BLOB */
     SQLITE_NULL,     /* 0x15 (not possible) */
     SQLITE_INTEGER,  /* 0x16 (not possible) */
     SQLITE_NULL,     /* 0x17 (not possible) */
     SQLITE_FLOAT,    /* 0x18 FLOAT + BLOB */
     SQLITE_NULL,     /* 0x19 (not possible) */
     SQLITE_FLOAT,    /* 0x1a (not possible) */
     SQLITE_NULL,     /* 0x1b (not possible) */
     SQLITE_INTEGER,  /* 0x1c (not possible) */
     SQLITE_NULL,     /* 0x1d (not possible) */
     SQLITE_INTEGER,  /* 0x1e (not possible) */
     SQLITE_NULL,     /* 0x1f (not possible) */
     SQLITE_FLOAT,    /* 0x20 INTREAL */
     SQLITE_NULL,     /* 0x21 (not possible) */
     SQLITE_TEXT,     /* 0x22 INTREAL + TEXT */
     SQLITE_NULL,     /* 0x23 (not possible) */
     SQLITE_FLOAT,    /* 0x24 (not possible) */
     SQLITE_NULL,     /* 0x25 (not possible) */
     SQLITE_FLOAT,    /* 0x26 (not possible) */
     SQLITE_NULL,     /* 0x27 (not possible) */
     SQLITE_FLOAT,    /* 0x28 (not possible) */
     SQLITE_NULL,     /* 0x29 (not possible) */
     SQLITE_FLOAT,    /* 0x2a (not possible) */
     SQLITE_NULL,     /* 0x2b (not possible) */
     SQLITE_FLOAT,    /* 0x2c (not possible) */
     SQLITE_NULL,     /* 0x2d (not possible) */
     SQLITE_FLOAT,    /* 0x2e (not possible) */
     SQLITE_NULL,     /* 0x2f (not possible) */
     SQLITE_BLOB,     /* 0x30 (not possible) */
     SQLITE_NULL,     /* 0x31 (not possible) */
     SQLITE_TEXT,     /* 0x32 (not possible) */
     SQLITE_NULL,     /* 0x33 (not possible) */
     SQLITE_FLOAT,    /* 0x34 (not possible) */
     SQLITE_NULL,     /* 0x35 (not possible) */
     SQLITE_FLOAT,    /* 0x36 (not possible) */
     SQLITE_NULL,     /* 0x37 (not possible) */
     SQLITE_FLOAT,    /* 0x38 (not possible) */
     SQLITE_NULL,     /* 0x39 (not possible) */
     SQLITE_FLOAT,    /* 0x3a (not possible) */
     SQLITE_NULL,     /* 0x3b (not possible) */
     SQLITE_FLOAT,    /* 0x3c (not possible) */
     SQLITE_NULL,     /* 0x3d (not possible) */
     SQLITE_FLOAT,    /* 0x3e (not possible) */
     SQLITE_NULL,     /* 0x3f (not possible) */
  };
#ifdef SQLITE_DEBUG
  {
    int eType = SQLITE_BLOB;
    if( pVal->flags & MEM_Null ){
      eType = SQLITE_NULL;
    }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
      eType = SQLITE_FLOAT;
    }else if( pVal->flags & MEM_Int ){
      eType = SQLITE_INTEGER;
    }else if( pVal->flags & MEM_Str ){
      eType = SQLITE_TEXT;

Referenced by absFunc(), db_push_value(), exprCompareVariable(), instrFunc(), isDate(), isLikeOrGlob(), likeFunc(), minmaxStep(), quoteFunc(), replaceFunc(), sqlite3_value_numeric_type(), statPush(), and substrFunc().

◆ sqlite3_vfs_find()

SQLITE_API sqlite3_vfs * sqlite3_vfs_find ( const char * zVfsName )

Definition at line 23307 of file sqlite3.c.

                                                          {
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;

References mutex, sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, vfsList, and sqlite3_vfs::zName.

Referenced by attachFunc(), and sqlite3ParseUri().

◆ sqlite3_vfs_register()

SQLITE_API int sqlite3_vfs_register	(	sqlite3_vfs *	pVfs,
		int	makeDflt )

Definition at line 23353 of file sqlite3.c.

                                                                    {
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
#endif
 
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;

References mutex, MUTEX_LOGIC, sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MISUSE_BKPT, SQLITE_MUTEX_STATIC_MAIN, SQLITE_OK, vfsList, and vfsUnlink().

Referenced by sqlite3_os_init().

◆ sqlite3_vfs_unregister()

SQLITE_API int sqlite3_vfs_unregister ( sqlite3_vfs * pVfs )

Definition at line 23381 of file sqlite3.c.

                                                        {
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )

◆ sqlite3_vmprintf()

SQLITE_API char * sqlite3_vmprintf	(	const char *	zFormat,
		va_list	ap )

Definition at line 29299 of file sqlite3.c.

                                                                  {
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zFormat==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;

◆ sqlite3_vsnprintf()

SQLITE_API char * sqlite3_vsnprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
		va_list	ap )

Definition at line 29348 of file sqlite3.c.

                                                                                      {
  StrAccum acc;
  if( n<=0 ) return zBuf;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zBuf==0 || zFormat==0 ) {
    (void)SQLITE_MISUSE_BKPT;
    if( zBuf ) zBuf[0] = 0;
    return zBuf;
  }

References SQLITE_MISUSE_BKPT.

◆ sqlite3_vtab_collation()

SQLITE_API const char * sqlite3_vtab_collation	(	sqlite3_index_info *	pIdxInfo,
		int	iCons )

Definition at line 148920 of file sqlite3.c.

                                                                                      {
  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
  const char *zRet = 0;
  if( iCons>=0 && iCons<pIdxInfo->nConstraint ){
    CollSeq *pC = 0;
    int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
    Expr *pX = pHidden->pWC->a[iTerm].pExpr;
    if( pX->pLeft ){

References WhereClause::a, sqlite3_index_info::aConstraint, sqlite3_index_info::sqlite3_index_constraint::iTermOffset, WhereTerm::pExpr, Expr::pLeft, HiddenIndexInfo::pParse, HiddenIndexInfo::pWC, sqlite3ExprCompareCollSeq(), sqlite3StrBINARY, and CollSeq::zName.

◆ sqlite3_vtab_config()

SQLITE_API int sqlite3_vtab_config	(	sqlite3 *	db,
		int	op,
			... )

Definition at line 140848 of file sqlite3.c.

                                                            {
  va_list ap;
  int rc = SQLITE_OK;
  VtabCtx *p;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  p = db->pVtabCtx;
  if( !p ){
    rc = SQLITE_MISUSE_BKPT;
  }else{
    assert( p->pTab==0 || IsVirtual(p->pTab) );
    va_start(ap, op);
    switch( op ){
      case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
        p->pVTable->bConstraint = (u8)va_arg(ap, int);
        break;
      }
      case SQLITE_VTAB_INNOCUOUS: {
        p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low;
        break;
      }
      case SQLITE_VTAB_DIRECTONLY: {
        p->pVTable->eVtabRisk = SQLITE_VTABRISK_High;
        break;
      }
      default: {
        rc = SQLITE_MISUSE_BKPT;
        break;
      }
    }
    va_end(ap);

References VTable::bConstraint, VTable::eVtabRisk, IsVirtual, sqlite3::mutex, VtabCtx::pTab, sqlite3::pVtabCtx, VtabCtx::pVTable, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3Error(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, SQLITE_VTAB_CONSTRAINT_SUPPORT, SQLITE_VTAB_DIRECTONLY, SQLITE_VTAB_INNOCUOUS, SQLITE_VTABRISK_High, and SQLITE_VTABRISK_Low.

◆ sqlite3_vtab_nochange()

SQLITE_API int sqlite3_vtab_nochange ( sqlite3_context * p )

Definition at line 83813 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3_value_nochange().

◆ sqlite3_vtab_on_conflict()

SQLITE_API int sqlite3_vtab_on_conflict ( sqlite3 * db )

Definition at line 140830 of file sqlite3.c.

                                                    {
  static const unsigned char aMap[] = {
    SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
  };
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;

References OE_Abort, OE_Fail, OE_Ignore, OE_Replace, OE_Rollback, sqlite3SafetyCheckOk(), SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_MISUSE_BKPT, SQLITE_REPLACE, SQLITE_ROLLBACK, and sqlite3::vtabOnConflict.

◆ sqlite3_wal_autocheckpoint()

SQLITE_API int sqlite3_wal_autocheckpoint	(	sqlite3 *	db,
		int	N )

Definition at line 163281 of file sqlite3.c.

                                                                  {
#ifdef SQLITE_OMIT_WAL
  UNUSED_PARAMETER(db);
  UNUSED_PARAMETER(nFrame);
#else
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( nFrame>0 ){
    sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));

References sqlite3_wal_hook(), sqlite3SafetyCheckOk(), sqlite3WalDefaultHook(), SQLITE_INT_TO_PTR, SQLITE_MISUSE_BKPT, SQLITE_OK, and UNUSED_PARAMETER.

Referenced by openDatabase(), and sqlite3Pragma().

◆ sqlite3_wal_checkpoint()

SQLITE_API int sqlite3_wal_checkpoint	(	sqlite3 *	db,
		const char *	zDb )

Definition at line 163391 of file sqlite3.c.

References sqlite3_wal_checkpoint_v2(), and SQLITE_CHECKPOINT_PASSIVE.

Referenced by sqlite3WalDefaultHook().

◆ sqlite3_wal_checkpoint_v2()

SQLITE_API int sqlite3_wal_checkpoint_v2	(	sqlite3 *	db,
		const char *	zDb,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt )

Definition at line 163329 of file sqlite3.c.

 {
#ifdef SQLITE_OMIT_WAL
  return SQLITE_OK;
#else
  int rc;                         /* Return code */
  int iDb = SQLITE_MAX_ATTACHED;  /* sqlite3.aDb[] index of db to checkpoint */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
 
  /* Initialize the output variables to -1 in case an error occurs. */
  if( pnLog ) *pnLog = -1;
  if( pnCkpt ) *pnCkpt = -1;
 
  assert( SQLITE_CHECKPOINT_PASSIVE==0 );
  assert( SQLITE_CHECKPOINT_FULL==1 );
  assert( SQLITE_CHECKPOINT_RESTART==2 );
  assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
  if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
    /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
    ** mode: */
    return SQLITE_MISUSE;
  }
 
  sqlite3_mutex_enter(db->mutex);
  if( zDb && zDb[0] ){
    iDb = sqlite3FindDbName(db, zDb);
  }
  if( iDb<0 ){
    rc = SQLITE_ERROR;
    sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
  }else{
    db->busyHandler.nBusy = 0;
    rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
    sqlite3Error(db, rc);
  }
  rc = sqlite3ApiExit(db, rc);
 
  /* If there are no active statements, clear the interrupt flag at this
  ** point.  */
  if( db->nVdbeActive==0 ){
    AtomicStore(&db->u1.isInterrupted, 0);

Referenced by sqlite3_wal_checkpoint().

◆ sqlite3_wal_hook()

SQLITE_API void * sqlite3_wal_hook	(	sqlite3 *	db,
		int()(void , sqlite3 , const char , int)	xCallback,
		void *	pArg )

Definition at line 163302 of file sqlite3.c.

 {
#ifndef SQLITE_OMIT_WAL
  void *pRet;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pWalArg;
  db->xWalCallback = xCallback;
  db->pWalArg = pArg;

Referenced by sqlite3_wal_autocheckpoint().

◆ sqlite3_win32_set_directory()

SQLITE_API int sqlite3_win32_set_directory	(	unsigned long	type,
		void *	zValue )

◆ sqlite3_win32_set_directory16()

SQLITE_API int sqlite3_win32_set_directory16	(	unsigned long	type,
		const void *	zValue )

◆ sqlite3_win32_set_directory8()

SQLITE_API int sqlite3_win32_set_directory8	(	unsigned long	type,
		const char *	zValue )

◆ sqlite3AbsInt32()

SQLITE_PRIVATE int sqlite3AbsInt32 ( int x )

Definition at line 32640 of file sqlite3.c.

Referenced by allocateBtreePage(), sqlite3InitOne(), and sqlite3Pragma().

◆ sqlite3AddCheckConstraint()

SQLITE_PRIVATE void sqlite3AddCheckConstraint	(	Parse *	pParse,
		Expr *	pCheckExpr )

Definition at line 112008 of file sqlite3.c.

 {
#ifndef SQLITE_OMIT_CHECK
  Table *pTab = pParse->pNewTable;
  sqlite3 *db = pParse->db;
  if( pTab && !IN_DECLARE_VTAB
   && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
  ){
    pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
    if( pParse->constraintName.n ){
      sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
    }

Referenced by yy_reduce().

◆ sqlite3AddCollateType()

SQLITE_PRIVATE void sqlite3AddCollateType	(	Parse *	pParse,
		Token *	pToken )

Definition at line 112033 of file sqlite3.c.

                                                                       {
  Table *p;
  int i;
  char *zColl;              /* Dequoted name of collation sequence */
  sqlite3 *db;
 
  if( (p = pParse->pNewTable)==0 ) return;
  i = p->nCol-1;
  db = pParse->db;
  zColl = sqlite3NameFromToken(db, pToken);
  if( !zColl ) return;
 
  if( sqlite3LocateCollSeq(pParse, zColl) ){
    Index *pIdx;
    sqlite3DbFree(db, p->aCol[i].zColl);
    p->aCol[i].zColl = zColl;
 
    /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
    ** then an index may have been created on this column before the
    ** collation type was added. Correct this if it is the case.
    */
    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
      assert( pIdx->nKeyCol==1 );
      if( pIdx->aiColumn[0]==i ){
        pIdx->azColl[0] = p->aCol[i].zColl;

Referenced by yy_reduce().

◆ sqlite3AddColumn()

SQLITE_PRIVATE void sqlite3AddColumn	(	Parse *	pParse,
		Token *	pName,
		Token *	pType )

Definition at line 111640 of file sqlite3.c.

                                                                               {
  Table *p;
  int i;
  char *z;
  char *zType;
  Column *pCol;
  sqlite3 *db = pParse->db;
  if( (p = pParse->pNewTable)==0 ) return;
  if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
    return;
  }
  z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
  if( z==0 ) return;
  if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName);
  memcpy(z, pName->z, pName->n);
  z[pName->n] = 0;
  sqlite3Dequote(z);
  for(i=0; i<p->nCol; i++){
    if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
      sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
      sqlite3DbFree(db, z);
      return;
    }
  }
  if( (p->nCol & 0x7)==0 ){
    Column *aNew;
    aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
    if( aNew==0 ){
      sqlite3DbFree(db, z);
      return;
    }
    p->aCol = aNew;
  }
  pCol = &p->aCol[p->nCol];
  memset(pCol, 0, sizeof(p->aCol[0]));
  pCol->zName = z;
  pCol->hName = sqlite3StrIHash(z);
  sqlite3ColumnPropertiesFromName(p, pCol);
 
  if( pType->n==0 ){
    /* If there is no type specified, columns have the default affinity
    ** 'BLOB' with a default size of 4 bytes. */
    pCol->affinity = SQLITE_AFF_BLOB;
    pCol->szEst = 1;
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    if( 4>=sqlite3GlobalConfig.szSorterRef ){
      pCol->colFlags |= COLFLAG_SORTERREF;
    }
#endif
  }else{
    zType = z + sqlite3Strlen30(z) + 1;
    memcpy(zType, pType->z, pType->n);
    zType[pType->n] = 0;
    sqlite3Dequote(zType);
    pCol->affinity = sqlite3AffinityType(zType, pCol);

References Table::aCol, Column::affinity, sqlite3::aLimit, COLFLAG_HASTYPE, COLFLAG_SORTERREF, Column::colFlags, Parse::constraintName, Parse::db, Column::hName, IN_RENAME_OBJECT, Token::n, Table::nCol, Table::nNVCol, Parse::pNewTable, sqlite3_stricmp(), sqlite3AffinityType(), sqlite3ColumnPropertiesFromName, sqlite3DbFree(), sqlite3DbMallocRaw(), sqlite3DbRealloc(), sqlite3Dequote(), sqlite3ErrorMsg(), sqlite3GlobalConfig, sqlite3RenameTokenMap(), sqlite3StrIHash(), sqlite3Strlen30(), SQLITE_AFF_BLOB, SQLITE_LIMIT_COLUMN, Column::szEst, Token::z, Column::zName, and Table::zName.

Referenced by yy_reduce().

◆ sqlite3AddDefaultValue()

SQLITE_PRIVATE void sqlite3AddDefaultValue	(	Parse *	pParse,
		Expr *	pExpr,
		const char *	zStart,
		const char *	zEnd )

Definition at line 111833 of file sqlite3.c.

 {
  Table *p;
  Column *pCol;
  sqlite3 *db = pParse->db;
  p = pParse->pNewTable;
  if( p!=0 ){
    int isInit = db->init.busy && db->init.iDb!=1;
    pCol = &(p->aCol[p->nCol-1]);
    if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
          pCol->zName);
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    }else if( pCol->colFlags & COLFLAG_GENERATED ){
      testcase( pCol->colFlags & COLFLAG_VIRTUAL );
      testcase( pCol->colFlags & COLFLAG_STORED );
      sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
#endif
    }else{
      /* A copy of pExpr is used instead of the original, as pExpr contains
      ** tokens that point to volatile memory.
      */
      Expr x;
      sqlite3ExprDelete(db, pCol->pDflt);
      memset(&x, 0, sizeof(x));
      x.op = TK_SPAN;
      x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
      x.pLeft = pExpr;
      x.flags = EP_Skip;
      pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
      sqlite3DbFree(db, x.u.zToken);
    }

References Table::aCol, sqlite3::sqlite3InitInfo::busy, COLFLAG_GENERATED, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, EP_Skip, EXPRDUP_REDUCE, Expr::flags, sqlite3::sqlite3InitInfo::iDb, IN_RENAME_OBJECT, sqlite3::init, Table::nCol, Expr::op, Column::pDflt, Expr::pLeft, Parse::pNewTable, sqlite3DbFree(), sqlite3DbSpanDup(), sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIsConstantOrFunction(), sqlite3RenameExprUnmap(), testcase, TK_SPAN, Expr::u, Column::zName, and Expr::zToken.

Referenced by yy_reduce().

◆ sqlite3AddGenerated()

SQLITE_PRIVATE void sqlite3AddGenerated	(	Parse *	pParse,
		Expr *	pExpr,
		Token *	pType )

Definition at line 112068 of file sqlite3.c.

                                                                                 {
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  u8 eType = COLFLAG_VIRTUAL;
  Table *pTab = pParse->pNewTable;
  Column *pCol;
  if( pTab==0 ){
    /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
    goto generated_done;
  }
  pCol = &(pTab->aCol[pTab->nCol-1]);
  if( IN_DECLARE_VTAB ){
    sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
    goto generated_done;
  }
  if( pCol->pDflt ) goto generated_error;
  if( pType ){
    if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
      /* no-op */
    }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
      eType = COLFLAG_STORED;
    }else{
      goto generated_error;
    }
  }
  if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
  pCol->colFlags |= eType;
  assert( TF_HasVirtual==COLFLAG_VIRTUAL );
  assert( TF_HasStored==COLFLAG_STORED );
  pTab->tabFlags |= eType;
  if( pCol->colFlags & COLFLAG_PRIMKEY ){
    makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
  }
  pCol->pDflt = pExpr;
  pExpr = 0;
  goto generated_done;
 
generated_error:
  sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
                  pCol->zName);
generated_done:
  sqlite3ExprDelete(pParse->db, pExpr);
#else

Referenced by yy_reduce().

◆ sqlite3AddInt64()

SQLITE_PRIVATE int sqlite3AddInt64	(	i64 *	pA,
		i64	iB )

Definition at line 32579 of file sqlite3.c.

                                                   {
#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
  return __builtin_add_overflow(*pA, iB, pA);
#else
  i64 iA = *pA;
  testcase( iA==0 ); testcase( iA==1 );
  testcase( iB==-1 ); testcase( iB==0 );
  if( iB>=0 ){
    testcase( iA>0 && LARGEST_INT64 - iA == iB );
    testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
    if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
  }else{
    testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
    testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );

References LARGEST_INT64, and testcase.

Referenced by sqlite3VdbeExec(), and sumStep().

◆ sqlite3AddNotNull()

SQLITE_PRIVATE void sqlite3AddNotNull	(	Parse *	pParse,
		int	onError )

Definition at line 111709 of file sqlite3.c.

                                                                 {
  Table *p;
  Column *pCol;
  p = pParse->pNewTable;
  if( p==0 || NEVER(p->nCol<1) ) return;
  pCol = &p->aCol[p->nCol-1];
  pCol->notNull = (u8)onError;
  p->tabFlags |= TF_HasNotNull;
 
  /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
  ** on this column.  */
  if( pCol->colFlags & COLFLAG_UNIQUE ){
    Index *pIdx;
    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
      assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );

References Table::aCol, Index::aiColumn, COLFLAG_UNIQUE, Column::colFlags, Table::nCol, NEVER, Index::nKeyCol, Column::notNull, OE_None, Index::onError, Table::pIndex, Parse::pNewTable, Index::pNext, Table::tabFlags, TF_HasNotNull, and Index::uniqNotNull.

Referenced by yy_reduce().

◆ sqlite3AddPrimaryKey()

SQLITE_PRIVATE void sqlite3AddPrimaryKey	(	Parse *	pParse,
		ExprList *	pList,
		int	onError,
		int	autoInc,
		int	sortOrder )

Definition at line 111933 of file sqlite3.c.

 {
  Table *pTab = pParse->pNewTable;
  Column *pCol = 0;
  int iCol = -1, i;
  int nTerm;
  if( pTab==0 ) goto primary_key_exit;
  if( pTab->tabFlags & TF_HasPrimaryKey ){
    sqlite3ErrorMsg(pParse,
      "table \"%s\" has more than one primary key", pTab->zName);
    goto primary_key_exit;
  }
  pTab->tabFlags |= TF_HasPrimaryKey;
  if( pList==0 ){
    iCol = pTab->nCol - 1;
    pCol = &pTab->aCol[iCol];
    makeColumnPartOfPrimaryKey(pParse, pCol);
    nTerm = 1;
  }else{
    nTerm = pList->nExpr;
    for(i=0; i<nTerm; i++){
      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
      assert( pCExpr!=0 );
      sqlite3StringToId(pCExpr);
      if( pCExpr->op==TK_ID ){
        const char *zCName = pCExpr->u.zToken;
        for(iCol=0; iCol<pTab->nCol; iCol++){
          if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
            pCol = &pTab->aCol[iCol];
            makeColumnPartOfPrimaryKey(pParse, pCol);
            break;
          }
        }
      }
    }
  }
  if( nTerm==1
   && pCol
   && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
   && sortOrder!=SQLITE_SO_DESC
  ){
    if( IN_RENAME_OBJECT && pList ){
      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
      sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
    }
    pTab->iPKey = iCol;
    pTab->keyConf = (u8)onError;
    assert( autoInc==0 || autoInc==1 );
    pTab->tabFlags |= autoInc*TF_Autoincrement;
    if( pList ) pParse->iPkSortOrder = pList->a[0].sortFlags;
    (void)sqlite3HasExplicitNulls(pParse, pList);
  }else if( autoInc ){
#ifndef SQLITE_OMIT_AUTOINCREMENT
    sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
       "INTEGER PRIMARY KEY");
#endif
  }else{
    sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
                           0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
    pList = 0;

References ExprList::a, Table::aCol, Parse::db, IN_RENAME_OBJECT, Table::iPKey, Parse::iPkSortOrder, Table::keyConf, makeColumnPartOfPrimaryKey(), Table::nCol, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Parse::pNewTable, ExprList::ExprList_item::sortFlags, sqlite3ColumnType(), sqlite3CreateIndex(), sqlite3ErrorMsg(), sqlite3ExprListDelete(), sqlite3ExprSkipCollate(), sqlite3HasExplicitNulls(), sqlite3RenameTokenRemap(), sqlite3StrICmp(), sqlite3StringToId(), SQLITE_IDXTYPE_PRIMARYKEY, SQLITE_SO_DESC, Table::tabFlags, TF_Autoincrement, TF_HasPrimaryKey, TK_ID, Expr::u, Column::zName, Table::zName, and Expr::zToken.

Referenced by yy_reduce().

◆ sqlite3AffinityType()

SQLITE_PRIVATE char sqlite3AffinityType	(	const char *	zIn,
		Column *	pCol )

Definition at line 111756 of file sqlite3.c.

                                                                      {
  u32 h = 0;
  char aff = SQLITE_AFF_NUMERIC;
  const char *zChar = 0;
 
  assert( zIn!=0 );
  while( zIn[0] ){
    h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
    zIn++;
    if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
      aff = SQLITE_AFF_TEXT;
      zChar = zIn;
    }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */
      aff = SQLITE_AFF_TEXT;
    }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */
      aff = SQLITE_AFF_TEXT;
    }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */
        && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
      aff = SQLITE_AFF_BLOB;
      if( zIn[0]=='(' ) zChar = zIn;
#ifndef SQLITE_OMIT_FLOATING_POINT
    }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */
        && aff==SQLITE_AFF_NUMERIC ){
      aff = SQLITE_AFF_REAL;
    }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */
        && aff==SQLITE_AFF_NUMERIC ){
      aff = SQLITE_AFF_REAL;
    }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */
        && aff==SQLITE_AFF_NUMERIC ){
      aff = SQLITE_AFF_REAL;
#endif
    }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */
      aff = SQLITE_AFF_INTEGER;
      break;
    }
  }
 
  /* If pCol is not NULL, store an estimate of the field size.  The
  ** estimate is scaled so that the size of an integer is 1.  */
  if( pCol ){
    int v = 0;   /* default size is approx 4 bytes */
    if( aff<SQLITE_AFF_NUMERIC ){
      if( zChar ){
        while( zChar[0] ){
          if( sqlite3Isdigit(zChar[0]) ){
            /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
            sqlite3GetInt32(zChar, &v);
            break;
          }
          zChar++;
        }
      }else{
        v = 16;   /* BLOB, TEXT, CLOB -> r=5  (approx 20 bytes)*/
      }
    }
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    if( v>=sqlite3GlobalConfig.szSorterRef ){
      pCol->colFlags |= COLFLAG_SORTERREF;
    }
#endif

References COLFLAG_SORTERREF, Column::colFlags, sqlite3GetInt32(), sqlite3GlobalConfig, sqlite3Isdigit, sqlite3UpperToLower, SQLITE_AFF_BLOB, SQLITE_AFF_INTEGER, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, and Column::szEst.

Referenced by createTableStmt(), sqlite3AddColumn(), sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), and valueFromExpr().

◆ sqlite3AggInfoPersistWalkerInit()

SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit	(	Walker *	pWalker,
		Parse *	pParse )

Definition at line 105496 of file sqlite3.c.

Referenced by flattenSubquery(), and sqlite3WindowRewrite().

◆ sqlite3AllocateIndexObject()

SQLITE_PRIVATE Index * sqlite3AllocateIndexObject	(	sqlite3 *	db,
		i16	nCol,
		int	nExtra,
		char **	ppExtra )

Definition at line 113808 of file sqlite3.c.

 {
  Index *p;            /* Allocated index object */
  int nByte;           /* Bytes of space for Index object + arrays */
 
  nByte = ROUND8(sizeof(Index)) +              /* Index structure  */
          ROUND8(sizeof(char*)*nCol) +         /* Index.azColl     */
          ROUND8(sizeof(LogEst)*(nCol+1) +     /* Index.aiRowLogEst   */
                 sizeof(i16)*nCol +            /* Index.aiColumn   */
                 sizeof(u8)*nCol);             /* Index.aSortOrder */
  p = sqlite3DbMallocZero(db, nByte + nExtra);
  if( p ){
    char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
    p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
    p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
    p->aiColumn = (i16*)pExtra;       pExtra += sizeof(i16)*nCol;
    p->aSortOrder = (u8*)pExtra;

References Index::aiColumn, Index::aiRowLogEst, Index::aSortOrder, Index::azColl, Index::nColumn, Index::nKeyCol, ROUND8, and sqlite3DbMallocZero().

Referenced by constructAutomaticIndex(), and sqlite3CreateIndex().

◆ sqlite3AlterBeginAddColumn()

SQLITE_PRIVATE void sqlite3AlterBeginAddColumn	(	Parse *	pParse,
		SrcList *	pSrc )

Definition at line 106223 of file sqlite3.c.

                                                                            {
  Table *pNew;
  Table *pTab;
  int iDb;
  int i;
  int nAlloc;
  sqlite3 *db = pParse->db;
 
  /* Look up the table being altered. */
  assert( pParse->pNewTable==0 );
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  if( db->mallocFailed ) goto exit_begin_add_column;
  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
  if( !pTab ) goto exit_begin_add_column;
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
    goto exit_begin_add_column;
  }
#endif
 
  /* Make sure this is not an attempt to ALTER a view. */
  if( pTab->pSelect ){
    sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
    goto exit_begin_add_column;
  }
  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
    goto exit_begin_add_column;
  }
 
  sqlite3MayAbort(pParse);
  assert( pTab->addColOffset>0 );
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 
  /* Put a copy of the Table struct in Parse.pNewTable for the
  ** sqlite3AddColumn() function and friends to modify.  But modify
  ** the name by adding an "sqlite_altertab_" prefix.  By adding this
  ** prefix, we insure that the name will not collide with an existing
  ** table because user table are not allowed to have the "sqlite_"
  ** prefix on their name.
  */
  pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
  if( !pNew ) goto exit_begin_add_column;
  pParse->pNewTable = pNew;
  pNew->nTabRef = 1;
  pNew->nCol = pTab->nCol;
  assert( pNew->nCol>0 );
  nAlloc = (((pNew->nCol-1)/8)*8)+8;
  assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
  pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
  pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
  if( !pNew->aCol || !pNew->zName ){
    assert( db->mallocFailed );
    goto exit_begin_add_column;
  }
  memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
  for(i=0; i<pNew->nCol; i++){
    Column *pCol = &pNew->aCol[i];
    pCol->zName = sqlite3DbStrDup(db, pCol->zName);
    pCol->hName = sqlite3StrIHash(pCol->zName);
    pCol->zColl = 0;
    pCol->pDflt = 0;
  }
  pNew->pSchema = db->aDb[iDb].pSchema;
  pNew->addColOffset = pTab->addColOffset;

References SrcList::a, Table::aCol, sqlite3::aDb, Table::addColOffset, Parse::db, Column::hName, isAlterableTable(), IsVirtual, sqlite3::mallocFailed, Table::nCol, Table::nTabRef, Column::pDflt, Parse::pNewTable, Db::pSchema, Table::pSchema, Table::pSelect, sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3LocateTableItem(), sqlite3MayAbort(), sqlite3MPrintf(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3StrIHash(), SQLITE_OK, Column::zColl, Column::zName, and Table::zName.

Referenced by yy_reduce().

◆ sqlite3AlterFinishAddColumn()

SQLITE_PRIVATE void sqlite3AlterFinishAddColumn	(	Parse *	pParse,
		Token *	pColDef )

Definition at line 106078 of file sqlite3.c.

                                                                              {
  Table *pNew;              /* Copy of pParse->pNewTable */
  Table *pTab;              /* Table being altered */
  int iDb;                  /* Database number */
  const char *zDb;          /* Database name */
  const char *zTab;         /* Table name */
  char *zCol;               /* Null-terminated column definition */
  Column *pCol;             /* The new column */
  Expr *pDflt;              /* Default value for the new column */
  sqlite3 *db;              /* The database connection; */
  Vdbe *v;                  /* The prepared statement under construction */
  int r1;                   /* Temporary registers */
 
  db = pParse->db;
  if( pParse->nErr || db->mallocFailed ) return;
  pNew = pParse->pNewTable;
  assert( pNew );
 
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
  zDb = db->aDb[iDb].zDbSName;
  zTab = &pNew->zName[16];  /* Skip the "sqlite_altertab_" prefix on the name */
  pCol = &pNew->aCol[pNew->nCol-1];
  pDflt = pCol->pDflt;
  pTab = sqlite3FindTable(db, zTab, zDb);
  assert( pTab );
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  /* Invoke the authorization callback. */
  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
    return;
  }
#endif
 
 
  /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
  ** If there is a NOT NULL constraint, then the default value for the
  ** column must not be NULL.
  */
  if( pCol->colFlags & COLFLAG_PRIMKEY ){
    sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
    return;
  }
  if( pNew->pIndex ){
    sqlite3ErrorMsg(pParse,
         "Cannot add a UNIQUE column");
    return;
  }
  if( (pCol->colFlags & COLFLAG_GENERATED)==0 ){
    /* If the default value for the new column was specified with a
    ** literal NULL, then set pDflt to 0. This simplifies checking
    ** for an SQL NULL default below.
    */
    assert( pDflt==0 || pDflt->op==TK_SPAN );
    if( pDflt && pDflt->pLeft->op==TK_NULL ){
      pDflt = 0;
    }
    if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
      sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
          "Cannot add a REFERENCES column with non-NULL default value");
    }
    if( pCol->notNull && !pDflt ){
      sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
          "Cannot add a NOT NULL column with default value NULL");
    }
 
 
    /* Ensure the default expression is something that sqlite3ValueFromExpr()
    ** can handle (i.e. not CURRENT_TIME etc.)
    */
    if( pDflt ){
      sqlite3_value *pVal = 0;
      int rc;
      rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
      assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
      if( rc!=SQLITE_OK ){
        assert( db->mallocFailed == 1 );
        return;
      }
      if( !pVal ){
        sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
           "Cannot add a column with non-constant default");
      }
      sqlite3ValueFree(pVal);
    }
  }else if( pCol->colFlags & COLFLAG_STORED ){
    sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column");
  }
 
 
  /* Modify the CREATE TABLE statement. */
  zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
  if( zCol ){
    char *zEnd = &zCol[pColDef->n-1];
    u32 savedDbFlags = db->mDbFlags;
    while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
      *zEnd-- = '\0';
    }
    db->mDbFlags |= DBFLAG_PreferBuiltin;
    sqlite3NestedParse(pParse,
        "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
          "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
        "WHERE type = 'table' AND name = %Q",
      zDb, pNew->addColOffset, zCol, pNew->addColOffset+1,
      zTab
    );
    sqlite3DbFree(db, zCol);
    db->mDbFlags = savedDbFlags;
  }
 
  /* Make sure the schema version is at least 3.  But do not upgrade
  ** from less than 3 to 4, as that will corrupt any preexisting DESC
  ** index.
  */
  v = sqlite3GetVdbe(pParse);
  if( v ){
    r1 = sqlite3GetTempReg(pParse);
    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
    sqlite3VdbeUsesBtree(v, iDb);
    sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
    sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
    VdbeCoverage(v);
    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);

References Table::aCol, sqlite3::aDb, Table::addColOffset, BTREE_FILE_FORMAT, COLFLAG_GENERATED, COLFLAG_PRIMKEY, COLFLAG_STORED, Column::colFlags, Parse::db, DBFLAG_PreferBuiltin, DFLT_SCHEMA_TABLE, sqlite3::flags, sqlite3::mallocFailed, sqlite3::mDbFlags, Token::n, Table::nCol, Parse::nErr, Column::notNull, Expr::op, OP_AddImm, OP_IfPos, OP_ReadCookie, OP_SetCookie, Column::pDflt, Table::pFKey, Table::pIndex, Expr::pLeft, Parse::pNewTable, Table::pSchema, renameReloadSchema(), sqlite3AuthCheck(), sqlite3DbFree(), sqlite3DbStrNDup(), sqlite3ErrorIfNotEmpty(), sqlite3ErrorMsg(), sqlite3FindTable(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3Isspace, sqlite3NestedParse(), sqlite3ReleaseTempReg(), sqlite3SchemaToIndex(), sqlite3ValueFree(), sqlite3ValueFromExpr(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeCurrentAddr(), sqlite3VdbeUsesBtree(), SQLITE_AFF_BLOB, SQLITE_ALTER_TABLE, SQLITE_ForeignKeys, SQLITE_NOMEM, SQLITE_OK, SQLITE_UTF8, TK_NULL, TK_SPAN, VdbeCoverage, Token::z, Db::zDbSName, and Table::zName.

Referenced by yy_reduce().

◆ sqlite3AlterFunctions()

SQLITE_PRIVATE void sqlite3AlterFunctions ( void )

Definition at line 107532 of file sqlite3.c.

107538 {

107539 static FuncDef aAlterTableFuncs[] = {

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sqlite3AlterRenameColumn()

SQLITE_PRIVATE void sqlite3AlterRenameColumn	(	Parse *	pParse,
		SrcList *	pSrc,
		Token *	pOld,
		Token *	pNew )

Definition at line 106334 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;       /* Database connection */
  Table *pTab;                    /* Table being updated */
  int iCol;                       /* Index of column being renamed */
  char *zOld = 0;                 /* Old column name */
  char *zNew = 0;                 /* New column name */
  const char *zDb;                /* Name of schema containing the table */
  int iSchema;                    /* Index of the schema */
  int bQuote;                     /* True to quote the new name */
 
  /* Locate the table to be altered */
  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
  if( !pTab ) goto exit_rename_column;
 
  /* Cannot alter a system table */
  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
  if( SQLITE_OK!=isRealTable(pParse, pTab) ) goto exit_rename_column;
 
  /* Which schema holds the table to be altered */
  iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iSchema>=0 );
  zDb = db->aDb[iSchema].zDbSName;
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  /* Invoke the authorization callback. */
  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
    goto exit_rename_column;
  }
#endif
 
  /* Make sure the old name really is a column name in the table to be
  ** altered.  Set iCol to be the index of the column being renamed */
  zOld = sqlite3NameFromToken(db, pOld);
  if( !zOld ) goto exit_rename_column;
  for(iCol=0; iCol<pTab->nCol; iCol++){
    if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break;
  }
  if( iCol==pTab->nCol ){
    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);
    goto exit_rename_column;
  }
 
  /* Do the rename operation using a recursive UPDATE statement that
  ** uses the sqlite_rename_column() SQL function to compute the new
  ** CREATE statement text for the sqlite_schema table.
  */
  sqlite3MayAbort(pParse);
  zNew = sqlite3NameFromToken(db, pNew);
  if( !zNew ) goto exit_rename_column;
  assert( pNew->n>0 );
  bQuote = sqlite3Isquote(pNew->z[0]);
  sqlite3NestedParse(pParse,
      "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) "
      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' "
      " AND (type != 'index' OR tbl_name = %Q)"
      " AND sql NOT LIKE 'create virtual%%'",
      zDb,
      zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
      pTab->zName
  );
 
  sqlite3NestedParse(pParse,
      "UPDATE temp." DFLT_SCHEMA_TABLE " SET "
      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "
      "WHERE type IN ('trigger', 'view')",
      zDb, pTab->zName, iCol, zNew, bQuote
  );
 
  /* Drop and reload the database schema. */
  renameReloadSchema(pParse, iSchema);
  renameTestSchema(pParse, zDb, iSchema==1);
 

References SrcList::a, Table::aCol, sqlite3::aDb, Parse::db, DFLT_SCHEMA_TABLE, isAlterableTable(), isRealTable(), Token::n, Table::nCol, Table::pSchema, renameReloadSchema(), renameTestSchema(), sqlite3AuthCheck(), sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3Isquote, sqlite3LocateTableItem(), sqlite3MayAbort(), sqlite3NameFromToken(), sqlite3NestedParse(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3StrICmp(), SQLITE_ALTER_TABLE, SQLITE_OK, Token::z, Db::zDbSName, Column::zName, and Table::zName.

Referenced by yy_reduce().

◆ sqlite3AlterRenameTable()

SQLITE_PRIVATE void sqlite3AlterRenameTable	(	Parse *	pParse,
		SrcList *	pSrc,
		Token *	pName )

Definition at line 105885 of file sqlite3.c.

 {
  int iDb;                  /* Database that contains the table */
  char *zDb;                /* Name of database iDb */
  Table *pTab;              /* Table being renamed */
  char *zName = 0;          /* NULL-terminated version of pName */
  sqlite3 *db = pParse->db; /* Database connection */
  int nTabName;             /* Number of UTF-8 characters in zTabName */
  const char *zTabName;     /* Original name of the table */
  Vdbe *v;
  VTable *pVTab = 0;        /* Non-zero if this is a v-tab with an xRename() */
  u32 savedDbFlags;         /* Saved value of db->mDbFlags */
 
  savedDbFlags = db->mDbFlags;
  if( NEVER(db->mallocFailed) ) goto exit_rename_table;
  assert( pSrc->nSrc==1 );
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
 
  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
  if( !pTab ) goto exit_rename_table;
  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  zDb = db->aDb[iDb].zDbSName;
  db->mDbFlags |= DBFLAG_PreferBuiltin;
 
  /* Get a NULL terminated version of the new table name. */
  zName = sqlite3NameFromToken(db, pName);
  if( !zName ) goto exit_rename_table;
 
  /* Check that a table or index named 'zName' does not already exist
  ** in database iDb. If so, this is an error.
  */
  if( sqlite3FindTable(db, zName, zDb)
   || sqlite3FindIndex(db, zName, zDb)
   || sqlite3IsShadowTableOf(db, pTab, zName)
  ){
    sqlite3ErrorMsg(pParse,
        "there is already another table or index with this name: %s", zName);
    goto exit_rename_table;
  }
 
  /* Make sure it is not a system table being altered, or a reserved name
  ** that the table is being renamed to.
  */
  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
    goto exit_rename_table;
  }
  if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
    goto exit_rename_table;
  }
 
#ifndef SQLITE_OMIT_VIEW
  if( pTab->pSelect ){
    sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
    goto exit_rename_table;
  }
#endif
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  /* Invoke the authorization callback. */
  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
    goto exit_rename_table;
  }
#endif
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
    goto exit_rename_table;
  }
  if( IsVirtual(pTab) ){
    pVTab = sqlite3GetVTable(db, pTab);
    if( pVTab->pVtab->pModule->xRename==0 ){
      pVTab = 0;
    }
  }
#endif
 
  /* Begin a transaction for database iDb. Then modify the schema cookie
  ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(),
  ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the
  ** nested SQL may raise an exception.  */
  v = sqlite3GetVdbe(pParse);
  if( v==0 ){
    goto exit_rename_table;
  }
  sqlite3MayAbort(pParse);
 
  /* figure out how many UTF-8 characters are in zName */
  zTabName = pTab->zName;
  nTabName = sqlite3Utf8CharLen(zTabName, -1);
 
  /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
  ** the schema to use the new table name.  */
  sqlite3NestedParse(pParse,
      "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
      "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) "
      "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)"
      "AND   name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
      , zDb, zDb, zTabName, zName, (iDb==1), zTabName
  );
 
  /* Update the tbl_name and name columns of the sqlite_schema table
  ** as required.  */
  sqlite3NestedParse(pParse,
      "UPDATE %Q." DFLT_SCHEMA_TABLE " SET "
          "tbl_name = %Q, "
          "name = CASE "
            "WHEN type='table' THEN %Q "
            "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' "
            "     AND type='index' THEN "
             "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
            "ELSE name END "
      "WHERE tbl_name=%Q COLLATE nocase AND "
          "(type='table' OR type='index' OR type='trigger');",
      zDb,
      zName, zName, zName,
      nTabName, zTabName
  );
 
#ifndef SQLITE_OMIT_AUTOINCREMENT
  /* If the sqlite_sequence table exists in this database, then update
  ** it with the new table name.
  */
  if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
    sqlite3NestedParse(pParse,
        "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
        zDb, zName, pTab->zName);
  }
#endif
 
  /* If the table being renamed is not itself part of the temp database,
  ** edit view and trigger definitions within the temp database
  ** as required.  */
  if( iDb!=1 ){
    sqlite3NestedParse(pParse,
        "UPDATE sqlite_temp_schema SET "
            "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "
            "tbl_name = "
              "CASE WHEN tbl_name=%Q COLLATE nocase AND "
              "          sqlite_rename_test(%Q, sql, type, name, 1) "
              "THEN %Q ELSE tbl_name END "
            "WHERE type IN ('view', 'trigger')"
        , zDb, zTabName, zName, zTabName, zDb, zName);
  }
 
  /* If this is a virtual table, invoke the xRename() function if
  ** one is defined. The xRename() callback will modify the names
  ** of any resources used by the v-table implementation (including other
  ** SQLite tables) that are identified by the name of the virtual table.
  */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( pVTab ){
    int i = ++pParse->nMem;
    sqlite3VdbeLoadString(v, i, zName);
    sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
  }
#endif
 
  renameReloadSchema(pParse, iDb);
  renameTestSchema(pParse, zDb, iDb==1);

Referenced by yy_reduce().

◆ sqlite3AnalysisLoad()

SQLITE_PRIVATE int sqlite3AnalysisLoad	(	sqlite3 *	db,
		int	iDB )

Definition at line 109418 of file sqlite3.c.

                                                            {
  analysisInfo sInfo;
  HashElem *i;
  char *zSql;
  int rc = SQLITE_OK;
  Schema *pSchema = db->aDb[iDb].pSchema;
 
  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pBt!=0 );
 
  /* Clear any prior statistics */
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){
    Table *pTab = sqliteHashData(i);
    pTab->tabFlags &= ~TF_HasStat1;
  }
  for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
    pIdx->hasStat1 = 0;
#ifdef SQLITE_ENABLE_STAT4
    sqlite3DeleteIndexSamples(db, pIdx);
    pIdx->aSample = 0;
#endif
  }
 
  /* Load new statistics out of the sqlite_stat1 table */
  sInfo.db = db;
  sInfo.zDatabase = db->aDb[iDb].zDbSName;
  if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)!=0 ){
    zSql = sqlite3MPrintf(db,
        "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
    if( zSql==0 ){
      rc = SQLITE_NOMEM_BKPT;
    }else{
      rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
      sqlite3DbFree(db, zSql);
    }
  }
 
  /* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
    if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx);
  }
 
  /* Load the statistics from the sqlite_stat4 table. */
#ifdef SQLITE_ENABLE_STAT4
  if( rc==SQLITE_OK ){
    DisableLookaside;
    rc = loadStat4(db, sInfo.zDatabase);
    EnableLookaside;
  }
  for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
    sqlite3_free(pIdx->aiRowEst);
    pIdx->aiRowEst = 0;
  }
#endif

References sqlite3::aDb, analysisLoader(), analysisInfo::db, DisableLookaside, EnableLookaside, Index::hasStat1, Schema::idxHash, Db::pBt, Db::pSchema, sqlite3_exec(), sqlite3_free(), sqlite3DbFree(), sqlite3DefaultRowEst(), sqlite3DeleteIndexSamples(), sqlite3FindTable(), sqlite3MPrintf(), sqlite3OomFault(), SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, sqliteHashData, sqliteHashFirst, sqliteHashNext, Table::tabFlags, Schema::tblHash, analysisInfo::zDatabase, and Db::zDbSName.

Referenced by sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3Analyze()

SQLITE_PRIVATE void sqlite3Analyze	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2 )

Definition at line 108955 of file sqlite3.c.

                                                                               {
  sqlite3 *db = pParse->db;
  int iDb;
  int i;
  char *z, *zDb;
  Table *pTab;
  Index *pIdx;
  Token *pTableName;
  Vdbe *v;
 
  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    return;
  }
 
  assert( pName2!=0 || pName1==0 );
  if( pName1==0 ){
    /* Form 1:  Analyze everything */
    for(i=0; i<db->nDb; i++){
      if( i==1 ) continue;  /* Do not analyze the TEMP database */
      analyzeDatabase(pParse, i);
    }
  }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
    /* Analyze the schema named as the argument */
    analyzeDatabase(pParse, iDb);
  }else{
    /* Form 3: Analyze the table or index named as an argument */
    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
    if( iDb>=0 ){
      zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
      z = sqlite3NameFromToken(db, pTableName);
      if( z ){
        if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
          analyzeTable(pParse, pIdx->pTable, pIdx);
        }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
          analyzeTable(pParse, pTab, 0);
        }
        sqlite3DbFree(db, z);
      }

References sqlite3::aDb, analyzeDatabase(), analyzeTable(), Parse::db, Token::n, sqlite3::nDb, sqlite3::nSqlExec, OP_Expire, Index::pTable, sqlite3DbFree(), sqlite3FindDb(), sqlite3FindIndex(), sqlite3GetVdbe(), sqlite3LocateTable(), sqlite3NameFromToken(), sqlite3ReadSchema(), sqlite3TwoPartName(), sqlite3VdbeAddOp0(), SQLITE_OK, and Db::zDbSName.

Referenced by yy_reduce().

◆ sqlite3ApiExit()

SQLITE_PRIVATE int sqlite3ApiExit	(	sqlite3 *	db,
		int	rc )

Definition at line 28121 of file sqlite3.c.

                                                      {
  /* If the db handle must hold the connection handle mutex here.
  ** Otherwise the read (and possible write) of db->mallocFailed
  ** is unsafe, as is the call to sqlite3Error().
  */
  assert( db!=0 );
  assert( sqlite3_mutex_held(db->mutex) );

References apiOomError(), sqlite3::errMask, sqlite3::mallocFailed, sqlite3::mutex, sqlite3_mutex_held(), and SQLITE_IOERR_NOMEM.

Referenced by columnMallocFailure(), createFunctionApi(), createModule(), sqlite3_blob_reopen(), sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_finalize(), sqlite3_reset(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3Prepare16(), and sqlite3Step().

◆ sqlite3ArrayAllocate()

SQLITE_PRIVATE void * sqlite3ArrayAllocate	(	sqlite3 *	db,
		void *	pArray,
		int	szEntry,
		int *	pnEntry,
		int *	pIdx )

Definition at line 114587 of file sqlite3.c.

 {
  char *z;
  sqlite3_int64 n = *pIdx = *pnEntry;
  if( (n & (n-1))==0 ){
    sqlite3_int64 sz = (n==0) ? 1 : 2*n;
    void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
    if( pNew==0 ){
      *pIdx = -1;
      return pArray;
    }
    pArray = pNew;

References sqlite3DbRealloc().

Referenced by sqlite3IdListAppend().

◆ sqlite3AtoF()

SQLITE_PRIVATE int sqlite3AtoF	(	const char *	z,
		double *	pResult,
		int	length,
		u8	enc )

Definition at line 31584 of file sqlite3.c.

                        : 4756)
#endif
SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
#ifndef SQLITE_OMIT_FLOATING_POINT
  int incr;
  const char *zEnd;
  /* sign * significand * (10 ^ (esign * exponent)) */
  int sign = 1;    /* sign of significand */
  i64 s = 0;       /* significand */
  int d = 0;       /* adjust exponent for shifting decimal point */
  int esign = 1;   /* sign of exponent */
  int e = 0;       /* exponent */
  int eValid = 1;  /* True exponent is either not used or is well-formed */
  double result;
  int nDigit = 0;  /* Number of digits processed */
  int eType = 1;   /* 1: pure integer,  2+: fractional  -1 or less: bad UTF16 */
 
  assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
  *pResult = 0.0;   /* Default return value, in case of an error */
  if( length==0 ) return 0;
 
  if( enc==SQLITE_UTF8 ){
    incr = 1;
    zEnd = z + length;
  }else{
    int i;
    incr = 2;
    length &= ~1;
    assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
    testcase( enc==SQLITE_UTF16LE );
    testcase( enc==SQLITE_UTF16BE );
    for(i=3-enc; i<length && z[i]==0; i+=2){}
    if( i<length ) eType = -100;
    zEnd = &z[i^1];
    z += (enc&1);
  }
 
  /* skip leading spaces */
  while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
  if( z>=zEnd ) return 0;
 
  /* get sign of significand */
  if( *z=='-' ){
    sign = -1;
    z+=incr;
  }else if( *z=='+' ){
    z+=incr;
  }
 
  /* copy max significant digits to significand */
  while( z<zEnd && sqlite3Isdigit(*z) ){
    s = s*10 + (*z - '0');
    z+=incr; nDigit++;
    if( s>=((LARGEST_INT64-9)/10) ){
      /* skip non-significant significand digits
      ** (increase exponent by d to shift decimal left) */
      while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; }
    }
  }
  if( z>=zEnd ) goto do_atof_calc;
 
  /* if decimal point is present */
  if( *z=='.' ){
    z+=incr;
    eType++;
    /* copy digits from after decimal to significand
    ** (decrease exponent by d to shift decimal right) */
    while( z<zEnd && sqlite3Isdigit(*z) ){
      if( s<((LARGEST_INT64-9)/10) ){
        s = s*10 + (*z - '0');
        d--;
        nDigit++;
      }
      z+=incr;
    }
  }
  if( z>=zEnd ) goto do_atof_calc;
 
  /* if exponent is present */
  if( *z=='e' || *z=='E' ){
    z+=incr;
    eValid = 0;
    eType++;
 
    /* This branch is needed to avoid a (harmless) buffer overread.  The
    ** special comment alerts the mutation tester that the correct answer
    ** is obtained even if the branch is omitted */
    if( z>=zEnd ) goto do_atof_calc;              /*PREVENTS-HARMLESS-OVERREAD*/
 
    /* get sign of exponent */
    if( *z=='-' ){
      esign = -1;
      z+=incr;
    }else if( *z=='+' ){
      z+=incr;
    }
    /* copy digits to exponent */
    while( z<zEnd && sqlite3Isdigit(*z) ){
      e = e<10000 ? (e*10 + (*z - '0')) : 10000;
      z+=incr;
      eValid = 1;
    }
  }
 
  /* skip trailing spaces */
  while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
 
do_atof_calc:
  /* adjust exponent by d, and update sign */
  e = (e*esign) + d;
  if( e<0 ) {
    esign = -1;
    e *= -1;
  } else {
    esign = 1;
  }
 
  if( s==0 ) {
    /* In the IEEE 754 standard, zero is signed. */
    result = sign<0 ? -(double)0 : (double)0;
  } else {
    /* Attempt to reduce exponent.
    **
    ** Branches that are not required for the correct answer but which only
    ** help to obtain the correct answer faster are marked with special
    ** comments, as a hint to the mutation tester.
    */
    while( e>0 ){                                       /*OPTIMIZATION-IF-TRUE*/
      if( esign>0 ){
        if( s>=(LARGEST_INT64/10) ) break;             /*OPTIMIZATION-IF-FALSE*/
        s *= 10;
      }else{
        if( s%10!=0 ) break;                           /*OPTIMIZATION-IF-FALSE*/
        s /= 10;
      }
      e--;
    }
 
    /* adjust the sign of significand */
    s = sign<0 ? -s : s;
 
    if( e==0 ){                                         /*OPTIMIZATION-IF-TRUE*/
      result = (double)s;
    }else{
      /* attempt to handle extremely small/large numbers better */
      if( e>307 ){                                      /*OPTIMIZATION-IF-TRUE*/
        if( e<342 ){                                    /*OPTIMIZATION-IF-TRUE*/
          LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308);
          if( esign<0 ){
            result = s / scale;
            result /= 1.0e+308;
          }else{
            result = s * scale;
            result *= 1.0e+308;
          }
        }else{ assert( e>=342 );
          if( esign<0 ){
            result = 0.0*s;
          }else{
#ifdef INFINITY
            result = INFINITY*s;
#else
            result = 1e308*1e308*s;  /* Infinity */
#endif
          }
        }
      }else{
        LONGDOUBLE_TYPE scale = sqlite3Pow10(e);
        if( esign<0 ){
          result = s / scale;
        }else{
          result = s * scale;
        }
      }
    }
  }
 
  /* store the result */
  *pResult = result;
 
  /* return true if number and no extra non-whitespace chracters after */
  if( z==zEnd && nDigit>0 && eValid && eType>0 ){
    return eType;
  }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){
    return -1;
  }else{

References eType, LARGEST_INT64, LONGDOUBLE_TYPE, s, sqlite3Atoi64(), sqlite3Isdigit, sqlite3Isspace, sqlite3Pow10(), SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, and testcase.

Referenced by applyNumericAffinity(), codeReal(), computeNumericType(), exprProbability(), isLikeOrGlob(), parseDateOrTime(), parseModifier(), quoteFunc(), sqlite3VdbeMemNumerify(), and sqlite3VdbeRealValue().

◆ sqlite3Atoi()

SQLITE_PRIVATE int sqlite3Atoi ( const char * z )

Definition at line 32040 of file sqlite3.c.

Referenced by decodeIntArray(), getAutoVacuum(), getSafetyLevel(), and sqlite3Pragma().

◆ sqlite3Atoi64()

SQLITE_PRIVATE int sqlite3Atoi64	(	const char *	zNum,
		i64 *	pNum,
		int	length,
		u8	enc )

Definition at line 31849 of file sqlite3.c.

                                                                                 {
  int incr;
  u64 u = 0;
  int neg = 0; /* assume positive */
  int i;
  int c = 0;
  int nonNum = 0;  /* True if input contains UTF16 with high byte non-zero */
  int rc;          /* Baseline return code */
  const char *zStart;
  const char *zEnd = zNum + length;
  assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
  if( enc==SQLITE_UTF8 ){
    incr = 1;
  }else{
    incr = 2;
    assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
    for(i=3-enc; i<length && zNum[i]==0; i+=2){}
    nonNum = i<length;
    zEnd = &zNum[i^1];
    zNum += (enc&1);
  }
  while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
  if( zNum<zEnd ){
    if( *zNum=='-' ){
      neg = 1;
      zNum+=incr;
    }else if( *zNum=='+' ){
      zNum+=incr;
    }
  }
  zStart = zNum;
  while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
  for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
    u = u*10 + c - '0';
  }
  testcase( i==18*incr );
  testcase( i==19*incr );
  testcase( i==20*incr );
  if( u>LARGEST_INT64 ){
    /* This test and assignment is needed only to suppress UB warnings
    ** from clang and -fsanitize=undefined.  This test and assignment make
    ** the code a little larger and slower, and no harm comes from omitting
    ** them, but we must appaise the undefined-behavior pharisees. */
    *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
  }else if( neg ){
    *pNum = -(i64)u;
  }else{
    *pNum = (i64)u;
  }
  rc = 0;
  if( i==0 && zStart==zNum ){    /* No digits */
    rc = -1;
  }else if( nonNum ){            /* UTF16 with high-order bytes non-zero */
    rc = 1;
  }else if( &zNum[i]<zEnd ){     /* Extra bytes at the end */
    int jj = i;
    do{
      if( !sqlite3Isspace(zNum[jj]) ){
        rc = 1;          /* Extra non-space text after the integer */
        break;
      }
      jj += incr;
    }while( &zNum[jj]<zEnd );
  }
  if( i<19*incr ){
    /* Less than 19 digits, so we know that it fits in 64 bits */
    assert( u<=LARGEST_INT64 );
    return rc;
  }else{
    /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
    c = i>19*incr ? 1 : compare2pow63(zNum, incr);
    if( c<0 ){
      /* zNum is less than 9223372036854775808 so it fits */
      assert( u<=LARGEST_INT64 );
      return rc;
    }else{
      *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
      if( c>0 ){
        /* zNum is greater than 9223372036854775808 so it overflows */
        return 2;
      }else{
        /* zNum is exactly 9223372036854775808.  Fits if negative.  The
        ** special case 2 overflow if positive */

References compare2pow63(), LARGEST_INT64, SMALLEST_INT64, sqlite3Isspace, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, and testcase.

Referenced by alsoAnInt(), computeNumericType(), sqlite3AtoF(), sqlite3DecOrHexToI64(), sqlite3ExprAssignVarNumber(), sqlite3VdbeIntValue(), and sqlite3VdbeMemNumerify().

◆ sqlite3Attach()

SQLITE_PRIVATE void sqlite3Attach	(	Parse *	pParse,
		Expr *	p,
		Expr *	pDbname,
		Expr *	pKey )

Definition at line 109906 of file sqlite3.c.

                                                                                    {
  static const FuncDef attach_func = {
    3,                /* nArg */
    SQLITE_UTF8,      /* funcFlags */
    0,                /* pUserData */
    0,                /* pNext */
    attachFunc,       /* xSFunc */
    0,                /* xFinalize */

References attachFunc(), codeAttach(), SQLITE_ATTACH, and SQLITE_UTF8.

Referenced by yy_reduce().

◆ sqlite3AuthCheck()

SQLITE_PRIVATE int sqlite3AuthCheck	(	Parse *	pParse,
		int	code,
		const char *	zArg1,
		const char *	zArg2,
		const char *	zArg3 )

Definition at line 110310 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  int rc;
 
  /* Don't do any authorization checks if the database is initialising
  ** or if the parser is being invoked from within sqlite3_declare_vtab.
  */
  assert( !IN_RENAME_OBJECT || db->xAuth==0 );
  if( db->init.busy || IN_SPECIAL_PARSE ){
    return SQLITE_OK;
  }
 
  if( db->xAuth==0 ){
    return SQLITE_OK;
  }
 
  /* EVIDENCE-OF: R-43249-19882 The third through sixth parameters to the
  ** callback are either NULL pointers or zero-terminated strings that
  ** contain additional details about the action to be authorized.
  **
  ** The following testcase() macros show that any of the 3rd through 6th
  ** parameters can be either NULL or a string. */
  testcase( zArg1==0 );
  testcase( zArg2==0 );
  testcase( zArg3==0 );
  testcase( pParse->zAuthContext==0 );
 
  rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
#ifdef SQLITE_USER_AUTHENTICATION
                 ,db->auth.zAuthUser
#endif
                );
  if( rc==SQLITE_DENY ){
    sqlite3ErrorMsg(pParse, "not authorized");
    pParse->rc = SQLITE_AUTH;

References sqlite3::sqlite3InitInfo::busy, Parse::db, IN_RENAME_OBJECT, IN_SPECIAL_PARSE, sqlite3::init, sqlite3::pAuthArg, Parse::rc, sqlite3ErrorMsg(), SQLITE_AUTH, SQLITE_DENY, SQLITE_IGNORE, SQLITE_OK, sqliteAuthBadReturnCode(), testcase, sqlite3::xAuth, and Parse::zAuthContext.

Referenced by analyzeOneTable(), flattenSubquery(), generateWithRecursiveQuery(), resolveExprStep(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTransaction(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3StartTable(), sqlite3Update(), and sqlite3VtabBeginParse().

◆ sqlite3AuthContextPop()

SQLITE_PRIVATE void sqlite3AuthContextPop ( AuthContext * pContext )

Definition at line 110378 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), and sqlite3Update().

◆ sqlite3AuthContextPush()

SQLITE_PRIVATE void sqlite3AuthContextPush	(	Parse *	pParse,
		AuthContext *	pContext,
		const char *	zContext )

Definition at line 110363 of file sqlite3.c.

References AuthContext::pParse, Parse::zAuthContext, and AuthContext::zAuthContext.

Referenced by sqlite3DeleteFrom(), and sqlite3Update().

◆ sqlite3AuthRead()

SQLITE_PRIVATE void sqlite3AuthRead	(	Parse *	pParse,
		Expr *	pExpr,
		Schema *	pSchema,
		SrcList *	pTabList )

Definition at line 110252 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  Table *pTab = 0;      /* The table being read */
  const char *zCol;     /* Name of the column of the table */
  int iSrc;             /* Index in pTabList->a[] of table being read */
  int iDb;              /* The index of the database the expression refers to */
  int iCol;             /* Index of column in table */
 
  assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
  assert( !IN_RENAME_OBJECT || db->xAuth==0 );
  if( db->xAuth==0 ) return;
  iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
  if( iDb<0 ){
    /* An attempt to read a column out of a subquery or other
    ** temporary table. */
    return;
  }
 
  if( pExpr->op==TK_TRIGGER ){
    pTab = pParse->pTriggerTab;
  }else{
    assert( pTabList );
    for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){
      if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
        pTab = pTabList->a[iSrc].pTab;
        break;
      }
    }
  }
  iCol = pExpr->iColumn;
  if( NEVER(pTab==0) ) return;
 
  if( iCol>=0 ){
    assert( iCol<pTab->nCol );
    zCol = pTab->aCol[iCol].zName;
  }else if( pTab->iPKey>=0 ){
    assert( pTab->iPKey<pTab->nCol );
    zCol = pTab->aCol[pTab->iPKey].zName;
  }else{
    zCol = "ROWID";

References SrcList::a, Table::aCol, ALWAYS, Parse::db, Expr::iColumn, SrcList::SrcList_item::iCursor, IN_RENAME_OBJECT, Table::iPKey, Expr::iTable, Table::nCol, NEVER, Expr::op, SrcList::SrcList_item::pTab, Parse::pTriggerTab, sqlite3AuthReadCol(), sqlite3SchemaToIndex(), SQLITE_IGNORE, TK_COLUMN, TK_NULL, TK_TRIGGER, sqlite3::xAuth, Column::zName, and Table::zName.

Referenced by lookupName().

◆ sqlite3AuthReadCol()

SQLITE_PRIVATE int sqlite3AuthReadCol	(	Parse *	pParse,
		const char *	zTab,
		const char *	zCol,
		int	iDb )

Definition at line 110216 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;          /* Database handle */
  char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
  int rc;                            /* Auth callback return code */
 
  if( db->init.busy ) return SQLITE_OK;
  rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
#ifdef SQLITE_USER_AUTHENTICATION
                 ,db->auth.zAuthUser
#endif
                );
  if( rc==SQLITE_DENY ){
    char *z = sqlite3_mprintf("%s.%s", zTab, zCol);
    if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
    sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);

References sqlite3::aDb, sqlite3::sqlite3InitInfo::busy, Parse::db, sqlite3::init, sqlite3::nDb, sqlite3::pAuthArg, Parse::rc, sqlite3_mprintf(), sqlite3ErrorMsg(), SQLITE_AUTH, SQLITE_DENY, SQLITE_IGNORE, SQLITE_OK, SQLITE_READ, sqliteAuthBadReturnCode(), sqlite3::xAuth, Parse::zAuthContext, and Db::zDbSName.

Referenced by sqlite3AuthRead(), and sqlite3FkCheck().

◆ sqlite3AutoincrementBegin()

SQLITE_PRIVATE void sqlite3AutoincrementBegin ( Parse * pParse )

Definition at line 120937 of file sqlite3.c.

                                                            {
  AutoincInfo *p;            /* Information about an AUTOINCREMENT */
  sqlite3 *db = pParse->db;  /* The database connection */
  Db *pDb;                   /* Database only autoinc table */
  int memId;                 /* Register holding max rowid */
  Vdbe *v = pParse->pVdbe;   /* VDBE under construction */
 
  /* This routine is never called during trigger-generation.  It is
  ** only called from the top-level */
  assert( pParse->pTriggerTab==0 );
  assert( sqlite3IsToplevel(pParse) );
 
  assert( v );   /* We failed long ago if this is not so */
  for(p = pParse->pAinc; p; p = p->pNext){
    static const int iLn = VDBE_OFFSET_LINENO(2);
    static const VdbeOpList autoInc[] = {
      /* 0  */ {OP_Null,    0,  0, 0},
      /* 1  */ {OP_Rewind,  0, 10, 0},
      /* 2  */ {OP_Column,  0,  0, 0},
      /* 3  */ {OP_Ne,      0,  9, 0},
      /* 4  */ {OP_Rowid,   0,  0, 0},
      /* 5  */ {OP_Column,  0,  1, 0},
      /* 6  */ {OP_AddImm,  0,  0, 0},
      /* 7  */ {OP_Copy,    0,  0, 0},
      /* 8  */ {OP_Goto,    0, 11, 0},
      /* 9  */ {OP_Next,    0,  2, 0},
      /* 10 */ {OP_Integer, 0,  0, 0},
      /* 11 */ {OP_Close,   0,  0, 0}
    };
    VdbeOp *aOp;
    pDb = &db->aDb[p->iDb];
    memId = p->regCtr;
    assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
    sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
    sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
    aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
    if( aOp==0 ) break;
    aOp[0].p2 = memId;
    aOp[0].p3 = memId+2;
    aOp[2].p3 = memId;
    aOp[3].p1 = memId-1;
    aOp[3].p3 = memId;
    aOp[3].p5 = SQLITE_JUMPIFNULL;
    aOp[4].p2 = memId+1;
    aOp[5].p3 = memId;
    aOp[6].p1 = memId;

Referenced by sqlite3FinishCoding().

◆ sqlite3AutoincrementEnd()

SQLITE_PRIVATE void sqlite3AutoincrementEnd ( Parse * pParse )

Definition at line 121048 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Update(), and xferOptimization().

◆ sqlite3AutoLoadExtensions()

SQLITE_PRIVATE void sqlite3AutoLoadExtensions ( sqlite3 * db )

Definition at line 125047 of file sqlite3.c.

                                                          {
  u32 i;
  int go = 1;
  int rc;
  sqlite3_loadext_entry xInit;
 
  wsdAutoextInit;
  if( wsdAutoext.nExt==0 ){
    /* Common case: early out without every having to acquire a mutex */
    return;
  }
  for(i=0; go; i++){
    char *zErrmsg;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
#ifdef SQLITE_OMIT_LOAD_EXTENSION
    const sqlite3_api_routines *pThunk = 0;
#else
    const sqlite3_api_routines *pThunk = &sqlite3Apis;
#endif
    sqlite3_mutex_enter(mutex);
    if( i>=wsdAutoext.nExt ){
      xInit = 0;
      go = 0;
    }else{
      xInit = (sqlite3_loadext_entry)wsdAutoext.aExt[i];
    }
    sqlite3_mutex_leave(mutex);
    zErrmsg = 0;
    if( xInit && (rc = xInit(db, &zErrmsg, pThunk))!=0 ){
      sqlite3ErrorWithMsg(db, rc,

References mutex, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3Apis, sqlite3ErrorWithMsg(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, wsdAutoext, and wsdAutoextInit.

Referenced by openDatabase().

◆ sqlite3BackupRestart()

SQLITE_PRIVATE void sqlite3BackupRestart ( sqlite3_backup * pBackup )

Definition at line 75755 of file sqlite3.c.

75761 {

References sqlite3_backup::iNext, BtShared::mutex, Btree::pBt, sqlite3_backup::pNext, sqlite3_backup::pSrc, and sqlite3_mutex_held().

Referenced by pagerUndoCallback(), and sqlite3PagerCommitPhaseOne().

◆ sqlite3BackupUpdate()

SQLITE_PRIVATE void sqlite3BackupUpdate	(	sqlite3_backup *	pBackup,
		Pgno	iPage,
		const u8 *	aData )

Definition at line 75740 of file sqlite3.c.

                         {
        p->rc = rc;
      }

References sqlite3_backup::rc.

Referenced by pager_playback_one_page(), pager_write_pagelist(), and pagerWalFrames().

◆ sqlite3BeginBenignMalloc()

SQLITE_PRIVATE void sqlite3BeginBenignMalloc ( void )

Definition at line 23469 of file sqlite3.c.

23474 {

Referenced by getPageNormal(), hasHotJournal(), pagerUnlockAndRollback(), pcache1ResizeHash(), rehash(), setupLookaside(), sqlite3PagerClose(), sqlite3RollbackAll(), sqlite3VdbeExec(), sqlite3VdbeTransferError(), sqlite3WalDefaultHook(), and vdbeCommit().

◆ sqlite3BeginTransaction()

SQLITE_PRIVATE void sqlite3BeginTransaction	(	Parse *	pParse,
		int	type )

Definition at line 115022 of file sqlite3.c.

                                                                    {
  sqlite3 *db;
  Vdbe *v;
  int i;
 
  assert( pParse!=0 );
  db = pParse->db;
  assert( db!=0 );
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( !v ) return;
  if( type!=TK_DEFERRED ){
    for(i=0; i<db->nDb; i++){

Referenced by yy_reduce().

◆ sqlite3BeginTrigger()

SQLITE_PRIVATE void sqlite3BeginTrigger	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		int	tr_tm,
		int	op,
		IdList *	pColumns,
		SrcList *	pTableName,
		Expr *	pWhen,
		int	isTemp,
		int	noErr )

Definition at line 136467 of file sqlite3.c.

 {
  Trigger *pTrigger = 0;  /* The new trigger */
  Table *pTab;            /* Table that the trigger fires off of */
  char *zName = 0;        /* Name of the trigger */
  sqlite3 *db = pParse->db;  /* The database connection */
  int iDb;                /* The database to store the trigger in */
  Token *pName;           /* The unqualified db name */
  DbFixer sFix;           /* State vector for the DB fixer */
 
  assert( pName1!=0 );   /* pName1->z might be NULL, but not pName1 itself */
  assert( pName2!=0 );
  assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
  assert( op>0 && op<0xff );
  if( isTemp ){
    /* If TEMP was specified, then the trigger name may not be qualified. */
    if( pName2->n>0 ){
      sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
      goto trigger_cleanup;
    }
    iDb = 1;
    pName = pName1;
  }else{
    /* Figure out the db that the trigger will be created in */
    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
    if( iDb<0 ){
      goto trigger_cleanup;
    }
  }
  if( !pTableName || db->mallocFailed ){
    goto trigger_cleanup;
  }
 
  /* A long-standing parser bug is that this syntax was allowed:
  **
  **    CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
  **                                                 ^^^^^^^^
  **
  ** To maintain backwards compatibility, ignore the database
  ** name on pTableName if we are reparsing out of the schema table
  */
  if( db->init.busy && iDb!=1 ){
    sqlite3DbFree(db, pTableName->a[0].zDatabase);
    pTableName->a[0].zDatabase = 0;
  }
 
  /* If the trigger name was unqualified, and the table is a temp table,
  ** then set iDb to 1 to create the trigger in the temporary database.
  ** If sqlite3SrcListLookup() returns 0, indicating the table does not
  ** exist, the error is caught by the block below.
  */
  pTab = sqlite3SrcListLookup(pParse, pTableName);
  if( db->init.busy==0 && pName2->n==0 && pTab
        && pTab->pSchema==db->aDb[1].pSchema ){
    iDb = 1;
  }
 
  /* Ensure the table name matches database name and that the table exists */
  if( db->mallocFailed ) goto trigger_cleanup;
  assert( pTableName->nSrc==1 );
  sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
  if( sqlite3FixSrcList(&sFix, pTableName) ){
    goto trigger_cleanup;
  }
  pTab = sqlite3SrcListLookup(pParse, pTableName);
  if( !pTab ){
    /* The table does not exist. */
    if( db->init.iDb==1 ){
      /* Ticket #3810.
      ** Normally, whenever a table is dropped, all associated triggers are
      ** dropped too.  But if a TEMP trigger is created on a non-TEMP table
      ** and the table is dropped by a different database connection, the
      ** trigger is not visible to the database connection that does the
      ** drop so the trigger cannot be dropped.  This results in an
      ** "orphaned trigger" - a trigger whose associated table is missing.
      */
      db->init.orphanTrigger = 1;
    }
    goto trigger_cleanup;
  }
  if( IsVirtual(pTab) ){
    sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
    goto trigger_cleanup;
  }
 
  /* Check that the trigger name is not reserved and that no trigger of the
  ** specified name exists */
  zName = sqlite3NameFromToken(db, pName);
  if( zName==0 ){
    assert( db->mallocFailed );
    goto trigger_cleanup;
  }
  if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
    goto trigger_cleanup;
  }
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  if( !IN_RENAME_OBJECT ){
    if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
      if( !noErr ){
        sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
      }else{
        assert( !db->init.busy );
        sqlite3CodeVerifySchema(pParse, iDb);
      }
      goto trigger_cleanup;
    }
  }
 
  /* Do not create a trigger on a system table */
  if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
    sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
    goto trigger_cleanup;
  }
 
  /* INSTEAD of triggers are only for views and views only support INSTEAD
  ** of triggers.
  */
  if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
    sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
        (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
    goto trigger_cleanup;
  }
  if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
    sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
        " trigger on table: %S", pTableName, 0);
    goto trigger_cleanup;
  }
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( !IN_RENAME_OBJECT ){
    int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
    int code = SQLITE_CREATE_TRIGGER;
    const char *zDb = db->aDb[iTabDb].zDbSName;
    const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb;
    if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
    if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
      goto trigger_cleanup;
    }
    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
      goto trigger_cleanup;
    }
  }
#endif
 
  /* INSTEAD OF triggers can only appear on views and BEFORE triggers
  ** cannot appear on views.  So we might as well translate every
  ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code
  ** elsewhere.
  */
  if (tr_tm == TK_INSTEAD){
    tr_tm = TK_BEFORE;
  }
 
  /* Build the Trigger object */
  pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
  if( pTrigger==0 ) goto trigger_cleanup;
  pTrigger->zName = zName;
  zName = 0;
  pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
  pTrigger->pSchema = db->aDb[iDb].pSchema;
  pTrigger->pTabSchema = pTab->pSchema;
  pTrigger->op = (u8)op;
  pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
  if( IN_RENAME_OBJECT ){
    sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
    pTrigger->pWhen = pWhen;
    pWhen = 0;
  }else{
    pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
  }
  pTrigger->pColumns = pColumns;
  pColumns = 0;
  assert( pParse->pNewTrigger==0 );
  pParse->pNewTrigger = pTrigger;
 
trigger_cleanup:
  sqlite3DbFree(db, zName);
  sqlite3SrcListDelete(db, pTableName);
  sqlite3IdListDelete(db, pColumns);
  sqlite3ExprDelete(db, pWhen);

References SrcList::a, sqlite3::aDb, sqlite3::sqlite3InitInfo::busy, Parse::db, EXPRDUP_REDUCE, sqlite3::sqlite3InitInfo::iDb, IN_RENAME_OBJECT, sqlite3::init, IsVirtual, sqlite3::mallocFailed, Token::n, SrcList::nSrc, Trigger::op, sqlite3::sqlite3InitInfo::orphanTrigger, Trigger::pColumns, Parse::pNewTrigger, Db::pSchema, Table::pSchema, Trigger::pSchema, Table::pSelect, Trigger::pTabSchema, Trigger::pWhen, SCHEMA_TABLE, sqlite3AuthCheck(), sqlite3CheckObjectName(), sqlite3CodeVerifySchema(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3DeleteTrigger(), sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3FixInit(), sqlite3FixSrcList(), sqlite3HashFind(), sqlite3IdListDelete(), sqlite3NameFromToken(), sqlite3RenameTokenRemap(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3StrNICmp, sqlite3TwoPartName(), SQLITE_CREATE_TEMP_TRIGGER, SQLITE_CREATE_TRIGGER, SQLITE_INSERT, Trigger::table, TK_BEFORE, TK_DELETE, TK_INSERT, TK_INSTEAD, TK_UPDATE, Trigger::tr_tm, TRIGGER_AFTER, TRIGGER_BEFORE, Schema::trigHash, SrcList::SrcList_item::zDatabase, Db::zDbSName, Table::zName, SrcList::SrcList_item::zName, Trigger::zName, and zName.

Referenced by yy_reduce().

◆ sqlite3BeginWriteOperation()

SQLITE_PRIVATE void sqlite3BeginWriteOperation	(	Parse *	pParse,
		int	setStatement,
		int	iDb )

Definition at line 115169 of file sqlite3.c.

References DbMaskSet, Parse::isMultiWrite, sqlite3CodeVerifySchema(), sqlite3ParseToplevel, and Parse::writeMask.

Referenced by analyzeTable(), reindexTable(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), sqlite3Reindex(), sqlite3StartTable(), and sqlite3Update().

◆ sqlite3BenignMallocHooks()

SQLITE_PRIVATE void sqlite3BenignMallocHooks	(	void(*)(void)	xBenignBegin,
		void(*)(void)	xBenignEnd )

Definition at line 23455 of file sqlite3.c.

References wsdHooks, wsdHooksInit, and BenignMallocHooks::xBenignBegin.

◆ sqlite3BinaryCompareCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3BinaryCompareCollSeq	(	Parse *	pParse,
		const Expr *	pLeft,
		const Expr *	pRight )

Definition at line 100041 of file sqlite3.c.

 {
  CollSeq *pColl;
  assert( pLeft );
  if( pLeft->flags & EP_Collate ){
    pColl = sqlite3ExprCollSeq(pParse, pLeft);
  }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
    pColl = sqlite3ExprCollSeq(pParse, pRight);
  }else{
    pColl = sqlite3ExprCollSeq(pParse, pLeft);

References EP_Collate, Expr::flags, and sqlite3ExprCollSeq().

Referenced by sqlite3CodeRhsOfIN(), sqlite3ExprCompareCollSeq(), sqlite3FindInIndex(), and whereRangeVectorLen().

◆ sqlite3BitvecBuiltinTest()

SQLITE_PRIVATE int sqlite3BitvecBuiltinTest	(	int	sz,
		int *	aOp )

Definition at line 48796 of file sqlite3.c.

                                                             {
  Bitvec *pBitvec = 0;
  unsigned char *pV = 0;
  int rc = -1;
  int i, nx, pc, op;
  void *pTmpSpace;
 
  /* Allocate the Bitvec to be tested and a linear array of
  ** bits to act as the reference */
  pBitvec = sqlite3BitvecCreate( sz );
  pV = sqlite3MallocZero( (sz+7)/8 + 1 );
  pTmpSpace = sqlite3_malloc64(BITVEC_SZ);
  if( pBitvec==0 || pV==0 || pTmpSpace==0  ) goto bitvec_end;
 
  /* NULL pBitvec tests */
  sqlite3BitvecSet(0, 1);
  sqlite3BitvecClear(0, 1, pTmpSpace);
 
  /* Run the program */
  pc = 0;
  while( (op = aOp[pc])!=0 ){
    switch( op ){
      case 1:
      case 2:
      case 5: {
        nx = 4;
        i = aOp[pc+2] - 1;
        aOp[pc+2] += aOp[pc+3];
        break;
      }
      case 3:
      case 4:
      default: {
        nx = 2;
        sqlite3_randomness(sizeof(i), &i);
        break;
      }
    }
    if( (--aOp[pc+1]) > 0 ) nx = 0;
    pc += nx;
    i = (i & 0x7fffffff)%sz;
    if( (op & 1)!=0 ){
      SETBIT(pV, (i+1));
      if( op!=5 ){
        if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end;
      }
    }else{
      CLEARBIT(pV, (i+1));
      sqlite3BitvecClear(pBitvec, i+1, pTmpSpace);
    }
  }
 
  /* Test to make sure the linear array exactly matches the
  ** Bitvec object.  Start with the assumption that they do
  ** match (rc==0).  Change rc to non-zero if a discrepancy
  ** is found.
  */
  rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1)
          + sqlite3BitvecTest(pBitvec, 0)
          + (sqlite3BitvecSize(pBitvec) - sz);
  for(i=1; i<=sz; i++){
    if(  (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){
      rc = i;
      break;
    }
  }
 
  /* Free allocated structure */

References BITVEC_SZ, CLEARBIT, SETBIT, sqlite3_free(), sqlite3_malloc64(), sqlite3_randomness(), sqlite3BitvecClear(), sqlite3BitvecCreate(), sqlite3BitvecDestroy(), sqlite3BitvecSet(), sqlite3BitvecSize(), sqlite3BitvecTest(), sqlite3MallocZero(), and TESTBIT.

◆ sqlite3BitvecClear()

SQLITE_PRIVATE void sqlite3BitvecClear	(	Bitvec *	p,
		u32	i,
		void *	pBuf )

Definition at line 48699 of file sqlite3.c.

                                                                    {
  if( p==0 ) return;
  assert( i>0 );
  i--;
  while( p->iDivisor ){
    u32 bin = i/p->iDivisor;
    i = i%p->iDivisor;
    p = p->u.apSub[bin];
    if (!p) {
      return;
    }
  }
  if( p->iSize<=BITVEC_NBIT ){
    p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
  }else{
    unsigned int j;
    u32 *aiValues = pBuf;
    memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
    memset(p->u.aHash, 0, sizeof(p->u.aHash));
    p->nSet = 0;
    for(j=0; j<BITVEC_NINT; j++){
      if( aiValues[j] && aiValues[j]!=(i+1) ){
        u32 h = BITVEC_HASH(aiValues[j]-1);
        p->nSet++;
        while( p->u.aHash[h] ){
          h++;
          if( h>=BITVEC_NINT ) h = 0;

References Bitvec::aBitmap, Bitvec::aHash, Bitvec::apSub, BITVEC_HASH, BITVEC_NBIT, BITVEC_NINT, BITVEC_SZELEM, Bitvec::iDivisor, Bitvec::iSize, Bitvec::nSet, and Bitvec::u.

Referenced by sqlite3BitvecBuiltinTest(), and sqlite3PagerMovepage().

◆ sqlite3BitvecCreate()

SQLITE_PRIVATE Bitvec * sqlite3BitvecCreate ( u32 iSize )

Definition at line 48574 of file sqlite3.c.

                                                     {
  Bitvec *p;
  assert( sizeof(*p)==BITVEC_SZ );

References BITVEC_SZ, Bitvec::iSize, and sqlite3MallocZero().

Referenced by btreeSetHasContent(), pager_open_journal(), pagerOpenSavepoint(), pagerPlaybackSavepoint(), sqlite3BitvecBuiltinTest(), and sqlite3BitvecSet().

◆ sqlite3BitvecDestroy()

SQLITE_PRIVATE void sqlite3BitvecDestroy ( Bitvec * p )

Definition at line 48736 of file sqlite3.c.

                                                   {
  if( p==0 ) return;
  if( p->iDivisor ){
    unsigned int i;

Referenced by pager_end_transaction(), pager_open_journal(), pager_unlock(), pagerPlaybackSavepoint(), releaseAllSavepoints(), sqlite3BitvecBuiltinTest(), and sqlite3PagerSavepoint().

◆ sqlite3BitvecSet()

SQLITE_PRIVATE int sqlite3BitvecSet	(	Bitvec *	p,
		u32	i )

Definition at line 48628 of file sqlite3.c.

                                                     {
  u32 h;
  if( p==0 ) return SQLITE_OK;
  assert( i>0 );
  assert( i<=p->iSize );
  i--;
  while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
    u32 bin = i/p->iDivisor;
    i = i%p->iDivisor;
    if( p->u.apSub[bin]==0 ){
      p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
      if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM_BKPT;
    }
    p = p->u.apSub[bin];
  }
  if( p->iSize<=BITVEC_NBIT ){
    p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
    return SQLITE_OK;
  }
  h = BITVEC_HASH(i++);
  /* if there wasn't a hash collision, and this doesn't */
  /* completely fill the hash, then just add it without */
  /* worring about sub-dividing and re-hashing. */
  if( !p->u.aHash[h] ){
    if (p->nSet<(BITVEC_NINT-1)) {
      goto bitvec_set_end;
    } else {
      goto bitvec_set_rehash;
    }
  }
  /* there was a collision, check to see if it's already */
  /* in hash, if not, try to find a spot for it */
  do {
    if( p->u.aHash[h]==i ) return SQLITE_OK;
    h++;
    if( h>=BITVEC_NINT ) h = 0;
  } while( p->u.aHash[h] );
  /* we didn't find it in the hash.  h points to the first */
  /* available free spot. check to see if this is going to */
  /* make our hash too "full".  */
bitvec_set_rehash:
  if( p->nSet>=BITVEC_MXHASH ){
    unsigned int j;
    int rc;
    u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
    if( aiValues==0 ){
      return SQLITE_NOMEM_BKPT;
    }else{
      memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
      memset(p->u.apSub, 0, sizeof(p->u.apSub));
      p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
      rc = sqlite3BitvecSet(p, i);
      for(j=0; j<BITVEC_NINT; j++){
        if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);
      }
      sqlite3StackFree(0, aiValues);
      return rc;
    }

References Bitvec::aBitmap, Bitvec::aHash, Bitvec::apSub, BITVEC_HASH, BITVEC_MXHASH, BITVEC_NBIT, BITVEC_NINT, BITVEC_NPTR, BITVEC_SZELEM, Bitvec::iDivisor, Bitvec::iSize, Bitvec::nSet, sqlite3BitvecCreate(), sqlite3BitvecSet(), sqlite3StackAllocRaw, sqlite3StackFree, SQLITE_NOMEM_BKPT, SQLITE_OK, and Bitvec::u.

Referenced by addToSavepointBitvecs(), btreeSetHasContent(), getPageNormal(), pager_playback_one_page(), sqlite3BitvecBuiltinTest(), and sqlite3BitvecSet().

◆ sqlite3BitvecSize()

SQLITE_PRIVATE u32 sqlite3BitvecSize ( Bitvec * p )

Definition at line 48751 of file sqlite3.c.

Referenced by btreeGetHasContent(), btreeSetHasContent(), and sqlite3BitvecBuiltinTest().

◆ sqlite3BitvecTest()

SQLITE_PRIVATE int sqlite3BitvecTest	(	Bitvec *	p,
		u32	i )

Definition at line 48612 of file sqlite3.c.

Referenced by pager_playback_one_page(), pagerWriteLargeSector(), and sqlite3BitvecBuiltinTest().

◆ sqlite3BitvecTestNotNull()

SQLITE_PRIVATE int sqlite3BitvecTestNotNull	(	Bitvec *	p,
		u32	i )

Definition at line 48589 of file sqlite3.c.

                                                             {
  assert( p!=0 );
  i--;
  if( i>=p->iSize ) return 0;
  while( p->iDivisor ){
    u32 bin = i/p->iDivisor;
    i = i%p->iDivisor;
    p = p->u.apSub[bin];
    if (!p) {
      return 0;
    }
  }
  if( p->iSize<=BITVEC_NBIT ){
    return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
  } else{
    u32 h = BITVEC_HASH(i++);
    while( p->u.aHash[h] ){

References Bitvec::aBitmap, Bitvec::aHash, Bitvec::apSub, BITVEC_HASH, BITVEC_NBIT, BITVEC_SZELEM, Bitvec::iDivisor, Bitvec::iSize, and Bitvec::u.

Referenced by btreeGetHasContent(), pager_write(), and subjRequiresPage().

◆ sqlite3BlobCompare()

SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare	(	const Mem *	pB1,
		const Mem *	pB2 )

Definition at line 81993 of file sqlite3.c.

                                                                                     {
  int c;
  int n1 = pB1->n;
  int n2 = pB2->n;
 
  /* It is possible to have a Blob value that has some non-zero content
  ** followed by zero content.  But that only comes up for Blobs formed
  ** by the OP_MakeRecord opcode, and such Blobs never get passed into
  ** sqlite3MemCompare(). */
  assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
  assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
 
  if( (pB1->flags|pB2->flags) & MEM_Zero ){
    if( pB1->flags & pB2->flags & MEM_Zero ){
      return pB1->u.nZero - pB2->u.nZero;
    }else if( pB1->flags & MEM_Zero ){
      if( !isAllZero(pB2->z, pB2->n) ) return -1;
      return pB1->u.nZero - n2;
    }else{
      if( !isAllZero(pB1->z, pB1->n) ) return +1;
      return n1 - pB2->u.nZero;

References sqlite3_value::flags, isAllZero(), MEM_Zero, sqlite3_value::n, sqlite3_value::MemValue::nZero, sqlite3_value::u, and sqlite3_value::z.

Referenced by sqlite3MemCompare().

◆ sqlite3BtreeBeginStmt()

SQLITE_PRIVATE int sqlite3BtreeBeginStmt	(	Btree *	p,
		int	iStatement )

Definition at line 68747 of file sqlite3.c.

                                                                  {
  int rc;
  BtShared *pBt = p->pBt;
  sqlite3BtreeEnter(p);
  assert( p->inTrans==TRANS_WRITE );
  assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
  assert( iStatement>0 );
  assert( iStatement>p->db->nSavepoint );
  assert( pBt->inTransaction==TRANS_WRITE );
  /* At the pager level, a statement transaction is a savepoint with
  ** an index greater than all savepoints created explicitly using
  ** SQL statements. It is illegal to open, release or rollback any

References BTS_READ_ONLY, BtShared::btsFlags, Btree::db, Btree::inTrans, BtShared::inTransaction, sqlite3::nSavepoint, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerOpenSavepoint(), and TRANS_WRITE.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeBeginTrans()

SQLITE_PRIVATE int sqlite3BtreeBeginTrans	(	Btree *	p,
		int	wrflag,
		int *	pSchemaVersion )

Definition at line 67850 of file sqlite3.c.

                                                                                    {
  BtShared *pBt = p->pBt;
  Pager *pPager = pBt->pPager;
  int rc = SQLITE_OK;
 
  sqlite3BtreeEnter(p);
  btreeIntegrity(p);
 
  /* If the btree is already in a write-transaction, or it
  ** is already in a read-transaction and a read-transaction
  ** is requested, this is a no-op.
  */
  if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
    goto trans_begun;
  }
  assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
 
  if( (p->db->flags & SQLITE_ResetDatabase)
   && sqlite3PagerIsreadonly(pPager)==0
  ){
    pBt->btsFlags &= ~BTS_READ_ONLY;
  }
 
  /* Write transactions are not possible on a read-only database */
  if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
    rc = SQLITE_READONLY;
    goto trans_begun;
  }
 
#ifndef SQLITE_OMIT_SHARED_CACHE
  {
    sqlite3 *pBlock = 0;
    /* If another database handle has already opened a write transaction
    ** on this shared-btree structure and a second write transaction is
    ** requested, return SQLITE_LOCKED.
    */
    if( (wrflag && pBt->inTransaction==TRANS_WRITE)
     || (pBt->btsFlags & BTS_PENDING)!=0
    ){
      pBlock = pBt->pWriter->db;
    }else if( wrflag>1 ){
      BtLock *pIter;
      for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
        if( pIter->pBtree!=p ){
          pBlock = pIter->pBtree->db;
          break;
        }
      }
    }
    if( pBlock ){
      sqlite3ConnectionBlocked(p->db, pBlock);
      rc = SQLITE_LOCKED_SHAREDCACHE;
      goto trans_begun;
    }
  }
#endif
 
  /* Any read-only or read-write transaction implies a read-lock on
  ** page 1. So if some other shared-cache client already has a write-lock
  ** on page 1, the transaction cannot be opened. */
  rc = querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK);
  if( SQLITE_OK!=rc ) goto trans_begun;
 
  pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
  if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
  do {
    sqlite3PagerWalDb(pPager, p->db);
 
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
    /* If transitioning from no transaction directly to a write transaction,
    ** block for the WRITER lock first if possible. */
    if( pBt->pPage1==0 && wrflag ){
      assert( pBt->inTransaction==TRANS_NONE );
      rc = sqlite3PagerWalWriteLock(pPager, 1);
      if( rc!=SQLITE_BUSY && rc!=SQLITE_OK ) break;
    }
#endif
 
    /* Call lockBtree() until either pBt->pPage1 is populated or
    ** lockBtree() returns something other than SQLITE_OK. lockBtree()
    ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
    ** reading page 1 it discovers that the page-size of the database
    ** file is not pBt->pageSize. In this case lockBtree() will update
    ** pBt->pageSize to the page-size of the file on disk.
    */
    while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
 
    if( rc==SQLITE_OK && wrflag ){
      if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
        rc = SQLITE_READONLY;
      }else{
        rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db));
        if( rc==SQLITE_OK ){
          rc = newDatabase(pBt);
        }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){
          /* if there was no transaction opened when this function was
          ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error
          ** code to SQLITE_BUSY. */
          rc = SQLITE_BUSY;
        }
      }
    }
 
    if( rc!=SQLITE_OK ){
      (void)sqlite3PagerWalWriteLock(pPager, 0);
      unlockBtreeIfUnused(pBt);
    }
  }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
          btreeInvokeBusyHandler(pBt) );
  sqlite3PagerWalDb(pPager, 0);
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  if( rc==SQLITE_BUSY_TIMEOUT ) rc = SQLITE_BUSY;
#endif
 
  if( rc==SQLITE_OK ){
    if( p->inTrans==TRANS_NONE ){
      pBt->nTransaction++;
#ifndef SQLITE_OMIT_SHARED_CACHE
      if( p->sharable ){
        assert( p->lock.pBtree==p && p->lock.iTable==1 );
        p->lock.eLock = READ_LOCK;
        p->lock.pNext = pBt->pLock;
        pBt->pLock = &p->lock;
      }
#endif
    }
    p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
    if( p->inTrans>pBt->inTransaction ){
      pBt->inTransaction = p->inTrans;
    }
    if( wrflag ){
      MemPage *pPage1 = pBt->pPage1;
#ifndef SQLITE_OMIT_SHARED_CACHE
      assert( !pBt->pWriter );
      pBt->pWriter = p;
      pBt->btsFlags &= ~BTS_EXCLUSIVE;
      if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
#endif
 
      /* If the db-size header field is incorrect (as it may be if an old
      ** client has been writing the database file), update it now. Doing
      ** this sooner rather than later means the database size can safely
      ** re-read the database size from page 1 if a savepoint or transaction
      ** rollback occurs within the transaction.
      */
      if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
        rc = sqlite3PagerWrite(pPage1->pDbPage);
        if( rc==SQLITE_OK ){
          put4byte(&pPage1->aData[28], pBt->nPage);
        }
      }
    }
  }
 
trans_begun:
  if( rc==SQLITE_OK ){
    if( pSchemaVersion ){
      *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
    }
    if( wrflag ){
      /* This call makes sure that the pager has the correct number of
      ** open savepoints. If the second parameter is greater than 0 and
      ** the sub-journal is not already open, then it will be opened here.
      */
      rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint);
    }

References MemPage::aData, BtShared::bDoTruncate, btreeIntegrity, btreeInvokeBusyHandler(), BTS_EXCLUSIVE, BTS_INITIALLY_EMPTY, BTS_PENDING, BTS_READ_ONLY, BtShared::btsFlags, Btree::db, BtLock::eLock, sqlite3::flags, get4byte, IfNotOmitAV, Btree::inTrans, BtShared::inTransaction, BtLock::iTable, Btree::lock, lockBtree(), newDatabase(), BtShared::nPage, sqlite3::nSavepoint, BtShared::nTransaction, Btree::pBt, BtLock::pBtree, MemPage::pDbPage, BtShared::pLock, BtLock::pNext, BtShared::pPage1, BtShared::pPager, put4byte, BtShared::pWriter, querySharedCacheTableLock(), READ_LOCK, SCHEMA_ROOT, Btree::sharable, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3ConnectionBlocked, sqlite3PagerBegin(), sqlite3PagerIsreadonly(), sqlite3PagerOpenSavepoint(), sqlite3PagerWalDb, sqlite3PagerWalWriteLock, sqlite3PagerWrite(), sqlite3TempInMemory(), SQLITE_BUSY, SQLITE_BUSY_SNAPSHOT, SQLITE_BUSY_TIMEOUT, SQLITE_LOCKED_SHAREDCACHE, SQLITE_OK, SQLITE_READONLY, SQLITE_ResetDatabase, TRANS_NONE, TRANS_READ, TRANS_WRITE, and unlockBtreeIfUnused().

Referenced by schemaIsValid(), sqlite3BtreeSetVersion(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3BtreeCheckpoint()

SQLITE_PRIVATE int sqlite3BtreeCheckpoint	(	Btree *	p,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt )

Definition at line 74806 of file sqlite3.c.

                                                                                       {
  int rc = SQLITE_OK;
  if( p ){
    BtShared *pBt = p->pBt;
    sqlite3BtreeEnter(p);
    if( pBt->inTransaction!=TRANS_NONE ){
      rc = SQLITE_LOCKED;
    }else{

References Btree::db, BtShared::inTransaction, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerCheckpoint(), SQLITE_LOCKED, SQLITE_OK, and TRANS_NONE.

Referenced by sqlite3Checkpoint().

◆ sqlite3BtreeClearCursor()

SQLITE_PRIVATE void sqlite3BtreeClearCursor ( BtCursor * pCur )

Definition at line 65266 of file sqlite3.c.

Referenced by moveToRoot(), sqlite3BtreeTripAllCursors(), and sqlite3VdbeExec().

◆ sqlite3BtreeClearTable()

SQLITE_PRIVATE int sqlite3BtreeClearTable	(	Btree *	p,
		int	iTable,
		int *	pnChange )

Definition at line 73802 of file sqlite3.c.

                                                                              {
  int rc;
  BtShared *pBt = p->pBt;
  sqlite3BtreeEnter(p);
  assert( p->inTrans==TRANS_WRITE );
 
  rc = saveAllCursors(pBt, (Pgno)iTable, 0);
 
  if( SQLITE_OK==rc ){
    /* Invalidate all incrblob cursors open on table iTable (assuming iTable
    ** is the root of a table b-tree - if it is not, the following call is
    ** a no-op).  */

References clearDatabasePage(), Btree::inTrans, invalidateIncrblobCursors(), Btree::pBt, saveAllCursors(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), SQLITE_OK, and TRANS_WRITE.

Referenced by btreeDropTable(), sqlite3BtreeClearTableOfCursor(), and sqlite3VdbeExec().

◆ sqlite3BtreeClearTableOfCursor()

SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor ( BtCursor * pCur )

Definition at line 73826 of file sqlite3.c.

References BtCursor::pBtree, BtCursor::pgnoRoot, and sqlite3BtreeClearTable().

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeClose()

SQLITE_PRIVATE int sqlite3BtreeClose ( Btree * p )

Definition at line 67186 of file sqlite3.c.

                                              {
  BtShared *pBt = p->pBt;
  BtCursor *pCur;
 
  /* Close all cursors opened via this handle.  */
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  pCur = pBt->pCursor;
  while( pCur ){
    BtCursor *pTmp = pCur;
    pCur = pCur->pNext;
    if( pTmp->pBtree==p ){
      sqlite3BtreeCloseCursor(pTmp);
    }
  }
 
  /* Rollback any active transaction and free the handle structure.
  ** The call to sqlite3BtreeRollback() drops any table-locks held by
  ** this handle.
  */
  sqlite3BtreeRollback(p, SQLITE_OK, 0);
  sqlite3BtreeLeave(p);
 
  /* If there are still other outstanding references to the shared-btree
  ** structure, return now. The remainder of this procedure cleans
  ** up the shared-btree.
  */
  assert( p->wantToLock==0 && p->locked==0 );
  if( !p->sharable || removeFromSharingList(pBt) ){
    /* The pBt is no longer on the sharing list, so we can access
    ** it without having to hold the mutex.
    **
    ** Clean out and delete the BtShared object.
    */
    assert( !pBt->pCursor );
    sqlite3PagerClose(pBt->pPager, p->db);
    if( pBt->xFreeSchema && pBt->pSchema ){
      pBt->xFreeSchema(pBt->pSchema);
    }
    sqlite3DbFree(0, pBt->pSchema);
    freeTempSpace(pBt);
    sqlite3_free(pBt);
  }
 
#ifndef SQLITE_OMIT_SHARED_CACHE
  assert( p->wantToLock==0 );
  assert( p->locked==0 );
  if( p->pPrev ) p->pPrev->pNext = p->pNext;

Referenced by attachFunc(), detachFunc(), invalidateTempStorage(), and sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3BtreeCloseCursor()

SQLITE_PRIVATE int sqlite3BtreeCloseCursor ( BtCursor * pCur )

Definition at line 68969 of file sqlite3.c.

                                                          {
  Btree *pBtree = pCur->pBtree;
  if( pBtree ){
    BtShared *pBt = pCur->pBt;
    sqlite3BtreeEnter(pBtree);
    assert( pBt->pCursor!=0 );
    if( pBt->pCursor==pCur ){
      pBt->pCursor = pCur->pNext;
    }else{
      BtCursor *pPrev = pBt->pCursor;
      do{
        if( pPrev->pNext==pCur ){
          pPrev->pNext = pCur->pNext;
          break;
        }
        pPrev = pPrev->pNext;
      }while( ALWAYS(pPrev) );
    }
    btreeReleaseAllCursorPages(pCur);
    unlockBtreeIfUnused(pBt);
    sqlite3_free(pCur->aOverflow);

◆ sqlite3BtreeCommit()

SQLITE_PRIVATE int sqlite3BtreeCommit ( Btree * p )

Definition at line 68594 of file sqlite3.c.

                                               {
  int rc;
  sqlite3BtreeEnter(p);
  rc = sqlite3BtreeCommitPhaseOne(p, 0);

Referenced by schemaIsValid(), and sqlite3InitOne().

◆ sqlite3BtreeCommitPhaseOne()

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne	(	Btree *	p,
		const char *	zSuperJrnl )

Definition at line 68473 of file sqlite3.c.

                                                                               {
  int rc = SQLITE_OK;
  if( p->inTrans==TRANS_WRITE ){
    BtShared *pBt = p->pBt;
    sqlite3BtreeEnter(p);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum ){
      rc = autoVacuumCommit(pBt);
      if( rc!=SQLITE_OK ){
        sqlite3BtreeLeave(p);
        return rc;
      }
    }
    if( pBt->bDoTruncate ){
      sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
    }

References BtShared::autoVacuum, autoVacuumCommit(), BtShared::bDoTruncate, Btree::inTrans, BtShared::nPage, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerCommitPhaseOne(), sqlite3PagerTruncateImage(), SQLITE_OK, and TRANS_WRITE.

Referenced by vdbeCommit().

◆ sqlite3BtreeCommitPhaseTwo()

SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo	(	Btree *	p,
		int	bCleanup )

Definition at line 68562 of file sqlite3.c.

                                                                     {
 
  if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
  sqlite3BtreeEnter(p);
  btreeIntegrity(p);
 
  /* If the handle has a write-transaction open, commit the shared-btrees
  ** transaction and set the shared state to TRANS_READ.
  */
  if( p->inTrans==TRANS_WRITE ){
    int rc;
    BtShared *pBt = p->pBt;
    assert( pBt->inTransaction==TRANS_WRITE );
    assert( pBt->nTransaction>0 );
    rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
    if( rc!=SQLITE_OK && bCleanup==0 ){
      sqlite3BtreeLeave(p);
      return rc;
    }
    p->iDataVersion--;  /* Compensate for pPager->iDataVersion++; */
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);

References btreeClearHasContent(), btreeEndTransaction(), btreeIntegrity, Btree::iDataVersion, Btree::inTrans, BtShared::inTransaction, BtShared::nTransaction, Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerCommitPhaseTwo(), SQLITE_OK, TRANS_NONE, TRANS_READ, and TRANS_WRITE.

Referenced by vdbeCommit().

◆ sqlite3BtreeConnectionCount()

SQLITE_PRIVATE int sqlite3BtreeConnectionCount ( Btree * p )

Definition at line 75043 of file sqlite3.c.

References BtShared::nRef, Btree::pBt, Btree::sharable, and testcase.

Referenced by sqlite3BtreeOpen().

◆ sqlite3BtreeCopyFile()

SQLITE_PRIVATE int sqlite3BtreeCopyFile	(	Btree *	pTo,
		Btree *	pFrom )

Definition at line 75772 of file sqlite3.c.

                                                                 {
  int rc;
  sqlite3_file *pFd;              /* File descriptor for database pTo */
  sqlite3_backup b;
  sqlite3BtreeEnter(pTo);
  sqlite3BtreeEnter(pFrom);
 
  assert( sqlite3BtreeIsInTrans(pTo) );
  pFd = sqlite3PagerFile(sqlite3BtreePager(pTo));
  if( pFd->pMethods ){
    i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
    rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
    if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
    if( rc ) goto copy_finished;
  }
 
  /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
  ** to 0. This is used by the implementations of sqlite3_backup_step()
  ** and sqlite3_backup_finish() to detect that they are being called
  ** from this function, not directly by the user.
  */
  memset(&b, 0, sizeof(b));
  b.pSrcDb = pFrom->db;
  b.pSrc = pFrom;
  b.pDest = pTo;
  b.iNext = 1;
 
  /* 0x7FFFFFFF is the hard limit for the number of pages in a database
  ** file. By passing this as the number of pages to copy to
  ** sqlite3_backup_step(), we can guarantee that the copy finishes
  ** within a single call (unless an error occurs). The assert() statement
  ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
  ** or an error code.  */
  sqlite3_backup_step(&b, 0x7FFFFFFF);
  assert( b.rc!=SQLITE_OK );
 
  rc = sqlite3_backup_finish(&b);
  if( rc==SQLITE_OK ){
    pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
  }else{
    sqlite3PagerClearCache(sqlite3BtreePager(b.pDest));
  }
 

References BtShared::btsFlags, Btree::db, sqlite3_backup::iNext, Btree::pBt, sqlite3_backup::pDest, sqlite3_file::pMethods, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_backup::rc, sqlite3_backup_finish(), sqlite3_backup_step(), sqlite3BtreeEnter(), sqlite3BtreeGetPageSize(), sqlite3BtreeIsInTrans(), sqlite3BtreeLastPage(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3OsFileControl(), sqlite3PagerClearCache(), sqlite3PagerFile(), SQLITE_FCNTL_OVERWRITE, SQLITE_NOTFOUND, and SQLITE_OK.

◆ sqlite3BtreeCount()

SQLITE_PRIVATE int sqlite3BtreeCount	(	sqlite3 *	db,
		BtCursor *	pCur,
		i64 *	pnEntry )

Definition at line 74026 of file sqlite3.c.

                                                                               {
  i64 nEntry = 0;                      /* Value to return in *pnEntry */
  int rc;                              /* Return code */
 
  rc = moveToRoot(pCur);
  if( rc==SQLITE_EMPTY ){
    *pnEntry = 0;
    return SQLITE_OK;
  }
 
  /* Unless an error occurs, the following loop runs one iteration for each
  ** page in the B-Tree structure (not including overflow pages).
  */
  while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){
    int iIdx;                          /* Index of child node in parent */
    MemPage *pPage;                    /* Current page of the b-tree */
 
    /* If this is a leaf page or the tree is not an int-key tree, then
    ** this page contains countable entries. Increment the entry counter
    ** accordingly.
    */
    pPage = pCur->pPage;
    if( pPage->leaf || !pPage->intKey ){
      nEntry += pPage->nCell;
    }
 
    /* pPage is a leaf node. This loop navigates the cursor so that it
    ** points to the first interior cell that it points to the parent of
    ** the next page in the tree that has not yet been visited. The
    ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
    ** of the page, or to the number of cells in the page if the next page
    ** to visit is the right-child of its parent.
    **
    ** If all pages in the tree have been visited, return SQLITE_OK to the
    ** caller.
    */
    if( pPage->leaf ){
      do {
        if( pCur->iPage==0 ){
          /* All pages of the b-tree have been visited. Return successfully. */
          *pnEntry = nEntry;
          return moveToRoot(pCur);
        }
        moveToParent(pCur);
      }while ( pCur->ix>=pCur->pPage->nCell );
 
      pCur->ix++;
      pPage = pCur->pPage;
    }
 
    /* Descend to the child node of the cell that the cursor currently
    ** points at. This is the right-child if (iIdx==pPage->nCell).
    */
    iIdx = pCur->ix;
    if( iIdx==pPage->nCell ){
      rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
    }else{
      rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));

References MemPage::aData, AtomicLoad, findCell, get4byte, MemPage::hdrOffset, MemPage::intKey, BtCursor::iPage, sqlite3::isInterrupted, BtCursor::ix, MemPage::leaf, moveToChild(), moveToParent(), moveToRoot(), MemPage::nCell, BtCursor::pPage, SQLITE_EMPTY, SQLITE_OK, and sqlite3::u1.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCreateTable()

SQLITE_PRIVATE int sqlite3BtreeCreateTable	(	Btree *	p,
		Pgno *	piTable,
		int	flags )

Definition at line 73723 of file sqlite3.c.

73729 {

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursor()

SQLITE_PRIVATE int sqlite3BtreeCursor	(	Btree *	p,
		Pgno	iTable,
		int	wrFlag,
		struct KeyInfo *	pKeyInfo,
		BtCursor *	pCursor )

Definition at line 68927 of file sqlite3.c.

68939 {

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorHasHint()

SQLITE_PRIVATE int sqlite3BtreeCursorHasHint	(	BtCursor *	pCsr,
		unsigned int	mask )

Definition at line 75014 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorHasMoved()

SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved ( BtCursor * pCur )

Definition at line 65359 of file sqlite3.c.

65365 {

References CURSOR_VALID, EIGHT_BYTE_ALIGNMENT, BtCursor::eState, offsetof, and sqlite3BtreeFakeValidCursor().

Referenced by handleMovedCursor(), and sqlite3VdbeCursorMoveto().

◆ sqlite3BtreeCursorHintFlags()

SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags	(	BtCursor *	pCur,
		unsigned	x )

Definition at line 65423 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorIsValidNN()

SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN ( BtCursor * pCur )

Definition at line 69042 of file sqlite3.c.

69044 {

69045 return pCur && pCur->eState==CURSOR_VALID;

References CURSOR_VALID, and BtCursor::eState.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorPin()

SQLITE_PRIVATE void sqlite3BtreeCursorPin ( BtCursor * pCur )

Definition at line 69064 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorRestore()

SQLITE_PRIVATE int sqlite3BtreeCursorRestore	(	BtCursor *	pCur,
		int *	pDifferentRow )

Definition at line 65391 of file sqlite3.c.

                                                                                {
  int rc;
 
  assert( pCur!=0 );
  assert( pCur->eState!=CURSOR_VALID );
  rc = restoreCursorPosition(pCur);
  if( rc ){
    *pDifferentRow = 1;
    return rc;
  }
  if( pCur->eState!=CURSOR_VALID ){

References CURSOR_VALID, BtCursor::eState, restoreCursorPosition, and SQLITE_OK.

Referenced by handleMovedCursor().

◆ sqlite3BtreeCursorSize()

SQLITE_PRIVATE int sqlite3BtreeCursorSize ( void )

Definition at line 68949 of file sqlite3.c.

References ROUND8.

Referenced by allocateCursor().

◆ sqlite3BtreeCursorUnpin()

SQLITE_PRIVATE void sqlite3BtreeCursorUnpin ( BtCursor * pCur )

Definition at line 69068 of file sqlite3.c.

69070 {

69071 assert( (pCur->curFlags & BTCF_Pinned)==0 );

References BTCF_Pinned, and BtCursor::curFlags.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeCursorZero()

SQLITE_PRIVATE void sqlite3BtreeCursorZero ( BtCursor * p )

Definition at line 68961 of file sqlite3.c.

References BTCURSOR_FIRST_UNINIT, and offsetof.

Referenced by allocateCursor().

◆ sqlite3BtreeDelete()

SQLITE_PRIVATE int sqlite3BtreeDelete	(	BtCursor *	pCur,
		u8	flags )

Definition at line 73394 of file sqlite3.c.

                                                               {
  Btree *p = pCur->pBtree;
  BtShared *pBt = p->pBt;
  int rc;                              /* Return code */
  MemPage *pPage;                      /* Page to delete cell from */
  unsigned char *pCell;                /* Pointer to cell to delete */
  int iCellIdx;                        /* Index of cell to delete */
  int iCellDepth;                      /* Depth of node containing pCell */
  CellInfo info;                       /* Size of the cell being deleted */
  int bSkipnext = 0;                   /* Leaf cursor in SKIPNEXT state */
  u8 bPreserve = flags & BTREE_SAVEPOSITION;  /* Keep cursor valid */
 
  assert( cursorOwnsBtShared(pCur) );
  assert( pBt->inTransaction==TRANS_WRITE );
  assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
  assert( pCur->curFlags & BTCF_WriteFlag );
  assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
  assert( !hasReadConflicts(p, pCur->pgnoRoot) );
  assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
  if( pCur->eState==CURSOR_REQUIRESEEK ){
    rc = btreeRestoreCursorPosition(pCur);
    if( rc ) return rc;
  }
  assert( pCur->eState==CURSOR_VALID );
 
  iCellDepth = pCur->iPage;
  iCellIdx = pCur->ix;
  pPage = pCur->pPage;
  pCell = findCell(pPage, iCellIdx);
  if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ) return SQLITE_CORRUPT;
 
  /* If the bPreserve flag is set to true, then the cursor position must
  ** be preserved following this delete operation. If the current delete
  ** will cause a b-tree rebalance, then this is done by saving the cursor
  ** key and leaving the cursor in CURSOR_REQUIRESEEK state before
  ** returning.
  **
  ** Or, if the current delete will not cause a rebalance, then the cursor
  ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately
  ** before or after the deleted entry. In this case set bSkipnext to true.  */
  if( bPreserve ){
    if( !pPage->leaf
     || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
     || pPage->nCell==1  /* See dbfuzz001.test for a test case */
    ){
      /* A b-tree rebalance will be required after deleting this entry.
      ** Save the cursor key.  */
      rc = saveCursorKey(pCur);
      if( rc ) return rc;
    }else{
      bSkipnext = 1;
    }
  }
 
  /* If the page containing the entry to delete is not a leaf page, move
  ** the cursor to the largest entry in the tree that is smaller than
  ** the entry being deleted. This cell will replace the cell being deleted
  ** from the internal node. The 'previous' entry is used for this instead
  ** of the 'next' entry, as the previous entry is always a part of the
  ** sub-tree headed by the child page of the cell being deleted. This makes
  ** balancing the tree following the delete operation easier.  */
  if( !pPage->leaf ){
    rc = sqlite3BtreePrevious(pCur, 0);
    assert( rc!=SQLITE_DONE );
    if( rc ) return rc;
  }
 
  /* Save the positions of any other cursors open on this table before
  ** making any modifications.  */
  if( pCur->curFlags & BTCF_Multiple ){
    rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
    if( rc ) return rc;
  }
 
  /* If this is a delete operation to remove a row from a table b-tree,
  ** invalidate any incrblob cursors open on the row being deleted.  */
  if( pCur->pKeyInfo==0 ){
    invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
  }
 
  /* Make the page containing the entry to be deleted writable. Then free any
  ** overflow pages associated with the entry and finally remove the cell
  ** itself from within the page.  */
  rc = sqlite3PagerWrite(pPage->pDbPage);
  if( rc ) return rc;
  rc = clearCell(pPage, pCell, &info);
  dropCell(pPage, iCellIdx, info.nSize, &rc);
  if( rc ) return rc;
 
  /* If the cell deleted was not located on a leaf page, then the cursor
  ** is currently pointing to the largest entry in the sub-tree headed
  ** by the child-page of the cell that was just deleted from an internal
  ** node. The cell from the leaf node needs to be moved to the internal
  ** node to replace the deleted cell.  */
  if( !pPage->leaf ){
    MemPage *pLeaf = pCur->pPage;
    int nCell;
    Pgno n;
    unsigned char *pTmp;
 
    if( pLeaf->nFree<0 ){
      rc = btreeComputeFreeSpace(pLeaf);
      if( rc ) return rc;
    }
    if( iCellDepth<pCur->iPage-1 ){
      n = pCur->apPage[iCellDepth+1]->pgno;
    }else{
      n = pCur->pPage->pgno;
    }
    pCell = findCell(pLeaf, pLeaf->nCell-1);
    if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
    nCell = pLeaf->xCellSize(pLeaf, pCell);
    assert( MX_CELL_SIZE(pBt) >= nCell );
    pTmp = pBt->pTmpSpace;
    assert( pTmp!=0 );
    rc = sqlite3PagerWrite(pLeaf->pDbPage);
    if( rc==SQLITE_OK ){
      insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
    }
    dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
    if( rc ) return rc;
  }
 
  /* Balance the tree. If the entry deleted was located on a leaf page,
  ** then the cursor still points to that page. In this case the first
  ** call to balance() repairs the tree, and the if(...) condition is
  ** never true.
  **
  ** Otherwise, if the entry deleted was on an internal node page, then
  ** pCur is pointing to the leaf page from which a cell was removed to
  ** replace the cell deleted from the internal node. This is slightly
  ** tricky as the leaf node may be underfull, and the internal node may
  ** be either under or overfull. In this case run the balancing algorithm
  ** on the leaf node first. If the balance proceeds far enough up the
  ** tree that we can be sure that any problem in the internal node has
  ** been corrected, so be it. Otherwise, after balancing the leaf node,
  ** walk the cursor up the tree to the internal node and balance it as
  ** well.  */
  rc = balance(pCur);
  if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
    releasePageNotNull(pCur->pPage);
    pCur->iPage--;
    while( pCur->iPage>iCellDepth ){
      releasePage(pCur->apPage[pCur->iPage--]);
    }
    pCur->pPage = pCur->apPage[pCur->iPage];
    rc = balance(pCur);
  }
 
  if( rc==SQLITE_OK ){
    if( bSkipnext ){
      assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
      assert( pPage==pCur->pPage || CORRUPT_DB );
      assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell );
      pCur->eState = CURSOR_SKIPNEXT;
      if( iCellIdx>=pPage->nCell ){
        pCur->skipNext = -1;
        pCur->ix = pPage->nCell-1;
      }else{
        pCur->skipNext = 1;
      }
    }else{
      rc = moveToRoot(pCur);
      if( bPreserve ){
        btreeReleaseAllCursorPages(pCur);
        pCur->eState = CURSOR_REQUIRESEEK;

References BtCursor::apPage, balance(), BTCF_Multiple, BTCF_WriteFlag, BTREE_AUXDELETE, BTREE_SAVEPOSITION, btreeComputeFreeSpace(), btreeReleaseAllCursorPages(), btreeRestoreCursorPosition(), BTS_READ_ONLY, BtShared::btsFlags, cellSizePtr(), clearCell(), CORRUPT_DB, BtCursor::curFlags, CURSOR_REQUIRESEEK, CURSOR_SKIPNEXT, CURSOR_VALID, dropCell(), BtCursor::eState, findCell, BtCursor::info, insertCell(), BtShared::inTransaction, invalidateIncrblobCursors(), BtCursor::iPage, BtCursor::ix, MemPage::leaf, moveToRoot(), MX_CELL_SIZE, MemPage::nCell, MemPage::nFree, CellInfo::nKey, CellInfo::nSize, Btree::pBt, BtCursor::pBtree, MemPage::pDbPage, MemPage::pgno, BtCursor::pgnoRoot, BtCursor::pKeyInfo, BtCursor::pPage, BtShared::pTmpSpace, releasePage(), releasePageNotNull(), saveAllCursors(), saveCursorKey(), BtCursor::skipNext, sqlite3BtreePrevious(), sqlite3PagerWrite(), SQLITE_CORRUPT, SQLITE_CORRUPT_BKPT, SQLITE_DONE, SQLITE_EMPTY, SQLITE_OK, TRANS_WRITE, BtShared::usableSize, and MemPage::xCellSize.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeDropTable()

SQLITE_PRIVATE int sqlite3BtreeDropTable	(	Btree *	p,
		int	iTable,
		int *	piMoved )

Definition at line 73935 of file sqlite3.c.

73941 {

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeEnter()

SQLITE_PRIVATE void sqlite3BtreeEnter ( Btree * p )

Definition at line 64237 of file sqlite3.c.

                                               {
  /* Some basic sanity checking on the Btree.  The list of Btrees
  ** connected by pNext and pPrev should be in sorted order by
  ** Btree.pBt value. All elements of the list should belong to
  ** the same connection. Only shared Btrees are on the list. */
  assert( p->pNext==0 || p->pNext->pBt>p->pBt );
  assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
  assert( p->pNext==0 || p->pNext->db==p->db );
  assert( p->pPrev==0 || p->pPrev->db==p->db );
  assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
 
  /* Check for locking consistency */
  assert( !p->locked || p->wantToLock>0 );
  assert( p->sharable || p->wantToLock==0 );
 
  /* We should already hold a lock on the database connection */
  assert( sqlite3_mutex_held(p->db->mutex) );
 
  /* Unless the database is sharable and unlocked, then BtShared.db
  ** should already be set correctly. */
  assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );

References btreeLockCarefully(), Btree::db, BtShared::db, Btree::locked, sqlite3::mutex, Btree::pBt, Btree::pNext, Btree::pPrev, Btree::sharable, sqlite3_mutex_held(), and Btree::wantToLock.

Referenced by attachFunc(), doWalCallbacks(), openDatabase(), sqlite3BtreeBeginStmt(), sqlite3BtreeBeginTrans(), sqlite3BtreeCheckpoint(), sqlite3BtreeClearTable(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeCopyFile(), sqlite3BtreeGetMeta(), sqlite3BtreeGetRequestedReserve(), sqlite3BtreeIncrVacuum(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeLeaveCursor(), sqlite3BtreeLockTable(), sqlite3BtreeMaxPageCount(), sqlite3BtreeNewDb(), sqlite3BtreeRollback(), sqlite3BtreeSavepoint(), sqlite3BtreeSchema(), sqlite3BtreeSchemaLocked(), sqlite3BtreeSecureDelete(), sqlite3BtreeSetAutoVacuum(), sqlite3BtreeSetCacheSize(), sqlite3BtreeSetPagerFlags(), sqlite3BtreeSetPageSize(), sqlite3BtreeSetSpillSize(), sqlite3BtreeTripAllCursors(), sqlite3InitOne(), sqlite3VdbeEnter(), and vdbeCommit().

◆ sqlite3BtreeEnterAll()

SQLITE_PRIVATE void sqlite3BtreeEnterAll ( sqlite3 * db )

Definition at line 64366 of file sqlite3.c.

Referenced by attachFunc(), renameColumnFunc(), renameTableFunc(), sqlite3_table_column_metadata(), and sqlite3RollbackAll().

◆ sqlite3BtreeEnterCursor()

SQLITE_PRIVATE void sqlite3BtreeEnterCursor ( BtCursor * pCur )

Definition at line 64464 of file sqlite3.c.

◆ sqlite3BtreeEof()

SQLITE_PRIVATE int sqlite3BtreeEof ( BtCursor * pCur )

Definition at line 70139 of file sqlite3.c.

70145 {

References CURSOR_VALID, and BtCursor::eState.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeFakeValidCursor()

SQLITE_PRIVATE BtCursor * sqlite3BtreeFakeValidCursor ( void )

Definition at line 65372 of file sqlite3.c.

References CURSOR_VALID, and offsetof.

Referenced by sqlite3BtreeCursorHasMoved(), and sqlite3VdbeExec().

◆ sqlite3BtreeFirst()

SQLITE_PRIVATE int sqlite3BtreeFirst	(	BtCursor *	pCur,
		int *	pRes )

Definition at line 69796 of file sqlite3.c.

                                                               {
  int rc;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  rc = moveToRoot(pCur);
  if( rc==SQLITE_OK ){
    assert( pCur->pPage->nCell>0 );
    *pRes = 0;
    rc = moveToLeftmost(pCur);
  }else if( rc==SQLITE_EMPTY ){

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeGetAutoVacuum()

SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum ( Btree * p )

Definition at line 67482 of file sqlite3.c.

                                                      {
#ifdef SQLITE_OMIT_AUTOVACUUM
  return BTREE_AUTOVACUUM_NONE;
#else
  int rc;
  sqlite3BtreeEnter(p);
  rc = (
    (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
    (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:

Referenced by sqlite3Pragma().

◆ sqlite3BtreeGetFilename()

SQLITE_PRIVATE const char * sqlite3BtreeGetFilename ( Btree * p )

Definition at line 74771 of file sqlite3.c.

References Btree::pBt, BtShared::pPager, and sqlite3PagerFilename().

Referenced by sqlite3Pragma(), and vdbeCommit().

◆ sqlite3BtreeGetJournalname()

SQLITE_PRIVATE const char * sqlite3BtreeGetJournalname ( Btree * p )

Definition at line 74784 of file sqlite3.c.

References Btree::pBt, and BtShared::pPager.

Referenced by vdbeCommit().

◆ sqlite3BtreeGetMeta()

SQLITE_PRIVATE void sqlite3BtreeGetMeta	(	Btree *	pBtree,
		int	idx,
		u32 *	pValue )

Definition at line 73964 of file sqlite3.c.

                                                                      {
  BtShared *pBt = p->pBt;
 
  sqlite3BtreeEnter(p);
  assert( p->inTrans>TRANS_NONE );
  assert( SQLITE_OK==querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK) );
  assert( pBt->pPage1 );
  assert( idx>=0 && idx<=15 );
 
  if( idx==BTREE_DATA_VERSION ){
    *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
  }else{
    *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
  }
 
  /* If auto-vacuum is disabled in this build and this is an auto-vacuum
  ** database, mark the database as read-only.  */
#ifdef SQLITE_OMIT_AUTOVACUUM
  if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){

References MemPage::aData, BTREE_DATA_VERSION, BTREE_LARGEST_ROOT_PAGE, BTS_READ_ONLY, BtShared::btsFlags, get4byte, Btree::iDataVersion, Btree::inTrans, Btree::pBt, BtShared::pPage1, BtShared::pPager, querySharedCacheTableLock(), READ_LOCK, SCHEMA_ROOT, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerDataVersion(), SQLITE_OK, and TRANS_NONE.

Referenced by btreeCreateTable(), btreeDropTable(), schemaIsValid(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3BtreeGetPageSize()

SQLITE_PRIVATE int sqlite3BtreeGetPageSize ( Btree * p )

Definition at line 67365 of file sqlite3.c.

Referenced by backupOnePage(), sqlite3BtreeCopyFile(), sqlite3Pragma(), and sqlite3VdbeSorterInit().

◆ sqlite3BtreeGetRequestedReserve()

SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve ( Btree * p )

Definition at line 67396 of file sqlite3.c.

67402 {

67403 int n1, n2;

References BtShared::nReserveWanted, Btree::pBt, sqlite3BtreeEnter(), sqlite3BtreeGetReserveNoMutex(), and sqlite3BtreeLeave().

◆ sqlite3BtreeGetReserveNoMutex()

SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex ( Btree * p )

Definition at line 67380 of file sqlite3.c.

References BtShared::mutex, BtShared::pageSize, Btree::pBt, sqlite3_mutex_held(), and BtShared::usableSize.

Referenced by backupOnePage(), and sqlite3BtreeGetRequestedReserve().

◆ sqlite3BtreeIncrblobCursor()

SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor ( BtCursor * pCur )

Definition at line 74968 of file sqlite3.c.

Referenced by blobSeekToRow().

◆ sqlite3BtreeIncrVacuum()

SQLITE_PRIVATE int sqlite3BtreeIncrVacuum ( Btree * p )

Definition at line 68352 of file sqlite3.c.

                                                   {
  int rc;
  BtShared *pBt = p->pBt;
 
  sqlite3BtreeEnter(p);
  assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
  if( !pBt->autoVacuum ){
    rc = SQLITE_DONE;
  }else{
    Pgno nOrig = btreePagecount(pBt);
    Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
    Pgno nFin = finalDbSize(pBt, nOrig, nFree);
 
    if( nOrig<nFin || nFree>=nOrig ){
      rc = SQLITE_CORRUPT_BKPT;
    }else if( nFree>0 ){
      rc = saveAllCursors(pBt, 0, 0);
      if( rc==SQLITE_OK ){
        invalidateAllOverflowCache(pBt);
        rc = incrVacuumStep(pBt, nFin, nOrig, 0);
      }
      if( rc==SQLITE_OK ){
        rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
        put4byte(&pBt->pPage1->aData[28], pBt->nPage);
      }
    }else{

References MemPage::aData, BtShared::autoVacuum, btreePagecount(), finalDbSize(), get4byte, incrVacuumStep(), Btree::inTrans, BtShared::inTransaction, invalidateAllOverflowCache(), BtShared::nPage, Btree::pBt, MemPage::pDbPage, BtShared::pPage1, put4byte, saveAllCursors(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_DONE, SQLITE_OK, and TRANS_WRITE.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeInsert()

SQLITE_PRIVATE int sqlite3BtreeInsert	(	BtCursor *	pCur,
		const BtreePayload *	pPayload,
		int	flags,
		int	seekResult )

Definition at line 73109 of file sqlite3.c.

 {
  int rc;
  int loc = seekResult;          /* -1: before desired location  +1: after */
  int szNew = 0;
  int idx;
  MemPage *pPage;
  Btree *p = pCur->pBtree;
  BtShared *pBt = p->pBt;
  unsigned char *oldCell;
  unsigned char *newCell = 0;
 
  assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags );
 
  if( pCur->eState==CURSOR_FAULT ){
    assert( pCur->skipNext!=SQLITE_OK );
    return pCur->skipNext;
  }
 
  assert( cursorOwnsBtShared(pCur) );
  assert( (pCur->curFlags & BTCF_WriteFlag)!=0
              && pBt->inTransaction==TRANS_WRITE
              && (pBt->btsFlags & BTS_READ_ONLY)==0 );
  assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
 
  /* Assert that the caller has been consistent. If this cursor was opened
  ** expecting an index b-tree, then the caller should be inserting blob
  ** keys with no associated data. If the cursor was opened expecting an
  ** intkey table, the caller should be inserting integer keys with a
  ** blob of associated data.  */
  assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
 
  /* Save the positions of any other cursors open on this table.
  **
  ** In some cases, the call to btreeMoveto() below is a no-op. For
  ** example, when inserting data into a table with auto-generated integer
  ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
  ** integer key to use. It then calls this function to actually insert the
  ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
  ** that the cursor is already where it needs to be and returns without
  ** doing any work. To avoid thwarting these optimizations, it is important
  ** not to clear the cursor here.
  */
  if( pCur->curFlags & BTCF_Multiple ){
    rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
    if( rc ) return rc;
  }
 
  if( pCur->pKeyInfo==0 ){
    assert( pX->pKey==0 );
    /* If this is an insert into a table b-tree, invalidate any incrblob
    ** cursors open on the row being replaced */
    invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
 
    /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
    ** to a row with the same key as the new entry being inserted.
    */
#ifdef SQLITE_DEBUG
    if( flags & BTREE_SAVEPOSITION ){
      assert( pCur->curFlags & BTCF_ValidNKey );
      assert( pX->nKey==pCur->info.nKey );
      assert( loc==0 );
    }
#endif
 
    /* On the other hand, BTREE_SAVEPOSITION==0 does not imply
    ** that the cursor is not pointing to a row to be overwritten.
    ** So do a complete check.
    */
    if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
      /* The cursor is pointing to the entry that is to be
      ** overwritten */
      assert( pX->nData>=0 && pX->nZero>=0 );
      if( pCur->info.nSize!=0
       && pCur->info.nPayload==(u32)pX->nData+pX->nZero
      ){
        /* New entry is the same size as the old.  Do an overwrite */
        return btreeOverwriteCell(pCur, pX);
      }
      assert( loc==0 );
    }else if( loc==0 ){
      /* The cursor is *not* pointing to the cell to be overwritten, nor
      ** to an adjacent cell.  Move the cursor so that it is pointing either
      ** to the cell to be overwritten or an adjacent cell.
      */
      rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
      if( rc ) return rc;
    }
  }else{
    /* This is an index or a WITHOUT ROWID table */
 
    /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
    ** to a row with the same key as the new entry being inserted.
    */
    assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 );
 
    /* If the cursor is not already pointing either to the cell to be
    ** overwritten, or if a new cell is being inserted, if the cursor is
    ** not pointing to an immediately adjacent cell, then move the cursor
    ** so that it does.
    */
    if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){
      if( pX->nMem ){
        UnpackedRecord r;
        r.pKeyInfo = pCur->pKeyInfo;
        r.aMem = pX->aMem;
        r.nField = pX->nMem;
        r.default_rc = 0;
        r.errCode = 0;
        r.r1 = 0;
        r.r2 = 0;
        r.eqSeen = 0;
        rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
      }else{
        rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
      }
      if( rc ) return rc;
    }
 
    /* If the cursor is currently pointing to an entry to be overwritten
    ** and the new content is the same as as the old, then use the
    ** overwrite optimization.
    */
    if( loc==0 ){
      getCellInfo(pCur);
      if( pCur->info.nKey==pX->nKey ){
        BtreePayload x2;
        x2.pData = pX->pKey;
        x2.nData = pX->nKey;
        x2.nZero = 0;
        return btreeOverwriteCell(pCur, &x2);
      }
    }
 
  }
  assert( pCur->eState==CURSOR_VALID
       || (pCur->eState==CURSOR_INVALID && loc)
       || CORRUPT_DB );
 
  pPage = pCur->pPage;
  assert( pPage->intKey || pX->nKey>=0 );
  assert( pPage->leaf || !pPage->intKey );
  if( pPage->nFree<0 ){
    if( pCur->eState>CURSOR_INVALID ){
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      rc = btreeComputeFreeSpace(pPage);
    }
    if( rc ) return rc;
  }
 
  TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
          pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
          loc==0 ? "overwrite" : "new entry"));
  assert( pPage->isInit );
  newCell = pBt->pTmpSpace;
  assert( newCell!=0 );
  rc = fillInCell(pPage, newCell, pX, &szNew);
  if( rc ) goto end_insert;
  assert( szNew==pPage->xCellSize(pPage, newCell) );
  assert( szNew <= MX_CELL_SIZE(pBt) );
  idx = pCur->ix;
  if( loc==0 ){
    CellInfo info;
    assert( idx<pPage->nCell );
    rc = sqlite3PagerWrite(pPage->pDbPage);
    if( rc ){
      goto end_insert;
    }
    oldCell = findCell(pPage, idx);
    if( !pPage->leaf ){
      memcpy(newCell, oldCell, 4);
    }
    rc = clearCell(pPage, oldCell, &info);
    testcase( pCur->curFlags & BTCF_ValidOvfl );
    invalidateOverflowCache(pCur);
    if( info.nSize==szNew && info.nLocal==info.nPayload
     && (!ISAUTOVACUUM || szNew<pPage->minLocal)
    ){
      /* Overwrite the old cell with the new if they are the same size.
      ** We could also try to do this if the old cell is smaller, then add
      ** the leftover space to the free list.  But experiments show that
      ** doing that is no faster then skipping this optimization and just
      ** calling dropCell() and insertCell().
      **
      ** This optimization cannot be used on an autovacuum database if the
      ** new entry uses overflow pages, as the insertCell() call below is
      ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry.  */
      assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
      if( oldCell < pPage->aData+pPage->hdrOffset+10 ){
        return SQLITE_CORRUPT_BKPT;
      }
      if( oldCell+szNew > pPage->aDataEnd ){
        return SQLITE_CORRUPT_BKPT;
      }
      memcpy(oldCell, newCell, szNew);
      return SQLITE_OK;
    }
    dropCell(pPage, idx, info.nSize, &rc);
    if( rc ) goto end_insert;
  }else if( loc<0 && pPage->nCell>0 ){
    assert( pPage->leaf );
    idx = ++pCur->ix;
    pCur->curFlags &= ~BTCF_ValidNKey;
  }else{
    assert( pPage->leaf );
  }
  insertCell(pPage, idx, newCell, szNew, 0, 0, &rc);
  assert( pPage->nOverflow==0 || rc==SQLITE_OK );
  assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
 
  /* If no error has occurred and pPage has an overflow cell, call balance()
  ** to redistribute the cells within the tree. Since balance() may move
  ** the cursor, zero the BtCursor.info.nSize and BTCF_ValidNKey
  ** variables.
  **
  ** Previous versions of SQLite called moveToRoot() to move the cursor
  ** back to the root page as balance() used to invalidate the contents
  ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that,
  ** set the cursor state to "invalid". This makes common insert operations
  ** slightly faster.
  **
  ** There is a subtle but important optimization here too. When inserting
  ** multiple records into an intkey b-tree using a single cursor (as can
  ** happen while processing an "INSERT INTO ... SELECT" statement), it
  ** is advantageous to leave the cursor pointing to the last entry in
  ** the b-tree if possible. If the cursor is left pointing to the last
  ** entry in the table, and the next row inserted has an integer key
  ** larger than the largest existing key, it is possible to insert the
  ** row without seeking the cursor. This can be a big performance boost.
  */
  pCur->info.nSize = 0;
  if( pPage->nOverflow ){
    assert( rc==SQLITE_OK );
    pCur->curFlags &= ~(BTCF_ValidNKey);
    rc = balance(pCur);
 
    /* Must make sure nOverflow is reset to zero even if the balance()
    ** fails. Internal data structure corruption will result otherwise.
    ** Also, set the cursor state to invalid. This stops saveCursorPosition()
    ** from trying to save the current position of the cursor.  */
    pCur->pPage->nOverflow = 0;
    pCur->eState = CURSOR_INVALID;
    if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){
      btreeReleaseAllCursorPages(pCur);
      if( pCur->pKeyInfo ){
        assert( pCur->pKey==0 );
        pCur->pKey = sqlite3Malloc( pX->nKey );
        if( pCur->pKey==0 ){
          rc = SQLITE_NOMEM;
        }else{
          memcpy(pCur->pKey, pX->pKey, pX->nKey);
        }
      }
      pCur->eState = CURSOR_REQUIRESEEK;
      pCur->nKey = pX->nKey;
    }

References MemPage::aDataEnd, BtreePayload::aMem, UnpackedRecord::aMem, balance(), BTCF_Multiple, BTCF_ValidNKey, BTCF_ValidOvfl, BTCF_WriteFlag, BTREE_APPEND, BTREE_SAVEPOSITION, btreeComputeFreeSpace(), btreeMoveto(), btreeOverwriteCell(), btreeReleaseAllCursorPages(), BTS_READ_ONLY, BtShared::btsFlags, clearCell(), CORRUPT_DB, BtCursor::curFlags, CURSOR_FAULT, CURSOR_INVALID, CURSOR_REQUIRESEEK, CURSOR_VALID, UnpackedRecord::default_rc, dropCell(), UnpackedRecord::eqSeen, UnpackedRecord::errCode, BtCursor::eState, fillInCell(), findCell, getCellInfo(), MemPage::hdrOffset, BtCursor::info, insertCell(), MemPage::intKey, BtShared::inTransaction, invalidateIncrblobCursors(), invalidateOverflowCache, BtCursor::iPage, ISAUTOVACUUM, MemPage::isInit, BtCursor::ix, MemPage::leaf, MX_CELL_SIZE, MemPage::nCell, BtreePayload::nData, UnpackedRecord::nField, MemPage::nFree, BtreePayload::nKey, CellInfo::nKey, BtCursor::nKey, CellInfo::nLocal, BtreePayload::nMem, MemPage::nOverflow, CellInfo::nPayload, CellInfo::nSize, BtreePayload::nZero, Btree::pBt, BtCursor::pBtree, BtreePayload::pData, MemPage::pDbPage, MemPage::pgno, BtCursor::pgnoRoot, BtreePayload::pKey, BtCursor::pKey, UnpackedRecord::pKeyInfo, BtCursor::pKeyInfo, BtCursor::pPage, BtShared::pTmpSpace, UnpackedRecord::r1, UnpackedRecord::r2, saveAllCursors(), BtCursor::skipNext, sqlite3BtreeMovetoUnpacked(), sqlite3Malloc(), sqlite3PagerWrite(), SQLITE_CORRUPT_BKPT, SQLITE_NOMEM, SQLITE_OK, testcase, TRACE, TRANS_WRITE, and MemPage::xCellSize.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeIntegerKey()

SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey ( BtCursor * pCur )

Definition at line 69053 of file sqlite3.c.

69059 {

References BtCursor::curIntKey, CURSOR_VALID, BtCursor::eState, and getCellInfo().

Referenced by saveCursorKey(), and sqlite3VdbeExec().

◆ sqlite3BtreeIntegrityCheck()

SQLITE_PRIVATE char * sqlite3BtreeIntegrityCheck	(	sqlite3 *	db,
		Btree *	p,
		Pgno *	aRoot,
		int	nRoot,
		int	mxErr,
		int *	pnErr )

Definition at line 74616 of file sqlite3.c.

 {
  Pgno i;
  IntegrityCk sCheck;
  BtShared *pBt = p->pBt;
  u64 savedDbFlags = pBt->db->flags;
  char zErr[100];
  int bPartial = 0;            /* True if not checking all btrees */
  int bCkFreelist = 1;         /* True to scan the freelist */
  VVA_ONLY( int nRef );
  assert( nRoot>0 );
 
  /* aRoot[0]==0 means this is a partial check */
  if( aRoot[0]==0 ){
    assert( nRoot>1 );
    bPartial = 1;
    if( aRoot[1]!=1 ) bCkFreelist = 0;
  }
 
  sqlite3BtreeEnter(p);
  assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
  VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
  assert( nRef>=0 );
  sCheck.db = db;
  sCheck.pBt = pBt;
  sCheck.pPager = pBt->pPager;
  sCheck.nPage = btreePagecount(sCheck.pBt);
  sCheck.mxErr = mxErr;
  sCheck.nErr = 0;
  sCheck.bOomFault = 0;
  sCheck.zPfx = 0;
  sCheck.v1 = 0;
  sCheck.v2 = 0;
  sCheck.aPgRef = 0;
  sCheck.heap = 0;
  sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH);
  sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL;
  if( sCheck.nPage==0 ){
    goto integrity_ck_cleanup;
  }
 
  sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1);
  if( !sCheck.aPgRef ){
    sCheck.bOomFault = 1;
    goto integrity_ck_cleanup;
  }
  sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
  if( sCheck.heap==0 ){
    sCheck.bOomFault = 1;
    goto integrity_ck_cleanup;
  }
 
  i = PENDING_BYTE_PAGE(pBt);
  if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i);
 
  /* Check the integrity of the freelist
  */
  if( bCkFreelist ){
    sCheck.zPfx = "Main freelist: ";
    checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
              get4byte(&pBt->pPage1->aData[36]));
    sCheck.zPfx = 0;
  }
 
  /* Check all the tables.
  */
#ifndef SQLITE_OMIT_AUTOVACUUM
  if( !bPartial ){
    if( pBt->autoVacuum ){
      Pgno mx = 0;
      Pgno mxInHdr;
      for(i=0; (int)i<nRoot; i++) if( mx<aRoot[i] ) mx = aRoot[i];
      mxInHdr = get4byte(&pBt->pPage1->aData[52]);
      if( mx!=mxInHdr ){
        checkAppendMsg(&sCheck,
          "max rootpage (%d) disagrees with header (%d)",
          mx, mxInHdr
        );
      }
    }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){
      checkAppendMsg(&sCheck,
        "incremental_vacuum enabled with a max rootpage of zero"
      );
    }
  }
#endif
  testcase( pBt->db->flags & SQLITE_CellSizeCk );
  pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
  for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
    i64 notUsed;
    if( aRoot[i]==0 ) continue;
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum && aRoot[i]>1 && !bPartial ){
      checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0);
    }
#endif
    checkTreePage(&sCheck, aRoot[i], &notUsed, LARGEST_INT64);
  }
  pBt->db->flags = savedDbFlags;
 
  /* Make sure every page in the file is referenced
  */
  if( !bPartial ){
    for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
#ifdef SQLITE_OMIT_AUTOVACUUM
      if( getPageReferenced(&sCheck, i)==0 ){
        checkAppendMsg(&sCheck, "Page %d is never used", i);
      }
#else
      /* If the database supports auto-vacuum, make sure no tables contain
      ** references to pointer-map pages.
      */
      if( getPageReferenced(&sCheck, i)==0 &&
         (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
        checkAppendMsg(&sCheck, "Page %d is never used", i);
      }
      if( getPageReferenced(&sCheck, i)!=0 &&
         (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
        checkAppendMsg(&sCheck, "Pointer map page %d is referenced", i);
      }
#endif
    }
  }
 
  /* Clean  up and report errors.
  */
integrity_ck_cleanup:
  sqlite3PageFree(sCheck.heap);
  sqlite3_free(sCheck.aPgRef);
  if( sCheck.bOomFault ){
    sqlite3_str_reset(&sCheck.errMsg);
    sCheck.nErr++;
  }
  *pnErr = sCheck.nErr;

References MemPage::aData, IntegrityCk::aPgRef, BtShared::autoVacuum, IntegrityCk::bOomFault, btreePagecount(), checkAppendMsg(), checkList(), checkPtrmap(), checkTreePage(), BtShared::db, IntegrityCk::db, IntegrityCk::errMsg, sqlite3::flags, get4byte, getPageReferenced(), IntegrityCk::heap, Btree::inTrans, BtShared::inTransaction, LARGEST_INT64, IntegrityCk::mxErr, IntegrityCk::nErr, IntegrityCk::nPage, BtShared::pageSize, Btree::pBt, IntegrityCk::pBt, PENDING_BYTE_PAGE, BtShared::pPage1, BtShared::pPager, IntegrityCk::pPager, sqlite3_str::printfFlags, PTRMAP_PAGENO, PTRMAP_ROOTPAGE, setPageReferenced(), sqlite3_free(), sqlite3_str_reset(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3MallocZero(), sqlite3PageFree(), sqlite3PageMalloc(), sqlite3StrAccumFinish(), sqlite3StrAccumInit(), SQLITE_CellSizeCk, SQLITE_MAX_LENGTH, SQLITE_PRINTF_INTERNAL, testcase, TRANS_NONE, IntegrityCk::v1, IntegrityCk::v2, VVA_ONLY, and IntegrityCk::zPfx.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeIsInBackup()

SQLITE_PRIVATE int sqlite3BtreeIsInBackup ( Btree * p )

Definition at line 74831 of file sqlite3.c.

                                                      {
  assert( p );
  assert( sqlite3_mutex_held(p->db->mutex) );
  return p->inTrans!=TRANS_NONE;
}

References Btree::db, Btree::inTrans, sqlite3::mutex, sqlite3_mutex_held(), and TRANS_NONE.

Referenced by detachFunc().

◆ sqlite3BtreeIsInReadTrans()

SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans ( Btree * p )

Definition at line 74825 of file sqlite3.c.

Referenced by checkReadTransaction(), detachFunc(), invalidateTempStorage(), schemaIsValid(), and sqlite3InitOne().

◆ sqlite3BtreeIsInTrans()

SQLITE_PRIVATE int sqlite3BtreeIsInTrans ( Btree * p )

Definition at line 74792 of file sqlite3.c.

Referenced by sqlite3BtreeCopyFile(), sqlite3RollbackAll(), sqlite3VdbeExec(), and vdbeCommit().

◆ sqlite3BtreeIsReadonly()

SQLITE_PRIVATE int sqlite3BtreeIsReadonly ( Btree * pBt )

Definition at line 75021 of file sqlite3.c.

◆ sqlite3BtreeLast()

SQLITE_PRIVATE int sqlite3BtreeLast	(	BtCursor *	pCur,
		int *	pRes )

Definition at line 69818 of file sqlite3.c.

                                                              {
  int rc;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
 
  /* If the cursor already points to the last entry, this is a no-op. */
  if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
#ifdef SQLITE_DEBUG
    /* This block serves to assert() that the cursor really does point
    ** to the last entry in the b-tree. */
    int ii;
    for(ii=0; ii<pCur->iPage; ii++){
      assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
    }
    assert( pCur->ix==pCur->pPage->nCell-1 );
    assert( pCur->pPage->leaf );
#endif
    *pRes = 0;
    return SQLITE_OK;
  }
 
  rc = moveToRoot(pCur);
  if( rc==SQLITE_OK ){
    assert( pCur->eState==CURSOR_VALID );
    *pRes = 0;
    rc = moveToRightmost(pCur);
    if( rc==SQLITE_OK ){
      pCur->curFlags |= BTCF_AtLast;
    }else{
      pCur->curFlags &= ~BTCF_AtLast;
    }
  }else if( rc==SQLITE_EMPTY ){

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeLastPage()

SQLITE_PRIVATE Pgno sqlite3BtreeLastPage ( Btree * p )

Definition at line 66621 of file sqlite3.c.

66624 {

References BtShared::nPage.

Referenced by backupOnePage(), sqlite3BtreeCopyFile(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3BtreeLeave()

SQLITE_PRIVATE void sqlite3BtreeLeave ( Btree * p )

Definition at line 64309 of file sqlite3.c.

                                               {
  assert( sqlite3_mutex_held(p->db->mutex) );
  if( p->sharable ){
    assert( p->wantToLock>0 );

Referenced by attachFunc(), doWalCallbacks(), openDatabase(), sqlite3BtreeBeginStmt(), sqlite3BtreeBeginTrans(), sqlite3BtreeCheckpoint(), sqlite3BtreeClearTable(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeCopyFile(), sqlite3BtreeGetMeta(), sqlite3BtreeGetRequestedReserve(), sqlite3BtreeIncrVacuum(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeLockTable(), sqlite3BtreeMaxPageCount(), sqlite3BtreeNewDb(), sqlite3BtreeRollback(), sqlite3BtreeSavepoint(), sqlite3BtreeSchema(), sqlite3BtreeSchemaLocked(), sqlite3BtreeSecureDelete(), sqlite3BtreeSetAutoVacuum(), sqlite3BtreeSetCacheSize(), sqlite3BtreeSetPagerFlags(), sqlite3BtreeSetPageSize(), sqlite3BtreeSetSpillSize(), sqlite3BtreeTripAllCursors(), sqlite3InitOne(), sqlite3VdbeLeave(), and vdbeCommit().

◆ sqlite3BtreeLeaveAll()

SQLITE_PRIVATE void sqlite3BtreeLeaveAll ( sqlite3 * db )

Definition at line 64378 of file sqlite3.c.

64379 {

64380 p = db->aDb[i].pBt;

Referenced by attachFunc(), renameColumnFunc(), renameTableFunc(), sqlite3_table_column_metadata(), and sqlite3RollbackAll().

◆ sqlite3BtreeLeaveCursor()

SQLITE_PRIVATE void sqlite3BtreeLeaveCursor ( BtCursor * pCur )

Definition at line 64468 of file sqlite3.c.

64470 {

References BtCursor::pBtree, and sqlite3BtreeEnter().

◆ sqlite3BtreeLockTable()

SQLITE_PRIVATE int sqlite3BtreeLockTable	(	Btree *	pBtree,
		int	iTab,
		u8	isWriteLock )

Definition at line 74890 of file sqlite3.c.

                                                                            {
  int rc = SQLITE_OK;
  assert( p->inTrans!=TRANS_NONE );
  if( p->sharable ){
    u8 lockType = READ_LOCK + isWriteLock;
    assert( READ_LOCK+1==WRITE_LOCK );
    assert( isWriteLock==0 || isWriteLock==1 );
 
    sqlite3BtreeEnter(p);
    rc = querySharedCacheTableLock(p, iTab, lockType);
    if( rc==SQLITE_OK ){

References Btree::inTrans, querySharedCacheTableLock(), READ_LOCK, setSharedCacheTableLock(), Btree::sharable, sqlite3BtreeEnter(), sqlite3BtreeLeave(), SQLITE_OK, TRANS_NONE, and WRITE_LOCK.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeMaxPageCount()

SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount	(	Btree *	p,
		Pgno	mxPage )

Definition at line 67411 of file sqlite3.c.

67417 {

References Btree::pBt, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), and sqlite3PagerMaxPageCount().

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeMaxRecordSize()

SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize ( BtCursor * pCur )

Definition at line 69116 of file sqlite3.c.

References CURSOR_VALID, BtCursor::eState, BtShared::nPage, BtShared::pageSize, and BtCursor::pBt.

Referenced by sqlite3VdbeMemFromBtree().

◆ sqlite3BtreeMovetoUnpacked()

SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked	(	BtCursor *	pCur,
		UnpackedRecord *	pUnKey,
		i64	intKey,
		int	bias,
		int *	pRes )

Definition at line 69888 of file sqlite3.c.

 {
  int rc;
  RecordCompare xRecordCompare;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( pRes );
  assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
  assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
 
  /* If the cursor is already positioned at the point we are trying
  ** to move to, then just return without doing any work */
  if( pIdxKey==0
   && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
  ){
    if( pCur->info.nKey==intKey ){
      *pRes = 0;
      return SQLITE_OK;
    }
    if( pCur->info.nKey<intKey ){
      if( (pCur->curFlags & BTCF_AtLast)!=0 ){
        *pRes = -1;
        return SQLITE_OK;
      }
      /* If the requested key is one more than the previous key, then
      ** try to get there using sqlite3BtreeNext() rather than a full
      ** binary search.  This is an optimization only.  The correct answer
      ** is still obtained without this case, only a little more slowely */
      if( pCur->info.nKey+1==intKey ){
        *pRes = 0;
        rc = sqlite3BtreeNext(pCur, 0);
        if( rc==SQLITE_OK ){
          getCellInfo(pCur);
          if( pCur->info.nKey==intKey ){
            return SQLITE_OK;
          }
        }else if( rc==SQLITE_DONE ){
          rc = SQLITE_OK;
        }else{
          return rc;
        }
      }
    }
  }
 
  if( pIdxKey ){
    xRecordCompare = sqlite3VdbeFindCompare(pIdxKey);
    pIdxKey->errCode = 0;
    assert( pIdxKey->default_rc==1
         || pIdxKey->default_rc==0
         || pIdxKey->default_rc==-1
    );
  }else{
    xRecordCompare = 0; /* All keys are integers */
  }
 
  rc = moveToRoot(pCur);
  if( rc ){
    if( rc==SQLITE_EMPTY ){
      assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
      *pRes = -1;
      return SQLITE_OK;
    }
    return rc;
  }
  assert( pCur->pPage );
  assert( pCur->pPage->isInit );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->pPage->nCell > 0 );
  assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
  assert( pCur->curIntKey || pIdxKey );
  for(;;){
    int lwr, upr, idx, c;
    Pgno chldPg;
    MemPage *pPage = pCur->pPage;
    u8 *pCell;                          /* Pointer to current cell in pPage */
 
    /* pPage->nCell must be greater than zero. If this is the root-page
    ** the cursor would have been INVALID above and this for(;;) loop
    ** not run. If this is not the root-page, then the moveToChild() routine
    ** would have already detected db corruption. Similarly, pPage must
    ** be the right kind (index or table) of b-tree page. Otherwise
    ** a moveToChild() or moveToRoot() call would have detected corruption.  */
    assert( pPage->nCell>0 );
    assert( pPage->intKey==(pIdxKey==0) );
    lwr = 0;
    upr = pPage->nCell-1;
    assert( biasRight==0 || biasRight==1 );
    idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */
    pCur->ix = (u16)idx;
    if( xRecordCompare==0 ){
      for(;;){
        i64 nCellKey;
        pCell = findCellPastPtr(pPage, idx);
        if( pPage->intKeyLeaf ){
          while( 0x80 <= *(pCell++) ){
            if( pCell>=pPage->aDataEnd ){
              return SQLITE_CORRUPT_PAGE(pPage);
            }
          }
        }
        getVarint(pCell, (u64*)&nCellKey);
        if( nCellKey<intKey ){
          lwr = idx+1;
          if( lwr>upr ){ c = -1; break; }
        }else if( nCellKey>intKey ){
          upr = idx-1;
          if( lwr>upr ){ c = +1; break; }
        }else{
          assert( nCellKey==intKey );
          pCur->ix = (u16)idx;
          if( !pPage->leaf ){
            lwr = idx;
            goto moveto_next_layer;
          }else{
            pCur->curFlags |= BTCF_ValidNKey;
            pCur->info.nKey = nCellKey;
            pCur->info.nSize = 0;
            *pRes = 0;
            return SQLITE_OK;
          }
        }
        assert( lwr+upr>=0 );
        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2; */
      }
    }else{
      for(;;){
        int nCell;  /* Size of the pCell cell in bytes */
        pCell = findCellPastPtr(pPage, idx);
 
        /* The maximum supported page-size is 65536 bytes. This means that
        ** the maximum number of record bytes stored on an index B-Tree
        ** page is less than 16384 bytes and may be stored as a 2-byte
        ** varint. This information is used to attempt to avoid parsing
        ** the entire cell by checking for the cases where the record is
        ** stored entirely within the b-tree page by inspecting the first
        ** 2 bytes of the cell.
        */
        nCell = pCell[0];
        if( nCell<=pPage->max1bytePayload ){
          /* This branch runs if the record-size field of the cell is a
          ** single byte varint and the record fits entirely on the main
          ** b-tree page.  */
          testcase( pCell+nCell+1==pPage->aDataEnd );
          c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
        }else if( !(pCell[1] & 0x80)
          && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
        ){
          /* The record-size field is a 2 byte varint and the record
          ** fits entirely on the main b-tree page.  */
          testcase( pCell+nCell+2==pPage->aDataEnd );
          c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
        }else{
          /* The record flows over onto one or more overflow pages. In
          ** this case the whole cell needs to be parsed, a buffer allocated
          ** and accessPayload() used to retrieve the record into the
          ** buffer before VdbeRecordCompare() can be called.
          **
          ** If the record is corrupt, the xRecordCompare routine may read
          ** up to two varints past the end of the buffer. An extra 18
          ** bytes of padding is allocated at the end of the buffer in
          ** case this happens.  */
          void *pCellKey;
          u8 * const pCellBody = pCell - pPage->childPtrSize;
          const int nOverrun = 18;  /* Size of the overrun padding */
          pPage->xParseCell(pPage, pCellBody, &pCur->info);
          nCell = (int)pCur->info.nKey;
          testcase( nCell<0 );   /* True if key size is 2^32 or more */
          testcase( nCell==0 );  /* Invalid key size:  0x80 0x80 0x00 */
          testcase( nCell==1 );  /* Invalid key size:  0x80 0x80 0x01 */
          testcase( nCell==2 );  /* Minimum legal index key size */
          if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
            rc = SQLITE_CORRUPT_PAGE(pPage);
            goto moveto_finish;
          }
          pCellKey = sqlite3Malloc( nCell+nOverrun );
          if( pCellKey==0 ){
            rc = SQLITE_NOMEM_BKPT;
            goto moveto_finish;
          }
          pCur->ix = (u16)idx;
          rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
          memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */
          pCur->curFlags &= ~BTCF_ValidOvfl;
          if( rc ){
            sqlite3_free(pCellKey);
            goto moveto_finish;
          }
          c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
          sqlite3_free(pCellKey);
        }
        assert(
            (pIdxKey->errCode!=SQLITE_CORRUPT || c==0)
         && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
        );
        if( c<0 ){
          lwr = idx+1;
        }else if( c>0 ){
          upr = idx-1;
        }else{
          assert( c==0 );
          *pRes = 0;
          rc = SQLITE_OK;
          pCur->ix = (u16)idx;
          if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT;
          goto moveto_finish;
        }
        if( lwr>upr ) break;
        assert( lwr+upr>=0 );
        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2 */
      }
    }
    assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
    assert( pPage->isInit );
    if( pPage->leaf ){
      assert( pCur->ix<pCur->pPage->nCell );
      pCur->ix = (u16)idx;
      *pRes = c;
      rc = SQLITE_OK;
      goto moveto_finish;
    }
moveto_next_layer:
    if( lwr>=pPage->nCell ){
      chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    }else{
      chldPg = get4byte(findCell(pPage, lwr));
    }
    pCur->ix = (u16)lwr;
    rc = moveToChild(pCur, chldPg);
    if( rc ) break;

References accessPayload(), MemPage::aData, MemPage::aDataEnd, BtCursor::apPage, BTCF_AtLast, BTCF_ValidNKey, BTCF_ValidOvfl, MemPage::childPtrSize, BtCursor::curFlags, BtCursor::curIntKey, CURSOR_VALID, Btree::db, UnpackedRecord::default_rc, UnpackedRecord::errCode, BtCursor::eState, findCell, findCellPastPtr, get4byte, getCellInfo(), getVarint, MemPage::hdrOffset, BtCursor::info, MemPage::intKey, MemPage::intKeyLeaf, BtCursor::iPage, MemPage::isInit, BtCursor::ix, MemPage::leaf, sqlite3::mallocFailed, MemPage::maxLocal, moveToChild(), moveToRoot(), sqlite3::mutex, MemPage::nCell, CellInfo::nKey, BtShared::nPage, CellInfo::nSize, BtCursor::pBt, BtCursor::pBtree, BtCursor::pgnoRoot, BtCursor::pKeyInfo, BtCursor::pPage, sqlite3_free(), sqlite3_mutex_held(), sqlite3BtreeNext(), sqlite3Malloc(), sqlite3VdbeFindCompare(), sqlite3VdbeRecordCompare(), SQLITE_CORRUPT, SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_PAGE, SQLITE_DONE, SQLITE_EMPTY, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, BtShared::usableSize, and MemPage::xParseCell.

Referenced by btreeMoveto(), sqlite3BtreeInsert(), sqlite3VdbeExec(), and sqlite3VdbeFinishMoveto().

◆ sqlite3BtreeNewDb()

SQLITE_PRIVATE int sqlite3BtreeNewDb ( Btree * p )

Definition at line 67806 of file sqlite3.c.

67812 {

67813 int rc;

References newDatabase(), BtShared::nPage, Btree::pBt, sqlite3BtreeEnter(), and sqlite3BtreeLeave().

◆ sqlite3BtreeNext()

SQLITE_PRIVATE int sqlite3BtreeNext	(	BtCursor *	pCur,
		int	flags )

Definition at line 70262 of file sqlite3.c.

                   {
    return SQLITE_OK;
  }else{
    return moveToLeftmost(pCur);
  }
}
SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
  MemPage *pPage;
  UNUSED_PARAMETER( flags );  /* Used in COMDB2 but not native SQLite */
  assert( cursorOwnsBtShared(pCur) );
  assert( flags==0 || flags==1 );
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
  if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
  pPage = pCur->pPage;
  if( (++pCur->ix)>=pPage->nCell ){
    pCur->ix--;
    return btreeNext(pCur);
  }

References SQLITE_OK.

Referenced by btreeNext(), resolveP2Values(), sqlite3BtreeMovetoUnpacked(), and sqlite3VdbeExec().

◆ sqlite3BtreeOpen()

SQLITE_PRIVATE int sqlite3BtreeOpen	(	sqlite3_vfs *	pVfs,
		const char *	zFilename,
		sqlite3 *	db,
		Btree **	ppBtree,
		int	flags,
		int	vfsFlags )

Definition at line 66809 of file sqlite3.c.

 {
  BtShared *pBt = 0;             /* Shared part of btree structure */
  Btree *p;                      /* Handle to return */
  sqlite3_mutex *mutexOpen = 0;  /* Prevents a race condition. Ticket #3537 */
  int rc = SQLITE_OK;            /* Result code from this function */
  u8 nReserve;                   /* Byte of unused space on each page */
  unsigned char zDbHeader[100];  /* Database header content */
 
  /* True if opening an ephemeral, temporary database */
  const int isTempDb = zFilename==0 || zFilename[0]==0;
 
  /* Set the variable isMemdb to true for an in-memory database, or
  ** false for a file-based database.
  */
#ifdef SQLITE_OMIT_MEMORYDB
  const int isMemdb = 0;
#else
  const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0)
                       || (isTempDb && sqlite3TempInMemory(db))
                       || (vfsFlags & SQLITE_OPEN_MEMORY)!=0;
#endif
 
  assert( db!=0 );
  assert( pVfs!=0 );
  assert( sqlite3_mutex_held(db->mutex) );
  assert( (flags&0xff)==flags );   /* flags fit in 8 bits */
 
  /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */
  assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
 
  /* A BTREE_SINGLE database is always a temporary and/or ephemeral */
  assert( (flags & BTREE_SINGLE)==0 || isTempDb );
 
  if( isMemdb ){
    flags |= BTREE_MEMORY;
  }
  if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){
    vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
  }
  p = sqlite3MallocZero(sizeof(Btree));
  if( !p ){
    return SQLITE_NOMEM_BKPT;
  }
  p->inTrans = TRANS_NONE;
  p->db = db;
#ifndef SQLITE_OMIT_SHARED_CACHE
  p->lock.pBtree = p;
  p->lock.iTable = 1;
#endif
 
#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
  /*
  ** If this Btree is a candidate for shared cache, try to find an
  ** existing BtShared object that we can share with
  */
  if( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){
    if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){
      int nFilename = sqlite3Strlen30(zFilename)+1;
      int nFullPathname = pVfs->mxPathname+1;
      char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename));
      MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
 
      p->sharable = 1;
      if( !zFullPathname ){
        sqlite3_free(p);
        return SQLITE_NOMEM_BKPT;
      }
      if( isMemdb ){
        memcpy(zFullPathname, zFilename, nFilename);
      }else{
        rc = sqlite3OsFullPathname(pVfs, zFilename,
                                   nFullPathname, zFullPathname);
        if( rc ){
          if( rc==SQLITE_OK_SYMLINK ){
            rc = SQLITE_OK;
          }else{
            sqlite3_free(zFullPathname);
            sqlite3_free(p);
            return rc;
          }
        }
      }
#if SQLITE_THREADSAFE
      mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN);
      sqlite3_mutex_enter(mutexOpen);
      mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
      sqlite3_mutex_enter(mutexShared);
#endif
      for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
        assert( pBt->nRef>0 );
        if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
                 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
          int iDb;
          for(iDb=db->nDb-1; iDb>=0; iDb--){
            Btree *pExisting = db->aDb[iDb].pBt;
            if( pExisting && pExisting->pBt==pBt ){
              sqlite3_mutex_leave(mutexShared);
              sqlite3_mutex_leave(mutexOpen);
              sqlite3_free(zFullPathname);
              sqlite3_free(p);
              return SQLITE_CONSTRAINT;
            }
          }
          p->pBt = pBt;
          pBt->nRef++;
          break;
        }
      }
      sqlite3_mutex_leave(mutexShared);
      sqlite3_free(zFullPathname);
    }
#ifdef SQLITE_DEBUG
    else{
      /* In debug mode, we mark all persistent databases as sharable
      ** even when they are not.  This exercises the locking code and
      ** gives more opportunity for asserts(sqlite3_mutex_held())
      ** statements to find locking problems.
      */
      p->sharable = 1;
    }
#endif
  }
#endif
  if( pBt==0 ){
    /*
    ** The following asserts make sure that structures used by the btree are
    ** the right size.  This is to guard against size changes that result
    ** when compiling on a different architecture.
    */
    assert( sizeof(i64)==8 );
    assert( sizeof(u64)==8 );
    assert( sizeof(u32)==4 );
    assert( sizeof(u16)==2 );
    assert( sizeof(Pgno)==4 );
 
    pBt = sqlite3MallocZero( sizeof(*pBt) );
    if( pBt==0 ){
      rc = SQLITE_NOMEM_BKPT;
      goto btree_open_out;
    }
    rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
                          sizeof(MemPage), flags, vfsFlags, pageReinit);
    if( rc==SQLITE_OK ){
      sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
      rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
    }
    if( rc!=SQLITE_OK ){
      goto btree_open_out;
    }
    pBt->openFlags = (u8)flags;
    pBt->db = db;
    sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
    p->pBt = pBt;
 
    pBt->pCursor = 0;
    pBt->pPage1 = 0;
    if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
#if defined(SQLITE_SECURE_DELETE)
    pBt->btsFlags |= BTS_SECURE_DELETE;
#elif defined(SQLITE_FAST_SECURE_DELETE)
    pBt->btsFlags |= BTS_OVERWRITE;
#endif
    /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
    ** determined by the 2-byte integer located at an offset of 16 bytes from
    ** the beginning of the database file. */
    pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
    if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
         || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
      pBt->pageSize = 0;
#ifndef SQLITE_OMIT_AUTOVACUUM
      /* If the magic name ":memory:" will create an in-memory database, then
      ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
      ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
      ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
      ** regular file-name. In this case the auto-vacuum applies as per normal.
      */
      if( zFilename && !isMemdb ){
        pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
        pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
      }
#endif
      nReserve = 0;
    }else{
      /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is
      ** determined by the one-byte unsigned integer found at an offset of 20
      ** into the database file header. */
      nReserve = zDbHeader[20];
      pBt->btsFlags |= BTS_PAGESIZE_FIXED;
#ifndef SQLITE_OMIT_AUTOVACUUM
      pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
      pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
#endif
    }
    rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
    if( rc ) goto btree_open_out;
    pBt->usableSize = pBt->pageSize - nReserve;
    assert( (pBt->pageSize & 7)==0 );  /* 8-byte alignment of pageSize */
 
#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
    /* Add the new BtShared object to the linked list sharable BtShareds.
    */
    pBt->nRef = 1;
    if( p->sharable ){
      MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
      MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);)
      if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){
        pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
        if( pBt->mutex==0 ){
          rc = SQLITE_NOMEM_BKPT;
          goto btree_open_out;
        }
      }
      sqlite3_mutex_enter(mutexShared);
      pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
      GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
      sqlite3_mutex_leave(mutexShared);
    }
#endif
  }
 
#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
  /* If the new Btree uses a sharable pBtShared, then link the new
  ** Btree into the list of all sharable Btrees for the same connection.
  ** The list is kept in ascending order by pBt address.
  */
  if( p->sharable ){
    int i;
    Btree *pSib;
    for(i=0; i<db->nDb; i++){
      if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
        while( pSib->pPrev ){ pSib = pSib->pPrev; }
        if( (uptr)p->pBt<(uptr)pSib->pBt ){
          p->pNext = pSib;
          p->pPrev = 0;
          pSib->pPrev = p;
        }else{
          while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){
            pSib = pSib->pNext;
          }
          p->pNext = pSib->pNext;
          p->pPrev = pSib;
          if( p->pNext ){
            p->pNext->pPrev = p;
          }
          pSib->pNext = p;
        }
        break;
      }
    }
  }
#endif
  *ppBtree = p;
 
btree_open_out:
  if( rc!=SQLITE_OK ){
    if( pBt && pBt->pPager ){
      sqlite3PagerClose(pBt->pPager, 0);
    }
    sqlite3_free(pBt);
    sqlite3_free(p);
    *ppBtree = 0;
  }else{
    sqlite3_file *pFile;
 
    /* If the B-Tree was successfully opened, set the pager-cache size to the
    ** default value. Except, when opening on an existing shared pager-cache,
    ** do not change the pager-cache size.
    */
    if( sqlite3BtreeSchema(p, 0, 0)==0 ){
      sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
    }
 
    pFile = sqlite3PagerFile(pBt->pPager);
    if( pFile->pMethods ){
      sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
    }
  }
  if( mutexOpen ){

References sqlite3::aDb, BtShared::autoVacuum, BTREE_MEMORY, BTREE_SINGLE, BTREE_UNORDERED, btreeInvokeBusyHandler(), BTS_OVERWRITE, BTS_PAGESIZE_FIXED, BTS_READ_ONLY, BTS_SECURE_DELETE, BtShared::btsFlags, Btree::db, BtShared::db, get4byte, GLOBAL, BtShared::incrVacuum, Btree::inTrans, BtLock::iTable, Btree::lock, MAX, sqlite3::mutex, BtShared::mutex, MUTEX_LOGIC, sqlite3_vfs::mxPathname, sqlite3::nDb, BtShared::nRef, BtShared::openFlags, pageReinit(), BtShared::pageSize, Db::pBt, Btree::pBt, BtLock::pBtree, BtShared::pCursor, sqlite3_file::pMethods, Btree::pNext, BtShared::pNext, BtShared::pPage1, BtShared::pPager, Btree::pPrev, Btree::sharable, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_held(), sqlite3_mutex_leave(), sqlite3BtreeConnectionCount(), sqlite3BtreeSchema(), sqlite3GlobalConfig, sqlite3Malloc(), sqlite3MallocZero(), sqlite3MutexAlloc(), sqlite3OsFileControlHint(), sqlite3OsFullPathname(), sqlite3PagerClose(), sqlite3PagerFile(), sqlite3PagerFilename(), sqlite3PagerIsreadonly(), sqlite3PagerOpen(), sqlite3PagerReadFileheader(), sqlite3PagerSetBusyHandler(), sqlite3PagerSetCachesize(), sqlite3PagerSetMmapLimit(), sqlite3PagerSetPagesize(), sqlite3PagerVfs(), sqlite3SharedCacheList, sqlite3Strlen30(), sqlite3TempInMemory(), SQLITE_CONSTRAINT, SQLITE_DEFAULT_AUTOVACUUM, SQLITE_DEFAULT_CACHE_SIZE, SQLITE_FCNTL_PDB, SQLITE_MAX_PAGE_SIZE, SQLITE_MUTEX_FAST, SQLITE_MUTEX_STATIC_MAIN, SQLITE_MUTEX_STATIC_OPEN, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OK_SYMLINK, SQLITE_OPEN_MAIN_DB, SQLITE_OPEN_MEMORY, SQLITE_OPEN_SHAREDCACHE, SQLITE_OPEN_TEMP_DB, SQLITE_OPEN_URI, SQLITE_THREADSAFE, sqlite3::szMmap, TRANS_NONE, and BtShared::usableSize.

Referenced by attachFunc(), openDatabase(), and sqlite3VdbeExec().

◆ sqlite3BtreePager()

SQLITE_PRIVATE Pager * sqlite3BtreePager ( Btree * p )

Definition at line 74095 of file sqlite3.c.

Referenced by attachFunc(), backupOnePage(), doWalCallbacks(), openDatabase(), sqlite3BtreeCopyFile(), sqlite3Pragma(), sqlite3VdbeExec(), and vdbeCommit().

◆ sqlite3BtreePayload()

SQLITE_PRIVATE int sqlite3BtreePayload	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		void *	pBuf )

Definition at line 69461 of file sqlite3.c.

69467 {

References accessPayload(), CURSOR_VALID, BtCursor::eState, BtCursor::iPage, BtCursor::ix, MemPage::nCell, and BtCursor::pPage.

Referenced by saveCursorKey(), and sqlite3VdbeMemFromBtree().

◆ sqlite3BtreePayloadChecked()

SQLITE_PRIVATE int sqlite3BtreePayloadChecked	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		void *	pBuf )

Definition at line 69489 of file sqlite3.c.

                 : accessPayload(pCur, offset, amt, pBuf, 0);
}
SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
  if( pCur->eState==CURSOR_VALID ){

◆ sqlite3BtreePayloadFetch()

SQLITE_PRIVATE const void * sqlite3BtreePayloadFetch	(	BtCursor *	pCur,
		u32 *	pAmt )

Definition at line 69557 of file sqlite3.c.

References fetchPayload().

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreePayloadSize()

SQLITE_PRIVATE u32 sqlite3BtreePayloadSize ( BtCursor * pCur )

Definition at line 69096 of file sqlite3.c.

References CURSOR_VALID, BtCursor::eState, getCellInfo(), BtCursor::info, and CellInfo::nPayload.

Referenced by saveCursorKey(), sqlite3VdbeExec(), sqlite3VdbeIdxKeyCompare(), and sqlite3VdbeIdxRowid().

◆ sqlite3BtreePrevious()

SQLITE_PRIVATE int sqlite3BtreePrevious	(	BtCursor *	pCur,
		int	flags )

Definition at line 70351 of file sqlite3.c.

         {
      rc = SQLITE_OK;
    }
  }
  return rc;
}
SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
  assert( cursorOwnsBtShared(pCur) );
  assert( flags==0 || flags==1 );
  UNUSED_PARAMETER( flags );  /* Used in COMDB2 but not native SQLite */
  pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
  pCur->info.nSize = 0;
  if( pCur->eState!=CURSOR_VALID
   || pCur->ix==0
   || pCur->pPage->leaf==0

Referenced by btreePrevious(), resolveP2Values(), sqlite3BtreeDelete(), and sqlite3VdbeExec().

◆ sqlite3BtreePutData()

SQLITE_PRIVATE int sqlite3BtreePutData	(	BtCursor *	pCsr,
		u32	offset,
		u32	amt,
		void *	z )

Definition at line 74920 of file sqlite3.c.

                                                                                    {
  int rc;
  assert( cursorOwnsBtShared(pCsr) );
  assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
  assert( pCsr->curFlags & BTCF_Incrblob );
 
  rc = restoreCursorPosition(pCsr);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  assert( pCsr->eState!=CURSOR_REQUIRESEEK );
  if( pCsr->eState!=CURSOR_VALID ){
    return SQLITE_ABORT;
  }
 
  /* Save the positions of all other cursors open on this table. This is
  ** required in case any of them are holding references to an xFetch
  ** version of the b-tree page modified by the accessPayload call below.
  **
  ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
  ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence
  ** saveAllCursors can only return SQLITE_OK.
  */
  VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
  assert( rc==SQLITE_OK );
 
  /* Check some assumptions:
  **   (a) the cursor is open for writing,
  **   (b) there is a read/write transaction open,
  **   (c) the connection holds a write-lock on the table (if required),
  **   (d) there are no conflicting read-locks, and
  **   (e) the cursor points at a valid row of an intKey table.
  */
  if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
    return SQLITE_READONLY;
  }
  assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
              && pCsr->pBt->inTransaction==TRANS_WRITE );

References BTCF_Incrblob, BTCF_WriteFlag, BTS_READ_ONLY, BtShared::btsFlags, BtCursor::curFlags, CURSOR_REQUIRESEEK, CURSOR_VALID, Btree::db, BtCursor::eState, MemPage::intKey, BtShared::inTransaction, sqlite3::mutex, BtCursor::pBt, BtCursor::pBtree, BtCursor::pgnoRoot, BtCursor::pPage, restoreCursorPosition, saveAllCursors(), sqlite3_mutex_held(), SQLITE_ABORT, SQLITE_OK, SQLITE_READONLY, TRANS_WRITE, and VVA_ONLY.

◆ sqlite3BtreeRollback()

SQLITE_PRIVATE int sqlite3BtreeRollback	(	Btree *	p,
		int	tripCode,
		int	writeOnly )

Definition at line 68682 of file sqlite3.c.

                                                                              {
  int rc;
  BtShared *pBt = p->pBt;
  MemPage *pPage1;
 
  assert( writeOnly==1 || writeOnly==0 );
  assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
  sqlite3BtreeEnter(p);
  if( tripCode==SQLITE_OK ){
    rc = tripCode = saveAllCursors(pBt, 0, 0);
    if( rc ) writeOnly = 0;
  }else{
    rc = SQLITE_OK;
  }
  if( tripCode ){
    int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly);
    assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
    if( rc2!=SQLITE_OK ) rc = rc2;
  }
  btreeIntegrity(p);
 
  if( p->inTrans==TRANS_WRITE ){
    int rc2;
 
    assert( TRANS_WRITE==pBt->inTransaction );
    rc2 = sqlite3PagerRollback(pBt->pPager);
    if( rc2!=SQLITE_OK ){
      rc = rc2;
    }
 
    /* The rollback may have destroyed the pPage1->aData value.  So
    ** call btreeGetPage() on page 1 again to make
    ** sure pPage1->aData is set correctly. */
    if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
      btreeSetNPage(pBt, pPage1);
      releasePageOne(pPage1);
    }
    assert( countValidCursors(pBt, 1)==0 );
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);

References btreeClearHasContent(), btreeEndTransaction(), btreeGetPage(), btreeIntegrity, btreeSetNPage(), Btree::inTrans, BtShared::inTransaction, Btree::pBt, BtShared::pPager, releasePageOne(), saveAllCursors(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreeTripAllCursors(), sqlite3PagerRollback(), SQLITE_ABORT_ROLLBACK, SQLITE_OK, TRANS_READ, and TRANS_WRITE.

Referenced by sqlite3RollbackAll().

◆ sqlite3BtreeRowCountEst()

SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst ( BtCursor * pCur )

Definition at line 70152 of file sqlite3.c.

                                                          {
  i64 n;
  u8 i;
 
  assert( cursorOwnsBtShared(pCur) );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
 
  /* Currently this interface is only called by the OP_IfSmaller
  ** opcode, and it that case the cursor will always be valid and
  ** will always point to a leaf node. */
  if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
  if( NEVER(pCur->pPage->leaf==0) ) return -1;
 

References BtCursor::apPage, CURSOR_VALID, Btree::db, BtCursor::eState, BtCursor::iPage, MemPage::leaf, sqlite3::mutex, MemPage::nCell, NEVER, BtCursor::pBtree, BtCursor::pPage, and sqlite3_mutex_held().

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeSavepoint()

SQLITE_PRIVATE int sqlite3BtreeSavepoint	(	Btree *	p,
		int	op,
		int	iSavepoint )

Definition at line 68778 of file sqlite3.c.

                                                                          {
  int rc = SQLITE_OK;
  if( p && p->inTrans==TRANS_WRITE ){
    BtShared *pBt = p->pBt;
    assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
    assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
    sqlite3BtreeEnter(p);
    if( op==SAVEPOINT_ROLLBACK ){
      rc = saveAllCursors(pBt, 0, 0);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
        pBt->nPage = 0;
      }
      rc = newDatabase(pBt);
      btreeSetNPage(pBt, pBt->pPage1);
 
      /* pBt->nPage might be zero if the database was corrupt when
      ** the transaction was started. Otherwise, it must be at least 1.  */

References btreeSetNPage(), BTS_INITIALLY_EMPTY, BtShared::btsFlags, CORRUPT_DB, Btree::inTrans, newDatabase(), BtShared::nPage, Btree::pBt, BtShared::pPage1, BtShared::pPager, saveAllCursors(), SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerSavepoint(), SQLITE_OK, and TRANS_WRITE.

Referenced by sqlite3VdbeExec(), and vdbeCloseStatement().

◆ sqlite3BtreeSchema()

SQLITE_PRIVATE void * sqlite3BtreeSchema	(	Btree *	p,
		int	nBytes,
		void()(void )	xFree )

Definition at line 74857 of file sqlite3.c.

                                                                                   {
  BtShared *pBt = p->pBt;
  sqlite3BtreeEnter(p);
  if( !pBt->pSchema && nBytes ){

References Btree::pBt, BtShared::pSchema, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3DbMallocZero(), and BtShared::xFreeSchema.

Referenced by sqlite3BtreeOpen().

◆ sqlite3BtreeSchemaLocked()

SQLITE_PRIVATE int sqlite3BtreeSchemaLocked ( Btree * pBtree )

Definition at line 74873 of file sqlite3.c.

                                                     {
  int rc;
  assert( sqlite3_mutex_held(p->db->mutex) );

References Btree::db, sqlite3::mutex, querySharedCacheTableLock(), READ_LOCK, SCHEMA_ROOT, sqlite3_mutex_held(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), SQLITE_LOCKED_SHAREDCACHE, and SQLITE_OK.

◆ sqlite3BtreeSecureDelete()

SQLITE_PRIVATE int sqlite3BtreeSecureDelete	(	Btree *	p,
		int	newFlag )

Definition at line 67437 of file sqlite3.c.

                                                                  {
  int b;
  if( p==0 ) return 0;
  sqlite3BtreeEnter(p);
  assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 );
  assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) );
  if( newFlag>=0 ){
    p->pBt->btsFlags &= ~BTS_FAST_SECURE;

References BTS_FAST_SECURE, BTS_OVERWRITE, BTS_SECURE_DELETE, BtShared::btsFlags, Btree::pBt, sqlite3BtreeEnter(), and sqlite3BtreeLeave().

Referenced by attachFunc(), and sqlite3Pragma().

◆ sqlite3BtreeSetAutoVacuum()

SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum	(	Btree *	p,
		int	autoVacuum )

Definition at line 67458 of file sqlite3.c.

                                                                      {
#ifdef SQLITE_OMIT_AUTOVACUUM
  return SQLITE_READONLY;
#else
  BtShared *pBt = p->pBt;
  int rc = SQLITE_OK;
  u8 av = (u8)autoVacuum;
 
  sqlite3BtreeEnter(p);
  if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
    rc = SQLITE_READONLY;
  }else{
    pBt->autoVacuum = av ?1:0;

References BtShared::autoVacuum, BTS_PAGESIZE_FIXED, BtShared::btsFlags, BtShared::incrVacuum, Btree::pBt, sqlite3BtreeEnter(), sqlite3BtreeLeave(), SQLITE_OK, and SQLITE_READONLY.

Referenced by sqlite3Pragma().

◆ sqlite3BtreeSetCacheSize()

SQLITE_PRIVATE int sqlite3BtreeSetCacheSize	(	Btree *	p,
		int	mxPage )

Definition at line 67248 of file sqlite3.c.

67254 {

67255 BtShared *pBt = p->pBt;

References Btree::db, sqlite3::mutex, Btree::pBt, BtShared::pPager, sqlite3_mutex_held(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerSetCachesize(), and SQLITE_OK.

Referenced by sqlite3InitOne(), and sqlite3Pragma().

◆ sqlite3BtreeSetPagerFlags()

SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags	(	Btree *	p,
		unsigned	pgFlags )

Definition at line 67301 of file sqlite3.c.

67310 {

67311 BtShared *pBt = p->pBt;

References Btree::db, sqlite3::mutex, Btree::pBt, BtShared::pPager, sqlite3_mutex_held(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerSetFlags(), and SQLITE_OK.

Referenced by attachFunc(), and setAllPagerFlags().

◆ sqlite3BtreeSetPageSize()

SQLITE_PRIVATE int sqlite3BtreeSetPageSize	(	Btree *	p,
		int	nPagesize,
		int	nReserve,
		int	eFix )

Definition at line 67334 of file sqlite3.c.

                                                                                          {
  int rc = SQLITE_OK;
  int x;
  BtShared *pBt = p->pBt;
  assert( nReserve>=0 && nReserve<=255 );
  sqlite3BtreeEnter(p);
  pBt->nReserveWanted = nReserve;
  x = pBt->pageSize - pBt->usableSize;
  if( nReserve<x ) nReserve = x;
  if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
    sqlite3BtreeLeave(p);
    return SQLITE_READONLY;
  }
  assert( nReserve>=0 && nReserve<=255 );
  if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
        ((pageSize-1)&pageSize)==0 ){
    assert( (pageSize & 7)==0 );
    assert( !pBt->pCursor );
    pBt->pageSize = (u32)pageSize;
    freeTempSpace(pBt);
  }

References BTS_PAGESIZE_FIXED, BtShared::btsFlags, freeTempSpace(), BtShared::nReserveWanted, BtShared::pageSize, Btree::pBt, BtShared::pCursor, BtShared::pPager, sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3PagerSetPagesize(), SQLITE_MAX_PAGE_SIZE, SQLITE_OK, SQLITE_READONLY, and BtShared::usableSize.

Referenced by sqlite3Pragma().

◆ sqlite3BtreeSetSpillSize()

SQLITE_PRIVATE int sqlite3BtreeSetSpillSize	(	Btree *	p,
		int	mxPage )

Definition at line 67267 of file sqlite3.c.

                                                                 {
  BtShared *pBt = p->pBt;
  int res;

References Btree::db, sqlite3::mutex, Btree::pBt, BtShared::pPager, sqlite3_mutex_held(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), and sqlite3PagerSetSpillsize().

Referenced by sqlite3Pragma().

◆ sqlite3BtreeSetVersion()

SQLITE_PRIVATE int sqlite3BtreeSetVersion	(	Btree *	pBt,
		int	iVersion )

Definition at line 74979 of file sqlite3.c.

                                                                      {
  BtShared *pBt = pBtree->pBt;
  int rc;                         /* Return code */
 
  assert( iVersion==1 || iVersion==2 );
 
  /* If setting the version fields to 1, do not automatically open the
  ** WAL connection, even if the version fields are currently set to 2.
  */
  pBt->btsFlags &= ~BTS_NO_WAL;
  if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
 
  rc = sqlite3BtreeBeginTrans(pBtree, 0, 0);
  if( rc==SQLITE_OK ){
    u8 *aData = pBt->pPage1->aData;
    if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
      rc = sqlite3BtreeBeginTrans(pBtree, 2, 0);
      if( rc==SQLITE_OK ){
        rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
        if( rc==SQLITE_OK ){
          aData[18] = (u8)iVersion;
          aData[19] = (u8)iVersion;
        }
      }

References MemPage::aData, BTS_NO_WAL, BtShared::btsFlags, Btree::pBt, MemPage::pDbPage, BtShared::pPage1, sqlite3BtreeBeginTrans(), sqlite3PagerWrite(), and SQLITE_OK.

Referenced by sqlite3VdbeExec().

◆ sqlite3BtreeSharable()

SQLITE_PRIVATE int sqlite3BtreeSharable ( Btree * p )

Definition at line 75034 of file sqlite3.c.

                                               { return ROUND8(sizeof(MemPage)); }
 
#if !defined(SQLITE_OMIT_SHARED_CACHE)

References ROUND8.

Referenced by sqlite3TableLock(), and sqlite3VdbeUsesBtree().

◆ sqlite3BtreeTripAllCursors()

SQLITE_PRIVATE int sqlite3BtreeTripAllCursors	(	Btree *	pBtree,
		int	errCode,
		int	writeOnly )

Definition at line 68631 of file sqlite3.c.

                                                                                        {
  BtCursor *p;
  int rc = SQLITE_OK;
 
  assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
  if( pBtree ){
    sqlite3BtreeEnter(pBtree);
    for(p=pBtree->pBt->pCursor; p; p=p->pNext){
      if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
        if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
          rc = saveCursorPosition(p);
          if( rc!=SQLITE_OK ){
            (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0);
            break;
          }
        }
      }else{
        sqlite3BtreeClearCursor(p);
        p->eState = CURSOR_FAULT;
        p->skipNext = errCode;
      }

References BTCF_WriteFlag, btreeReleaseAllCursorPages(), BtCursor::curFlags, CURSOR_FAULT, CURSOR_SKIPNEXT, CURSOR_VALID, BtCursor::eState, Btree::pBt, BtShared::pCursor, BtCursor::pNext, saveCursorPosition(), BtCursor::skipNext, sqlite3BtreeClearCursor(), sqlite3BtreeEnter(), sqlite3BtreeLeave(), sqlite3BtreeTripAllCursors(), and SQLITE_OK.

Referenced by sqlite3BtreeRollback(), sqlite3BtreeTripAllCursors(), and sqlite3VdbeExec().

◆ sqlite3BtreeUpdateMeta()

SQLITE_PRIVATE int sqlite3BtreeUpdateMeta	(	Btree *	p,
		int	idx,
		u32	value )

Definition at line 73994 of file sqlite3.c.

                                                                       {
  BtShared *pBt = p->pBt;
  unsigned char *pP1;
  int rc;
  assert( idx>=1 && idx<=15 );
  sqlite3BtreeEnter(p);
  assert( p->inTrans==TRANS_WRITE );
  assert( pBt->pPage1!=0 );
  pP1 = pBt->pPage1->aData;
  rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
  if( rc==SQLITE_OK ){
    put4byte(&pP1[36 + idx*4], iMeta);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( idx==BTREE_INCR_VACUUM ){
      assert( pBt->autoVacuum || iMeta==0 );
      assert( iMeta==0 || iMeta==1 );
      pBt->incrVacuum = (u8)iMeta;

Referenced by btreeCreateTable(), btreeDropTable(), and sqlite3VdbeExec().

◆ sqlite3CantopenError()

SQLITE_PRIVATE int sqlite3CantopenError ( int lineno )

Definition at line 164595 of file sqlite3.c.

164597 {

164598 testcase( sqlite3GlobalConfig.xLog!=0 );

◆ sqlite3ChangeCookie()

SQLITE_PRIVATE void sqlite3ChangeCookie	(	Parse *	pParse,
		int	iDb )

Definition at line 112136 of file sqlite3.c.

                    : R-34230-56049 SQLite automatically increments
** the schema-version whenever the schema changes.
*/
SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){

References sqlite3::aDb, BTREE_SCHEMA_VERSION, Parse::db, OP_SetCookie, Db::pSchema, Parse::pVdbe, Schema::schema_cookie, and sqlite3VdbeAddOp3().

Referenced by sqlite3CreateIndex(), and sqlite3EndTable().

◆ sqlite3CheckCollSeq()

SQLITE_PRIVATE int sqlite3CheckCollSeq	(	Parse *	pParse,
		CollSeq *	pColl )

Definition at line 115615 of file sqlite3.c.

                                                                     {
  if( pColl && pColl->xCmp==0 ){
    const char *zName = pColl->zName;
    sqlite3 *db = pParse->db;
    CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
    if( !p ){

References Parse::db, ENC, sqlite3GetCollSeq(), SQLITE_ERROR, SQLITE_OK, CollSeq::xCmp, CollSeq::zName, and zName.

Referenced by sqlite3ExprCollSeq().

◆ sqlite3CheckObjectName()

SQLITE_PRIVATE int sqlite3CheckObjectName	(	Parse *	pParse,
		const char *	zName,
		const char *	zType,
		const char *	zTblName )

Definition at line 111272 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  if( sqlite3WritableSchema(db)
   || db->init.imposterTable
   || !sqlite3Config.bExtraSchemaChecks
  ){
    /* Skip these error checks for writable_schema=ON */
    return SQLITE_OK;
  }
  if( db->init.busy ){
    if( sqlite3_stricmp(zType, db->init.azInit[0])
     || sqlite3_stricmp(zName, db->init.azInit[1])
     || sqlite3_stricmp(zTblName, db->init.azInit[2])
    ){
      sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
      return SQLITE_ERROR;
    }
  }else{
    if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
     || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
    ){
      sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
                      zName);

References sqlite3::sqlite3InitInfo::azInit, Sqlite3Config::bExtraSchemaChecks, sqlite3::sqlite3InitInfo::busy, Parse::db, sqlite3::sqlite3InitInfo::imposterTable, sqlite3::init, Parse::nested, sqlite3_stricmp(), sqlite3Config, sqlite3ErrorMsg(), sqlite3ReadOnlyShadowTables(), sqlite3ShadowTableName(), sqlite3StrNICmp, sqlite3WritableSchema(), SQLITE_ERROR, SQLITE_OK, and zName.

Referenced by sqlite3BeginTrigger(), sqlite3CreateIndex(), and sqlite3StartTable().

◆ sqlite3Checkpoint()

SQLITE_PRIVATE int sqlite3Checkpoint	(	sqlite3 *	db,
		int	iDb,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt )

Definition at line 163418 of file sqlite3.c.

                                                                                              {
  int rc = SQLITE_OK;             /* Return code */
  int i;                          /* Used to iterate through attached dbs */
  int bBusy = 0;                  /* True if SQLITE_BUSY has been encountered */
 
  assert( sqlite3_mutex_held(db->mutex) );
  assert( !pnLog || *pnLog==-1 );
  assert( !pnCkpt || *pnCkpt==-1 );
 
  for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
    if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
      rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
      pnLog = 0;
      pnCkpt = 0;
      if( rc==SQLITE_BUSY ){
        bBusy = 1;
        rc = SQLITE_OK;

References sqlite3::aDb, sqlite3::mutex, sqlite3::nDb, Db::pBt, sqlite3_mutex_held(), sqlite3BtreeCheckpoint(), SQLITE_BUSY, SQLITE_MAX_ATTACHED, and SQLITE_OK.

Referenced by sqlite3VdbeExec().

◆ sqlite3ClearStatTables()

static void sqlite3ClearStatTables	(	Parse *	pParse,
		int	iDb,
		const char *	zType,
		const char *	zName )

static

Definition at line 113307 of file sqlite3.c.

 {
  int i;
  const char *zDbName = pParse->db->aDb[iDb].zDbSName;
  for(i=1; i<=4; i++){
    char zTab[24];
    sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
    if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
      sqlite3NestedParse(pParse,

◆ sqlite3ClearTempRegCache()

SQLITE_PRIVATE void sqlite3ClearTempRegCache ( Parse * pParse )

Definition at line 105764 of file sqlite3.c.

References Parse::nRangeReg, and Parse::nTempReg.

Referenced by sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3Pragma(), and sqlite3Select().

◆ sqlite3Close()

static int sqlite3Close	(	sqlite3 *	db,
		int	forceZombie )

static

Definition at line 162187 of file sqlite3.c.

                                                     {
  if( !db ){
    /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or
    ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */
    return SQLITE_OK;
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mTrace & SQLITE_TRACE_CLOSE ){
    db->trace.xV2(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0);
  }
 
  /* Force xDisconnect calls on all virtual tables */
  disconnectAllVtab(db);
 
  /* If a transaction is open, the disconnectAllVtab() call above
  ** will not have called the xDisconnect() method on any virtual
  ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
  ** call will do so. We need to do this before the check for active
  ** SQL statements below, as the v-table implementation may be storing
  ** some prepared statements internally.
  */
  sqlite3VtabRollback(db);
 
  /* Legacy behavior (sqlite3_close() behavior) is to return
  ** SQLITE_BUSY if the connection can not be closed immediately.
  */
  if( !forceZombie && connectionIsBusy(db) ){
    sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized "
       "statements or unfinished backups");
    sqlite3_mutex_leave(db->mutex);
    return SQLITE_BUSY;
  }
 
#ifdef SQLITE_ENABLE_SQLLOG
  if( sqlite3GlobalConfig.xSqllog ){
    /* Closing the handle. Fourth parameter is passed the value 2. */
    sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2);
  }
#endif
 

Referenced by sqlite3_close_v2().

◆ sqlite3CloseExtensions()

SQLITE_PRIVATE void sqlite3CloseExtensions ( sqlite3 * db )

Definition at line 124894 of file sqlite3.c.

124900 {

124901 int i;

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3CloseSavepoints()

SQLITE_PRIVATE void sqlite3CloseSavepoints ( sqlite3 * db )

Definition at line 162110 of file sqlite3.c.

                                                       {
  while( db->pSavepoint ){
    Savepoint *pTmp = db->pSavepoint;
    db->pSavepoint = pTmp->pNext;

References sqlite3::isTransactionSavepoint, sqlite3::nSavepoint, sqlite3::nStatement, Savepoint::pNext, sqlite3::pSavepoint, and sqlite3DbFree().

Referenced by sqlite3LeaveMutexAndCloseZombie(), sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3CodeDropTable()

SQLITE_PRIVATE void sqlite3CodeDropTable	(	Parse *	pParse,
		Table *	pTab,
		int	iDb,
		int	isView )

Definition at line 113330 of file sqlite3.c.

                                                                                         {
  Vdbe *v;
  sqlite3 *db = pParse->db;
  Trigger *pTrigger;
  Db *pDb = &db->aDb[iDb];
 
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  sqlite3BeginWriteOperation(pParse, 1, iDb);
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    sqlite3VdbeAddOp0(v, OP_VBegin);
  }
#endif
 
  /* Drop all triggers associated with the table being dropped. Code
  ** is generated to remove entries from sqlite_schema and/or
  ** sqlite_temp_schema if required.
  */
  pTrigger = sqlite3TriggerList(pParse, pTab);
  while( pTrigger ){
    assert( pTrigger->pSchema==pTab->pSchema ||
        pTrigger->pSchema==db->aDb[1].pSchema );
    sqlite3DropTriggerPtr(pParse, pTrigger);
    pTrigger = pTrigger->pNext;
  }
 
#ifndef SQLITE_OMIT_AUTOINCREMENT
  /* Remove any entries of the sqlite_sequence table associated with
  ** the table being dropped. This is done before the table is dropped
  ** at the btree level, in case the sqlite_sequence table needs to
  ** move as a result of the drop (can happen in auto-vacuum mode).
  */
  if( pTab->tabFlags & TF_Autoincrement ){
    sqlite3NestedParse(pParse,
      "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
      pDb->zDbSName, pTab->zName
    );
  }
#endif
 
  /* Drop all entries in the schema table that refer to the
  ** table. The program name loops through the schema table and deletes
  ** every row that refers to a table of the same name as the one being
  ** dropped. Triggers are handled separately because a trigger can be
  ** created in the temp database that refers to a table in another
  ** database.
  */
  sqlite3NestedParse(pParse,
      "DELETE FROM %Q." DFLT_SCHEMA_TABLE
      " WHERE tbl_name=%Q and type!='trigger'",
      pDb->zDbSName, pTab->zName);
  if( !isView && !IsVirtual(pTab) ){
    destroyTable(pParse, pTab);
  }
 
  /* Remove the table entry from SQLite's internal schema and modify
  ** the schema cookie.
  */
  if( IsVirtual(pTab) ){
    sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);

◆ sqlite3CodeRhsOfIN()

SQLITE_PRIVATE void sqlite3CodeRhsOfIN	(	Parse *	pParse,
		Expr *	pExpr,
		int	iTab )

Definition at line 102537 of file sqlite3.c.

 {
  int addrOnce = 0;           /* Address of the OP_Once instruction at top */
  int addr;                   /* Address of OP_OpenEphemeral instruction */
  Expr *pLeft;                /* the LHS of the IN operator */
  KeyInfo *pKeyInfo = 0;      /* Key information */
  int nVal;                   /* Size of vector pLeft */
  Vdbe *v;                    /* The prepared statement under construction */
 
  v = pParse->pVdbe;
  assert( v!=0 );
 
  /* The evaluation of the IN must be repeated every time it
  ** is encountered if any of the following is true:
  **
  **    *  The right-hand side is a correlated subquery
  **    *  The right-hand side is an expression list containing variables
  **    *  We are inside a trigger
  **
  ** If all of the above are false, then we can compute the RHS just once
  ** and reuse it many names.
  */
  if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
    /* Reuse of the RHS is allowed */
    /* If this routine has already been coded, but the previous code
    ** might not have been invoked yet, so invoke it now as a subroutine.
    */
    if( ExprHasProperty(pExpr, EP_Subrtn) ){
      addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d",
              pExpr->x.pSelect->selId));
      }
      sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
                        pExpr->y.sub.iAddr);
      sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
      sqlite3VdbeJumpHere(v, addrOnce);
      return;
    }
 
    /* Begin coding the subroutine */
    ExprSetProperty(pExpr, EP_Subrtn);
    assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
    pExpr->y.sub.regReturn = ++pParse->nMem;
    pExpr->y.sub.iAddr =
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
    VdbeComment((v, "return address"));
 
    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
  }
 
  /* Check to see if this is a vector IN operator */
  pLeft = pExpr->pLeft;
  nVal = sqlite3ExprVectorSize(pLeft);
 
  /* Construct the ephemeral table that will contain the content of
  ** RHS of the IN operator.
  */
  pExpr->iTable = iTab;
  addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
    VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
  }else{
    VdbeComment((v, "RHS of IN operator"));
  }
#endif
  pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
 
  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
    /* Case 1:     expr IN (SELECT ...)
    **
    ** Generate code to write the results of the select into the temporary
    ** table allocated and opened above.
    */
    Select *pSelect = pExpr->x.pSelect;
    ExprList *pEList = pSelect->pEList;
 
    ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d",
        addrOnce?"":"CORRELATED ", pSelect->selId
    ));
    /* If the LHS and RHS of the IN operator do not match, that
    ** error will have been caught long before we reach this point. */
    if( ALWAYS(pEList->nExpr==nVal) ){
      SelectDest dest;
      int i;
      sqlite3SelectDestInit(&dest, SRT_Set, iTab);
      dest.zAffSdst = exprINAffinity(pParse, pExpr);
      pSelect->iLimit = 0;
      testcase( pSelect->selFlags & SF_Distinct );
      testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
      if( sqlite3Select(pParse, pSelect, &dest) ){
        sqlite3DbFree(pParse->db, dest.zAffSdst);
        sqlite3KeyInfoUnref(pKeyInfo);
        return;
      }
      sqlite3DbFree(pParse->db, dest.zAffSdst);
      assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
      assert( pEList!=0 );
      assert( pEList->nExpr>0 );
      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
      for(i=0; i<nVal; i++){
        Expr *p = sqlite3VectorFieldSubexpr(pLeft, i);
        pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
            pParse, p, pEList->a[i].pExpr
        );
      }
    }
  }else if( ALWAYS(pExpr->x.pList!=0) ){
    /* Case 2:     expr IN (exprlist)
    **
    ** For each expression, build an index key from the evaluation and
    ** store it in the temporary table. If <expr> is a column, then use
    ** that columns affinity when building index keys. If <expr> is not
    ** a column, use numeric affinity.
    */
    char affinity;            /* Affinity of the LHS of the IN */
    int i;
    ExprList *pList = pExpr->x.pList;
    struct ExprList_item *pItem;
    int r1, r2;
    affinity = sqlite3ExprAffinity(pLeft);
    if( affinity<=SQLITE_AFF_NONE ){
      affinity = SQLITE_AFF_BLOB;
    }else if( affinity==SQLITE_AFF_REAL ){
      affinity = SQLITE_AFF_NUMERIC;
    }
    if( pKeyInfo ){
      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
      pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
    }
 
    /* Loop through each expression in <exprlist>. */
    r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3GetTempReg(pParse);
    for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
      Expr *pE2 = pItem->pExpr;
 
      /* If the expression is not constant then we will need to
      ** disable the test that was generated above that makes sure
      ** this code only executes once.  Because for a non-constant
      ** expression we need to rerun this code each time.
      */
      if( addrOnce && !sqlite3ExprIsConstant(pE2) ){
        sqlite3VdbeChangeToNoop(v, addrOnce);
        ExprClearProperty(pExpr, EP_Subrtn);
        addrOnce = 0;
      }
 
      /* Evaluate the expression and insert it into the temp table */
      sqlite3ExprCode(pParse, pE2, r1);
      sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1);
    }
    sqlite3ReleaseTempReg(pParse, r1);
    sqlite3ReleaseTempReg(pParse, r2);
  }
  if( pKeyInfo ){
    sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
  }
  if( addrOnce ){
    sqlite3VdbeJumpHere(v, addrOnce);

References ExprList::a, KeyInfo::aColl, ALWAYS, Parse::db, EP_Reduced, EP_Subrtn, EP_TokenOnly, EP_VarSelect, EP_xIsSelect, ExplainQueryPlan, ExprClearProperty, ExprHasProperty, exprINAffinity(), ExprSetProperty, Expr::iAddr, Select::iLimit, Parse::iSelfTab, Expr::iTable, ExprList::nExpr, Parse::nMem, OP_Gosub, OP_IdxInsert, OP_Integer, OP_MakeRecord, OP_Once, OP_OpenDup, OP_OpenEphemeral, OP_Return, P4_KEYINFO, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pSelect, Parse::pVdbe, Expr::regReturn, Select::selFlags, Select::selId, SF_Distinct, sqlite3BinaryCompareCollSeq(), sqlite3ClearTempRegCache(), sqlite3DbFree(), sqlite3ExprAffinity(), sqlite3ExprCode(), sqlite3ExprCollSeq(), sqlite3ExprIsConstant(), sqlite3ExprVectorSize(), sqlite3GetTempReg(), sqlite3KeyInfoAlloc(), sqlite3KeyInfoUnref(), sqlite3ReleaseTempReg(), sqlite3Select(), sqlite3SelectDestInit(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP1(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), sqlite3VectorFieldSubexpr(), SQLITE_AFF_BLOB, SQLITE_AFF_NONE, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SRT_Set, Expr::sub, testcase, VdbeComment, VdbeCoverage, Expr::x, Expr::y, and SelectDest::zAffSdst.

Referenced by sqlite3FindInIndex().

◆ sqlite3CodeRowTrigger()

SQLITE_PRIVATE void sqlite3CodeRowTrigger	(	Parse *	pParse,
		Trigger *	pTrigger,
		int	op,
		ExprList *	pChanges,
		int	tr_tm,
		Table *	pTab,
		int	reg,
		int	orconf,
		int	ignoreJump )

Definition at line 137501 of file sqlite3.c.

 {
  Trigger *p;          /* Used to iterate through pTrigger list */
 
  assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
  assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
  assert( (op==TK_UPDATE)==(pChanges!=0) );
 
  for(p=pTrigger; p; p=p->pNext){
 
    /* Sanity checking:  The schema for the trigger and for the table are
    ** always defined.  The trigger must be in the same schema as the table
    ** or else it must be a TEMP trigger. */
    assert( p->pSchema!=0 );
    assert( p->pTabSchema!=0 );
    assert( p->pSchema==p->pTabSchema
         || p->pSchema==pParse->db->aDb[1].pSchema );
 
    /* Determine whether we should code this trigger */
    if( p->op==op
     && p->tr_tm==tr_tm

References sqlite3::aDb, checkColumnOverlap(), Parse::db, Trigger::op, Trigger::pColumns, Trigger::pNext, Db::pSchema, Trigger::pSchema, Trigger::pTabSchema, sqlite3CodeRowTriggerDirect(), TK_DELETE, TK_INSERT, TK_UPDATE, Trigger::tr_tm, TRIGGER_AFTER, and TRIGGER_BEFORE.

Referenced by sqlite3GenerateRowDelete(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3CodeRowTriggerDirect()

SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect	(	Parse *	pParse,
		Trigger *	p,
		Table *	pTab,
		int	reg,
		int	orconf,
		int	ignoreJump )

Definition at line 137429 of file sqlite3.c.

 {
  Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
  TriggerPrg *pPrg;
  pPrg = getRowTrigger(pParse, p, pTab, orconf);
  assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
 
  /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
  ** is a pointer to the sub-vdbe containing the trigger program.  */
  if( pPrg ){
    int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
 
    sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
                      (const char *)pPrg->pProgram, P4_SUBPROGRAM);
    VdbeComment(
        (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
 
    /* Set the P5 operand of the OP_Program instruction to non-zero if
    ** recursive invocation of this trigger program is disallowed. Recursive

References Parse::db, sqlite3::flags, getRowTrigger(), sqlite3::mallocFailed, Parse::nErr, Parse::nMem, OP_Program, P4_SUBPROGRAM, TriggerPrg::pProgram, sqlite3GetVdbe(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), SQLITE_RecTriggers, VdbeComment, and Trigger::zName.

Referenced by sqlite3CodeRowTrigger().

◆ sqlite3CodeSubselect()

SQLITE_PRIVATE int sqlite3CodeSubselect	(	Parse *	pParse,
		Expr *	pExpr )

Definition at line 102725 of file sqlite3.c.

                                                                   {
  int addrOnce = 0;           /* Address of OP_Once at top of subroutine */
  int rReg = 0;               /* Register storing resulting */
  Select *pSel;               /* SELECT statement to encode */
  SelectDest dest;            /* How to deal with SELECT result */
  int nReg;                   /* Registers to allocate */
  Expr *pLimit;               /* New limit expression */
 
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  testcase( pExpr->op==TK_EXISTS );
  testcase( pExpr->op==TK_SELECT );
  assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
  assert( ExprHasProperty(pExpr, EP_xIsSelect) );
  pSel = pExpr->x.pSelect;
 
  /* The evaluation of the EXISTS/SELECT must be repeated every time it
  ** is encountered if any of the following is true:
  **
  **    *  The right-hand side is a correlated subquery
  **    *  The right-hand side is an expression list containing variables
  **    *  We are inside a trigger
  **
  ** If all of the above are false, then we can run this code just once
  ** save the results, and reuse the same result on subsequent invocations.
  */
  if( !ExprHasProperty(pExpr, EP_VarSelect) ){
    /* If this routine has already been coded, then invoke it as a
    ** subroutine. */
    if( ExprHasProperty(pExpr, EP_Subrtn) ){
      ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
      sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
                        pExpr->y.sub.iAddr);
      return pExpr->iTable;
    }
 
    /* Begin coding the subroutine */
    ExprSetProperty(pExpr, EP_Subrtn);
    pExpr->y.sub.regReturn = ++pParse->nMem;
    pExpr->y.sub.iAddr =
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
    VdbeComment((v, "return address"));
 
    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
  }
 
  /* For a SELECT, generate code to put the values for all columns of
  ** the first row into an array of registers and return the index of
  ** the first register.
  **
  ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
  ** into a register and return that register number.
  **
  ** In both cases, the query is augmented with "LIMIT 1".  Any
  ** preexisting limit is discarded in place of the new LIMIT 1.
  */
  ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d",
        addrOnce?"":"CORRELATED ", pSel->selId));
  nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
  sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
  pParse->nMem += nReg;
  if( pExpr->op==TK_SELECT ){
    dest.eDest = SRT_Mem;
    dest.iSdst = dest.iSDParm;
    dest.nSdst = nReg;
    sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
    VdbeComment((v, "Init subquery result"));
  }else{
    dest.eDest = SRT_Exists;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
    VdbeComment((v, "Init EXISTS result"));
  }
  if( pSel->pLimit ){
    /* The subquery already has a limit.  If the pre-existing limit is X
    ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
    sqlite3 *db = pParse->db;
    pLimit = sqlite3Expr(db, TK_INTEGER, "0");
    if( pLimit ){
      pLimit->affExpr = SQLITE_AFF_NUMERIC;
      pLimit = sqlite3PExpr(pParse, TK_NE,
                            sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit);
    }
    sqlite3ExprDelete(db, pSel->pLimit->pLeft);
    pSel->pLimit->pLeft = pLimit;
  }else{
    /* If there is no pre-existing limit add a limit of 1 */
    pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
    pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
  }
  pSel->iLimit = 0;
  if( sqlite3Select(pParse, pSel, &dest) ){
    return 0;
  }
  pExpr->iTable = rReg = dest.iSDParm;
  ExprSetVVAProperty(pExpr, EP_NoReduce);
  if( addrOnce ){
    sqlite3VdbeJumpHere(v, addrOnce);
 
    /* Subroutine return */
    sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);

References Expr::affExpr, Parse::db, SelectDest::eDest, EP_NoReduce, EP_Subrtn, EP_VarSelect, EP_xIsSelect, ExplainQueryPlan, ExprHasProperty, ExprSetProperty, ExprSetVVAProperty, Expr::iAddr, Select::iLimit, SelectDest::iSDParm, SelectDest::iSdst, Expr::iTable, ExprList::nExpr, Parse::nMem, SelectDest::nSdst, Expr::op, OP_Gosub, OP_Integer, OP_Null, OP_Once, OP_Return, Select::pEList, Expr::pLeft, Select::pLimit, Expr::pSelect, Parse::pVdbe, Expr::regReturn, Select::selId, sqlite3ClearTempRegCache(), sqlite3Expr(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3PExpr(), sqlite3Select(), sqlite3SelectDestInit(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP1(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), SQLITE_AFF_NUMERIC, SRT_Exists, SRT_Mem, Expr::sub, testcase, TK_EXISTS, TK_INTEGER, TK_LIMIT, TK_NE, TK_SELECT, VdbeComment, VdbeCoverage, Expr::x, and Expr::y.

Referenced by codeExprOrVector(), exprCodeSubselect(), exprCodeVector(), and sqlite3ExprCodeTarget().

◆ sqlite3CodeVerifyNamedSchema()

SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema	(	Parse *	pParse,
		const char *	zDb )

Definition at line 115145 of file sqlite3.c.

                                                                                {
  sqlite3 *db = pParse->db;
  int i;
  for(i=0; i<db->nDb; i++){

Referenced by sqlite3DropTrigger(), and sqlite3Pragma().

◆ sqlite3CodeVerifySchema()

SQLITE_PRIVATE void sqlite3CodeVerifySchema	(	Parse *	pParse,
		int	iDb )

Definition at line 115126 of file sqlite3.c.

                                                                   {
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
 
  assert( iDb>=0 && iDb<pParse->db->nDb );
  assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
  assert( iDb<SQLITE_MAX_ATTACHED+2 );
  assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
  if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){

References sqlite3::aDb, Parse::cookieMask, Parse::db, DbMaskSet, DbMaskTest, sqlite3::nDb, OMIT_TEMPDB, Db::pBt, sqlite3OpenTempDatabase(), sqlite3ParseToplevel, and SQLITE_MAX_ATTACHED.

Referenced by sqlite3BeginTrigger(), sqlite3BeginWriteOperation(), sqlite3CreateIndex(), sqlite3FindInIndex(), sqlite3Pragma(), sqlite3Select(), sqlite3StartTable(), sqlite3WhereBegin(), and xferOptimization().

◆ sqlite3CollapseDatabaseArray()

SQLITE_PRIVATE void sqlite3CollapseDatabaseArray ( sqlite3 * db )

Definition at line 110938 of file sqlite3.c.

                                                             {
  int i, j;
  for(i=j=2; i<db->nDb; i++){
    struct Db *pDb = &db->aDb[i];
    if( pDb->pBt==0 ){
      sqlite3DbFree(db, pDb->zDbSName);
      pDb->zDbSName = 0;
      continue;
    }
    if( j<i ){
      db->aDb[j] = db->aDb[i];
    }
    j++;
  }
  db->nDb = j;

References sqlite3::aDb, sqlite3::aDbStatic, sqlite3::nDb, Db::pBt, sqlite3DbFree(), and Db::zDbSName.

Referenced by detachFunc(), and sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3ColumnDefault()

SQLITE_PRIVATE void sqlite3ColumnDefault	(	Vdbe *	v,
		Table *	pTab,
		int	i,
		int	iReg )

Definition at line 137656 of file sqlite3.c.

                                                                               {
  assert( pTab!=0 );
  if( !pTab->pSelect ){
    sqlite3_value *pValue = 0;
    u8 enc = ENC(sqlite3VdbeDb(v));
    Column *pCol = &pTab->aCol[i];
    VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
    assert( i<pTab->nCol );
    sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
                         pCol->affinity, &pValue);
    if( pValue ){
      sqlite3VdbeAppendP4(v, pValue, P4_MEM);
    }
  }

References Table::aCol, Column::affinity, ENC, IsVirtual, OP_RealAffinity, P4_MEM, Column::pDflt, Table::pSelect, sqlite3ValueFromExpr(), sqlite3VdbeAddOp1(), sqlite3VdbeAppendP4(), sqlite3VdbeDb(), SQLITE_AFF_REAL, VdbeComment, Column::zName, and Table::zName.

◆ sqlite3ColumnsFromExprList()

SQLITE_PRIVATE int sqlite3ColumnsFromExprList	(	Parse *	pParse,
		ExprList *	pEList,
		i16 *	pnCol,
		Column **	paCol )

Definition at line 131254 of file sqlite3.c.

           : generateColumnNames()
*/
SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
  Parse *pParse,          /* Parsing context */
  ExprList *pEList,       /* Expr list from which to derive column names */
  i16 *pnCol,             /* Write the number of columns here */
  Column **paCol          /* Write the new column list here */
){
  sqlite3 *db = pParse->db;   /* Database connection */
  int i, j;                   /* Loop counters */
  u32 cnt;                    /* Index added to make the name unique */
  Column *aCol, *pCol;        /* For looping over result columns */
  int nCol;                   /* Number of columns in the result set */
  char *zName;                /* Column name */
  int nName;                  /* Size of name in zName[] */
  Hash ht;                    /* Hash table of column names */
 
  sqlite3HashInit(&ht);
  if( pEList ){
    nCol = pEList->nExpr;
    aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
    testcase( aCol==0 );
    if( nCol>32767 ) nCol = 32767;
  }else{
    nCol = 0;
    aCol = 0;
  }
  assert( nCol==(i16)nCol );
  *pnCol = nCol;
  *paCol = aCol;
 
  for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
    /* Get an appropriate name for the column
    */
    if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){
      /* If the column contains an "AS <name>" phrase, use <name> as the name */
    }else{
      Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr);
      while( pColExpr->op==TK_DOT ){
        pColExpr = pColExpr->pRight;
        assert( pColExpr!=0 );
      }
      if( pColExpr->op==TK_COLUMN ){
        /* For columns use the column name name */
        int iCol = pColExpr->iColumn;
        Table *pTab = pColExpr->y.pTab;
        assert( pTab!=0 );
        if( iCol<0 ) iCol = pTab->iPKey;
        zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
      }else if( pColExpr->op==TK_ID ){
        assert( !ExprHasProperty(pColExpr, EP_IntValue) );
        zName = pColExpr->u.zToken;
      }else{
        /* Use the original text of the column expression as its name */
        zName = pEList->a[i].zEName;
      }
    }
    if( zName && !sqlite3IsTrueOrFalse(zName) ){
      zName = sqlite3DbStrDup(db, zName);
    }else{
      zName = sqlite3MPrintf(db,"column%d",i+1);
    }
 
    /* Make sure the column name is unique.  If the name is not unique,
    ** append an integer to the name so that it becomes unique.
    */
    cnt = 0;
    while( zName && sqlite3HashFind(&ht, zName)!=0 ){
      nName = sqlite3Strlen30(zName);
      if( nName>0 ){
        for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
        if( zName[j]==':' ) nName = j;
      }
      zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
      if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);
    }
    pCol->zName = zName;
    pCol->hName = sqlite3StrIHash(zName);
    sqlite3ColumnPropertiesFromName(0, pCol);
    if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
      sqlite3OomFault(db);
    }
  }
  sqlite3HashClear(&ht);
  if( db->mallocFailed ){
    for(j=0; j<i; j++){
      sqlite3DbFree(db, aCol[j].zName);
    }
    sqlite3DbFree(db, aCol);

References ExprList::a, Table::aCol, Parse::db, ExprList::ExprList_item::eEName, ENAME_NAME, EP_IntValue, ExprHasProperty, Column::hName, Expr::iColumn, Table::iPKey, sqlite3::mallocFailed, ExprList::nExpr, nName, Expr::op, ExprList::ExprList_item::pExpr, Expr::pRight, Expr::pTab, sqlite3_randomness(), sqlite3ColumnPropertiesFromName, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ExprSkipCollateAndLikely(), sqlite3HashClear(), sqlite3HashFind(), sqlite3HashInit(), sqlite3HashInsert(), sqlite3Isdigit, sqlite3IsTrueOrFalse(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3StrIHash(), sqlite3Strlen30(), SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, TK_COLUMN, TK_DOT, TK_ID, Expr::u, Expr::y, ExprList::ExprList_item::zEName, Column::zName, zName, and Expr::zToken.

Referenced by sqlite3ExpandSubquery(), sqlite3ViewGetColumnNames(), and withExpand().

◆ sqlite3ColumnType()

SQLITE_PRIVATE char * sqlite3ColumnType	(	Column *	pCol,
		char *	zDflt )

Definition at line 31271 of file sqlite3.c.

References COLFLAG_HASTYPE, Column::colFlags, and Column::zName.

Referenced by columnTypeImpl(), sqlite3_table_column_metadata(), sqlite3AddPrimaryKey(), sqlite3Pragma(), and vtabCallConstructor().

◆ sqlite3CommitInternalChanges()

SQLITE_PRIVATE void sqlite3CommitInternalChanges ( sqlite3 * db )

Definition at line 111013 of file sqlite3.c.

Referenced by sqlite3Init(), and sqlite3VdbeHalt().

◆ sqlite3CompareAffinity()

SQLITE_PRIVATE char sqlite3CompareAffinity	(	const Expr *	pExpr,
		char	aff2 )

Definition at line 99959 of file sqlite3.c.

                                                                        {
  char aff1 = sqlite3ExprAffinity(pExpr);
  if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){
    /* Both sides of the comparison are columns. If one has numeric
    ** affinity, use that. Otherwise use no affinity.
    */
    if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
      return SQLITE_AFF_NUMERIC;
    }else{
      return SQLITE_AFF_BLOB;
    }

References sqlite3ExprAffinity(), sqlite3IsNumericAffinity, SQLITE_AFF_BLOB, SQLITE_AFF_NONE, and SQLITE_AFF_NUMERIC.

Referenced by codeAllEqualityTerms(), exprINAffinity(), sqlite3FindInIndex(), updateRangeAffinityStr(), and whereRangeVectorLen().

◆ sqlite3CompileOptions()

SQLITE_PRIVATE const char ** sqlite3CompileOptions ( int * pnOpt )

Definition at line 782 of file sqlite3.c.

                                                             {
  *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]);
  return (const char**)sqlite3azCompileOpt;
}

References sqlite3azCompileOpt.

Referenced by sqlite3_compileoption_used().

◆ sqlite3CompleteInsertion()

SQLITE_PRIVATE void sqlite3CompleteInsertion	(	Parse *	pParse,
		Table *	pTab,
		int	iDataCur,
		int	iIdxCur,
		int	regNewData,
		int *	aRegIdx,
		int	update_flags,
		int	appendBias,
		int	useSeekResult )

Definition at line 122833 of file sqlite3.c.

 {
  Vdbe *v;            /* Prepared statements under construction */
  Index *pIdx;        /* An index being inserted or updated */
  u8 pik_flags;       /* flag values passed to the btree insert */
  int i;              /* Loop counter */
 
  assert( update_flags==0
       || update_flags==OPFLAG_ISUPDATE
       || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION)
  );
 
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
    /* All REPLACE indexes are at the end of the list */
    assert( pIdx->onError!=OE_Replace
         || pIdx->pNext==0
         || pIdx->pNext->onError==OE_Replace );
    if( aRegIdx[i]==0 ) continue;
    if( pIdx->pPartIdxWhere ){
      sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
      VdbeCoverage(v);
    }
    pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0);
    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
      assert( pParse->nested==0 );
      pik_flags |= OPFLAG_NCHANGE;
      pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
      if( update_flags==0 ){
        int r = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
        sqlite3VdbeAddOp4(v, OP_Insert,
            iIdxCur+i, aRegIdx[i], r, (char*)pTab, P4_TABLE
        );
        sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
        sqlite3ReleaseTempReg(pParse, r);
      }
#endif
    }
    sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
                         aRegIdx[i]+1,
                         pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
    sqlite3VdbeChangeP5(v, pik_flags);
  }
  if( !HasRowid(pTab) ) return;
  if( pParse->nested ){
    pik_flags = 0;
  }else{
    pik_flags = OPFLAG_NCHANGE;
    pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID);
  }
  if( appendBias ){
    pik_flags |= OPFLAG_APPEND;
  }
  if( useSeekResult ){
    pik_flags |= OPFLAG_USESEEKRESULT;
  }

References HasRowid, IsPrimaryKeyIndex, Index::nColumn, Parse::nested, Index::nKeyCol, OE_Replace, Index::onError, OP_IdxInsert, OP_Insert, OP_Integer, OP_IsNull, OPFLAG_APPEND, OPFLAG_ISNOOP, OPFLAG_ISUPDATE, OPFLAG_LASTROWID, OPFLAG_NCHANGE, OPFLAG_SAVEPOSITION, OPFLAG_USESEEKRESULT, P4_TABLE, Table::pIndex, Index::pNext, Index::pPartIdxWhere, Table::pSelect, sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), Index::uniqNotNull, and VdbeCoverage.

Referenced by sqlite3Insert(), and sqlite3Update().

◆ sqlite3ComputeGeneratedColumns()

SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns	(	Parse *	pParse,
		int	iRegStore,
		Table *	pTab )

Definition at line 120770 of file sqlite3.c.

 {
  int i;
  Walker w;
  Column *pRedo;
  int eProgress;
  VdbeOp *pOp;
 
  assert( pTab->tabFlags & TF_HasGenerated );
  testcase( pTab->tabFlags & TF_HasVirtual );
  testcase( pTab->tabFlags & TF_HasStored );
 
  /* Before computing generated columns, first go through and make sure
  ** that appropriate affinity has been applied to the regular columns
  */
  sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
  if( (pTab->tabFlags & TF_HasStored)!=0
   && (pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1))->opcode==OP_Affinity
  ){
    /* Change the OP_Affinity argument to '@' (NONE) for all stored
    ** columns.  '@' is the no-op affinity and those columns have not
    ** yet been computed. */
    int ii, jj;
    char *zP4 = pOp->p4.z;
    assert( zP4!=0 );
    assert( pOp->p4type==P4_DYNAMIC );
    for(ii=jj=0; zP4[jj]; ii++){
      if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
        continue;
      }
      if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
        zP4[jj] = SQLITE_AFF_NONE;
      }
      jj++;
    }
  }
 
  /* Because there can be multiple generated columns that refer to one another,
  ** this is a two-pass algorithm.  On the first pass, mark all generated
  ** columns as "not available".
  */
  for(i=0; i<pTab->nCol; i++){
    if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
      testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
      testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
      pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
    }
  }
 
  w.u.pTab = pTab;
  w.xExprCallback = exprColumnFlagUnion;
  w.xSelectCallback = 0;
  w.xSelectCallback2 = 0;
 
  /* On the second pass, compute the value of each NOT-AVAILABLE column.
  ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
  ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as
  ** they are needed.
  */
  pParse->iSelfTab = -iRegStore;
  do{
    eProgress = 0;
    pRedo = 0;
    for(i=0; i<pTab->nCol; i++){
      Column *pCol = pTab->aCol + i;
      if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){
        int x;
        pCol->colFlags |= COLFLAG_BUSY;
        w.eCode = 0;
        sqlite3WalkExpr(&w, pCol->pDflt);
        pCol->colFlags &= ~COLFLAG_BUSY;
        if( w.eCode & COLFLAG_NOTAVAIL ){
          pRedo = pCol;
          continue;
        }
        eProgress = 1;
        assert( pCol->colFlags & COLFLAG_GENERATED );
        x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
        sqlite3ExprCodeGeneratedColumn(pParse, pCol, x);
        pCol->colFlags &= ~COLFLAG_NOTAVAIL;
      }
    }

References Table::aCol, COLFLAG_BUSY, COLFLAG_GENERATED, COLFLAG_NOTAVAIL, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, Walker::eCode, exprColumnFlagUnion(), Parse::iSelfTab, Table::nCol, OP_Affinity, VdbeOp::p4, P4_DYNAMIC, VdbeOp::p4type, Column::pDflt, Walker::pTab, Parse::pVdbe, sqlite3ErrorMsg(), sqlite3ExprCodeGeneratedColumn(), sqlite3TableAffinity(), sqlite3TableColumnToStorage(), sqlite3VdbeGetOp(), sqlite3WalkExpr(), SQLITE_AFF_NONE, Table::tabFlags, testcase, TF_HasGenerated, TF_HasStored, TF_HasVirtual, Walker::u, Walker::xExprCallback, Walker::xSelectCallback, Walker::xSelectCallback2, VdbeOp::p4union::z, and Column::zName.

Referenced by sqlite3GenerateConstraintChecks(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3CorruptError()

SQLITE_PRIVATE int sqlite3CorruptError ( int lineno )

Definition at line 164587 of file sqlite3.c.

                                                                              {
  sqlite3_log(iErr, "%s at line %d of [%.10s]",
              zType, lineno, 20+sqlite3_sourceid());

References sqlite3_log(), and sqlite3_sourceid().

◆ sqlite3CreateColumnExpr()

SQLITE_PRIVATE Expr * sqlite3CreateColumnExpr	(	sqlite3 *	db,
		SrcList *	pSrc,
		int	iSrc,
		int	iCol )

Definition at line 98400 of file sqlite3.c.

                                                                                            {
  Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
  if( p ){
    struct SrcList_item *pItem = &pSrc->a[iSrc];
    Table *pTab = p->y.pTab = pItem->pTab;
    p->iTable = pItem->iCursor;
    if( p->y.pTab->iPKey==iCol ){
      p->iColumn = -1;
    }else{
      p->iColumn = (ynVar)iCol;
      if( (pTab->tabFlags & TF_HasGenerated)!=0
       && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
      ){
        testcase( pTab->nCol==63 );
        testcase( pTab->nCol==64 );
        pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
      }else{
        testcase( iCol==BMS );
        testcase( iCol==BMS-1 );

Referenced by addWhereTerm().

◆ sqlite3CreateForeignKey()

SQLITE_PRIVATE void sqlite3CreateForeignKey	(	Parse *	pParse,
		ExprList *	pFromCol,
		Token *	pTo,
		ExprList *	pToCol,
		int	flags )

Definition at line 113551 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
#ifndef SQLITE_OMIT_FOREIGN_KEY
  FKey *pFKey = 0;
  FKey *pNextTo;
  Table *p = pParse->pNewTable;
  int nByte;
  int i;
  int nCol;
  char *z;
 
  assert( pTo!=0 );
  if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
  if( pFromCol==0 ){
    int iCol = p->nCol-1;
    if( NEVER(iCol<0) ) goto fk_end;
    if( pToCol && pToCol->nExpr!=1 ){
      sqlite3ErrorMsg(pParse, "foreign key on %s"
         " should reference only one column of table %T",
         p->aCol[iCol].zName, pTo);
      goto fk_end;
    }
    nCol = 1;
  }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
    sqlite3ErrorMsg(pParse,
        "number of columns in foreign key does not match the number of "
        "columns in the referenced table");
    goto fk_end;
  }else{
    nCol = pFromCol->nExpr;
  }
  nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
  if( pToCol ){
    for(i=0; i<pToCol->nExpr; i++){
      nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1;
    }
  }
  pFKey = sqlite3DbMallocZero(db, nByte );
  if( pFKey==0 ){
    goto fk_end;
  }
  pFKey->pFrom = p;
  pFKey->pNextFrom = p->pFKey;
  z = (char*)&pFKey->aCol[nCol];
  pFKey->zTo = z;
  if( IN_RENAME_OBJECT ){
    sqlite3RenameTokenMap(pParse, (void*)z, pTo);
  }
  memcpy(z, pTo->z, pTo->n);
  z[pTo->n] = 0;
  sqlite3Dequote(z);
  z += pTo->n+1;
  pFKey->nCol = nCol;
  if( pFromCol==0 ){
    pFKey->aCol[0].iFrom = p->nCol-1;
  }else{
    for(i=0; i<nCol; i++){
      int j;
      for(j=0; j<p->nCol; j++){
        if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zEName)==0 ){
          pFKey->aCol[i].iFrom = j;
          break;
        }
      }
      if( j>=p->nCol ){
        sqlite3ErrorMsg(pParse,
          "unknown column \"%s\" in foreign key definition",
          pFromCol->a[i].zEName);
        goto fk_end;
      }
      if( IN_RENAME_OBJECT ){
        sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
      }
    }
  }
  if( pToCol ){
    for(i=0; i<nCol; i++){
      int n = sqlite3Strlen30(pToCol->a[i].zEName);
      pFKey->aCol[i].zCol = z;
      if( IN_RENAME_OBJECT ){
        sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
      }
      memcpy(z, pToCol->a[i].zEName, n);
      z[n] = 0;
      z += n+1;
    }
  }
  pFKey->isDeferred = 0;
  pFKey->aAction[0] = (u8)(flags & 0xff);            /* ON DELETE action */
  pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff);    /* ON UPDATE action */
 
  assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
  pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
      pFKey->zTo, (void *)pFKey
  );
  if( pNextTo==pFKey ){
    sqlite3OomFault(db);
    goto fk_end;
  }
  if( pNextTo ){
    assert( pNextTo->pPrevTo==0 );
    pFKey->pNextTo = pNextTo;
    pNextTo->pPrevTo = pFKey;
  }
 
  /* Link the foreign key to the table as the last step.
  */
  p->pFKey = pFKey;
  pFKey = 0;
 

References ExprList::a, FKey::aAction, Table::aCol, FKey::aCol, Parse::db, Schema::fkeyHash, FKey::sColMap::iFrom, IN_DECLARE_VTAB, IN_RENAME_OBJECT, FKey::isDeferred, Token::n, Table::nCol, FKey::nCol, NEVER, ExprList::nExpr, Table::pFKey, FKey::pFrom, Parse::pNewTable, FKey::pNextFrom, FKey::pNextTo, FKey::pPrevTo, Table::pSchema, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3Dequote(), sqlite3ErrorMsg(), sqlite3ExprListDelete(), sqlite3HashInsert(), sqlite3OomFault(), sqlite3RenameTokenMap(), sqlite3RenameTokenRemap(), sqlite3StrICmp(), sqlite3Strlen30(), Token::z, FKey::sColMap::zCol, ExprList::ExprList_item::zEName, Column::zName, and FKey::zTo.

Referenced by yy_reduce().

◆ sqlite3CreateFunc()

SQLITE_PRIVATE int sqlite3CreateFunc	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	enc,
		void *	pUserData,
		void()(sqlite3_context , int, sqlite3_value **)	xSFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(sqlite3_context )	xValue,
		void()(sqlite3_context , int, sqlite3_value **)	xInverse,
		FuncDestructor *	pDestructor )

Definition at line 162765 of file sqlite3.c.

 {
  FuncDef *p;
  int nName;
  int extraFlags;
 
  assert( sqlite3_mutex_held(db->mutex) );
  assert( xValue==0 || xSFunc==0 );
  if( zFunctionName==0                /* Must have a valid name */
   || (xSFunc!=0 && xFinal!=0)        /* Not both xSFunc and xFinal */
   || ((xFinal==0)!=(xStep==0))       /* Both or neither of xFinal and xStep */
   || ((xValue==0)!=(xInverse==0))    /* Both or neither of xValue, xInverse */
   || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG)
   || (255<(nName = sqlite3Strlen30( zFunctionName)))
  ){
    return SQLITE_MISUSE_BKPT;
  }
 
  assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
  assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
  extraFlags = enc &  (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
                       SQLITE_SUBTYPE|SQLITE_INNOCUOUS);
  enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
 
  /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE.  But
  ** the meaning is inverted.  So flip the bit. */
  assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
  extraFlags ^= SQLITE_FUNC_UNSAFE;
 
 
#ifndef SQLITE_OMIT_UTF16
  /* If SQLITE_UTF16 is specified as the encoding type, transform this
  ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
  ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
  **
  ** If SQLITE_ANY is specified, add three versions of the function
  ** to the hash table.
  */
  if( enc==SQLITE_UTF16 ){
    enc = SQLITE_UTF16NATIVE;
  }else if( enc==SQLITE_ANY ){
    int rc;
    rc = sqlite3CreateFunc(db, zFunctionName, nArg,
         (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE,
         pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
    if( rc==SQLITE_OK ){
      rc = sqlite3CreateFunc(db, zFunctionName, nArg,
           (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE,
           pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
    }
    if( rc!=SQLITE_OK ){
      return rc;
    }
    enc = SQLITE_UTF16BE;
  }
#else
  enc = SQLITE_UTF8;
#endif
 
  /* Check if an existing function is being overridden or deleted. If so,
  ** and there are active VMs, then return SQLITE_BUSY. If a function
  ** is being overridden/deleted but there are no active VMs, allow the
  ** operation to continue but invalidate all precompiled statements.
  */
  p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
  if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){
    if( db->nVdbeActive ){
      sqlite3ErrorWithMsg(db, SQLITE_BUSY,
        "unable to delete/modify user-function due to active statements");
      assert( !db->mallocFailed );
      return SQLITE_BUSY;
    }else{
      sqlite3ExpirePreparedStatements(db, 0);
    }
  }
 
  p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
  assert(p || db->mallocFailed);
  if( !p ){
    return SQLITE_NOMEM_BKPT;
  }
 
  /* If an older version of the function with a configured destructor is
  ** being replaced invoke the destructor function here. */
  functionDestroy(db, p);
 
  if( pDestructor ){
    pDestructor->nRef++;
  }
  p->u.pDestructor = pDestructor;
  p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
  testcase( p->funcFlags & SQLITE_DETERMINISTIC );
  testcase( p->funcFlags & SQLITE_DIRECTONLY );
  p->xSFunc = xSFunc ? xSFunc : xStep;
  p->xFinalize = xFinal;

References FuncDef::funcFlags, functionDestroy(), sqlite3::mallocFailed, sqlite3::mutex, FuncDef::nArg, nName, FuncDestructor::nRef, sqlite3::nVdbeActive, FuncDef::pDestructor, FuncDef::pUserData, sqlite3_mutex_held(), sqlite3CreateFunc(), sqlite3ErrorWithMsg(), sqlite3ExpirePreparedStatements(), sqlite3FindFunction(), sqlite3Strlen30(), SQLITE_ANY, SQLITE_BUSY, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_FUNC_CONSTANT, SQLITE_FUNC_DIRECT, SQLITE_FUNC_ENCMASK, SQLITE_FUNC_UNSAFE, SQLITE_INNOCUOUS, SQLITE_MAX_FUNCTION_ARG, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_SUBTYPE, SQLITE_UTF16, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF16NATIVE, SQLITE_UTF8, testcase, FuncDef::u, FuncDef::xFinalize, FuncDef::xInverse, FuncDef::xSFunc, and FuncDef::xValue.

Referenced by createFunctionApi(), sqlite3CreateFunc(), and sqlite3RegisterLikeFunctions().

◆ sqlite3CreateIndex()

SQLITE_PRIVATE void sqlite3CreateIndex	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		SrcList *	pTblName,
		ExprList *	pList,
		int	onError,
		Token *	pStart,
		Expr *	pPIWhere,
		int	sortOrder,
		int	ifNotExist,
		u8	idxType )

Definition at line 113869 of file sqlite3.c.

 {
  Table *pTab = 0;     /* Table to be indexed */
  Index *pIndex = 0;   /* The index to be created */
  char *zName = 0;     /* Name of the index */
  int nName;           /* Number of characters in zName */
  int i, j;
  DbFixer sFix;        /* For assigning database names to pTable */
  int sortOrderMask;   /* 1 to honor DESC in index.  0 to ignore. */
  sqlite3 *db = pParse->db;
  Db *pDb;             /* The specific table containing the indexed database */
  int iDb;             /* Index of the database that is being written */
  Token *pName = 0;    /* Unqualified name of the index to create */
  struct ExprList_item *pListItem; /* For looping over pList */
  int nExtra = 0;                  /* Space allocated for zExtra[] */
  int nExtraCol;                   /* Number of extra columns needed */
  char *zExtra = 0;                /* Extra space after the Index object */
  Index *pPk = 0;      /* PRIMARY KEY index for WITHOUT ROWID tables */
 
  if( db->mallocFailed || pParse->nErr>0 ){
    goto exit_create_index;
  }
  if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
    goto exit_create_index;
  }
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    goto exit_create_index;
  }
  if( sqlite3HasExplicitNulls(pParse, pList) ){
    goto exit_create_index;
  }
 
  /*
  ** Find the table that is to be indexed.  Return early if not found.
  */
  if( pTblName!=0 ){
 
    /* Use the two-part index name to determine the database
    ** to search for the table. 'Fix' the table name to this db
    ** before looking up the table.
    */
    assert( pName1 && pName2 );
    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
    if( iDb<0 ) goto exit_create_index;
    assert( pName && pName->z );
 
#ifndef SQLITE_OMIT_TEMPDB
    /* If the index name was unqualified, check if the table
    ** is a temp table. If so, set the database to 1. Do not do this
    ** if initialising a database schema.
    */
    if( !db->init.busy ){
      pTab = sqlite3SrcListLookup(pParse, pTblName);
      if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
        iDb = 1;
      }
    }
#endif
 
    sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
    if( sqlite3FixSrcList(&sFix, pTblName) ){
      /* Because the parser constructs pTblName from a single identifier,
      ** sqlite3FixSrcList can never fail. */
      assert(0);
    }
    pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
    assert( db->mallocFailed==0 || pTab==0 );
    if( pTab==0 ) goto exit_create_index;
    if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
      sqlite3ErrorMsg(pParse,
           "cannot create a TEMP index on non-TEMP table \"%s\"",
           pTab->zName);
      goto exit_create_index;
    }
    if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
  }else{
    assert( pName==0 );
    assert( pStart==0 );
    pTab = pParse->pNewTable;
    if( !pTab ) goto exit_create_index;
    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  }
  pDb = &db->aDb[iDb];
 
  assert( pTab!=0 );
  assert( pParse->nErr==0 );
  if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
       && db->init.busy==0
       && pTblName!=0
#if SQLITE_USER_AUTHENTICATION
       && sqlite3UserAuthTable(pTab->zName)==0
#endif
  ){
    sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
    goto exit_create_index;
  }
#ifndef SQLITE_OMIT_VIEW
  if( pTab->pSelect ){
    sqlite3ErrorMsg(pParse, "views may not be indexed");
    goto exit_create_index;
  }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
    goto exit_create_index;
  }
#endif
 
  /*
  ** Find the name of the index.  Make sure there is not already another
  ** index or table with the same name.
  **
  ** Exception:  If we are reading the names of permanent indices from the
  ** sqlite_schema table (because some other process changed the schema) and
  ** one of the index names collides with the name of a temporary table or
  ** index, then we will continue to process this index.
  **
  ** If pName==0 it means that we are
  ** dealing with a primary key or UNIQUE constraint.  We have to invent our
  ** own name.
  */
  if( pName ){
    zName = sqlite3NameFromToken(db, pName);
    if( zName==0 ) goto exit_create_index;
    assert( pName->z!=0 );
    if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
      goto exit_create_index;
    }
    if( !IN_RENAME_OBJECT ){
      if( !db->init.busy ){
        if( sqlite3FindTable(db, zName, 0)!=0 ){
          sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
          goto exit_create_index;
        }
      }
      if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
        if( !ifNotExist ){
          sqlite3ErrorMsg(pParse, "index %s already exists", zName);
        }else{
          assert( !db->init.busy );
          sqlite3CodeVerifySchema(pParse, iDb);
        }
        goto exit_create_index;
      }
    }
  }else{
    int n;
    Index *pLoop;
    for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
    zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
    if( zName==0 ){
      goto exit_create_index;
    }
 
    /* Automatic index names generated from within sqlite3_declare_vtab()
    ** must have names that are distinct from normal automatic index names.
    ** The following statement converts "sqlite3_autoindex..." into
    ** "sqlite3_butoindex..." in order to make the names distinct.
    ** The "vtab_err.test" test demonstrates the need of this statement. */
    if( IN_SPECIAL_PARSE ) zName[7]++;
  }
 
  /* Check for authorization to create an index.
  */
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( !IN_RENAME_OBJECT ){
    const char *zDb = pDb->zDbSName;
    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
      goto exit_create_index;
    }
    i = SQLITE_CREATE_INDEX;
    if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
    if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
      goto exit_create_index;
    }
  }
#endif
 
  /* If pList==0, it means this routine was called to make a primary
  ** key out of the last column added to the table under construction.
  ** So create a fake list to simulate this.
  */
  if( pList==0 ){
    Token prevCol;
    Column *pCol = &pTab->aCol[pTab->nCol-1];
    pCol->colFlags |= COLFLAG_UNIQUE;
    sqlite3TokenInit(&prevCol, pCol->zName);
    pList = sqlite3ExprListAppend(pParse, 0,
              sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
    if( pList==0 ) goto exit_create_index;
    assert( pList->nExpr==1 );
    sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
  }else{
    sqlite3ExprListCheckLength(pParse, pList, "index");
    if( pParse->nErr ) goto exit_create_index;
  }
 
  /* Figure out how many bytes of space are required to store explicitly
  ** specified collation sequence names.
  */
  for(i=0; i<pList->nExpr; i++){
    Expr *pExpr = pList->a[i].pExpr;
    assert( pExpr!=0 );
    if( pExpr->op==TK_COLLATE ){
      nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
    }
  }
 
  /*
  ** Allocate the index structure.
  */
  nName = sqlite3Strlen30(zName);
  nExtraCol = pPk ? pPk->nKeyCol : 1;
  assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
  pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
                                      nName + nExtra + 1, &zExtra);
  if( db->mallocFailed ){
    goto exit_create_index;
  }
  assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
  assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
  pIndex->zName = zExtra;
  zExtra += nName + 1;
  memcpy(pIndex->zName, zName, nName+1);
  pIndex->pTable = pTab;
  pIndex->onError = (u8)onError;
  pIndex->uniqNotNull = onError!=OE_None;
  pIndex->idxType = idxType;
  pIndex->pSchema = db->aDb[iDb].pSchema;
  pIndex->nKeyCol = pList->nExpr;
  if( pPIWhere ){
    sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
    pIndex->pPartIdxWhere = pPIWhere;
    pPIWhere = 0;
  }
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
 
  /* Check to see if we should honor DESC requests on index columns
  */
  if( pDb->pSchema->file_format>=4 ){
    sortOrderMask = -1;   /* Honor DESC */
  }else{
    sortOrderMask = 0;    /* Ignore DESC */
  }
 
  /* Analyze the list of expressions that form the terms of the index and
  ** report any errors.  In the common case where the expression is exactly
  ** a table column, store that column in aiColumn[].  For general expressions,
  ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
  **
  ** TODO: Issue a warning if two or more columns of the index are identical.
  ** TODO: Issue a warning if the table primary key is used as part of the
  ** index key.
  */
  pListItem = pList->a;
  if( IN_RENAME_OBJECT ){
    pIndex->aColExpr = pList;
    pList = 0;
  }
  for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
    Expr *pCExpr;                  /* The i-th index expression */
    int requestedSortOrder;        /* ASC or DESC on the i-th expression */
    const char *zColl;             /* Collation sequence name */
 
    sqlite3StringToId(pListItem->pExpr);
    sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
    if( pParse->nErr ) goto exit_create_index;
    pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
    if( pCExpr->op!=TK_COLUMN ){
      if( pTab==pParse->pNewTable ){
        sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
                                "UNIQUE constraints");
        goto exit_create_index;
      }
      if( pIndex->aColExpr==0 ){
        pIndex->aColExpr = pList;
        pList = 0;
      }
      j = XN_EXPR;
      pIndex->aiColumn[i] = XN_EXPR;
      pIndex->uniqNotNull = 0;
    }else{
      j = pCExpr->iColumn;
      assert( j<=0x7fff );
      if( j<0 ){
        j = pTab->iPKey;
      }else{
        if( pTab->aCol[j].notNull==0 ){
          pIndex->uniqNotNull = 0;
        }
        if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
          pIndex->bHasVCol = 1;
        }
      }
      pIndex->aiColumn[i] = (i16)j;
    }
    zColl = 0;
    if( pListItem->pExpr->op==TK_COLLATE ){
      int nColl;
      zColl = pListItem->pExpr->u.zToken;
      nColl = sqlite3Strlen30(zColl) + 1;
      assert( nExtra>=nColl );
      memcpy(zExtra, zColl, nColl);
      zColl = zExtra;
      zExtra += nColl;
      nExtra -= nColl;
    }else if( j>=0 ){
      zColl = pTab->aCol[j].zColl;
    }
    if( !zColl ) zColl = sqlite3StrBINARY;
    if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
      goto exit_create_index;
    }
    pIndex->azColl[i] = zColl;
    requestedSortOrder = pListItem->sortFlags & sortOrderMask;
    pIndex->aSortOrder[i] = (u8)requestedSortOrder;
  }
 
  /* Append the table key to the end of the index.  For WITHOUT ROWID
  ** tables (when pPk!=0) this will be the declared PRIMARY KEY.  For
  ** normal tables (when pPk==0) this will be the rowid.
  */
  if( pPk ){
    for(j=0; j<pPk->nKeyCol; j++){
      int x = pPk->aiColumn[j];
      assert( x>=0 );
      if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
        pIndex->nColumn--;
      }else{
        testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
        pIndex->aiColumn[i] = x;
        pIndex->azColl[i] = pPk->azColl[j];
        pIndex->aSortOrder[i] = pPk->aSortOrder[j];
        i++;
      }
    }
    assert( i==pIndex->nColumn );
  }else{
    pIndex->aiColumn[i] = XN_ROWID;
    pIndex->azColl[i] = sqlite3StrBINARY;
  }
  sqlite3DefaultRowEst(pIndex);
  if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
 
  /* If this index contains every column of its table, then mark
  ** it as a covering index */
  assert( HasRowid(pTab)
      || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
  recomputeColumnsNotIndexed(pIndex);
  if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
    pIndex->isCovering = 1;
    for(j=0; j<pTab->nCol; j++){
      if( j==pTab->iPKey ) continue;
      if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue;
      pIndex->isCovering = 0;
      break;
    }
  }
 
  if( pTab==pParse->pNewTable ){
    /* This routine has been called to create an automatic index as a
    ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
    ** a PRIMARY KEY or UNIQUE clause following the column definitions.
    ** i.e. one of:
    **
    ** CREATE TABLE t(x PRIMARY KEY, y);
    ** CREATE TABLE t(x, y, UNIQUE(x, y));
    **
    ** Either way, check to see if the table already has such an index. If
    ** so, don't bother creating this one. This only applies to
    ** automatically created indices. Users can do as they wish with
    ** explicit indices.
    **
    ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
    ** (and thus suppressing the second one) even if they have different
    ** sort orders.
    **
    ** If there are different collating sequences or if the columns of
    ** the constraint occur in different orders, then the constraints are
    ** considered distinct and both result in separate indices.
    */
    Index *pIdx;
    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
      int k;
      assert( IsUniqueIndex(pIdx) );
      assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
      assert( IsUniqueIndex(pIndex) );
 
      if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
      for(k=0; k<pIdx->nKeyCol; k++){
        const char *z1;
        const char *z2;
        assert( pIdx->aiColumn[k]>=0 );
        if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
        z1 = pIdx->azColl[k];
        z2 = pIndex->azColl[k];
        if( sqlite3StrICmp(z1, z2) ) break;
      }
      if( k==pIdx->nKeyCol ){
        if( pIdx->onError!=pIndex->onError ){
          /* This constraint creates the same index as a previous
          ** constraint specified somewhere in the CREATE TABLE statement.
          ** However the ON CONFLICT clauses are different. If both this
          ** constraint and the previous equivalent constraint have explicit
          ** ON CONFLICT clauses this is an error. Otherwise, use the
          ** explicitly specified behavior for the index.
          */
          if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
            sqlite3ErrorMsg(pParse,
                "conflicting ON CONFLICT clauses specified", 0);
          }
          if( pIdx->onError==OE_Default ){
            pIdx->onError = pIndex->onError;
          }
        }
        if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
        if( IN_RENAME_OBJECT ){
          pIndex->pNext = pParse->pNewIndex;
          pParse->pNewIndex = pIndex;
          pIndex = 0;
        }
        goto exit_create_index;
      }
    }
  }
 
  if( !IN_RENAME_OBJECT ){
 
    /* Link the new Index structure to its table and to the other
    ** in-memory database structures.
    */
    assert( pParse->nErr==0 );
    if( db->init.busy ){
      Index *p;
      assert( !IN_SPECIAL_PARSE );
      assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
      if( pTblName!=0 ){
        pIndex->tnum = db->init.newTnum;
        if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
          sqlite3ErrorMsg(pParse, "invalid rootpage");
          pParse->rc = SQLITE_CORRUPT_BKPT;
          goto exit_create_index;
        }
      }
      p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
          pIndex->zName, pIndex);
      if( p ){
        assert( p==pIndex );  /* Malloc must have failed */
        sqlite3OomFault(db);
        goto exit_create_index;
      }
      db->mDbFlags |= DBFLAG_SchemaChange;
    }
 
    /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
    ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
    ** emit code to allocate the index rootpage on disk and make an entry for
    ** the index in the sqlite_schema table and populate the index with
    ** content.  But, do not do this if we are simply reading the sqlite_schema
    ** table to parse the schema, or if this index is the PRIMARY KEY index
    ** of a WITHOUT ROWID table.
    **
    ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
    ** or UNIQUE index in a CREATE TABLE statement.  Since the table
    ** has just been created, it contains no data and the index initialization
    ** step can be skipped.
    */
    else if( HasRowid(pTab) || pTblName!=0 ){
      Vdbe *v;
      char *zStmt;
      int iMem = ++pParse->nMem;
 
      v = sqlite3GetVdbe(pParse);
      if( v==0 ) goto exit_create_index;
 
      sqlite3BeginWriteOperation(pParse, 1, iDb);
 
      /* Create the rootpage for the index using CreateIndex. But before
      ** doing so, code a Noop instruction and store its address in
      ** Index.tnum. This is required in case this index is actually a
      ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
      ** that case the convertToWithoutRowidTable() routine will replace
      ** the Noop with a Goto to jump over the VDBE code generated below. */
      pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
      sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
 
      /* Gather the complete text of the CREATE INDEX statement into
      ** the zStmt variable
      */
      assert( pName!=0 || pStart==0 );
      if( pStart ){
        int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
        if( pName->z[n-1]==';' ) n--;
        /* A named index with an explicit CREATE INDEX statement */
        zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
            onError==OE_None ? "" : " UNIQUE", n, pName->z);
      }else{
        /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
        /* zStmt = sqlite3MPrintf(""); */
        zStmt = 0;
      }
 
      /* Add an entry in sqlite_schema for this index
      */
      sqlite3NestedParse(pParse,
          "INSERT INTO %Q." DFLT_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
          db->aDb[iDb].zDbSName,
          pIndex->zName,
          pTab->zName,
          iMem,
          zStmt
          );
      sqlite3DbFree(db, zStmt);
 
      /* Fill the index with data and reparse the schema. Code an OP_Expire
      ** to invalidate all pre-compiled statements.
      */
      if( pTblName ){
        sqlite3RefillIndex(pParse, pIndex, iMem);
        sqlite3ChangeCookie(pParse, iDb);
        sqlite3VdbeAddParseSchemaOp(v, iDb,
            sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
        sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
      }
 
      sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
    }
  }
  if( db->init.busy || pTblName==0 ){
    pIndex->pNext = pTab->pIndex;
    pTab->pIndex = pIndex;
    pIndex = 0;
  }
  else if( IN_RENAME_OBJECT ){
    assert( pParse->pNewIndex==0 );
    pParse->pNewIndex = pIndex;
    pIndex = 0;
  }
 
  /* Clean up before exiting */
exit_create_index:
  if( pIndex ) sqlite3FreeIndex(db, pIndex);
  if( pTab ){  /* Ensure all REPLACE indexes are at the end of the list */
    Index **ppFrom = &pTab->pIndex;
    Index *pThis;
    for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
      Index *pNext;
      if( pThis->onError!=OE_Replace ) continue;
      while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
        *ppFrom = pNext;
        pThis->pNext = pNext->pNext;
        pNext->pNext = pThis;
        ppFrom = &pNext->pNext;
      }
      break;
    }

References ExprList::a, SrcList::a, Table::aCol, Index::aColExpr, sqlite3::aDb, Index::aiColumn, Index::aiRowLogEst, Index::aSortOrder, Index::azColl, Index::bHasVCol, BTREE_BLOBKEY, sqlite3::sqlite3InitInfo::busy, COLFLAG_UNIQUE, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, DBFLAG_SchemaChange, DFLT_SCHEMA_TABLE, EIGHT_BYTE_ALIGNMENT, estimateIndexWidth(), Schema::file_format, hasColumn(), HasRowid, Expr::iColumn, Schema::idxHash, Index::idxType, IN_DECLARE_VTAB, IN_RENAME_OBJECT, IN_SPECIAL_PARSE, sqlite3::init, Table::iPKey, Index::isCovering, isDupColumn(), IsUniqueIndex, IsVirtual, sqlite3::mallocFailed, sqlite3::mDbFlags, Token::n, NC_IdxExpr, NC_PartIdx, Table::nCol, Index::nColumn, Parse::nErr, sqlite3::sqlite3InitInfo::newTnum, ExprList::nExpr, Index::nKeyCol, Parse::nMem, nName, Column::notNull, OE_Default, OE_None, OE_Replace, OMIT_TEMPDB, Index::onError, Expr::op, OP_CreateBtree, OP_Expire, OP_Noop, ExprList::ExprList_item::pExpr, Table::pIndex, Parse::pNewIndex, Parse::pNewTable, Index::pNext, Index::pPartIdxWhere, Db::pSchema, Table::pSchema, Index::pSchema, Table::pSelect, Index::pTable, Parse::rc, recomputeColumnsNotIndexed(), SCHEMA_TABLE, Parse::sLastToken, sqlite3AllocateIndexObject(), sqlite3AuthCheck(), sqlite3BeginWriteOperation(), sqlite3ChangeCookie(), sqlite3CheckObjectName(), sqlite3CodeVerifySchema(), sqlite3DbFree(), sqlite3DefaultRowEst(), sqlite3ErrorMsg(), sqlite3ExprAlloc(), sqlite3ExprDelete(), sqlite3ExprListAppend(), sqlite3ExprListCheckLength(), sqlite3ExprListDelete(), sqlite3ExprListSetSortOrder(), sqlite3ExprSkipCollate(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3FixInit(), sqlite3FixSrcList(), sqlite3FreeIndex(), sqlite3GetVdbe(), sqlite3HasExplicitNulls(), sqlite3HashInsert(), sqlite3IndexHasDuplicateRootPage(), sqlite3LocateCollSeq(), sqlite3LocateTableItem(), sqlite3MPrintf(), sqlite3NameFromToken(), sqlite3NestedParse(), sqlite3OomFault(), sqlite3PrimaryKeyIndex(), sqlite3ReadSchema(), sqlite3RefillIndex(), sqlite3ResolveSelfReference(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3StrBINARY, sqlite3StrICmp(), sqlite3StringToId(), sqlite3Strlen30(), sqlite3StrNICmp, sqlite3TableColumnToIndex(), sqlite3TokenInit(), sqlite3TwoPartName(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddParseSchemaOp(), sqlite3VdbeJumpHere(), SQLITE_CORRUPT_BKPT, SQLITE_CREATE_INDEX, SQLITE_CREATE_TEMP_INDEX, SQLITE_IDXTYPE_APPDEF, SQLITE_IDXTYPE_PRIMARYKEY, SQLITE_INSERT, SQLITE_OK, SQLITE_SO_UNDEFINED, testcase, TK_COLLATE, TK_COLUMN, TK_ID, Index::tnum, Expr::u, Index::uniqNotNull, XN_EXPR, XN_ROWID, Token::z, Column::zColl, Db::zDbSName, Column::zName, Table::zName, Index::zName, zName, and Expr::zToken.

Referenced by convertToWithoutRowidTable(), sqlite3AddPrimaryKey(), and yy_reduce().

◆ sqlite3CreateView()

SQLITE_PRIVATE void sqlite3CreateView	(	Parse *	pParse,
		Token *	pBegin,
		Token *	pName1,
		Token *	pName2,
		ExprList *	pCNames,
		Select *	pSelect,
		int	isTemp,
		int	noErr )

Definition at line 112951 of file sqlite3.c.

 {
  Table *p;
  int n;
  const char *z;
  Token sEnd;
  DbFixer sFix;
  Token *pName = 0;
  int iDb;
  sqlite3 *db = pParse->db;
 
  if( pParse->nVar>0 ){
    sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
    goto create_view_fail;
  }
  sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
  p = pParse->pNewTable;
  if( p==0 || pParse->nErr ) goto create_view_fail;
  sqlite3TwoPartName(pParse, pName1, pName2, &pName);
  iDb = sqlite3SchemaToIndex(db, p->pSchema);
  sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
  if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
 
  /* Make a copy of the entire SELECT statement that defines the view.
  ** This will force all the Expr.token.z values to be dynamically
  ** allocated rather than point to the input string - which means that
  ** they will persist after the current sqlite3_exec() call returns.
  */
  pSelect->selFlags |= SF_View;
  if( IN_RENAME_OBJECT ){
    p->pSelect = pSelect;
    pSelect = 0;
  }else{
    p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
  }
  p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
  if( db->mallocFailed ) goto create_view_fail;
 
  /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
  ** the end.
  */
  sEnd = pParse->sLastToken;
  assert( sEnd.z[0]!=0 || sEnd.n==0 );
  if( sEnd.z[0]!=';' ){
    sEnd.z += sEnd.n;
  }
  sEnd.n = 0;
  n = (int)(sEnd.z - pBegin->z);
  assert( n>0 );
  z = pBegin->z;
  while( sqlite3Isspace(z[n-1]) ){ n--; }
  sEnd.z = &z[n-1];
  sEnd.n = 1;
 
  /* Use sqlite3EndTable() to add the view to the schema table */
  sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
 
create_view_fail:
  sqlite3SelectDelete(db, pSelect);

Referenced by yy_reduce().

◆ sqlite3DbFree()

SQLITE_PRIVATE void sqlite3DbFree	(	sqlite3 *	db,
		void *	p )

Definition at line 27757 of file sqlite3.c.

Referenced by addModuleArgument(), analyzeOneTable(), attachFunc(), btreeMoveto(), callCollNeeded(), callFinaliser(), codeEqualityTerm(), deleteTable(), findBtree(), findCollSeqEntry(), fkActionTrigger(), fkTriggerDelete(), flattenSubquery(), freeP4FuncCtx(), functionDestroy(), propagateConstants(), renameEditSql(), resolveAlias(), resolveP2Values(), selectExpander(), sqlite3_blob_reopen(), sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_step(), sqlite3_str_vappendf(), sqlite3_table_column_metadata(), sqlite3AddColumn(), sqlite3AddDefaultValue(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3AnalysisLoad(), sqlite3Analyze(), sqlite3BeginTrigger(), sqlite3CloseSavepoints(), sqlite3CodeRhsOfIN(), sqlite3CollapseDatabaseArray(), sqlite3ColumnsFromExprList(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3DbReallocOrFree(), sqlite3DeleteFrom(), sqlite3DeleteTriggerStep(), sqlite3EndTable(), sqlite3ErrorMsg(), sqlite3ExprCodeIN(), sqlite3FindDb(), sqlite3FindFunction(), sqlite3FixSrcList(), sqlite3FkCheck(), sqlite3FkDelete(), sqlite3FkLocateIndex(), sqlite3InitOne(), sqlite3Insert(), sqlite3LeaveMutexAndCloseZombie(), sqlite3NestedParse(), sqlite3PagerOpen(), sqlite3Pragma(), sqlite3Prepare16(), sqlite3Reindex(), sqlite3RowSetClear(), sqlite3RowSetDelete(), sqlite3RunParser(), sqlite3SrcListAppendList(), sqlite3StartTable(), sqlite3TriggerStepSrc(), sqlite3Update(), sqlite3UpsertDelete(), sqlite3VdbeClearObject(), sqlite3VdbeDeleteAuxData(), sqlite3VdbeExec(), sqlite3VdbeFrameDelete(), sqlite3VdbeHalt(), sqlite3VdbeReset(), sqlite3VdbeSetNumCols(), sqlite3VtabCallConnect(), sqlite3VtabClear(), sqlite3VtabCreateModule(), sqlite3VtabEponymousTableInit(), sqlite3VtabImportErrmsg(), sqlite3WhereBegin(), sqlite3WhereClauseClear(), sqlite3WhereEnd(), sqlite3WindowChain(), sqlite3WindowRewrite(), sqlite3WithAdd(), transferParseError(), valueFromExpr(), vdbeCommit(), vdbeFreeOpArray(), vtabCallConstructor(), whereClauseInsert(), and whereLoopAddVirtual().

◆ sqlite3DbFreeNN()

SQLITE_PRIVATE void sqlite3DbFreeNN	(	sqlite3 *	db,
		void *	p )

Definition at line 27720 of file sqlite3.c.

                                                         {
  assert( db==0 || sqlite3_mutex_held(db->mutex) );
  assert( p!=0 );
  if( db ){
    if( db->pnBytesFreed ){
      measureAllocationSize(db, p);
      return;
    }
    if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
      if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){
        LookasideSlot *pBuf = (LookasideSlot*)p;
#ifdef SQLITE_DEBUG
        memset(p, 0xaa, LOOKASIDE_SMALL);  /* Trash freed content */
#endif
        pBuf->pNext = db->lookaside.pSmallFree;
        db->lookaside.pSmallFree = pBuf;
        return;
      }
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
      if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){
        LookasideSlot *pBuf = (LookasideSlot*)p;
#ifdef SQLITE_DEBUG
        memset(p, 0xaa, db->lookaside.szTrue);  /* Trash freed content */
#endif
        pBuf->pNext = db->lookaside.pFree;
        db->lookaside.pFree = pBuf;
        return;
      }
    }
  }
  assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

References sqlite3::lookaside, LOOKASIDE_SMALL, measureAllocationSize(), MEMTYPE_HEAP, MEMTYPE_LOOKASIDE, sqlite3::mutex, Lookaside::pEnd, Lookaside::pFree, Lookaside::pMiddle, sqlite3::pnBytesFreed, LookasideSlot::pNext, Lookaside::pSmallFree, Lookaside::pStart, sqlite3_mutex_held(), sqlite3MemdebugHasType, and Lookaside::szTrue.

Referenced by clearSelect(), freeEphemeralFunction(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeMemFinalize(), sqlite3VdbeMemGrow(), valueNew(), vdbeFreeOpArray(), vdbeMemClear(), whereLoopAddVirtual(), and wherePathSolver().

◆ sqlite3DbIsNamed()

SQLITE_PRIVATE int sqlite3DbIsNamed	(	sqlite3 *	db,
		int	iDb,
		const char *	zName )

Definition at line 109540 of file sqlite3.c.

Referenced by attachFunc(), detachFunc(), sqlite3DropTrigger(), and sqlite3FindIndex().

◆ sqlite3DbMallocRaw()

SQLITE_PRIVATE void * sqlite3DbMallocRaw	(	sqlite3 *	db,
		u64	n )

Definition at line 27893 of file sqlite3.c.

                             : "a") worked too.
**
** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is
** not a NULL pointer.
*/
SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
  void *p;

Referenced by createTableStmt(), exprINAffinity(), printfTempBuf(), sqlite3_exec(), sqlite3AddColumn(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3IndexAffinityStr(), sqlite3PagerOpen(), sqlite3TableAffinity(), sqlite3VdbeAllocUnpackedRecord(), sqlite3VdbeMemGrow(), sqlite3VdbeMemTranslate(), and strAccumFinishRealloc().

◆ sqlite3DbMallocRawNN()

SQLITE_PRIVATE void * sqlite3DbMallocRawNN	(	sqlite3 *	db,
		u64	n )

Definition at line 27900 of file sqlite3.c.

                                                             {
#ifndef SQLITE_OMIT_LOOKASIDE
  LookasideSlot *pBuf;
  assert( db!=0 );
  assert( sqlite3_mutex_held(db->mutex) );
  assert( db->pnBytesFreed==0 );
  if( n>db->lookaside.sz ){
    if( !db->lookaside.bDisable ){
      db->lookaside.anStat[1]++;
    }else if( db->mallocFailed ){
      return 0;
    }
    return dbMallocRawFinish(db, n);
  }
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
  if( n<=LOOKASIDE_SMALL ){
    if( (pBuf = db->lookaside.pSmallFree)!=0 ){
      db->lookaside.pSmallFree = pBuf->pNext;
      db->lookaside.anStat[0]++;
      return (void*)pBuf;
    }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){
      db->lookaside.pSmallInit = pBuf->pNext;
      db->lookaside.anStat[0]++;
      return (void*)pBuf;
    }
  }
#endif
  if( (pBuf = db->lookaside.pFree)!=0 ){
    db->lookaside.pFree = pBuf->pNext;
    db->lookaside.anStat[0]++;
    return (void*)pBuf;
  }else if( (pBuf = db->lookaside.pInit)!=0 ){
    db->lookaside.pInit = pBuf->pNext;
    db->lookaside.anStat[0]++;
    return (void*)pBuf;
  }else{
    db->lookaside.anStat[2]++;
  }
#else
  assert( db!=0 );
  assert( sqlite3_mutex_held(db->mutex) );
  assert( db->pnBytesFreed==0 );
  if( db->mallocFailed ){

Referenced by analyzeOneTable(), attachFunc(), autoIncBegin(), exprAnalyzeOrTerm(), exprDup(), multiSelectOrderBy(), rowSetEntryAlloc(), sqlite3DbRealloc(), sqlite3DeleteFrom(), sqlite3ExprAlloc(), sqlite3ExprListAppend(), sqlite3FkLocateIndex(), sqlite3HexToBlob(), sqlite3Insert(), sqlite3PExpr(), sqlite3Pragma(), sqlite3RowSetInit(), sqlite3SelectNew(), sqlite3SrcListAppend(), sqlite3SrcListDup(), sqlite3Update(), sqlite3VdbeAddFunctionCall(), sqlite3VdbeExec(), sqlite3VdbeMakeReady(), sqlite3VdbeSetNumCols(), sqlite3WhereBegin(), strftimeFunc(), tokenExpr(), whereClauseInsert(), whereLoopInsert(), and wherePathSolver().

◆ sqlite3DbMallocSize()

SQLITE_PRIVATE int sqlite3DbMallocSize	(	sqlite3 *	db,
		void *	p )

Definition at line 27654 of file sqlite3.c.

                                                        : LOOKASIDE_SMALL;
#else
  return db->lookaside.szTrue;
#endif
}
SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
  assert( p!=0 );
#ifdef SQLITE_DEBUG
  if( db==0 || !isLookaside(db,p) ){
    if( db==0 ){
      assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
      assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
    }else{
      assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
    }
  }
#endif
  if( db ){
    if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
      if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){
        assert( sqlite3_mutex_held(db->mutex) );
        return LOOKASIDE_SMALL;
      }
#endif
      if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){
        assert( sqlite3_mutex_held(db->mutex) );
        return db->lookaside.szTrue;

Referenced by growOpArray(), measureAllocationSize(), sqlite3_str_vappendf(), sqlite3RowSetInit(), sqlite3StrAccumEnlarge(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemTranslate(), and whereClauseInsert().

◆ sqlite3DbMallocZero()

SQLITE_PRIVATE void * sqlite3DbMallocZero	(	sqlite3 *	db,
		u64	n )

Definition at line 27849 of file sqlite3.c.

27854 {

27855 void *p;

References sqlite3DbMallocRaw(), and testcase.

Referenced by allocateIndexInfo(), analyzeOneTable(), codeDeferredSeek(), codeEqualityTerm(), convertCompoundSelectToSubquery(), exprAnalyzeOrTerm(), findCollSeqEntry(), fkActionTrigger(), renameEditSql(), sqlite3_set_auxdata(), sqlite3AllocateIndexObject(), sqlite3AlterBeginAddColumn(), sqlite3BeginTrigger(), sqlite3BtreeSchema(), sqlite3ColumnsFromExprList(), sqlite3CreateForeignKey(), sqlite3ExpandSubquery(), sqlite3ExprCodeIN(), sqlite3FindFunction(), sqlite3IdListAppend(), sqlite3LoadExtension(), sqlite3RenameTokenMap(), sqlite3Select(), sqlite3SelectNew(), sqlite3StartTable(), sqlite3TriggerSelectStep(), sqlite3VdbeExec(), sqlite3VdbeSorterInit(), sqlite3VtabEponymousTableInit(), sqlite3VtabOverloadFunction(), sqlite3WindowDup(), sqlite3WindowRewrite(), sqlite3WithAdd(), statInit(), triggerStepAllocate(), valueNew(), vdbeSorterSetupMerge(), withDup(), withExpand(), and yy_reduce().

◆ sqlite3DbNameToBtree()

SQLITE_PRIVATE Btree * sqlite3DbNameToBtree	(	sqlite3 *	db,
		const char *	zDbName )

Definition at line 165375 of file sqlite3.c.

◆ sqlite3DbRealloc()

SQLITE_PRIVATE void * sqlite3DbRealloc	(	sqlite3 *	db,
		void *	p,
		u64	n )

Definition at line 27956 of file sqlite3.c.

                                                                  {
  assert( db!=0 );
  if( p==0 ) return sqlite3DbMallocRawNN(db, n);
  assert( sqlite3_mutex_held(db->mutex) );
  if( ((uptr)p)<(uptr)db->lookaside.pEnd ){
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
    if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){
      if( n<=LOOKASIDE_SMALL ) return p;
    }else
#endif
    if( ((uptr)p)>=(uptr)db->lookaside.pStart ){

References sqlite3::lookaside, LOOKASIDE_SMALL, sqlite3::mutex, Lookaside::pEnd, Lookaside::pMiddle, Lookaside::pStart, sqlite3_mutex_held(), and sqlite3DbMallocRawNN().

Referenced by addModuleArgument(), attachFunc(), growOpArray(), sqlite3AddColumn(), sqlite3ArrayAllocate(), sqlite3DbReallocOrFree(), sqlite3ExprListAppend(), sqlite3SrcListEnlarge(), sqlite3StrAccumEnlarge(), sqlite3VListAdd(), and sqlite3WithAdd().

◆ sqlite3DbReallocOrFree()

SQLITE_PRIVATE void * sqlite3DbReallocOrFree	(	sqlite3 *	db,
		void *	p,
		u64	n )

Definition at line 28002 of file sqlite3.c.

                                                                        {
  void *pNew;
  pNew = sqlite3DbRealloc(db, p, n);

References sqlite3DbFree(), and sqlite3DbRealloc().

Referenced by codeEqualityTerm(), constInsert(), resizeResolveLabel(), sqlite3SelectAddColumnTypeAndCollation(), sqlite3TableLock(), and sqlite3VdbeMemGrow().

◆ sqlite3DbSpanDup()

SQLITE_PRIVATE char * sqlite3DbSpanDup	(	sqlite3 *	db,
		const char *	zStart,
		const char *	zEnd )

Definition at line 28049 of file sqlite3.c.

28054 {

28055 int n;

References ALWAYS, sqlite3DbStrNDup(), and sqlite3Isspace.

Referenced by sqlite3AddDefaultValue(), and sqlite3ExprListSetSpan().

◆ sqlite3DbStrDup()

SQLITE_PRIVATE char * sqlite3DbStrDup	(	sqlite3 *	db,
		const char *	z )

Definition at line 28018 of file sqlite3.c.

                                                                {
  char *zNew;
  size_t n;
  if( z==0 ){
    return 0;
  }
  n = strlen(z) + 1;
  zNew = sqlite3DbMallocRaw(db, n);

References sqlite3DbMallocRaw().

Referenced by attachFunc(), callCollNeeded(), codeAllEqualityTerms(), corruptSchema(), generateColumnNames(), resolveAlias(), selectExpander(), sqlite3_exec(), sqlite3_step(), sqlite3AlterBeginAddColumn(), sqlite3BeginTrigger(), sqlite3ColumnsFromExprList(), sqlite3ExpandSubquery(), sqlite3MaterializeView(), sqlite3PagerOpen(), sqlite3SelectAddColumnTypeAndCollation(), sqlite3SrcListDup(), sqlite3StartTable(), sqlite3TriggerStepSrc(), sqlite3VdbeExec(), sqlite3VtabBeginParse(), sqlite3VtabEponymousTableInit(), sqlite3VtabImportErrmsg(), sqlite3WindowDup(), vtabCallConstructor(), withDup(), and withExpand().

◆ sqlite3DbStrNDup()

SQLITE_PRIVATE char * sqlite3DbStrNDup	(	sqlite3 *	db,
		const char *	z,
		u64	n )

Definition at line 28031 of file sqlite3.c.

            {
    memcpy(zNew, z, n);
  }
  return zNew;
}
SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
  char *zNew;
  assert( db!=0 );
  assert( z!=0 || n==0 );
  assert( (n&0x7fffffff)==n );
  zNew = z ? sqlite3DbMallocRawNN(db, n+1) : 0;
  if( zNew ){

Referenced by addArgumentToVtab(), sqlite3AlterFinishAddColumn(), sqlite3DbSpanDup(), sqlite3ExprListSetName(), sqlite3NameFromToken(), sqlite3RunParser(), sqlite3WindowAssemble(), and yy_reduce().

◆ sqlite3DecOrHexToI64()

SQLITE_PRIVATE int sqlite3DecOrHexToI64	(	const char *	z,
		i64 *	pOut )

Definition at line 31951 of file sqlite3.c.

                                                                 {
#ifndef SQLITE_OMIT_HEX_INTEGER
  if( z[0]=='0'
   && (z[1]=='x' || z[1]=='X')
  ){
    u64 u = 0;
    int i, k;
    for(i=2; z[i]=='0'; i++){}
    for(k=i; sqlite3Isxdigit(z[k]); k++){
      u = u*16 + sqlite3HexToInt(z[k]);
    }
    memcpy(pOut, &u, 8);
    return (z[k]==0 && k-i<=16) ? 0 : 2;

References sqlite3Atoi64(), sqlite3HexToInt(), sqlite3Isxdigit, sqlite3Strlen30(), and SQLITE_UTF8.

Referenced by codeInteger(), and sqlite3Pragma().

◆ sqlite3DefaultMutex()

SQLITE_PRIVATE sqlite3_mutex_methods const * sqlite3DefaultMutex ( void )

Definition at line 26596 of file sqlite3.c.

                                                                     {
  static const sqlite3_mutex_methods sMutex = {
    pthreadMutexInit,
    pthreadMutexEnd,
    pthreadMutexAlloc,
    pthreadMutexFree,
    pthreadMutexEnter,
    pthreadMutexTry,
    pthreadMutexLeave,
#ifdef SQLITE_DEBUG
    pthreadMutexHeld,
    pthreadMutexNotheld
#else
    0,
    0

Referenced by sqlite3MutexInit().

◆ sqlite3DefaultRowEst()

SQLITE_PRIVATE void sqlite3DefaultRowEst ( Index * pIdx )

Definition at line 114462 of file sqlite3.c.

                                                     {
               /*                10,  9,  8,  7,  6 */
  static const LogEst aVal[] = { 33, 32, 30, 28, 26 };
  LogEst *a = pIdx->aiRowLogEst;
  LogEst x;
  int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
  int i;
 
  /* Indexes with default row estimates should not have stat1 data */
  assert( !pIdx->hasStat1 );
 
  /* Set the first entry (number of rows in the index) to the estimated
  ** number of rows in the table, or half the number of rows in the table
  ** for a partial index.
  **
  ** 2020-05-27:  If some of the stat data is coming from the sqlite_stat1
  ** table but other parts we are having to guess at, then do not let the
  ** estimated number of rows in the table be less than 1000 (LogEst 99).
  ** Failure to do this can cause the indexes for which we do not have
  ** stat1 data to be ignored by the query planner.
  */
  x = pIdx->pTable->nRowLogEst;
  assert( 99==sqlite3LogEst(1000) );
  if( x<99 ){
    pIdx->pTable->nRowLogEst = x = 99;
  }
  if( pIdx->pPartIdxWhere!=0 ) x -= 10;  assert( 10==sqlite3LogEst(2) );
  a[0] = x;
 
  /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
  ** 6 and each subsequent value (if any) is 5.  */
  memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
  for(i=nCopy+1; i<=pIdx->nKeyCol; i++){

References Index::aiRowLogEst, ArraySize, Index::hasStat1, IsUniqueIndex, MIN, Index::nKeyCol, Table::nRowLogEst, Index::pPartIdxWhere, Index::pTable, and sqlite3LogEst().

Referenced by sqlite3AnalysisLoad(), and sqlite3CreateIndex().

◆ sqlite3DeferForeignKey()

SQLITE_PRIVATE void sqlite3DeferForeignKey	(	Parse *	pParse,
		int	isDeferred )

Definition at line 113681 of file sqlite3.c.

                                                                         {
#ifndef SQLITE_OMIT_FOREIGN_KEY
  Table *pTab;

References FKey::isDeferred, Table::pFKey, and Parse::pNewTable.

Referenced by yy_reduce().

◆ sqlite3DeleteColumnNames()

SQLITE_PRIVATE void sqlite3DeleteColumnNames	(	sqlite3 *	db,
		Table *	pTable )

Definition at line 111021 of file sqlite3.c.

                                                                        {
  int i;
  Column *pCol;
  assert( pTable!=0 );
  if( (pCol = pTable->aCol)!=0 ){
    for(i=0; i<pTable->nCol; i++, pCol++){
      assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) );
      sqlite3DbFree(db, pCol->zName);

Referenced by deleteTable(), sqlite3ViewGetColumnNames(), and sqliteViewResetAll().

◆ sqlite3DeleteFrom()

SQLITE_PRIVATE void sqlite3DeleteFrom	(	Parse *	pParse,
		SrcList *	pTabList,
		Expr *	pWhere,
		ExprList *	pOrderBy,
		Expr *	pLimit )

Definition at line 116309 of file sqlite3.c.

 {
  Vdbe *v;               /* The virtual database engine */
  Table *pTab;           /* The table from which records will be deleted */
  int i;                 /* Loop counter */
  WhereInfo *pWInfo;     /* Information about the WHERE clause */
  Index *pIdx;           /* For looping over indices of the table */
  int iTabCur;           /* Cursor number for the table */
  int iDataCur = 0;      /* VDBE cursor for the canonical data source */
  int iIdxCur = 0;       /* Cursor number of the first index */
  int nIdx;              /* Number of indices */
  sqlite3 *db;           /* Main database structure */
  AuthContext sContext;  /* Authorization context */
  NameContext sNC;       /* Name context to resolve expressions in */
  int iDb;               /* Database number */
  int memCnt = 0;        /* Memory cell used for change counting */
  int rcauth;            /* Value returned by authorization callback */
  int eOnePass;          /* ONEPASS_OFF or _SINGLE or _MULTI */
  int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
  u8 *aToOpen = 0;       /* Open cursor iTabCur+j if aToOpen[j] is true */
  Index *pPk;            /* The PRIMARY KEY index on the table */
  int iPk = 0;           /* First of nPk registers holding PRIMARY KEY value */
  i16 nPk = 1;           /* Number of columns in the PRIMARY KEY */
  int iKey;              /* Memory cell holding key of row to be deleted */
  i16 nKey;              /* Number of memory cells in the row key */
  int iEphCur = 0;       /* Ephemeral table holding all primary key values */
  int iRowSet = 0;       /* Register for rowset of rows to delete */
  int addrBypass = 0;    /* Address of jump over the delete logic */
  int addrLoop = 0;      /* Top of the delete loop */
  int addrEphOpen = 0;   /* Instruction to open the Ephemeral table */
  int bComplex;          /* True if there are triggers or FKs or
                         ** subqueries in the WHERE clause */
 
#ifndef SQLITE_OMIT_TRIGGER
  int isView;                  /* True if attempting to delete from a view */
  Trigger *pTrigger;           /* List of table triggers, if required */
#endif
 
  memset(&sContext, 0, sizeof(sContext));
  db = pParse->db;
  if( pParse->nErr || db->mallocFailed ){
    goto delete_from_cleanup;
  }
  assert( pTabList->nSrc==1 );
 
 
  /* Locate the table which we want to delete.  This table has to be
  ** put in an SrcList structure because some of the subroutines we
  ** will be calling are designed to work with multiple tables and expect
  ** an SrcList* parameter instead of just a Table* parameter.
  */
  pTab = sqlite3SrcListLookup(pParse, pTabList);
  if( pTab==0 )  goto delete_from_cleanup;
 
  /* Figure out if we have any triggers and if the table being
  ** deleted from is a view
  */
#ifndef SQLITE_OMIT_TRIGGER
  pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
  isView = pTab->pSelect!=0;
#else
# define pTrigger 0
# define isView 0
#endif
  bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0);
#ifdef SQLITE_OMIT_VIEW
# undef isView
# define isView 0
#endif
 
#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
  if( !isView ){
    pWhere = sqlite3LimitWhere(
        pParse, pTabList, pWhere, pOrderBy, pLimit, "DELETE"
    );
    pOrderBy = 0;
    pLimit = 0;
  }
#endif
 
  /* If pTab is really a view, make sure it has been initialized.
  */
  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
    goto delete_from_cleanup;
  }
 
  if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
    goto delete_from_cleanup;
  }
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb<db->nDb );
  rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
                            db->aDb[iDb].zDbSName);
  assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
  if( rcauth==SQLITE_DENY ){
    goto delete_from_cleanup;
  }
  assert(!isView || pTrigger);
 
  /* Assign cursor numbers to the table and all its indices.
  */
  assert( pTabList->nSrc==1 );
  iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
  for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
    pParse->nTab++;
  }
 
  /* Start the view context
  */
  if( isView ){
    sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
  }
 
  /* Begin generating code.
  */
  v = sqlite3GetVdbe(pParse);
  if( v==0 ){
    goto delete_from_cleanup;
  }
  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
  sqlite3BeginWriteOperation(pParse, bComplex, iDb);
 
  /* If we are trying to delete from a view, realize that view into
  ** an ephemeral table.
  */
#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
  if( isView ){
    sqlite3MaterializeView(pParse, pTab,
        pWhere, pOrderBy, pLimit, iTabCur
    );
    iDataCur = iIdxCur = iTabCur;
    pOrderBy = 0;
    pLimit = 0;
  }
#endif
 
  /* Resolve the column names in the WHERE clause.
  */
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pParse;
  sNC.pSrcList = pTabList;
  if( sqlite3ResolveExprNames(&sNC, pWhere) ){
    goto delete_from_cleanup;
  }
 
  /* Initialize the counter of the number of rows deleted, if
  ** we are counting rows.
  */
  if( (db->flags & SQLITE_CountRows)!=0
   && !pParse->nested
   && !pParse->pTriggerTab
  ){
    memCnt = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
  }
 
#ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
  /* Special case: A DELETE without a WHERE clause deletes everything.
  ** It is easier just to erase the whole table. Prior to version 3.6.5,
  ** this optimization caused the row change count (the value returned by
  ** API function sqlite3_count_changes) to be set incorrectly.
  **
  ** The "rcauth==SQLITE_OK" terms is the
  ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
  ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but
  ** the truncate optimization is disabled and all rows are deleted
  ** individually.
  */
  if( rcauth==SQLITE_OK
   && pWhere==0
   && !bComplex
   && !IsVirtual(pTab)
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
   && db->xPreUpdateCallback==0
#endif
  ){
    assert( !isView );
    sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
    if( HasRowid(pTab) ){
      sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
                        pTab->zName, P4_STATIC);
    }
    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
      assert( pIdx->pSchema==pTab->pSchema );
      sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
    }
  }else
#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
  {
    u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK|WHERE_SEEK_TABLE;
    if( sNC.ncFlags & NC_VarSelect ) bComplex = 1;
    wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW);
    if( HasRowid(pTab) ){
      /* For a rowid table, initialize the RowSet to an empty set */
      pPk = 0;
      nPk = 1;
      iRowSet = ++pParse->nMem;
      sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
    }else{
      /* For a WITHOUT ROWID table, create an ephemeral table used to
      ** hold all primary keys for rows to be deleted. */
      pPk = sqlite3PrimaryKeyIndex(pTab);
      assert( pPk!=0 );
      nPk = pPk->nKeyCol;
      iPk = pParse->nMem+1;
      pParse->nMem += nPk;
      iEphCur = pParse->nTab++;
      addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk);
      sqlite3VdbeSetP4KeyInfo(pParse, pPk);
    }
 
    /* Construct a query to find the rowid or primary key for every row
    ** to be deleted, based on the WHERE clause. Set variable eOnePass
    ** to indicate the strategy used to implement this delete:
    **
    **  ONEPASS_OFF:    Two-pass approach - use a FIFO for rowids/PK values.
    **  ONEPASS_SINGLE: One-pass approach - at most one row deleted.
    **  ONEPASS_MULTI:  One-pass approach - any number of rows may be deleted.
    */
    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, wcf, iTabCur+1);
    if( pWInfo==0 ) goto delete_from_cleanup;
    eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
    assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
    assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
    if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse);
 
    /* Keep track of the number of rows to be deleted */
    if( memCnt ){
      sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
    }
 
    /* Extract the rowid or primary key for the current row */
    if( pPk ){
      for(i=0; i<nPk; i++){
        assert( pPk->aiColumn[i]>=0 );
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
                                        pPk->aiColumn[i], iPk+i);
      }
      iKey = iPk;
    }else{
      iKey = ++pParse->nMem;
      sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
    }
 
    if( eOnePass!=ONEPASS_OFF ){
      /* For ONEPASS, no need to store the rowid/primary-key. There is only
      ** one, so just keep it in its register(s) and fall through to the
      ** delete code.  */
      nKey = nPk; /* OP_Found will use an unpacked key */
      aToOpen = sqlite3DbMallocRawNN(db, nIdx+2);
      if( aToOpen==0 ){
        sqlite3WhereEnd(pWInfo);
        goto delete_from_cleanup;
      }
      memset(aToOpen, 1, nIdx+1);
      aToOpen[nIdx+1] = 0;
      if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0;
      if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0;
      if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
    }else{
      if( pPk ){
        /* Add the PK key for this row to the temporary table */
        iKey = ++pParse->nMem;
        nKey = 0;   /* Zero tells OP_Found to use a composite key */
        sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey,
            sqlite3IndexAffinityStr(pParse->db, pPk), nPk);
        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk);
      }else{
        /* Add the rowid of the row to be deleted to the RowSet */
        nKey = 1;  /* OP_DeferredSeek always uses a single rowid */
        sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
      }
    }
 
    /* If this DELETE cannot use the ONEPASS strategy, this is the
    ** end of the WHERE loop */
    if( eOnePass!=ONEPASS_OFF ){
      addrBypass = sqlite3VdbeMakeLabel(pParse);
    }else{
      sqlite3WhereEnd(pWInfo);
    }
 
    /* Unless this is a view, open cursors for the table we are
    ** deleting from and all its indices. If this is a view, then the
    ** only effect this statement has is to fire the INSTEAD OF
    ** triggers.
    */
    if( !isView ){
      int iAddrOnce = 0;
      if( eOnePass==ONEPASS_MULTI ){
        iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
      }
      testcase( IsVirtual(pTab) );
      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
                                 iTabCur, aToOpen, &iDataCur, &iIdxCur);
      assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
      assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
      if( eOnePass==ONEPASS_MULTI ){
        sqlite3VdbeJumpHereOrPopInst(v, iAddrOnce);
      }
    }
 
    /* Set up a loop over the rowids/primary-keys that were found in the
    ** where-clause loop above.
    */
    if( eOnePass!=ONEPASS_OFF ){
      assert( nKey==nPk );  /* OP_Found will use an unpacked key */
      if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
        assert( pPk!=0 || pTab->pSelect!=0 );
        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
        VdbeCoverage(v);
      }
    }else if( pPk ){
      addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);
      if( IsVirtual(pTab) ){
        sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey);
      }else{
        sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey);
      }
      assert( nKey==0 );  /* OP_Found will use a composite key */
    }else{
      addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);
      VdbeCoverage(v);
      assert( nKey==1 );
    }
 
    /* Delete the row */
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( IsVirtual(pTab) ){
      const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
      sqlite3VtabMakeWritable(pParse, pTab);
      assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
      sqlite3MayAbort(pParse);
      if( eOnePass==ONEPASS_SINGLE ){
        sqlite3VdbeAddOp1(v, OP_Close, iTabCur);
        if( sqlite3IsToplevel(pParse) ){
          pParse->isMultiWrite = 0;
        }
      }
      sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
      sqlite3VdbeChangeP5(v, OE_Abort);
    }else
#endif
    {
      int count = (pParse->nested==0);    /* True to count changes */
      sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
          iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]);
    }
 
    /* End of the loop over all rowids/primary-keys. */
    if( eOnePass!=ONEPASS_OFF ){
      sqlite3VdbeResolveLabel(v, addrBypass);
      sqlite3WhereEnd(pWInfo);
    }else if( pPk ){
      sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);
      sqlite3VdbeJumpHere(v, addrLoop);
    }else{
      sqlite3VdbeGoto(v, addrLoop);
      sqlite3VdbeJumpHere(v, addrLoop);
    }
  } /* End non-truncate path */
 
  /* Update the sqlite_sequence table by storing the content of the
  ** maximum rowid counter values recorded while inserting into
  ** autoincrement tables.
  */
  if( pParse->nested==0 && pParse->pTriggerTab==0 ){
    sqlite3AutoincrementEnd(pParse);
  }
 
  /* Return the number of rows that were deleted. If this routine is
  ** generating code because of a call to sqlite3NestedParse(), do not
  ** invoke the callback function.
  */
  if( memCnt ){
    sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
    sqlite3VdbeSetNumCols(v, 1);
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
  }
 
delete_from_cleanup:
  sqlite3AuthContextPop(&sContext);
  sqlite3SrcListDelete(db, pTabList);
  sqlite3ExprDelete(db, pWhere);
#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)

References SrcList::a, sqlite3::aDb, Index::aiColumn, COLNAME_NAME, Parse::db, sqlite3::flags, HasRowid, SrcList::SrcList_item::iCursor, Parse::isMultiWrite, IsVirtual, sqlite3::mallocFailed, NC_VarSelect, NameContext::ncFlags, Parse::nErr, Parse::nested, Index::nKeyCol, Parse::nMem, SrcList::nSrc, Parse::nTab, OE_Abort, OE_Default, ONEPASS_MULTI, ONEPASS_OFF, ONEPASS_SINGLE, OP_AddImm, OP_Clear, OP_Close, OP_Column, OP_IdxInsert, OP_Integer, OP_MakeRecord, OP_Next, OP_NotFound, OP_Null, OP_Once, OP_OpenEphemeral, OP_OpenWrite, OP_ResultRow, OP_Rewind, OP_RowData, OP_RowSetAdd, OP_RowSetRead, OP_VUpdate, OPFLAG_FORDELETE, P4_STATIC, P4_VTAB, Table::pIndex, Index::pNext, NameContext::pParse, Table::pSchema, Index::pSchema, Table::pSelect, NameContext::pSrcList, Parse::pTriggerTab, sqlite3AuthCheck(), sqlite3AuthContextPop(), sqlite3AuthContextPush(), sqlite3AutoincrementEnd(), sqlite3BeginWriteOperation(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3ExprCodeGetColumnOfTable(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3FkRequired(), sqlite3GenerateRowDelete(), sqlite3GetVdbe(), sqlite3GetVTable(), sqlite3IndexAffinityStr(), sqlite3IsReadOnly(), sqlite3IsToplevel, sqlite3MaterializeView(), sqlite3MayAbort(), sqlite3MultiWrite(), sqlite3OpenTableAndIndices(), sqlite3PrimaryKeyIndex(), sqlite3ResolveExprNames(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3TableLock(), sqlite3TriggersExist(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCountChanges(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeJumpHereOrPopInst(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), sqlite3VdbeSetP4KeyInfo(), sqlite3ViewGetColumnNames(), sqlite3VtabMakeWritable(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereOkOnePass(), SQLITE_CountRows, SQLITE_DELETE, SQLITE_DENY, SQLITE_IGNORE, SQLITE_OK, SQLITE_STATIC, testcase, TK_DELETE, Table::tnum, Index::tnum, VdbeCoverage, WHERE_DUPLICATES_OK, WHERE_ONEPASS_DESIRED, WHERE_ONEPASS_MULTIROW, WHERE_SEEK_TABLE, Db::zDbSName, and Table::zName.

Referenced by sqlite3FkDropTable(), and yy_reduce().

◆ sqlite3DeleteIndexSamples()

SQLITE_PRIVATE void sqlite3DeleteIndexSamples	(	sqlite3 *	db,
		Index *	pIdx )

Definition at line 109154 of file sqlite3.c.

                                                                       {
#ifdef SQLITE_ENABLE_STAT4
  if( pIdx->aSample ){
    int j;
    for(j=0; j<pIdx->nSample; j++){
      IndexSample *p = &pIdx->aSample[j];
      sqlite3DbFree(db, p->p);
    }
    sqlite3DbFree(db, pIdx->aSample);
  }
  if( db && db->pnBytesFreed==0 ){
    pIdx->nSample = 0;
    pIdx->aSample = 0;

Referenced by sqlite3AnalysisLoad().

◆ sqlite3DeleteTable()

SQLITE_PRIVATE void sqlite3DeleteTable	(	sqlite3 *	db,
		Table *	pTable )

Definition at line 111102 of file sqlite3.c.

Referenced by sqlite3_declare_vtab(), sqlite3EndTable(), sqlite3RunParser(), sqlite3SchemaClear(), sqlite3SrcListLookup(), sqlite3UnlinkAndDeleteTable(), sqlite3ViewGetColumnNames(), and sqlite3VtabCallDestroy().

◆ sqlite3DeleteTrigger()

SQLITE_PRIVATE void sqlite3DeleteTrigger	(	sqlite3 *	db,
		Trigger *	pTrigger )

Definition at line 136938 of file sqlite3.c.

                                                                        {
  if( pTrigger==0 ) return;
  sqlite3DeleteTriggerStep(db, pTrigger->step_list);

Referenced by sqlite3BeginTrigger(), sqlite3RunParser(), and sqlite3SchemaClear().

◆ sqlite3DeleteTriggerStep()

SQLITE_PRIVATE void sqlite3DeleteTriggerStep	(	sqlite3 *	db,
		TriggerStep *	pTriggerStep )

Definition at line 136403 of file sqlite3.c.

                                                                                    {
  while( pTriggerStep ){
    TriggerStep * pTmp = pTriggerStep;
    pTriggerStep = pTriggerStep->pNext;
 
    sqlite3ExprDelete(db, pTmp->pWhere);
    sqlite3ExprListDelete(db, pTmp->pExprList);
    sqlite3SelectDelete(db, pTmp->pSelect);
    sqlite3IdListDelete(db, pTmp->pIdList);
    sqlite3UpsertDelete(db, pTmp->pUpsert);

References TriggerStep::pExprList, TriggerStep::pFrom, TriggerStep::pIdList, TriggerStep::pNext, TriggerStep::pSelect, TriggerStep::pUpsert, TriggerStep::pWhere, sqlite3DbFree(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3IdListDelete(), sqlite3SelectDelete(), sqlite3SrcListDelete(), sqlite3UpsertDelete(), and TriggerStep::zSpan.

Referenced by yy_destructor().

◆ sqlite3Dequote()

SQLITE_PRIVATE void sqlite3Dequote ( char * z )

Definition at line 31411 of file sqlite3.c.

             : This routine is extended to remove MS-Access style
** brackets from around identifiers.  For example:  "[a-b-c]" becomes
** "a-b-c".
*/
SQLITE_PRIVATE void sqlite3Dequote(char *z){
  char quote;
  int i, j;
  if( z==0 ) return;
  quote = z[0];
  if( !sqlite3Isquote(quote) ) return;
  if( quote=='[' ) quote = ']';
  for(i=1, j=0;; i++){
    assert( z[i] );
    if( z[i]==quote ){
      if( z[i+1]==quote ){
        z[j++] = quote;
        i++;
      }else{
        break;
      }

References sqlite3Isquote.

Referenced by sqlite3AddColumn(), sqlite3CreateForeignKey(), sqlite3ExprListSetName(), sqlite3NameFromToken(), sqlite3RunParser(), and triggerStepAllocate().

◆ sqlite3DequoteExpr()

SQLITE_PRIVATE void sqlite3DequoteExpr ( Expr * p )

Definition at line 31433 of file sqlite3.c.

         {
      z[j++] = z[i];
    }
  }
  z[j] = 0;

Referenced by sqlite3ExprAlloc(), and tokenExpr().

◆ sqlite3Detach()

SQLITE_PRIVATE void sqlite3Detach	(	Parse *	pParse,
		Expr *	pDbname )

Definition at line 109886 of file sqlite3.c.

                                                               {
  static const FuncDef detach_func = {
    1,                /* nArg */
    SQLITE_UTF8,      /* funcFlags */
    0,                /* pUserData */
    0,                /* pNext */
    detachFunc,       /* xSFunc */
    0,                /* xFinalize */

References codeAttach(), detachFunc(), SQLITE_DETACH, and SQLITE_UTF8.

Referenced by yy_reduce().

◆ sqlite3DropIndex()

SQLITE_PRIVATE void sqlite3DropIndex	(	Parse *	pParse,
		SrcList *	pName,
		int	ifExists )

Definition at line 114506 of file sqlite3.c.

                                                                                 {
  Index *pIndex;
  Vdbe *v;
  sqlite3 *db = pParse->db;
  int iDb;
 
  assert( pParse->nErr==0 );   /* Never called with prior errors */
  if( db->mallocFailed ){
    goto exit_drop_index;
  }
  assert( pName->nSrc==1 );
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    goto exit_drop_index;
  }
  pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
  if( pIndex==0 ){
    if( !ifExists ){
      sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
    }else{
      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
    }
    pParse->checkSchema = 1;
    goto exit_drop_index;
  }
  if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
    sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
      "or PRIMARY KEY constraint cannot be dropped", 0);
    goto exit_drop_index;
  }
  iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
#ifndef SQLITE_OMIT_AUTHORIZATION
  {
    int code = SQLITE_DROP_INDEX;
    Table *pTab = pIndex->pTable;
    const char *zDb = db->aDb[iDb].zDbSName;
    const char *zTab = SCHEMA_TABLE(iDb);
    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
      goto exit_drop_index;
    }
    if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
    if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
      goto exit_drop_index;
    }
  }
#endif
 
  /* Generate code to remove the index and from the schema table */
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3BeginWriteOperation(pParse, 1, iDb);
    sqlite3NestedParse(pParse,
       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
       db->aDb[iDb].zDbSName, pIndex->zName
    );
    sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
    sqlite3ChangeCookie(pParse, iDb);
    destroyRootPage(pParse, pIndex->tnum, iDb);

Referenced by yy_reduce().

◆ sqlite3DropTable()

SQLITE_PRIVATE void sqlite3DropTable	(	Parse *	pParse,
		SrcList *	pName,
		int	isView,
		int	noErr )

Definition at line 113434 of file sqlite3.c.

                                                                                          {
  Table *pTab;
  Vdbe *v;
  sqlite3 *db = pParse->db;
  int iDb;
 
  if( db->mallocFailed ){
    goto exit_drop_table;
  }
  assert( pParse->nErr==0 );
  assert( pName->nSrc==1 );
  if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
  if( noErr ) db->suppressErr++;
  assert( isView==0 || isView==LOCATE_VIEW );
  pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
  if( noErr ) db->suppressErr--;
 
  if( pTab==0 ){
    if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
    goto exit_drop_table;
  }
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
 
  /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
  ** it is initialized.
  */
  if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
    goto exit_drop_table;
  }
#ifndef SQLITE_OMIT_AUTHORIZATION
  {
    int code;
    const char *zTab = SCHEMA_TABLE(iDb);
    const char *zDb = db->aDb[iDb].zDbSName;
    const char *zArg2 = 0;
    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
      goto exit_drop_table;
    }
    if( isView ){
      if( !OMIT_TEMPDB && iDb==1 ){
        code = SQLITE_DROP_TEMP_VIEW;
      }else{
        code = SQLITE_DROP_VIEW;
      }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    }else if( IsVirtual(pTab) ){
      code = SQLITE_DROP_VTABLE;
      zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
#endif
    }else{
      if( !OMIT_TEMPDB && iDb==1 ){
        code = SQLITE_DROP_TEMP_TABLE;
      }else{
        code = SQLITE_DROP_TABLE;
      }
    }
    if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
      goto exit_drop_table;
    }
    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
      goto exit_drop_table;
    }
  }
#endif
  if( tableMayNotBeDropped(db, pTab) ){
    sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
    goto exit_drop_table;
  }
 
#ifndef SQLITE_OMIT_VIEW
  /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
  ** on a table.
  */
  if( isView && pTab->pSelect==0 ){
    sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
    goto exit_drop_table;
  }
  if( !isView && pTab->pSelect ){
    sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
    goto exit_drop_table;
  }
#endif
 
  /* Generate code to remove the table from the schema table
  ** on disk.
  */
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3BeginWriteOperation(pParse, 1, iDb);
    if( !isView ){
      sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
      sqlite3FkDropTable(pParse, pName, pTab);
    }

Referenced by yy_reduce().

◆ sqlite3DropTrigger()

SQLITE_PRIVATE void sqlite3DropTrigger	(	Parse *	pParse,
		SrcList *	pName,
		int	noErr )

Definition at line 136956 of file sqlite3.c.

                                                                                {
  Trigger *pTrigger = 0;
  int i;
  const char *zDb;
  const char *zName;
  sqlite3 *db = pParse->db;
 
  if( db->mallocFailed ) goto drop_trigger_cleanup;
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    goto drop_trigger_cleanup;
  }
 
  assert( pName->nSrc==1 );
  zDb = pName->a[0].zDatabase;
  zName = pName->a[0].zName;
  assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
  for(i=OMIT_TEMPDB; i<db->nDb; i++){
    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
    if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
    assert( sqlite3SchemaMutexHeld(db, j, 0) );
    pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
    if( pTrigger ) break;
  }
  if( !pTrigger ){
    if( !noErr ){
      sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
    }else{
      sqlite3CodeVerifyNamedSchema(pParse, zDb);
    }
    pParse->checkSchema = 1;
    goto drop_trigger_cleanup;

References SrcList::a, sqlite3::aDb, Parse::checkSchema, Parse::db, sqlite3::mallocFailed, sqlite3::nDb, SrcList::nSrc, OMIT_TEMPDB, Db::pSchema, sqlite3CodeVerifyNamedSchema(), sqlite3DbIsNamed(), sqlite3DropTriggerPtr(), sqlite3ErrorMsg(), sqlite3HashFind(), sqlite3ReadSchema(), sqlite3SrcListDelete(), SQLITE_OK, Schema::trigHash, SrcList::SrcList_item::zDatabase, SrcList::SrcList_item::zName, and zName.

Referenced by yy_reduce().

◆ sqlite3DropTriggerPtr()

SQLITE_PRIVATE void sqlite3DropTriggerPtr	(	Parse *	pParse,
		Trigger *	pTrigger )

Definition at line 137006 of file sqlite3.c.

                                                                           {
  Table   *pTable;
  Vdbe *v;
  sqlite3 *db = pParse->db;
  int iDb;
 
  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
  pTable = tableOfTrigger(pTrigger);
  assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( pTable ){
    int code = SQLITE_DROP_TRIGGER;
    const char *zDb = db->aDb[iDb].zDbSName;
    const char *zTab = SCHEMA_TABLE(iDb);
    if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
    if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
      sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
      return;
    }
  }
#endif
 
  /* Generate code to destroy the database record of the trigger.
  */
  if( (v = sqlite3GetVdbe(pParse))!=0 ){
    sqlite3NestedParse(pParse,
       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",

Referenced by sqlite3DropTrigger().

◆ sqlite3EndBenignMalloc()

SQLITE_PRIVATE void sqlite3EndBenignMalloc ( void )

Definition at line 23475 of file sqlite3.c.

                             {
    wsdHooks.xBenignBegin();
  }
}
SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){

References wsdHooks.

Referenced by getPageNormal(), hasHotJournal(), pagerUnlockAndRollback(), pcache1ResizeHash(), rehash(), setupLookaside(), sqlite3PagerClose(), sqlite3RollbackAll(), sqlite3VdbeExec(), sqlite3VdbeTransferError(), sqlite3WalDefaultHook(), and vdbeCommit().

◆ sqlite3EndTable()

SQLITE_PRIVATE void sqlite3EndTable	(	Parse *	pParse,
		Token *	pCons,
		Token *	pEnd,
		u8	tabOpts,
		Select *	pSelect )

Definition at line 112660 of file sqlite3.c.

 {
  Table *p;                 /* The new table */
  sqlite3 *db = pParse->db; /* The database connection */
  int iDb;                  /* Database in which the table lives */
  Index *pIdx;              /* An implied index of the table */
 
  if( pEnd==0 && pSelect==0 ){
    return;
  }
  assert( !db->mallocFailed );
  p = pParse->pNewTable;
  if( p==0 ) return;
 
  if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
    p->tabFlags |= TF_Shadow;
  }
 
  /* If the db->init.busy is 1 it means we are reading the SQL off the
  ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
  ** So do not write to the disk again.  Extract the root page number
  ** for the table from the db->init.newTnum field.  (The page number
  ** should have been put there by the sqliteOpenCb routine.)
  **
  ** If the root page number is 1, that means this is the sqlite_schema
  ** table itself.  So mark it read-only.
  */
  if( db->init.busy ){
    if( pSelect ){
      sqlite3ErrorMsg(pParse, "");
      return;
    }
    p->tnum = db->init.newTnum;
    if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
  }
 
  assert( (p->tabFlags & TF_HasPrimaryKey)==0
       || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
  assert( (p->tabFlags & TF_HasPrimaryKey)!=0
       || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
 
  /* Special processing for WITHOUT ROWID Tables */
  if( tabOpts & TF_WithoutRowid ){
    if( (p->tabFlags & TF_Autoincrement) ){
      sqlite3ErrorMsg(pParse,
          "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
      return;
    }
    if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
      sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
      return;
    }
    p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
    convertToWithoutRowidTable(pParse, p);
  }
  iDb = sqlite3SchemaToIndex(db, p->pSchema);
 
#ifndef SQLITE_OMIT_CHECK
  /* Resolve names in all CHECK constraint expressions.
  */
  if( p->pCheck ){
    sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
    if( pParse->nErr ){
      /* If errors are seen, delete the CHECK constraints now, else they might
      ** actually be used if PRAGMA writable_schema=ON is set. */
      sqlite3ExprListDelete(db, p->pCheck);
      p->pCheck = 0;
    }else{
      markExprListImmutable(p->pCheck);
    }
  }
#endif /* !defined(SQLITE_OMIT_CHECK) */
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  if( p->tabFlags & TF_HasGenerated ){
    int ii, nNG = 0;
    testcase( p->tabFlags & TF_HasVirtual );
    testcase( p->tabFlags & TF_HasStored );
    for(ii=0; ii<p->nCol; ii++){
      u32 colFlags = p->aCol[ii].colFlags;
      if( (colFlags & COLFLAG_GENERATED)!=0 ){
        Expr *pX = p->aCol[ii].pDflt;
        testcase( colFlags & COLFLAG_VIRTUAL );
        testcase( colFlags & COLFLAG_STORED );
        if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
          /* If there are errors in resolving the expression, change the
          ** expression to a NULL.  This prevents code generators that operate
          ** on the expression from inserting extra parts into the expression
          ** tree that have been allocated from lookaside memory, which is
          ** illegal in a schema and will lead to errors or heap corruption
          ** when the database connection closes. */
          sqlite3ExprDelete(db, pX);
          p->aCol[ii].pDflt = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
        }
      }else{
        nNG++;
      }
    }
    if( nNG==0 ){
      sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
      return;
    }
  }
#endif
 
  /* Estimate the average row size for the table and for all implied indices */
  estimateTableWidth(p);
  for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
    estimateIndexWidth(pIdx);
  }
 
  /* If not initializing, then create a record for the new table
  ** in the schema table of the database.
  **
  ** If this is a TEMPORARY table, write the entry into the auxiliary
  ** file instead of into the main database file.
  */
  if( !db->init.busy ){
    int n;
    Vdbe *v;
    char *zType;    /* "view" or "table" */
    char *zType2;   /* "VIEW" or "TABLE" */
    char *zStmt;    /* Text of the CREATE TABLE or CREATE VIEW statement */
 
    v = sqlite3GetVdbe(pParse);
    if( NEVER(v==0) ) return;
 
    sqlite3VdbeAddOp1(v, OP_Close, 0);
 
    /*
    ** Initialize zType for the new view or table.
    */
    if( p->pSelect==0 ){
      /* A regular table */
      zType = "table";
      zType2 = "TABLE";
#ifndef SQLITE_OMIT_VIEW
    }else{
      /* A view */
      zType = "view";
      zType2 = "VIEW";
#endif
    }
 
    /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
    ** statement to populate the new table. The root-page number for the
    ** new table is in register pParse->regRoot.
    **
    ** Once the SELECT has been coded by sqlite3Select(), it is in a
    ** suitable state to query for the column names and types to be used
    ** by the new table.
    **
    ** A shared-cache write-lock is not required to write to the new table,
    ** as a schema-lock must have already been obtained to create it. Since
    ** a schema-lock excludes all other database users, the write-lock would
    ** be redundant.
    */
    if( pSelect ){
      SelectDest dest;    /* Where the SELECT should store results */
      int regYield;       /* Register holding co-routine entry-point */
      int addrTop;        /* Top of the co-routine */
      int regRec;         /* A record to be insert into the new table */
      int regRowid;       /* Rowid of the next row to insert */
      int addrInsLoop;    /* Top of the loop for inserting rows */
      Table *pSelTab;     /* A table that describes the SELECT results */
 
      regYield = ++pParse->nMem;
      regRec = ++pParse->nMem;
      regRowid = ++pParse->nMem;
      assert(pParse->nTab==1);
      sqlite3MayAbort(pParse);
      sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
      sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
      pParse->nTab = 2;
      addrTop = sqlite3VdbeCurrentAddr(v) + 1;
      sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
      if( pParse->nErr ) return;
      pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
      if( pSelTab==0 ) return;
      assert( p->aCol==0 );
      p->nCol = p->nNVCol = pSelTab->nCol;
      p->aCol = pSelTab->aCol;
      pSelTab->nCol = 0;
      pSelTab->aCol = 0;
      sqlite3DeleteTable(db, pSelTab);
      sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
      sqlite3Select(pParse, pSelect, &dest);
      if( pParse->nErr ) return;
      sqlite3VdbeEndCoroutine(v, regYield);
      sqlite3VdbeJumpHere(v, addrTop - 1);
      addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
      VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
      sqlite3TableAffinity(v, p, 0);
      sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
      sqlite3VdbeGoto(v, addrInsLoop);
      sqlite3VdbeJumpHere(v, addrInsLoop);
      sqlite3VdbeAddOp1(v, OP_Close, 1);
    }
 
    /* Compute the complete text of the CREATE statement */
    if( pSelect ){
      zStmt = createTableStmt(db, p);
    }else{
      Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
      n = (int)(pEnd2->z - pParse->sNameToken.z);
      if( pEnd2->z[0]!=';' ) n += pEnd2->n;
      zStmt = sqlite3MPrintf(db,
          "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
      );
    }
 
    /* A slot for the record has already been allocated in the
    ** schema table.  We just need to update that slot with all
    ** the information we've collected.
    */
    sqlite3NestedParse(pParse,
      "UPDATE %Q." DFLT_SCHEMA_TABLE
      " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
      " WHERE rowid=#%d",
      db->aDb[iDb].zDbSName,
      zType,
      p->zName,
      p->zName,
      pParse->regRoot,
      zStmt,
      pParse->regRowid
    );
    sqlite3DbFree(db, zStmt);
    sqlite3ChangeCookie(pParse, iDb);
 
#ifndef SQLITE_OMIT_AUTOINCREMENT
    /* Check to see if we need to create an sqlite_sequence table for
    ** keeping track of autoincrement keys.
    */
    if( (p->tabFlags & TF_Autoincrement)!=0 ){
      Db *pDb = &db->aDb[iDb];
      assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
      if( pDb->pSchema->pSeqTab==0 ){
        sqlite3NestedParse(pParse,
          "CREATE TABLE %Q.sqlite_sequence(name,seq)",
          pDb->zDbSName
        );
      }
    }
#endif
 
    /* Reparse everything to update our internal data structures */
    sqlite3VdbeAddParseSchemaOp(v, iDb,
           sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
  }
 
  /* Add the table to the in-memory representation of the database.
  */
  if( db->init.busy ){
    Table *pOld;
    Schema *pSchema = p->pSchema;
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
    if( pOld ){
      assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
      sqlite3OomFault(db);
      return;
    }
    pParse->pNewTable = 0;
    db->mDbFlags |= DBFLAG_SchemaChange;
 
#ifndef SQLITE_OMIT_ALTERTABLE
    if( !p->pSelect ){
      const char *zName = (const char *)pParse->sNameToken.z;
      int nName;
      assert( !pSelect && pCons && pEnd );
      if( pCons->z==0 ){
        pCons = pEnd;
      }

References Table::aCol, sqlite3::aDb, Table::addColOffset, sqlite3::sqlite3InitInfo::busy, COLFLAG_GENERATED, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, convertToWithoutRowidTable(), createTableStmt(), Parse::db, DBFLAG_SchemaChange, DFLT_SCHEMA_TABLE, estimateIndexWidth(), estimateTableWidth(), sqlite3::init, Table::iPKey, SelectDest::iSDParm, SelectDest::iSdst, sqlite3::mallocFailed, markExprListImmutable, sqlite3::mDbFlags, Token::n, NC_GenCol, NC_IsCheck, Table::nCol, Parse::nErr, NEVER, sqlite3::sqlite3InitInfo::newTnum, Parse::nMem, nName, Table::nNVCol, SelectDest::nSdst, Parse::nTab, OP_Close, OP_InitCoroutine, OP_Insert, OP_MakeRecord, OP_NewRowid, OP_OpenWrite, OP_Yield, OPFLAG_P2ISREG, Table::pCheck, Column::pDflt, Table::pIndex, Parse::pNewTable, Index::pNext, Db::pSchema, Table::pSchema, Table::pSelect, Schema::pSeqTab, Parse::regRoot, Parse::regRowid, Parse::sLastToken, Parse::sNameToken, sqlite3ChangeCookie(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3ErrorMsg(), sqlite3ExprAlloc(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3GetVdbe(), sqlite3HashInsert(), sqlite3MayAbort(), sqlite3MPrintf(), sqlite3NestedParse(), sqlite3OomFault(), sqlite3PrimaryKeyIndex(), sqlite3ResolveSelfReference(), sqlite3ResultSetOfSelect(), sqlite3SchemaToIndex(), sqlite3Select(), sqlite3SelectDestInit(), sqlite3ShadowTableName(), sqlite3TableAffinity(), sqlite3Utf8CharLen(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddParseSchemaOp(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeEndCoroutine(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), SQLITE_AFF_BLOB, SRT_Coroutine, Table::tabFlags, Schema::tblHash, testcase, TF_Autoincrement, TF_HasGenerated, TF_HasPrimaryKey, TF_HasStored, TF_HasVirtual, TF_NoVisibleRowid, TF_Readonly, TF_Shadow, TF_WithoutRowid, TK_NULL, Table::tnum, VdbeCoverage, Token::z, Db::zDbSName, Table::zName, and zName.

Referenced by yy_reduce().

◆ sqlite3EndTransaction()

SQLITE_PRIVATE void sqlite3EndTransaction	(	Parse *	pParse,
		int	eType )

Definition at line 115049 of file sqlite3.c.

                                                                   {
  Vdbe *v;
  int isRollback;
 
  assert( pParse!=0 );
  assert( pParse->db!=0 );
  assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
  isRollback = eType==TK_ROLLBACK;
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
       isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
    return;

References Parse::db, eType, OP_AutoCommit, sqlite3AuthCheck(), sqlite3GetVdbe(), sqlite3VdbeAddOp2(), SQLITE_TRANSACTION, TK_COMMIT, TK_END, and TK_ROLLBACK.

Referenced by yy_reduce().

◆ sqlite3Error()

SQLITE_PRIVATE void sqlite3Error	(	sqlite3 *	db,
		int	err_code )

Definition at line 31291 of file sqlite3.c.

References sqlite3::errCode, sqlite3::pErr, and sqlite3ErrorFinish().

Referenced by columnMem(), openDatabase(), sqlite3_backup_init(), sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_vtab_config(), sqlite3ErrorWithMsg(), sqlite3LeaveMutexAndCloseZombie(), and vdbeUnbind().

◆ sqlite3ErrorFinish()

static SQLITE_NOINLINE void sqlite3ErrorFinish	(	sqlite3 *	db,
		int	err_code )

static

Definition at line 31281 of file sqlite3.c.

References sqlite3::pErr, sqlite3SystemError(), and sqlite3ValueSetNull().

Referenced by sqlite3Error().

◆ sqlite3ErrorIfNotEmpty()

static void sqlite3ErrorIfNotEmpty	(	Parse *	pParse,
		const char *	zDb,
		const char *	zTab,
		const char *	zErr )

static

Definition at line 106058 of file sqlite3.c.

Referenced by sqlite3AlterFinishAddColumn().

◆ sqlite3ErrorMsg()

SQLITE_PRIVATE void sqlite3ErrorMsg	(	Parse *	pParse,
		const char *	zFormat,
			... )

Definition at line 31363 of file sqlite3.c.

                                                                            {
  char *zMsg;
  va_list ap;
  sqlite3 *db = pParse->db;
  va_start(ap, zFormat);
  zMsg = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  if( db->suppressErr ){
    sqlite3DbFree(db, zMsg);
  }else{
    pParse->nErr++;

References Parse::db, Parse::nErr, Parse::pWith, Parse::rc, sqlite3DbFree(), sqlite3VMPrintf(), SQLITE_ERROR, sqlite3::suppressErr, and Parse::zErrMsg.

Referenced by addModuleArgument(), allocateIndexInfo(), cannotBeFunction(), codeInteger(), codeVectorCompare(), destroyRootPage(), exprAnalyze(), generateWithRecursiveQuery(), invalidateTempStorage(), isAlterableTable(), isRealTable(), lookupName(), multiSelect(), parserAddExprIdListTerm(), parserDoubleLinkSelect(), resetAccumulator(), resolveCompoundOrderBy(), resolveExprStep(), selectExpander(), sqlite3AddColumn(), sqlite3AddDefaultValue(), sqlite3AddPrimaryKey(), sqlite3AlterBeginAddColumn(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3AuthCheck(), sqlite3AuthReadCol(), sqlite3BeginTrigger(), sqlite3CheckObjectName(), sqlite3ComputeGeneratedColumns(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3DropTrigger(), sqlite3EndTable(), sqlite3ExprAssignVarNumber(), sqlite3ExprCheckHeight(), sqlite3ExprCodeTarget(), sqlite3ExprFunctionUsable(), sqlite3ExprListAppendVector(), sqlite3FinishCoding(), sqlite3FixSrcList(), sqlite3FkLocateIndex(), sqlite3GetCollSeq(), sqlite3HasExplicitNulls(), sqlite3IndexedByLookup(), sqlite3Insert(), sqlite3IsReadOnly(), sqlite3JoinType(), sqlite3LocateTable(), sqlite3Pragma(), sqlite3Reindex(), sqlite3ResolveOrderGroupBy(), sqlite3RunParser(), sqlite3Select(), sqlite3SelectWrongNumTermsError(), sqlite3SrcListAppendFromTerm(), sqlite3SrcListEnlarge(), sqlite3StartTable(), sqlite3SubselectError(), sqlite3TwoPartName(), sqlite3Update(), sqlite3UpsertAnalyzeTarget(), sqlite3VectorErrorMsg(), sqlite3ViewGetColumnNames(), sqlite3VtabCallConnect(), sqlite3VtabEponymousTableInit(), sqlite3WhereBegin(), sqlite3WhereTabFuncArgs(), sqlite3WindowChain(), sqlite3WindowUpdate(), sqlite3WithAdd(), sqliteProcessJoin(), updateFromSelect(), vtabBestIndex(), whereLoopAddVirtualOne(), wherePathSolver(), withExpand(), and yy_reduce().

◆ sqlite3ErrorToParser()

SQLITE_PRIVATE int sqlite3ErrorToParser	(	sqlite3 *	db,
		int	errCode )

Definition at line 31386 of file sqlite3.c.

31392 {

References Parse::nErr, sqlite3::pParse, and Parse::rc.

Referenced by sqlite3VdbeMemSetStr(), and sqlite3WindowRewrite().

◆ sqlite3ErrorWithMsg()

SQLITE_PRIVATE void sqlite3ErrorWithMsg	(	sqlite3 *	db,
		int	err_code,
		const char *	zFormat,
			... )

Definition at line 31330 of file sqlite3.c.

                                                                                            {
  assert( db!=0 );
  db->errCode = err_code;
  sqlite3SystemError(db, err_code);
  if( zFormat==0 ){
    sqlite3Error(db, err_code);
  }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
    char *z;
    va_list ap;

References sqlite3::errCode, sqlite3::pErr, sqlite3Error(), sqlite3SystemError(), sqlite3ValueNew(), sqlite3ValueSetStr(), sqlite3VMPrintf(), SQLITE_DYNAMIC, and SQLITE_UTF8.

Referenced by checkReadTransaction(), findBtree(), openDatabase(), sqlite3_backup_init(), sqlite3_blob_reopen(), sqlite3_declare_vtab(), sqlite3_errmsg16(), sqlite3_table_column_metadata(), sqlite3AutoLoadExtensions(), sqlite3CreateFunc(), and sqlite3VdbeReset().

◆ sqlite3ErrStr()

SQLITE_PRIVATE const char * sqlite3ErrStr ( int rc )

Definition at line 162539 of file sqlite3.c.

                                                {
  static const char* const aMsg[] = {
    /* SQLITE_OK          */ "not an error",
    /* SQLITE_ERROR       */ "SQL logic error",
    /* SQLITE_INTERNAL    */ 0,
    /* SQLITE_PERM        */ "access permission denied",
    /* SQLITE_ABORT       */ "query aborted",
    /* SQLITE_BUSY        */ "database is locked",
    /* SQLITE_LOCKED      */ "database table is locked",
    /* SQLITE_NOMEM       */ "out of memory",
    /* SQLITE_READONLY    */ "attempt to write a readonly database",
    /* SQLITE_INTERRUPT   */ "interrupted",
    /* SQLITE_IOERR       */ "disk I/O error",
    /* SQLITE_CORRUPT     */ "database disk image is malformed",
    /* SQLITE_NOTFOUND    */ "unknown operation",
    /* SQLITE_FULL        */ "database or disk is full",
    /* SQLITE_CANTOPEN    */ "unable to open database file",
    /* SQLITE_PROTOCOL    */ "locking protocol",
    /* SQLITE_EMPTY       */ 0,
    /* SQLITE_SCHEMA      */ "database schema has changed",
    /* SQLITE_TOOBIG      */ "string or blob too big",
    /* SQLITE_CONSTRAINT  */ "constraint failed",
    /* SQLITE_MISMATCH    */ "datatype mismatch",
    /* SQLITE_MISUSE      */ "bad parameter or other API misuse",
#ifdef SQLITE_DISABLE_LFS
    /* SQLITE_NOLFS       */ "large file support is disabled",
#else
    /* SQLITE_NOLFS       */ 0,
#endif
    /* SQLITE_AUTH        */ "authorization denied",
    /* SQLITE_FORMAT      */ 0,
    /* SQLITE_RANGE       */ "column index out of range",
    /* SQLITE_NOTADB      */ "file is not a database",
    /* SQLITE_NOTICE      */ "notification message",
    /* SQLITE_WARNING     */ "warning message",
  };
  const char *zErr = "unknown error";
  switch( rc ){
    case SQLITE_ABORT_ROLLBACK: {
      zErr = "abort due to ROLLBACK";
      break;
    }
    case SQLITE_ROW: {
      zErr = "another row available";
      break;
    }
    case SQLITE_DONE: {
      zErr = "no more rows available";
      break;
    }
    default: {
      rc &= 0xff;
      if( ALWAYS(rc>=0) && rc<ArraySize(aMsg) && aMsg[rc]!=0 ){
        zErr = aMsg[rc];

References ALWAYS, ArraySize, SQLITE_ABORT_ROLLBACK, SQLITE_DONE, and SQLITE_ROW.

Referenced by sqlite3_errmsg16(), sqlite3_errstr(), sqlite3InitOne(), sqlite3Pragma(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeList(), and vtabBestIndex().

◆ sqlite3ExpandSubquery()

SQLITE_PRIVATE int sqlite3ExpandSubquery	(	Parse *	pParse,
		struct SrcList_item *	pFrom )

Definition at line 134220 of file sqlite3.c.

                                                                                   {
  Select *pSel = pFrom->pSelect;
  Table *pTab;
 
  assert( pSel );
  pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
  if( pTab==0 ) return SQLITE_NOMEM;
  pTab->nTabRef = 1;
  if( pFrom->zAlias ){
    pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
  }else{
    pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
  }
  while( pSel->pPrior ){ pSel = pSel->pPrior; }
  sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);

References Table::aCol, Parse::db, Table::iPKey, Table::nCol, Parse::nErr, Table::nRowLogEst, Table::nTabRef, Select::pEList, Select::pPrior, Select::selId, sqlite3ColumnsFromExprList(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3LogEst(), sqlite3MPrintf(), SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, Table::tabFlags, TF_Ephemeral, and Table::zName.

Referenced by selectExpander().

◆ sqlite3ExpirePreparedStatements()

SQLITE_PRIVATE void sqlite3ExpirePreparedStatements	(	sqlite3 *	db,
		int	iCode )

Definition at line 82779 of file sqlite3.c.

References Vdbe::expired, Vdbe::pNext, and sqlite3::pVdbe.

Referenced by sqlite3_set_authorizer(), sqlite3CreateFunc(), sqlite3RollbackAll(), sqlite3VdbeExec(), and sqlite3VtabUnlockList().

◆ sqlite3Expr()

SQLITE_PRIVATE Expr * sqlite3Expr	(	sqlite3 *	db,
		int	op,
		const char *	zToken )

Definition at line 100554 of file sqlite3.c.

Referenced by convertCompoundSelectToSubquery(), exprTableRegister(), fkActionTrigger(), fkScanChildren(), havingToWhereExprCb(), isLikeOrGlob(), multiSelectOrderBy(), resolveCompoundOrderBy(), selectExpander(), sqlite3CodeSubselect(), sqlite3ExprAnd(), sqlite3SelectNew(), sqlite3WindowRewrite(), sqlite3WindowUpdate(), and yy_reduce().

◆ sqlite3ExprAddCollateString()

SQLITE_PRIVATE Expr * sqlite3ExprAddCollateString	(	Parse *	pParse,
		Expr *	pExpr,
		const char *	zC )

Definition at line 99814 of file sqlite3.c.

Referenced by exprAnalyze(), exprTableRegister(), multiSelectOrderByKeyInfo(), resolveAlias(), and substExpr().

◆ sqlite3ExprAddCollateToken()

SQLITE_PRIVATE Expr * sqlite3ExprAddCollateToken	(	Parse *	pParse,
		Expr *	pExpr,
		const Token *	pCollName,
		int	dequote )

Definition at line 99798 of file sqlite3.c.

 {
  if( pCollName->n>0 ){
    Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
    if( pNew ){
      pNew->pLeft = pExpr;

References Parse::db, Token::n, Expr::pLeft, sqlite3ExprAlloc(), and TK_COLLATE.

Referenced by yy_reduce().

◆ sqlite3ExprAffinity()

SQLITE_PRIVATE char sqlite3ExprAffinity ( const Expr * pExpr )

Definition at line 99753 of file sqlite3.c.

                                                          {
  int op;
  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
  }
  op = pExpr->op;
  if( op==TK_SELECT ){
    assert( pExpr->flags&EP_xIsSelect );
    assert( pExpr->x.pSelect!=0 );
    assert( pExpr->x.pSelect->pEList!=0 );
    assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
  }
  if( op==TK_REGISTER ) op = pExpr->op2;
#ifndef SQLITE_OMIT_CAST
  if( op==TK_CAST ){
    assert( !ExprHasProperty(pExpr, EP_IntValue) );
    return sqlite3AffinityType(pExpr->u.zToken, 0);
  }
#endif
  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
  }
  if( op==TK_SELECT_COLUMN ){
    assert( pExpr->pLeft->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(
        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
    );

References ExprList::a, Expr::affExpr, EP_IntValue, EP_Skip, EP_xIsSelect, ExprHasProperty, Expr::flags, Expr::iColumn, Expr::op, Expr::op2, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pSelect, Expr::pTab, sqlite3AffinityType(), sqlite3ExprAffinity(), sqlite3TableColumnAffinity(), TK_AGG_COLUMN, TK_CAST, TK_COLLATE, TK_COLUMN, TK_IF_NULL_ROW, TK_REGISTER, TK_SELECT, TK_SELECT_COLUMN, TK_VECTOR, Expr::u, Expr::x, Expr::y, and Expr::zToken.

Referenced by constInsert(), exprAnalyzeOrTerm(), exprINAffinity(), isLikeOrGlob(), sqlite3CodeRhsOfIN(), sqlite3CompareAffinity(), sqlite3ExprAffinity(), sqlite3IndexAffinityStr(), sqlite3SelectAddColumnTypeAndCollation(), termIsEquivalence(), whereIndexExprTransNode(), whereRangeVectorLen(), and whereScanInitIndexExpr().

◆ sqlite3ExprAlloc()

SQLITE_PRIVATE Expr * sqlite3ExprAlloc	(	sqlite3 *	db,
		int	op,
		const Token *	pToken,
		int	dequote )

Definition at line 100506 of file sqlite3.c.

               :  If op==TK_INTEGER and pToken points to a string that
** can be translated into a 32-bit integer, then the token is not
** stored in u.zToken.  Instead, the integer values is written
** into u.iValue and the EP_IntValue flag is set.  No extra storage
** is allocated to hold the integer text and the dequote flag is ignored.
*/
SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
  sqlite3 *db,            /* Handle for sqlite3DbMallocRawNN() */
  int op,                 /* Expression opcode */
  const Token *pToken,    /* Token argument.  Might be NULL */
  int dequote             /* True to dequote */
){
  Expr *pNew;
  int nExtra = 0;
  int iValue = 0;
 
  assert( db!=0 );
  if( pToken ){
    if( op!=TK_INTEGER || pToken->z==0
          || sqlite3GetInt32(pToken->z, &iValue)==0 ){
      nExtra = pToken->n+1;
      assert( iValue>=0 );
    }
  }
  pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
  if( pNew ){
    memset(pNew, 0, sizeof(Expr));
    pNew->op = (u8)op;
    pNew->iAgg = -1;
    if( pToken ){
      if( nExtra==0 ){
        pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
        pNew->u.iValue = iValue;
      }else{
        pNew->u.zToken = (char*)&pNew[1];
        assert( pToken->z!=0 || pToken->n==0 );
        if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
        pNew->u.zToken[pToken->n] = 0;
        if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
          sqlite3DequoteExpr(pNew);
        }
      }
    }

References EP_IntValue, EP_IsFalse, EP_IsTrue, EP_Leaf, Expr::flags, Expr::iAgg, Expr::iValue, Token::n, Expr::nHeight, Expr::op, sqlite3DbMallocRawNN(), sqlite3DequoteExpr(), sqlite3GetInt32(), sqlite3Isquote, TK_INTEGER, Expr::u, Token::z, and Expr::zToken.

Referenced by convertToWithoutRowidTable(), exprAnalyze(), fkActionTrigger(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3ExprAddCollateToken(), sqlite3WhereTabFuncArgs(), sqlite3WindowOffsetExpr(), and yy_reduce().

◆ sqlite3ExprAnalyzeAggList()

SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList	(	NameContext *	pNC,
		ExprList *	pList )

Definition at line 105694 of file sqlite3.c.

                                                                                {
  struct ExprList_item *pItem;
  int i;

References ExprList::a, ExprList::nExpr, and sqlite3ExprAnalyzeAggregates().

Referenced by sqlite3Select().

◆ sqlite3ExprAnalyzeAggregates()

SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates	(	NameContext *	pNC,
		Expr *	pExpr )

Definition at line 105676 of file sqlite3.c.

                                                                               {
  Walker w;
  w.xExprCallback = analyzeAggregate;
  w.xSelectCallback = sqlite3WalkerDepthIncrease;
  w.xSelectCallback2 = sqlite3WalkerDepthDecrease;

References analyzeAggregate(), Walker::pNC, Walker::pParse, NameContext::pSrcList, sqlite3WalkerDepthDecrease(), sqlite3WalkerDepthIncrease(), sqlite3WalkExpr(), Walker::u, Walker::walkerDepth, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3ExprAnalyzeAggList(), and sqlite3Select().

◆ sqlite3ExprAnd()

SQLITE_PRIVATE Expr * sqlite3ExprAnd	(	Parse *	pParse,
		Expr *	pLeft,
		Expr *	pRight )

Definition at line 100646 of file sqlite3.c.

                                                                             {
  sqlite3 *db = pParse->db;
  if( pLeft==0  ){
    return pRight;
  }else if( pRight==0 ){
    return pLeft;
  }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight))
         && !IN_RENAME_OBJECT
  ){
    sqlite3ExprDelete(db, pLeft);

References Parse::db, ExprAlwaysFalse, IN_RENAME_OBJECT, sqlite3Expr(), sqlite3ExprDelete(), sqlite3PExpr(), TK_AND, and TK_INTEGER.

Referenced by addWhereTerm(), constructAutomaticIndex(), fkActionTrigger(), fkScanChildren(), havingToWhereExprCb(), pushDownWhereTerms(), sqliteProcessJoin(), and yy_reduce().

◆ sqlite3ExprAssignVarNumber()

SQLITE_PRIVATE void sqlite3ExprAssignVarNumber	(	Parse *	pParse,
		Expr *	pExpr,
		u32	n )

Definition at line 100742 of file sqlite3.c.

                          :aaa", "@aaa", or "$aaa" are assigned the same number
** as the previous instance of the same wildcard.  Or if this is the first
** instance of the wildcard, the next sequential variable number is
** assigned.
*/
SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
  sqlite3 *db = pParse->db;
  const char *z;
  ynVar x;
 
  if( pExpr==0 ) return;
  assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
  z = pExpr->u.zToken;
  assert( z!=0 );
  assert( z[0]!=0 );
  assert( n==(u32)sqlite3Strlen30(z) );
  if( z[1]==0 ){
    /* Wildcard of the form "?".  Assign the next variable number */
    assert( z[0]=='?' );
    x = (ynVar)(++pParse->nVar);
  }else{
    int doAdd = 0;
    if( z[0]=='?' ){
      /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
      ** use it as the variable number */
      i64 i;
      int bOk;
      if( n==2 ){ /*OPTIMIZATION-IF-TRUE*/
        i = z[1]-'0';  /* The common case of ?N for a single digit N */
        bOk = 1;
      }else{
        bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
      }
      testcase( i==0 );
      testcase( i==1 );
      testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
      testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
      if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
        sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
            db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
        return;
      }
      x = (ynVar)i;
      if( x>pParse->nVar ){
        pParse->nVar = (int)x;
        doAdd = 1;
      }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){
        doAdd = 1;
      }
    }else{
      /* Wildcards like ":aaa", "$aaa" or "@aaa".  Reuse the same variable
      ** number as the prior appearance of the same name, or if the name
      ** has never appeared before, reuse the same variable number
      */
      x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n);
      if( x==0 ){
        x = (ynVar)(++pParse->nVar);
        doAdd = 1;
      }
    }
    if( doAdd ){
      pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x);
    }

References sqlite3::aLimit, Parse::db, EP_IntValue, EP_Reduced, EP_TokenOnly, ExprHasProperty, Expr::iColumn, Parse::nVar, Parse::pVList, sqlite3Atoi64(), sqlite3ErrorMsg(), sqlite3Strlen30(), sqlite3VListAdd(), sqlite3VListNameToNum(), sqlite3VListNumToName(), SQLITE_LIMIT_VARIABLE_NUMBER, SQLITE_UTF8, testcase, Expr::u, and Expr::zToken.

Referenced by yy_reduce().

◆ sqlite3ExprAttachSubtrees()

SQLITE_PRIVATE void sqlite3ExprAttachSubtrees	(	sqlite3 *	db,
		Expr *	pRoot,
		Expr *	pLeft,
		Expr *	pRight )

Definition at line 100571 of file sqlite3.c.

 {
  if( pRoot==0 ){
    assert( db->mallocFailed );
    sqlite3ExprDelete(db, pLeft);
    sqlite3ExprDelete(db, pRight);
  }else{
    if( pRight ){
      pRoot->pRight = pRight;
      pRoot->flags |= EP_Propagate & pRight->flags;
    }
    if( pLeft ){

References EP_Propagate, exprSetHeight(), Expr::flags, sqlite3::mallocFailed, Expr::pLeft, Expr::pRight, and sqlite3ExprDelete().

Referenced by sqlite3PExpr(), and yy_reduce().

◆ sqlite3ExprCanBeNull()

SQLITE_PRIVATE int sqlite3ExprCanBeNull ( const Expr * p )

Definition at line 101989 of file sqlite3.c.

                                                      {
  u8 op;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER:
    case TK_STRING:
    case TK_FLOAT:
    case TK_BLOB:
      return 0;
    case TK_COLUMN:
      return ExprHasProperty(p, EP_CanBeNull) ||
             p->y.pTab==0 ||  /* Reference to column of index on expression */
             (p->iColumn>=0

References Table::aCol, ALWAYS, EP_CanBeNull, ExprHasProperty, Expr::iColumn, Column::notNull, Expr::op, Expr::op2, Expr::pLeft, Expr::pTab, TK_BLOB, TK_COLUMN, TK_FLOAT, TK_INTEGER, TK_REGISTER, TK_STRING, TK_UMINUS, TK_UPLUS, and Expr::y.

Referenced by codeAllEqualityTerms(), minMaxQuery(), sqlite3ExprCodeIN(), and sqlite3FindInIndex().

◆ sqlite3ExprCheckHeight()

SQLITE_PRIVATE int sqlite3ExprCheckHeight	(	Parse *	pParse,
		int	nHeight )

Definition at line 100379 of file sqlite3.c.

                                                                     {
  int rc = SQLITE_OK;
  int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
  if( nHeight>mxHeight ){
    sqlite3ErrorMsg(pParse,

References sqlite3::aLimit, Parse::db, sqlite3ErrorMsg(), SQLITE_ERROR, SQLITE_LIMIT_EXPR_DEPTH, and SQLITE_OK.

Referenced by sqlite3ExprSetHeightAndFlags(), sqlite3PExpr(), sqlite3ResolveExprListNames(), and sqlite3ResolveExprNames().

◆ sqlite3ExprCheckIN()

SQLITE_PRIVATE int sqlite3ExprCheckIN	(	Parse *	pParse,
		Expr *	pIn )

Definition at line 102840 of file sqlite3.c.

                                                               {
  int nVector = sqlite3ExprVectorSize(pIn->pLeft);
  if( (pIn->flags & EP_xIsSelect) ){
    if( nVector!=pIn->x.pSelect->pEList->nExpr ){
      sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector);
      return 1;
    }

References EP_xIsSelect, Expr::flags, ExprList::nExpr, Select::pEList, Expr::pLeft, Expr::pSelect, sqlite3ExprVectorSize(), sqlite3SubselectError(), sqlite3VectorErrorMsg(), and Expr::x.

Referenced by exprAnalyze(), and sqlite3ExprCodeIN().

◆ sqlite3ExprCode()

SQLITE_PRIVATE void sqlite3ExprCode	(	Parse *	pParse,
		Expr *	pExpr,
		int	target )

Definition at line 104341 of file sqlite3.c.

                                                                           {
  int inReg;
 
  assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
  assert( target>0 && target<=pParse->nMem );
  assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
  if( pParse->pVdbe==0 ) return;
  inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
  if( inReg!=target ){
    u8 op;
    if( ExprHasProperty(pExpr,EP_Subquery) ){
      op = OP_Copy;

References Parse::db, EP_Immutable, EP_Subquery, ExprHasProperty, ExprHasVVAProperty, sqlite3::mallocFailed, OP_Copy, OP_SCopy, Parse::pVdbe, sqlite3ExprCodeTarget(), and sqlite3VdbeAddOp2().

Referenced by codeExprOrVector(), computeLimitRegisters(), generateSortTail(), sqlite3CodeRhsOfIN(), sqlite3ExprCodeCopy(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3FinishCoding(), sqlite3Insert(), sqlite3Select(), sqlite3Update(), sqlite3Vacuum(), sqlite3WindowCodeStep(), updateAccumulator(), and updateVirtualTable().

◆ sqlite3ExprCodeCopy()

SQLITE_PRIVATE void sqlite3ExprCodeCopy	(	Parse *	pParse,
		Expr *	pExpr,
		int	target )

Definition at line 104365 of file sqlite3.c.

References Parse::db, sqlite3::mallocFailed, sqlite3ExprCode(), sqlite3ExprDelete(), and sqlite3ExprDup().

Referenced by sqlite3ExprCodeFactorable(), sqlite3ExprCodeGeneratedColumn(), and sqlite3GenerateConstraintChecks().

◆ sqlite3ExprCodeExprList()

SQLITE_PRIVATE int sqlite3ExprCodeExprList	(	Parse *	pParse,
		ExprList *	pList,
		int	target,
		int	srcReg,
		u8	flags )

Definition at line 104406 of file sqlite3.c.

 {
  struct ExprList_item *pItem;
  int i, j, n;
  u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy;
  Vdbe *v = pParse->pVdbe;
  assert( pList!=0 );
  assert( target>0 );
  assert( pParse->pVdbe!=0 );  /* Never gets this far otherwise */
  n = pList->nExpr;
  if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
  for(pItem=pList->a, i=0; i<n; i++, pItem++){
    Expr *pExpr = pItem->pExpr;
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    if( pItem->bSorterRef ){
      i--;
      n--;
    }else
#endif
    if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){
      if( flags & SQLITE_ECEL_OMITREF ){
        i--;
        n--;
      }else{
        sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
      }
    }else if( (flags & SQLITE_ECEL_FACTOR)!=0
           && sqlite3ExprIsConstantNotJoin(pExpr)
    ){
      sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
    }else{
      int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
      if( inReg!=target+i ){
        VdbeOp *pOp;
        if( copyOp==OP_Copy
         && (pOp=sqlite3VdbeGetOp(v, -1))->opcode==OP_Copy
         && pOp->p1+pOp->p3+1==inReg
         && pOp->p2+pOp->p3+1==target+i
         && pOp->p5==0  /* The do-not-merge flag must be clear */
        ){
          pOp->p3++;
        }else{
          sqlite3VdbeAddOp2(v, copyOp, inReg, target+i);

References ExprList::a, ConstFactorOk, ExprList::nExpr, OP_Copy, OP_SCopy, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, VdbeOp::p5, Parse::pVdbe, sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprIsConstantNotJoin(), sqlite3VdbeAddOp2(), sqlite3VdbeGetOp(), SQLITE_ECEL_DUP, SQLITE_ECEL_FACTOR, SQLITE_ECEL_OMITREF, and SQLITE_ECEL_REF.

Referenced by sqlite3ExprCodeTarget(), sqlite3Select(), updateAccumulator(), and windowAggStep().

◆ sqlite3ExprCodeFactorable()

SQLITE_PRIVATE void sqlite3ExprCodeFactorable	(	Parse *	pParse,
		Expr *	pExpr,
		int	target )

Definition at line 104378 of file sqlite3.c.

104384 {

References Parse::okConstFactor, sqlite3ExprCodeCopy(), sqlite3ExprCodeRunJustOnce(), and sqlite3ExprIsConstantNotJoin().

Referenced by exprCodeVector(), and sqlite3Insert().

◆ sqlite3ExprCodeGeneratedColumn()

SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn	(	Parse *	pParse,
		Column *	pCol,
		int	regOut )

Definition at line 103217 of file sqlite3.c.

 {
  int iAddr;
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  assert( pParse->iSelfTab!=0 );
  if( pParse->iSelfTab>0 ){
    iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
  }else{
    iAddr = 0;
  }

References Column::affinity, Parse::iSelfTab, OP_Affinity, OP_IfNullRow, Column::pDflt, Parse::pVdbe, sqlite3ExprCodeCopy(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeJumpHere(), and SQLITE_AFF_TEXT.

Referenced by sqlite3ComputeGeneratedColumns(), and sqlite3ExprCodeTarget().

◆ sqlite3ExprCodeGetColumn()

SQLITE_PRIVATE int sqlite3ExprCodeGetColumn	(	Parse *	pParse,
		Table *	pTab,
		int	iColumn,
		int	iTable,
		int	iReg,
		u8	p5 )

Definition at line 103299 of file sqlite3.c.

 {
  assert( pParse->pVdbe!=0 );
  sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);

References OP_Column, VdbeOp::opcode, VdbeOp::p5, Parse::pVdbe, sqlite3ExprCodeGetColumnOfTable(), and sqlite3VdbeGetOp().

Referenced by sqlite3ExprCodeTarget().

◆ sqlite3ExprCodeGetColumnOfTable()

SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable	(	Vdbe *	v,
		Table *	pTab,
		int	iTabCur,
		int	iCol,
		int	regOut )

Definition at line 103242 of file sqlite3.c.

 {
  Column *pCol;
  assert( v!=0 );
  if( pTab==0 ){
    sqlite3VdbeAddOp3(v, OP_Column, iTabCur, iCol, regOut);
    return;
  }
  if( iCol<0 || iCol==pTab->iPKey ){
    sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
  }else{
    int op;
    int x;
    if( IsVirtual(pTab) ){
      op = OP_VColumn;
      x = iCol;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
      Parse *pParse = sqlite3VdbeParser(v);
      if( pCol->colFlags & COLFLAG_BUSY ){
        sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName);
      }else{
        int savedSelfTab = pParse->iSelfTab;
        pCol->colFlags |= COLFLAG_BUSY;
        pParse->iSelfTab = iTabCur+1;
        sqlite3ExprCodeGeneratedColumn(pParse, pCol, regOut);
        pParse->iSelfTab = savedSelfTab;
        pCol->colFlags &= ~COLFLAG_BUSY;
      }
      return;
#endif
    }else if( !HasRowid(pTab) ){
      testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
      x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
      op = OP_Column;
    }else{
      x = sqlite3TableColumnToStorage(pTab,iCol);
      testcase( x!=iCol );

Referenced by sqlite3DeleteFrom(), sqlite3ExprCodeGetColumn(), sqlite3GenerateRowDelete(), sqlite3Pragma(), sqlite3Select(), and sqlite3Update().

◆ sqlite3ExprCodeIN()

static void sqlite3ExprCodeIN	(	Parse *	pParse,
		Expr *	pExpr,
		int	destIfFalse,
		int	destIfNull )

static

Definition at line 102881 of file sqlite3.c.

 {
  int rRhsHasNull = 0;  /* Register that is true if RHS contains NULL values */
  int eType;            /* Type of the RHS */
  int rLhs;             /* Register(s) holding the LHS values */
  int rLhsOrig;         /* LHS values prior to reordering by aiMap[] */
  Vdbe *v;              /* Statement under construction */
  int *aiMap = 0;       /* Map from vector field to index column */
  char *zAff = 0;       /* Affinity string for comparisons */
  int nVector;          /* Size of vectors for this IN operator */
  int iDummy;           /* Dummy parameter to exprCodeVector() */
  Expr *pLeft;          /* The LHS of the IN operator */
  int i;                /* loop counter */
  int destStep2;        /* Where to jump when NULLs seen in step 2 */
  int destStep6 = 0;    /* Start of code for Step 6 */
  int addrTruthOp;      /* Address of opcode that determines the IN is true */
  int destNotNull;      /* Jump here if a comparison is not true in step 6 */
  int addrTop;          /* Top of the step-6 loop */
  int iTab = 0;         /* Index to use */
  u8 okConstFactor = pParse->okConstFactor;
 
  assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
  pLeft = pExpr->pLeft;
  if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
  zAff = exprINAffinity(pParse, pExpr);
  nVector = sqlite3ExprVectorSize(pExpr->pLeft);
  aiMap = (int*)sqlite3DbMallocZero(
      pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1
  );
  if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
 
  /* Attempt to compute the RHS. After this step, if anything other than
  ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
  ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
  ** the RHS has not yet been coded.  */
  v = pParse->pVdbe;
  assert( v!=0 );       /* OOM detected prior to this routine */
  VdbeNoopComment((v, "begin IN expr"));
  eType = sqlite3FindInIndex(pParse, pExpr,
                             IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK,
                             destIfFalse==destIfNull ? 0 : &rRhsHasNull,
                             aiMap, &iTab);
 
  assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH
       || eType==IN_INDEX_INDEX_ASC || eType==IN_INDEX_INDEX_DESC
  );
#ifdef SQLITE_DEBUG
  /* Confirm that aiMap[] contains nVector integer values between 0 and
  ** nVector-1. */
  for(i=0; i<nVector; i++){
    int j, cnt;
    for(cnt=j=0; j<nVector; j++) if( aiMap[j]==i ) cnt++;
    assert( cnt==1 );
  }
#endif
 
  /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
  ** vector, then it is stored in an array of nVector registers starting
  ** at r1.
  **
  ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
  ** so that the fields are in the same order as an existing index.   The
  ** aiMap[] array contains a mapping from the original LHS field order to
  ** the field order that matches the RHS index.
  **
  ** Avoid factoring the LHS of the IN(...) expression out of the loop,
  ** even if it is constant, as OP_Affinity may be used on the register
  ** by code generated below.  */
  assert( pParse->okConstFactor==okConstFactor );
  pParse->okConstFactor = 0;
  rLhsOrig = exprCodeVector(pParse, pLeft, &iDummy);
  pParse->okConstFactor = okConstFactor;
  for(i=0; i<nVector && aiMap[i]==i; i++){} /* Are LHS fields reordered? */
  if( i==nVector ){
    /* LHS fields are not reordered */
    rLhs = rLhsOrig;
  }else{
    /* Need to reorder the LHS fields according to aiMap */
    rLhs = sqlite3GetTempRange(pParse, nVector);
    for(i=0; i<nVector; i++){
      sqlite3VdbeAddOp3(v, OP_Copy, rLhsOrig+i, rLhs+aiMap[i], 0);
    }
  }
 
  /* If sqlite3FindInIndex() did not find or create an index that is
  ** suitable for evaluating the IN operator, then evaluate using a
  ** sequence of comparisons.
  **
  ** This is step (1) in the in-operator.md optimized algorithm.
  */
  if( eType==IN_INDEX_NOOP ){
    ExprList *pList = pExpr->x.pList;
    CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
    int labelOk = sqlite3VdbeMakeLabel(pParse);
    int r2, regToFree;
    int regCkNull = 0;
    int ii;
    assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
    if( destIfNull!=destIfFalse ){
      regCkNull = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull);
    }
    for(ii=0; ii<pList->nExpr; ii++){
      r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, &regToFree);
      if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
        sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull);
      }
      sqlite3ReleaseTempReg(pParse, regToFree);
      if( ii<pList->nExpr-1 || destIfNull!=destIfFalse ){
        int op = rLhs!=r2 ? OP_Eq : OP_NotNull;
        sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2,
                          (void*)pColl, P4_COLLSEQ);
        VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
        VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
        VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull);
        VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull);
        sqlite3VdbeChangeP5(v, zAff[0]);
      }else{
        int op = rLhs!=r2 ? OP_Ne : OP_IsNull;
        assert( destIfNull==destIfFalse );
        sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2,
                          (void*)pColl, P4_COLLSEQ);
        VdbeCoverageIf(v, op==OP_Ne);
        VdbeCoverageIf(v, op==OP_IsNull);
        sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL);
      }
    }
    if( regCkNull ){
      sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v);
      sqlite3VdbeGoto(v, destIfFalse);
    }
    sqlite3VdbeResolveLabel(v, labelOk);
    sqlite3ReleaseTempReg(pParse, regCkNull);
    goto sqlite3ExprCodeIN_finished;
  }
 
  /* Step 2: Check to see if the LHS contains any NULL columns.  If the
  ** LHS does contain NULLs then the result must be either FALSE or NULL.
  ** We will then skip the binary search of the RHS.
  */
  if( destIfNull==destIfFalse ){
    destStep2 = destIfFalse;
  }else{
    destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse);
  }
  if( pParse->nErr ) goto sqlite3ExprCodeIN_finished;
  for(i=0; i<nVector; i++){
    Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
    if( sqlite3ExprCanBeNull(p) ){
      sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2);
      VdbeCoverage(v);
    }
  }
 
  /* Step 3.  The LHS is now known to be non-NULL.  Do the binary search
  ** of the RHS using the LHS as a probe.  If found, the result is
  ** true.
  */
  if( eType==IN_INDEX_ROWID ){
    /* In this case, the RHS is the ROWID of table b-tree and so we also
    ** know that the RHS is non-NULL.  Hence, we combine steps 3 and 4
    ** into a single opcode. */
    sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs);
    VdbeCoverage(v);
    addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto);  /* Return True */
  }else{
    sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
    if( destIfFalse==destIfNull ){
      /* Combine Step 3 and Step 5 into a single opcode */
      sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse,
                           rLhs, nVector); VdbeCoverage(v);
      goto sqlite3ExprCodeIN_finished;
    }
    /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
    addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0,
                                      rLhs, nVector); VdbeCoverage(v);
  }
 
  /* Step 4.  If the RHS is known to be non-NULL and we did not find
  ** an match on the search above, then the result must be FALSE.
  */
  if( rRhsHasNull && nVector==1 ){
    sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse);
    VdbeCoverage(v);
  }
 
  /* Step 5.  If we do not care about the difference between NULL and
  ** FALSE, then just return false.
  */
  if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse);
 
  /* Step 6: Loop through rows of the RHS.  Compare each row to the LHS.
  ** If any comparison is NULL, then the result is NULL.  If all
  ** comparisons are FALSE then the final result is FALSE.
  **
  ** For a scalar LHS, it is sufficient to check just the first row
  ** of the RHS.
  */
  if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6);
  addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse);
  VdbeCoverage(v);
  if( nVector>1 ){
    destNotNull = sqlite3VdbeMakeLabel(pParse);
  }else{
    /* For nVector==1, combine steps 6 and 7 by immediately returning
    ** FALSE if the first comparison is not NULL */
    destNotNull = destIfFalse;
  }
  for(i=0; i<nVector; i++){
    Expr *p;
    CollSeq *pColl;
    int r3 = sqlite3GetTempReg(pParse);
    p = sqlite3VectorFieldSubexpr(pLeft, i);
    pColl = sqlite3ExprCollSeq(pParse, p);
    sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3);
    sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3,
                      (void*)pColl, P4_COLLSEQ);
    VdbeCoverage(v);
    sqlite3ReleaseTempReg(pParse, r3);
  }
  sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
  if( nVector>1 ){
    sqlite3VdbeResolveLabel(v, destNotNull);
    sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1);
    VdbeCoverage(v);
 
    /* Step 7:  If we reach this point, we know that the result must
    ** be false. */
    sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
  }
 
  /* Jumps here in order to return true. */
  sqlite3VdbeJumpHere(v, addrTruthOp);
 
sqlite3ExprCodeIN_finished:

References ExprList::a, Parse::db, EP_Immutable, EP_xIsSelect, eType, exprCodeVector(), ExprHasProperty, ExprHasVVAProperty, exprINAffinity(), IN_INDEX_EPH, IN_INDEX_INDEX_ASC, IN_INDEX_INDEX_DESC, IN_INDEX_MEMBERSHIP, IN_INDEX_NOOP, IN_INDEX_NOOP_OK, IN_INDEX_ROWID, sqlite3::mallocFailed, Parse::nErr, ExprList::nExpr, Parse::okConstFactor, OP_Affinity, OP_BitAnd, OP_Column, OP_Copy, OP_Eq, OP_Found, OP_Goto, OP_IsNull, OP_Ne, OP_Next, OP_NotFound, OP_NotNull, OP_Rewind, OP_SeekRowid, P4_COLLSEQ, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Parse::pVdbe, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3ExprCanBeNull(), sqlite3ExprCheckIN(), sqlite3ExprCodeTemp(), sqlite3ExprCollSeq(), sqlite3ExprVectorSize(), sqlite3FindInIndex(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VectorFieldSubexpr(), SQLITE_JUMPIFNULL, VdbeComment, VdbeCoverage, VdbeCoverageIf, VdbeNoopComment, and Expr::x.

Referenced by sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ sqlite3ExprCodeLoadIndexColumn()

SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn	(	Parse *	pParse,
		Index *	pIdx,
		int	iTabCur,
		int	iIdxCol,
		int	regOut )

Definition at line 103192 of file sqlite3.c.

 {
  i16 iTabCol = pIdx->aiColumn[iIdxCol];
  if( iTabCol==XN_EXPR ){
    assert( pIdx->aColExpr );
    assert( pIdx->aColExpr->nExpr>iIdxCol );
    pParse->iSelfTab = iTabCur + 1;
    sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);

Referenced by analyzeOneTable(), and sqlite3GenerateIndexKey().

◆ sqlite3ExprCodeMove()

SQLITE_PRIVATE void sqlite3ExprCodeMove	(	Parse *	pParse,
		int	iFrom,
		int	iTo,
		int	nReg )

Definition at line 103320 of file sqlite3.c.

Referenced by generateOutputSubroutine(), and sqlite3Select().

◆ sqlite3ExprCodeRunJustOnce()

SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce	(	Parse *	pParse,
		Expr *	pExpr,
		int	regDest )

Definition at line 104257 of file sqlite3.c.

 {
  ExprList *p;
  assert( ConstFactorOk(pParse) );
  p = pParse->pConstExpr;
  if( regDest<0 && p ){
    struct ExprList_item *pItem;
    int i;
    for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
      if( pItem->reusable && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 ){
        return pItem->u.iConstExprReg;
      }
    }
  }
  pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
  if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
    Vdbe *v = pParse->pVdbe;
    int addr;
    assert( v );
    addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
    pParse->okConstFactor = 0;
    if( !pParse->db->mallocFailed ){
      if( regDest<0 ) regDest = ++pParse->nMem;
      sqlite3ExprCode(pParse, pExpr, regDest);
    }
    pParse->okConstFactor = 1;
    sqlite3ExprDelete(pParse->db, pExpr);
    sqlite3VdbeJumpHere(v, addr);
  }else{
    p = sqlite3ExprListAppend(pParse, p, pExpr);
    if( p ){
       struct ExprList_item *pItem = &p->a[p->nExpr-1];
       pItem->reusable = regDest<0;
       if( regDest<0 ) regDest = ++pParse->nMem;

References ExprList::a, ConstFactorOk, Parse::db, EP_HasFunc, ExprHasProperty, sqlite3::mallocFailed, ExprList::nExpr, Parse::nMem, Parse::okConstFactor, OP_Once, Parse::pConstExpr, Parse::pVdbe, ExprList::ExprList_item::reusable, sqlite3ExprCode(), sqlite3ExprCompare(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3VdbeAddOp0(), sqlite3VdbeJumpHere(), and VdbeCoverage.

Referenced by sqlite3ExprCodeExprList(), sqlite3ExprCodeFactorable(), sqlite3ExprCodeTarget(), and sqlite3ExprCodeTemp().

◆ sqlite3ExprCodeTarget()

SQLITE_PRIVATE int sqlite3ExprCodeTarget	(	Parse *	pParse,
		Expr *	pExpr,
		int	target )

Definition at line 103502 of file sqlite3.c.

                                                                                {
  Vdbe *v = pParse->pVdbe;  /* The VM under construction */
  int op;                   /* The opcode being coded */
  int inReg = target;       /* Results stored in register inReg */
  int regFree1 = 0;         /* If non-zero free this temporary register */
  int regFree2 = 0;         /* If non-zero free this temporary register */
  int r1, r2;               /* Various register numbers */
  Expr tempX;               /* Temporary expression node */
  int p5 = 0;
 
  assert( target>0 && target<=pParse->nMem );
  assert( v!=0 );
 
expr_code_doover:
  if( pExpr==0 ){
    op = TK_NULL;
  }else{
    assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
    op = pExpr->op;
  }
  switch( op ){
    case TK_AGG_COLUMN: {
      AggInfo *pAggInfo = pExpr->pAggInfo;
      struct AggInfo_col *pCol;
      assert( pAggInfo!=0 );
      assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
      pCol = &pAggInfo->aCol[pExpr->iAgg];
      if( !pAggInfo->directMode ){
        assert( pCol->iMem>0 );
        return pCol->iMem;
      }else if( pAggInfo->useSortingIdx ){
        Table *pTab = pCol->pTab;
        sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
                              pCol->iSorterColumn, target);
        if( pCol->iColumn<0 ){
          VdbeComment((v,"%s.rowid",pTab->zName));
        }else{
          VdbeComment((v,"%s.%s",pTab->zName,pTab->aCol[pCol->iColumn].zName));
          if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){
            sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
          }
        }
        return target;
      }
      /* Otherwise, fall thru into the TK_COLUMN case */
      /* no break */ deliberate_fall_through
    }
    case TK_COLUMN: {
      int iTab = pExpr->iTable;
      int iReg;
      if( ExprHasProperty(pExpr, EP_FixedCol) ){
        /* This COLUMN expression is really a constant due to WHERE clause
        ** constraints, and that constant is coded by the pExpr->pLeft
        ** expresssion.  However, make sure the constant has the correct
        ** datatype by applying the Affinity of the table column to the
        ** constant.
        */
        int aff;
        iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
        if( pExpr->y.pTab ){
          aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
        }else{
          aff = pExpr->affExpr;
        }
        if( aff>SQLITE_AFF_BLOB ){
          static const char zAff[] = "B\000C\000D\000E";
          assert( SQLITE_AFF_BLOB=='A' );
          assert( SQLITE_AFF_TEXT=='B' );
          sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0,
                            &zAff[(aff-'B')*2], P4_STATIC);
        }
        return iReg;
      }
      if( iTab<0 ){
        if( pParse->iSelfTab<0 ){
          /* Other columns in the same row for CHECK constraints or
          ** generated columns or for inserting into partial index.
          ** The row is unpacked into registers beginning at
          ** 0-(pParse->iSelfTab).  The rowid (if any) is in a register
          ** immediately prior to the first column.
          */
          Column *pCol;
          Table *pTab = pExpr->y.pTab;
          int iSrc;
          int iCol = pExpr->iColumn;
          assert( pTab!=0 );
          assert( iCol>=XN_ROWID );
          assert( iCol<pTab->nCol );
          if( iCol<0 ){
            return -1-pParse->iSelfTab;
          }
          pCol = pTab->aCol + iCol;
          testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
          iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
          if( pCol->colFlags & COLFLAG_GENERATED ){
            if( pCol->colFlags & COLFLAG_BUSY ){
              sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
                              pCol->zName);
              return 0;
            }
            pCol->colFlags |= COLFLAG_BUSY;
            if( pCol->colFlags & COLFLAG_NOTAVAIL ){
              sqlite3ExprCodeGeneratedColumn(pParse, pCol, iSrc);
            }
            pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL);
            return iSrc;
          }else
#endif /* SQLITE_OMIT_GENERATED_COLUMNS */
          if( pCol->affinity==SQLITE_AFF_REAL ){
            sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target);
            sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
            return target;
          }else{
            return iSrc;
          }
        }else{
          /* Coding an expression that is part of an index where column names
          ** in the index refer to the table to which the index belongs */
          iTab = pParse->iSelfTab - 1;
        }
      }
      iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
                               pExpr->iColumn, iTab, target,
                               pExpr->op2);
      if( pExpr->y.pTab==0 && pExpr->affExpr==SQLITE_AFF_REAL ){
        sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
      }
      return iReg;
    }
    case TK_INTEGER: {
      codeInteger(pParse, pExpr, 0, target);
      return target;
    }
    case TK_TRUEFALSE: {
      sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
      return target;
    }
#ifndef SQLITE_OMIT_FLOATING_POINT
    case TK_FLOAT: {
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      codeReal(v, pExpr->u.zToken, 0, target);
      return target;
    }
#endif
    case TK_STRING: {
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
      return target;
    }
    default: {
      /* Make NULL the default case so that if a bug causes an illegal
      ** Expr node to be passed into this function, it will be handled
      ** sanely and not crash.  But keep the assert() to bring the problem
      ** to the attention of the developers. */
      assert( op==TK_NULL );
      sqlite3VdbeAddOp2(v, OP_Null, 0, target);
      return target;
    }
#ifndef SQLITE_OMIT_BLOB_LITERAL
    case TK_BLOB: {
      int n;
      const char *z;
      char *zBlob;
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
      assert( pExpr->u.zToken[1]=='\'' );
      z = &pExpr->u.zToken[2];
      n = sqlite3Strlen30(z) - 1;
      assert( z[n]=='\'' );
      zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
      sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
      return target;
    }
#endif
    case TK_VARIABLE: {
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      assert( pExpr->u.zToken!=0 );
      assert( pExpr->u.zToken[0]!=0 );
      sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
      if( pExpr->u.zToken[1]!=0 ){
        const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
        assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) );
        pParse->pVList[0] = 0; /* Indicate VList may no longer be enlarged */
        sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC);
      }
      return target;
    }
    case TK_REGISTER: {
      return pExpr->iTable;
    }
#ifndef SQLITE_OMIT_CAST
    case TK_CAST: {
      /* Expressions of the form:   CAST(pLeft AS token) */
      inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
      if( inReg!=target ){
        sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
        inReg = target;
      }
      sqlite3VdbeAddOp2(v, OP_Cast, target,
                        sqlite3AffinityType(pExpr->u.zToken, 0));
      return inReg;
    }
#endif /* SQLITE_OMIT_CAST */
    case TK_IS:
    case TK_ISNOT:
      op = (op==TK_IS) ? TK_EQ : TK_NE;
      p5 = SQLITE_NULLEQ;
      /* fall-through */
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE:
    case TK_NE:
    case TK_EQ: {
      Expr *pLeft = pExpr->pLeft;
      if( sqlite3ExprIsVector(pLeft) ){
        codeVectorCompare(pParse, pExpr, target, op, p5);
      }else{
        r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
        codeCompare(pParse, pLeft, pExpr->pRight, op,
            r1, r2, inReg, SQLITE_STOREP2 | p5,
            ExprHasProperty(pExpr,EP_Commuted));
        assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
        assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
        assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
        assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
        assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
        assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
        testcase( regFree1==0 );
        testcase( regFree2==0 );
      }
      break;
    }
    case TK_AND:
    case TK_OR:
    case TK_PLUS:
    case TK_STAR:
    case TK_MINUS:
    case TK_REM:
    case TK_BITAND:
    case TK_BITOR:
    case TK_SLASH:
    case TK_LSHIFT:
    case TK_RSHIFT:
    case TK_CONCAT: {
      assert( TK_AND==OP_And );            testcase( op==TK_AND );
      assert( TK_OR==OP_Or );              testcase( op==TK_OR );
      assert( TK_PLUS==OP_Add );           testcase( op==TK_PLUS );
      assert( TK_MINUS==OP_Subtract );     testcase( op==TK_MINUS );
      assert( TK_REM==OP_Remainder );      testcase( op==TK_REM );
      assert( TK_BITAND==OP_BitAnd );      testcase( op==TK_BITAND );
      assert( TK_BITOR==OP_BitOr );        testcase( op==TK_BITOR );
      assert( TK_SLASH==OP_Divide );       testcase( op==TK_SLASH );
      assert( TK_LSHIFT==OP_ShiftLeft );   testcase( op==TK_LSHIFT );
      assert( TK_RSHIFT==OP_ShiftRight );  testcase( op==TK_RSHIFT );
      assert( TK_CONCAT==OP_Concat );      testcase( op==TK_CONCAT );
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
      sqlite3VdbeAddOp3(v, op, r2, r1, target);
      testcase( regFree1==0 );
      testcase( regFree2==0 );
      break;
    }
    case TK_UMINUS: {
      Expr *pLeft = pExpr->pLeft;
      assert( pLeft );
      if( pLeft->op==TK_INTEGER ){
        codeInteger(pParse, pLeft, 1, target);
        return target;
#ifndef SQLITE_OMIT_FLOATING_POINT
      }else if( pLeft->op==TK_FLOAT ){
        assert( !ExprHasProperty(pExpr, EP_IntValue) );
        codeReal(v, pLeft->u.zToken, 1, target);
        return target;
#endif
      }else{
        tempX.op = TK_INTEGER;
        tempX.flags = EP_IntValue|EP_TokenOnly;
        tempX.u.iValue = 0;
        ExprClearVVAProperties(&tempX);
        r1 = sqlite3ExprCodeTemp(pParse, &tempX, &regFree1);
        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
        sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
        testcase( regFree2==0 );
      }
      break;
    }
    case TK_BITNOT:
    case TK_NOT: {
      assert( TK_BITNOT==OP_BitNot );   testcase( op==TK_BITNOT );
      assert( TK_NOT==OP_Not );         testcase( op==TK_NOT );
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      testcase( regFree1==0 );
      sqlite3VdbeAddOp2(v, op, r1, inReg);
      break;
    }
    case TK_TRUTH: {
      int isTrue;    /* IS TRUE or IS NOT TRUE */
      int bNormal;   /* IS TRUE or IS FALSE */
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      testcase( regFree1==0 );
      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
      bNormal = pExpr->op2==TK_IS;
      testcase( isTrue && bNormal);
      testcase( !isTrue && bNormal);
      sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal);
      break;
    }
    case TK_ISNULL:
    case TK_NOTNULL: {
      int addr;
      assert( TK_ISNULL==OP_IsNull );   testcase( op==TK_ISNULL );
      assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
      sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      testcase( regFree1==0 );
      addr = sqlite3VdbeAddOp1(v, op, r1);
      VdbeCoverageIf(v, op==TK_ISNULL);
      VdbeCoverageIf(v, op==TK_NOTNULL);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
      sqlite3VdbeJumpHere(v, addr);
      break;
    }
    case TK_AGG_FUNCTION: {
      AggInfo *pInfo = pExpr->pAggInfo;
      if( pInfo==0
       || NEVER(pExpr->iAgg<0)
       || NEVER(pExpr->iAgg>=pInfo->nFunc)
      ){
        assert( !ExprHasProperty(pExpr, EP_IntValue) );
        sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
      }else{
        return pInfo->aFunc[pExpr->iAgg].iMem;
      }
      break;
    }
    case TK_FUNCTION: {
      ExprList *pFarg;       /* List of function arguments */
      int nFarg;             /* Number of function arguments */
      FuncDef *pDef;         /* The function definition object */
      const char *zId;       /* The function name */
      u32 constMask = 0;     /* Mask of function arguments that are constant */
      int i;                 /* Loop counter */
      sqlite3 *db = pParse->db;  /* The database connection */
      u8 enc = ENC(db);      /* The text encoding used by this database */
      CollSeq *pColl = 0;    /* A collating sequence */
 
#ifndef SQLITE_OMIT_WINDOWFUNC
      if( ExprHasProperty(pExpr, EP_WinFunc) ){
        return pExpr->y.pWin->regResult;
      }
#endif
 
      if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
        /* SQL functions can be expensive. So try to avoid running them
        ** multiple times if we know they always give the same result */
        return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
      }
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
      pFarg = pExpr->x.pList;
      nFarg = pFarg ? pFarg->nExpr : 0;
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      zId = pExpr->u.zToken;
      pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0);
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
      if( pDef==0 && pParse->explain ){
        pDef = sqlite3FindFunction(db, "unknown", nFarg, enc, 0);
      }
#endif
      if( pDef==0 || pDef->xFinalize!=0 ){
        sqlite3ErrorMsg(pParse, "unknown function: %s()", zId);
        break;
      }
      if( pDef->funcFlags & SQLITE_FUNC_INLINE ){
        assert( (pDef->funcFlags & SQLITE_FUNC_UNSAFE)==0 );
        assert( (pDef->funcFlags & SQLITE_FUNC_DIRECT)==0 );
        return exprCodeInlineFunction(pParse, pFarg,
             SQLITE_PTR_TO_INT(pDef->pUserData), target);
      }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){
        sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
      }
 
      for(i=0; i<nFarg; i++){
        if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
          testcase( i==31 );
          constMask |= MASKBIT32(i);
        }
        if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
          pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
        }
      }
      if( pFarg ){
        if( constMask ){
          r1 = pParse->nMem+1;
          pParse->nMem += nFarg;
        }else{
          r1 = sqlite3GetTempRange(pParse, nFarg);
        }
 
        /* For length() and typeof() functions with a column argument,
        ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
        ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
        ** loading.
        */
        if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){
          u8 exprOp;
          assert( nFarg==1 );
          assert( pFarg->a[0].pExpr!=0 );
          exprOp = pFarg->a[0].pExpr->op;
          if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){
            assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
            assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
            testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
            pFarg->a[0].pExpr->op2 =
                  pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG);
          }
        }
 
        sqlite3ExprCodeExprList(pParse, pFarg, r1, 0,
                                SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR);
      }else{
        r1 = 0;
      }
#ifndef SQLITE_OMIT_VIRTUALTABLE
      /* Possibly overload the function if the first argument is
      ** a virtual table column.
      **
      ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
      ** second argument, not the first, as the argument to test to
      ** see if it is a column in a virtual table.  This is done because
      ** the left operand of infix functions (the operand we want to
      ** control overloading) ends up as the second argument to the
      ** function.  The expression "A glob B" is equivalent to
      ** "glob(B,A).  We want to use the A in "A glob B" to test
      ** for function overloading.  But we use the B term in "glob(B,A)".
      */
      if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
        pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
      }else if( nFarg>0 ){
        pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
      }
#endif
      if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){
        if( !pColl ) pColl = db->pDfltColl;
        sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
      }
#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
      if( pDef->funcFlags & SQLITE_FUNC_OFFSET ){
        Expr *pArg = pFarg->a[0].pExpr;
        if( pArg->op==TK_COLUMN ){
          sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
        }else{
          sqlite3VdbeAddOp2(v, OP_Null, 0, target);
        }
      }else
#endif
      {
        sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg,
                                   pDef, pExpr->op2);
      }
      if( nFarg ){
        if( constMask==0 ){
          sqlite3ReleaseTempRange(pParse, r1, nFarg);
        }else{
          sqlite3VdbeReleaseRegisters(pParse, r1, nFarg, constMask, 1);
        }
      }
      return target;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_EXISTS:
    case TK_SELECT: {
      int nCol;
      testcase( op==TK_EXISTS );
      testcase( op==TK_SELECT );
      if( pParse->db->mallocFailed ){
        return 0;
      }else if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){
        sqlite3SubselectError(pParse, nCol, 1);
      }else{
        return sqlite3CodeSubselect(pParse, pExpr);
      }
      break;
    }
    case TK_SELECT_COLUMN: {
      int n;
      if( pExpr->pLeft->iTable==0 ){
        pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
      }
      assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT );
      if( pExpr->iTable!=0
       && pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
      ){
        sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
                                pExpr->iTable, n);
      }
      return pExpr->pLeft->iTable + pExpr->iColumn;
    }
    case TK_IN: {
      int destIfFalse = sqlite3VdbeMakeLabel(pParse);
      int destIfNull = sqlite3VdbeMakeLabel(pParse);
      sqlite3VdbeAddOp2(v, OP_Null, 0, target);
      sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
      sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
      sqlite3VdbeResolveLabel(v, destIfFalse);
      sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
      sqlite3VdbeResolveLabel(v, destIfNull);
      return target;
    }
#endif /* SQLITE_OMIT_SUBQUERY */
 
 
    /*
    **    x BETWEEN y AND z
    **
    ** This is equivalent to
    **
    **    x>=y AND x<=z
    **
    ** X is stored in pExpr->pLeft.
    ** Y is stored in pExpr->pList->a[0].pExpr.
    ** Z is stored in pExpr->pList->a[1].pExpr.
    */
    case TK_BETWEEN: {
      exprCodeBetween(pParse, pExpr, target, 0, 0);
      return target;
    }
    case TK_SPAN:
    case TK_COLLATE:
    case TK_UPLUS: {
      pExpr = pExpr->pLeft;
      goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */
    }
 
    case TK_TRIGGER: {
      /* If the opcode is TK_TRIGGER, then the expression is a reference
      ** to a column in the new.* or old.* pseudo-tables available to
      ** trigger programs. In this case Expr.iTable is set to 1 for the
      ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
      ** is set to the column of the pseudo-table to read, or to -1 to
      ** read the rowid field.
      **
      ** The expression is implemented using an OP_Param opcode. The p1
      ** parameter is set to 0 for an old.rowid reference, or to (i+1)
      ** to reference another column of the old.* pseudo-table, where
      ** i is the index of the column. For a new.rowid reference, p1 is
      ** set to (n+1), where n is the number of columns in each pseudo-table.
      ** For a reference to any other column in the new.* pseudo-table, p1
      ** is set to (n+2+i), where n and i are as defined previously. For
      ** example, if the table on which triggers are being fired is
      ** declared as:
      **
      **   CREATE TABLE t1(a, b);
      **
      ** Then p1 is interpreted as follows:
      **
      **   p1==0   ->    old.rowid     p1==3   ->    new.rowid
      **   p1==1   ->    old.a         p1==4   ->    new.a
      **   p1==2   ->    old.b         p1==5   ->    new.b
      */
      Table *pTab = pExpr->y.pTab;
      int iCol = pExpr->iColumn;
      int p1 = pExpr->iTable * (pTab->nCol+1) + 1
                     + sqlite3TableColumnToStorage(pTab, iCol);
 
      assert( pExpr->iTable==0 || pExpr->iTable==1 );
      assert( iCol>=-1 && iCol<pTab->nCol );
      assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
      assert( p1>=0 && p1<(pTab->nCol*2+2) );
 
      sqlite3VdbeAddOp2(v, OP_Param, p1, target);
      VdbeComment((v, "r[%d]=%s.%s", target,
        (pExpr->iTable ? "new" : "old"),
        (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
      ));
 
#ifndef SQLITE_OMIT_FLOATING_POINT
      /* If the column has REAL affinity, it may currently be stored as an
      ** integer. Use OP_RealAffinity to make sure it is really real.
      **
      ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
      ** floating point when extracting it from the record.  */
      if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
        sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
      }
#endif
      break;
    }
 
    case TK_VECTOR: {
      sqlite3ErrorMsg(pParse, "row value misused");
      break;
    }
 
    /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
    ** that derive from the right-hand table of a LEFT JOIN.  The
    ** Expr.iTable value is the table number for the right-hand table.
    ** The expression is only evaluated if that table is not currently
    ** on a LEFT JOIN NULL row.
    */
    case TK_IF_NULL_ROW: {
      int addrINR;
      u8 okConstFactor = pParse->okConstFactor;
      addrINR = sqlite3VdbeAddOp1(v, OP_IfNullRow, pExpr->iTable);
      /* Temporarily disable factoring of constant expressions, since
      ** even though expressions may appear to be constant, they are not
      ** really constant because they originate from the right-hand side
      ** of a LEFT JOIN. */
      pParse->okConstFactor = 0;
      inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
      pParse->okConstFactor = okConstFactor;
      sqlite3VdbeJumpHere(v, addrINR);
      sqlite3VdbeChangeP3(v, addrINR, inReg);
      break;
    }
 
    /*
    ** Form A:
    **   CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
    **
    ** Form B:
    **   CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
    **
    ** Form A is can be transformed into the equivalent form B as follows:
    **   CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
    **        WHEN x=eN THEN rN ELSE y END
    **
    ** X (if it exists) is in pExpr->pLeft.
    ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
    ** odd.  The Y is also optional.  If the number of elements in x.pList
    ** is even, then Y is omitted and the "otherwise" result is NULL.
    ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
    **
    ** The result of the expression is the Ri for the first matching Ei,
    ** or if there is no matching Ei, the ELSE term Y, or if there is
    ** no ELSE term, NULL.
    */
    case TK_CASE: {
      int endLabel;                     /* GOTO label for end of CASE stmt */
      int nextCase;                     /* GOTO label for next WHEN clause */
      int nExpr;                        /* 2x number of WHEN terms */
      int i;                            /* Loop counter */
      ExprList *pEList;                 /* List of WHEN terms */
      struct ExprList_item *aListelem;  /* Array of WHEN terms */
      Expr opCompare;                   /* The X==Ei expression */
      Expr *pX;                         /* The X expression */
      Expr *pTest = 0;                  /* X==Ei (form A) or just Ei (form B) */
      Expr *pDel = 0;
      sqlite3 *db = pParse->db;
 
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
      assert(pExpr->x.pList->nExpr > 0);
      pEList = pExpr->x.pList;
      aListelem = pEList->a;
      nExpr = pEList->nExpr;
      endLabel = sqlite3VdbeMakeLabel(pParse);
      if( (pX = pExpr->pLeft)!=0 ){
        pDel = sqlite3ExprDup(db, pX, 0);
        if( db->mallocFailed ){
          sqlite3ExprDelete(db, pDel);
          break;
        }
        testcase( pX->op==TK_COLUMN );
        exprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
        testcase( regFree1==0 );
        memset(&opCompare, 0, sizeof(opCompare));
        opCompare.op = TK_EQ;
        opCompare.pLeft = pDel;
        pTest = &opCompare;
        /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
        ** The value in regFree1 might get SCopy-ed into the file result.
        ** So make sure that the regFree1 register is not reused for other
        ** purposes and possibly overwritten.  */
        regFree1 = 0;
      }
      for(i=0; i<nExpr-1; i=i+2){
        if( pX ){
          assert( pTest!=0 );
          opCompare.pRight = aListelem[i].pExpr;
        }else{
          pTest = aListelem[i].pExpr;
        }
        nextCase = sqlite3VdbeMakeLabel(pParse);
        testcase( pTest->op==TK_COLUMN );
        sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
        testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
        sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
        sqlite3VdbeGoto(v, endLabel);
        sqlite3VdbeResolveLabel(v, nextCase);
      }
      if( (nExpr&1)!=0 ){
        sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
      }else{
        sqlite3VdbeAddOp2(v, OP_Null, 0, target);
      }
      sqlite3ExprDelete(db, pDel);
      setDoNotMergeFlagOnCopy(v);
      sqlite3VdbeResolveLabel(v, endLabel);
      break;
    }
#ifndef SQLITE_OMIT_TRIGGER
    case TK_RAISE: {
      assert( pExpr->affExpr==OE_Rollback
           || pExpr->affExpr==OE_Abort
           || pExpr->affExpr==OE_Fail
           || pExpr->affExpr==OE_Ignore
      );
      if( !pParse->pTriggerTab && !pParse->nested ){
        sqlite3ErrorMsg(pParse,
                       "RAISE() may only be used within a trigger-program");
        return 0;
      }
      if( pExpr->affExpr==OE_Abort ){
        sqlite3MayAbort(pParse);
      }
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
      if( pExpr->affExpr==OE_Ignore ){
        sqlite3VdbeAddOp4(
            v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
        VdbeCoverage(v);
      }else{
        sqlite3HaltConstraint(pParse,
             pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR,
             pExpr->affExpr, pExpr->u.zToken, 0, 0);
      }
 
      break;
    }

References ExprList::a, Table::aCol, AggInfo::aCol, Expr::affExpr, Column::affinity, AggInfo::aFunc, codeCompare(), codeInteger(), codeReal(), codeVectorCompare(), COLFLAG_BUSY, COLFLAG_GENERATED, COLFLAG_NOTAVAIL, Column::colFlags, ConstFactorOk, Parse::db, deliberate_fall_through, AggInfo::directMode, ENC, EP_Commuted, EP_FixedCol, EP_Immutable, EP_InfixFunc, EP_IntValue, EP_TokenOnly, EP_WinFunc, EP_xIsSelect, Parse::explain, ExprClearVVAProperties, exprCodeBetween(), exprCodeInlineFunction(), exprCodeVector(), ExprHasProperty, ExprHasVVAProperty, exprToRegister(), Expr::flags, FuncDef::funcFlags, Expr::iAgg, Expr::iColumn, AggInfo::AggInfo_func::iMem, Table::iPKey, Parse::iSelfTab, Expr::iTable, Expr::iValue, sqlite3::mallocFailed, MASKBIT32, Table::nCol, AggInfo::nColumn, Parse::nested, NEVER, ExprList::nExpr, AggInfo::nFunc, Parse::nMem, OE_Abort, OE_Fail, OE_Ignore, OE_Rollback, Parse::okConstFactor, Expr::op, Expr::op2, OP_Add, OP_AddImm, OP_Affinity, OP_And, OP_BitAnd, OP_BitNot, OP_BitOr, OP_Blob, OP_Cast, OP_CollSeq, OP_Column, OP_Concat, OP_Divide, OP_Eq, OP_Ge, OP_Gt, OP_Halt, OP_IfNullRow, OP_Integer, OP_IsNull, OP_IsTrue, OP_Le, OP_Lt, OP_Ne, OP_Not, OP_NotNull, OP_Null, OP_Offset, OP_Or, OP_Param, OP_RealAffinity, OP_Remainder, OP_SCopy, OP_ShiftLeft, OP_ShiftRight, OP_Subtract, OP_Variable, OPFLAG_LENGTHARG, OPFLAG_TYPEOFARG, P4_COLLSEQ, P4_DYNAMIC, P4_STATIC, Expr::pAggInfo, sqlite3::pDfltColl, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pSelect, Expr::pTab, Parse::pTriggerTab, FuncDef::pUserData, Parse::pVdbe, Parse::pVList, Expr::pWin, Window::regResult, setDoNotMergeFlagOnCopy(), AggInfo::sortingIdxPTab, sqlite3AffinityType(), sqlite3CodeSubselect(), sqlite3ErrorMsg(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeGetColumn(), sqlite3ExprCodeIN(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprCodeTemp(), sqlite3ExprCollSeq(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprFunctionUsable(), sqlite3ExprIfFalse(), sqlite3ExprIsConstant(), sqlite3ExprIsConstantNotJoin(), sqlite3ExprIsVector(), sqlite3ExprTruthValue(), sqlite3ExprVectorSize(), sqlite3FindFunction(), sqlite3GetTempRange(), sqlite3HaltConstraint(), sqlite3HexToBlob(), sqlite3MayAbort(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3Strlen30(), sqlite3SubselectError(), sqlite3TableColumnAffinity(), sqlite3TableColumnToStorage(), sqlite3VdbeAddFunctionCall(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP3(), sqlite3VdbeDb(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeLoadString(), sqlite3VdbeMakeLabel(), sqlite3VdbeReleaseRegisters, sqlite3VdbeResolveLabel(), sqlite3VListNumToName(), sqlite3VtabOverloadFunction(), SQLITE_AFF_BLOB, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, SQLITE_CONSTRAINT_TRIGGER, SQLITE_ECEL_DUP, SQLITE_ECEL_FACTOR, SQLITE_ERROR, SQLITE_FUNC_DIRECT, SQLITE_FUNC_INLINE, SQLITE_FUNC_LENGTH, SQLITE_FUNC_NEEDCOLL, SQLITE_FUNC_OFFSET, SQLITE_FUNC_TYPEOF, SQLITE_FUNC_UNSAFE, SQLITE_JUMPIFNULL, SQLITE_NULLEQ, SQLITE_OK, SQLITE_PTR_TO_INT, SQLITE_STOREP2, testcase, TK_AGG_COLUMN, TK_AGG_FUNCTION, TK_AND, TK_BETWEEN, TK_BITAND, TK_BITNOT, TK_BITOR, TK_BLOB, TK_CASE, TK_CAST, TK_COLLATE, TK_COLUMN, TK_CONCAT, TK_EQ, TK_EXISTS, TK_FLOAT, TK_FUNCTION, TK_GE, TK_GT, TK_IF_NULL_ROW, TK_IN, TK_INTEGER, TK_IS, TK_ISNOT, TK_ISNULL, TK_LE, TK_LSHIFT, TK_LT, TK_MINUS, TK_NE, TK_NOT, TK_NOTNULL, TK_NULL, TK_OR, TK_PLUS, TK_RAISE, TK_REGISTER, TK_REM, TK_RSHIFT, TK_SELECT, TK_SELECT_COLUMN, TK_SLASH, TK_SPAN, TK_STAR, TK_STRING, TK_TRIGGER, TK_TRUEFALSE, TK_TRUTH, TK_UMINUS, TK_UPLUS, TK_VARIABLE, TK_VECTOR, Expr::u, AggInfo::useSortingIdx, VdbeComment, VdbeCoverage, VdbeCoverageIf, Expr::x, FuncDef::xFinalize, XN_ROWID, Expr::y, Column::zName, Table::zName, and Expr::zToken.

Referenced by codeEqualityTerm(), exprCodeBetween(), isLikeOrGlob(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeTarget(), and sqlite3ExprCodeTemp().

◆ sqlite3ExprCodeTemp()

SQLITE_PRIVATE int sqlite3ExprCodeTemp	(	Parse *	pParse,
		Expr *	pExpr,
		int *	pReg )

Definition at line 104314 of file sqlite3.c.

                                                                             {
  int r2;
  pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
  if( ConstFactorOk(pParse)
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
    *pReg  = 0;
    r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    if( r2==r1 ){
      *pReg = r1;
    }else{

References ConstFactorOk, Expr::op, sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprIsConstantNotJoin(), sqlite3ExprSkipCollateAndLikely(), sqlite3GetTempReg(), sqlite3ReleaseTempReg(), and TK_REGISTER.

Referenced by exprCodeVector(), exprVectorRegister(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), and sqlite3ExprIfTrue().

◆ sqlite3ExprCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3ExprCollSeq	(	Parse *	pParse,
		const Expr *	pExpr )

Definition at line 99866 of file sqlite3.c.

                                                                            {
  sqlite3 *db = pParse->db;
  CollSeq *pColl = 0;
  const Expr *p = pExpr;
  while( p ){
    int op = p->op;
    if( op==TK_REGISTER ) op = p->op2;
    if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER)
     && p->y.pTab!=0
    ){
      /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
      ** a TK_COLUMN but was previously evaluated and cached in a register */
      int j = p->iColumn;
      if( j>=0 ){
        const char *zColl = p->y.pTab->aCol[j].zColl;
        pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
      }
      break;
    }
    if( op==TK_CAST || op==TK_UPLUS ){
      p = p->pLeft;
      continue;
    }
    if( op==TK_VECTOR ){
      p = p->x.pList->a[0].pExpr;
      continue;
    }
    if( op==TK_COLLATE ){
      pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
      break;
    }
    if( p->flags & EP_Collate ){
      if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
        p = p->pLeft;
      }else{
        Expr *pNext  = p->pRight;
        /* The Expr.x union is never used at the same time as Expr.pRight */
        assert( p->x.pList==0 || p->pRight==0 );
        if( p->x.pList!=0
         && !db->mallocFailed
         && ALWAYS(!ExprHasProperty(p, EP_xIsSelect))
        ){
          int i;
          for(i=0; ALWAYS(i<p->x.pList->nExpr); i++){
            if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
              pNext = p->x.pList->a[i].pExpr;
              break;
            }
          }
        }
        p = pNext;
      }
    }else{
      break;
    }

References ExprList::a, Table::aCol, ALWAYS, Parse::db, ENC, EP_Collate, EP_xIsSelect, ExprHasProperty, Expr::flags, Expr::iColumn, sqlite3::mallocFailed, Expr::op, Expr::op2, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pTab, sqlite3CheckCollSeq(), sqlite3FindCollSeq(), sqlite3GetCollSeq(), TK_AGG_COLUMN, TK_CAST, TK_COLLATE, TK_COLUMN, TK_REGISTER, TK_TRIGGER, TK_UPLUS, TK_VECTOR, Expr::u, Expr::x, Expr::y, Column::zColl, and Expr::zToken.

Referenced by multiSelectCollSeq(), multiSelectOrderByKeyInfo(), selectInnerLoop(), sqlite3BinaryCompareCollSeq(), sqlite3CodeRhsOfIN(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprNNCollSeq(), sqlite3SelectAddColumnTypeAndCollation(), substExpr(), and updateAccumulator().

◆ sqlite3ExprCollSeqMatch()

SQLITE_PRIVATE int sqlite3ExprCollSeqMatch	(	Parse *	pParse,
		const Expr *	pE1,
		const Expr *	pE2 )

Definition at line 99948 of file sqlite3.c.

Referenced by termIsEquivalence().

◆ sqlite3ExprColUsed()

SQLITE_PRIVATE Bitmask sqlite3ExprColUsed ( Expr * pExpr )

Definition at line 97938 of file sqlite3.c.

                                                      {
  int n;
  Table *pExTab;
 
  n = pExpr->iColumn;
  pExTab = pExpr->y.pTab;
  assert( pExTab!=0 );
  if( (pExTab->tabFlags & TF_HasGenerated)!=0
   && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
  ){
    testcase( pExTab->nCol==BMS-1 );
    testcase( pExTab->nCol==BMS );
    return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
  }else{

Referenced by lookupName().

◆ sqlite3ExprCompare()

SQLITE_PRIVATE int sqlite3ExprCompare	(	Parse *	pParse,
		Expr *	pA,
		Expr *	pB,
		int	iTab )

Definition at line 104941 of file sqlite3.c.

                                                                                  {
  u32 combinedFlags;
  if( pA==0 || pB==0 ){
    return pB==pA ? 0 : 2;
  }
  if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){
    return 0;
  }
  combinedFlags = pA->flags | pB->flags;
  if( combinedFlags & EP_IntValue ){
    if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
      return 0;
    }
    return 2;
  }
  if( pA->op!=pB->op || pA->op==TK_RAISE ){
    if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){
      return 1;
    }
    if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){
      return 1;
    }
    return 2;
  }
  if( pA->op!=TK_COLUMN && pA->op!=TK_AGG_COLUMN && pA->u.zToken ){
    if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){
      if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
#ifndef SQLITE_OMIT_WINDOWFUNC
      assert( pA->op==pB->op );
      if( ExprHasProperty(pA,EP_WinFunc)!=ExprHasProperty(pB,EP_WinFunc) ){
        return 2;
      }
      if( ExprHasProperty(pA,EP_WinFunc) ){
        if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){
          return 2;
        }
      }
#endif
    }else if( pA->op==TK_NULL ){
      return 0;
    }else if( pA->op==TK_COLLATE ){
      if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
    }else if( ALWAYS(pB->u.zToken!=0) && strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
      return 2;
    }
  }
  if( (pA->flags & (EP_Distinct|EP_Commuted))
     != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2;
  if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){
    if( combinedFlags & EP_xIsSelect ) return 2;
    if( (combinedFlags & EP_FixedCol)==0
     && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2;
    if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2;
    if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
    if( pA->op!=TK_STRING
     && pA->op!=TK_TRUEFALSE
     && ALWAYS((combinedFlags & EP_Reduced)==0)
    ){
      if( pA->iColumn!=pB->iColumn ) return 2;
      if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2;
      if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){

References ALWAYS, EP_Commuted, EP_Distinct, EP_FixedCol, EP_IntValue, EP_Reduced, EP_TokenOnly, EP_WinFunc, EP_xIsSelect, exprCompareVariable(), ExprHasProperty, Expr::flags, Expr::iColumn, Expr::iTable, Expr::iValue, Expr::op, Expr::op2, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pWin, sqlite3_stricmp(), sqlite3ExprCompare(), sqlite3ExprListCompare(), sqlite3StrICmp(), sqlite3WindowCompare(), TK_AGG_COLUMN, TK_AGG_FUNCTION, TK_COLLATE, TK_COLUMN, TK_FUNCTION, TK_IN, TK_NULL, TK_RAISE, TK_STRING, TK_TRUEFALSE, TK_TRUTH, TK_VARIABLE, Expr::u, Expr::x, Expr::y, and Expr::zToken.

Referenced by analyzeAggregate(), exprAnalyzeOrTerm(), exprImpliesNotNull(), isSelfJoinView(), resolveOrderByTermToExprList(), resolveOrderGroupBy(), selectWindowRewriteExprCb(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCompare(), sqlite3ExprImpliesExpr(), sqlite3ExprListCompare(), sqlite3UpsertAnalyzeTarget(), sqlite3WindowCompare(), whereApplyPartialIndexConstraints(), whereCombineDisjuncts(), whereIndexExprTransNode(), xferCompatibleIndex(), and xferOptimization().

◆ sqlite3ExprCompareCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3ExprCompareCollSeq	(	Parse *	pParse,
		const Expr *	p )

Definition at line 100069 of file sqlite3.c.

100075 {

References EP_Commuted, ExprHasProperty, Expr::pLeft, Expr::pRight, and sqlite3BinaryCompareCollSeq().

Referenced by constInsert(), constructAutomaticIndex(), sqlite3_vtab_collation(), termIsEquivalence(), wherePathSatisfiesOrderBy(), and whereScanNext().

◆ sqlite3ExprCompareSkip()

SQLITE_PRIVATE int sqlite3ExprCompareSkip	(	Expr *	pA,
		Expr *	pB,
		int	iTab )

Definition at line 105044 of file sqlite3.c.

Referenced by exprMightBeIndexed2(), indexMightHelpWithOrderBy(), wherePathSatisfiesOrderBy(), and whereScanNext().

◆ sqlite3ExprCoveredByIndex()

SQLITE_PRIVATE int sqlite3ExprCoveredByIndex	(	Expr *	pExpr,
		int	iCur,
		Index *	pIdx )

Definition at line 105344 of file sqlite3.c.

 {
  Walker w;
  struct IdxCover xcov;
  memset(&w, 0, sizeof(w));
  xcov.iCur = iCur;

References Walker::eCode, exprIdxCover(), IdxCover::iCur, IdxCover::pIdx, Walker::pIdxCover, sqlite3WalkExpr(), Walker::u, and Walker::xExprCallback.

Referenced by whereLoopAddBtree().

◆ sqlite3ExprDelete()

SQLITE_PRIVATE void sqlite3ExprDelete	(	sqlite3 *	db,
		Expr *	p )

Definition at line 100849 of file sqlite3.c.

100851 {

Referenced by clearSelect(), codeEqualityTerm(), constructAutomaticIndex(), exprAnalyze(), exprCodeBetween(), fkActionTrigger(), fkScanChildren(), fkTriggerDelete(), isLikeOrGlob(), lookupName(), multiSelect(), multiSelectOrderBy(), removeUnindexableInClauseTerms(), resolveAlias(), resolveCompoundOrderBy(), selectWindowRewriteExprCb(), sqlite3AddDefaultValue(), sqlite3BeginTrigger(), sqlite3CodeSubselect(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3DeleteTriggerStep(), sqlite3EndTable(), sqlite3ExprAnd(), sqlite3ExprAttachSubtrees(), sqlite3ExprCodeCopy(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalseDup(), sqlite3ExprListAppend(), sqlite3GenerateConstraintChecks(), sqlite3PExpr(), sqlite3SrcListAppendFromTerm(), sqlite3TriggerDeleteStep(), sqlite3TriggerUpdateStep(), sqlite3Update(), sqlite3UpsertDelete(), sqlite3Vacuum(), sqlite3WhereClauseClear(), sqlite3WindowOffsetExpr(), sqlite3WindowUpdate(), substExpr(), whereClauseInsert(), yy_destructor(), and yy_reduce().

◆ sqlite3ExprDeleteNN()

static SQLITE_NOINLINE void sqlite3ExprDeleteNN	(	sqlite3 *	db,
		Expr *	p )

static

Definition at line 100810 of file sqlite3.c.

                                                                     {
  assert( p!=0 );
  /* Sanity check: Assert that the IntValue is non-negative if it exists */
  assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
 
  assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed );
  assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced)
          || p->y.pWin==0 || ExprHasProperty(p, EP_WinFunc) );
#ifdef SQLITE_DEBUG
  if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){
    assert( p->pLeft==0 );
    assert( p->pRight==0 );
    assert( p->x.pSelect==0 );
  }
#endif
  if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
    /* The Expr.x union is never used at the same time as Expr.pRight */
    assert( p->x.pList==0 || p->pRight==0 );
    if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft);
    if( p->pRight ){
      assert( !ExprHasProperty(p, EP_WinFunc) );
      sqlite3ExprDeleteNN(db, p->pRight);
    }else if( ExprHasProperty(p, EP_xIsSelect) ){
      assert( !ExprHasProperty(p, EP_WinFunc) );
      sqlite3SelectDelete(db, p->x.pSelect);
    }else{
      sqlite3ExprListDelete(db, p->x.pList);
#ifndef SQLITE_OMIT_WINDOWFUNC
      if( ExprHasProperty(p, EP_WinFunc) ){
        sqlite3WindowDelete(db, p->y.pWin);
      }
#endif
    }

◆ sqlite3ExprDup()

SQLITE_PRIVATE Expr * sqlite3ExprDup	(	sqlite3 *	db,
		Expr *	p,
		int	flags )

Definition at line 101161 of file sqlite3.c.

Referenced by agginfoPersistExprCb(), constructAutomaticIndex(), exprAnalyze(), exprAnalyzeOrTerm(), exprCodeBetween(), exprDup(), fkActionTrigger(), propagateConstantExprRewrite(), pushDownWhereTerms(), removeUnindexableInClauseTerms(), resolveAlias(), resolveCompoundOrderBy(), selectWindowRewriteExprCb(), sqlite3AddDefaultValue(), sqlite3BeginTrigger(), sqlite3CodeSubselect(), sqlite3ExprCodeCopy(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3ExprForVectorField(), sqlite3ExprIfFalseDup(), sqlite3GenerateConstraintChecks(), sqlite3MaterializeView(), sqlite3TriggerDeleteStep(), sqlite3TriggerUpdateStep(), sqlite3WhereTabFuncArgs(), sqlite3WindowDup(), sqlite3WindowRewrite(), sqlite3WindowUpdate(), substExpr(), updateFromSelect(), updateVirtualTable(), and whereCombineDisjuncts().

◆ sqlite3ExprForVectorField()

SQLITE_PRIVATE Expr * sqlite3ExprForVectorField	(	Parse *	pParse,
		Expr *	pVector,
		int	iField )

Definition at line 100187 of file sqlite3.c.

 {
  Expr *pRet;
  if( pVector->op==TK_SELECT ){
    assert( pVector->flags & EP_xIsSelect );
    /* The TK_SELECT_COLUMN Expr node:
    **
    ** pLeft:           pVector containing TK_SELECT.  Not deleted.
    ** pRight:          not used.  But recursively deleted.
    ** iColumn:         Index of a column in pVector
    ** iTable:          0 or the number of columns on the LHS of an assignment
    ** pLeft->iTable:   First in an array of register holding result, or 0
    **                  if the result is not yet computed.
    **
    ** sqlite3ExprDelete() specifically skips the recursive delete of
    ** pLeft on TK_SELECT_COLUMN nodes.  But pRight is followed, so pVector
    ** can be attached to pRight to cause this node to take ownership of
    ** pVector.  Typically there will be multiple TK_SELECT_COLUMN nodes
    ** with the same pLeft pointer to the pVector, but only one of them
    ** will own the pVector.
    */
    pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0);
    if( pRet ){
      pRet->iColumn = iField;
      pRet->pLeft = pVector;
    }
    assert( pRet==0 || pRet->iTable==0 );
  }else{

References ExprList::a, Parse::db, EP_xIsSelect, Expr::flags, Expr::iColumn, Expr::iTable, Expr::op, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, sqlite3ExprDup(), sqlite3PExpr(), sqlite3RenameTokenRemap(), TK_SELECT, TK_SELECT_COLUMN, TK_VECTOR, and Expr::x.

Referenced by exprAnalyze(), and sqlite3ExprListAppendVector().

◆ sqlite3ExprFunction()

SQLITE_PRIVATE Expr * sqlite3ExprFunction	(	Parse *	pParse,
		ExprList *	pList,
		Token *	pToken,
		int	eDistinct )

Definition at line 100667 of file sqlite3.c.

 {
  Expr *pNew;
  sqlite3 *db = pParse->db;
  assert( pToken );
  pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
    return 0;
  }
  if( pList && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
    sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken);
  }
  pNew->x.pList = pList;

Referenced by yy_reduce().

◆ sqlite3ExprFunctionUsable()

SQLITE_PRIVATE void sqlite3ExprFunctionUsable	(	Parse *	pParse,
		Expr *	pExpr,
		FuncDef *	pDef )

Definition at line 100703 of file sqlite3.c.

 {
  assert( !IN_RENAME_OBJECT );
  assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 );
  if( ExprHasProperty(pExpr, EP_FromDDL) ){
    if( (pDef->funcFlags & SQLITE_FUNC_DIRECT)!=0
     || (pParse->db->flags & SQLITE_TrustedSchema)==0
    ){
      /* Functions prohibited in triggers and views if:
      **     (1) tagged with SQLITE_DIRECTONLY
      **     (2) not tagged with SQLITE_INNOCUOUS (which means it
      **         is tagged with SQLITE_FUNC_UNSAFE) and
      **         SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning

References Parse::db, EP_FromDDL, ExprHasProperty, sqlite3::flags, FuncDef::funcFlags, IN_RENAME_OBJECT, sqlite3ErrorMsg(), SQLITE_FUNC_DIRECT, SQLITE_FUNC_UNSAFE, SQLITE_TrustedSchema, and FuncDef::zName.

Referenced by resolveExprStep(), and sqlite3ExprCodeTarget().

◆ sqlite3ExprIdToTrueFalse()

SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse ( Expr * pExpr )

Definition at line 101631 of file sqlite3.c.

                                                        {
  u32 v;
  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
  if( !ExprHasProperty(pExpr, EP_Quoted)
   && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
  ){

References EP_Quoted, ExprHasProperty, ExprSetProperty, Expr::op, sqlite3IsTrueOrFalse(), TK_ID, TK_STRING, TK_TRUEFALSE, Expr::u, and Expr::zToken.

Referenced by exprNodeIsConstant(), lookupName(), and yy_reduce().

◆ sqlite3ExprIfFalse()

SQLITE_PRIVATE void sqlite3ExprIfFalse	(	Parse *	pParse,
		Expr *	pExpr,
		int	dest,
		int	jumpIfNull )

Definition at line 104695 of file sqlite3.c.

                                                                                            {
  Vdbe *v = pParse->pVdbe;
  int op = 0;
  int regFree1 = 0;
  int regFree2 = 0;
  int r1, r2;
 
  assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
  if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
  if( pExpr==0 )    return;
  assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
 
  /* The value of pExpr->op and op are related as follows:
  **
  **       pExpr->op            op
  **       ---------          ----------
  **       TK_ISNULL          OP_NotNull
  **       TK_NOTNULL         OP_IsNull
  **       TK_NE              OP_Eq
  **       TK_EQ              OP_Ne
  **       TK_GT              OP_Le
  **       TK_LE              OP_Gt
  **       TK_GE              OP_Lt
  **       TK_LT              OP_Ge
  **
  ** For other values of pExpr->op, op is undefined and unused.
  ** The value of TK_ and OP_ constants are arranged such that we
  ** can compute the mapping above using the following expression.
  ** Assert()s verify that the computation is correct.
  */
  op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
 
  /* Verify correct alignment of TK_ and OP_ constants
  */
  assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
  assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
  assert( pExpr->op!=TK_NE || op==OP_Eq );
  assert( pExpr->op!=TK_EQ || op==OP_Ne );
  assert( pExpr->op!=TK_LT || op==OP_Ge );
  assert( pExpr->op!=TK_LE || op==OP_Gt );
  assert( pExpr->op!=TK_GT || op==OP_Le );
  assert( pExpr->op!=TK_GE || op==OP_Lt );
 
  switch( pExpr->op ){
    case TK_AND:
    case TK_OR: {
      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
      if( pAlt!=pExpr ){
        sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull);
      }else if( pExpr->op==TK_AND ){
        testcase( jumpIfNull==0 );
        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
      }else{
        int d2 = sqlite3VdbeMakeLabel(pParse);
        testcase( jumpIfNull==0 );
        sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
                          jumpIfNull^SQLITE_JUMPIFNULL);
        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
        sqlite3VdbeResolveLabel(v, d2);
      }
      break;
    }
    case TK_NOT: {
      testcase( jumpIfNull==0 );
      sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
      break;
    }
    case TK_TRUTH: {
      int isNot;   /* IS NOT TRUE or IS NOT FALSE */
      int isTrue;  /* IS TRUE or IS NOT TRUE */
      testcase( jumpIfNull==0 );
      isNot = pExpr->op2==TK_ISNOT;
      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
      testcase( isTrue && isNot );
      testcase( !isTrue && isNot );
      if( isTrue ^ isNot ){
        /* IS TRUE and IS NOT FALSE */
        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
                           isNot ? 0 : SQLITE_JUMPIFNULL);
 
      }else{
        /* IS FALSE and IS NOT TRUE */
        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
                          isNot ? 0 : SQLITE_JUMPIFNULL);
      }
      break;
    }
    case TK_IS:
    case TK_ISNOT:
      testcase( pExpr->op==TK_IS );
      testcase( pExpr->op==TK_ISNOT );
      op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
      jumpIfNull = SQLITE_NULLEQ;
      /* no break */ deliberate_fall_through
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE:
    case TK_NE:
    case TK_EQ: {
      if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
      testcase( jumpIfNull==0 );
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                  r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
      assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
      assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
      assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
      assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
      assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
      VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
      VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
      assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
      VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
      VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
      testcase( regFree1==0 );
      testcase( regFree2==0 );
      break;
    }
    case TK_ISNULL:
    case TK_NOTNULL: {
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      sqlite3VdbeAddOp2(v, op, r1, dest);
      testcase( op==TK_ISNULL );   VdbeCoverageIf(v, op==TK_ISNULL);
      testcase( op==TK_NOTNULL );  VdbeCoverageIf(v, op==TK_NOTNULL);
      testcase( regFree1==0 );
      break;
    }
    case TK_BETWEEN: {
      testcase( jumpIfNull==0 );
      exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
      break;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_IN: {
      if( jumpIfNull ){
        sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
      }else{
        int destIfNull = sqlite3VdbeMakeLabel(pParse);
        sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
        sqlite3VdbeResolveLabel(v, destIfNull);
      }
      break;
    }
#endif
    default: {
    default_expr:
      if( ExprAlwaysFalse(pExpr) ){
        sqlite3VdbeGoto(v, dest);
      }else if( ExprAlwaysTrue(pExpr) ){
        /* no-op */
      }else{
        r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
        sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
        VdbeCoverage(v);
        testcase( regFree1==0 );
        testcase( jumpIfNull==0 );
      }

References codeCompare(), deliberate_fall_through, EP_Commuted, EP_Immutable, ExprAlwaysFalse, ExprAlwaysTrue, exprCodeBetween(), ExprHasProperty, ExprHasVVAProperty, NEVER, Expr::op, Expr::op2, OP_Eq, OP_Ge, OP_Gt, OP_IfNot, OP_IsNull, OP_Le, OP_Lt, OP_Ne, OP_NotNull, Expr::pLeft, Expr::pRight, Parse::pVdbe, sqlite3ExprCodeIN(), sqlite3ExprCodeTemp(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprIsVector(), sqlite3ExprSimplifiedAndOr(), sqlite3ExprTruthValue(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeGoto(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_JUMPIFNULL, SQLITE_NULLEQ, testcase, TK_AND, TK_BETWEEN, TK_EQ, TK_GE, TK_GT, TK_IN, TK_IS, TK_ISNOT, TK_ISNULL, TK_LE, TK_LT, TK_NE, TK_NOT, TK_NOTNULL, TK_OR, TK_TRUTH, VdbeCoverage, and VdbeCoverageIf.

Referenced by constructAutomaticIndex(), exprCodeBetween(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfFalseDup(), sqlite3ExprIfTrue(), sqlite3Pragma(), sqlite3Select(), sqlite3Update(), sqlite3WhereBegin(), and updateAccumulator().

◆ sqlite3ExprIfFalseDup()

SQLITE_PRIVATE void sqlite3ExprIfFalseDup	(	Parse *	pParse,
		Expr *	pExpr,
		int	dest,
		int	jumpIfNull )

Definition at line 104867 of file sqlite3.c.

104873 {

104874 sqlite3 *db = pParse->db;

References Parse::db, sqlite3::mallocFailed, sqlite3ExprDelete(), sqlite3ExprDup(), and sqlite3ExprIfFalse().

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3GenerateIndexKey().

◆ sqlite3ExprIfTrue()

SQLITE_PRIVATE void sqlite3ExprIfTrue	(	Parse *	pParse,
		Expr *	pExpr,
		int	dest,
		int	jumpIfNull )

Definition at line 104553 of file sqlite3.c.

                                                              : TK_EQ)
** are the same as opcode values (ex: OP_Eq) that implement the corresponding
** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in
** the make process cause these values to align.  Assert()s in the code
** below verify that the numbers are aligned correctly.
*/
SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
  Vdbe *v = pParse->pVdbe;
  int op = 0;
  int regFree1 = 0;
  int regFree2 = 0;
  int r1, r2;
 
  assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
  if( NEVER(v==0) )     return;  /* Existence of VDBE checked by caller */
  if( NEVER(pExpr==0) ) return;  /* No way this can happen */
  assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
  op = pExpr->op;
  switch( op ){
    case TK_AND:
    case TK_OR: {
      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
      if( pAlt!=pExpr ){
        sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull);
      }else if( op==TK_AND ){
        int d2 = sqlite3VdbeMakeLabel(pParse);
        testcase( jumpIfNull==0 );
        sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
                           jumpIfNull^SQLITE_JUMPIFNULL);
        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
        sqlite3VdbeResolveLabel(v, d2);
      }else{
        testcase( jumpIfNull==0 );
        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
      }
      break;
    }
    case TK_NOT: {
      testcase( jumpIfNull==0 );
      sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
      break;
    }
    case TK_TRUTH: {
      int isNot;      /* IS NOT TRUE or IS NOT FALSE */
      int isTrue;     /* IS TRUE or IS NOT TRUE */
      testcase( jumpIfNull==0 );
      isNot = pExpr->op2==TK_ISNOT;
      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
      testcase( isTrue && isNot );
      testcase( !isTrue && isNot );
      if( isTrue ^ isNot ){
        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
                          isNot ? SQLITE_JUMPIFNULL : 0);
      }else{
        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
                           isNot ? SQLITE_JUMPIFNULL : 0);
      }
      break;
    }
    case TK_IS:
    case TK_ISNOT:
      testcase( op==TK_IS );
      testcase( op==TK_ISNOT );
      op = (op==TK_IS) ? TK_EQ : TK_NE;
      jumpIfNull = SQLITE_NULLEQ;
      /* no break */ deliberate_fall_through
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE:
    case TK_NE:
    case TK_EQ: {
      if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
      testcase( jumpIfNull==0 );
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                  r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
      assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
      assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
      assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
      assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
      assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
      VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
      VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
      assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
      VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
      VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
      testcase( regFree1==0 );
      testcase( regFree2==0 );
      break;
    }
    case TK_ISNULL:
    case TK_NOTNULL: {
      assert( TK_ISNULL==OP_IsNull );   testcase( op==TK_ISNULL );
      assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
      sqlite3VdbeAddOp2(v, op, r1, dest);
      VdbeCoverageIf(v, op==TK_ISNULL);
      VdbeCoverageIf(v, op==TK_NOTNULL);
      testcase( regFree1==0 );
      break;
    }
    case TK_BETWEEN: {
      testcase( jumpIfNull==0 );
      exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
      break;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_IN: {
      int destIfFalse = sqlite3VdbeMakeLabel(pParse);
      int destIfNull = jumpIfNull ? dest : destIfFalse;
      sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
      sqlite3VdbeGoto(v, dest);
      sqlite3VdbeResolveLabel(v, destIfFalse);
      break;
    }
#endif
    default: {
    default_expr:
      if( ExprAlwaysTrue(pExpr) ){
        sqlite3VdbeGoto(v, dest);
      }else if( ExprAlwaysFalse(pExpr) ){
        /* No-op */
      }else{
        r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
        sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
        VdbeCoverage(v);
        testcase( regFree1==0 );
        testcase( jumpIfNull==0 );
      }

References codeCompare(), deliberate_fall_through, EP_Commuted, EP_Immutable, ExprAlwaysFalse, ExprAlwaysTrue, exprCodeBetween(), ExprHasProperty, ExprHasVVAProperty, NEVER, Expr::op, Expr::op2, OP_Eq, OP_Ge, OP_Gt, OP_If, OP_IsNull, OP_Le, OP_Lt, OP_Ne, OP_NotNull, Expr::pLeft, Expr::pRight, Parse::pVdbe, sqlite3ExprCodeIN(), sqlite3ExprCodeTemp(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprIsVector(), sqlite3ExprSimplifiedAndOr(), sqlite3ExprTruthValue(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeGoto(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_JUMPIFNULL, SQLITE_NULLEQ, testcase, TK_AND, TK_BETWEEN, TK_EQ, TK_GE, TK_GT, TK_IN, TK_IS, TK_ISNOT, TK_ISNULL, TK_LE, TK_LT, TK_NE, TK_NOT, TK_NOTNULL, TK_OR, TK_TRUTH, VdbeCoverage, and VdbeCoverageIf.

Referenced by exprCodeBetween(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3GenerateConstraintChecks(), and sqlite3Pragma().

◆ sqlite3ExprImpliesExpr()

SQLITE_PRIVATE int sqlite3ExprImpliesExpr	(	Parse *	pParse,
		Expr *	pE1,
		Expr *	pE2,
		int	iTab )

Definition at line 105153 of file sqlite3.c.

                                                                                        {
  if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){
    return 1;
  }
  if( pE2->op==TK_OR
   && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab)
             || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) )
  ){
    return 1;
  }
  if( pE2->op==TK_NOTNULL

References exprImpliesNotNull(), Expr::op, Expr::pLeft, Expr::pRight, sqlite3ExprCompare(), sqlite3ExprImpliesExpr(), TK_NOTNULL, and TK_OR.

Referenced by sqlite3ExprImpliesExpr().

◆ sqlite3ExprImpliesNonNullRow()

SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow	(	Expr *	p,
		int	iTab )

Definition at line 105285 of file sqlite3.c.

                                                                  {
  Walker w;
  p = sqlite3ExprSkipCollateAndLikely(p);
  if( p==0 ) return 0;
  if( p->op==TK_NOTNULL ){
    p = p->pLeft;
  }else{
    while( p->op==TK_AND ){
      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1;
      p = p->pRight;
    }
  }
  w.xExprCallback = impliesNotNullRow;
  w.xSelectCallback = 0;

References Walker::eCode, Walker::iCur, impliesNotNullRow(), Expr::op, Expr::pLeft, Expr::pRight, sqlite3ExprImpliesNonNullRow(), sqlite3ExprSkipCollateAndLikely(), sqlite3WalkExpr(), TK_AND, TK_NOTNULL, Walker::u, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3ExprImpliesNonNullRow(), and sqlite3Select().

◆ sqlite3ExprIsConstant()

SQLITE_PRIVATE int sqlite3ExprIsConstant ( Expr * p )

Definition at line 101803 of file sqlite3.c.

101805 : "abc")

References exprIsConst().

Referenced by constInsert(), findConstInWhere(), sqlite3CodeRhsOfIN(), sqlite3ExprCodeTarget(), sqlite3InRhsIsConstant(), sqlite3WindowOffsetExpr(), whereIndexExprTrans(), wherePathSatisfiesOrderBy(), and yy_reduce().

◆ sqlite3ExprIsConstantNotJoin()

SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin ( Expr * p )

Definition at line 101820 of file sqlite3.c.

References exprIsConst().

Referenced by sqlite3ExprCodeExprList(), sqlite3ExprCodeFactorable(), sqlite3ExprCodeTarget(), and sqlite3ExprCodeTemp().

◆ sqlite3ExprIsConstantOrFunction()

SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction	(	Expr *	p,
		u8	isInit )

Definition at line 101914 of file sqlite3.c.

101916 : "abc")

101917** is considered a variable but a single-quoted string (ex: 'abc') is

References exprIsConst().

Referenced by sqlite3AddDefaultValue().

◆ sqlite3ExprIsConstantOrGroupBy()

SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy	(	Parse *	pParse,
		Expr *	p,
		ExprList *	pGroupBy )

Definition at line 101882 of file sqlite3.c.

                                                                                             {
  Walker w;
  w.eCode = 1;
  w.xExprCallback = exprNodeIsConstantOrGroupBy;

References Walker::eCode, exprNodeIsConstantOrGroupBy(), Walker::pGroupBy, Walker::pParse, sqlite3WalkExpr(), Walker::u, Walker::xExprCallback, and Walker::xSelectCallback.

Referenced by havingToWhereExprCb().

◆ sqlite3ExprIsInteger()

SQLITE_PRIVATE int sqlite3ExprIsInteger	(	Expr *	p,
		int *	pValue )

Definition at line 101943 of file sqlite3.c.

                                                             {
  int rc = 0;
  if( NEVER(p==0) ) return 0;  /* Used to only happen following on OOM */
 
  /* If an expression is an integer literal that fits in a signed 32-bit
  ** integer, then the EP_IntValue flag will have already been set */
  assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
           || sqlite3GetInt32(p->u.zToken, &rc)==0 );
 
  if( p->flags & EP_IntValue ){
    *pValue = p->u.iValue;
    return 1;
  }
  switch( p->op ){
    case TK_UPLUS: {
      rc = sqlite3ExprIsInteger(p->pLeft, pValue);
      break;
    }
    case TK_UMINUS: {
      int v;
      if( sqlite3ExprIsInteger(p->pLeft, &v) ){
        assert( v!=(-2147483647-1) );
        *pValue = -v;
        rc = 1;
      }

References EP_IntValue, Expr::flags, Expr::iValue, NEVER, Expr::op, Expr::pLeft, sqlite3ExprIsInteger(), sqlite3GetInt32(), TK_INTEGER, TK_UMINUS, TK_UPLUS, Expr::u, and Expr::zToken.

Referenced by computeLimitRegisters(), multiSelect(), resolveCompoundOrderBy(), resolveOrderByTermToExprList(), resolveOrderGroupBy(), sqlite3ExprIsInteger(), and whereLoopOutputAdjust().

◆ sqlite3ExprIsTableConstant()

SQLITE_PRIVATE int sqlite3ExprIsTableConstant	(	Expr *	p,
		int	iCur )

Definition at line 101830 of file sqlite3.c.

References exprIsConst().

Referenced by constructAutomaticIndex(), and pushDownWhereTerms().

◆ sqlite3ExprIsVector()

SQLITE_PRIVATE int sqlite3ExprIsVector ( Expr * pExpr )

Definition at line 100116 of file sqlite3.c.

References sqlite3ExprVectorSize().

Referenced by allocateIndexInfo(), codeExprOrVector(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3VectorFieldSubexpr(), and substExpr().

◆ sqlite3ExprListAppend()

SQLITE_PRIVATE ExprList * sqlite3ExprListAppend	(	Parse *	pParse,
		ExprList *	pList,
		Expr *	pExpr )

Definition at line 101344 of file sqlite3.c.

 {
  struct ExprList_item *pItem;
  sqlite3 *db = pParse->db;
  assert( db!=0 );
  if( pList==0 ){
    pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) );
    if( pList==0 ){
      goto no_mem;
    }
    pList->nExpr = 0;
  }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
    ExprList *pNew;
    pNew = sqlite3DbRealloc(db, pList,
         sizeof(*pList)+(2*(sqlite3_int64)pList->nExpr-1)*sizeof(pList->a[0]));
    if( pNew==0 ){
      goto no_mem;
    }
    pList = pNew;
  }
  pItem = &pList->a[pList->nExpr++];
  assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) );
  assert( offsetof(struct ExprList_item,pExpr)==0 );
  memset(&pItem->zEName,0,sizeof(*pItem)-offsetof(struct ExprList_item,zEName));
  pItem->pExpr = pExpr;
  return pList;
 

References ExprList::a, Parse::db, ExprList::nExpr, offsetof, sqlite3DbMallocRawNN(), sqlite3DbRealloc(), sqlite3ExprDelete(), and sqlite3ExprListDelete().

Referenced by agginfoPersistExprCb(), convertCompoundSelectToSubquery(), convertToWithoutRowidTable(), exprAnalyzeOrTerm(), fkActionTrigger(), multiSelectOrderBy(), parserAddExprIdListTerm(), removeUnindexableInClauseTerms(), selectExpander(), selectWindowRewriteExprCb(), sqlite3CreateIndex(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprListAppendVector(), sqlite3SelectNew(), sqlite3WindowRewrite(), updateFromSelect(), updateVirtualTable(), and yy_reduce().

◆ sqlite3ExprListAppendVector()

SQLITE_PRIVATE ExprList * sqlite3ExprListAppendVector	(	Parse *	pParse,
		ExprList *	pList,
		IdList *	pColumns,
		Expr *	pExpr )

Definition at line 101392 of file sqlite3.c.

     :    (a,b,c) = (SELECT x,y,z FROM ....)
**
** For each term of the vector assignment, append new entries to the
** expression list pList.  In the case of a subquery on the RHS, append
** TK_SELECT_COLUMN expressions.
*/
SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(
  Parse *pParse,         /* Parsing context */
  ExprList *pList,       /* List to which to append. Might be NULL */
  IdList *pColumns,      /* List of names of LHS of the assignment */
  Expr *pExpr            /* Vector expression to be appended. Might be NULL */
){
  sqlite3 *db = pParse->db;
  int n;
  int i;
  int iFirst = pList ? pList->nExpr : 0;
  /* pColumns can only be NULL due to an OOM but an OOM will cause an
  ** exit prior to this routine being invoked */
  if( NEVER(pColumns==0) ) goto vector_append_error;
  if( pExpr==0 ) goto vector_append_error;
 
  /* If the RHS is a vector, then we can immediately check to see that
  ** the size of the RHS and LHS match.  But if the RHS is a SELECT,
  ** wildcards ("*") in the result set of the SELECT must be expanded before
  ** we can do the size check, so defer the size check until code generation.
  */
  if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
    sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
                    pColumns->nId, n);
    goto vector_append_error;
  }
 
  for(i=0; i<pColumns->nId; i++){
    Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i);
    assert( pSubExpr!=0 || db->mallocFailed );
    assert( pSubExpr==0 || pSubExpr->iTable==0 );
    if( pSubExpr==0 ) continue;
    pSubExpr->iTable = pColumns->nId;
    pList = sqlite3ExprListAppend(pParse, pList, pSubExpr);
    if( pList ){
      assert( pList->nExpr==iFirst+i+1 );
      pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
      pColumns->a[i].zName = 0;
    }
  }
 
  if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
    Expr *pFirst = pList->a[iFirst].pExpr;
    assert( pFirst!=0 );
    assert( pFirst->op==TK_SELECT_COLUMN );
 
    /* Store the SELECT statement in pRight so it will be deleted when
    ** sqlite3ExprListDelete() is called */
    pFirst->pRight = pExpr;
    pExpr = 0;
 
    /* Remember the size of the LHS in iTable so that we can check that
    ** the RHS and LHS sizes match during code generation. */
    pFirst->iTable = pColumns->nId;
  }

References ExprList::a, IdList::a, ALWAYS, Parse::db, Expr::iTable, sqlite3::mallocFailed, NEVER, ExprList::nExpr, IdList::nId, Expr::op, ExprList::ExprList_item::pExpr, Expr::pRight, sqlite3ErrorMsg(), sqlite3ExprForVectorField(), sqlite3ExprListAppend(), sqlite3ExprUnmapAndDelete(), sqlite3ExprVectorSize(), sqlite3IdListDelete(), TK_SELECT, TK_SELECT_COLUMN, ExprList::ExprList_item::zEName, and IdList::IdList_item::zName.

Referenced by yy_reduce().

◆ sqlite3ExprListCheckLength()

SQLITE_PRIVATE void sqlite3ExprListCheckLength	(	Parse *	pParse,
		ExprList *	pEList,
		const char *	zObject )

Definition at line 101551 of file sqlite3.c.

101561 {

101562 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];

Referenced by sqlite3CreateIndex(), and yy_reduce().

◆ sqlite3ExprListCompare()

SQLITE_PRIVATE int sqlite3ExprListCompare	(	ExprList *	pA,
		ExprList *	pB,
		int	iTab )

Definition at line 105025 of file sqlite3.c.

                                                                               {
  int i;
  if( pA==0 && pB==0 ) return 0;
  if( pA==0 || pB==0 ) return 1;
  if( pA->nExpr!=pB->nExpr ) return 1;
  for(i=0; i<pA->nExpr; i++){
    int res;
    Expr *pExprA = pA->a[i].pExpr;

References ExprList::a, ExprList::nExpr, ExprList::ExprList_item::pExpr, ExprList::ExprList_item::sortFlags, and sqlite3ExprCompare().

Referenced by sqlite3ExprCompare(), sqlite3Select(), sqlite3WindowCompare(), sqlite3WindowRewrite(), and xferOptimization().

◆ sqlite3ExprListDelete()

SQLITE_PRIVATE void sqlite3ExprListDelete	(	sqlite3 *	db,
		ExprList *	pList )

◆ sqlite3ExprListDup()

SQLITE_PRIVATE ExprList * sqlite3ExprListDup	(	sqlite3 *	db,
		ExprList *	p,
		int	flags )

Definition at line 101165 of file sqlite3.c.

                                                                    {
  assert( flags==0 || flags==EXPRDUP_REDUCE );
  return p ? exprDup(db, p, flags, 0) : 0;
}
SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
  ExprList *pNew;
  struct ExprList_item *pItem, *pOldItem;
  int i;
  Expr *pPriorSelectCol = 0;
  assert( db!=0 );
  if( p==0 ) return 0;
  pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p));
  if( pNew==0 ) return 0;
  pNew->nExpr = p->nExpr;
  pItem = pNew->a;
  pOldItem = p->a;
  for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
    Expr *pOldExpr = pOldItem->pExpr;
    Expr *pNewExpr;
    pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
    if( pOldExpr
     && pOldExpr->op==TK_SELECT_COLUMN
     && (pNewExpr = pItem->pExpr)!=0
    ){
      assert( pNewExpr->iColumn==0 || i>0 );
      if( pNewExpr->iColumn==0 ){
        assert( pOldExpr->pLeft==pOldExpr->pRight );
        pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
      }else{
        assert( i>0 );
        assert( pItem[-1].pExpr!=0 );
        assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
        assert( pPriorSelectCol==pItem[-1].pExpr->pLeft );
        pNewExpr->pLeft = pPriorSelectCol;
      }
    }
    pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName);
    pItem->sortFlags = pOldItem->sortFlags;
    pItem->eEName = pOldItem->eEName;
    pItem->done = 0;

References exprDup(), and EXPRDUP_REDUCE.

Referenced by exprDup(), fkActionTrigger(), minMaxQuery(), multiSelectOrderBy(), sqlite3Pragma(), sqlite3Select(), sqlite3SrcListDup(), sqlite3TriggerUpdateStep(), sqlite3WindowChain(), sqlite3WindowDup(), sqlite3WindowUpdate(), updateFromSelect(), and withDup().

◆ sqlite3ExprListFlags()

SQLITE_PRIVATE u32 sqlite3ExprListFlags ( const ExprList * pList )

Definition at line 101586 of file sqlite3.c.

                                                              {
  int i;
  u32 m = 0;
  assert( pList!=0 );
  for(i=0; i<pList->nExpr; i++){

Referenced by exprSetHeight().

◆ sqlite3ExprListSetName()

SQLITE_PRIVATE void sqlite3ExprListSetName	(	Parse *	pParse,
		ExprList *	pList,
		Token *	pName,
		int	dequote )

Definition at line 101494 of file sqlite3.c.

 {
  assert( pList!=0 || pParse->db->mallocFailed!=0 );
  assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 );
  if( pList ){
    struct ExprList_item *pItem;
    assert( pList->nExpr>0 );
    pItem = &pList->a[pList->nExpr-1];
    assert( pItem->zEName==0 );
    assert( pItem->eEName==ENAME_NAME );
    pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
    if( dequote ){
      /* If dequote==0, then pName->z does not point to part of a DDL
      ** statement handled by the parser. And so no token need be added
      ** to the token-map.  */
      sqlite3Dequote(pItem->zEName);

References ExprList::a, Parse::db, ENAME_NAME, Parse::eParseMode, IN_RENAME_OBJECT, sqlite3::mallocFailed, Token::n, ExprList::nExpr, PARSE_MODE_UNMAP, sqlite3DbStrNDup(), sqlite3Dequote(), sqlite3RenameTokenMap(), and Token::z.

Referenced by fkActionTrigger(), parserAddExprIdListTerm(), selectExpander(), and yy_reduce().

◆ sqlite3ExprListSetSortOrder()

SQLITE_PRIVATE void sqlite3ExprListSetSortOrder	(	ExprList *	p,
		int	iSortOrder,
		int	eNulls )

Definition at line 101456 of file sqlite3.c.

                                                                                        {
  struct ExprList_item *pItem;
  if( p==0 ) return;
  assert( p->nExpr>0 );
 
  assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC==0 && SQLITE_SO_DESC>0 );
  assert( iSortOrder==SQLITE_SO_UNDEFINED
       || iSortOrder==SQLITE_SO_ASC
       || iSortOrder==SQLITE_SO_DESC
  );
  assert( eNulls==SQLITE_SO_UNDEFINED
       || eNulls==SQLITE_SO_ASC
       || eNulls==SQLITE_SO_DESC
  );
 
  pItem = &p->a[p->nExpr-1];
  assert( pItem->bNulls==0 );
  if( iSortOrder==SQLITE_SO_UNDEFINED ){
    iSortOrder = SQLITE_SO_ASC;
  }
  pItem->sortFlags = (u8)iSortOrder;
 
  if( eNulls!=SQLITE_SO_UNDEFINED ){

Referenced by sqlite3CreateIndex(), and yy_reduce().

◆ sqlite3ExprListSetSpan()

SQLITE_PRIVATE void sqlite3ExprListSetSpan	(	Parse *	pParse,
		ExprList *	pList,
		const char *	zStart,
		const char *	zEnd )

Definition at line 101529 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  assert( pList!=0 || db->mallocFailed!=0 );
  if( pList ){
    struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
    assert( pList->nExpr>0 );

References ExprList::a, Parse::db, ENAME_SPAN, sqlite3::mallocFailed, ExprList::nExpr, and sqlite3DbSpanDup().

Referenced by yy_reduce().

◆ sqlite3ExprNeedsNoAffinityChange()

SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange	(	const Expr *	p,
		char	aff )

Definition at line 102023 of file sqlite3.c.

                                                                            {
  u8 op;
  int unaryMinus = 0;
  if( aff==SQLITE_AFF_BLOB ) return 1;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    if( p->op==TK_UMINUS ) unaryMinus = 1;
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_FLOAT: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_STRING: {
      return !unaryMinus && aff==SQLITE_AFF_TEXT;
    }
    case TK_BLOB: {
      return !unaryMinus;
    }
    case TK_COLUMN: {
      assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
      return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0;

References Expr::iColumn, Expr::iTable, Expr::op, Expr::op2, Expr::pLeft, SQLITE_AFF_BLOB, SQLITE_AFF_NUMERIC, SQLITE_AFF_TEXT, TK_BLOB, TK_COLUMN, TK_FLOAT, TK_INTEGER, TK_REGISTER, TK_STRING, TK_UMINUS, and TK_UPLUS.

Referenced by codeAllEqualityTerms(), and updateRangeAffinityStr().

◆ sqlite3ExprNNCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3ExprNNCollSeq	(	Parse *	pParse,
		const Expr *	pExpr )

Definition at line 99938 of file sqlite3.c.

           : sqlite3ExprCollSeq()
**
** The sqlite3ExprCollSeq() routine works the same except that it
** returns NULL if there is no defined collation.
*/

References Parse::db, sqlite3::pDfltColl, and sqlite3ExprCollSeq().

Referenced by findIndexCol(), sqlite3KeyInfoFromExprList(), wherePathSatisfiesOrderBy(), and windowAggStep().

◆ sqlite3ExprReferencesUpdatedColumn()

SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn	(	Expr *	pExpr,
		int *	aiChng,
		int	chngRowid )

Definition at line 121926 of file sqlite3.c.

             : pExpr might also be an expression for an index-on-expressions.
** The operation of this routine is the same - return true if an only if
** the expression uses one or more of columns identified by the second and
** third arguments.
*/
SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
  Expr *pExpr,    /* The expression to be checked */
  int *aiChng,    /* aiChng[x]>=0 if column x changed by the UPDATE */
  int chngRowid   /* True if UPDATE changes the rowid */
){
  Walker w;
  memset(&w, 0, sizeof(w));
  w.eCode = 0;
  w.xExprCallback = checkConstraintExprNode;
  w.u.aiCol = aiChng;
  sqlite3WalkExpr(&w, pExpr);
  if( !chngRowid ){
    testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
    w.eCode &= ~CKCNSTRNT_ROWID;
  }

References Walker::aiCol, checkConstraintExprNode(), CKCNSTRNT_COLUMN, CKCNSTRNT_ROWID, Walker::eCode, sqlite3WalkExpr(), testcase, Walker::u, and Walker::xExprCallback.

Referenced by indexColumnIsBeingUpdated(), indexWhereClauseMightChange(), sqlite3GenerateConstraintChecks(), and sqlite3Update().

◆ sqlite3ExprSetHeightAndFlags()

SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags	(	Parse *	pParse,
		Expr *	p )

Definition at line 100458 of file sqlite3.c.

References exprSetHeight(), Parse::nErr, Expr::nHeight, and sqlite3ExprCheckHeight().

Referenced by yy_reduce().

◆ sqlite3ExprSimplifiedAndOr()

SQLITE_PRIVATE Expr * sqlite3ExprSimplifiedAndOr ( Expr * pExpr )

Definition at line 101669 of file sqlite3.c.

                                                            {
  assert( pExpr!=0 );
  if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
    Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
    Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
    if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){
      pExpr = pExpr->op==TK_AND ? pRight : pLeft;

References ExprAlwaysFalse, ExprAlwaysTrue, Expr::op, Expr::pLeft, Expr::pRight, sqlite3ExprSimplifiedAndOr(), TK_AND, and TK_OR.

Referenced by sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3ExprSimplifiedAndOr().

◆ sqlite3ExprSkipCollate()

SQLITE_PRIVATE Expr * sqlite3ExprSkipCollate ( Expr * pExpr )

Definition at line 99824 of file sqlite3.c.

99830 {

Referenced by exprAnalyze(), isLikeOrGlob(), sqlite3AddPrimaryKey(), and sqlite3CreateIndex().

◆ sqlite3ExprSkipCollateAndLikely()

SQLITE_PRIVATE Expr * sqlite3ExprSkipCollateAndLikely ( Expr * pExpr )

Definition at line 99837 of file sqlite3.c.

                                                                 {
  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
    if( ExprHasProperty(pExpr, EP_Unlikely) ){
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( pExpr->x.pList->nExpr>0 );
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{

References ExprList::a, EP_Skip, EP_Unlikely, EP_xIsSelect, ExprHasProperty, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, TK_COLLATE, TK_FUNCTION, TK_IF_NULL_ROW, and Expr::x.

Referenced by exprToRegister(), findIndexCol(), indexMightHelpWithOrderBy(), isDistinctRedundant(), resolveCompoundOrderBy(), resolveExprStep(), resolveOrderGroupBy(), sqlite3ColumnsFromExprList(), sqlite3ExprCodeTemp(), sqlite3ExprImpliesNonNullRow(), sqlite3WhereSplit(), whereClauseInsert(), wherePathSatisfiesOrderBy(), and whereScanNext().

◆ sqlite3ExprTruthValue()

SQLITE_PRIVATE int sqlite3ExprTruthValue ( const Expr * pExpr )

Definition at line 101648 of file sqlite3.c.

101654 {

Referenced by sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and yy_reduce().

◆ sqlite3ExprUnmapAndDelete()

SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete	(	Parse *	pParse,
		Expr *	p )

Definition at line 100856 of file sqlite3.c.

100862 {

100863 if( p ){

Referenced by sqlite3ExprListAppendVector(), and yy_reduce().

◆ sqlite3ExprVectorSize()

SQLITE_PRIVATE int sqlite3ExprVectorSize ( Expr * pExpr )

Definition at line 100126 of file sqlite3.c.

                                                     {
  u8 op = pExpr->op;
  if( op==TK_REGISTER ) op = pExpr->op2;
  if( op==TK_VECTOR ){
    return pExpr->x.pList->nExpr;

References ExprList::nExpr, Expr::op, Expr::op2, Select::pEList, Expr::pList, Expr::pSelect, TK_REGISTER, TK_SELECT, TK_VECTOR, and Expr::x.

Referenced by codeVectorCompare(), exprAnalyze(), exprCodeVector(), exprINAffinity(), lookupName(), resolveExprStep(), sqlite3CodeRhsOfIN(), sqlite3ExprCheckIN(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIsVector(), sqlite3ExprListAppendVector(), sqlite3FindInIndex(), sqlite3VectorFieldSubexpr(), whereRangeScanEst(), and whereRangeVectorLen().

◆ sqlite3ExprWalkNoop()

SQLITE_PRIVATE int sqlite3ExprWalkNoop	(	Walker *	NotUsed,
		Expr *	NotUsed2 )

Definition at line 97734 of file sqlite3.c.

References UNUSED_PARAMETER2, and WRC_Continue.

Referenced by sqlite3SelectAddTypeInfo(), and sqlite3SelectExpand().

◆ sqlite3FaultSim()

SQLITE_PRIVATE int sqlite3FaultSim ( int iTest )

Definition at line 31234 of file sqlite3.c.

References sqlite3GlobalConfig, and SQLITE_OK.

Referenced by btreeRestoreCursorPosition(), sqlite3PagerCommitPhaseOne(), sqlite3TestExtInit(), vdbeIncrMergerNew(), vdbeMergeEngineNew(), vdbePmaReaderSeek(), vdbeSorterOpenTempFile(), walIndexPageRealloc(), and xferOptimization().

◆ sqlite3FindCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3FindCollSeq	(	sqlite3 *	db,
		u8	enc,
		const char *	zName,
		int	create )

Definition at line 115695 of file sqlite3.c.

           : sqlite3LocateCollSeq(), sqlite3GetCollSeq()
*/
SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(
  sqlite3 *db,          /* Database connection to search */
  u8 enc,               /* Desired text encoding */
  const char *zName,    /* Name of the collating sequence.  Might be NULL */
  int create            /* True to create CollSeq if doesn't already exist */
){
  CollSeq *pColl;
  assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
  assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
  if( zName ){
    pColl = findCollSeqEntry(db, zName, create);

References findCollSeqEntry(), sqlite3::pDfltColl, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, and zName.

Referenced by sqlite3ExprCollSeq(), sqlite3GetCollSeq(), sqlite3LocateCollSeq(), sqlite3Reindex(), and synthCollSeq().

◆ sqlite3FindDb()

SQLITE_PRIVATE int sqlite3FindDb	(	sqlite3 *	db,
		Token *	pName )

Definition at line 111192 of file sqlite3.c.

111198 {

111199 int i; /* Database number */

References sqlite3DbFree(), sqlite3FindDbName(), sqlite3NameFromToken(), and zName.

Referenced by sqlite3Analyze(), sqlite3TwoPartName(), and sqlite3Vacuum().

◆ sqlite3FindDbName()

SQLITE_PRIVATE int sqlite3FindDbName	(	sqlite3 *	db,
		const char *	zName )

Definition at line 111172 of file sqlite3.c.

                                                                    {
  int i = -1;         /* Database number */
  if( zName ){
    Db *pDb;
    for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
      if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
      /* "main" is always an acceptable alias for the primary database

References sqlite3::aDb, sqlite3::nDb, sqlite3_stricmp(), Db::zDbSName, and zName.

Referenced by findBtree(), renameParseSql(), renameTableTest(), sqlite3FindDb(), and sqlite3FixSrcList().

◆ sqlite3FindFunction()

SQLITE_PRIVATE FuncDef * sqlite3FindFunction	(	sqlite3 *	db,
		const char *	zName,
		int	nArg,
		u8	enc,
		u8	createFlag )

Definition at line 115931 of file sqlite3.c.

 {
  FuncDef *p;         /* Iterator variable */
  FuncDef *pBest = 0; /* Best match found so far */
  int bestScore = 0;  /* Score of best match */
  int h;              /* Hash value */
  int nName;          /* Length of the name */
 
  assert( nArg>=(-2) );
  assert( nArg>=(-1) || createFlag==0 );
  nName = sqlite3Strlen30(zName);
 
  /* First search for a match amongst the application-defined functions.
  */
  p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
  while( p ){
    int score = matchQuality(p, nArg, enc);
    if( score>bestScore ){
      pBest = p;
      bestScore = score;
    }
    p = p->pNext;
  }
 
  /* If no match is found, search the built-in functions.
  **
  ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in
  ** functions even if a prior app-defined function was found.  And give
  ** priority to built-in functions.
  **
  ** Except, if createFlag is true, that means that we are trying to
  ** install a new function.  Whatever FuncDef structure is returned it will
  ** have fields overwritten with new information appropriate for the
  ** new function.  But the FuncDefs for built-in functions are read-only.
  ** So we must not search for built-ins when creating a new function.
  */
  if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){
    bestScore = 0;
    h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
    p = sqlite3FunctionSearch(h, zName);
    while( p ){
      int score = matchQuality(p, nArg, enc);
      if( score>bestScore ){
        pBest = p;
        bestScore = score;
      }
      p = p->pNext;
    }
  }
 
  /* If the createFlag parameter is true and the search did not reveal an
  ** exact match for the name, number of arguments and encoding, then add a
  ** new entry to the hash table and return it.
  */
  if( createFlag && bestScore<FUNC_PERFECT_MATCH &&
      (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
    FuncDef *pOther;
    u8 *z;
    pBest->zName = (const char*)&pBest[1];
    pBest->nArg = (u16)nArg;
    pBest->funcFlags = enc;
    memcpy((char*)&pBest[1], zName, nName+1);
    for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
    pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
    if( pOther==pBest ){
      sqlite3DbFree(db, pBest);
      sqlite3OomFault(db);
      return 0;
    }else{
      pBest->pNext = pOther;
    }
  }

References sqlite3::aFunc, DBFLAG_PreferBuiltin, FUNC_PERFECT_MATCH, FuncDef::funcFlags, matchQuality(), sqlite3::mDbFlags, FuncDef::nArg, nName, FuncDef::pNext, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3FunctionSearch(), sqlite3HashFind(), sqlite3HashInsert(), sqlite3OomFault(), sqlite3Strlen30(), sqlite3UpperToLower, SQLITE_FUNC_HASH, FuncDef::xSFunc, FuncDef::zName, and zName.

Referenced by analyzeAggregate(), resolveExprStep(), sqlite3_overload_function(), sqlite3CreateFunc(), sqlite3ExprCodeTarget(), sqlite3IsLikeFunction(), and sqlite3RegisterLikeFunctions().

◆ sqlite3FindIndex()

SQLITE_PRIVATE Index * sqlite3FindIndex	(	sqlite3 *	db,
		const char *	zName,
		const char *	zDb )

Definition at line 110865 of file sqlite3.c.

                                                                                       {
  Index *p = 0;
  int i;
  /* All mutexes are required for schema access.  Make sure we hold them. */
  assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
  for(i=OMIT_TEMPDB; i<db->nDb; i++){
    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
    Schema *pSchema = db->aDb[j].pSchema;
    assert( pSchema );
    if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;

References sqlite3::aDb, Schema::idxHash, sqlite3::nDb, OMIT_TEMPDB, Db::pSchema, sqlite3DbIsNamed(), sqlite3HashFind(), and zName.

Referenced by analysisLoader(), sqlite3Analyze(), sqlite3CreateIndex(), sqlite3InitCallback(), sqlite3Pragma(), sqlite3Reindex(), and sqlite3StartTable().

◆ sqlite3FindInIndex()

SQLITE_PRIVATE int sqlite3FindInIndex	(	Parse *	pParse,
		Expr *	pX,
		u32	inFlags,
		int *	prRhsHasNull,
		int *	aiMap,
		int *	piTab )

Definition at line 102229 of file sqlite3.c.

                                  {2, 0, 1}.
*/
#ifndef SQLITE_OMIT_SUBQUERY
SQLITE_PRIVATE int sqlite3FindInIndex(
  Parse *pParse,             /* Parsing context */
  Expr *pX,                  /* The IN expression */
  u32 inFlags,               /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */
  int *prRhsHasNull,         /* Register holding NULL status.  See notes */
  int *aiMap,                /* Mapping from Index fields to RHS fields */
  int *piTab                 /* OUT: index to use */
){
  Select *p;                            /* SELECT to the right of IN operator */
  int eType = 0;                        /* Type of RHS table. IN_INDEX_* */
  int iTab = pParse->nTab++;            /* Cursor of the RHS table */
  int mustBeUnique;                     /* True if RHS must be unique */
  Vdbe *v = sqlite3GetVdbe(pParse);     /* Virtual machine being coded */
 
  assert( pX->op==TK_IN );
  mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0;
 
  /* If the RHS of this IN(...) operator is a SELECT, and if it matters
  ** whether or not the SELECT result contains NULL values, check whether
  ** or not NULL is actually possible (it may not be, for example, due
  ** to NOT NULL constraints in the schema). If no NULL values are possible,
  ** set prRhsHasNull to 0 before continuing.  */
  if( prRhsHasNull && (pX->flags & EP_xIsSelect) ){
    int i;
    ExprList *pEList = pX->x.pSelect->pEList;
    for(i=0; i<pEList->nExpr; i++){
      if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
    }
    if( i==pEList->nExpr ){
      prRhsHasNull = 0;
    }
  }
 
  /* Check to see if an existing table or index can be used to
  ** satisfy the query.  This is preferable to generating a new
  ** ephemeral table.  */
  if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){
    sqlite3 *db = pParse->db;              /* Database connection */
    Table *pTab;                           /* Table <table>. */
    int iDb;                               /* Database idx for pTab */
    ExprList *pEList = p->pEList;
    int nExpr = pEList->nExpr;
 
    assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */
    assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
    assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
    pTab = p->pSrc->a[0].pTab;
 
    /* Code an OP_Transaction and OP_TableLock for <table>. */
    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
    assert( iDb>=0 && iDb<SQLITE_MAX_ATTACHED );
    sqlite3CodeVerifySchema(pParse, iDb);
    sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
 
    assert(v);  /* sqlite3GetVdbe() has always been previously called */
    if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
      /* The "x IN (SELECT rowid FROM table)" case */
      int iAddr = sqlite3VdbeAddOp0(v, OP_Once);
      VdbeCoverage(v);
 
      sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
      eType = IN_INDEX_ROWID;
      ExplainQueryPlan((pParse, 0,
            "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
      sqlite3VdbeJumpHere(v, iAddr);
    }else{
      Index *pIdx;                         /* Iterator variable */
      int affinity_ok = 1;
      int i;
 
      /* Check that the affinity that will be used to perform each
      ** comparison is the same as the affinity of each column in table
      ** on the RHS of the IN operator.  If it not, it is not possible to
      ** use any index of the RHS table.  */
      for(i=0; i<nExpr && affinity_ok; i++){
        Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
        int iCol = pEList->a[i].pExpr->iColumn;
        char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
        char cmpaff = sqlite3CompareAffinity(pLhs, idxaff);
        testcase( cmpaff==SQLITE_AFF_BLOB );
        testcase( cmpaff==SQLITE_AFF_TEXT );
        switch( cmpaff ){
          case SQLITE_AFF_BLOB:
            break;
          case SQLITE_AFF_TEXT:
            /* sqlite3CompareAffinity() only returns TEXT if one side or the
            ** other has no affinity and the other side is TEXT.  Hence,
            ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
            ** and for the term on the LHS of the IN to have no affinity. */
            assert( idxaff==SQLITE_AFF_TEXT );
            break;
          default:
            affinity_ok = sqlite3IsNumericAffinity(idxaff);
        }
      }
 
      if( affinity_ok ){
        /* Search for an existing index that will work for this IN operator */
        for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
          Bitmask colUsed;      /* Columns of the index used */
          Bitmask mCol;         /* Mask for the current column */
          if( pIdx->nColumn<nExpr ) continue;
          if( pIdx->pPartIdxWhere!=0 ) continue;
          /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
          ** BITMASK(nExpr) without overflowing */
          testcase( pIdx->nColumn==BMS-2 );
          testcase( pIdx->nColumn==BMS-1 );
          if( pIdx->nColumn>=BMS-1 ) continue;
          if( mustBeUnique ){
            if( pIdx->nKeyCol>nExpr
             ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx))
            ){
              continue;  /* This index is not unique over the IN RHS columns */
            }
          }
 
          colUsed = 0;   /* Columns of index used so far */
          for(i=0; i<nExpr; i++){
            Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
            Expr *pRhs = pEList->a[i].pExpr;
            CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
            int j;
 
            assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr );
            for(j=0; j<nExpr; j++){
              if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
              assert( pIdx->azColl[j] );
              if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
                continue;
              }
              break;
            }
            if( j==nExpr ) break;
            mCol = MASKBIT(j);
            if( mCol & colUsed ) break; /* Each column used only once */
            colUsed |= mCol;
            if( aiMap ) aiMap[i] = j;
          }
 
          assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) );
          if( colUsed==(MASKBIT(nExpr)-1) ){
            /* If we reach this point, that means the index pIdx is usable */
            int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
            ExplainQueryPlan((pParse, 0,
                              "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
            sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
            sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
            VdbeComment((v, "%s", pIdx->zName));
            assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 );
            eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0];
 
            if( prRhsHasNull ){
#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
              i64 mask = (1<<nExpr)-1;
              sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed,
                  iTab, 0, 0, (u8*)&mask, P4_INT64);
#endif
              *prRhsHasNull = ++pParse->nMem;
              if( nExpr==1 ){
                sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull);
              }
            }
            sqlite3VdbeJumpHere(v, iAddr);
          }
        } /* End loop over indexes */
      } /* End if( affinity_ok ) */
    } /* End if not an rowid index */
  } /* End attempt to optimize using an index */
 
  /* If no preexisting index is available for the IN clause
  ** and IN_INDEX_NOOP is an allowed reply
  ** and the RHS of the IN operator is a list, not a subquery
  ** and the RHS is not constant or has two or fewer terms,
  ** then it is not worth creating an ephemeral table to evaluate
  ** the IN operator so return IN_INDEX_NOOP.
  */
  if( eType==0
   && (inFlags & IN_INDEX_NOOP_OK)
   && !ExprHasProperty(pX, EP_xIsSelect)
   && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
  ){
    eType = IN_INDEX_NOOP;
  }
 
  if( eType==0 ){
    /* Could not find an existing table or index to use as the RHS b-tree.
    ** We will have to generate an ephemeral table to do the job.
    */
    u32 savedNQueryLoop = pParse->nQueryLoop;
    int rMayHaveNull = 0;
    eType = IN_INDEX_EPH;
    if( inFlags & IN_INDEX_LOOP ){
      pParse->nQueryLoop = 0;
    }else if( prRhsHasNull ){
      *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
    }
    assert( pX->op==TK_IN );
    sqlite3CodeRhsOfIN(pParse, pX, iTab);
    if( rMayHaveNull ){
      sqlite3SetHasNullFlag(v, iTab, rMayHaveNull);
    }
    pParse->nQueryLoop = savedNQueryLoop;
  }
 
  if( aiMap && eType!=IN_INDEX_INDEX_ASC && eType!=IN_INDEX_INDEX_DESC ){
    int i, n;

References ExprList::a, SrcList::a, Index::aiColumn, Index::aSortOrder, Index::azColl, BMS, Parse::db, EP_xIsSelect, eType, ExplainQueryPlan, ExprHasProperty, Expr::flags, Expr::iColumn, IN_INDEX_EPH, IN_INDEX_INDEX_ASC, IN_INDEX_INDEX_DESC, IN_INDEX_LOOP, IN_INDEX_NOOP, IN_INDEX_NOOP_OK, IN_INDEX_ROWID, isCandidateForInOpt(), IsUniqueIndex, mask, MASKBIT, Index::nColumn, Parse::nErr, ExprList::nExpr, Index::nKeyCol, Parse::nMem, Parse::nQueryLoop, Parse::nTab, Expr::op, OP_ColumnsUsed, OP_Once, OP_OpenRead, P4_INT64, Select::pEList, ExprList::ExprList_item::pExpr, Table::pIndex, Expr::pLeft, Expr::pList, Index::pNext, Index::pPartIdxWhere, Table::pSchema, Expr::pSelect, Select::pSrc, SrcList::SrcList_item::pTab, sqlite3BinaryCompareCollSeq(), sqlite3CodeRhsOfIN(), sqlite3CodeVerifySchema(), sqlite3CompareAffinity(), sqlite3ExprCanBeNull(), sqlite3ExprVectorSize(), sqlite3GetVdbe(), sqlite3InRhsIsConstant(), sqlite3IsNumericAffinity, sqlite3OpenTable(), sqlite3SchemaToIndex(), sqlite3SetHasNullFlag(), sqlite3StrICmp(), sqlite3TableColumnAffinity(), sqlite3TableLock(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Dup8(), sqlite3VdbeJumpHere(), sqlite3VdbeSetP4KeyInfo(), sqlite3VectorFieldSubexpr(), SQLITE_AFF_BLOB, SQLITE_AFF_TEXT, SQLITE_MAX_ATTACHED, testcase, TK_IN, Table::tnum, Index::tnum, VdbeComment, VdbeCoverage, Expr::x, XN_ROWID, CollSeq::zName, Table::zName, and Index::zName.

Referenced by codeEqualityTerm(), and sqlite3ExprCodeIN().

◆ sqlite3FindTable()

SQLITE_PRIVATE Table * sqlite3FindTable	(	sqlite3 *	db,
		const char *	zName,
		const char *	zDatabase )

Definition at line 110699 of file sqlite3.c.

                                                                                             {
  Table *p = 0;
  int i;
 
  /* All mutexes are required for schema access.  Make sure we hold them. */
  assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
#if SQLITE_USER_AUTHENTICATION
  /* Only the admin user is allowed to know that the sqlite_user table
  ** exists */
  if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
    return 0;
  }
#endif
  if( zDatabase ){
    for(i=0; i<db->nDb; i++){
      if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;
    }
    if( i>=db->nDb ){
      /* No match against the official names.  But always match "main"
      ** to schema 0 as a legacy fallback. */
      if( sqlite3StrICmp(zDatabase,"main")==0 ){
        i = 0;
      }else{
        return 0;
      }
    }
    p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
    if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
      if( i==1 ){
        if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0
         || sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0
         || sqlite3StrICmp(zName+7, &DFLT_SCHEMA_TABLE[7])==0
        ){
          p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
                              DFLT_TEMP_SCHEMA_TABLE);
        }
      }else{
        if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
          p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
                              DFLT_SCHEMA_TABLE);
        }
      }
    }
  }else{
    /* Match against TEMP first */
    p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
    if( p ) return p;
    /* The main database is second */
    p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
    if( p ) return p;
    /* Attached databases are in order of attachment */
    for(i=2; i<db->nDb; i++){
      assert( sqlite3SchemaMutexHeld(db, i, 0) );
      p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
      if( p ) break;
    }
    if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
      if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
        p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, DFLT_SCHEMA_TABLE);
      }else if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 ){
        p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,

References sqlite3::aDb, ALT_SCHEMA_TABLE, ALT_TEMP_SCHEMA_TABLE, DFLT_SCHEMA_TABLE, DFLT_TEMP_SCHEMA_TABLE, sqlite3::nDb, Db::pSchema, sqlite3HashFind(), sqlite3StrICmp(), sqlite3StrNICmp, Schema::tblHash, Db::zDbSName, and zName.

Referenced by analysisLoader(), openStatTable(), renameColumnFunc(), renameResolveTrigger(), renameTableFunc(), sqlite3_table_column_metadata(), sqlite3AlterFinishAddColumn(), sqlite3AnalysisLoad(), sqlite3CreateIndex(), sqlite3FkCheck(), sqlite3LocateTable(), sqlite3Pragma(), sqlite3Reindex(), sqlite3ShadowTableName(), sqlite3StartTable(), sqlite3VtabCallCreate(), and sqlite3VtabCallDestroy().

◆ sqlite3FinishCoding()

SQLITE_PRIVATE void sqlite3FinishCoding ( Parse * pParse )

Definition at line 110520 of file sqlite3.c.

                                                      {
  sqlite3 *db;
  Vdbe *v;
 
  assert( pParse->pToplevel==0 );
  db = pParse->db;
  if( pParse->nested ) return;
  if( db->mallocFailed || pParse->nErr ){
    if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
    return;
  }
 
  /* Begin by generating some termination code at the end of the
  ** vdbe program
  */
  v = sqlite3GetVdbe(pParse);
  assert( !pParse->isMultiWrite
       || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
  if( v ){
    sqlite3VdbeAddOp0(v, OP_Halt);
 
#if SQLITE_USER_AUTHENTICATION
    if( pParse->nTableLock>0 && db->init.busy==0 ){
      sqlite3UserAuthInit(db);
      if( db->auth.authLevel<UAUTH_User ){
        sqlite3ErrorMsg(pParse, "user not authenticated");
        pParse->rc = SQLITE_AUTH_USER;
        return;
      }
    }
#endif
 
    /* The cookie mask contains one bit for each database file open.
    ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are
    ** set for each database that is used.  Generate code to start a
    ** transaction on each used database and to verify the schema cookie
    ** on each used database.
    */
    if( db->mallocFailed==0
     && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
    ){
      int iDb, i;
      assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
      sqlite3VdbeJumpHere(v, 0);
      for(iDb=0; iDb<db->nDb; iDb++){
        Schema *pSchema;
        if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
        sqlite3VdbeUsesBtree(v, iDb);
        pSchema = db->aDb[iDb].pSchema;
        sqlite3VdbeAddOp4Int(v,
          OP_Transaction,                    /* Opcode */
          iDb,                               /* P1 */
          DbMaskTest(pParse->writeMask,iDb), /* P2 */
          pSchema->schema_cookie,            /* P3 */
          pSchema->iGeneration               /* P4 */
        );
        if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
        VdbeComment((v,
              "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
      }
#ifndef SQLITE_OMIT_VIRTUALTABLE
      for(i=0; i<pParse->nVtabLock; i++){
        char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
        sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
      }
      pParse->nVtabLock = 0;
#endif
 
      /* Once all the cookies have been verified and transactions opened,
      ** obtain the required table-locks. This is a no-op unless the
      ** shared-cache feature is enabled.
      */
      codeTableLocks(pParse);
 
      /* Initialize any AUTOINCREMENT data structures required.
      */
      sqlite3AutoincrementBegin(pParse);
 
      /* Code constant expressions that where factored out of inner loops.
      **
      ** The pConstExpr list might also contain expressions that we simply
      ** want to keep around until the Parse object is deleted.  Such
      ** expressions have iConstExprReg==0.  Do not generate code for
      ** those expressions, of course.
      */
      if( pParse->pConstExpr ){
        ExprList *pEL = pParse->pConstExpr;
        pParse->okConstFactor = 0;
        for(i=0; i<pEL->nExpr; i++){
          int iReg = pEL->a[i].u.iConstExprReg;
          if( iReg>0 ){
            sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg);
          }
        }
      }
 
      /* Finally, jump back to the beginning of the executable code. */
      sqlite3VdbeGoto(v, 1);
    }
  }
 
 
  /* Get the VDBE program ready for execution
  */
  if( v && pParse->nErr==0 && !db->mallocFailed ){
    /* A minimum of one cursor is required if autoincrement is used
    *  See ticket [a696379c1f08866] */
    assert( pParse->pAinc==0 || pParse->nTab>0 );

References ExprList::a, sqlite3::aDb, Parse::apVtabLock, sqlite3::sqlite3InitInfo::busy, codeTableLocks(), Parse::cookieMask, Parse::db, DbMaskNonZero, DbMaskTest, ExprList::ExprList_item::iConstExprReg, Schema::iGeneration, sqlite3::init, Parse::isMultiWrite, sqlite3::mallocFailed, Parse::mayAbort, sqlite3::nDb, Parse::nErr, Parse::nested, ExprList::nExpr, Parse::nTab, Parse::nTableLock, Parse::nVtabLock, Parse::okConstFactor, OP_Halt, OP_Init, OP_Transaction, OP_VBegin, P4_VTAB, Parse::pAinc, Parse::pConstExpr, ExprList::ExprList_item::pExpr, Db::pSchema, Parse::pToplevel, Parse::rc, Schema::schema_cookie, sqlite3AutoincrementBegin(), sqlite3ErrorMsg(), sqlite3ExprCode(), sqlite3GetVdbe(), sqlite3GetVTable(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeGetOp(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeReady(), sqlite3VdbeUsesBtree(), SQLITE_AUTH_USER, SQLITE_DONE, SQLITE_ERROR, SQLITE_OK, ExprList::ExprList_item::u, VdbeComment, and Parse::writeMask.

Referenced by yy_reduce().

◆ sqlite3FinishTrigger()

SQLITE_PRIVATE void sqlite3FinishTrigger	(	Parse *	pParse,
		TriggerStep *	pStepList,
		Token *	pAll )

Definition at line 136668 of file sqlite3.c.

 {
  Trigger *pTrig = pParse->pNewTrigger;   /* Trigger being finished */
  char *zName;                            /* Name of trigger */
  sqlite3 *db = pParse->db;               /* The database */
  DbFixer sFix;                           /* Fixer object */
  int iDb;                                /* Database containing the trigger */
  Token nameToken;                        /* Trigger name for error reporting */
 
  pParse->pNewTrigger = 0;
  if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
  zName = pTrig->zName;
  iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
  pTrig->step_list = pStepList;
  while( pStepList ){
    pStepList->pTrig = pTrig;
    pStepList = pStepList->pNext;
  }
  sqlite3TokenInit(&nameToken, pTrig->zName);
  sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
  if( sqlite3FixTriggerStep(&sFix, pTrig->step_list)
   || sqlite3FixExpr(&sFix, pTrig->pWhen)
  ){
    goto triggerfinish_cleanup;
  }
 
#ifndef SQLITE_OMIT_ALTERTABLE
  if( IN_RENAME_OBJECT ){
    assert( !db->init.busy );
    pParse->pNewTrigger = pTrig;
    pTrig = 0;
  }else
#endif
 
  /* if we are not initializing,
  ** build the sqlite_schema entry
  */
  if( !db->init.busy ){
    Vdbe *v;
    char *z;
 
    /* Make an entry in the sqlite_schema table */
    v = sqlite3GetVdbe(pParse);
    if( v==0 ) goto triggerfinish_cleanup;
    sqlite3BeginWriteOperation(pParse, 0, iDb);
    z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
    testcase( z==0 );
    sqlite3NestedParse(pParse,
       "INSERT INTO %Q." DFLT_SCHEMA_TABLE
       " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
       db->aDb[iDb].zDbSName, zName,
       pTrig->table, z);
    sqlite3DbFree(db, z);
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddParseSchemaOp(v, iDb,
        sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
  }
 
  if( db->init.busy ){
    Trigger *pLink = pTrig;
    Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    assert( pLink!=0 );
    pTrig = sqlite3HashInsert(pHash, zName, pTrig);
    if( pTrig ){
      sqlite3OomFault(db);
    }else if( pLink->pSchema==pLink->pTabSchema ){
      Table *pTab;
      pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
      assert( pTab!=0 );
      pLink->pNext = pTab->pTrigger;
      pTab->pTrigger = pLink;
    }
  }

Referenced by yy_reduce().

◆ sqlite3FixExpr()

SQLITE_PRIVATE int sqlite3FixExpr	(	DbFixer *	pFix,
		Expr *	pExpr )

Definition at line 110032 of file sqlite3.c.

 {
  while( pExpr ){
    if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
    if( pExpr->op==TK_VARIABLE ){
      if( pFix->pParse->db->init.busy ){
        pExpr->op = TK_NULL;
      }else{
        sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
        return 1;
      }
    }
    if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
    }else{
      if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
    }
    if( sqlite3FixExpr(pFix, pExpr->pRight) ){

Referenced by sqlite3FixSrcList().

◆ sqlite3FixExprList()

SQLITE_PRIVATE int sqlite3FixExprList	(	DbFixer *	pFix,
		ExprList *	pList )

Definition at line 110059 of file sqlite3.c.

 {
  int i;
  struct ExprList_item *pItem;
  if( pList==0 ) return 0;
  for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){

Referenced by sqlite3FixSrcList().

◆ sqlite3FixInit()

SQLITE_PRIVATE void sqlite3FixInit	(	DbFixer *	pFix,
		Parse *	pParse,
		int	iDb,
		const char *	zType,
		const Token *	pName )

Definition at line 109926 of file sqlite3.c.

 {
  sqlite3 *db;
 
  db = pParse->db;
  assert( db->nDb>iDb );
  pFix->pParse = pParse;

References sqlite3::aDb, DbFixer::bTemp, Parse::db, sqlite3::nDb, DbFixer::pName, DbFixer::pParse, Db::pSchema, DbFixer::pSchema, DbFixer::zDb, Db::zDbSName, and DbFixer::zType.

Referenced by sqlite3BeginTrigger(), and sqlite3CreateIndex().

◆ sqlite3FixSelect()

SQLITE_PRIVATE int sqlite3FixSelect	(	DbFixer *	pFix,
		Select *	pSelect )

Definition at line 109994 of file sqlite3.c.

 {
  while( pSelect ){
    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
      return 1;
    }
    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
      return 1;
    }
    if( pSelect->pWith ){
      int i;
      for(i=0; i<pSelect->pWith->nCte; i++){
        if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
          return 1;
        }

Referenced by sqlite3FixSrcList().

◆ sqlite3FixSrcList()

SQLITE_PRIVATE int sqlite3FixSrcList	(	DbFixer *	pFix,
		SrcList *	pList )

Definition at line 109959 of file sqlite3.c.

             : indices, triggers, and views in the TEMP database are
** allowed to refer to anything.)  If a reference is explicitly made
** to an object in a different database, an error message is added to
** pParse->zErrMsg and these routines return non-zero.  If everything
** checks out, these routines return 0.
*/
SQLITE_PRIVATE int sqlite3FixSrcList(
  DbFixer *pFix,       /* Context of the fixation */
  SrcList *pList       /* The Source list to check and modify */
){
  int i;
  struct SrcList_item *pItem;
  sqlite3 *db = pFix->pParse->db;
  int iDb = sqlite3FindDbName(db, pFix->zDb);
 
  if( NEVER(pList==0) ) return 0;
 
  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
    if( pFix->bTemp==0 ){
      if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
        sqlite3ErrorMsg(pFix->pParse,
            "%s %T cannot reference objects in database %s",
            pFix->zType, pFix->pName, pItem->zDatabase);
        return 1;
      }
      sqlite3DbFree(db, pItem->zDatabase);
      pItem->zDatabase = 0;
      pItem->pSchema = pFix->pSchema;
      pItem->fg.fromDDL = 1;
    }
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
#endif

References SrcList::a, DbFixer::bTemp, Parse::db, NEVER, SrcList::nSrc, DbFixer::pName, DbFixer::pParse, DbFixer::pSchema, sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3FindDbName(), sqlite3FixExpr(), sqlite3FixExprList(), sqlite3FixSelect(), DbFixer::zDb, and DbFixer::zType.

Referenced by sqlite3BeginTrigger(), and sqlite3CreateIndex().

◆ sqlite3FixTriggerStep()

SQLITE_PRIVATE int sqlite3FixTriggerStep	(	DbFixer *	pFix,
		TriggerStep *	pStep )

Definition at line 110076 of file sqlite3.c.

 {
  while( pStep ){
    if( sqlite3FixSelect(pFix, pStep->pSelect) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pStep->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pStep->pExprList) ){
      return 1;
    }
    if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){
      return 1;
    }
#ifndef SQLITE_OMIT_UPSERT
    if( pStep->pUpsert ){
      Upsert *pUp = pStep->pUpsert;
      if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
       || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
       || sqlite3FixExprList(pFix, pUp->pUpsertSet)
       || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
      ){
        return 1;
      }

◆ sqlite3FkActions()

SQLITE_PRIVATE void sqlite3FkActions	(	Parse *	pParse,
		Table *	pTab,
		ExprList *	pChanges,
		int	regOld,
		int *	aChange,
		int	bChngRowid )

Definition at line 120475 of file sqlite3.c.

 {
  /* If foreign-key support is enabled, iterate through all FKs that
  ** refer to table pTab. If there is an action associated with the FK
  ** for this operation (either update or delete), invoke the associated
  ** trigger sub-program.  */
  if( pParse->db->flags&SQLITE_ForeignKeys ){
    FKey *pFKey;                  /* Iterator variable */
    for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
      if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){
        Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
        if( pAct ){

Referenced by sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3FkCheck()

SQLITE_PRIVATE void sqlite3FkCheck	(	Parse *	pParse,
		Table *	pTab,
		int	regOld,
		int	regNew,
		int *	aChange,
		int	bChngRowid )

Definition at line 119966 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;       /* Database handle */
  FKey *pFKey;                    /* Used to iterate through FKs */
  int iDb;                        /* Index of database containing pTab */
  const char *zDb;                /* Name of database containing pTab */
  int isIgnoreErrors = pParse->disableTriggers;
 
  /* Exactly one of regOld and regNew should be non-zero. */
  assert( (regOld==0)!=(regNew==0) );
 
  /* If foreign-keys are disabled, this function is a no-op. */
  if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
 
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  zDb = db->aDb[iDb].zDbSName;
 
  /* Loop through all the foreign key constraints for which pTab is the
  ** child table (the table that the foreign key definition is part of).  */
  for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
    Table *pTo;                   /* Parent table of foreign key pFKey */
    Index *pIdx = 0;              /* Index on key columns in pTo */
    int *aiFree = 0;
    int *aiCol;
    int iCol;
    int i;
    int bIgnore = 0;
 
    if( aChange
     && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
     && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0
    ){
      continue;
    }
 
    /* Find the parent table of this foreign key. Also find a unique index
    ** on the parent key columns in the parent table. If either of these
    ** schema items cannot be located, set an error in pParse and return
    ** early.  */
    if( pParse->disableTriggers ){
      pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
    }else{
      pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
    }
    if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
      assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
      if( !isIgnoreErrors || db->mallocFailed ) return;
      if( pTo==0 ){
        /* If isIgnoreErrors is true, then a table is being dropped. In this
        ** case SQLite runs a "DELETE FROM xxx" on the table being dropped
        ** before actually dropping it in order to check FK constraints.
        ** If the parent table of an FK constraint on the current table is
        ** missing, behave as if it is empty. i.e. decrement the relevant
        ** FK counter for each row of the current table with non-NULL keys.
        */
        Vdbe *v = sqlite3GetVdbe(pParse);
        int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
        for(i=0; i<pFKey->nCol; i++){
          int iFromCol, iReg;
          iFromCol = pFKey->aCol[i].iFrom;
          iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1;
          sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v);
        }
        sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
      }
      continue;
    }
    assert( pFKey->nCol==1 || (aiFree && pIdx) );
 
    if( aiFree ){
      aiCol = aiFree;
    }else{
      iCol = pFKey->aCol[0].iFrom;
      aiCol = &iCol;
    }
    for(i=0; i<pFKey->nCol; i++){
      if( aiCol[i]==pTab->iPKey ){
        aiCol[i] = -1;
      }
      assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
#ifndef SQLITE_OMIT_AUTHORIZATION
      /* Request permission to read the parent key columns. If the
      ** authorization callback returns SQLITE_IGNORE, behave as if any
      ** values read from the parent table are NULL. */
      if( db->xAuth ){
        int rcauth;
        char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
        rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
        bIgnore = (rcauth==SQLITE_IGNORE);
      }
#endif
    }
 
    /* Take a shared-cache advisory read-lock on the parent table. Allocate
    ** a cursor to use to search the unique index on the parent key columns
    ** in the parent table.  */
    sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
    pParse->nTab++;
 
    if( regOld!=0 ){
      /* A row is being removed from the child table. Search for the parent.
      ** If the parent does not exist, removing the child row resolves an
      ** outstanding foreign key constraint violation. */
      fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
    }
    if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){
      /* A row is being added to the child table. If a parent row cannot
      ** be found, adding the child row has violated the FK constraint.
      **
      ** If this operation is being performed as part of a trigger program
      ** that is actually a "SET NULL" action belonging to this very
      ** foreign key, then omit this scan altogether. As all child key
      ** values are guaranteed to be NULL, it is not possible for adding
      ** this row to cause an FK violation.  */
      fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
    }
 
    sqlite3DbFree(db, aiFree);
  }
 
  /* Loop through all the foreign key constraints that refer to this table.
  ** (the "child" constraints) */
  for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
    Index *pIdx = 0;              /* Foreign key index for pFKey */
    SrcList *pSrc;
    int *aiCol = 0;
 
    if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){
      continue;
    }
 
    if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs)
     && !pParse->pToplevel && !pParse->isMultiWrite
    ){
      assert( regOld==0 && regNew!=0 );
      /* Inserting a single row into a parent table cannot cause (or fix)
      ** an immediate foreign key violation. So do nothing in this case.  */
      continue;
    }
 
    if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
      if( !isIgnoreErrors || db->mallocFailed ) return;
      continue;
    }
    assert( aiCol || pFKey->nCol==1 );
 
    /* Create a SrcList structure containing the child table.  We need the
    ** child table as a SrcList for sqlite3WhereBegin() */
    pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
    if( pSrc ){
      struct SrcList_item *pItem = pSrc->a;
      pItem->pTab = pFKey->pFrom;
      pItem->zName = pFKey->pFrom->zName;
      pItem->pTab->nTabRef++;
      pItem->iCursor = pParse->nTab++;
 
      if( regNew!=0 ){
        fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
      }
      if( regOld!=0 ){
        int eAction = pFKey->aAction[aChange!=0];
        fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
        /* If this is a deferred FK constraint, or a CASCADE or SET NULL
        ** action applies, then any foreign key violations caused by
        ** removing the parent key will be rectified by the action trigger.
        ** So do not set the "may-abort" flag in this case.
        **
        ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the
        ** may-abort flag will eventually be set on this statement anyway
        ** (when this function is called as part of processing the UPDATE
        ** within the action trigger).
        **
        ** Note 2: At first glance it may seem like SQLite could simply omit
        ** all OP_FkCounter related scans when either CASCADE or SET NULL
        ** applies. The trouble starts if the CASCADE or SET NULL action
        ** trigger causes other triggers or action rules attached to the
        ** child table to fire. In these cases the fk constraint counters
        ** might be set incorrectly if any OP_FkCounter related scans are
        ** omitted.  */
        if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){
          sqlite3MayAbort(pParse);
        }
      }

References SrcList::a, FKey::aAction, Table::aCol, FKey::aCol, sqlite3::aDb, Index::aiColumn, Parse::db, Parse::disableTriggers, fkChildIsModified(), fkLookupParent(), fkParentIsModified(), fkScanChildren(), sqlite3::flags, FKey::sColMap::iFrom, Table::iPKey, FKey::isDeferred, Parse::isMultiWrite, isSetNullAction(), sqlite3::mallocFailed, FKey::nCol, Parse::nTab, OE_Cascade, OE_SetNull, OP_FkCounter, OP_IsNull, Table::pFKey, FKey::pFrom, FKey::pNextFrom, FKey::pNextTo, Table::pSchema, Parse::pToplevel, sqlite3_stricmp(), sqlite3AuthReadCol(), sqlite3DbFree(), sqlite3FindTable(), sqlite3FkLocateIndex(), sqlite3FkReferences(), sqlite3GetVdbe(), sqlite3LocateTable(), sqlite3MayAbort(), sqlite3SchemaToIndex(), sqlite3SrcListAppend(), sqlite3TableColumnToStorage(), sqlite3TableLock(), sqlite3VdbeAddOp2(), sqlite3VdbeCurrentAddr(), SQLITE_DeferFKs, SQLITE_ForeignKeys, SQLITE_IGNORE, Table::tnum, VdbeCoverage, sqlite3::xAuth, Db::zDbSName, Column::zName, Table::zName, and FKey::zTo.

Referenced by sqlite3GenerateRowDelete(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3FkDelete()

SQLITE_PRIVATE void sqlite3FkDelete	(	sqlite3 *	db,
		Table *	pTab )

Definition at line 120507 of file sqlite3.c.

                                                             {
  FKey *pFKey;                    /* Iterator variable */
  FKey *pNext;                    /* Copy of pFKey->pNextFrom */
 
  assert( db==0 || IsVirtual(pTab)
         || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
  for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
 
    /* Remove the FK from the fkeyHash hash table. */
    if( !db || db->pnBytesFreed==0 ){
      if( pFKey->pPrevTo ){
        pFKey->pPrevTo->pNextTo = pFKey->pNextTo;
      }else{
        void *p = (void *)pFKey->pNextTo;
        const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo);
        sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p);
      }
      if( pFKey->pNextTo ){
        pFKey->pNextTo->pPrevTo = pFKey->pPrevTo;
      }
    }
 
    /* EV: R-30323-21917 Each foreign key constraint in SQLite is
    ** classified as either immediate or deferred.
    */
    assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
 
    /* Delete any triggers created to implement actions for this FK. */
#ifndef SQLITE_OMIT_TRIGGER
    fkTriggerDelete(db, pFKey->apTrigger[0]);
    fkTriggerDelete(db, pFKey->apTrigger[1]);

References FKey::apTrigger, Schema::fkeyHash, fkTriggerDelete(), FKey::isDeferred, IsVirtual, Table::pFKey, sqlite3::pnBytesFreed, FKey::pNextFrom, FKey::pNextTo, FKey::pPrevTo, Table::pSchema, sqlite3DbFree(), sqlite3HashInsert(), and FKey::zTo.

Referenced by deleteTable().

◆ sqlite3FkDropTable()

SQLITE_PRIVATE void sqlite3FkDropTable	(	Parse *	pParse,
		SrcList *	pName,
		Table *	pTab )

Definition at line 119814 of file sqlite3.c.

                                                                                  {
  sqlite3 *db = pParse->db;
  if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) ){
    int iSkip = 0;
    Vdbe *v = sqlite3GetVdbe(pParse);
 
    assert( v );                  /* VDBE has already been allocated */
    assert( pTab->pSelect==0 );   /* Not a view */
    if( sqlite3FkReferences(pTab)==0 ){
      /* Search for a deferred foreign key constraint for which this table
      ** is the child table. If one cannot be found, return without
      ** generating any VDBE code. If one can be found, then jump over
      ** the entire DELETE if there are no outstanding deferred constraints
      ** when this statement is run.  */
      FKey *p;
      for(p=pTab->pFKey; p; p=p->pNextFrom){
        if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
      }
      if( !p ) return;
      iSkip = sqlite3VdbeMakeLabel(pParse);
      sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);
    }
 
    pParse->disableTriggers = 1;
    sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0);
    pParse->disableTriggers = 0;
 
    /* If the DELETE has generated immediate foreign key constraint
    ** violations, halt the VDBE and return an error at this point, before
    ** any modifications to the schema are made. This is because statement
    ** transactions are not able to rollback schema changes.
    **
    ** If the SQLITE_DeferFKs flag is set, then this is not required, as
    ** the statement transaction will not be rolled back even if FK
    ** constraints are violated.
    */
    if( (db->flags & SQLITE_DeferFKs)==0 ){
      sqlite3VdbeVerifyAbortable(v, OE_Abort);
      sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
      VdbeCoverage(v);
      sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
          OE_Abort, 0, P4_STATIC, P5_ConstraintFK);
    }

References Parse::db, Parse::disableTriggers, sqlite3::flags, FKey::isDeferred, IsVirtual, OE_Abort, OP_FkIfZero, P4_STATIC, P5_ConstraintFK, Table::pFKey, FKey::pNextFrom, Table::pSelect, sqlite3DeleteFrom(), sqlite3FkReferences(), sqlite3GetVdbe(), sqlite3HaltConstraint(), sqlite3SrcListDup(), sqlite3VdbeAddOp2(), sqlite3VdbeCurrentAddr(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeVerifyAbortable, SQLITE_CONSTRAINT_FOREIGNKEY, SQLITE_DeferFKs, SQLITE_ForeignKeys, and VdbeCoverage.

◆ sqlite3FkLocateIndex()

SQLITE_PRIVATE int sqlite3FkLocateIndex	(	Parse *	pParse,
		Table *	pParent,
		FKey *	pFKey,
		Index **	ppIdx,
		int **	paiCol )

Definition at line 119278 of file sqlite3.c.

 {
  Index *pIdx = 0;                    /* Value to return via *ppIdx */
  int *aiCol = 0;                     /* Value to return via *paiCol */
  int nCol = pFKey->nCol;             /* Number of columns in parent key */
  char *zKey = pFKey->aCol[0].zCol;   /* Name of left-most parent key column */
 
  /* The caller is responsible for zeroing output parameters. */
  assert( ppIdx && *ppIdx==0 );
  assert( !paiCol || *paiCol==0 );
  assert( pParse );
 
  /* If this is a non-composite (single column) foreign key, check if it
  ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx
  ** and *paiCol set to zero and return early.
  **
  ** Otherwise, for a composite foreign key (more than one column), allocate
  ** space for the aiCol array (returned via output parameter *paiCol).
  ** Non-composite foreign keys do not require the aiCol array.
  */
  if( nCol==1 ){
    /* The FK maps to the IPK if any of the following are true:
    **
    **   1) There is an INTEGER PRIMARY KEY column and the FK is implicitly
    **      mapped to the primary key of table pParent, or
    **   2) The FK is explicitly mapped to a column declared as INTEGER
    **      PRIMARY KEY.
    */
    if( pParent->iPKey>=0 ){
      if( !zKey ) return 0;
      if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
    }
  }else if( paiCol ){
    assert( nCol>1 );
    aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
    if( !aiCol ) return 1;
    *paiCol = aiCol;
  }
 
  for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
    if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
      /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
      ** of columns. If each indexed column corresponds to a foreign key
      ** column of pFKey, then this index is a winner.  */
 
      if( zKey==0 ){
        /* If zKey is NULL, then this foreign key is implicitly mapped to
        ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be
        ** identified by the test.  */
        if( IsPrimaryKeyIndex(pIdx) ){
          if( aiCol ){
            int i;
            for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
          }
          break;
        }
      }else{
        /* If zKey is non-NULL, then this foreign key was declared to
        ** map to an explicit list of columns in table pParent. Check if this
        ** index matches those columns. Also, check that the index uses
        ** the default collation sequences for each column. */
        int i, j;
        for(i=0; i<nCol; i++){
          i16 iCol = pIdx->aiColumn[i];     /* Index of column in parent tbl */
          const char *zDfltColl;            /* Def. collation for column */
          char *zIdxCol;                    /* Name of indexed column */
 
          if( iCol<0 ) break; /* No foreign keys against expression indexes */
 
          /* If the index uses a collation sequence that is different from
          ** the default collation sequence for the column, this index is
          ** unusable. Bail out early in this case.  */
          zDfltColl = pParent->aCol[iCol].zColl;
          if( !zDfltColl ) zDfltColl = sqlite3StrBINARY;
          if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
 
          zIdxCol = pParent->aCol[iCol].zName;
          for(j=0; j<nCol; j++){
            if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){
              if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;
              break;
            }
          }
          if( j==nCol ) break;
        }
        if( i==nCol ) break;      /* pIdx is usable */
      }
    }
  }
 
  if( !pIdx ){
    if( !pParse->disableTriggers ){
      sqlite3ErrorMsg(pParse,
           "foreign key mismatch - \"%w\" referencing \"%w\"",
           pFKey->pFrom->zName, pFKey->zTo);
    }
    sqlite3DbFree(pParse->db, aiCol);

References Table::aCol, FKey::aCol, Index::aiColumn, Index::azColl, Parse::db, Parse::disableTriggers, FKey::sColMap::iFrom, Table::iPKey, IsPrimaryKeyIndex, IsUniqueIndex, FKey::nCol, Index::nKeyCol, FKey::pFrom, Table::pIndex, Index::pNext, Index::pPartIdxWhere, sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3ErrorMsg(), sqlite3StrBINARY, sqlite3StrICmp(), FKey::sColMap::zCol, Column::zColl, Column::zName, Table::zName, and FKey::zTo.

Referenced by fkActionTrigger(), sqlite3FkCheck(), sqlite3FkOldmask(), and sqlite3Pragma().

◆ sqlite3FkOldmask()

SQLITE_PRIVATE u32 sqlite3FkOldmask	(	Parse *	pParse,
		Table *	pTab )

Definition at line 120168 of file sqlite3.c.

                                              : ((u32)1<<(x)))
 
/*
** This function is called before generating code to update or delete a
** row contained in table pTab.
*/
SQLITE_PRIVATE u32 sqlite3FkOldmask(
  Parse *pParse,                  /* Parse context */
  Table *pTab                     /* Table being modified */
){
  u32 mask = 0;
  if( pParse->db->flags&SQLITE_ForeignKeys ){
    FKey *p;
    int i;
    for(p=pTab->pFKey; p; p=p->pNextFrom){
      for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
    }
    for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
      Index *pIdx = 0;
      sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
      if( pIdx ){
        for(i=0; i<pIdx->nKeyCol; i++){
          assert( pIdx->aiColumn[i]>=0 );
          mask |= COLUMN_MASK(pIdx->aiColumn[i]);

References FKey::aCol, Index::aiColumn, COLUMN_MASK, Parse::db, sqlite3::flags, FKey::sColMap::iFrom, mask, FKey::nCol, Index::nKeyCol, Table::pFKey, FKey::pNextFrom, FKey::pNextTo, sqlite3FkLocateIndex(), sqlite3FkReferences(), and SQLITE_ForeignKeys.

Referenced by sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3FkReferences()

SQLITE_PRIVATE FKey * sqlite3FkReferences ( Table * pTab )

Definition at line 119774 of file sqlite3.c.

References Schema::fkeyHash, Table::pSchema, sqlite3HashFind(), and Table::zName.

Referenced by sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3FkOldmask(), sqlite3FkRequired(), and sqlite3GenerateConstraintChecks().

◆ sqlite3FkRequired()

SQLITE_PRIVATE int sqlite3FkRequired	(	Parse *	pParse,
		Table *	pTab,
		int *	aChange,
		int	chngRowid )

Definition at line 120216 of file sqlite3.c.

 {
  int eRet = 0;
  if( pParse->db->flags&SQLITE_ForeignKeys ){
    if( !aChange ){
      /* A DELETE operation. Foreign key processing is required if the
      ** table in question is either the child or parent table for any
      ** foreign key constraint.  */
      eRet = (sqlite3FkReferences(pTab) || pTab->pFKey);
    }else{
      /* This is an UPDATE. Foreign key processing is only required if the
      ** operation modifies one or more child or parent key columns. */
      FKey *p;
 
      /* Check if any child key columns are being modified. */
      for(p=pTab->pFKey; p; p=p->pNextFrom){
        if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2;
        if( fkChildIsModified(pTab, p, aChange, chngRowid) ){
          eRet = 1;
        }
      }
 
      /* Check if any parent key columns are being modified. */
      for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
        if( fkParentIsModified(pTab, p, aChange, chngRowid) ){
          if( p->aAction[1]!=OE_None ) return 2;
          eRet = 1;

References FKey::aAction, Parse::db, fkChildIsModified(), fkParentIsModified(), sqlite3::flags, OE_None, Table::pFKey, FKey::pNextFrom, FKey::pNextTo, sqlite3_stricmp(), sqlite3FkReferences(), SQLITE_ForeignKeys, Table::zName, and FKey::zTo.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3FreeIndex()

SQLITE_PRIVATE void sqlite3FreeIndex	(	sqlite3 *	db,
		Index *	p )

Definition at line 110885 of file sqlite3.c.

                                                           {
#ifndef SQLITE_OMIT_ANALYZE
  sqlite3DeleteIndexSamples(db, p);
#endif
  sqlite3ExprDelete(db, p->pPartIdxWhere);
  sqlite3ExprListDelete(db, p->aColExpr);
  sqlite3DbFree(db, p->zColAff);

Referenced by deleteTable(), sqlite3CreateIndex(), and sqlite3UnlinkAndDeleteIndex().

◆ sqlite3FunctionSearch()

SQLITE_PRIVATE FuncDef * sqlite3FunctionSearch	(	int	h,
		const char *	zFunc )

Definition at line 115870 of file sqlite3.c.

 {
  FuncDef *p;
  for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){

Referenced by sqlite3FindFunction().

◆ sqlite3FunctionUsesThisSrc()

SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc	(	Expr *	pExpr,
		SrcList *	pSrcList )

Definition at line 105424 of file sqlite3.c.

                                                                             {
  Walker w;
  struct SrcCount cnt;
  assert( pExpr->op==TK_AGG_FUNCTION );
  memset(&w, 0, sizeof(w));
  w.xExprCallback = exprSrcCount;
  w.xSelectCallback = selectSrcCount;
  w.u.pSrcCount = &cnt;
  cnt.pSrc = pSrcList;
  cnt.iSrcInner = (pSrcList&&pSrcList->nSrc)?pSrcList->a[0].iCursor:0x7FFFFFFF;
  cnt.nThis = 0;
  cnt.nOther = 0;
  sqlite3WalkExprList(&w, pExpr->x.pList);
#ifndef SQLITE_OMIT_WINDOWFUNC

References SrcList::a, EP_WinFunc, ExprHasProperty, exprSrcCount(), SrcList::SrcList_item::iCursor, SrcCount::iSrcInner, SrcCount::nOther, SrcList::nSrc, SrcCount::nThis, Expr::op, Window::pFilter, Expr::pList, SrcCount::pSrc, Walker::pSrcCount, Expr::pWin, selectSrcCount(), sqlite3WalkExpr(), sqlite3WalkExprList(), TK_AGG_FUNCTION, Walker::u, Expr::x, Walker::xExprCallback, Walker::xSelectCallback, and Expr::y.

Referenced by resolveExprStep().

◆ sqlite3GenerateConstraintChecks()

SQLITE_PRIVATE void sqlite3GenerateConstraintChecks	(	Parse *	pParse,
		Table *	pTab,
		int *	aRegIdx,
		int	iDataCur,
		int	iIdxCur,
		int	regNewData,
		int	regOldData,
		u8	pkChng,
		u8	overrideError,
		int	ignoreDest,
		int *	pbMayReplace,
		int *	aiChng,
		Upsert *	pUpsert )

Definition at line 122039 of file sqlite3.c.

 {
  Vdbe *v;             /* VDBE under constrution */
  Index *pIdx;         /* Pointer to one of the indices */
  Index *pPk = 0;      /* The PRIMARY KEY index */
  sqlite3 *db;         /* Database connection */
  int i;               /* loop counter */
  int ix;              /* Index loop counter */
  int nCol;            /* Number of columns */
  int onError;         /* Conflict resolution strategy */
  int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
  int nPkField;        /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
  Index *pUpIdx = 0;   /* Index to which to apply the upsert */
  u8 isUpdate;         /* True if this is an UPDATE operation */
  u8 bAffinityDone = 0;  /* True if the OP_Affinity operation has been run */
  int upsertBypass = 0;  /* Address of Goto to bypass upsert subroutine */
  int upsertJump = 0;    /* Address of Goto that jumps into upsert subroutine */
  int ipkTop = 0;        /* Top of the IPK uniqueness check */
  int ipkBottom = 0;     /* OP_Goto at the end of the IPK uniqueness check */
  /* Variables associated with retesting uniqueness constraints after
  ** replace triggers fire have run */
  int regTrigCnt;       /* Register used to count replace trigger invocations */
  int addrRecheck = 0;  /* Jump here to recheck all uniqueness constraints */
  int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */
  Trigger *pTrigger;    /* List of DELETE triggers on the table pTab */
  int nReplaceTrig = 0; /* Number of replace triggers coded */
 
  isUpdate = regOldData!=0;
  db = pParse->db;
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
  nCol = pTab->nCol;
 
  /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
  ** normal rowid tables.  nPkField is the number of key fields in the
  ** pPk index or 1 for a rowid table.  In other words, nPkField is the
  ** number of fields in the true primary key of the table. */
  if( HasRowid(pTab) ){
    pPk = 0;
    nPkField = 1;
  }else{
    pPk = sqlite3PrimaryKeyIndex(pTab);
    nPkField = pPk->nKeyCol;
  }
 
  /* Record that this module has started */
  VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
                     iDataCur, iIdxCur, regNewData, regOldData, pkChng));
 
  /* Test all NOT NULL constraints.
  */
  if( pTab->tabFlags & TF_HasNotNull ){
    int b2ndPass = 0;         /* True if currently running 2nd pass */
    int nSeenReplace = 0;     /* Number of ON CONFLICT REPLACE operations */
    int nGenerated = 0;       /* Number of generated columns with NOT NULL */
    while(1){  /* Make 2 passes over columns. Exit loop via "break" */
      for(i=0; i<nCol; i++){
        int iReg;                        /* Register holding column value */
        Column *pCol = &pTab->aCol[i];   /* The column to check for NOT NULL */
        int isGenerated;                 /* non-zero if column is generated */
        onError = pCol->notNull;
        if( onError==OE_None ) continue; /* No NOT NULL on this column */
        if( i==pTab->iPKey ){
          continue;        /* ROWID is never NULL */
        }
        isGenerated = pCol->colFlags & COLFLAG_GENERATED;
        if( isGenerated && !b2ndPass ){
          nGenerated++;
          continue;        /* Generated columns processed on 2nd pass */
        }
        if( aiChng && aiChng[i]<0 && !isGenerated ){
          /* Do not check NOT NULL on columns that do not change */
          continue;
        }
        if( overrideError!=OE_Default ){
          onError = overrideError;
        }else if( onError==OE_Default ){
          onError = OE_Abort;
        }
        if( onError==OE_Replace ){
          if( b2ndPass        /* REPLACE becomes ABORT on the 2nd pass */
           || pCol->pDflt==0  /* REPLACE is ABORT if no DEFAULT value */
          ){
            testcase( pCol->colFlags & COLFLAG_VIRTUAL );
            testcase( pCol->colFlags & COLFLAG_STORED );
            testcase( pCol->colFlags & COLFLAG_GENERATED );
            onError = OE_Abort;
          }else{
            assert( !isGenerated );
          }
        }else if( b2ndPass && !isGenerated ){
          continue;
        }
        assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
            || onError==OE_Ignore || onError==OE_Replace );
        testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
        iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1;
        switch( onError ){
          case OE_Replace: {
            int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg);
            VdbeCoverage(v);
            assert( (pCol->colFlags & COLFLAG_GENERATED)==0 );
            nSeenReplace++;
            sqlite3ExprCodeCopy(pParse, pCol->pDflt, iReg);
            sqlite3VdbeJumpHere(v, addr1);
            break;
          }
          case OE_Abort:
            sqlite3MayAbort(pParse);
            /* no break */ deliberate_fall_through
          case OE_Rollback:
          case OE_Fail: {
            char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
                                        pCol->zName);
            sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
                              onError, iReg);
            sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
            sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
            VdbeCoverage(v);
            break;
          }
          default: {
            assert( onError==OE_Ignore );
            sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest);
            VdbeCoverage(v);
            break;
          }
        } /* end switch(onError) */
      } /* end loop i over columns */
      if( nGenerated==0 && nSeenReplace==0 ){
        /* If there are no generated columns with NOT NULL constraints
        ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
        ** pass is sufficient */
        break;
      }
      if( b2ndPass ) break;  /* Never need more than 2 passes */
      b2ndPass = 1;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
      if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
        /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
        ** first pass, recomputed values for all generated columns, as
        ** those values might depend on columns affected by the REPLACE.
        */
        sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
      }
#endif
    } /* end of 2-pass loop */
  } /* end if( has-not-null-constraints ) */
 
  /* Test all CHECK constraints
  */
#ifndef SQLITE_OMIT_CHECK
  if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
    ExprList *pCheck = pTab->pCheck;
    pParse->iSelfTab = -(regNewData+1);
    onError = overrideError!=OE_Default ? overrideError : OE_Abort;
    for(i=0; i<pCheck->nExpr; i++){
      int allOk;
      Expr *pCopy;
      Expr *pExpr = pCheck->a[i].pExpr;
      if( aiChng
       && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
      ){
        /* The check constraints do not reference any of the columns being
        ** updated so there is no point it verifying the check constraint */
        continue;
      }
      if( bAffinityDone==0 ){
        sqlite3TableAffinity(v, pTab, regNewData+1);
        bAffinityDone = 1;
      }
      allOk = sqlite3VdbeMakeLabel(pParse);
      sqlite3VdbeVerifyAbortable(v, onError);
      pCopy = sqlite3ExprDup(db, pExpr, 0);
      if( !db->mallocFailed ){
        sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL);
      }
      sqlite3ExprDelete(db, pCopy);
      if( onError==OE_Ignore ){
        sqlite3VdbeGoto(v, ignoreDest);
      }else{
        char *zName = pCheck->a[i].zEName;
        if( zName==0 ) zName = pTab->zName;
        if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */
        sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
                              onError, zName, P4_TRANSIENT,
                              P5_ConstraintCheck);
      }
      sqlite3VdbeResolveLabel(v, allOk);
    }
    pParse->iSelfTab = 0;
  }
#endif /* !defined(SQLITE_OMIT_CHECK) */
 
  /* UNIQUE and PRIMARY KEY constraints should be handled in the following
  ** order:
  **
  **   (1)  OE_Update
  **   (2)  OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
  **   (3)  OE_Replace
  **
  ** OE_Fail and OE_Ignore must happen before any changes are made.
  ** OE_Update guarantees that only a single row will change, so it
  ** must happen before OE_Replace.  Technically, OE_Abort and OE_Rollback
  ** could happen in any order, but they are grouped up front for
  ** convenience.
  **
  ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
  ** The order of constraints used to have OE_Update as (2) and OE_Abort
  ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
  ** constraint before any others, so it had to be moved.
  **
  ** Constraint checking code is generated in this order:
  **   (A)  The rowid constraint
  **   (B)  Unique index constraints that do not have OE_Replace as their
  **        default conflict resolution strategy
  **   (C)  Unique index that do use OE_Replace by default.
  **
  ** The ordering of (2) and (3) is accomplished by making sure the linked
  ** list of indexes attached to a table puts all OE_Replace indexes last
  ** in the list.  See sqlite3CreateIndex() for where that happens.
  */
 
  if( pUpsert ){
    if( pUpsert->pUpsertTarget==0 ){
      /* An ON CONFLICT DO NOTHING clause, without a constraint-target.
      ** Make all unique constraint resolution be OE_Ignore */
      assert( pUpsert->pUpsertSet==0 );
      overrideError = OE_Ignore;
      pUpsert = 0;
    }else if( (pUpIdx = pUpsert->pUpsertIdx)!=0 ){
      /* If the constraint-target uniqueness check must be run first.
      ** Jump to that uniqueness check now */
      upsertJump = sqlite3VdbeAddOp0(v, OP_Goto);
      VdbeComment((v, "UPSERT constraint goes first"));
    }
  }
 
  /* Determine if it is possible that triggers (either explicitly coded
  ** triggers or FK resolution actions) might run as a result of deletes
  ** that happen when OE_Replace conflict resolution occurs. (Call these
  ** "replace triggers".)  If any replace triggers run, we will need to
  ** recheck all of the uniqueness constraints after they have all run.
  ** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
  **
  ** If replace triggers are a possibility, then
  **
  **   (1) Allocate register regTrigCnt and initialize it to zero.
  **       That register will count the number of replace triggers that
  **       fire.  Constraint recheck only occurs if the number is positive.
  **   (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
  **   (3) Initialize addrRecheck and lblRecheckOk
  **
  ** The uniqueness rechecking code will create a series of tests to run
  ** in a second pass.  The addrRecheck and lblRecheckOk variables are
  ** used to link together these tests which are separated from each other
  ** in the generate bytecode.
  */
  if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){
    /* There are not DELETE triggers nor FK constraints.  No constraint
    ** rechecks are needed. */
    pTrigger = 0;
    regTrigCnt = 0;
  }else{
    if( db->flags&SQLITE_RecTriggers ){
      pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
      regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
    }else{
      pTrigger = 0;
      regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
    }
    if( regTrigCnt ){
      /* Replace triggers might exist.  Allocate the counter and
      ** initialize it to zero. */
      regTrigCnt = ++pParse->nMem;
      sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt);
      VdbeComment((v, "trigger count"));
      lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
      addrRecheck = lblRecheckOk;
    }
  }
 
  /* If rowid is changing, make sure the new rowid does not previously
  ** exist in the table.
  */
  if( pkChng && pPk==0 ){
    int addrRowidOk = sqlite3VdbeMakeLabel(pParse);
 
    /* Figure out what action to take in case of a rowid collision */
    onError = pTab->keyConf;
    if( overrideError!=OE_Default ){
      onError = overrideError;
    }else if( onError==OE_Default ){
      onError = OE_Abort;
    }
 
    /* figure out whether or not upsert applies in this case */
    if( pUpsert && pUpsert->pUpsertIdx==0 ){
      if( pUpsert->pUpsertSet==0 ){
        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
      }else{
        onError = OE_Update;  /* DO UPDATE */
      }
    }
 
    /* If the response to a rowid conflict is REPLACE but the response
    ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
    ** to defer the running of the rowid conflict checking until after
    ** the UNIQUE constraints have run.
    */
    if( onError==OE_Replace      /* IPK rule is REPLACE */
     && onError!=overrideError   /* Rules for other contraints are different */
     && pTab->pIndex             /* There exist other constraints */
    ){
      ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
      VdbeComment((v, "defer IPK REPLACE until last"));
    }
 
    if( isUpdate ){
      /* pkChng!=0 does not mean that the rowid has changed, only that
      ** it might have changed.  Skip the conflict logic below if the rowid
      ** is unchanged. */
      sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
      sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
      VdbeCoverage(v);
    }
 
    /* Check to see if the new rowid already exists in the table.  Skip
    ** the following conflict logic if it does not. */
    VdbeNoopComment((v, "uniqueness check for ROWID"));
    sqlite3VdbeVerifyAbortable(v, onError);
    sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
    VdbeCoverage(v);
 
    switch( onError ){
      default: {
        onError = OE_Abort;
        /* no break */ deliberate_fall_through
      }
      case OE_Rollback:
      case OE_Abort:
      case OE_Fail: {
        testcase( onError==OE_Rollback );
        testcase( onError==OE_Abort );
        testcase( onError==OE_Fail );
        sqlite3RowidConstraint(pParse, onError, pTab);
        break;
      }
      case OE_Replace: {
        /* If there are DELETE triggers on this table and the
        ** recursive-triggers flag is set, call GenerateRowDelete() to
        ** remove the conflicting row from the table. This will fire
        ** the triggers and remove both the table and index b-tree entries.
        **
        ** Otherwise, if there are no triggers or the recursive-triggers
        ** flag is not set, but the table has one or more indexes, call
        ** GenerateRowIndexDelete(). This removes the index b-tree entries
        ** only. The table b-tree entry will be replaced by the new entry
        ** when it is inserted.
        **
        ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
        ** also invoke MultiWrite() to indicate that this VDBE may require
        ** statement rollback (if the statement is aborted after the delete
        ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
        ** but being more selective here allows statements like:
        **
        **   REPLACE INTO t(rowid) VALUES($newrowid)
        **
        ** to run without a statement journal if there are no indexes on the
        ** table.
        */
        if( regTrigCnt ){
          sqlite3MultiWrite(pParse);
          sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
                                   regNewData, 1, 0, OE_Replace, 1, -1);
          sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
          nReplaceTrig++;
        }else{
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
          assert( HasRowid(pTab) );
          /* This OP_Delete opcode fires the pre-update-hook only. It does
          ** not modify the b-tree. It is more efficient to let the coming
          ** OP_Insert replace the existing entry than it is to delete the
          ** existing entry and then insert a new one. */
          sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
          sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
          if( pTab->pIndex ){
            sqlite3MultiWrite(pParse);
            sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
          }
        }
        seenReplace = 1;
        break;
      }
#ifndef SQLITE_OMIT_UPSERT
      case OE_Update: {
        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
        /* no break */ deliberate_fall_through
      }
#endif
      case OE_Ignore: {
        testcase( onError==OE_Ignore );
        sqlite3VdbeGoto(v, ignoreDest);
        break;
      }
    }
    sqlite3VdbeResolveLabel(v, addrRowidOk);
    if( ipkTop ){
      ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
      sqlite3VdbeJumpHere(v, ipkTop-1);
    }
  }
 
  /* Test all UNIQUE constraints by creating entries for each UNIQUE
  ** index and making sure that duplicate entries do not already exist.
  ** Compute the revised record entries for indices as we go.
  **
  ** This loop also handles the case of the PRIMARY KEY index for a
  ** WITHOUT ROWID table.
  */
  for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
    int regIdx;          /* Range of registers hold conent for pIdx */
    int regR;            /* Range of registers holding conflicting PK */
    int iThisCur;        /* Cursor for this UNIQUE index */
    int addrUniqueOk;    /* Jump here if the UNIQUE constraint is satisfied */
    int addrConflictCk;  /* First opcode in the conflict check logic */
 
    if( aRegIdx[ix]==0 ) continue;  /* Skip indices that do not change */
    if( pUpIdx==pIdx ){
      addrUniqueOk = upsertJump+1;
      upsertBypass = sqlite3VdbeGoto(v, 0);
      VdbeComment((v, "Skip upsert subroutine"));
      sqlite3VdbeJumpHere(v, upsertJump);
    }else{
      addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
    }
    if( bAffinityDone==0 && (pUpIdx==0 || pUpIdx==pIdx) ){
      sqlite3TableAffinity(v, pTab, regNewData+1);
      bAffinityDone = 1;
    }
    VdbeNoopComment((v, "prep index %s", pIdx->zName));
    iThisCur = iIdxCur+ix;
 
 
    /* Skip partial indices for which the WHERE clause is not true */
    if( pIdx->pPartIdxWhere ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
      pParse->iSelfTab = -(regNewData+1);
      sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
                            SQLITE_JUMPIFNULL);
      pParse->iSelfTab = 0;
    }
 
    /* Create a record for this index entry as it should appear after
    ** the insert or update.  Store that record in the aRegIdx[ix] register
    */
    regIdx = aRegIdx[ix]+1;
    for(i=0; i<pIdx->nColumn; i++){
      int iField = pIdx->aiColumn[i];
      int x;
      if( iField==XN_EXPR ){
        pParse->iSelfTab = -(regNewData+1);
        sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
        pParse->iSelfTab = 0;
        VdbeComment((v, "%s column %d", pIdx->zName, i));
      }else if( iField==XN_ROWID || iField==pTab->iPKey ){
        x = regNewData;
        sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i);
        VdbeComment((v, "rowid"));
      }else{
        testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
        x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
        sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
        VdbeComment((v, "%s", pTab->aCol[iField].zName));
      }
    }
    sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
    VdbeComment((v, "for %s", pIdx->zName));
#ifdef SQLITE_ENABLE_NULL_TRIM
    if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
      sqlite3SetMakeRecordP5(v, pIdx->pTable);
    }
#endif
    sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
 
    /* In an UPDATE operation, if this index is the PRIMARY KEY index
    ** of a WITHOUT ROWID table and there has been no change the
    ** primary key, then no collision is possible.  The collision detection
    ** logic below can all be skipped. */
    if( isUpdate && pPk==pIdx && pkChng==0 ){
      sqlite3VdbeResolveLabel(v, addrUniqueOk);
      continue;
    }
 
    /* Find out what action to take in case there is a uniqueness conflict */
    onError = pIdx->onError;
    if( onError==OE_None ){
      sqlite3VdbeResolveLabel(v, addrUniqueOk);
      continue;  /* pIdx is not a UNIQUE index */
    }
    if( overrideError!=OE_Default ){
      onError = overrideError;
    }else if( onError==OE_Default ){
      onError = OE_Abort;
    }
 
    /* Figure out if the upsert clause applies to this index */
    if( pUpIdx==pIdx ){
      if( pUpsert->pUpsertSet==0 ){
        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
      }else{
        onError = OE_Update;  /* DO UPDATE */
      }
    }
 
    /* Collision detection may be omitted if all of the following are true:
    **   (1) The conflict resolution algorithm is REPLACE
    **   (2) The table is a WITHOUT ROWID table
    **   (3) There are no secondary indexes on the table
    **   (4) No delete triggers need to be fired if there is a conflict
    **   (5) No FK constraint counters need to be updated if a conflict occurs.
    **
    ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
    ** must be explicitly deleted in order to ensure any pre-update hook
    ** is invoked.  */
#ifndef SQLITE_ENABLE_PREUPDATE_HOOK
    if( (ix==0 && pIdx->pNext==0)                   /* Condition 3 */
     && pPk==pIdx                                   /* Condition 2 */
     && onError==OE_Replace                         /* Condition 1 */
     && ( 0==(db->flags&SQLITE_RecTriggers) ||      /* Condition 4 */
          0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
     && ( 0==(db->flags&SQLITE_ForeignKeys) ||      /* Condition 5 */
         (0==pTab->pFKey && 0==sqlite3FkReferences(pTab)))
    ){
      sqlite3VdbeResolveLabel(v, addrUniqueOk);
      continue;
    }
#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */
 
    /* Check to see if the new index entry will be unique */
    sqlite3VdbeVerifyAbortable(v, onError);
    addrConflictCk =
      sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                           regIdx, pIdx->nKeyCol); VdbeCoverage(v);
 
    /* Generate code to handle collisions */
    regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
    if( isUpdate || onError==OE_Replace ){
      if( HasRowid(pTab) ){
        sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
        /* Conflict only if the rowid of the existing index entry
        ** is different from old-rowid */
        if( isUpdate ){
          sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
          sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
          VdbeCoverage(v);
        }
      }else{
        int x;
        /* Extract the PRIMARY KEY from the end of the index entry and
        ** store it in registers regR..regR+nPk-1 */
        if( pIdx!=pPk ){
          for(i=0; i<pPk->nKeyCol; i++){
            assert( pPk->aiColumn[i]>=0 );
            x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
            sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
            VdbeComment((v, "%s.%s", pTab->zName,
                         pTab->aCol[pPk->aiColumn[i]].zName));
          }
        }
        if( isUpdate ){
          /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
          ** table, only conflict if the new PRIMARY KEY values are actually
          ** different from the old.
          **
          ** For a UNIQUE index, only conflict if the PRIMARY KEY values
          ** of the matched index row are different from the original PRIMARY
          ** KEY values of this row before the update.  */
          int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
          int op = OP_Ne;
          int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR);
 
          for(i=0; i<pPk->nKeyCol; i++){
            char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
            x = pPk->aiColumn[i];
            assert( x>=0 );
            if( i==(pPk->nKeyCol-1) ){
              addrJump = addrUniqueOk;
              op = OP_Eq;
            }
            x = sqlite3TableColumnToStorage(pTab, x);
            sqlite3VdbeAddOp4(v, op,
                regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ
            );
            sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
            VdbeCoverageIf(v, op==OP_Eq);
            VdbeCoverageIf(v, op==OP_Ne);
          }
        }
      }
    }
 
    /* Generate code that executes if the new index entry is not unique */
    assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
        || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update );
    switch( onError ){
      case OE_Rollback:
      case OE_Abort:
      case OE_Fail: {
        testcase( onError==OE_Rollback );
        testcase( onError==OE_Abort );
        testcase( onError==OE_Fail );
        sqlite3UniqueConstraint(pParse, onError, pIdx);
        break;
      }
#ifndef SQLITE_OMIT_UPSERT
      case OE_Update: {
        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
        /* no break */ deliberate_fall_through
      }
#endif
      case OE_Ignore: {
        testcase( onError==OE_Ignore );
        sqlite3VdbeGoto(v, ignoreDest);
        break;
      }
      default: {
        int nConflictCk;   /* Number of opcodes in conflict check logic */
 
        assert( onError==OE_Replace );
        nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
        assert( nConflictCk>0 );
        testcase( nConflictCk>1 );
        if( regTrigCnt ){
          sqlite3MultiWrite(pParse);
          nReplaceTrig++;
        }
        if( pTrigger && isUpdate ){
          sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
        }
        sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
            regR, nPkField, 0, OE_Replace,
            (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
        if( pTrigger && isUpdate ){
          sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur);
        }
        if( regTrigCnt ){
          int addrBypass;  /* Jump destination to bypass recheck logic */
 
          sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
          addrBypass = sqlite3VdbeAddOp0(v, OP_Goto);  /* Bypass recheck */
          VdbeComment((v, "bypass recheck"));
 
          /* Here we insert code that will be invoked after all constraint
          ** checks have run, if and only if one or more replace triggers
          ** fired. */
          sqlite3VdbeResolveLabel(v, lblRecheckOk);
          lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
          if( pIdx->pPartIdxWhere ){
            /* Bypass the recheck if this partial index is not defined
            ** for the current row */
            sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
            VdbeCoverage(v);
          }
          /* Copy the constraint check code from above, except change
          ** the constraint-ok jump destination to be the address of
          ** the next retest block */
          while( nConflictCk>0 ){
            VdbeOp x;    /* Conflict check opcode to copy */
            /* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
            ** Hence, make a complete copy of the opcode, rather than using
            ** a pointer to the opcode. */
            x = *sqlite3VdbeGetOp(v, addrConflictCk);
            if( x.opcode!=OP_IdxRowid ){
              int p2;      /* New P2 value for copied conflict check opcode */
              const char *zP4;
              if( sqlite3OpcodeProperty[x.opcode]&OPFLG_JUMP ){
                p2 = lblRecheckOk;
              }else{
                p2 = x.p2;
              }
              zP4 = x.p4type==P4_INT32 ? SQLITE_INT_TO_PTR(x.p4.i) : x.p4.z;
              sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type);
              sqlite3VdbeChangeP5(v, x.p5);
              VdbeCoverageIf(v, p2!=x.p2);
            }
            nConflictCk--;
            addrConflictCk++;
          }
          /* If the retest fails, issue an abort */
          sqlite3UniqueConstraint(pParse, OE_Abort, pIdx);
 
          sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
        }
        seenReplace = 1;
        break;
      }
    }
    if( pUpIdx==pIdx ){
      sqlite3VdbeGoto(v, upsertJump+1);
      sqlite3VdbeJumpHere(v, upsertBypass);
    }else{
      sqlite3VdbeResolveLabel(v, addrUniqueOk);
    }
    if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
  }
 
  /* If the IPK constraint is a REPLACE, run it last */
  if( ipkTop ){
    sqlite3VdbeGoto(v, ipkTop);
    VdbeComment((v, "Do IPK REPLACE"));
    sqlite3VdbeJumpHere(v, ipkBottom);
  }
 
  /* Recheck all uniqueness constraints after replace triggers have run */
  testcase( regTrigCnt!=0 && nReplaceTrig==0 );
  assert( regTrigCnt!=0 || nReplaceTrig==0 );
  if( nReplaceTrig ){
    sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v);
    if( !pPk ){
      if( isUpdate ){
        sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData);
        sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
        VdbeCoverage(v);
      }
      sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData);
      VdbeCoverage(v);
      sqlite3RowidConstraint(pParse, OE_Abort, pTab);
    }else{
      sqlite3VdbeGoto(v, addrRecheck);
    }
    sqlite3VdbeResolveLabel(v, lblRecheckOk);
  }
 
  /* Generate the table record */
  if( HasRowid(pTab) ){
    int regRec = aRegIdx[ix];
    sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
    sqlite3SetMakeRecordP5(v, pTab);
    if( !bAffinityDone ){
      sqlite3TableAffinity(v, pTab, 0);

References ExprList::a, Table::aCol, Index::aColExpr, Index::aiColumn, Index::azColl, COLFLAG_GENERATED, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, deliberate_fall_through, sqlite3::flags, HasRowid, VdbeOp::p4union::i, Index::idxType, Table::iPKey, Parse::iSelfTab, IsPrimaryKeyIndex, Table::keyConf, sqlite3::mallocFailed, Table::nCol, Index::nColumn, ExprList::nExpr, Index::nKeyCol, Parse::nMem, Table::nNVCol, Column::notNull, OE_Abort, OE_Default, OE_Fail, OE_Ignore, OE_None, OE_Replace, OE_Rollback, OE_Update, ONEPASS_OFF, ONEPASS_SINGLE, Index::onError, OP_AddImm, OP_Column, OP_CursorLock, OP_CursorUnlock, OP_Delete, OP_Eq, OP_Goto, OP_HaltIfNull, OP_IdxRowid, OP_IfNot, OP_IntCopy, OP_Integer, OP_IsNull, OP_MakeRecord, OP_Ne, OP_NoConflict, OP_NotExists, OP_NotNull, OP_Null, OP_SCopy, VdbeOp::opcode, OPFLAG_ISNOOP, OPFLG_JUMP, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, VdbeOp::p4, P4_COLLSEQ, P4_DYNAMIC, P4_INT32, P4_TABLE, P4_TRANSIENT, VdbeOp::p4type, VdbeOp::p5, P5_ConstraintCheck, P5_ConstraintNotNull, Table::pCheck, Column::pDflt, ExprList::ExprList_item::pExpr, Table::pFKey, Table::pIndex, Index::pNext, Index::pPartIdxWhere, Table::pSelect, Index::pTable, Upsert::pUpsertIdx, Upsert::pUpsertSet, Upsert::pUpsertTarget, sqlite3ComputeGeneratedColumns(), sqlite3ExprCodeCopy(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIfFalseDup(), sqlite3ExprIfTrue(), sqlite3ExprReferencesUpdatedColumn(), sqlite3FkReferences(), sqlite3FkRequired(), sqlite3GenerateRowDelete(), sqlite3GenerateRowIndexDelete(), sqlite3GetTempRange(), sqlite3GetVdbe(), sqlite3HaltConstraint(), sqlite3LocateCollSeq(), sqlite3MayAbort(), sqlite3MPrintf(), sqlite3MultiWrite(), sqlite3OpcodeProperty, sqlite3PrimaryKeyIndex(), sqlite3ReleaseTempRange(), sqlite3RowidConstraint(), sqlite3SetMakeRecordP5, sqlite3TableAffinity(), sqlite3TableColumnToIndex(), sqlite3TableColumnToStorage(), sqlite3TriggersExist(), sqlite3UniqueConstraint(), sqlite3UpsertDoUpdate(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeReleaseRegisters, sqlite3VdbeResolveLabel(), sqlite3VdbeVerifyAbortable, SQLITE_CONSTRAINT_CHECK, SQLITE_CONSTRAINT_NOTNULL, SQLITE_ForeignKeys, SQLITE_IDXTYPE_PRIMARYKEY, SQLITE_IgnoreChecks, SQLITE_INT_TO_PTR, SQLITE_JUMPIFNULL, SQLITE_NOTNULL, SQLITE_RecTriggers, Table::tabFlags, testcase, TF_HasGenerated, TF_HasNotNull, TK_DELETE, VdbeComment, VdbeCoverage, VdbeCoverageIf, VdbeModuleComment, VdbeNoopComment, XN_EXPR, XN_ROWID, VdbeOp::p4union::z, ExprList::ExprList_item::zEName, Column::zName, Table::zName, Index::zName, and zName.

Referenced by sqlite3Insert(), and sqlite3Update().

◆ sqlite3GenerateIndexKey()

SQLITE_PRIVATE int sqlite3GenerateIndexKey	(	Parse *	pParse,
		Index *	pIdx,
		int	iDataCur,
		int	regOut,
		int	prefixOnly,
		int *	piPartIdxLabel,
		Index *	pPrior,
		int	regPrior )

Definition at line 116973 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  int j;
  int regBase;
  int nCol;
 
  if( piPartIdxLabel ){
    if( pIdx->pPartIdxWhere ){
      *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse);
      pParse->iSelfTab = iDataCur + 1;
      sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
                            SQLITE_JUMPIFNULL);
      pParse->iSelfTab = 0;
      pPrior = 0; /* Ticket a9efb42811fa41ee 2019-11-02;
                  ** pPartIdxWhere may have corrupted regPrior registers */
    }else{
      *piPartIdxLabel = 0;
    }
  }
  nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
  regBase = sqlite3GetTempRange(pParse, nCol);
  if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
  for(j=0; j<nCol; j++){
    if( pPrior
     && pPrior->aiColumn[j]==pIdx->aiColumn[j]
     && pPrior->aiColumn[j]!=XN_EXPR
    ){
      /* This column was already computed by the previous index */
      continue;
    }
    sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);
    /* If the column affinity is REAL but the number is an integer, then it
    ** might be stored in the table as an integer (using a compact
    ** representation) then converted to REAL by an OP_RealAffinity opcode.
    ** But we are getting ready to store this value back into an index, where
    ** it should be converted by to INTEGER again.  So omit the OP_RealAffinity
    ** opcode if it is present */
    sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
  }
  if( regOut ){
    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
    if( pIdx->pTable->pSelect ){
      const char *zAff = sqlite3IndexAffinityStr(pParse->db, pIdx);

References Index::aiColumn, Parse::db, Parse::iSelfTab, Index::nColumn, Index::nKeyCol, OP_MakeRecord, OP_RealAffinity, P4_TRANSIENT, Index::pPartIdxWhere, Table::pSelect, Index::pTable, Parse::pVdbe, sqlite3ExprCodeLoadIndexColumn(), sqlite3ExprIfFalseDup(), sqlite3GetTempRange(), sqlite3IndexAffinityStr(), sqlite3ReleaseTempRange(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP4(), sqlite3VdbeDeletePriorOpcode(), sqlite3VdbeMakeLabel(), SQLITE_JUMPIFNULL, Index::uniqNotNull, and XN_EXPR.

Referenced by constructAutomaticIndex(), sqlite3GenerateRowIndexDelete(), sqlite3Pragma(), and sqlite3RefillIndex().

◆ sqlite3GenerateRowDelete()

SQLITE_PRIVATE void sqlite3GenerateRowDelete	(	Parse *	pParse,
		Table *	pTab,
		Trigger *	pTrigger,
		int	iDataCur,
		int	iIdxCur,
		int	iPk,
		i16	nPk,
		u8	count,
		u8	onconf,
		u8	eMode,
		int	iIdxNoSeek )

Definition at line 116756 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;        /* Vdbe */
  int iOld = 0;                   /* First register in OLD.* array */
  int iLabel;                     /* Label resolved to end of generated code */
  u8 opSeek;                      /* Seek opcode */
 
  /* Vdbe is guaranteed to have been allocated by this stage. */
  assert( v );
  VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)",
                         iDataCur, iIdxCur, iPk, (int)nPk));
 
  /* Seek cursor iCur to the row to delete. If this row no longer exists
  ** (this can happen if a trigger program has already deleted it), do
  ** not attempt to delete it or fire any DELETE triggers.  */
  iLabel = sqlite3VdbeMakeLabel(pParse);
  opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
  if( eMode==ONEPASS_OFF ){
    sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
    VdbeCoverageIf(v, opSeek==OP_NotExists);
    VdbeCoverageIf(v, opSeek==OP_NotFound);
  }
 
  /* If there are any triggers to fire, allocate a range of registers to
  ** use for the old.* references in the triggers.  */
  if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
    u32 mask;                     /* Mask of OLD.* columns in use */
    int iCol;                     /* Iterator used while populating OLD.* */
    int addrStart;                /* Start of BEFORE trigger programs */
 
    /* TODO: Could use temporary registers here. Also could attempt to
    ** avoid copying the contents of the rowid register.  */
    mask = sqlite3TriggerColmask(
        pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
    );
    mask |= sqlite3FkOldmask(pParse, pTab);
    iOld = pParse->nMem+1;
    pParse->nMem += (1 + pTab->nCol);
 
    /* Populate the OLD.* pseudo-table register array. These values will be
    ** used by any BEFORE and AFTER triggers that exist.  */
    sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);
    for(iCol=0; iCol<pTab->nCol; iCol++){
      testcase( mask!=0xffffffff && iCol==31 );
      testcase( mask!=0xffffffff && iCol==32 );
      if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
        int kk = sqlite3TableColumnToStorage(pTab, iCol);
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
      }
    }
 
    /* Invoke BEFORE DELETE trigger programs. */
    addrStart = sqlite3VdbeCurrentAddr(v);
    sqlite3CodeRowTrigger(pParse, pTrigger,
        TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
    );
 
    /* If any BEFORE triggers were coded, then seek the cursor to the
    ** row to be deleted again. It may be that the BEFORE triggers moved
    ** the cursor or already deleted the row that the cursor was
    ** pointing to.
    **
    ** Also disable the iIdxNoSeek optimization since the BEFORE trigger
    ** may have moved that cursor.
    */
    if( addrStart<sqlite3VdbeCurrentAddr(v) ){
      sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
      VdbeCoverageIf(v, opSeek==OP_NotExists);
      VdbeCoverageIf(v, opSeek==OP_NotFound);
      testcase( iIdxNoSeek>=0 );
      iIdxNoSeek = -1;
    }
 
    /* Do FK processing. This call checks that any FK constraints that
    ** refer to this table (i.e. constraints attached to other tables)
    ** are not violated by deleting this row.  */
    sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
  }
 
  /* Delete the index and table entries. Skip this step if pTab is really
  ** a view (in which case the only effect of the DELETE statement is to
  ** fire the INSTEAD OF triggers).
  **
  ** If variable 'count' is non-zero, then this OP_Delete instruction should
  ** invoke the update-hook. The pre-update-hook, on the other hand should
  ** be invoked unless table pTab is a system table. The difference is that
  ** the update-hook is not invoked for rows removed by REPLACE, but the
  ** pre-update-hook is.
  */
  if( pTab->pSelect==0 ){
    u8 p5 = 0;
    sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
    sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
    if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
      sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
    }
    if( eMode!=ONEPASS_OFF ){
      sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
    }
    if( iIdxNoSeek>=0 && iIdxNoSeek!=iDataCur ){
      sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
    }
    if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;
    sqlite3VdbeChangeP5(v, p5);
  }
 
  /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
  ** handle rows (possibly in other tables) that refer via a foreign key
  ** to the row just deleted. */
  sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
 
  /* Invoke AFTER DELETE trigger programs. */
  sqlite3CodeRowTrigger(pParse, pTrigger,
      TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
  );
 

References HasRowid, mask, MASKBIT32, Table::nCol, Parse::nested, Parse::nMem, ONEPASS_MULTI, ONEPASS_OFF, OP_Copy, OP_Delete, OP_NotExists, OP_NotFound, OPFLAG_AUXDELETE, OPFLAG_NCHANGE, OPFLAG_SAVEPOSITION, P4_TABLE, Table::pSelect, Parse::pVdbe, sqlite3_stricmp(), sqlite3CodeRowTrigger(), sqlite3ExprCodeGetColumnOfTable(), sqlite3FkActions(), sqlite3FkCheck(), sqlite3FkOldmask(), sqlite3FkRequired(), sqlite3GenerateRowIndexDelete(), sqlite3TableColumnToStorage(), sqlite3TriggerColmask(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), testcase, TK_DELETE, TRIGGER_AFTER, TRIGGER_BEFORE, VdbeCoverageIf, VdbeModuleComment, and Table::zName.

Referenced by sqlite3DeleteFrom(), and sqlite3GenerateConstraintChecks().

◆ sqlite3GenerateRowIndexDelete()

SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete	(	Parse *	pParse,
		Table *	pTab,
		int	iDataCur,
		int	iIdxCur,
		int *	aRegIdx,
		int	iIdxNoSeek )

Definition at line 116908 of file sqlite3.c.

 {
  int i;             /* Index loop counter */
  int r1 = -1;       /* Register holding an index key */
  int iPartIdxLabel; /* Jump destination for skipping partial index entries */
  Index *pIdx;       /* Current index */
  Index *pPrior = 0; /* Prior index */
  Vdbe *v;           /* The prepared statement under construction */
  Index *pPk;        /* PRIMARY KEY index, or NULL for rowid tables */
 
  v = pParse->pVdbe;
  pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
  for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
    assert( iIdxCur+i!=iDataCur || pPk==pIdx );
    if( aRegIdx!=0 && aRegIdx[i]==0 ) continue;
    if( pIdx==pPk ) continue;
    if( iIdxCur+i==iIdxNoSeek ) continue;
    VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
    r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
        &iPartIdxLabel, pPrior, r1);
    sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,

References HasRowid, Index::nColumn, Index::nKeyCol, OP_IdxDelete, Table::pIndex, Index::pNext, Parse::pVdbe, sqlite3GenerateIndexKey(), sqlite3PrimaryKeyIndex(), sqlite3ResolvePartIdxLabel(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP5(), Index::uniqNotNull, VdbeModuleComment, and Index::zName.

Referenced by sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3Get4byte()

SQLITE_PRIVATE u32 sqlite3Get4byte ( const u8 * p )

Definition at line 32440 of file sqlite3.c.

                                               {
#if SQLITE_BYTEORDER==4321
  u32 x;
  memcpy(&x,p,4);
  return x;
#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
  u32 x;
  memcpy(&x,p,4);
  return __builtin_bswap32(x);
#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
  u32 x;
  memcpy(&x,p,4);

Referenced by pager_write_changecounter(), read32bits(), walDecodeFrame(), walIndexRecover(), walRestartHdr(), and walRewriteChecksums().

◆ sqlite3GetBoolean()

SQLITE_PRIVATE u8 sqlite3GetBoolean	(	const char *	z,
		u8	dflt )

Definition at line 125808 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ sqlite3GetCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3GetCollSeq	(	Parse *	pParse,
		u8	enc,
		CollSeq *	pColl,
		const char *	zName )

Definition at line 115740 of file sqlite3.c.

           : sqlite3LocateCollSeq(), sqlite3FindCollSeq()
*/
SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(
  Parse *pParse,        /* Parsing context */
  u8 enc,               /* The desired encoding for the collating sequence */
  CollSeq *pColl,       /* Collating sequence with native encoding, or NULL */
  const char *zName     /* Collating sequence name */
){
  CollSeq *p;
  sqlite3 *db = pParse->db;
 
  p = pColl;
  if( !p ){
    p = sqlite3FindCollSeq(db, enc, zName, 0);
  }
  if( !p || !p->xCmp ){
    /* No collation sequence of this type for this encoding is registered.
    ** Call the collation factory to see if it can supply us with one.
    */
    callCollNeeded(db, enc, zName);
    p = sqlite3FindCollSeq(db, enc, zName, 0);
  }
  if( p && !p->xCmp && synthCollSeq(db, p) ){
    p = 0;
  }
  assert( !p || p->xCmp );

References callCollNeeded(), Parse::db, Parse::rc, sqlite3ErrorMsg(), sqlite3FindCollSeq(), SQLITE_ERROR_MISSING_COLLSEQ, synthCollSeq(), CollSeq::xCmp, and zName.

Referenced by sqlite3CheckCollSeq(), sqlite3ExprCollSeq(), and sqlite3LocateCollSeq().

◆ sqlite3GetFuncCollSeq()

static CollSeq * sqlite3GetFuncCollSeq ( sqlite3_context * context )

static

Definition at line 117071 of file sqlite3.c.

117077 {

117078 VdbeOp *pOp;

References Vdbe::aOp, sqlite3_context::iOp, OP_CollSeq, VdbeOp::opcode, VdbeOp::p4, P4_COLLSEQ, VdbeOp::p4type, VdbeOp::p4union::pColl, and sqlite3_context::pVdbe.

Referenced by minmaxStep(), and nullifFunc().

◆ sqlite3GetInt32()

SQLITE_PRIVATE int sqlite3GetInt32	(	const char *	zNum,
		int *	pValue )

Definition at line 31981 of file sqlite3.c.

                                                                 {
  sqlite_int64 v = 0;
  int i, c;
  int neg = 0;
  if( zNum[0]=='-' ){
    neg = 1;
    zNum++;
  }else if( zNum[0]=='+' ){
    zNum++;
  }
#ifndef SQLITE_OMIT_HEX_INTEGER
  else if( zNum[0]=='0'
        && (zNum[1]=='x' || zNum[1]=='X')
        && sqlite3Isxdigit(zNum[2])
  ){
    u32 u = 0;
    zNum += 2;
    while( zNum[0]=='0' ) zNum++;
    for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
      u = u*16 + sqlite3HexToInt(zNum[i]);
    }
    if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
      memcpy(pValue, &u, 4);
      return 1;
    }else{
      return 0;
    }
  }
#endif
  if( !sqlite3Isdigit(zNum[0]) ) return 0;
  while( zNum[0]=='0' ) zNum++;
  for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
    v = v*10 + c;
  }
 
  /* The longest decimal representation of a 32 bit integer is 10 digits:
  **
  **             1234567890
  **     2^31 -> 2147483648
  */
  testcase( i==10 );
  if( i>10 ){
    return 0;
  }
  testcase( v-neg==2147483647 );
  if( v-neg>2147483647 ){
    return 0;
  }

References sqlite3HexToInt(), sqlite3Isdigit, sqlite3Isxdigit, and testcase.

Referenced by sqlite3AffinityType(), sqlite3ExprAlloc(), sqlite3ExprIsInteger(), sqlite3Pragma(), sqlite3VdbeExpandSql(), and yy_reduce().

◆ sqlite3GetTempRange()

SQLITE_PRIVATE int sqlite3GetTempRange	(	Parse *	pParse,
		int	nReg )

Definition at line 105730 of file sqlite3.c.

                                                               {
  int i, n;
  if( nReg==1 ) return sqlite3GetTempReg(pParse);
  i = pParse->iRangeReg;
  n = pParse->nRangeReg;
  if( nReg<=n ){
    pParse->iRangeReg += nReg;
    pParse->nRangeReg -= nReg;

Referenced by analyzeOneTable(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), selectInnerLoop(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3GenerateIndexKey(), sqlite3Insert(), sqlite3Select(), updateAccumulator(), windowAggStep(), windowCodeOp(), and windowFullScan().

◆ sqlite3GetTempReg()

SQLITE_PRIVATE int sqlite3GetTempReg ( Parse * pParse )

◆ sqlite3GetToken()

SQLITE_PRIVATE int sqlite3GetToken	(	const unsigned char *	z,
		int *	tokenType )

Definition at line 160008 of file sqlite3.c.

                                                                          {
  int i, c;
  switch( aiClass[*z] ){  /* Switch on the character-class of the first byte
                          ** of the token. See the comment on the CC_ defines
                          ** above. */
    case CC_SPACE: {
      testcase( z[0]==' ' );
      testcase( z[0]=='\t' );
      testcase( z[0]=='\n' );
      testcase( z[0]=='\f' );
      testcase( z[0]=='\r' );
      for(i=1; sqlite3Isspace(z[i]); i++){}
      *tokenType = TK_SPACE;
      return i;
    }
    case CC_MINUS: {
      if( z[1]=='-' ){
        for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
        *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
        return i;
      }
      *tokenType = TK_MINUS;
      return 1;
    }
    case CC_LP: {
      *tokenType = TK_LP;
      return 1;
    }
    case CC_RP: {
      *tokenType = TK_RP;
      return 1;
    }
    case CC_SEMI: {
      *tokenType = TK_SEMI;
      return 1;
    }
    case CC_PLUS: {
      *tokenType = TK_PLUS;
      return 1;
    }
    case CC_STAR: {
      *tokenType = TK_STAR;
      return 1;
    }
    case CC_SLASH: {
      if( z[1]!='*' || z[2]==0 ){
        *tokenType = TK_SLASH;
        return 1;
      }
      for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
      if( c ) i++;
      *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
      return i;
    }
    case CC_PERCENT: {
      *tokenType = TK_REM;
      return 1;
    }
    case CC_EQ: {
      *tokenType = TK_EQ;
      return 1 + (z[1]=='=');
    }
    case CC_LT: {
      if( (c=z[1])=='=' ){
        *tokenType = TK_LE;
        return 2;
      }else if( c=='>' ){
        *tokenType = TK_NE;
        return 2;
      }else if( c=='<' ){
        *tokenType = TK_LSHIFT;
        return 2;
      }else{
        *tokenType = TK_LT;
        return 1;
      }
    }
    case CC_GT: {
      if( (c=z[1])=='=' ){
        *tokenType = TK_GE;
        return 2;
      }else if( c=='>' ){
        *tokenType = TK_RSHIFT;
        return 2;
      }else{
        *tokenType = TK_GT;
        return 1;
      }
    }
    case CC_BANG: {
      if( z[1]!='=' ){
        *tokenType = TK_ILLEGAL;
        return 1;
      }else{
        *tokenType = TK_NE;
        return 2;
      }
    }
    case CC_PIPE: {
      if( z[1]!='|' ){
        *tokenType = TK_BITOR;
        return 1;
      }else{
        *tokenType = TK_CONCAT;
        return 2;
      }
    }
    case CC_COMMA: {
      *tokenType = TK_COMMA;
      return 1;
    }
    case CC_AND: {
      *tokenType = TK_BITAND;
      return 1;
    }
    case CC_TILDA: {
      *tokenType = TK_BITNOT;
      return 1;
    }
    case CC_QUOTE: {
      int delim = z[0];
      testcase( delim=='`' );
      testcase( delim=='\'' );
      testcase( delim=='"' );
      for(i=1; (c=z[i])!=0; i++){
        if( c==delim ){
          if( z[i+1]==delim ){
            i++;
          }else{
            break;
          }
        }
      }
      if( c=='\'' ){
        *tokenType = TK_STRING;
        return i+1;
      }else if( c!=0 ){
        *tokenType = TK_ID;
        return i+1;
      }else{
        *tokenType = TK_ILLEGAL;
        return i;
      }
    }
    case CC_DOT: {
#ifndef SQLITE_OMIT_FLOATING_POINT
      if( !sqlite3Isdigit(z[1]) )
#endif
      {
        *tokenType = TK_DOT;
        return 1;
      }
      /* If the next character is a digit, this is a floating point
      ** number that begins with ".".  Fall thru into the next case */
      /* no break */ deliberate_fall_through
    }
    case CC_DIGIT: {
      testcase( z[0]=='0' );  testcase( z[0]=='1' );  testcase( z[0]=='2' );
      testcase( z[0]=='3' );  testcase( z[0]=='4' );  testcase( z[0]=='5' );
      testcase( z[0]=='6' );  testcase( z[0]=='7' );  testcase( z[0]=='8' );
      testcase( z[0]=='9' );
      *tokenType = TK_INTEGER;
#ifndef SQLITE_OMIT_HEX_INTEGER
      if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
        for(i=3; sqlite3Isxdigit(z[i]); i++){}
        return i;
      }
#endif
      for(i=0; sqlite3Isdigit(z[i]); i++){}
#ifndef SQLITE_OMIT_FLOATING_POINT
      if( z[i]=='.' ){
        i++;
        while( sqlite3Isdigit(z[i]) ){ i++; }
        *tokenType = TK_FLOAT;
      }
      if( (z[i]=='e' || z[i]=='E') &&
           ( sqlite3Isdigit(z[i+1])
            || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
           )
      ){
        i += 2;
        while( sqlite3Isdigit(z[i]) ){ i++; }
        *tokenType = TK_FLOAT;
      }
#endif
      while( IdChar(z[i]) ){
        *tokenType = TK_ILLEGAL;
        i++;
      }
      return i;
    }
    case CC_QUOTE2: {
      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
      *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
      return i;
    }
    case CC_VARNUM: {
      *tokenType = TK_VARIABLE;
      for(i=1; sqlite3Isdigit(z[i]); i++){}
      return i;
    }
    case CC_DOLLAR:
    case CC_VARALPHA: {
      int n = 0;
      testcase( z[0]=='$' );  testcase( z[0]=='@' );
      testcase( z[0]==':' );  testcase( z[0]=='#' );
      *tokenType = TK_VARIABLE;
      for(i=1; (c=z[i])!=0; i++){
        if( IdChar(c) ){
          n++;
#ifndef SQLITE_OMIT_TCL_VARIABLE
        }else if( c=='(' && n>0 ){
          do{
            i++;
          }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' );
          if( c==')' ){
            i++;
          }else{
            *tokenType = TK_ILLEGAL;
          }
          break;
        }else if( c==':' && z[i+1]==':' ){
          i++;
#endif
        }else{
          break;
        }
      }
      if( n==0 ) *tokenType = TK_ILLEGAL;
      return i;
    }
    case CC_KYWD: {
      for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
      if( IdChar(z[i]) ){
        /* This token started out using characters that can appear in keywords,
        ** but z[i] is a character not allowed within keywords, so this must
        ** be an identifier instead */
        i++;
        break;
      }
      *tokenType = TK_ID;
      return keywordCode((char*)z, i, tokenType);
    }
    case CC_X: {
#ifndef SQLITE_OMIT_BLOB_LITERAL
      testcase( z[0]=='x' ); testcase( z[0]=='X' );
      if( z[1]=='\'' ){
        *tokenType = TK_BLOB;
        for(i=2; sqlite3Isxdigit(z[i]); i++){}
        if( z[i]!='\'' || i%2 ){
          *tokenType = TK_ILLEGAL;
          while( z[i] && z[i]!='\'' ){ i++; }
        }
        if( z[i] ) i++;
        return i;
      }
#endif
      /* If it is not a BLOB literal, then it must be an ID, since no
      ** SQL keywords start with the letter 'x'.  Fall through */
      /* no break */ deliberate_fall_through
    }
    case CC_ID: {
      i = 1;
      break;
    }
    case CC_NUL: {
      *tokenType = TK_ILLEGAL;
      return 0;
    }
    default: {
      *tokenType = TK_ILLEGAL;
      return 1;

References aiClass, CC_AND, CC_BANG, CC_COMMA, CC_DIGIT, CC_DOLLAR, CC_DOT, CC_EQ, CC_GT, CC_ID, CC_KYWD, CC_LP, CC_LT, CC_MINUS, CC_NUL, CC_PERCENT, CC_PIPE, CC_PLUS, CC_QUOTE, CC_QUOTE2, CC_RP, CC_SEMI, CC_SLASH, CC_SPACE, CC_STAR, CC_TILDA, CC_VARALPHA, CC_VARNUM, CC_X, deliberate_fall_through, IdChar, keywordCode(), sqlite3Isdigit, sqlite3Isspace, sqlite3Isxdigit, testcase, TK_BITAND, TK_BITNOT, TK_BITOR, TK_BLOB, TK_COMMA, TK_CONCAT, TK_DOT, TK_EQ, TK_FLOAT, TK_GE, TK_GT, TK_ID, TK_ILLEGAL, TK_INTEGER, TK_LE, TK_LP, TK_LSHIFT, TK_LT, TK_MINUS, TK_NE, TK_PLUS, TK_REM, TK_RP, TK_RSHIFT, TK_SEMI, TK_SLASH, TK_SPACE, TK_STAR, TK_STRING, and TK_VARIABLE.

Referenced by findNextHostParameter(), getToken(), and sqlite3RunParser().

◆ sqlite3GetUInt32()

SQLITE_PRIVATE int sqlite3GetUInt32	(	const char *	z,
		u32 *	pI )

Definition at line 32052 of file sqlite3.c.

                                                           {
  u64 v = 0;
  int i;
  for(i=0; sqlite3Isdigit(z[i]); i++){
    v = v*10 + z[i] - '0';

References sqlite3Isdigit.

Referenced by sqlite3InitCallback().

◆ sqlite3GetVarint()

SQLITE_PRIVATE u8 sqlite3GetVarint	(	const unsigned char *	p,
		u64 *	v )

Definition at line 32147 of file sqlite3.c.

                                                                  {
  u32 a,b,s;
 
  if( ((signed char*)p)[0]>=0 ){
    *v = *p;
    return 1;
  }
  if( ((signed char*)p)[1]>=0 ){
    *v = ((u32)(p[0]&0x7f)<<7) | p[1];
    return 2;
  }
 
  /* Verify that constants are precomputed correctly */
  assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
  assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
 
  a = ((u32)p[0])<<14;
  b = p[1];
  p += 2;
  a |= *p;
  /* a: p0<<14 | p2 (unmasked) */
  if (!(a&0x80))
  {
    a &= SLOT_2_0;
    b &= 0x7f;
    b = b<<7;
    a |= b;
    *v = a;
    return 3;
  }
 
  /* CSE1 from below */
  a &= SLOT_2_0;
  p++;
  b = b<<14;
  b |= *p;
  /* b: p1<<14 | p3 (unmasked) */
  if (!(b&0x80))
  {
    b &= SLOT_2_0;
    /* moved CSE1 up */
    /* a &= (0x7f<<14)|(0x7f); */
    a = a<<7;
    a |= b;
    *v = a;
    return 4;
  }
 
  /* a: p0<<14 | p2 (masked) */
  /* b: p1<<14 | p3 (unmasked) */
  /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
  /* moved CSE1 up */
  /* a &= (0x7f<<14)|(0x7f); */
  b &= SLOT_2_0;
  s = a;
  /* s: p0<<14 | p2 (masked) */
 
  p++;
  a = a<<14;
  a |= *p;
  /* a: p0<<28 | p2<<14 | p4 (unmasked) */
  if (!(a&0x80))
  {
    /* we can skip these cause they were (effectively) done above
    ** while calculating s */
    /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
    /* b &= (0x7f<<14)|(0x7f); */
    b = b<<7;
    a |= b;
    s = s>>18;
    *v = ((u64)s)<<32 | a;
    return 5;
  }
 
  /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
  s = s<<7;
  s |= b;
  /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
 
  p++;
  b = b<<14;
  b |= *p;
  /* b: p1<<28 | p3<<14 | p5 (unmasked) */
  if (!(b&0x80))
  {
    /* we can skip this cause it was (effectively) done above in calc'ing s */
    /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
    a &= SLOT_2_0;
    a = a<<7;
    a |= b;
    s = s>>18;
    *v = ((u64)s)<<32 | a;
    return 6;
  }
 
  p++;
  a = a<<14;
  a |= *p;
  /* a: p2<<28 | p4<<14 | p6 (unmasked) */
  if (!(a&0x80))
  {
    a &= SLOT_4_2_0;
    b &= SLOT_2_0;
    b = b<<7;
    a |= b;
    s = s>>11;
    *v = ((u64)s)<<32 | a;
    return 7;
  }
 
  /* CSE2 from below */
  a &= SLOT_2_0;
  p++;
  b = b<<14;
  b |= *p;
  /* b: p3<<28 | p5<<14 | p7 (unmasked) */
  if (!(b&0x80))
  {
    b &= SLOT_4_2_0;
    /* moved CSE2 up */
    /* a &= (0x7f<<14)|(0x7f); */
    a = a<<7;
    a |= b;
    s = s>>4;
    *v = ((u64)s)<<32 | a;
    return 8;
  }
 
  p++;
  a = a<<15;
  a |= *p;
  /* a: p4<<29 | p6<<15 | p8 (unmasked) */
 
  /* moved CSE2 up */
  /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
  b &= SLOT_2_0;
  b = b<<8;
  a |= b;
 
  s = s<<4;
  b = p[-4];
  b &= 0x7f;
  b = b>>3;

References s, SLOT_2_0, and SLOT_4_2_0.

Referenced by sqlite3GetVarint32().

◆ sqlite3GetVarint32()

SQLITE_PRIVATE u8 sqlite3GetVarint32	(	const unsigned char *	p,
		u32 *	v )

Definition at line 32308 of file sqlite3.c.

                                                                    {
  u32 a,b;
 
  /* The 1-byte case.  Overwhelmingly the most common.  Handled inline
  ** by the getVarin32() macro */
  a = *p;
  /* a: p0 (unmasked) */
#ifndef getVarint32
  if (!(a&0x80))
  {
    /* Values between 0 and 127 */
    *v = a;
    return 1;
  }
#endif
 
  /* The 2-byte case */
  p++;
  b = *p;
  /* b: p1 (unmasked) */
  if (!(b&0x80))
  {
    /* Values between 128 and 16383 */
    a &= 0x7f;
    a = a<<7;
    *v = a | b;
    return 2;
  }
 
  /* The 3-byte case */
  p++;
  a = a<<14;
  a |= *p;
  /* a: p0<<14 | p2 (unmasked) */
  if (!(a&0x80))
  {
    /* Values between 16384 and 2097151 */
    a &= (0x7f<<14)|(0x7f);
    b &= 0x7f;
    b = b<<7;
    *v = a | b;
    return 3;
  }
 
  /* A 32-bit varint is used to store size information in btrees.
  ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
  ** A 3-byte varint is sufficient, for example, to record the size
  ** of a 1048569-byte BLOB or string.
  **
  ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
  ** rare larger cases can be handled by the slower 64-bit varint
  ** routine.
  */
#if 1
  {
    u64 v64;
    u8 n;
 
    n = sqlite3GetVarint(p-2, &v64);
    assert( n>3 && n<=9 );
    if( (v64 & SQLITE_MAX_U32)!=v64 ){
      *v = 0xffffffff;
    }else{
      *v = (u32)v64;
    }
    return n;
  }
 
#else
  /* For following code (kept for historical record only) shows an
  ** unrolling for the 3- and 4-byte varint cases.  This code is
  ** slightly faster, but it is also larger and much harder to test.
  */
  p++;
  b = b<<14;
  b |= *p;
  /* b: p1<<14 | p3 (unmasked) */
  if (!(b&0x80))
  {
    /* Values between 2097152 and 268435455 */
    b &= (0x7f<<14)|(0x7f);
    a &= (0x7f<<14)|(0x7f);
    a = a<<7;
    *v = a | b;
    return 4;
  }
 
  p++;
  a = a<<14;
  a |= *p;
  /* a: p0<<28 | p2<<14 | p4 (unmasked) */
  if (!(a&0x80))
  {
    /* Values  between 268435456 and 34359738367 */
    a &= SLOT_4_2_0;
    b &= SLOT_4_2_0;
    b = b<<7;
    *v = a | b;
    return 5;
  }
 
  /* We can only reach this point when reading a corrupt database
  ** file.  In that case we are not in any hurry.  Use the (relatively
  ** slow) general-purpose sqlite3GetVarint() routine to extract the
  ** value. */
  {
    u64 v64;
    u8 n;
 
    p -= 4;
    n = sqlite3GetVarint(p, &v64);

References SLOT_4_2_0, sqlite3GetVarint(), and SQLITE_MAX_U32.

Referenced by sqlite3VdbeExec(), and vdbeRecordCompareString().

◆ sqlite3GetVdbe()

SQLITE_PRIVATE Vdbe * sqlite3GetVdbe ( Parse * pParse )

Definition at line 131442 of file sqlite3.c.

                                                  {
  if( pParse->pVdbe ){
    return pParse->pVdbe;
  }
  if( pParse->pToplevel==0

Referenced by analyzeOneTable(), computeLimitRegisters(), destroyRootPage(), fkLookupParent(), fkScanChildren(), loadAnalysis(), multiSelect(), openStatTable(), readsTable(), sqlite3AlterFinishAddColumn(), sqlite3Analyze(), sqlite3CodeRowTriggerDirect(), sqlite3CompleteInsertion(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3EndTransaction(), sqlite3FindInIndex(), sqlite3FinishCoding(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3HaltConstraint(), sqlite3Insert(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3StartTable(), sqlite3Update(), sqlite3Vacuum(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), sqlite3WindowRewrite(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowCodeRangeTest(), windowIfNewPeer(), windowInitAccum(), and xferOptimization().

◆ sqlite3GetVTable()

SQLITE_PRIVATE VTable * sqlite3GetVTable	(	sqlite3 *	db,
		Table *	pTab )

Definition at line 139763 of file sqlite3.c.

References VTable::db, IsVirtual, VTable::pNext, and Table::pVTable.

Referenced by isAuxiliaryVtabOperator(), readsTable(), sqlite3DeleteFrom(), sqlite3FinishCoding(), sqlite3Insert(), sqlite3VtabCallConnect(), sqlite3VtabCallCreate(), sqlite3VtabOverloadFunction(), sqlite3WhereBegin(), tabIsReadOnly(), updateVirtualTable(), and vtabBestIndex().

◆ sqlite3HaltConstraint()

SQLITE_PRIVATE void sqlite3HaltConstraint	(	Parse *	pParse,
		int	errCode,
		int	onError,
		char *	p4,
		i8	p4type,
		u8	p5Errmsg )

Definition at line 115214 of file sqlite3.c.

 {
  Vdbe *v = sqlite3GetVdbe(pParse);
  assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );

References Parse::nested, OE_Abort, OP_Halt, sqlite3GetVdbe(), sqlite3MayAbort(), sqlite3VdbeAddOp4(), and SQLITE_CONSTRAINT.

Referenced by fkLookupParent(), sqlite3ExprCodeTarget(), sqlite3FkDropTable(), and sqlite3GenerateConstraintChecks().

◆ sqlite3HasExplicitNulls()

SQLITE_PRIVATE int sqlite3HasExplicitNulls	(	Parse *	pParse,
		ExprList *	pList )

Definition at line 113841 of file sqlite3.c.

                                                                          {
  if( pList ){
    int i;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].bNulls ){
        u8 sf = pList->a[i].sortFlags;
        sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
            (sf==0 || sf==3) ? "FIRST" : "LAST"
        );

References ExprList::a, ExprList::ExprList_item::bNulls, ExprList::nExpr, ExprList::ExprList_item::sortFlags, and sqlite3ErrorMsg().

Referenced by sqlite3AddPrimaryKey(), sqlite3CreateIndex(), sqlite3Insert(), and sqlite3TriggerInsertStep().

◆ sqlite3HashClear()

SQLITE_PRIVATE void sqlite3HashClear ( Hash * pH )

Definition at line 32912 of file sqlite3.c.

                                              {
  HashElem *elem;         /* For looping over all elements of the table */
 
  assert( pH!=0 );
  elem = pH->first;
  pH->first = 0;
  sqlite3_free(pH->ht);
  pH->ht = 0;
  pH->htsize = 0;
  while( elem ){

Referenced by sqlite3ColumnsFromExprList(), sqlite3LeaveMutexAndCloseZombie(), and sqlite3SchemaClear().

◆ sqlite3HashFind()

SQLITE_PRIVATE void * sqlite3HashFind	(	const Hash *	pH,
		const char *	pKey )

Definition at line 33094 of file sqlite3.c.

Referenced by findCollSeqEntry(), sqlite3BeginTrigger(), sqlite3ColumnsFromExprList(), sqlite3DropTrigger(), sqlite3FindFunction(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3FkReferences(), sqlite3IsShadowTableOf(), sqlite3LocateTable(), sqlite3PragmaVtabRegister(), sqlite3VtabCallConnect(), and sqlite3VtabCallCreate().

◆ sqlite3HashInit()

SQLITE_PRIVATE void sqlite3HashInit ( Hash * pNew )

Definition at line 32900 of file sqlite3.c.

32906 {

References Hash::count, Hash::first, Hash::ht, and Hash::htsize.

Referenced by openDatabase(), sqlite3ColumnsFromExprList(), and sqlite3SchemaClear().

◆ sqlite3HashInsert()

SQLITE_PRIVATE void * sqlite3HashInsert	(	Hash *	pH,
		const char *	pKey,
		void *	pData )

Definition at line 33114 of file sqlite3.c.

                                                                              {
  unsigned int h;       /* the hash of the key modulo hash table size */
  HashElem *elem;       /* Used to loop thru the element list */
  HashElem *new_elem;   /* New element added to the pH */
 
  assert( pH!=0 );
  assert( pKey!=0 );
  elem = findElementWithHash(pH,pKey,&h);
  if( elem->data ){
    void *old_data = elem->data;
    if( data==0 ){
      removeElementGivenHash(pH,elem,h);
    }else{
      elem->data = data;
      elem->pKey = pKey;
    }
    return old_data;
  }
  if( data==0 ) return 0;
  new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) );
  if( new_elem==0 ) return data;
  new_elem->pKey = pKey;
  new_elem->data = data;
  pH->count++;
  if( pH->count>=10 && pH->count > 2*pH->htsize ){
    if( rehash(pH, pH->count*2) ){
      assert( pH->htsize>0 );

References Hash::count, HashElem::data, findElementWithHash(), Hash::ht, Hash::htsize, insertElement(), HashElem::pKey, rehash(), removeElementGivenHash(), sqlite3Malloc(), and strHash().

Referenced by deleteTable(), findCollSeqEntry(), sqlite3ColumnsFromExprList(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3FindFunction(), sqlite3FkDelete(), sqlite3UnlinkAndDeleteIndex(), sqlite3UnlinkAndDeleteTable(), and sqlite3VtabCreateModule().

◆ sqlite3HeaderSizeBtree()

SQLITE_PRIVATE int sqlite3HeaderSizeBtree ( void )

Definition at line 75028 of file sqlite3.c.

Referenced by sqlite3_config().

◆ sqlite3HeaderSizePcache()

SQLITE_PRIVATE int sqlite3HeaderSizePcache ( void )

Definition at line 49720 of file sqlite3.c.

Referenced by sqlite3_config().

◆ sqlite3HeaderSizePcache1()

SQLITE_PRIVATE int sqlite3HeaderSizePcache1 ( void )

Definition at line 50968 of file sqlite3.c.

Referenced by sqlite3_config().

◆ sqlite3HeapNearlyFull()

SQLITE_PRIVATE int sqlite3HeapNearlyFull ( void )

Definition at line 27493 of file sqlite3.c.

References AtomicLoad, and mem0.

Referenced by pcache1UnderMemoryPressure().

◆ sqlite3HexToBlob()

SQLITE_PRIVATE void * sqlite3HexToBlob	(	sqlite3 *	db,
		const char *	z,
		int	n )

Definition at line 32500 of file sqlite3.c.

                                                                        {
  char *zBlob;
  int i;
 
  zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
  n--;
  if( zBlob ){
    for(i=0; i<n; i+=2){

References sqlite3DbMallocRawNN(), and sqlite3HexToInt().

Referenced by sqlite3ExprCodeTarget(), and valueFromExpr().

◆ sqlite3HexToInt()

SQLITE_PRIVATE u8 sqlite3HexToInt ( int h )

Definition at line 32482 of file sqlite3.c.

                                        {
  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
#ifdef SQLITE_ASCII
  h += 9*(1&(h>>6));

Referenced by sqlite3DecOrHexToI64(), sqlite3GetInt32(), sqlite3HexToBlob(), and sqlite3ParseUri().

◆ sqlite3IdListAppend()

SQLITE_PRIVATE IdList * sqlite3IdListAppend	(	Parse *	pParse,
		IdList *	pList,
		Token *	pToken )

Definition at line 114617 of file sqlite3.c.

                                                                                       {
  sqlite3 *db = pParse->db;
  int i;
  if( pList==0 ){
    pList = sqlite3DbMallocZero(db, sizeof(IdList) );
    if( pList==0 ) return 0;
  }
  pList->a = sqlite3ArrayAllocate(
      db,
      pList->a,
      sizeof(pList->a[0]),
      &pList->nId,
      &i
  );
  if( i<0 ){
    sqlite3IdListDelete(db, pList);
    return 0;
  }

References IdList::a, Parse::db, IN_RENAME_OBJECT, IdList::nId, sqlite3ArrayAllocate(), sqlite3DbMallocZero(), sqlite3IdListDelete(), sqlite3NameFromToken(), sqlite3RenameTokenMap(), and IdList::IdList_item::zName.

Referenced by yy_reduce().

◆ sqlite3IdListDelete()

SQLITE_PRIVATE void sqlite3IdListDelete	(	sqlite3 *	db,
		IdList *	pList )

Definition at line 114645 of file sqlite3.c.

                                                                   {
  int i;
  if( pList==0 ) return;

Referenced by flattenSubquery(), sqlite3BeginTrigger(), sqlite3DeleteTriggerStep(), sqlite3ExprListAppendVector(), sqlite3IdListAppend(), sqlite3Insert(), sqlite3SrcListAppendFromTerm(), sqlite3TriggerInsertStep(), and yy_destructor().

◆ sqlite3IdListDup()

SQLITE_PRIVATE IdList * sqlite3IdListDup	(	sqlite3 *	db,
		IdList *	p )

Definition at line 101257 of file sqlite3.c.

                                                               {
  IdList *pNew;
  int i;
  assert( db!=0 );
  if( p==0 ) return 0;
  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
  if( pNew==0 ) return 0;
  pNew->nId = p->nId;
  pNew->a = sqlite3DbMallocRawNN(db, p->nId*sizeof(p->a[0]) );
  if( pNew->a==0 ){
    sqlite3DbFreeNN(db, pNew);
    return 0;
  }
  /* Note that because the size of the allocation for p->a[] is not
  ** necessarily a power of two, sqlite3IdListAppend() may not be called
  ** on the duplicate created by this function. */
  for(i=0; i<p->nId; i++){
    struct IdList_item *pNewItem = &pNew->a[i];

◆ sqlite3IdListIndex()

SQLITE_PRIVATE int sqlite3IdListIndex	(	IdList *	pList,
		const char *	zName )

Definition at line 114659 of file sqlite3.c.

114665 {

114666 int i;

Referenced by checkColumnOverlap(), and selectExpander().

◆ sqlite3IndexAffinityOk()

SQLITE_PRIVATE int sqlite3IndexAffinityOk	(	const Expr *	pExpr,
		char	idx_affinity )

Definition at line 100004 of file sqlite3.c.

                                                                               {
  char aff = comparisonAffinity(pExpr);
  if( aff<SQLITE_AFF_TEXT ){
    return 1;

References comparisonAffinity(), sqlite3IsNumericAffinity, and SQLITE_AFF_TEXT.

Referenced by termCanDriveIndex(), and whereScanNext().

◆ sqlite3IndexAffinityStr()

SQLITE_PRIVATE const char * sqlite3IndexAffinityStr	(	sqlite3 *	db,
		Index *	pIdx )

Definition at line 120619 of file sqlite3.c.

                                                                            {
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      sqlite3OomFault(db);
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      char aff;
      if( x>=0 ){
        aff = pTab->aCol[x].affinity;
      }else if( x==XN_ROWID ){
        aff = SQLITE_AFF_INTEGER;
      }else{
        assert( x==XN_EXPR );
        assert( pIdx->aColExpr!=0 );
        aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
      }
      if( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
      if( aff>SQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC;
      pIdx->zColAff[n] = aff;

References ExprList::a, Table::aCol, Index::aColExpr, Column::affinity, Index::aiColumn, Index::nColumn, ExprList::ExprList_item::pExpr, Index::pTable, sqlite3DbMallocRaw(), sqlite3ExprAffinity(), sqlite3OomFault(), SQLITE_AFF_BLOB, SQLITE_AFF_INTEGER, SQLITE_AFF_NUMERIC, XN_EXPR, XN_ROWID, and Index::zColAff.

Referenced by codeAllEqualityTerms(), fkLookupParent(), sqlite3DeleteFrom(), sqlite3GenerateIndexKey(), sqlite3Pragma(), and sqlite3Update().

◆ sqlite3IndexedByLookup()

SQLITE_PRIVATE int sqlite3IndexedByLookup	(	Parse *	pParse,
		struct SrcList_item *	pFrom )

Definition at line 133892 of file sqlite3.c.

                                                                                    {
  if( pFrom->pTab && pFrom->fg.isIndexedBy ){
    Table *pTab = pFrom->pTab;
    char *zIndexedBy = pFrom->u1.zIndexedBy;
    Index *pIdx;
    for(pIdx=pTab->pIndex;
        pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
        pIdx=pIdx->pNext
    );
    if( !pIdx ){
      sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
      pParse->checkSchema = 1;

References Parse::checkSchema, Table::pIndex, Index::pNext, sqlite3ErrorMsg(), sqlite3StrICmp(), SQLITE_ERROR, SQLITE_OK, and Index::zName.

Referenced by selectExpander(), and sqlite3SrcListLookup().

◆ sqlite3IndexHasDuplicateRootPage()

SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage ( Index * pIndex )

Definition at line 128385 of file sqlite3.c.

128391 {

References Table::pIndex, Index::pNext, Index::pTable, and Index::tnum.

Referenced by sqlite3CreateIndex(), and sqlite3InitCallback().

◆ sqlite3Init()

SQLITE_PRIVATE int sqlite3Init	(	sqlite3 *	db,
		char **	pzErrMsg )

Definition at line 128749 of file sqlite3.c.

                                                            {
  int i, rc;
  int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange);
 
  assert( sqlite3_mutex_held(db->mutex) );
  assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
  assert( db->init.busy==0 );
  ENC(db) = SCHEMA_ENC(db);
  assert( db->nDb>0 );
  /* Do the main schema first */
  if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){
    rc = sqlite3InitOne(db, 0, pzErrMsg, 0);
    if( rc ) return rc;
  }
  /* All other schemas after the main schema. The "temp" schema must be last */
  for(i=db->nDb-1; i>0; i--){
    assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
    if( !DbHasProperty(db, i, DB_SchemaLoaded) ){
      rc = sqlite3InitOne(db, i, pzErrMsg, 0);
      if( rc ) return rc;
    }

References sqlite3::aDb, sqlite3::sqlite3InitInfo::busy, DB_SchemaLoaded, DBFLAG_SchemaChange, DbHasProperty, ENC, sqlite3::init, sqlite3::mDbFlags, sqlite3::mutex, sqlite3::nDb, Db::pBt, SCHEMA_ENC, sqlite3_mutex_held(), sqlite3CommitInternalChanges(), sqlite3InitOne(), and SQLITE_OK.

Referenced by attachFunc(), and sqlite3_table_column_metadata().

◆ sqlite3InitCallback()

SQLITE_PRIVATE int sqlite3InitCallback	(	void *	pInit,
		int	argc,
		char **	argv,
		char **	NotUsed )

Definition at line 128419 of file sqlite3.c.

                                                                                          {
  InitData *pData = (InitData*)pInit;
  sqlite3 *db = pData->db;
  int iDb = pData->iDb;
 
  assert( argc==5 );
  UNUSED_PARAMETER2(NotUsed, argc);
  assert( sqlite3_mutex_held(db->mutex) );
  db->mDbFlags |= DBFLAG_EncodingFixed;
  pData->nInitRow++;
  if( db->mallocFailed ){
    corruptSchema(pData, argv[1], 0);
    return 1;
  }
 
  assert( iDb>=0 && iDb<db->nDb );
  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
  if( argv[3]==0 ){
    corruptSchema(pData, argv[1], 0);
  }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){
    /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
    ** But because db->init.busy is set to 1, no VDBE code is generated
    ** or executed.  All the parser does is build the internal data
    ** structures that describe the table, index, or view.
    */
    int rc;
    u8 saved_iDb = db->init.iDb;
    sqlite3_stmt *pStmt;
    TESTONLY(int rcp);            /* Return code from sqlite3_prepare() */
 
    assert( db->init.busy );
    db->init.iDb = iDb;
    if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0
     || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
    ){
      if( sqlite3Config.bExtraSchemaChecks ){
        corruptSchema(pData, argv[1], "invalid rootpage");
      }
    }
    db->init.orphanTrigger = 0;
    db->init.azInit = argv;
    pStmt = 0;
    TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
    rc = db->errCode;
    assert( (rc&0xFF)==(rcp&0xFF) );
    db->init.iDb = saved_iDb;
    /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
    if( SQLITE_OK!=rc ){
      if( db->init.orphanTrigger ){
        assert( iDb==1 );
      }else{
        if( rc > pData->rc ) pData->rc = rc;
        if( rc==SQLITE_NOMEM ){
          sqlite3OomFault(db);
        }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
          corruptSchema(pData, argv[1], sqlite3_errmsg(db));
        }
      }
    }
    sqlite3_finalize(pStmt);
  }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){
    corruptSchema(pData, argv[1], 0);
  }else{
    /* If the SQL column is blank it means this is an index that
    ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
    ** constraint for a CREATE TABLE.  The index should have already
    ** been created when we processed the CREATE TABLE.  All we have
    ** to do here is record the root page number for that index.
    */
    Index *pIndex;
    pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
    if( pIndex==0 ){
      corruptSchema(pData, argv[1], "orphan index");
    }else
    if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
     || pIndex->tnum<2
     || pIndex->tnum>pData->mxPage
     || sqlite3IndexHasDuplicateRootPage(pIndex)
    ){
      if( sqlite3Config.bExtraSchemaChecks ){

References sqlite3::aDb, sqlite3::sqlite3InitInfo::azInit, Sqlite3Config::bExtraSchemaChecks, sqlite3::sqlite3InitInfo::busy, corruptSchema(), InitData::db, DBFLAG_EncodingFixed, sqlite3::errCode, sqlite3::sqlite3InitInfo::iDb, InitData::iDb, sqlite3::init, sqlite3::mallocFailed, sqlite3::mDbFlags, sqlite3::mutex, InitData::mxPage, sqlite3::sqlite3InitInfo::newTnum, InitData::nInitRow, sqlite3::sqlite3InitInfo::orphanTrigger, InitData::rc, sqlite3_errmsg(), sqlite3_finalize(), sqlite3_mutex_held(), sqlite3_strnicmp(), sqlite3Config, sqlite3FindIndex(), sqlite3GetUInt32(), sqlite3IndexHasDuplicateRootPage(), sqlite3OomFault(), sqlite3Prepare(), SQLITE_INTERRUPT, SQLITE_LOCKED, SQLITE_NOMEM, SQLITE_OK, TESTONLY, Index::tnum, UNUSED_PARAMETER2, and Db::zDbSName.

Referenced by sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3InitOne()

SQLITE_PRIVATE int sqlite3InitOne	(	sqlite3 *	db,
		int	iDb,
		char **	pzErrMsg,
		u32	mFlags )

Definition at line 128514 of file sqlite3.c.

                                                                                    {
  int rc;
  int i;
#ifndef SQLITE_OMIT_DEPRECATED
  int size;
#endif
  Db *pDb;
  char const *azArg[6];
  int meta[5];
  InitData initData;
  const char *zSchemaTabName;
  int openedTransaction = 0;
  int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
 
  assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pSchema );
  assert( sqlite3_mutex_held(db->mutex) );
  assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
 
  db->init.busy = 1;
 
  /* Construct the in-memory representation schema tables (sqlite_schema or
  ** sqlite_temp_schema) by invoking the parser directly.  The appropriate
  ** table name will be inserted automatically by the parser so we can just
  ** use the abbreviation "x" here.  The parser will also automatically tag
  ** the schema table as read-only. */
  azArg[0] = "table";
  azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
  azArg[2] = azArg[1];
  azArg[3] = "1";
  azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text,"
                            "rootpage int,sql text)";
  azArg[5] = 0;
  initData.db = db;
  initData.iDb = iDb;
  initData.rc = SQLITE_OK;
  initData.pzErrMsg = pzErrMsg;
  initData.mInitFlags = mFlags;
  initData.nInitRow = 0;
  initData.mxPage = 0;
  sqlite3InitCallback(&initData, 5, (char **)azArg, 0);
  db->mDbFlags &= mask;
  if( initData.rc ){
    rc = initData.rc;
    goto error_out;
  }
 
  /* Create a cursor to hold the database open
  */
  pDb = &db->aDb[iDb];
  if( pDb->pBt==0 ){
    assert( iDb==1 );
    DbSetProperty(db, 1, DB_SchemaLoaded);
    rc = SQLITE_OK;
    goto error_out;
  }
 
  /* If there is not already a read-only (or read-write) transaction opened
  ** on the b-tree database, open one now. If a transaction is opened, it
  ** will be closed before this function returns.  */
  sqlite3BtreeEnter(pDb->pBt);
  if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
    rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
    if( rc!=SQLITE_OK ){
      sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc));
      goto initone_error_out;
    }
    openedTransaction = 1;
  }
 
  /* Get the database meta information.
  **
  ** Meta values are as follows:
  **    meta[0]   Schema cookie.  Changes with each schema change.
  **    meta[1]   File format of schema layer.
  **    meta[2]   Size of the page cache.
  **    meta[3]   Largest rootpage (auto/incr_vacuum mode)
  **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
  **    meta[5]   User version
  **    meta[6]   Incremental vacuum mode
  **    meta[7]   unused
  **    meta[8]   unused
  **    meta[9]   unused
  **
  ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
  ** the possible values of meta[4].
  */
  for(i=0; i<ArraySize(meta); i++){
    sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
  }
  if( (db->flags & SQLITE_ResetDatabase)!=0 ){
    memset(meta, 0, sizeof(meta));
  }
  pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
 
  /* If opening a non-empty database, check the text encoding. For the
  ** main database, set sqlite3.enc to the encoding of the main database.
  ** For an attached db, it is an error if the encoding is not the same
  ** as sqlite3.enc.
  */
  if( meta[BTREE_TEXT_ENCODING-1] ){  /* text encoding */
    if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
      u8 encoding;
#ifndef SQLITE_OMIT_UTF16
      /* If opening the main database, set ENC(db). */
      encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
      if( encoding==0 ) encoding = SQLITE_UTF8;
#else
      encoding = SQLITE_UTF8;
#endif
      sqlite3SetTextEncoding(db, encoding);
    }else{
      /* If opening an attached database, the encoding much match ENC(db) */
      if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){
        sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
            " text encoding as main database");
        rc = SQLITE_ERROR;
        goto initone_error_out;
      }
    }
  }
  pDb->pSchema->enc = ENC(db);
 
  if( pDb->pSchema->cache_size==0 ){
#ifndef SQLITE_OMIT_DEPRECATED
    size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
    if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
    pDb->pSchema->cache_size = size;
#else
    pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
#endif
    sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
  }
 
  /*
  ** file_format==1    Version 3.0.0.
  ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN
  ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults
  ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants
  */
  pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
  if( pDb->pSchema->file_format==0 ){
    pDb->pSchema->file_format = 1;
  }
  if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
    sqlite3SetString(pzErrMsg, db, "unsupported file format");
    rc = SQLITE_ERROR;
    goto initone_error_out;
  }
 
  /* Ticket #2804:  When we open a database in the newer file format,
  ** clear the legacy_file_format pragma flag so that a VACUUM will
  ** not downgrade the database and thus invalidate any descending
  ** indices that the user might have created.
  */
  if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
    db->flags &= ~(u64)SQLITE_LegacyFileFmt;
  }
 
  /* Read the schema information out of the schema tables
  */
  assert( db->init.busy );
  initData.mxPage = sqlite3BtreeLastPage(pDb->pBt);
  {
    char *zSql;
    zSql = sqlite3MPrintf(db,
        "SELECT*FROM\"%w\".%s ORDER BY rowid",
        db->aDb[iDb].zDbSName, zSchemaTabName);
#ifndef SQLITE_OMIT_AUTHORIZATION
    {
      sqlite3_xauth xAuth;
      xAuth = db->xAuth;
      db->xAuth = 0;
#endif
      rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
#ifndef SQLITE_OMIT_AUTHORIZATION
      db->xAuth = xAuth;
    }
#endif
    if( rc==SQLITE_OK ) rc = initData.rc;
    sqlite3DbFree(db, zSql);
#ifndef SQLITE_OMIT_ANALYZE
    if( rc==SQLITE_OK ){
      sqlite3AnalysisLoad(db, iDb);
    }
#endif
  }
  if( db->mallocFailed ){
    rc = SQLITE_NOMEM_BKPT;
    sqlite3ResetAllSchemasOfConnection(db);
  }
  if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){
    /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider
    ** the schema loaded, even if errors occurred. In this situation the
    ** current sqlite3_prepare() operation will fail, but the following one
    ** will attempt to compile the supplied statement against whatever subset
    ** of the schema was loaded before the error occurred. The primary
    ** purpose of this is to allow access to the sqlite_schema table
    ** even when its contents have been corrupted.
    */
    DbSetProperty(db, iDb, DB_SchemaLoaded);
    rc = SQLITE_OK;
  }
 
  /* Jump here for an error that occurs after successfully allocating
  ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
  ** before that point, jump to error_out.
  */
initone_error_out:
  if( openedTransaction ){
    sqlite3BtreeCommit(pDb->pBt);
  }
  sqlite3BtreeLeave(pDb->pBt);
 
error_out:
  if( rc ){
    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
      sqlite3OomFault(db);

References sqlite3::aDb, ArraySize, BTREE_DEFAULT_CACHE_SIZE, BTREE_FILE_FORMAT, BTREE_SCHEMA_VERSION, BTREE_TEXT_ENCODING, sqlite3::sqlite3InitInfo::busy, Schema::cache_size, InitData::db, DB_SchemaLoaded, DBFLAG_EncodingFixed, DBFLAG_SchemaKnownOk, DbSetProperty, Schema::enc, ENC, Schema::file_format, sqlite3::flags, InitData::iDb, sqlite3::init, sqlite3::mallocFailed, mask, sqlite3::mDbFlags, InitData::mInitFlags, sqlite3::mutex, InitData::mxPage, InitData::nInitRow, Db::pBt, Db::pSchema, InitData::pzErrMsg, InitData::rc, Schema::schema_cookie, SCHEMA_TABLE, sqlite3_exec(), sqlite3_mutex_held(), sqlite3AbsInt32(), sqlite3AnalysisLoad(), sqlite3BtreeBeginTrans(), sqlite3BtreeCommit(), sqlite3BtreeEnter(), sqlite3BtreeGetMeta(), sqlite3BtreeIsInReadTrans(), sqlite3BtreeLastPage(), sqlite3BtreeLeave(), sqlite3BtreeSetCacheSize(), sqlite3DbFree(), sqlite3ErrStr(), sqlite3InitCallback(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3ResetAllSchemasOfConnection(), sqlite3ResetOneSchema(), sqlite3SetString(), sqlite3SetTextEncoding(), SQLITE_DEFAULT_CACHE_SIZE, SQLITE_ERROR, SQLITE_IOERR_NOMEM, SQLITE_LegacyFileFmt, SQLITE_MAX_FILE_FORMAT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_NoSchemaError, SQLITE_OK, SQLITE_ResetDatabase, SQLITE_UTF8, sqlite3::xAuth, and Db::zDbSName.

Referenced by sqlite3Init(), and sqlite3VdbeExec().

◆ sqlite3InRhsIsConstant()

static int sqlite3InRhsIsConstant ( Expr * pIn )

static

Definition at line 102136 of file sqlite3.c.

                                            {
  Expr *pLHS;
  int res;
  assert( !ExprHasProperty(pIn, EP_xIsSelect) );

References EP_xIsSelect, ExprHasProperty, Expr::pLeft, and sqlite3ExprIsConstant().

Referenced by sqlite3FindInIndex().

◆ sqlite3Insert()

SQLITE_PRIVATE void sqlite3Insert	(	Parse *	pParse,
		SrcList *	pTabList,
		Select *	pSelect,
		IdList *	pColumn,
		int	onError,
		Upsert *	pUpsert )

Definition at line 121167 of file sqlite3.c.

         : loop over rows of intermediate table
**           transfer values form intermediate table into <table>
**         end loop
**      D: cleanup
*/
SQLITE_PRIVATE void sqlite3Insert(
  Parse *pParse,        /* Parser context */
  SrcList *pTabList,    /* Name of table into which we are inserting */
  Select *pSelect,      /* A SELECT statement to use as the data source */
  IdList *pColumn,      /* Column names corresponding to IDLIST, or NULL. */
  int onError,          /* How to handle constraint errors */
  Upsert *pUpsert       /* ON CONFLICT clauses for upsert, or NULL */
){
  sqlite3 *db;          /* The main database structure */
  Table *pTab;          /* The table to insert into.  aka TABLE */
  int i, j;             /* Loop counters */
  Vdbe *v;              /* Generate code into this virtual machine */
  Index *pIdx;          /* For looping over indices of the table */
  int nColumn;          /* Number of columns in the data */
  int nHidden = 0;      /* Number of hidden columns if TABLE is virtual */
  int iDataCur = 0;     /* VDBE cursor that is the main data repository */
  int iIdxCur = 0;      /* First index cursor */
  int ipkColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
  int endOfLoop;        /* Label for the end of the insertion loop */
  int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
  int addrInsTop = 0;   /* Jump to label "D" */
  int addrCont = 0;     /* Top of insert loop. Label "C" in templates 3 and 4 */
  SelectDest dest;      /* Destination for SELECT on rhs of INSERT */
  int iDb;              /* Index of database holding TABLE */
  u8 useTempTable = 0;  /* Store SELECT results in intermediate table */
  u8 appendFlag = 0;    /* True if the insert is likely to be an append */
  u8 withoutRowid;      /* 0 for normal table.  1 for WITHOUT ROWID table */
  u8 bIdListInOrder;    /* True if IDLIST is in table order */
  ExprList *pList = 0;  /* List of VALUES() to be inserted  */
  int iRegStore;        /* Register in which to store next column */
 
  /* Register allocations */
  int regFromSelect = 0;/* Base register for data coming from SELECT */
  int regAutoinc = 0;   /* Register holding the AUTOINCREMENT counter */
  int regRowCount = 0;  /* Memory cell used for the row counter */
  int regIns;           /* Block of regs holding rowid+data being inserted */
  int regRowid;         /* registers holding insert rowid */
  int regData;          /* register holding first column to insert */
  int *aRegIdx = 0;     /* One register allocated to each index */
 
#ifndef SQLITE_OMIT_TRIGGER
  int isView;                 /* True if attempting to insert into a view */
  Trigger *pTrigger;          /* List of triggers on pTab, if required */
  int tmask;                  /* Mask of trigger times */
#endif
 
  db = pParse->db;
  if( pParse->nErr || db->mallocFailed ){
    goto insert_cleanup;
  }
  dest.iSDParm = 0;  /* Suppress a harmless compiler warning */
 
  /* If the Select object is really just a simple VALUES() list with a
  ** single row (the common case) then keep that one row of values
  ** and discard the other (unused) parts of the pSelect object
  */
  if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
    pList = pSelect->pEList;
    pSelect->pEList = 0;
    sqlite3SelectDelete(db, pSelect);
    pSelect = 0;
  }
 
  /* Locate the table into which we will be inserting new information.
  */
  assert( pTabList->nSrc==1 );
  pTab = sqlite3SrcListLookup(pParse, pTabList);
  if( pTab==0 ){
    goto insert_cleanup;
  }
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb<db->nDb );
  if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
                       db->aDb[iDb].zDbSName) ){
    goto insert_cleanup;
  }
  withoutRowid = !HasRowid(pTab);
 
  /* Figure out if we have any triggers and if the table being
  ** inserted into is a view
  */
#ifndef SQLITE_OMIT_TRIGGER
  pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
  isView = pTab->pSelect!=0;
#else
# define pTrigger 0
# define tmask 0
# define isView 0
#endif
#ifdef SQLITE_OMIT_VIEW
# undef isView
# define isView 0
#endif
  assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
 
  /* If pTab is really a view, make sure it has been initialized.
  ** ViewGetColumnNames() is a no-op if pTab is not a view.
  */
  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
    goto insert_cleanup;
  }
 
  /* Cannot insert into a read-only table.
  */
  if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
    goto insert_cleanup;
  }
 
  /* Allocate a VDBE
  */
  v = sqlite3GetVdbe(pParse);
  if( v==0 ) goto insert_cleanup;
  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
  sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
 
#ifndef SQLITE_OMIT_XFER_OPT
  /* If the statement is of the form
  **
  **       INSERT INTO <table1> SELECT * FROM <table2>;
  **
  ** Then special optimizations can be applied that make the transfer
  ** very fast and which reduce fragmentation of indices.
  **
  ** This is the 2nd template.
  */
  if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
    assert( !pTrigger );
    assert( pList==0 );
    goto insert_end;
  }
#endif /* SQLITE_OMIT_XFER_OPT */
 
  /* If this is an AUTOINCREMENT table, look up the sequence number in the
  ** sqlite_sequence table and store it in memory cell regAutoinc.
  */
  regAutoinc = autoIncBegin(pParse, iDb, pTab);
 
  /* Allocate a block registers to hold the rowid and the values
  ** for all columns of the new row.
  */
  regRowid = regIns = pParse->nMem+1;
  pParse->nMem += pTab->nCol + 1;
  if( IsVirtual(pTab) ){
    regRowid++;
    pParse->nMem++;
  }
  regData = regRowid+1;
 
  /* If the INSERT statement included an IDLIST term, then make sure
  ** all elements of the IDLIST really are columns of the table and
  ** remember the column indices.
  **
  ** If the table has an INTEGER PRIMARY KEY column and that column
  ** is named in the IDLIST, then record in the ipkColumn variable
  ** the index into IDLIST of the primary key column.  ipkColumn is
  ** the index of the primary key as it appears in IDLIST, not as
  ** is appears in the original table.  (The index of the INTEGER
  ** PRIMARY KEY in the original table is pTab->iPKey.)  After this
  ** loop, if ipkColumn==(-1), that means that integer primary key
  ** is unspecified, and hence the table is either WITHOUT ROWID or
  ** it will automatically generated an integer primary key.
  **
  ** bIdListInOrder is true if the columns in IDLIST are in storage
  ** order.  This enables an optimization that avoids shuffling the
  ** columns into storage order.  False negatives are harmless,
  ** but false positives will cause database corruption.
  */
  bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
  if( pColumn ){
    for(i=0; i<pColumn->nId; i++){
      pColumn->a[i].idx = -1;
    }
    for(i=0; i<pColumn->nId; i++){
      for(j=0; j<pTab->nCol; j++){
        if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
          pColumn->a[i].idx = j;
          if( i!=j ) bIdListInOrder = 0;
          if( j==pTab->iPKey ){
            ipkColumn = i;  assert( !withoutRowid );
          }
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
          if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
            sqlite3ErrorMsg(pParse,
               "cannot INSERT into generated column \"%s\"",
               pTab->aCol[j].zName);
            goto insert_cleanup;
          }
#endif
          break;
        }
      }
      if( j>=pTab->nCol ){
        if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
          ipkColumn = i;
          bIdListInOrder = 0;
        }else{
          sqlite3ErrorMsg(pParse, "table %S has no column named %s",
              pTabList, 0, pColumn->a[i].zName);
          pParse->checkSchema = 1;
          goto insert_cleanup;
        }
      }
    }
  }
 
  /* Figure out how many columns of data are supplied.  If the data
  ** is coming from a SELECT statement, then generate a co-routine that
  ** produces a single row of the SELECT on each invocation.  The
  ** co-routine is the common header to the 3rd and 4th templates.
  */
  if( pSelect ){
    /* Data is coming from a SELECT or from a multi-row VALUES clause.
    ** Generate a co-routine to run the SELECT. */
    int regYield;       /* Register holding co-routine entry-point */
    int addrTop;        /* Top of the co-routine */
    int rc;             /* Result code */
 
    regYield = ++pParse->nMem;
    addrTop = sqlite3VdbeCurrentAddr(v) + 1;
    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
    sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
    dest.iSdst = bIdListInOrder ? regData : 0;
    dest.nSdst = pTab->nCol;
    rc = sqlite3Select(pParse, pSelect, &dest);
    regFromSelect = dest.iSdst;
    if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup;
    sqlite3VdbeEndCoroutine(v, regYield);
    sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
    assert( pSelect->pEList );
    nColumn = pSelect->pEList->nExpr;
 
    /* Set useTempTable to TRUE if the result of the SELECT statement
    ** should be written into a temporary table (template 4).  Set to
    ** FALSE if each output row of the SELECT can be written directly into
    ** the destination table (template 3).
    **
    ** A temp table must be used if the table being updated is also one
    ** of the tables being read by the SELECT statement.  Also use a
    ** temp table in the case of row triggers.
    */
    if( pTrigger || readsTable(pParse, iDb, pTab) ){
      useTempTable = 1;
    }
 
    if( useTempTable ){
      /* Invoke the coroutine to extract information from the SELECT
      ** and add it to a transient table srcTab.  The code generated
      ** here is from the 4th template:
      **
      **      B: open temp table
      **      L: yield X, goto M at EOF
      **         insert row from R..R+n into temp table
      **         goto L
      **      M: ...
      */
      int regRec;          /* Register to hold packed record */
      int regTempRowid;    /* Register to hold temp table ROWID */
      int addrL;           /* Label "L" */
 
      srcTab = pParse->nTab++;
      regRec = sqlite3GetTempReg(pParse);
      regTempRowid = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
      addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
      sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
      sqlite3VdbeGoto(v, addrL);
      sqlite3VdbeJumpHere(v, addrL);
      sqlite3ReleaseTempReg(pParse, regRec);
      sqlite3ReleaseTempReg(pParse, regTempRowid);
    }
  }else{
    /* This is the case if the data for the INSERT is coming from a
    ** single-row VALUES clause
    */
    NameContext sNC;
    memset(&sNC, 0, sizeof(sNC));
    sNC.pParse = pParse;
    srcTab = -1;
    assert( useTempTable==0 );
    if( pList ){
      nColumn = pList->nExpr;
      if( sqlite3ResolveExprListNames(&sNC, pList) ){
        goto insert_cleanup;
      }
    }else{
      nColumn = 0;
    }
  }
 
  /* If there is no IDLIST term but the table has an integer primary
  ** key, the set the ipkColumn variable to the integer primary key
  ** column index in the original table definition.
  */
  if( pColumn==0 && nColumn>0 ){
    ipkColumn = pTab->iPKey;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
      testcase( pTab->tabFlags & TF_HasVirtual );
      testcase( pTab->tabFlags & TF_HasStored );
      for(i=ipkColumn-1; i>=0; i--){
        if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
          testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
          testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
          ipkColumn--;
        }
      }
    }
#endif
  }
 
  /* Make sure the number of columns in the source data matches the number
  ** of columns to be inserted into the table.
  */
  for(i=0; i<pTab->nCol; i++){
    if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
  }
  if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
    sqlite3ErrorMsg(pParse,
       "table %S has %d columns but %d values were supplied",
       pTabList, 0, pTab->nCol-nHidden, nColumn);
    goto insert_cleanup;
  }
  if( pColumn!=0 && nColumn!=pColumn->nId ){
    sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
    goto insert_cleanup;
  }
 
  /* Initialize the count of rows to be inserted
  */
  if( (db->flags & SQLITE_CountRows)!=0
   && !pParse->nested
   && !pParse->pTriggerTab
  ){
    regRowCount = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
  }
 
  /* If this is not a view, open the table and and all indices */
  if( !isView ){
    int nIdx;
    nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
                                      &iDataCur, &iIdxCur);
    aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2));
    if( aRegIdx==0 ){
      goto insert_cleanup;
    }
    for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
      assert( pIdx );
      aRegIdx[i] = ++pParse->nMem;
      pParse->nMem += pIdx->nColumn;
    }
    aRegIdx[i] = ++pParse->nMem;  /* Register to store the table record */
  }
#ifndef SQLITE_OMIT_UPSERT
  if( pUpsert ){
    if( IsVirtual(pTab) ){
      sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
              pTab->zName);
      goto insert_cleanup;
    }
    if( pTab->pSelect ){
      sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
      goto insert_cleanup;
    }
    if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
      goto insert_cleanup;
    }
    pTabList->a[0].iCursor = iDataCur;
    pUpsert->pUpsertSrc = pTabList;
    pUpsert->regData = regData;
    pUpsert->iDataCur = iDataCur;
    pUpsert->iIdxCur = iIdxCur;
    if( pUpsert->pUpsertTarget ){
      sqlite3UpsertAnalyzeTarget(pParse, pTabList, pUpsert);
    }
  }
#endif
 
 
  /* This is the top of the main insertion loop */
  if( useTempTable ){
    /* This block codes the top of loop only.  The complete loop is the
    ** following pseudocode (template 4):
    **
    **         rewind temp table, if empty goto D
    **      C: loop over rows of intermediate table
    **           transfer values form intermediate table into <table>
    **         end loop
    **      D: ...
    */
    addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
    addrCont = sqlite3VdbeCurrentAddr(v);
  }else if( pSelect ){
    /* This block codes the top of loop only.  The complete loop is the
    ** following pseudocode (template 3):
    **
    **      C: yield X, at EOF goto D
    **         insert the select result into <table> from R..R+n
    **         goto C
    **      D: ...
    */
    sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
    addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
    VdbeCoverage(v);
    if( ipkColumn>=0 ){
      /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
      ** SELECT, go ahead and copy the value into the rowid slot now, so that
      ** the value does not get overwritten by a NULL at tag-20191021-002. */
      sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
    }
  }
 
  /* Compute data for ordinary columns of the new entry.  Values
  ** are written in storage order into registers starting with regData.
  ** Only ordinary columns are computed in this loop. The rowid
  ** (if there is one) is computed later and generated columns are
  ** computed after the rowid since they might depend on the value
  ** of the rowid.
  */
  nHidden = 0;
  iRegStore = regData;  assert( regData==regRowid+1 );
  for(i=0; i<pTab->nCol; i++, iRegStore++){
    int k;
    u32 colFlags;
    assert( i>=nHidden );
    if( i==pTab->iPKey ){
      /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
      ** using the rowid. So put a NULL in the IPK slot of the record to avoid
      ** using excess space.  The file format definition requires this extra
      ** NULL - we cannot optimize further by skipping the column completely */
      sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
      continue;
    }
    if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
      nHidden++;
      if( (colFlags & COLFLAG_VIRTUAL)!=0 ){
        /* Virtual columns do not participate in OP_MakeRecord.  So back up
        ** iRegStore by one slot to compensate for the iRegStore++ in the
        ** outer for() loop */
        iRegStore--;
        continue;
      }else if( (colFlags & COLFLAG_STORED)!=0 ){
        /* Stored columns are computed later.  But if there are BEFORE
        ** triggers, the slots used for stored columns will be OP_Copy-ed
        ** to a second block of registers, so the register needs to be
        ** initialized to NULL to avoid an uninitialized register read */
        if( tmask & TRIGGER_BEFORE ){
          sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
        }
        continue;
      }else if( pColumn==0 ){
        /* Hidden columns that are not explicitly named in the INSERT
        ** get there default value */
        sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
        continue;
      }
    }
    if( pColumn ){
      for(j=0; j<pColumn->nId && pColumn->a[j].idx!=i; j++){}
      if( j>=pColumn->nId ){
        /* A column not named in the insert column list gets its
        ** default value */
        sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
        continue;
      }
      k = j;
    }else if( nColumn==0 ){
      /* This is INSERT INTO ... DEFAULT VALUES.  Load the default value. */
      sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
      continue;
    }else{
      k = i - nHidden;
    }
 
    if( useTempTable ){
      sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore);
    }else if( pSelect ){
      if( regFromSelect!=regData ){
        sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore);
      }
    }else{
      sqlite3ExprCode(pParse, pList->a[k].pExpr, iRegStore);
    }
  }
 
 
  /* Run the BEFORE and INSTEAD OF triggers, if there are any
  */
  endOfLoop = sqlite3VdbeMakeLabel(pParse);
  if( tmask & TRIGGER_BEFORE ){
    int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
 
    /* build the NEW.* reference row.  Note that if there is an INTEGER
    ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
    ** translated into a unique ID for the row.  But on a BEFORE trigger,
    ** we do not know what the unique ID will be (because the insert has
    ** not happened yet) so we substitute a rowid of -1
    */
    if( ipkColumn<0 ){
      sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
    }else{
      int addr1;
      assert( !withoutRowid );
      if( useTempTable ){
        sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
      }else{
        assert( pSelect==0 );  /* Otherwise useTempTable is true */
        sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
      }
      addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
      sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
      sqlite3VdbeJumpHere(v, addr1);
      sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
    }
 
    /* Cannot have triggers on a virtual table. If it were possible,
    ** this block would have to account for hidden column.
    */
    assert( !IsVirtual(pTab) );
 
    /* Copy the new data already generated. */
    assert( pTab->nNVCol>0 );
    sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
 
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    /* Compute the new value for generated columns after all other
    ** columns have already been computed.  This must be done after
    ** computing the ROWID in case one of the generated columns
    ** refers to the ROWID. */
    if( pTab->tabFlags & TF_HasGenerated ){
      testcase( pTab->tabFlags & TF_HasVirtual );
      testcase( pTab->tabFlags & TF_HasStored );
      sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
    }
#endif
 
    /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
    ** do not attempt any conversions before assembling the record.
    ** If this is a real table, attempt conversions as required by the
    ** table column affinities.
    */
    if( !isView ){
      sqlite3TableAffinity(v, pTab, regCols+1);
    }
 
    /* Fire BEFORE or INSTEAD OF triggers */
    sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
        pTab, regCols-pTab->nCol-1, onError, endOfLoop);
 
    sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
  }
 
  if( !isView ){
    if( IsVirtual(pTab) ){
      /* The row that the VUpdate opcode will delete: none */
      sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
    }
    if( ipkColumn>=0 ){
      /* Compute the new rowid */
      if( useTempTable ){
        sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
      }else if( pSelect ){
        /* Rowid already initialized at tag-20191021-001 */
      }else{
        Expr *pIpk = pList->a[ipkColumn].pExpr;
        if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
          sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
          appendFlag = 1;
        }else{
          sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
        }
      }
      /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
      ** to generate a unique primary key value.
      */
      if( !appendFlag ){
        int addr1;
        if( !IsVirtual(pTab) ){
          addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
          sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
          sqlite3VdbeJumpHere(v, addr1);
        }else{
          addr1 = sqlite3VdbeCurrentAddr(v);
          sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v);
        }
        sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
      }
    }else if( IsVirtual(pTab) || withoutRowid ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
    }else{
      sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
      appendFlag = 1;
    }
    autoIncStep(pParse, regAutoinc, regRowid);
 
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    /* Compute the new value for generated columns after all other
    ** columns have already been computed.  This must be done after
    ** computing the ROWID in case one of the generated columns
    ** is derived from the INTEGER PRIMARY KEY. */
    if( pTab->tabFlags & TF_HasGenerated ){
      sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
    }
#endif
 
    /* Generate code to check constraints and generate index keys and
    ** do the insertion.
    */
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( IsVirtual(pTab) ){
      const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
      sqlite3VtabMakeWritable(pParse, pTab);
      sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
      sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
      sqlite3MayAbort(pParse);
    }else
#endif
    {
      int isReplace;    /* Set to true if constraints may cause a replace */
      int bUseSeek;     /* True to use OPFLAG_SEEKRESULT */
      sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
          regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert
      );
      sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
 
      /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
      ** constraints or (b) there are no triggers and this table is not a
      ** parent table in a foreign key constraint. It is safe to set the
      ** flag in the second case as if any REPLACE constraint is hit, an
      ** OP_Delete or OP_IdxDelete instruction will be executed on each
      ** cursor that is disturbed. And these instructions both clear the
      ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
      ** functionality.  */
      bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v));
      sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
          regIns, aRegIdx, 0, appendFlag, bUseSeek
      );
    }
  }
 
  /* Update the count of rows that are inserted
  */
  if( regRowCount ){
    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
  }
 
  if( pTrigger ){
    /* Code AFTER triggers */
    sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
        pTab, regData-2-pTab->nCol, onError, endOfLoop);
  }
 
  /* The bottom of the main insertion loop, if the data source
  ** is a SELECT statement.
  */
  sqlite3VdbeResolveLabel(v, endOfLoop);
  if( useTempTable ){
    sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addrInsTop);
    sqlite3VdbeAddOp1(v, OP_Close, srcTab);
  }else if( pSelect ){
    sqlite3VdbeGoto(v, addrCont);
#ifdef SQLITE_DEBUG
    /* If we are jumping back to an OP_Yield that is preceded by an
    ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
    ** OP_ReleaseReg will be included in the loop. */
    if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
      assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
      sqlite3VdbeChangeP5(v, 1);
    }
#endif
    sqlite3VdbeJumpHere(v, addrInsTop);
  }
 
insert_end:
  /* Update the sqlite_sequence table by storing the content of the
  ** maximum rowid counter values recorded while inserting into
  ** autoincrement tables.
  */
  if( pParse->nested==0 && pParse->pTriggerTab==0 ){
    sqlite3AutoincrementEnd(pParse);
  }
 
  /*
  ** Return the number of rows inserted. If this routine is
  ** generating code because of a call to sqlite3NestedParse(), do not
  ** invoke the callback function.
  */
  if( regRowCount ){
    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
    sqlite3VdbeSetNumCols(v, 1);
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
  }
 
insert_cleanup:
  sqlite3SrcListDelete(db, pTabList);

References ExprList::a, IdList::a, SrcList::a, Table::aCol, sqlite3::aDb, autoIncBegin(), autoIncStep(), Parse::checkSchema, COLFLAG_GENERATED, COLFLAG_NOINSERT, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, COLNAME_NAME, Parse::db, sqlite3::flags, HasRowid, SrcList::SrcList_item::iCursor, Upsert::iDataCur, IdList::IdList_item::idx, Upsert::iIdxCur, Table::iPKey, SelectDest::iSDParm, SelectDest::iSdst, IsVirtual, sqlite3::mallocFailed, Table::nCol, Index::nColumn, Parse::nErr, Parse::nested, ExprList::nExpr, IdList::nId, Parse::nMem, Table::nNVCol, SelectDest::nSdst, SrcList::nSrc, Parse::nTab, OE_Abort, OE_Default, Expr::op, OP_AddImm, OP_Close, OP_Column, OP_Copy, OP_InitCoroutine, OP_Insert, OP_Integer, OP_IsNull, OP_MakeRecord, OP_MustBeInt, OP_NewRowid, OP_Next, OP_NotNull, OP_Null, OP_OpenEphemeral, OP_OpenWrite, OP_ReleaseReg, OP_ResultRow, OP_Rewind, OP_SCopy, OP_SoftNull, OP_VUpdate, OP_Yield, P4_VTAB, Column::pDflt, Select::pEList, ExprList::ExprList_item::pExpr, Table::pIndex, Index::pNext, NameContext::pParse, Select::pPrior, Table::pSchema, Table::pSelect, Parse::pTriggerTab, Upsert::pUpsertSrc, Upsert::pUpsertTarget, readsTable(), Upsert::regData, Select::selFlags, SF_Values, sqlite3AuthCheck(), sqlite3AutoincrementEnd(), sqlite3BeginWriteOperation(), sqlite3CodeRowTrigger(), sqlite3CompleteInsertion(), sqlite3ComputeGeneratedColumns(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3ErrorMsg(), sqlite3ExprCode(), sqlite3ExprCodeFactorable(), sqlite3ExprListDelete(), sqlite3FkCheck(), sqlite3GenerateConstraintChecks(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3GetVTable(), sqlite3HasExplicitNulls(), sqlite3IdListDelete(), sqlite3IsReadOnly(), sqlite3IsRowid(), sqlite3MayAbort(), sqlite3OpenTableAndIndices(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3ResolveExprListNames(), sqlite3SchemaToIndex(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectDestInit(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3StrICmp(), sqlite3TableAffinity(), sqlite3TriggersExist(), sqlite3UpsertAnalyzeTarget(), sqlite3UpsertDelete(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeCountChanges(), sqlite3VdbeCurrentAddr(), sqlite3VdbeEndCoroutine(), sqlite3VdbeGetOp(), sqlite3VdbeGoto(), sqlite3VdbeHasSubProgram(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeReleaseRegisters, sqlite3VdbeResolveLabel(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), sqlite3ViewGetColumnNames(), sqlite3VtabMakeWritable(), SQLITE_CountRows, SQLITE_INSERT, SQLITE_STATIC, SRT_Coroutine, Table::tabFlags, testcase, TF_HasGenerated, TF_HasStored, TF_HasVirtual, TF_OOOHidden, TK_INSERT, TK_NULL, TRIGGER_AFTER, TRIGGER_BEFORE, VdbeCoverage, xferOptimization(), Db::zDbSName, Column::zName, Table::zName, and IdList::IdList_item::zName.

Referenced by yy_reduce().

◆ sqlite3InsertBuiltinFuncs()

SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs	(	FuncDef *	aDef,
		int	nDef )

Definition at line 115886 of file sqlite3.c.

 {
  int i;
  for(i=0; i<nDef; i++){
    FuncDef *pOther;
    const char *zName = aDef[i].zName;
    int nName = sqlite3Strlen30(zName);
    int h = SQLITE_FUNC_HASH(zName[0], nName);
    assert( zName[0]>='a' && zName[0]<='z' );
    pOther = sqlite3FunctionSearch(h, zName);
    if( pOther ){
      assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
      aDef[i].pNext = pOther->pNext;
      pOther->pNext = &aDef[i];
    }else{

Referenced by sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterDateTimeFunctions().

◆ sqlite3Int64ToText()

SQLITE_PRIVATE void sqlite3Int64ToText	(	i64	v,
		char *	zOut )

Definition at line 31783 of file sqlite3.c.

                                                         {
  int i;
  u64 x;
  char zTemp[22];
  if( v<0 ){
    x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v;
  }else{
    x = v;
  }
  i = sizeof(zTemp)-2;
  zTemp[sizeof(zTemp)-1] = 0;
  do{

References SMALLEST_INT64.

Referenced by strftimeFunc(), and vdbeMemRenderNum().

◆ sqlite3IntFloatCompare()

static int sqlite3IntFloatCompare	(	i64	i,
		double	r )

static

Definition at line 82026 of file sqlite3.c.

                                                  {
  if( sizeof(LONGDOUBLE_TYPE)>8 ){
    LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
    if( x<r ) return -1;
    if( x>r ) return +1;
    return 0;
  }else{
    i64 y;
    double s;
    if( r<-9223372036854775808.0 ) return +1;
    if( r>=9223372036854775808.0 ) return -1;
    y = (i64)r;
    if( i<y ) return -1;
    if( i>y ) return +1;

References LONGDOUBLE_TYPE, and s.

Referenced by sqlite3MemCompare(), and sqlite3VdbeRecordCompareWithSkip().

◆ sqlite3InvalidFunction()

static void sqlite3InvalidFunction	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 163016 of file sqlite3.c.

 {
  const char *zName = (const char*)sqlite3_user_data(context);
  char *zErr;

References sqlite3_free(), sqlite3_mprintf(), sqlite3_result_error(), sqlite3_user_data(), UNUSED_PARAMETER2, and zName.

Referenced by sqlite3_overload_function().

◆ sqlite3InvokeBusyHandler()

SQLITE_PRIVATE int sqlite3InvokeBusyHandler ( BusyHandler * p )

Definition at line 162661 of file sqlite3.c.

                                                           {
  int rc;
  if( p->xBusyHandler==0 || p->nBusy<0 ) return 0;
  rc = p->xBusyHandler(p->pBusyArg, p->nBusy);
  if( rc==0 ){

References BusyHandler::nBusy, BusyHandler::pBusyArg, and BusyHandler::xBusyHandler.

◆ sqlite3IsBinary()

SQLITE_PRIVATE int sqlite3IsBinary ( const CollSeq * p )

Definition at line 162023 of file sqlite3.c.

Referenced by constInsert(), and termIsEquivalence().

◆ sqlite3IsIdChar()

SQLITE_PRIVATE int sqlite3IsIdChar ( u8 c )

Definition at line 159925 of file sqlite3.c.

Referenced by renameEditSql(), sqlite3_compileoption_used(), and sqlite3RunParser().

◆ sqlite3IsLikeFunction()

SQLITE_PRIVATE int sqlite3IsLikeFunction	(	sqlite3 *	db,
		Expr *	pExpr,
		int *	pIsNocase,
		char *	aWc )

Definition at line 118909 of file sqlite3.c.

                                                                                             {
  FuncDef *pDef;
  int nExpr;
  if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){
    return 0;
  }
  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
  nExpr = pExpr->x.pList->nExpr;
  pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
  if( pDef==0 ) return 0;
#endif
  if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
    return 0;
  }
 
  /* The memcpy() statement assumes that the wildcard characters are
  ** the first three statements in the compareInfo structure.  The
  ** asserts() that follow verify that assumption
  */
  memcpy(aWc, pDef->pUserData, 3);
  assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
  assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
  assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
 
  if( nExpr<3 ){
    aWc[3] = 0;
  }else{
    Expr *pEscape = pExpr->x.pList->a[2].pExpr;
    char *zEscape;
    if( pEscape->op!=TK_STRING ) return 0;
    zEscape = pEscape->u.zToken;
    if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
    if( zEscape[0]==aWc[0] ) return 0;
    if( zEscape[0]==aWc[1] ) return 0;

References ExprList::a, EP_xIsSelect, ExprHasProperty, FuncDef::funcFlags, likeInfoAlt, compareInfo::matchAll, compareInfo::matchOne, compareInfo::matchSet, NEVER, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Expr::pList, FuncDef::pUserData, sqlite3FindFunction(), SQLITE_FUNC_CASE, SQLITE_FUNC_LIKE, SQLITE_UTF8, TK_FUNCTION, TK_STRING, Expr::u, Expr::x, and Expr::zToken.

Referenced by isLikeOrGlob().

◆ sqlite3IsNaN()

SQLITE_PRIVATE int sqlite3IsNaN ( double x )

Definition at line 31244 of file sqlite3.c.

References IsNaN.

Referenced by codeReal(), sqlite3_initialize(), sqlite3_str_vappendf(), sqlite3VdbeExec(), and sqlite3VdbeMemSetDouble().

◆ sqlite3IsReadOnly()

SQLITE_PRIVATE int sqlite3IsReadOnly	(	Parse *	pParse,
		Table *	pTab,
		int	viewOk )

Definition at line 116156 of file sqlite3.c.

                                                                            {
  if( tabIsReadOnly(pParse, pTab) ){
    sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
    return 1;
  }
#ifndef SQLITE_OMIT_VIEW
  if( !viewOk && pTab->pSelect ){

References Table::pSelect, sqlite3ErrorMsg(), tabIsReadOnly(), and Table::zName.

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3IsRowid()

SQLITE_PRIVATE int sqlite3IsRowid ( const char * z )

Definition at line 102059 of file sqlite3.c.

Referenced by lookupName(), sqlite3_table_column_metadata(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3IsShadowTableOf()

SQLITE_PRIVATE int sqlite3IsShadowTableOf	(	sqlite3 *	db,
		Table *	pTab,
		const char *	zName )

Definition at line 112575 of file sqlite3.c.

                                                                                      {
  int nName;                    /* Length of zName */
  Module *pMod;                 /* Module for the virtual table */
 
  if( !IsVirtual(pTab) ) return 0;
  nName = sqlite3Strlen30(pTab->zName);
  if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
  if( zName[nName]!='_' ) return 0;

References sqlite3::aModule, Table::azModuleArg, IsVirtual, sqlite3_module::iVersion, nName, Module::pModule, sqlite3_strnicmp(), sqlite3HashFind(), sqlite3Strlen30(), sqlite3_module::xShadowName, Table::zName, and zName.

Referenced by sqlite3ShadowTableName().

◆ sqlite3IsTrueOrFalse()

SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse ( const char * zIn )

Definition at line 101619 of file sqlite3.c.

References EP_IsFalse, EP_IsTrue, and sqlite3StrICmp().

Referenced by sqlite3ColumnsFromExprList(), and sqlite3ExprIdToTrueFalse().

◆ sqlite3JoinType()

SQLITE_PRIVATE int sqlite3JoinType	(	Parse *	pParse,
		Token *	pA,
		Token *	pB,
		Token *	pC )

Definition at line 129497 of file sqlite3.c.

                                                                                  {
  int jointype = 0;
  Token *apAll[3];
  Token *p;
                             /*   0123456789 123456789 123456789 123 */
  static const char zKeyText[] = "naturaleftouterightfullinnercross";
  static const struct {
    u8 i;        /* Beginning of keyword text in zKeyText[] */
    u8 nChar;    /* Length of the keyword in characters */
    u8 code;     /* Join type mask */
  } aKeyword[] = {
    /* natural */ { 0,  7, JT_NATURAL                },
    /* left    */ { 6,  4, JT_LEFT|JT_OUTER          },
    /* outer   */ { 10, 5, JT_OUTER                  },
    /* right   */ { 14, 5, JT_RIGHT|JT_OUTER         },
    /* full    */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
    /* inner   */ { 23, 5, JT_INNER                  },
    /* cross   */ { 28, 5, JT_INNER|JT_CROSS         },
  };
  int i, j;
  apAll[0] = pA;
  apAll[1] = pB;
  apAll[2] = pC;
  for(i=0; i<3 && apAll[i]; i++){
    p = apAll[i];
    for(j=0; j<ArraySize(aKeyword); j++){
      if( p->n==aKeyword[j].nChar
          && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
        jointype |= aKeyword[j].code;
        break;
      }
    }
    testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
    if( j>=ArraySize(aKeyword) ){
      jointype |= JT_ERROR;
      break;
    }
  }
  if(
     (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
     (jointype & JT_ERROR)!=0
  ){
    const char *zSp = " ";
    assert( pB!=0 );
    if( pC==0 ){ zSp++; }
    sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
       "%T %T%s%T", pA, pB, zSp, pC);
    jointype = JT_INNER;
  }else if( (jointype & JT_OUTER)!=0
         && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){

References ArraySize, JT_CROSS, JT_ERROR, JT_INNER, JT_LEFT, JT_NATURAL, JT_OUTER, JT_RIGHT, Token::n, sqlite3ErrorMsg(), sqlite3StrNICmp, testcase, and Token::z.

Referenced by yy_reduce().

◆ sqlite3JournalIsInMemory()

SQLITE_PRIVATE int sqlite3JournalIsInMemory ( sqlite3_file * p )

Definition at line 97487 of file sqlite3.c.

References MemJournalMethods, and sqlite3_file::pMethods.

Referenced by pager_end_transaction(), releaseAllSavepoints(), sqlite3PagerCommitPhaseOne(), sqlite3PagerSavepoint(), and zeroJournalHdr().

◆ sqlite3JournalModename()

SQLITE_PRIVATE const char * sqlite3JournalModename ( int eMode )

Definition at line 125998 of file sqlite3.c.

                                                            {
  static char * const azModeName[] = {
    "delete", "persist", "off", "truncate", "memory"
#ifndef SQLITE_OMIT_WAL
     , "wal"
#endif
  };
  assert( PAGER_JOURNALMODE_DELETE==0 );
  assert( PAGER_JOURNALMODE_PERSIST==1 );
  assert( PAGER_JOURNALMODE_OFF==2 );
  assert( PAGER_JOURNALMODE_TRUNCATE==3 );
  assert( PAGER_JOURNALMODE_MEMORY==4 );

References ArraySize, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_PERSIST, PAGER_JOURNALMODE_TRUNCATE, and PAGER_JOURNALMODE_WAL.

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ sqlite3JournalOpen()

SQLITE_PRIVATE int sqlite3JournalOpen	(	sqlite3_vfs *	pVfs,
		const char *	zName,
		sqlite3_file *	pJfd,
		int	flags,
		int	nSpill )

Definition at line 97412 of file sqlite3.c.

 {
  MemJournal *p = (MemJournal*)pJfd;
 
  /* Zero the file-handle object. If nSpill was passed zero, initialize
  ** it using the sqlite3OsOpen() function of the underlying VFS. In this
  ** case none of the code in this module is executed as a result of calls
  ** made on the journal file-handle.  */
  memset(p, 0, sizeof(MemJournal));
  if( nSpill==0 ){
    return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
  }
 
  if( nSpill>0 ){
    p->nChunkSize = nSpill;
  }else{
    p->nChunkSize = 8 + MEMJOURNAL_DFLT_FILECHUNKSIZE - sizeof(FileChunk);
    assert( MEMJOURNAL_DFLT_FILECHUNKSIZE==fileChunkSize(p->nChunkSize) );
  }
 
  pJfd->pMethods = (const sqlite3_io_methods*)&MemJournalMethods;

References fileChunkSize, MemJournal::flags, MEMJOURNAL_DFLT_FILECHUNKSIZE, MemJournalMethods, MemJournal::nChunkSize, MemJournal::nSpill, sqlite3_file::pMethods, MemJournal::pVfs, sqlite3OsOpen(), MemJournal::zJournal, and zName.

Referenced by openSubJournal(), and pager_open_journal().

◆ sqlite3JournalSize()

SQLITE_PRIVATE int sqlite3JournalSize ( sqlite3_vfs * pVfs )

Definition at line 97495 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ sqlite3KeyInfoAlloc()

SQLITE_PRIVATE KeyInfo * sqlite3KeyInfoAlloc	(	sqlite3 *	db,
		int	N,
		int	X )

Definition at line 130589 of file sqlite3.c.

                                                                      {
  int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
  KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
  if( p ){
    p->aSortFlags = (u8*)&p->aColl[N+X];
    p->nKeyField = (u16)N;
    p->nAllField = (u16)(N+X);
    p->enc = ENC(db);
    p->db = db;
    p->nRef = 1;

Referenced by multiSelect(), multiSelectOrderBy(), multiSelectOrderByKeyInfo(), sqlite3CodeRhsOfIN(), sqlite3KeyInfoFromExprList(), and sqlite3KeyInfoOfIndex().

◆ sqlite3KeyInfoFromExprList()

SQLITE_PRIVATE KeyInfo * sqlite3KeyInfoFromExprList	(	Parse *	pParse,
		ExprList *	pList,
		int	iStart,
		int	nExtra )

Definition at line 130652 of file sqlite3.c.

 {
  int nExpr;
  KeyInfo *pInfo;
  struct ExprList_item *pItem;
  sqlite3 *db = pParse->db;
  int i;
 
  nExpr = pList->nExpr;
  pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
  if( pInfo ){
    assert( sqlite3KeyInfoIsWriteable(pInfo) );
    for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){

References ExprList::a, KeyInfo::aColl, KeyInfo::aSortFlags, Parse::db, ExprList::nExpr, sqlite3ExprNNCollSeq(), and sqlite3KeyInfoAlloc().

Referenced by resetAccumulator(), sqlite3Select(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), windowFullScan(), and windowIfNewPeer().

◆ sqlite3KeyInfoOfIndex()

SQLITE_PRIVATE KeyInfo * sqlite3KeyInfoOfIndex	(	Parse *	pParse,
		Index *	pIdx )

Definition at line 115426 of file sqlite3.c.

                                                                         {
  int i;
  int nCol = pIdx->nColumn;
  int nKey = pIdx->nKeyCol;
  KeyInfo *pKey;
  if( pParse->nErr ) return 0;
  if( pIdx->uniqNotNull ){
    pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
  }else{
    pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
  }
  if( pKey ){
    assert( sqlite3KeyInfoIsWriteable(pKey) );
    for(i=0; i<nCol; i++){
      const char *zColl = pIdx->azColl[i];
      pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
                        sqlite3LocateCollSeq(pParse, zColl);
      pKey->aSortFlags[i] = pIdx->aSortOrder[i];
      assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
    }
    if( pParse->nErr ){
      assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
      if( pIdx->bNoQuery==0 ){
        /* Deactivate the index because it contains an unknown collating
        ** sequence.  The only way to reactive the index is to reload the
        ** schema.  Adding the missing collating sequence later does not
        ** reactive the index.  The application had the chance to register
        ** the missing index using the collation-needed callback.  For
        ** simplicity, SQLite will not give the application a second chance.
        */
        pIdx->bNoQuery = 1;
        pParse->rc = SQLITE_ERROR_RETRY;
      }

References KeyInfo::aColl, KeyInfo::aSortFlags, Index::aSortOrder, Index::azColl, Index::bNoQuery, Parse::db, KEYINFO_ORDER_BIGNULL, Index::nColumn, Parse::nErr, Index::nKeyCol, Parse::rc, sqlite3KeyInfoAlloc(), sqlite3KeyInfoUnref(), sqlite3LocateCollSeq(), sqlite3StrBINARY, SQLITE_ERROR_MISSING_COLLSEQ, SQLITE_ERROR_RETRY, and Index::uniqNotNull.

Referenced by sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), and valueNew().

◆ sqlite3KeyInfoRef()

SQLITE_PRIVATE KeyInfo * sqlite3KeyInfoRef ( KeyInfo * p )

Definition at line 130620 of file sqlite3.c.

130626 {

Referenced by generateOutputSubroutine(), multiSelect(), sqlite3RefillIndex(), and sqlite3Select().

◆ sqlite3KeyInfoUnref()

SQLITE_PRIVATE void sqlite3KeyInfoUnref ( KeyInfo * p )

Definition at line 130609 of file sqlite3.c.

130615 {

Referenced by multiSelect(), multiSelectOrderBy(), sqlite3CodeRhsOfIN(), and sqlite3KeyInfoOfIndex().

◆ sqlite3KeywordCode()

SQLITE_PRIVATE int sqlite3KeywordCode	(	const unsigned char *	z,
		int	n )

Definition at line 159865 of file sqlite3.c.

Referenced by identPut().

◆ sqlite3LeaveMutexAndCloseZombie()

SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie ( sqlite3 * db )

Definition at line 162258 of file sqlite3.c.

                                                                {
  HashElem *i;                    /* Hash table iterator */
  int j;
 
  /* If there are outstanding sqlite3_stmt or sqlite3_backup objects
  ** or if the connection has not yet been closed by sqlite3_close_v2(),
  ** then just leave the mutex and return.
  */
  if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){
    sqlite3_mutex_leave(db->mutex);
    return;
  }
 
  /* If we reach this point, it means that the database connection has
  ** closed all sqlite3_stmt and sqlite3_backup objects and has been
  ** passed to sqlite3_close (meaning that it is a zombie).  Therefore,
  ** go ahead and free all resources.
  */
 
  /* If a transaction is open, roll it back. This also ensures that if
  ** any database schemas have been modified by an uncommitted transaction
  ** they are reset. And that the required b-tree mutex is held to make
  ** the pager rollback and schema reset an atomic operation. */
  sqlite3RollbackAll(db, SQLITE_OK);
 
  /* Free any outstanding Savepoint structures. */
  sqlite3CloseSavepoints(db);
 
  /* Close all database connections */
  for(j=0; j<db->nDb; j++){
    struct Db *pDb = &db->aDb[j];
    if( pDb->pBt ){
      sqlite3BtreeClose(pDb->pBt);
      pDb->pBt = 0;
      if( j!=1 ){
        pDb->pSchema = 0;
      }
    }
  }
  /* Clear the TEMP schema separately and last */
  if( db->aDb[1].pSchema ){
    sqlite3SchemaClear(db->aDb[1].pSchema);
  }
  sqlite3VtabUnlockList(db);
 
  /* Free up the array of auxiliary databases */
  sqlite3CollapseDatabaseArray(db);
  assert( db->nDb<=2 );
  assert( db->aDb==db->aDbStatic );
 
  /* Tell the code in notify.c that the connection no longer holds any
  ** locks and does not require any further unlock-notify callbacks.
  */
  sqlite3ConnectionClosed(db);
 
  for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
    FuncDef *pNext, *p;
    p = sqliteHashData(i);
    do{
      functionDestroy(db, p);
      pNext = p->pNext;
      sqlite3DbFree(db, p);
      p = pNext;
    }while( p );
  }
  sqlite3HashClear(&db->aFunc);
  for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
    CollSeq *pColl = (CollSeq *)sqliteHashData(i);
    /* Invoke any destructors registered for collation sequence user data. */
    for(j=0; j<3; j++){
      if( pColl[j].xDel ){
        pColl[j].xDel(pColl[j].pUser);
      }
    }
    sqlite3DbFree(db, pColl);
  }
  sqlite3HashClear(&db->aCollSeq);
#ifndef SQLITE_OMIT_VIRTUALTABLE
  for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
    Module *pMod = (Module *)sqliteHashData(i);
    sqlite3VtabEponymousTableClear(db, pMod);
    sqlite3VtabModuleUnref(db, pMod);
  }
  sqlite3HashClear(&db->aModule);
#endif
 
  sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
  sqlite3ValueFree(db->pErr);
  sqlite3CloseExtensions(db);
#if SQLITE_USER_AUTHENTICATION
  sqlite3_free(db->auth.zAuthUser);
  sqlite3_free(db->auth.zAuthPW);
#endif
 
  db->magic = SQLITE_MAGIC_ERROR;
 
  /* The temp-database schema is allocated differently from the other schema
  ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
  ** So it needs to be freed here. Todo: Why not roll the temp schema into
  ** the same sqliteMalloc() as the one that allocates the database
  ** structure?
  */
  sqlite3DbFree(db, db->aDb[1].pSchema);
  sqlite3_mutex_leave(db->mutex);
  db->magic = SQLITE_MAGIC_CLOSED;
  sqlite3_mutex_free(db->mutex);

References sqlite3::aCollSeq, sqlite3::aDb, sqlite3::aDbStatic, sqlite3::aFunc, sqlite3::aModule, Lookaside::bMalloced, connectionIsBusy(), functionDestroy(), sqlite3::lookaside, sqlite3::magic, sqlite3::mutex, sqlite3::nDb, Db::pBt, sqlite3::pErr, FuncDef::pNext, Db::pSchema, Lookaside::pStart, sqlite3_free(), sqlite3_mutex_free(), sqlite3_mutex_leave(), sqlite3BtreeClose(), sqlite3CloseExtensions(), sqlite3CloseSavepoints(), sqlite3CollapseDatabaseArray(), sqlite3ConnectionClosed, sqlite3DbFree(), sqlite3Error(), sqlite3HashClear(), sqlite3LookasideUsed(), sqlite3RollbackAll(), sqlite3SchemaClear(), sqlite3ValueFree(), sqlite3VtabEponymousTableClear(), sqlite3VtabModuleUnref(), sqlite3VtabUnlockList(), SQLITE_MAGIC_CLOSED, SQLITE_MAGIC_ERROR, SQLITE_MAGIC_ZOMBIE, SQLITE_OK, sqliteHashData, sqliteHashFirst, sqliteHashNext, and CollSeq::xDel.

Referenced by sqlite3_finalize().

◆ sqlite3LoadExtension()

static int sqlite3LoadExtension	(	sqlite3 *	db,
		const char *	zFile,
		const char *	zProc,
		char **	pzErrMsg )

static

Definition at line 124735 of file sqlite3.c.

 {
  sqlite3_vfs *pVfs = db->pVfs;
  void *handle;
  sqlite3_loadext_entry xInit;
  char *zErrmsg = 0;
  const char *zEntry;
  char *zAltEntry = 0;
  void **aHandle;
  u64 nMsg = 300 + sqlite3Strlen30(zFile);
  int ii;
  int rc;
 
  /* Shared library endings to try if zFile cannot be loaded as written */
  static const char *azEndings[] = {
#if SQLITE_OS_WIN
     "dll"
#elif defined(__APPLE__)
     "dylib"
#else
     "so"
#endif
  };
 
 
  if( pzErrMsg ) *pzErrMsg = 0;
 
  /* Ticket #1863.  To avoid a creating security problems for older
  ** applications that relink against newer versions of SQLite, the
  ** ability to run load_extension is turned off by default.  One
  ** must call either sqlite3_enable_load_extension(db) or
  ** sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 0)
  ** to turn on extension loading.
  */
  if( (db->flags & SQLITE_LoadExtension)==0 ){
    if( pzErrMsg ){
      *pzErrMsg = sqlite3_mprintf("not authorized");
    }
    return SQLITE_ERROR;
  }
 
  zEntry = zProc ? zProc : "sqlite3_extension_init";
 
  handle = sqlite3OsDlOpen(pVfs, zFile);
#if SQLITE_OS_UNIX || SQLITE_OS_WIN
  for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
    char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
    if( zAltFile==0 ) return SQLITE_NOMEM_BKPT;
    handle = sqlite3OsDlOpen(pVfs, zAltFile);
    sqlite3_free(zAltFile);
  }
#endif
  if( handle==0 ){
    if( pzErrMsg ){
      *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
      if( zErrmsg ){
        sqlite3_snprintf(nMsg, zErrmsg,
            "unable to open shared library [%s]", zFile);
        sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
      }
    }
    return SQLITE_ERROR;
  }
  xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
 
  /* If no entry point was specified and the default legacy
  ** entry point name "sqlite3_extension_init" was not found, then
  ** construct an entry point name "sqlite3_X_init" where the X is
  ** replaced by the lowercase value of every ASCII alphabetic
  ** character in the filename after the last "/" upto the first ".",
  ** and eliding the first three characters if they are "lib".
  ** Examples:
  **
  **    /usr/local/lib/libExample5.4.3.so ==>  sqlite3_example_init
  **    C:/lib/mathfuncs.dll              ==>  sqlite3_mathfuncs_init
  */
  if( xInit==0 && zProc==0 ){
    int iFile, iEntry, c;
    int ncFile = sqlite3Strlen30(zFile);
    zAltEntry = sqlite3_malloc64(ncFile+30);
    if( zAltEntry==0 ){
      sqlite3OsDlClose(pVfs, handle);
      return SQLITE_NOMEM_BKPT;
    }
    memcpy(zAltEntry, "sqlite3_", 8);
    for(iFile=ncFile-1; iFile>=0 && !DirSep(zFile[iFile]); iFile--){}
    iFile++;
    if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;
    for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){
      if( sqlite3Isalpha(c) ){
        zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];
      }
    }
    memcpy(zAltEntry+iEntry, "_init", 6);
    zEntry = zAltEntry;
    xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
  }
  if( xInit==0 ){
    if( pzErrMsg ){
      nMsg += sqlite3Strlen30(zEntry);
      *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
      if( zErrmsg ){
        sqlite3_snprintf(nMsg, zErrmsg,
            "no entry point [%s] in shared library [%s]", zEntry, zFile);
        sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
      }
    }
    sqlite3OsDlClose(pVfs, handle);
    sqlite3_free(zAltEntry);
    return SQLITE_ERROR;
  }
  sqlite3_free(zAltEntry);
  rc = xInit(db, &zErrmsg, &sqlite3Apis);
  if( rc ){
    if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK;
    if( pzErrMsg ){
      *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
    }
    sqlite3_free(zErrmsg);
    sqlite3OsDlClose(pVfs, handle);
    return SQLITE_ERROR;
  }
 
  /* Append the new shared library handle to the db->aExtension array. */
  aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
  if( aHandle==0 ){
    return SQLITE_NOMEM_BKPT;
  }
  if( db->nExtension>0 ){
    memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
  }

References sqlite3::aExtension, ArraySize, DirSep, sqlite3::flags, sqlite3::nExtension, sqlite3::pVfs, sqlite3_free(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3_snprintf(), sqlite3_strnicmp(), sqlite3Apis, sqlite3DbMallocZero(), sqlite3Isalpha, sqlite3OsDlClose(), sqlite3OsDlError(), sqlite3OsDlOpen(), sqlite3OsDlSym, sqlite3Strlen30(), sqlite3UpperToLower, SQLITE_ERROR, SQLITE_LoadExtension, SQLITE_NOMEM_BKPT, SQLITE_OK, and SQLITE_OK_LOAD_PERMANENTLY.

◆ sqlite3LocateCollSeq()

SQLITE_PRIVATE CollSeq * sqlite3LocateCollSeq	(	Parse *	pParse,
		const char *	zName )

Definition at line 115791 of file sqlite3.c.

           : sqlite3FindCollSeq(), sqlite3GetCollSeq()
*/
SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
  sqlite3 *db = pParse->db;
  u8 enc = ENC(db);
  u8 initbusy = db->init.busy;
  CollSeq *pColl;
 
  pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);

References sqlite3::sqlite3InitInfo::busy, Parse::db, ENC, sqlite3::init, sqlite3FindCollSeq(), sqlite3GetCollSeq(), CollSeq::xCmp, and zName.

Referenced by analyzeOneTable(), sqlite3CreateIndex(), sqlite3GenerateConstraintChecks(), and sqlite3KeyInfoOfIndex().

◆ sqlite3LocateTable()

SQLITE_PRIVATE Table * sqlite3LocateTable	(	Parse *	pParse,
		u32	flags,
		const char *	zName,
		const char *	zDbase )

Definition at line 110777 of file sqlite3.c.

 {
  Table *p;
  sqlite3 *db = pParse->db;
 
  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
   && SQLITE_OK!=sqlite3ReadSchema(pParse)
  ){
    return 0;
  }
 
  p = sqlite3FindTable(db, zName, zDbase);
  if( p==0 ){
#ifndef SQLITE_OMIT_VIRTUALTABLE
    /* If zName is the not the name of a table in the schema created using
    ** CREATE, then check to see if it is the name of an virtual table that
    ** can be an eponymous virtual table. */
    if( pParse->disableVtab==0 ){
      Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
      if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
        pMod = sqlite3PragmaVtabRegister(db, zName);
      }
      if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
        return pMod->pEpoTab;
      }
    }
#endif
    if( flags & LOCATE_NOERR ) return 0;
    pParse->checkSchema = 1;
  }else if( IsVirtual(p) && pParse->disableVtab ){
    p = 0;
  }
 
  if( p==0 ){
    const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
    if( zDbase ){
      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
    }else{

References sqlite3::aModule, Parse::checkSchema, Parse::db, DBFLAG_SchemaKnownOk, Parse::disableVtab, IsVirtual, LOCATE_NOERR, LOCATE_VIEW, sqlite3::mDbFlags, Module::pEpoTab, sqlite3_strnicmp(), sqlite3ErrorMsg(), sqlite3FindTable(), sqlite3HashFind(), sqlite3PragmaVtabRegister(), sqlite3ReadSchema(), sqlite3VtabEponymousTableInit(), SQLITE_OK, and zName.

Referenced by renameColumnFunc(), sqlite3Analyze(), sqlite3FkCheck(), sqlite3LocateTableItem(), and sqlite3Pragma().

◆ sqlite3LocateTableItem()

SQLITE_PRIVATE Table * sqlite3LocateTableItem	(	Parse *	pParse,
		u32	flags,
		struct SrcList_item *	p )

Definition at line 110837 of file sqlite3.c.

 {
  const char *zDb;
  assert( p->pSchema==0 || p->zDatabase==0 );
  if( p->pSchema ){
    int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);

References sqlite3::aDb, Parse::db, sqlite3LocateTable(), sqlite3SchemaToIndex(), and Db::zDbSName.

Referenced by renameResolveTrigger(), selectExpander(), sqlite3AlterBeginAddColumn(), sqlite3AlterRenameColumn(), sqlite3CreateIndex(), sqlite3SrcListLookup(), and xferOptimization().

◆ sqlite3LockAndPrepare()

static int sqlite3LockAndPrepare	(	sqlite3 *	db,
		const char *	zSql,
		int	nBytes,
		u32	prepFlags,
		Vdbe *	pOld,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

static

Definition at line 129050 of file sqlite3.c.

           :
 
  sqlite3ParserReset(&sParse);
  return rc;
}
static int sqlite3LockAndPrepare(
  sqlite3 *db,              /* Database handle. */
  const char *zSql,         /* UTF-8 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
  Vdbe *pOld,               /* VM being reprepared */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const char **pzTail       /* OUT: End of parsed string */
){
  int rc;
  int cnt = 0;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppStmt = 0;
  if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  do{
    /* Make multiple attempts to compile the SQL, until it either succeeds
    ** or encounters a permanent error.  A schema problem after one schema
    ** reset is considered a permanent error. */
    rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
    assert( rc==SQLITE_OK || *ppStmt==0 );
  }while( rc==SQLITE_ERROR_RETRY
       || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) );

Referenced by sqlite3_prepare_v2(), sqlite3Prepare16(), and sqlite3Reprepare().

◆ sqlite3LogEst()

SQLITE_PRIVATE LogEst sqlite3LogEst ( u64 x )

Definition at line 32710 of file sqlite3.c.

                                          {
  static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
  LogEst y = 40;
  if( x<8 ){
    if( x<2 ) return 0;
    while( x<8 ){  y -= 10; x <<= 1; }
  }else{
#if GCC_VERSION>=5004000
    int i = 60 - __builtin_clzll(x);
    y += i*10;
    x >>= i;
#else

Referenced by computeLimitRegisters(), decodeIntArray(), multiSelect(), sqlite3DefaultRowEst(), sqlite3ExpandSubquery(), sqlite3LogEstFromDouble(), sqlite3Pragma(), sqlite3Select(), sqlite3StartTable(), sqlite3VdbeExec(), whereClauseInsert(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopAddVirtualOne(), wherePathSolver(), whereRangeAdjust(), whereRangeScanEst(), whereSortingCost(), and withExpand().

◆ sqlite3LogEstAdd()

SQLITE_PRIVATE LogEst sqlite3LogEstAdd	(	LogEst	a,
		LogEst	b )

Definition at line 32683 of file sqlite3.c.

                                                          {
  static const unsigned char x[] = {
     10, 10,                         /* 0,1 */
      9, 9,                          /* 2,3 */
      8, 8,                          /* 4,5 */
      7, 7, 7,                       /* 6,7,8 */
      6, 6, 6,                       /* 9,10,11 */
      5, 5, 5,                       /* 12-14 */
      4, 4, 4, 4,                    /* 15-18 */
      3, 3, 3, 3, 3, 3,              /* 19-24 */
      2, 2, 2, 2, 2, 2, 2,           /* 25-31 */
  };
  if( a>=b ){
    if( a>b+49 ) return a;
    if( a>b+31 ) return a+1;
    return a+x[a-b];

Referenced by multiSelect(), multiSelectOrderBy(), whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopAddOr(), and wherePathSolver().

◆ sqlite3LogEstFromDouble()

SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble ( double x )

Definition at line 32734 of file sqlite3.c.

                                                       {
  u64 a;
  LogEst e;
  assert( sizeof(x)==8 && sizeof(a)==8 );

References sqlite3LogEst().

Referenced by whereLoopAddVirtualOne().

◆ sqlite3LookasideUsed()

SQLITE_PRIVATE int sqlite3LookasideUsed	(	sqlite3 *	db,
		int *	pHighwater )

Definition at line 21501 of file sqlite3.c.

                                                                     {
  u32 nInit = countLookasideSlots(db->lookaside.pInit);
  u32 nFree = countLookasideSlots(db->lookaside.pFree);
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
  nInit += countLookasideSlots(db->lookaside.pSmallInit);

Referenced by deleteTable(), setupLookaside(), and sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3Malloc()

SQLITE_PRIVATE void * sqlite3Malloc ( u64 n )

Definition at line 27590 of file sqlite3.c.

                                         {
  void *p;
  if( n==0 || n>=0x7fffff00 ){
    /* A memory allocation of a number of bytes which is near the maximum
    ** signed integer value might cause an integer overflow inside of the
    ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
    ** 255 bytes of overhead.  SQLite itself will never use anything near
    ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
    p = 0;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    mallocWithAlarm((int)n, &p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{

References EIGHT_BYTE_ALIGNMENT, mallocWithAlarm(), mem0, sqlite3_mutex_enter(), sqlite3_mutex_leave(), and sqlite3GlobalConfig.

Referenced by contextMalloc(), createFunctionApi(), dbMallocRawFinish(), pager_delsuper(), pcache1Alloc(), rehash(), saveCursorKey(), setupLookaside(), sqlite3BtreeInsert(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3HashInsert(), sqlite3MallocZero(), sqlite3RunParser(), sqlite3VdbeSorterInit(), sqlite3VtabCreateModule(), vdbePmaReaderSeek(), and vdbeSorterFlushPMA().

◆ sqlite3MallocAlarm()

static void sqlite3MallocAlarm ( int nByte )

static

Definition at line 27530 of file sqlite3.c.

27535 {

Referenced by mallocWithAlarm().

◆ sqlite3MallocEnd()

SQLITE_PRIVATE void sqlite3MallocEnd ( void )

Definition at line 27500 of file sqlite3.c.

27505 {

Referenced by sqlite3_shutdown().

◆ sqlite3MallocInit()

SQLITE_PRIVATE int sqlite3MallocInit ( void )

Definition at line 27471 of file sqlite3.c.

                                          {
  int rc;
  if( sqlite3GlobalConfig.m.xMalloc==0 ){
    sqlite3MemSetDefault();
  }
  memset(&mem0, 0, sizeof(mem0));
  mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
  if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
      || sqlite3GlobalConfig.nPage<=0 ){
    sqlite3GlobalConfig.pPage = 0;
    sqlite3GlobalConfig.szPage = 0;

References mem0, sqlite3GlobalConfig, sqlite3MemSetDefault(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MEM, and SQLITE_OK.

Referenced by sqlite3_initialize().

◆ sqlite3MallocMutex()

SQLITE_PRIVATE sqlite3_mutex * sqlite3MallocMutex ( void )

Definition at line 27374 of file sqlite3.c.

References mem0, and sqlite3_mutex::mutex.

Referenced by sqlite3RunParser(), sqlite3StatusHighwater(), sqlite3StatusUp(), and sqlite3StatusValue().

◆ sqlite3MallocSize()

SQLITE_PRIVATE int sqlite3MallocSize ( void * p )

Definition at line 27643 of file sqlite3.c.

Referenced by accessPayload(), mallocWithAlarm(), pcache1Alloc(), rehash(), setupLookaside(), sqlite3PagerMemUsed(), vdbeSorterFlushPMA(), and vdbeSorterSort().

◆ sqlite3MallocZero()

SQLITE_PRIVATE void * sqlite3MallocZero ( u64 n )

Definition at line 27837 of file sqlite3.c.

27842 {

27843 void *p = sqlite3Malloc(n);

References sqlite3Malloc().

Referenced by analysisLoader(), openDatabase(), pager_delsuper(), pcache1Create(), pcache1ResizeHash(), pthreadMutexAlloc(), setSharedCacheTableLock(), sqlite3_backup_init(), sqlite3BitvecBuiltinTest(), sqlite3BitvecCreate(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeOpen(), sqlite3PagerOpen(), sqlite3WalOpen(), statGet(), vdbeIncrMergerNew(), vdbeMergeEngineNew(), vtabCallConstructor(), and walIndexPageRealloc().

◆ sqlite3MatchEName()

SQLITE_PRIVATE int sqlite3MatchEName	(	const struct ExprList_item *	pItem,
		const char *	zCol,
		const char *	zTab,
		const char *	zDb )

Definition at line 97891 of file sqlite3.c.

 {
  int n;
  const char *zSpan;
  if( pItem->eEName!=ENAME_TAB ) return 0;
  zSpan = pItem->zEName;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
    return 0;
  }
  zSpan += n+1;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
    return 0;
  }

References ALWAYS, ENAME_TAB, sqlite3StrICmp(), and sqlite3StrNICmp.

Referenced by lookupName(), and selectExpander().

◆ sqlite3MaterializeView()

SQLITE_PRIVATE void sqlite3MaterializeView	(	Parse *	pParse,
		Table *	pView,
		Expr *	pWhere,
		ExprList *	pOrderBy,
		Expr *	pLimit,
		int	iCur )

Definition at line 116177 of file sqlite3.c.

 {
  SelectDest dest;
  Select *pSel;
  SrcList *pFrom;
  sqlite3 *db = pParse->db;
  int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
  pWhere = sqlite3ExprDup(db, pWhere, 0);
  pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0);
  if( pFrom ){
    assert( pFrom->nSrc==1 );
    pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
    assert( pFrom->a[0].pOn==0 );
    assert( pFrom->a[0].pUsing==0 );
  }

References SrcList::a, sqlite3::aDb, Parse::db, SrcList::nSrc, SrcList::SrcList_item::pOn, Table::pSchema, SrcList::SrcList_item::pUsing, SF_IncludeHidden, sqlite3DbStrDup(), sqlite3ExprDup(), sqlite3SchemaToIndex(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectDestInit(), sqlite3SelectNew(), sqlite3SrcListAppend(), SRT_EphemTab, SrcList::SrcList_item::zDatabase, Db::zDbSName, Table::zName, and SrcList::SrcList_item::zName.

Referenced by sqlite3DeleteFrom(), and sqlite3Update().

◆ sqlite3MayAbort()

SQLITE_PRIVATE void sqlite3MayAbort ( Parse * pParse )

Definition at line 115204 of file sqlite3.c.

References Parse::mayAbort, and sqlite3ParseToplevel.

Referenced by destroyRootPage(), fkLookupParent(), sqlite3AlterBeginAddColumn(), sqlite3AlterRenameColumn(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeTarget(), sqlite3FkCheck(), sqlite3GenerateConstraintChecks(), sqlite3HaltConstraint(), sqlite3Insert(), sqlite3RefillIndex(), sqlite3UpsertDoUpdate(), updateVirtualTable(), and windowCheckValue().

◆ sqlite3MemCompare()

SQLITE_PRIVATE int sqlite3MemCompare	(	const Mem *	pMem1,
		const Mem *	pMem2,
		const CollSeq *	pColl )

Definition at line 82056 of file sqlite3.c.

                                                                                              {
  int f1, f2;
  int combined_flags;
 
  f1 = pMem1->flags;
  f2 = pMem2->flags;
  combined_flags = f1|f2;
  assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
 
  /* If one value is NULL, it is less than the other. If both values
  ** are NULL, return 0.
  */
  if( combined_flags&MEM_Null ){
    return (f2&MEM_Null) - (f1&MEM_Null);
  }
 
  /* At least one of the two values is a number
  */
  if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){
    testcase( combined_flags & MEM_Int );
    testcase( combined_flags & MEM_Real );
    testcase( combined_flags & MEM_IntReal );
    if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){
      testcase( f1 & f2 & MEM_Int );
      testcase( f1 & f2 & MEM_IntReal );
      if( pMem1->u.i < pMem2->u.i ) return -1;
      if( pMem1->u.i > pMem2->u.i ) return +1;
      return 0;
    }
    if( (f1 & f2 & MEM_Real)!=0 ){
      if( pMem1->u.r < pMem2->u.r ) return -1;
      if( pMem1->u.r > pMem2->u.r ) return +1;
      return 0;
    }
    if( (f1&(MEM_Int|MEM_IntReal))!=0 ){
      testcase( f1 & MEM_Int );
      testcase( f1 & MEM_IntReal );
      if( (f2&MEM_Real)!=0 ){
        return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r);
      }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
        if( pMem1->u.i < pMem2->u.i ) return -1;
        if( pMem1->u.i > pMem2->u.i ) return +1;
        return 0;
      }else{
        return -1;
      }
    }
    if( (f1&MEM_Real)!=0 ){
      if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
        testcase( f2 & MEM_Int );
        testcase( f2 & MEM_IntReal );
        return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r);
      }else{
        return -1;
      }
    }
    return +1;
  }
 
  /* If one value is a string and the other is a blob, the string is less.
  ** If both are strings, compare using the collating functions.
  */
  if( combined_flags&MEM_Str ){
    if( (f1 & MEM_Str)==0 ){
      return 1;
    }
    if( (f2 & MEM_Str)==0 ){
      return -1;
    }
 
    assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
    assert( pMem1->enc==SQLITE_UTF8 ||
            pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
 
    /* The collation sequence must be defined at this point, even if
    ** the user deletes the collation sequence after the vdbe program is
    ** compiled (this was not always the case).
    */
    assert( !pColl || pColl->xCmp );
 
    if( pColl ){
      return vdbeCompareMemString(pMem1, pMem2, pColl, 0);
    }
    /* If a NULL pointer was passed as the collate function, fall through

References sqlite3_value::db, sqlite3_value::enc, sqlite3_value::flags, sqlite3_value::MemValue::i, sqlite3::mallocFailed, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, sqlite3_value::MemValue::r, sqlite3BlobCompare(), sqlite3IntFloatCompare(), SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, testcase, sqlite3_value::u, vdbeCompareMemString(), and CollSeq::xCmp.

Referenced by exprCompareVariable(), minmaxStep(), nullifFunc(), and sqlite3VdbeExec().

◆ sqlite3MemFree()

static void sqlite3MemFree ( void * pPrior )

static

Definition at line 23709 of file sqlite3.c.

                                        {
#ifdef SQLITE_MALLOCSIZE
  SQLITE_FREE(pPrior);
#else
  sqlite3_int64 *p = (sqlite3_int64*)pPrior;

References SQLITE_FREE.

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemInit()

static int sqlite3MemInit ( void * NotUsed )

static

Definition at line 23786 of file sqlite3.c.

                                        {
#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
  int cpuCount;
  size_t len;
  if( _sqliteZone_ ){
    return SQLITE_OK;
  }
  len = sizeof(cpuCount);
  /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
  sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
  if( cpuCount>1 ){
    /* defer MT decisions to system malloc */
    _sqliteZone_ = malloc_default_zone();
  }else{
    /* only 1 core, use our own zone to contention over global locks,
    ** e.g. we have our own dedicated locks */
    _sqliteZone_ = malloc_create_zone(4096, 0);
    malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap");

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemJournalOpen()

SQLITE_PRIVATE void sqlite3MemJournalOpen ( sqlite3_file * pJfd )

Definition at line 97448 of file sqlite3.c.

Referenced by pager_open_journal().

◆ sqlite3MemMalloc()

static void * sqlite3MemMalloc ( int nByte )

static

Definition at line 23675 of file sqlite3.c.

                                        {
#ifdef SQLITE_MALLOCSIZE
  void *p;
  testcase( ROUND8(nByte)==nByte );
  p = SQLITE_MALLOC( nByte );
  if( p==0 ){
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  }
  return p;
#else
  sqlite3_int64 *p;
  assert( nByte>0 );
  testcase( ROUND8(nByte)!=nByte );
  p = SQLITE_MALLOC( nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }else{
    testcase( sqlite3GlobalConfig.xLog!=0 );

References ROUND8, sqlite3_log(), sqlite3GlobalConfig, SQLITE_MALLOC, SQLITE_NOMEM, and testcase.

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemoryBarrier()

SQLITE_PRIVATE void sqlite3MemoryBarrier ( void )

Definition at line 26314 of file sqlite3.c.

26319 {

26320#if defined(SQLITE_MEMORY_BARRIER)

Referenced by sqlite3_initialize(), sqlite3MutexInit(), and unixShmBarrier().

◆ sqlite3MemRealloc()

static void * sqlite3MemRealloc	(	void *	pPrior,
		int	nByte )

static

Definition at line 23747 of file sqlite3.c.

                                                       {
#ifdef SQLITE_MALLOCSIZE
  void *p = SQLITE_REALLOC(pPrior, nByte);
  if( p==0 ){
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM,
      "failed memory resize %u to %u bytes",
      SQLITE_MALLOCSIZE(pPrior), nByte);
  }
  return p;
#else
  sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  assert( pPrior!=0 && nByte>0 );
  assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
  p--;
  p = SQLITE_REALLOC(p, nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }else{
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM,
      "failed memory resize %u to %u bytes",

References ROUND8, sqlite3_log(), sqlite3GlobalConfig, sqlite3MemSize(), SQLITE_NOMEM, SQLITE_REALLOC, and testcase.

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemRoundup()

static int sqlite3MemRoundup ( int n )

static

Definition at line 23779 of file sqlite3.c.

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemSetDefault()

SQLITE_PRIVATE void sqlite3MemSetDefault ( void )

Definition at line 23824 of file sqlite3.c.

                                              {
  static const sqlite3_mem_methods defaultMethods = {
     sqlite3MemMalloc,
     sqlite3MemFree,
     sqlite3MemRealloc,
     sqlite3MemSize,
     sqlite3MemRoundup,
     sqlite3MemInit,

References sqlite3_config(), sqlite3MemFree(), sqlite3MemInit(), sqlite3MemMalloc(), sqlite3MemRealloc(), sqlite3MemRoundup(), sqlite3MemShutdown(), sqlite3MemSize(), and SQLITE_CONFIG_MALLOC.

Referenced by sqlite3_config(), and sqlite3MallocInit().

◆ sqlite3MemShutdown()

static void sqlite3MemShutdown ( void * NotUsed )

static

Definition at line 23813 of file sqlite3.c.

Referenced by sqlite3MemSetDefault().

◆ sqlite3MemSize()

static int sqlite3MemSize ( void * pPrior )

static

Definition at line 23724 of file sqlite3.c.

                                       {
#ifdef SQLITE_MALLOCSIZE
  assert( pPrior!=0 );
  return (int)SQLITE_MALLOCSIZE(pPrior);
#else
  sqlite3_int64 *p;
  assert( pPrior!=0 );

Referenced by sqlite3MemRealloc(), and sqlite3MemSetDefault().

◆ sqlite3MisuseError()

SQLITE_PRIVATE int sqlite3MisuseError ( int lineno )

Definition at line 164591 of file sqlite3.c.

164593 {

164594 testcase( sqlite3GlobalConfig.xLog!=0 );

◆ sqlite3MPrintf()

SQLITE_PRIVATE char * sqlite3MPrintf	(	sqlite3 *	db,
		const char *	zFormat,
			... )

Definition at line 29286 of file sqlite3.c.

29292 {

29293 va_list ap;

Referenced by attachFunc(), blobSeekToRow(), corruptSchema(), generateColumnNames(), renameEditSql(), selectExpander(), sqlite3_table_column_metadata(), sqlite3AlterBeginAddColumn(), sqlite3AnalysisLoad(), sqlite3ColumnsFromExprList(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3ExpandSubquery(), sqlite3GenerateConstraintChecks(), sqlite3InitOne(), sqlite3Pragma(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VtabCallCreate(), valueFromExpr(), vdbeCommit(), and vtabCallConstructor().

◆ sqlite3MulInt64()

SQLITE_PRIVATE int sqlite3MulInt64	(	i64 *	pA,
		i64	iB )

Definition at line 32614 of file sqlite3.c.

       {
    return sqlite3AddInt64(pA, -iB);
  }
#endif
}
SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){
#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
  return __builtin_mul_overflow(*pA, iB, pA);
#else
  i64 iA = *pA;
  if( iB>0 ){
    if( iA>LARGEST_INT64/iB ) return 1;
    if( iA<SMALLEST_INT64/iB ) return 1;
  }else if( iB<0 ){
    if( iA>0 ){
      if( iB<SMALLEST_INT64/iA ) return 1;
    }else if( iA<0 ){
      if( iB==SMALLEST_INT64 ) return 1;
      if( iA==SMALLEST_INT64 ) return 1;
      if( -iA>LARGEST_INT64/-iB ) return 1;

Referenced by sqlite3VdbeExec().

◆ sqlite3MultiWrite()

SQLITE_PRIVATE void sqlite3MultiWrite ( Parse * pParse )

Definition at line 115183 of file sqlite3.c.

                               : deleting one row then inserting another,
** inserting multiple rows in a table, or inserting a row and index entries.)
** If an abort occurs after some of these writes have completed, then it will

References Parse::isMultiWrite, and sqlite3ParseToplevel.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3RefillIndex(), sqlite3Update(), and updateVirtualTable().

◆ sqlite3MutexAlloc()

SQLITE_PRIVATE sqlite3_mutex * sqlite3MutexAlloc ( int id )

Definition at line 25931 of file sqlite3.c.

                                                       {
  if( !sqlite3GlobalConfig.bCoreMutex ){
    return 0;

Referenced by openDatabase(), osLocaltime(), pcache1Init(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_cancel_auto_extension(), sqlite3_initialize(), sqlite3_os_init(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3AutoLoadExtensions(), sqlite3BtreeOpen(), and sqlite3MallocInit().

◆ sqlite3MutexEnd()

SQLITE_PRIVATE int sqlite3MutexEnd ( void )

Definition at line 25906 of file sqlite3.c.

                                        {
  int rc = SQLITE_OK;
  if( sqlite3GlobalConfig.mutex.xMutexEnd ){
    rc = sqlite3GlobalConfig.mutex.xMutexEnd();
  }
 
#ifdef SQLITE_DEBUG

References GLOBAL, sqlite3GlobalConfig, and SQLITE_OK.

Referenced by sqlite3_shutdown().

◆ sqlite3MutexInit()

SQLITE_PRIVATE int sqlite3MutexInit ( void )

Definition at line 25860 of file sqlite3.c.

                                         {
  int rc = SQLITE_OK;
  if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
    /* If the xMutexAlloc method has not been set, then the user did not
    ** install a mutex implementation via sqlite3_config() prior to
    ** sqlite3_initialize() being called. This block copies pointers to
    ** the default implementation into the sqlite3GlobalConfig structure.
    */
    sqlite3_mutex_methods const *pFrom;
    sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
 
    if( sqlite3GlobalConfig.bCoreMutex ){
#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS
      pFrom = multiThreadedCheckMutex();
#else
      pFrom = sqlite3DefaultMutex();
#endif
    }else{
      pFrom = sqlite3NoopMutex();
    }
    pTo->xMutexInit = pFrom->xMutexInit;
    pTo->xMutexEnd = pFrom->xMutexEnd;
    pTo->xMutexFree = pFrom->xMutexFree;
    pTo->xMutexEnter = pFrom->xMutexEnter;
    pTo->xMutexTry = pFrom->xMutexTry;
    pTo->xMutexLeave = pFrom->xMutexLeave;
    pTo->xMutexHeld = pFrom->xMutexHeld;
    pTo->xMutexNotheld = pFrom->xMutexNotheld;
    sqlite3MemoryBarrier();
    pTo->xMutexAlloc = pFrom->xMutexAlloc;
  }
  assert( sqlite3GlobalConfig.mutex.xMutexInit );
  rc = sqlite3GlobalConfig.mutex.xMutexInit();
 
#ifdef SQLITE_DEBUG
  GLOBAL(int, mutexIsInit) = 1;

References GLOBAL, sqlite3DefaultMutex(), sqlite3GlobalConfig, sqlite3MemoryBarrier(), sqlite3NoopMutex(), SQLITE_OK, sqlite3_mutex_methods::xMutexAlloc, sqlite3_mutex_methods::xMutexEnd, sqlite3_mutex_methods::xMutexEnter, sqlite3_mutex_methods::xMutexFree, sqlite3_mutex_methods::xMutexHeld, sqlite3_mutex_methods::xMutexInit, sqlite3_mutex_methods::xMutexLeave, sqlite3_mutex_methods::xMutexNotheld, and sqlite3_mutex_methods::xMutexTry.

Referenced by sqlite3_initialize().

◆ sqlite3NameFromToken()

SQLITE_PRIVATE char * sqlite3NameFromToken	(	sqlite3 *	db,
		Token *	pName )

Definition at line 111142 of file sqlite3.c.

                                                                    {
  char *zName;
  if( pName ){
    zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);

References Token::n, sqlite3DbStrNDup(), sqlite3Dequote(), Token::z, and zName.

Referenced by sqlite3AlterRenameColumn(), sqlite3Analyze(), sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3FindDb(), sqlite3IdListAppend(), sqlite3Pragma(), sqlite3Reindex(), sqlite3SrcListAppend(), sqlite3SrcListAppendFromTerm(), sqlite3StartTable(), sqlite3VtabBeginParse(), sqlite3WithAdd(), and yy_reduce().

◆ sqlite3NestedParse()

SQLITE_PRIVATE void sqlite3NestedParse	(	Parse *	pParse,
		const char *	zFormat,
			... )

Definition at line 110647 of file sqlite3.c.

                                                                               {
  va_list ap;
  char *zSql;
  char *zErrMsg = 0;
  sqlite3 *db = pParse->db;
  char saveBuf[PARSE_TAIL_SZ];
 
  if( pParse->nErr ) return;
  assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
  va_start(ap, zFormat);
  zSql = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  if( zSql==0 ){
    /* This can result either from an OOM or because the formatted string
    ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set
    ** an error */
    if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
    pParse->nErr++;
    return;
  }
  pParse->nested++;
  memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
  memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);

References Parse::db, sqlite3::mallocFailed, Parse::nErr, Parse::nested, PARSE_TAIL, PARSE_TAIL_SZ, Parse::rc, sqlite3DbFree(), sqlite3RunParser(), sqlite3VMPrintf(), and SQLITE_TOOBIG.

Referenced by destroyRootPage(), openStatTable(), renameTestSchema(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3CreateIndex(), and sqlite3EndTable().

◆ sqlite3NoopDestructor()

SQLITE_PRIVATE void sqlite3NoopDestructor ( void * p )

Definition at line 76696 of file sqlite3.c.

◆ sqlite3NoopMutex()

SQLITE_PRIVATE sqlite3_mutex_methods const * sqlite3NoopMutex ( void )

Definition at line 26057 of file sqlite3.c.

                                            { UNUSED_PARAMETER(p); return; }
 
SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){
  static const sqlite3_mutex_methods sMutex = {
    noopMutexInit,
    noopMutexEnd,
    noopMutexAlloc,
    noopMutexFree,
    noopMutexEnter,
    noopMutexTry,
    noopMutexLeave,
 
    0,

Referenced by sqlite3MutexInit().

◆ sqlite3NotPureFunc()

SQLITE_PRIVATE int sqlite3NotPureFunc ( sqlite3_context * pCtx )

Definition at line 82849 of file sqlite3.c.

                                                            {
  const VdbeOp *pOp;
#ifdef SQLITE_ENABLE_STAT4
  if( pCtx->pVdbe==0 ) return 1;
#endif
  pOp = pCtx->pVdbe->aOp + pCtx->iOp;
  if( pOp->opcode==OP_PureFunc ){
    const char *zContext;
    char *zMsg;
    if( pOp->p5 & NC_IsCheck ){
      zContext = "a CHECK constraint";
    }else if( pOp->p5 & NC_GenCol ){
      zContext = "a generated column";
    }else{
      zContext = "an index";
    }
    zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s",
                           pCtx->pFunc->zName, zContext);

References Vdbe::aOp, sqlite3_context::iOp, NC_GenCol, NC_IsCheck, OP_PureFunc, VdbeOp::opcode, VdbeOp::p5, sqlite3_context::pFunc, sqlite3_context::pVdbe, sqlite3_free(), sqlite3_mprintf(), sqlite3_result_error(), and FuncDef::zName.

Referenced by parseDateOrTime(), and parseModifier().

◆ sqlite3OomClear()

SQLITE_PRIVATE void sqlite3OomClear ( sqlite3 * db )

Definition at line 28091 of file sqlite3.c.

                                                {
  if( db->mallocFailed && db->nVdbeExec==0 ){
    db->mallocFailed = 0;

References AtomicStore, Lookaside::bDisable, EnableLookaside, sqlite3::isInterrupted, sqlite3::lookaside, sqlite3::mallocFailed, sqlite3::nVdbeExec, and sqlite3::u1.

Referenced by columnName(), and sqlite3_errmsg16().

◆ sqlite3OomFault()

SQLITE_PRIVATE void sqlite3OomFault ( sqlite3 * db )

Definition at line 28071 of file sqlite3.c.

                                                {
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
      AtomicStore(&db->u1.isInterrupted, 1);
    }
    DisableLookaside;

References AtomicStore, sqlite3::bBenignMalloc, DisableLookaside, sqlite3::isInterrupted, sqlite3::mallocFailed, sqlite3::nVdbeExec, sqlite3::pParse, Parse::rc, SQLITE_NOMEM_BKPT, and sqlite3::u1.

Referenced by analysisLoader(), attachFunc(), createFunctionApi(), createTableStmt(), dbMallocRawFinish(), findCollSeqEntry(), growOpArray(), openDatabase(), schemaIsValid(), sqlite3_exec(), sqlite3AnalysisLoad(), sqlite3ColumnsFromExprList(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3FindFunction(), sqlite3IndexAffinityStr(), sqlite3InitCallback(), sqlite3InitOne(), sqlite3Pragma(), sqlite3RegisterPerConnectionBuiltinFunctions(), sqlite3Reprepare(), sqlite3RunParser(), sqlite3TableAffinity(), sqlite3TableLock(), sqlite3VdbeDisplayP4(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3VtabCreateModule(), sqlite3VtabMakeWritable(), valueFromExpr(), vtabBestIndex(), and vtabCallConstructor().

◆ sqlite3OpcodeName()

SQLITE_PRIVATE const char * sqlite3OpcodeName ( int i )

Definition at line 33160 of file sqlite3.c.

                                                   {
 static const char *const azName[] = {
    /*   0 */ "Savepoint"        OpHelp(""),
    /*   1 */ "AutoCommit"       OpHelp(""),
    /*   2 */ "Transaction"      OpHelp(""),
    /*   3 */ "SorterNext"       OpHelp(""),
    /*   4 */ "Prev"             OpHelp(""),
    /*   5 */ "Next"             OpHelp(""),
    /*   6 */ "Checkpoint"       OpHelp(""),
    /*   7 */ "JournalMode"      OpHelp(""),
    /*   8 */ "Vacuum"           OpHelp(""),
    /*   9 */ "VFilter"          OpHelp("iplan=r[P3] zplan='P4'"),
    /*  10 */ "VUpdate"          OpHelp("data=r[P3@P2]"),
    /*  11 */ "Goto"             OpHelp(""),
    /*  12 */ "Gosub"            OpHelp(""),
    /*  13 */ "InitCoroutine"    OpHelp(""),
    /*  14 */ "Yield"            OpHelp(""),
    /*  15 */ "MustBeInt"        OpHelp(""),
    /*  16 */ "Jump"             OpHelp(""),
    /*  17 */ "Once"             OpHelp(""),
    /*  18 */ "If"               OpHelp(""),
    /*  19 */ "Not"              OpHelp("r[P2]= !r[P1]"),
    /*  20 */ "IfNot"            OpHelp(""),
    /*  21 */ "IfNullRow"        OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"),
    /*  22 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
    /*  23 */ "SeekLE"           OpHelp("key=r[P3@P4]"),
    /*  24 */ "SeekGE"           OpHelp("key=r[P3@P4]"),
    /*  25 */ "SeekGT"           OpHelp("key=r[P3@P4]"),
    /*  26 */ "IfNotOpen"        OpHelp("if( !csr[P1] ) goto P2"),
    /*  27 */ "IfNoHope"         OpHelp("key=r[P3@P4]"),
    /*  28 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
    /*  29 */ "NotFound"         OpHelp("key=r[P3@P4]"),
    /*  30 */ "Found"            OpHelp("key=r[P3@P4]"),
    /*  31 */ "SeekRowid"        OpHelp("intkey=r[P3]"),
    /*  32 */ "NotExists"        OpHelp("intkey=r[P3]"),
    /*  33 */ "Last"             OpHelp(""),
    /*  34 */ "IfSmaller"        OpHelp(""),
    /*  35 */ "SorterSort"       OpHelp(""),
    /*  36 */ "Sort"             OpHelp(""),
    /*  37 */ "Rewind"           OpHelp(""),
    /*  38 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
    /*  39 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
    /*  40 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
    /*  41 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
    /*  42 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
    /*  43 */ "Or"               OpHelp("r[P3]=(r[P1] || r[P2])"),
    /*  44 */ "And"              OpHelp("r[P3]=(r[P1] && r[P2])"),
    /*  45 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
    /*  46 */ "Program"          OpHelp(""),
    /*  47 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
    /*  48 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
    /*  49 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
    /*  50 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
    /*  51 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
    /*  52 */ "Ne"               OpHelp("IF r[P3]!=r[P1]"),
    /*  53 */ "Eq"               OpHelp("IF r[P3]==r[P1]"),
    /*  54 */ "Gt"               OpHelp("IF r[P3]>r[P1]"),
    /*  55 */ "Le"               OpHelp("IF r[P3]<=r[P1]"),
    /*  56 */ "Lt"               OpHelp("IF r[P3]<r[P1]"),
    /*  57 */ "Ge"               OpHelp("IF r[P3]>=r[P1]"),
    /*  58 */ "ElseNotEq"        OpHelp(""),
    /*  59 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
    /*  60 */ "IncrVacuum"       OpHelp(""),
    /*  61 */ "VNext"            OpHelp(""),
    /*  62 */ "Init"             OpHelp("Start at P2"),
    /*  63 */ "PureFunc"         OpHelp("r[P3]=func(r[P2@NP])"),
    /*  64 */ "Function"         OpHelp("r[P3]=func(r[P2@NP])"),
    /*  65 */ "Return"           OpHelp(""),
    /*  66 */ "EndCoroutine"     OpHelp(""),
    /*  67 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
    /*  68 */ "Halt"             OpHelp(""),
    /*  69 */ "Integer"          OpHelp("r[P2]=P1"),
    /*  70 */ "Int64"            OpHelp("r[P2]=P4"),
    /*  71 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
    /*  72 */ "Null"             OpHelp("r[P2..P3]=NULL"),
    /*  73 */ "SoftNull"         OpHelp("r[P1]=NULL"),
    /*  74 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
    /*  75 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
    /*  76 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
    /*  77 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
    /*  78 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
    /*  79 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
    /*  80 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
    /*  81 */ "CollSeq"          OpHelp(""),
    /*  82 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
    /*  83 */ "RealAffinity"     OpHelp(""),
    /*  84 */ "Cast"             OpHelp("affinity(r[P1])"),
    /*  85 */ "Permutation"      OpHelp(""),
    /*  86 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
    /*  87 */ "IsTrue"           OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"),
    /*  88 */ "Offset"           OpHelp("r[P3] = sqlite_offset(P1)"),
    /*  89 */ "Column"           OpHelp("r[P3]=PX"),
    /*  90 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
    /*  91 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
    /*  92 */ "Count"            OpHelp("r[P2]=count()"),
    /*  93 */ "ReadCookie"       OpHelp(""),
    /*  94 */ "SetCookie"        OpHelp(""),
    /*  95 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
    /*  96 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
    /*  97 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
    /*  98 */ "OpenDup"          OpHelp(""),
    /*  99 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
    /* 100 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
    /* 101 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
    /* 102 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
    /* 103 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
    /* 104 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
    /* 105 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
    /* 106 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
    /* 107 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
    /* 108 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
    /* 109 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
    /* 110 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
    /* 111 */ "SorterOpen"       OpHelp(""),
    /* 112 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
    /* 113 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
    /* 114 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
    /* 115 */ "String8"          OpHelp("r[P2]='P4'"),
    /* 116 */ "Close"            OpHelp(""),
    /* 117 */ "ColumnsUsed"      OpHelp(""),
    /* 118 */ "SeekHit"          OpHelp("seekHit=P2"),
    /* 119 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
    /* 120 */ "NewRowid"         OpHelp("r[P2]=rowid"),
    /* 121 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
    /* 122 */ "Delete"           OpHelp(""),
    /* 123 */ "ResetCount"       OpHelp(""),
    /* 124 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
    /* 125 */ "SorterData"       OpHelp("r[P2]=data"),
    /* 126 */ "RowData"          OpHelp("r[P2]=data"),
    /* 127 */ "Rowid"            OpHelp("r[P2]=rowid"),
    /* 128 */ "NullRow"          OpHelp(""),
    /* 129 */ "SeekEnd"          OpHelp(""),
    /* 130 */ "IdxInsert"        OpHelp("key=r[P2]"),
    /* 131 */ "SorterInsert"     OpHelp("key=r[P2]"),
    /* 132 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
    /* 133 */ "DeferredSeek"     OpHelp("Move P3 to P1.rowid if needed"),
    /* 134 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
    /* 135 */ "FinishSeek"       OpHelp(""),
    /* 136 */ "Destroy"          OpHelp(""),
    /* 137 */ "Clear"            OpHelp(""),
    /* 138 */ "ResetSorter"      OpHelp(""),
    /* 139 */ "CreateBtree"      OpHelp("r[P2]=root iDb=P1 flags=P3"),
    /* 140 */ "SqlExec"          OpHelp(""),
    /* 141 */ "ParseSchema"      OpHelp(""),
    /* 142 */ "LoadAnalysis"     OpHelp(""),
    /* 143 */ "DropTable"        OpHelp(""),
    /* 144 */ "DropIndex"        OpHelp(""),
    /* 145 */ "DropTrigger"      OpHelp(""),
    /* 146 */ "IntegrityCk"      OpHelp(""),
    /* 147 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
    /* 148 */ "Param"            OpHelp(""),
    /* 149 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
    /* 150 */ "Real"             OpHelp("r[P2]=P4"),
    /* 151 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
    /* 152 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
    /* 153 */ "AggInverse"       OpHelp("accum=r[P3] inverse(r[P2@P5])"),
    /* 154 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
    /* 155 */ "AggStep1"         OpHelp("accum=r[P3] step(r[P2@P5])"),
    /* 156 */ "AggValue"         OpHelp("r[P3]=value N=P2"),
    /* 157 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
    /* 158 */ "Expire"           OpHelp(""),
    /* 159 */ "CursorLock"       OpHelp(""),
    /* 160 */ "CursorUnlock"     OpHelp(""),
    /* 161 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
    /* 162 */ "VBegin"           OpHelp(""),
    /* 163 */ "VCreate"          OpHelp(""),
    /* 164 */ "VDestroy"         OpHelp(""),
    /* 165 */ "VOpen"            OpHelp(""),
    /* 166 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
    /* 167 */ "VRename"          OpHelp(""),
    /* 168 */ "Pagecount"        OpHelp(""),
    /* 169 */ "MaxPgcnt"         OpHelp(""),
    /* 170 */ "Trace"            OpHelp(""),
    /* 171 */ "CursorHint"       OpHelp(""),
    /* 172 */ "ReleaseReg"       OpHelp("release r[P1@P2] mask P3"),

References OpHelp.

Referenced by sqlite3VdbeList().

◆ sqlite3OpenSchemaTable()

SQLITE_PRIVATE void sqlite3OpenSchemaTable	(	Parse *	p,
		int	iDb )

Definition at line 111157 of file sqlite3.c.

111163 {

111164 Vdbe *v = sqlite3GetVdbe(p);

Referenced by sqlite3StartTable().

◆ sqlite3OpenTable()

SQLITE_PRIVATE void sqlite3OpenTable	(	Parse *	pParse,
		int	iCur,
		int	iDb,
		Table *	pTab,
		int	opcode )

Definition at line 120573 of file sqlite3.c.

 {
  Vdbe *v;
  assert( !IsVirtual(pTab) );
  v = sqlite3GetVdbe(pParse);
  assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
  sqlite3TableLock(pParse, iDb, pTab->tnum,
                   (opcode==OP_OpenWrite)?1:0, pTab->zName);
  if( HasRowid(pTab) ){
    sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
    VdbeComment((v, "%s", pTab->zName));
  }else{
    Index *pPk = sqlite3PrimaryKeyIndex(pTab);
    assert( pPk!=0 );

References HasRowid, IsVirtual, Table::nNVCol, OP_OpenRead, OP_OpenWrite, sqlite3GetVdbe(), sqlite3PrimaryKeyIndex(), sqlite3TableLock(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Int(), sqlite3VdbeSetP4KeyInfo(), Table::tnum, Index::tnum, VdbeComment, and Table::zName.

Referenced by analyzeOneTable(), autoIncrementEnd(), fkLookupParent(), generateSortTail(), sqlite3FindInIndex(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3WhereBegin(), and xferOptimization().

◆ sqlite3OpenTableAndIndices()

SQLITE_PRIVATE int sqlite3OpenTableAndIndices	(	Parse *	pParse,
		Table *	pTab,
		int	op,
		u8	p5,
		int	iBase,
		u8 *	aToOpen,
		int *	piDataCur,
		int *	piIdxCur )

Definition at line 122930 of file sqlite3.c.

 {
  int i;
  int iDb;
  int iDataCur;
  Index *pIdx;
  Vdbe *v;
 
  assert( op==OP_OpenRead || op==OP_OpenWrite );
  assert( op==OP_OpenWrite || p5==0 );
  if( IsVirtual(pTab) ){
    /* This routine is a no-op for virtual tables. Leave the output
    ** variables *piDataCur and *piIdxCur uninitialized so that valgrind
    ** can detect if they are used by mistake in the caller. */
    return 0;
  }
  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  if( iBase<0 ) iBase = pParse->nTab;
  iDataCur = iBase++;
  if( piDataCur ) *piDataCur = iDataCur;
  if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
    sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
  }else{
    sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
  }
  if( piIdxCur ) *piIdxCur = iBase;
  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
    int iIdxCur = iBase++;
    assert( pIdx->pSchema==pTab->pSchema );
    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
      if( piDataCur ) *piDataCur = iIdxCur;
      p5 = 0;
    }
    if( aToOpen==0 || aToOpen[i+1] ){
      sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
      sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
      sqlite3VdbeChangeP5(v, p5);

References Parse::db, HasRowid, IsPrimaryKeyIndex, IsVirtual, Parse::nTab, OP_OpenRead, OP_OpenWrite, Table::pIndex, Index::pNext, Table::pSchema, Index::pSchema, sqlite3GetVdbe(), sqlite3OpenTable(), sqlite3SchemaToIndex(), sqlite3TableLock(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP5(), sqlite3VdbeSetP4KeyInfo(), Table::tnum, Index::tnum, VdbeComment, Table::zName, and Index::zName.

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), and sqlite3Update().

◆ sqlite3OpenTempDatabase()

SQLITE_PRIVATE int sqlite3OpenTempDatabase ( Parse * pParse )

Definition at line 115091 of file sqlite3.c.

                                                         {
  sqlite3 *db = pParse->db;
  if( db->aDb[1].pBt==0 && !pParse->explain ){
    int rc;
    Btree *pBt;
    static const int flags =
          SQLITE_OPEN_READWRITE |
          SQLITE_OPEN_CREATE |
          SQLITE_OPEN_EXCLUSIVE |
          SQLITE_OPEN_DELETEONCLOSE |
          SQLITE_OPEN_TEMP_DB;
 
    rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorMsg(pParse, "unable to open a temporary database "
        "file for storing temporary tables");
      pParse->rc = rc;
      return 1;
    }
    db->aDb[1].pBt = pBt;
    assert( db->aDb[1].pSchema );
    if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){

Referenced by findBtree(), sqlite3CodeVerifySchema(), and sqlite3Pragma().

◆ sqlite3OsAccess()

SQLITE_PRIVATE int sqlite3OsAccess	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		int	flags,
		int *	pResOut )

Definition at line 23188 of file sqlite3.c.

                                                                                     {
  DO_OS_MALLOC_TEST(0);
  assert( dirSync==0 || dirSync==1 );
  return pVfs->xDelete(pVfs, zPath, dirSync);
}
SQLITE_PRIVATE int sqlite3OsAccess(
  sqlite3_vfs *pVfs,
  const char *zPath,
  int flags,

References DO_OS_MALLOC_TEST, and sqlite3_vfs::xDelete.

Referenced by hasHotJournal(), pager_delsuper(), pager_playback(), pagerOpenWalIfPresent(), sqlite3PagerCloseWal(), sqlite3PagerSharedLock(), sqlite3Pragma(), and vdbeCommit().

◆ sqlite3OsCheckReservedLock()

SQLITE_PRIVATE int sqlite3OsCheckReservedLock	(	sqlite3_file *	id,
		int *	pResOut )

Definition at line 23075 of file sqlite3.c.

23077 {

23078 return id->pMethods->xUnlock(id, lockType);

Referenced by hasHotJournal().

◆ sqlite3OsClose()

SQLITE_PRIVATE void sqlite3OsClose ( sqlite3_file * pId )

Definition at line 23043 of file sqlite3.c.

23048 {

Referenced by hasHotJournal(), pager_delsuper(), pager_end_transaction(), pager_unlock(), releaseAllSavepoints(), sqlite3PagerClose(), sqlite3PagerCommitPhaseOne(), sqlite3PagerOpen(), sqlite3PagerOpenWal(), sqlite3PagerSetJournalMode(), sqlite3PagerSharedLock(), and sqlite3WalOpen().

◆ sqlite3OsCloseFree()

SQLITE_PRIVATE void sqlite3OsCloseFree ( sqlite3_file * pFile )

Definition at line 23278 of file sqlite3.c.

       {
    rc = SQLITE_NOMEM_BKPT;
  }
  return rc;
}

Referenced by vdbeCommit().

◆ sqlite3OsCurrentTimeInt64()

SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64	(	sqlite3_vfs *	pVfs,
		sqlite3_int64 *	pTimeOut )

Definition at line 23238 of file sqlite3.c.

                                                           {
  return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0;
}
SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
  int rc;
  /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
  ** method to get the current date and time if that method is available
  ** (if iVersion is 2 or greater and the function pointer is not NULL) and
  ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
  ** unavailable.
  */
  if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
    rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
  }else{
    double r;

Referenced by invokeProfileCallback(), sqlite3Step(), and sqlite3StmtCurrentTime().

◆ sqlite3OsDelete()

SQLITE_PRIVATE int sqlite3OsDelete	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		int	dirSync )

Definition at line 23183 of file sqlite3.c.

Referenced by hasHotJournal(), pager_delsuper(), pager_end_transaction(), pagerOpenWalIfPresent(), sqlite3PagerSetJournalMode(), and vdbeCommit().

◆ sqlite3OsDeviceCharacteristics()

SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics ( sqlite3_file * id )

Definition at line 23117 of file sqlite3.c.

23118 {

23119 int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;

sqlite3_io_methods::xSectorSize

int(* xSectorSize)(sqlite3_file *)

Definition sqlite3.c:1843

References sqlite3_file::pMethods, SQLITE_DEFAULT_SECTOR_SIZE, and sqlite3_io_methods::xSectorSize.

Referenced by hasHotJournal(), jrnlBufferSize(), pager_end_transaction(), pager_unlock(), setSectorSize(), sqlite3PagerCommitPhaseOne(), sqlite3PagerOpen(), sqlite3WalOpen(), syncJournal(), vdbeCommit(), and writeJournalHdr().

◆ sqlite3OsDlClose()

SQLITE_PRIVATE void sqlite3OsDlClose	(	sqlite3_vfs *	pVfs,
		void *	pHandle )

Definition at line 23217 of file sqlite3.c.

23219 {

Referenced by sqlite3LoadExtension().

◆ sqlite3OsDlError()

SQLITE_PRIVATE void sqlite3OsDlError	(	sqlite3_vfs *	pVfs,
		int	nByte,
		char *	zBufOut )

Definition at line 23211 of file sqlite3.c.

23213 {

Referenced by sqlite3LoadExtension().

◆ sqlite3OsDlOpen()

SQLITE_PRIVATE void * sqlite3OsDlOpen	(	sqlite3_vfs *	pVfs,
		const char *	zPath )

Definition at line 23208 of file sqlite3.c.

Referenced by sqlite3LoadExtension().

◆ sqlite3OsFetch()

SQLITE_PRIVATE int sqlite3OsFetch	(	sqlite3_file *	id,
		i64	iOff,
		int	iAmt,
		void **	pp )

Definition at line 23153 of file sqlite3.c.

                                                                        {
  return id->pMethods->xUnfetch(id, iOff, p);
}
#else

Referenced by vdbeSorterMapFile().

◆ sqlite3OsFileControl()

SQLITE_PRIVATE int sqlite3OsFileControl	(	sqlite3_file *	id,
		int	op,
		void *	pArg )

Definition at line 23088 of file sqlite3.c.

                                                                             {
  if( id->pMethods==0 ) return SQLITE_NOTFOUND;
#ifdef SQLITE_TEST
  if( op!=SQLITE_FCNTL_COMMIT_PHASETWO
   && op!=SQLITE_FCNTL_LOCK_TIMEOUT
  ){
    /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
    ** is using a regular VFS, it is called after the corresponding
    ** transaction has been committed. Injecting a fault at this point
    ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
    ** but the transaction is committed anyway.
    **
    ** The core must call OsFileControl() though, not OsFileControlHint(),
    ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
    ** means the commit really has failed and an error should be returned
    ** to the user.  */

References sqlite3_file::pMethods, SQLITE_FCNTL_COMMIT_PHASETWO, SQLITE_FCNTL_LOCK_TIMEOUT, and SQLITE_NOTFOUND.

Referenced by databaseIsUnmoved(), pager_end_transaction(), sqlite3BtreeCopyFile(), sqlite3PagerCommitPhaseOne(), sqlite3PagerSync(), sqlite3Pragma(), and walCheckpoint().

◆ sqlite3OsFileControlHint()

SQLITE_PRIVATE void sqlite3OsFileControlHint	(	sqlite3_file *	id,
		int	op,
		void *	pArg )

Definition at line 23109 of file sqlite3.c.

Referenced by pager_playback(), pager_write_pagelist(), sqlite3BtreeOpen(), sqlite3PagerCommitPhaseOne(), sqlite3PagerSetBusyHandler(), sqlite3Pragma(), vdbeSorterOpenTempFile(), and walCheckpoint().

◆ sqlite3OsFileSize()

SQLITE_PRIVATE int sqlite3OsFileSize	(	sqlite3_file *	id,
		i64 *	pSize )

Definition at line 23064 of file sqlite3.c.

                                                             {
  DO_OS_MALLOC_TEST(id);
  return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK;

Referenced by backupTruncateFile(), pager_delsuper(), pager_playback(), pager_truncate(), pagerPagecount(), pagerSyncHotJournal(), readSuperJournal(), sqlite3PagerSetPagesize(), walBeginShmUnreliable(), walCheckpoint(), walIndexRecover(), writeSuperJournal(), and zeroJournalHdr().

◆ sqlite3OsFullPathname()

SQLITE_PRIVATE int sqlite3OsFullPathname	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		int	nPathOut,
		char *	zPathOut )

Definition at line 23197 of file sqlite3.c.

 {
  DO_OS_MALLOC_TEST(0);
  return pVfs->xAccess(pVfs, zPath, flags, pResOut);
}
SQLITE_PRIVATE int sqlite3OsFullPathname(
  sqlite3_vfs *pVfs,
  const char *zPath,
  int nPathOut,
  char *zPathOut

References DO_OS_MALLOC_TEST, and sqlite3_vfs::xAccess.

Referenced by sqlite3BtreeOpen(), and sqlite3PagerOpen().

◆ sqlite3OsGetLastError()

SQLITE_PRIVATE int sqlite3OsGetLastError ( sqlite3_vfs * pVfs )

Definition at line 23235 of file sqlite3.c.

23237 {

◆ sqlite3OsInit()

SQLITE_PRIVATE int sqlite3OsInit ( void )

Definition at line 23290 of file sqlite3.c.

23295 {

References sqlite3_free(), sqlite3_malloc(), sqlite3_os_init(), and SQLITE_NOMEM_BKPT.

Referenced by sqlite3_initialize().

◆ sqlite3OsLock()

SQLITE_PRIVATE int sqlite3OsLock	(	sqlite3_file *	id,
		int	lockType )

Definition at line 23068 of file sqlite3.c.

                                                                  {
  DO_OS_MALLOC_TEST(id);
  return id->pMethods->xFileSize(id, pSize);

Referenced by pagerLockDb().

◆ sqlite3OsOpen()

SQLITE_PRIVATE int sqlite3OsOpen	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		sqlite3_file *	pFile,
		int	flags,
		int *	pFlagsOut )

Definition at line 23166 of file sqlite3.c.

 {
  int rc;
  DO_OS_MALLOC_TEST(0);
  /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
  ** down into the VFS layer.  Some SQLITE_OPEN_ flags (for example,
  ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before

References DO_OS_MALLOC_TEST.

Referenced by hasHotJournal(), pager_delsuper(), pagerOpentemp(), sqlite3JournalOpen(), sqlite3PagerOpen(), sqlite3PagerSharedLock(), and sqlite3WalOpen().

◆ sqlite3OsOpenMalloc()

SQLITE_PRIVATE int sqlite3OsOpenMalloc	(	sqlite3_vfs *	pVfs,
		const char *	zFile,
		sqlite3_file **	ppFile,
		int	flags,
		int *	pOutFlags )

Definition at line 23256 of file sqlite3.c.

 {
  int rc;
  sqlite3_file *pFile;
  pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
  if( pFile ){
    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
    if( rc!=SQLITE_OK ){
      sqlite3_free(pFile);
    }else{
      *ppFile = pFile;
    }

Referenced by vdbeCommit(), and vdbeSorterOpenTempFile().

◆ sqlite3OsRandomness()

SQLITE_PRIVATE int sqlite3OsRandomness	(	sqlite3_vfs *	pVfs,
		int	nByte,
		char *	zBufOut )

Definition at line 23221 of file sqlite3.c.

                                                                      {
  pVfs->xDlClose(pVfs, pHandle);
}
#endif /* SQLITE_OMIT_LOAD_EXTENSION */
SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
  if( sqlite3Config.iPrngSeed ){
    memset(zBufOut, 0, nByte);
    if( ALWAYS(nByte>(signed)sizeof(unsigned)) ) nByte = sizeof(unsigned int);
    memcpy(zBufOut, &sqlite3Config.iPrngSeed, nByte);
    return SQLITE_OK;

◆ sqlite3OsRead()

SQLITE_PRIVATE int sqlite3OsRead	(	sqlite3_file *	id,
		void *	pBuf,
		int	amt,
		i64	offset )

Definition at line 23049 of file sqlite3.c.

                     {
    pId->pMethods->xClose(pId);
    pId->pMethods = 0;
  }

References sqlite3_file::pMethods, and sqlite3_io_methods::xClose.

Referenced by accessPayload(), hasHotJournal(), pager_delsuper(), pager_playback_one_page(), read32bits(), readDbPage(), readJournalHdr(), readSuperJournal(), sqlite3PagerReadFileheader(), sqlite3PagerSharedLock(), syncJournal(), vdbePmaReadBlob(), vdbePmaReaderSeek(), walBeginShmUnreliable(), walCheckpoint(), walIndexRecover(), and walRewriteChecksums().

◆ sqlite3OsSectorSize()

SQLITE_PRIVATE int sqlite3OsSectorSize ( sqlite3_file * id )

Definition at line 23113 of file sqlite3.c.

                                                                                  {
  if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg);
}

◆ sqlite3OsShmBarrier()

SQLITE_PRIVATE void sqlite3OsShmBarrier ( sqlite3_file * id )

Definition at line 23124 of file sqlite3.c.

23126 {

◆ sqlite3OsShmLock()

SQLITE_PRIVATE int sqlite3OsShmLock	(	sqlite3_file *	id,
		int	offset,
		int	n,
		int	flags )

Definition at line 23121 of file sqlite3.c.

23122 {

23123 return id->pMethods->xDeviceCharacteristics(id);

Referenced by walLockExclusive(), and walLockShared().

◆ sqlite3OsShmMap()

SQLITE_PRIVATE int sqlite3OsShmMap	(	sqlite3_file *	id,
		int	iPage,
		int	pgsz,
		int	bExtend,
		void volatile **	pp )

Definition at line 23130 of file sqlite3.c.

                                                                      {
  return id->pMethods->xShmUnmap(id, deleteFlag);
}
SQLITE_PRIVATE int sqlite3OsShmMap(
  sqlite3_file *id,               /* Database file handle */
  int iPage,
  int pgsz,
  int bExtend,                    /* True to extend file if necessary */

Referenced by walBeginShmUnreliable(), and walIndexPageRealloc().

◆ sqlite3OsShmUnmap()

SQLITE_PRIVATE int sqlite3OsShmUnmap	(	sqlite3_file *	id,
		int	deleteFlag )

Definition at line 23127 of file sqlite3.c.

23129 {

◆ sqlite3OsSleep()

SQLITE_PRIVATE int sqlite3OsSleep	(	sqlite3_vfs *	pVfs,
		int	nMicro )

Definition at line 23232 of file sqlite3.c.

       {
    return pVfs->xRandomness(pVfs, nByte, zBufOut);
  }

Referenced by sqliteDefaultBusyCallback(), and walTryBeginRead().

◆ sqlite3OsSync()

SQLITE_PRIVATE int sqlite3OsSync	(	sqlite3_file *	id,
		int	flags )

Definition at line 23060 of file sqlite3.c.

23062 {

23063 return id->pMethods->xTruncate(id, size);

Referenced by pager_end_transaction(), pagerSyncHotJournal(), sqlite3PagerSync(), syncJournal(), vdbeCommit(), walCheckpoint(), walWriteToLog(), and zeroJournalHdr().

◆ sqlite3OsTruncate()

SQLITE_PRIVATE int sqlite3OsTruncate	(	sqlite3_file *	id,
		i64	size )

Definition at line 23057 of file sqlite3.c.

23058 {

23059 DO_OS_MALLOC_TEST(id);

Referenced by backupTruncateFile(), pager_end_transaction(), pager_truncate(), sqlite3PagerSavepoint(), walCheckpoint(), writeSuperJournal(), and zeroJournalHdr().

◆ sqlite3OsUnfetch()

SQLITE_PRIVATE int sqlite3OsUnfetch	(	sqlite3_file *	id,
		i64	iOff,
		void *	p )

Definition at line 23157 of file sqlite3.c.

23158 {

23159 *pp = 0;

References SQLITE_OK.

Referenced by pager_unlock(), pagerBeginReadTransaction(), sqlite3PagerSharedLock(), sqlite3WalCheckpoint(), and vdbePmaReaderSeek().

◆ sqlite3OsUnlock()

SQLITE_PRIVATE int sqlite3OsUnlock	(	sqlite3_file *	id,
		int	lockType )

Definition at line 23072 of file sqlite3.c.

23073 {

23074 DO_OS_MALLOC_TEST(id);

Referenced by pagerUnlockDb().

◆ sqlite3OsWrite()

SQLITE_PRIVATE int sqlite3OsWrite	(	sqlite3_file *	id,
		const void *	pBuf,
		int	amt,
		i64	offset )

Definition at line 23053 of file sqlite3.c.

                                                                                   {
  DO_OS_MALLOC_TEST(id);
  return id->pMethods->xRead(id, pBuf, amt, offset);

Referenced by pager_incr_changecounter(), pager_playback_one_page(), pager_truncate(), pager_write_pagelist(), subjournalPage(), syncJournal(), vdbeCommit(), vdbePmaWriterFinish(), walCheckpoint(), walRewriteChecksums(), walWriteToLog(), write32bits(), writeJournalHdr(), writeSuperJournal(), and zeroJournalHdr().

◆ sqlite3PageFree()

SQLITE_PRIVATE void sqlite3PageFree ( void * p )

Definition at line 50260 of file sqlite3.c.

Referenced by balance(), sqlite3BtreeIntegrityCheck(), sqlite3PagerClose(), sqlite3PagerOpen(), and sqlite3PagerSetPagesize().

◆ sqlite3PageMalloc()

SQLITE_PRIVATE void * sqlite3PageMalloc ( int sz )

Definition at line 50252 of file sqlite3.c.

Referenced by allocateTempSpace(), balance(), sqlite3BtreeIntegrityCheck(), and sqlite3PagerSetPagesize().

◆ sqlite3PagerBackupPtr()

SQLITE_PRIVATE sqlite3_backup ** sqlite3PagerBackupPtr ( Pager * pPager )

Definition at line 59073 of file sqlite3.c.

References Pager::pBackup.

◆ sqlite3PagerBegin()

SQLITE_PRIVATE int sqlite3PagerBegin	(	Pager *	pPager,
		int	exFlag,
		int	subjInMemory )

Definition at line 57521 of file sqlite3.c.

                                                                                 {
  int rc = SQLITE_OK;
 
  if( pPager->errCode ) return pPager->errCode;
  assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
  pPager->subjInMemory = (u8)subjInMemory;
 
  if( ALWAYS(pPager->eState==PAGER_READER) ){
    assert( pPager->pInJournal==0 );
 
    if( pagerUseWal(pPager) ){
      /* If the pager is configured to use locking_mode=exclusive, and an
      ** exclusive lock on the database is not already held, obtain it now.
      */
      if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
        rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
        if( rc!=SQLITE_OK ){
          return rc;
        }
        (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
      }
 
      /* Grab the write lock on the log file. If successful, upgrade to
      ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
      ** The busy-handler is not invoked if another connection already
      ** holds the write-lock. If possible, the upper layer will call it.
      */
      rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
    }else{
      /* Obtain a RESERVED lock on the database file. If the exFlag parameter
      ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
      ** busy-handler callback can be used when upgrading to the EXCLUSIVE
      ** lock, but not when obtaining the RESERVED lock.
      */
      rc = pagerLockDb(pPager, RESERVED_LOCK);
      if( rc==SQLITE_OK && exFlag ){
        rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
      }
    }
 
    if( rc==SQLITE_OK ){
      /* Change to WRITER_LOCKED state.
      **
      ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
      ** when it has an open transaction, but never to DBMOD or FINISHED.
      ** This is because in those states the code to roll back savepoint
      ** transactions may copy data from the sub-journal into the database
      ** file as well as into the page cache. Which would be incorrect in
      ** WAL mode.
      */
      pPager->eState = PAGER_WRITER_LOCKED;
      pPager->dbHintSize = pPager->dbSize;
      pPager->dbFileSize = pPager->dbSize;
      pPager->dbOrigSize = pPager->dbSize;
      pPager->journalOff = 0;
    }
 
    assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
    assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );

References ALWAYS, Pager::dbFileSize, Pager::dbHintSize, Pager::dbOrigSize, Pager::dbSize, Pager::errCode, Pager::eState, EXCLUSIVE_LOCK, Pager::exclusiveMode, Pager::journalOff, PAGER_ERROR, PAGER_READER, pager_wait_on_lock(), PAGER_WRITER_LOCKED, PAGERID, pagerLockDb(), PAGERTRACE, pagerUseWal, Pager::pInJournal, Pager::pWal, RESERVED_LOCK, sqlite3WalBeginWriteTransaction(), sqlite3WalExclusiveMode(), SQLITE_OK, and Pager::subjInMemory.

Referenced by sqlite3BtreeBeginTrans().

◆ sqlite3PagerCacheStat()

SQLITE_PRIVATE void sqlite3PagerCacheStat	(	Pager *	pPager,
		int	eStat,
		int	reset,
		int *	pnVal )

Definition at line 58474 of file sqlite3.c.

                                                                                          {
 
  assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
       || eStat==SQLITE_DBSTATUS_CACHE_MISS
       || eStat==SQLITE_DBSTATUS_CACHE_WRITE
       || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1
  );
 
  assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
  assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
  assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1
           && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 );
 

References Pager::aStat, PAGER_STAT_HIT, PAGER_STAT_MISS, PAGER_STAT_SPILL, PAGER_STAT_WRITE, SQLITE_DBSTATUS_CACHE_HIT, SQLITE_DBSTATUS_CACHE_MISS, and SQLITE_DBSTATUS_CACHE_WRITE.

◆ sqlite3PagerCheckpoint()

SQLITE_PRIVATE int sqlite3PagerCheckpoint	(	Pager *	pPager,
		sqlite3 *	db,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt )

Definition at line 59096 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  if( pPager->pWal ){
    rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
        (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
        pPager->pBusyHandlerArg,

References Pager::pageSize, Pager::pBusyHandlerArg, Pager::pTmpSpace, Pager::pWal, sqlite3WalCheckpoint(), SQLITE_CHECKPOINT_PASSIVE, SQLITE_OK, Pager::walSyncFlags, and Pager::xBusyHandler.

Referenced by sqlite3BtreeCheckpoint().

◆ sqlite3PagerClearCache()

SQLITE_PRIVATE void sqlite3PagerClearCache ( Pager * pPager )

Definition at line 59081 of file sqlite3.c.

Referenced by sqlite3BtreeCopyFile().

◆ sqlite3PagerClose()

SQLITE_PRIVATE int sqlite3PagerClose	(	Pager *	pPager,
		sqlite3 *	db )

Definition at line 55785 of file sqlite3.c.

                                                                {
  u8 *pTmp = (u8*)pPager->pTmpSpace;
  assert( db || pagerUseWal(pPager)==0 );
  assert( assert_pager_state(pPager) );
  disable_simulated_io_errors();
  sqlite3BeginBenignMalloc();
  pagerFreeMapHdrs(pPager);
  /* pPager->errCode = 0; */
  pPager->exclusiveMode = 0;
#ifndef SQLITE_OMIT_WAL
  {
    u8 *a = 0;
    assert( db || pPager->pWal==0 );
    if( db && 0==(db->flags & SQLITE_NoCkptOnClose)
     && SQLITE_OK==databaseIsUnmoved(pPager)
    ){
      a = pTmp;
    }
    sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
    pPager->pWal = 0;
  }
#endif
  pager_reset(pPager);
  if( MEMDB ){
    pager_unlock(pPager);
  }else{
    /* If it is open, sync the journal file before calling UnlockAndRollback.
    ** If this is not done, then an unsynced portion of the open journal
    ** file may be played back into the database. If a power failure occurs
    ** while this is happening, the database could become corrupt.
    **
    ** If an error occurs while trying to sync the journal, shift the pager
    ** into the ERROR state. This causes UnlockAndRollback to unlock the
    ** database and close the journal file without attempting to roll it
    ** back or finalize it. The next database user will have to do hot-journal
    ** rollback before accessing the database file.
    */
    if( isOpen(pPager->jfd) ){
      pager_error(pPager, pagerSyncHotJournal(pPager));
    }
    pagerUnlockAndRollback(pPager);
  }
  sqlite3EndBenignMalloc();
  enable_simulated_io_errors();
  PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
  IOTRACE(("CLOSE %p\n", pPager))
  sqlite3OsClose(pPager->jfd);
  sqlite3OsClose(pPager->fd);
  sqlite3PageFree(pTmp);
  sqlite3PcacheClose(pPager->pPCache);

References Pager::aSavepoint, databaseIsUnmoved(), disable_simulated_io_errors, enable_simulated_io_errors, Pager::exclusiveMode, Pager::fd, sqlite3::flags, IOTRACE, isOpen, Pager::jfd, MEMDB, pager_error(), pager_reset(), pager_unlock(), pagerFreeMapHdrs(), PAGERID, pagerSyncHotJournal(), PAGERTRACE, pagerUnlockAndRollback(), pagerUseWal, Pager::pageSize, Pager::pInJournal, Pager::pPCache, Pager::pTmpSpace, Pager::pWal, Pager::sjfd, sqlite3_free(), sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), sqlite3OsClose(), sqlite3PageFree(), sqlite3PcacheClose(), sqlite3WalClose(), SQLITE_NoCkptOnClose, SQLITE_OK, and Pager::walSyncFlags.

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerCloseWal()

SQLITE_PRIVATE int sqlite3PagerCloseWal	(	Pager *	pPager,
		sqlite3 *	db )

Definition at line 59237 of file sqlite3.c.

                                                                   {
  int rc = SQLITE_OK;
 
  assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
 
  /* If the log file is not already open, but does exist in the file-system,
  ** it may need to be checkpointed before the connection can switch to
  ** rollback mode. Open it now so this can happen.
  */
  if( !pPager->pWal ){
    int logexists = 0;
    rc = pagerLockDb(pPager, SHARED_LOCK);
    if( rc==SQLITE_OK ){
      rc = sqlite3OsAccess(
          pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
      );
    }
    if( rc==SQLITE_OK && logexists ){
      rc = pagerOpenWal(pPager);
    }
  }
 
  /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
  ** the database file, the log and log-summary files will be deleted.
  */
  if( rc==SQLITE_OK && pPager->pWal ){
    rc = pagerExclusiveLock(pPager);
    if( rc==SQLITE_OK ){
      rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
                           pPager->pageSize, (u8*)pPager->pTmpSpace);
      pPager->pWal = 0;

References Pager::exclusiveMode, Pager::journalMode, PAGER_JOURNALMODE_WAL, pagerExclusiveLock(), pagerFixMaplimit(), pagerLockDb(), pagerOpenWal(), pagerUnlockDb(), Pager::pageSize, Pager::pTmpSpace, Pager::pVfs, Pager::pWal, SHARED_LOCK, sqlite3OsAccess(), sqlite3WalClose(), SQLITE_ACCESS_EXISTS, SQLITE_OK, Pager::walSyncFlags, and Pager::zWal.

Referenced by sqlite3VdbeExec().

◆ sqlite3PagerCommitPhaseOne()

SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne	(	Pager *	pPager,
		const char *	zSuper,
		int	noSync )

Definition at line 58064 of file sqlite3.c.

 {
  int rc = SQLITE_OK;             /* Return code */
 
  assert( pPager->eState==PAGER_WRITER_LOCKED
       || pPager->eState==PAGER_WRITER_CACHEMOD
       || pPager->eState==PAGER_WRITER_DBMOD
       || pPager->eState==PAGER_ERROR
  );
  assert( assert_pager_state(pPager) );
 
  /* If a prior error occurred, report that error again. */
  if( NEVER(pPager->errCode) ) return pPager->errCode;
 
  /* Provide the ability to easily simulate an I/O error during testing */
  if( sqlite3FaultSim(400) ) return SQLITE_IOERR;
 
  PAGERTRACE(("DATABASE SYNC: File=%s zSuper=%s nSize=%d\n",
      pPager->zFilename, zSuper, pPager->dbSize));
 
  /* If no database changes have been made, return early. */
  if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
 
  assert( MEMDB==0 || pPager->tempFile );
  assert( isOpen(pPager->fd) || pPager->tempFile );
  if( 0==pagerFlushOnCommit(pPager, 1) ){
    /* If this is an in-memory db, or no pages have been written to, or this
    ** function has already been called, it is mostly a no-op.  However, any
    ** backup in progress needs to be restarted.  */
    sqlite3BackupRestart(pPager->pBackup);
  }else{
    PgHdr *pList;
    if( pagerUseWal(pPager) ){
      PgHdr *pPageOne = 0;
      pList = sqlite3PcacheDirtyList(pPager->pPCache);
      if( pList==0 ){
        /* Must have at least one page for the WAL commit flag.
        ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
        rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
        pList = pPageOne;
        pList->pDirty = 0;
      }
      assert( rc==SQLITE_OK );
      if( ALWAYS(pList) ){
        rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
      }
      sqlite3PagerUnref(pPageOne);
      if( rc==SQLITE_OK ){
        sqlite3PcacheCleanAll(pPager->pPCache);
      }
    }else{
      /* The bBatch boolean is true if the batch-atomic-write commit method
      ** should be used.  No rollback journal is created if batch-atomic-write
      ** is enabled.
      */
#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
      sqlite3_file *fd = pPager->fd;
      int bBatch = zSuper==0    /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
        && (sqlite3OsDeviceCharacteristics(fd) & SQLITE_IOCAP_BATCH_ATOMIC)
        && !pPager->noSync
        && sqlite3JournalIsInMemory(pPager->jfd);
#else
#     define bBatch 0
#endif
 
#ifdef SQLITE_ENABLE_ATOMIC_WRITE
      /* The following block updates the change-counter. Exactly how it
      ** does this depends on whether or not the atomic-update optimization
      ** was enabled at compile time, and if this transaction meets the
      ** runtime criteria to use the operation:
      **
      **    * The file-system supports the atomic-write property for
      **      blocks of size page-size, and
      **    * This commit is not part of a multi-file transaction, and
      **    * Exactly one page has been modified and store in the journal file.
      **
      ** If the optimization was not enabled at compile time, then the
      ** pager_incr_changecounter() function is called to update the change
      ** counter in 'indirect-mode'. If the optimization is compiled in but
      ** is not applicable to this transaction, call sqlite3JournalCreate()
      ** to make sure the journal file has actually been created, then call
      ** pager_incr_changecounter() to update the change-counter in indirect
      ** mode.
      **
      ** Otherwise, if the optimization is both enabled and applicable,
      ** then call pager_incr_changecounter() to update the change-counter
      ** in 'direct' mode. In this case the journal file will never be
      ** created for this transaction.
      */
      if( bBatch==0 ){
        PgHdr *pPg;
        assert( isOpen(pPager->jfd)
            || pPager->journalMode==PAGER_JOURNALMODE_OFF
            || pPager->journalMode==PAGER_JOURNALMODE_WAL
            );
        if( !zSuper && isOpen(pPager->jfd)
         && pPager->journalOff==jrnlBufferSize(pPager)
         && pPager->dbSize>=pPager->dbOrigSize
         && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
        ){
          /* Update the db file change counter via the direct-write method. The
          ** following call will modify the in-memory representation of page 1
          ** to include the updated change counter and then write page 1
          ** directly to the database file. Because of the atomic-write
          ** property of the host file-system, this is safe.
          */
          rc = pager_incr_changecounter(pPager, 1);
        }else{
          rc = sqlite3JournalCreate(pPager->jfd);
          if( rc==SQLITE_OK ){
            rc = pager_incr_changecounter(pPager, 0);
          }
        }
      }
#else  /* SQLITE_ENABLE_ATOMIC_WRITE */
#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
      if( zSuper ){
        rc = sqlite3JournalCreate(pPager->jfd);
        if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
        assert( bBatch==0 );
      }
#endif
      rc = pager_incr_changecounter(pPager, 0);
#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */
      if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
 
      /* Write the super-journal name into the journal file. If a
      ** super-journal file name has already been written to the journal file,
      ** or if zSuper is NULL (no super-journal), then this call is a no-op.
      */
      rc = writeSuperJournal(pPager, zSuper);
      if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
 
      /* Sync the journal file and write all dirty pages to the database.
      ** If the atomic-update optimization is being used, this sync will not
      ** create the journal file or perform any real IO.
      **
      ** Because the change-counter page was just modified, unless the
      ** atomic-update optimization is used it is almost certain that the
      ** journal requires a sync here. However, in locking_mode=exclusive
      ** on a system under memory pressure it is just possible that this is
      ** not the case. In this case it is likely enough that the redundant
      ** xSync() call will be changed to a no-op by the OS anyhow.
      */
      rc = syncJournal(pPager, 0);
      if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
 
      pList = sqlite3PcacheDirtyList(pPager->pPCache);
#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
      if( bBatch ){
        rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, 0);
        if( rc==SQLITE_OK ){
          rc = pager_write_pagelist(pPager, pList);
          if( rc==SQLITE_OK ){
            rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0);
          }
          if( rc!=SQLITE_OK ){
            sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0);
          }
        }
 
        if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){
          rc = sqlite3JournalCreate(pPager->jfd);
          if( rc!=SQLITE_OK ){
            sqlite3OsClose(pPager->jfd);
            goto commit_phase_one_exit;
          }
          bBatch = 0;
        }else{
          sqlite3OsClose(pPager->jfd);
        }
      }
#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
 
      if( bBatch==0 ){
        rc = pager_write_pagelist(pPager, pList);
      }
      if( rc!=SQLITE_OK ){
        assert( rc!=SQLITE_IOERR_BLOCKED );
        goto commit_phase_one_exit;
      }
      sqlite3PcacheCleanAll(pPager->pPCache);
 
      /* If the file on disk is smaller than the database image, use
      ** pager_truncate to grow the file here. This can happen if the database
      ** image was extended as part of the current transaction and then the
      ** last page in the db image moved to the free-list. In this case the
      ** last page is never written out to disk, leaving the database file
      ** undersized. Fix this now if it is the case.  */
      if( pPager->dbSize>pPager->dbFileSize ){
        Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
        assert( pPager->eState==PAGER_WRITER_DBMOD );
        rc = pager_truncate(pPager, nNew);
        if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
      }
 
      /* Finally, sync the database file. */
      if( !noSync ){
        rc = sqlite3PagerSync(pPager, zSuper);
      }
      IOTRACE(("DBSYNC %p\n", pPager))
    }
  }
 

References ALWAYS, bBatch, Pager::dbFileSize, Pager::dbOrigSize, Pager::dbSize, Pager::errCode, Pager::eState, Pager::fd, IOTRACE, isOpen, Pager::jfd, Pager::journalMode, Pager::journalOff, jrnlBufferSize(), MEMDB, NEVER, Pager::noSync, PAGER_ERROR, pager_incr_changecounter(), PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_WAL, PAGER_MJ_PGNO, pager_truncate(), pager_write_pagelist(), PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGER_WRITER_FINISHED, PAGER_WRITER_LOCKED, pagerFlushOnCommit(), PAGERTRACE, pagerUseWal, pagerWalFrames(), Pager::pBackup, PgHdr::pDirty, Pager::pPCache, sqlite3BackupRestart(), sqlite3FaultSim(), sqlite3JournalIsInMemory(), sqlite3OsClose(), sqlite3OsDeviceCharacteristics(), sqlite3OsFileControl(), sqlite3OsFileControlHint(), sqlite3PagerGet(), sqlite3PagerSync(), sqlite3PagerUnref(), sqlite3PcacheCleanAll(), sqlite3PcacheDirtyList(), SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, SQLITE_IOCAP_BATCH_ATOMIC, SQLITE_IOERR, SQLITE_IOERR_BLOCKED, SQLITE_IOERR_NOMEM, SQLITE_OK, syncJournal(), Pager::tempFile, writeSuperJournal(), and Pager::zFilename.

Referenced by sqlite3BtreeCommitPhaseOne().

◆ sqlite3PagerCommitPhaseTwo()

SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo ( Pager * pPager )

Definition at line 58294 of file sqlite3.c.

                                                            {
  int rc = SQLITE_OK;                  /* Return code */
 
  /* This routine should not be called if a prior error has occurred.
  ** But if (due to a coding error elsewhere in the system) it does get
  ** called, just return the same error code without doing anything. */
  if( NEVER(pPager->errCode) ) return pPager->errCode;
  pPager->iDataVersion++;
 
  assert( pPager->eState==PAGER_WRITER_LOCKED
       || pPager->eState==PAGER_WRITER_FINISHED
       || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
  );
  assert( assert_pager_state(pPager) );
 
  /* An optimization. If the database was not actually modified during
  ** this transaction, the pager is running in exclusive-mode and is
  ** using persistent journals, then this function is a no-op.
  **
  ** The start of the journal file currently contains a single journal
  ** header with the nRec field set to 0. If such a journal is used as
  ** a hot-journal during hot-journal rollback, 0 changes will be made
  ** to the database file. So there is no need to zero the journal
  ** header. Since the pager is in exclusive mode, there is no need
  ** to drop any locks either.
  */
  if( pPager->eState==PAGER_WRITER_LOCKED
   && pPager->exclusiveMode
   && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
  ){
    assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
    pPager->eState = PAGER_READER;
    return SQLITE_OK;

References Pager::errCode, Pager::eState, Pager::exclusiveMode, Pager::iDataVersion, JOURNAL_HDR_SZ, Pager::journalMode, Pager::journalOff, NEVER, pager_end_transaction(), pager_error(), PAGER_JOURNALMODE_PERSIST, PAGER_READER, PAGER_WRITER_CACHEMOD, PAGER_WRITER_FINISHED, PAGER_WRITER_LOCKED, PAGERID, PAGERTRACE, pagerUseWal, Pager::setSuper, and SQLITE_OK.

Referenced by sqlite3BtreeCommitPhaseTwo().

◆ sqlite3PagerDataVersion()

SQLITE_PRIVATE u32 sqlite3PagerDataVersion ( Pager * pPager )

Definition at line 53456 of file sqlite3.c.

Referenced by sqlite3BtreeGetMeta().

◆ sqlite3PagerDontWrite()

SQLITE_PRIVATE void sqlite3PagerDontWrite ( DbPage * pPg )

Definition at line 57882 of file sqlite3.c.

                                                     {
  Pager *pPager = pPg->pPager;
  if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
    PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
    IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))

References PgHdr::flags, IOTRACE, Pager::nSavepoint, pager_set_pagehash, PAGERID, PAGERTRACE, PGHDR_DIRTY, PGHDR_DONT_WRITE, PGHDR_NEED_SYNC, PgHdr::pgno, PgHdr::pPager, Pager::tempFile, and testcase.

Referenced by freePage2().

◆ sqlite3PagerExclusiveLock()

SQLITE_PRIVATE int sqlite3PagerExclusiveLock ( Pager * pPager )

Definition at line 58022 of file sqlite3.c.

                                                           {
  int rc = pPager->errCode;
  assert( assert_pager_state(pPager) );
  if( rc==SQLITE_OK ){
    assert( pPager->eState==PAGER_WRITER_CACHEMOD
         || pPager->eState==PAGER_WRITER_DBMOD
         || pPager->eState==PAGER_WRITER_LOCKED
    );
    assert( assert_pager_state(pPager) );

References Pager::errCode, Pager::eState, EXCLUSIVE_LOCK, pager_wait_on_lock(), PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGER_WRITER_LOCKED, pagerUseWal, and SQLITE_OK.

Referenced by syncJournal(), and vdbeCommit().

◆ sqlite3PagerFile()

SQLITE_PRIVATE sqlite3_file * sqlite3PagerFile ( Pager * pPager )

Definition at line 58694 of file sqlite3.c.

References Pager::fd.

Referenced by accessPayload(), sqlite3BtreeCopyFile(), sqlite3BtreeOpen(), and sqlite3Pragma().

◆ sqlite3PagerFilename()

SQLITE_PRIVATE const char * sqlite3PagerFilename	(	const Pager *	pPager,
		int	nullIfMemDb )

Definition at line 58677 of file sqlite3.c.

Referenced by sqlite3BtreeGetFilename(), sqlite3BtreeOpen(), and sqlite3VdbeExec().

◆ sqlite3PagerFlush()

SQLITE_PRIVATE int sqlite3PagerFlush ( Pager * pPager )

Definition at line 56293 of file sqlite3.c.

                                                   {
  int rc = pPager->errCode;
  if( !MEMDB ){
    PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
    assert( assert_pager_state(pPager) );
    while( rc==SQLITE_OK && pList ){
      PgHdr *pNext = pList->pDirty;
      if( pList->nRef==0 ){
        rc = pagerStress((void*)pPager, pList);
      }

◆ sqlite3PagerGet()

SQLITE_PRIVATE int sqlite3PagerGet	(	Pager *	pPager,
		Pgno	pgno,
		DbPage **	ppPage,
		int	clrFlag )

Definition at line 57342 of file sqlite3.c.

Referenced by accessPayload(), backupOnePage(), btreeGetPage(), checkList(), getAndInitPage(), pager_incr_changecounter(), pager_playback_one_page(), pagerWriteLargeSector(), ptrmapGet(), ptrmapPut(), sqlite3PagerCommitPhaseOne(), and sqlite3PagerMovepage().

◆ sqlite3PagerGetData()

SQLITE_PRIVATE void * sqlite3PagerGetData ( DbPage * pPg )

Definition at line 58890 of file sqlite3.c.

Referenced by accessPayload(), backupOnePage(), btreeInitPage(), btreePageFromDbPage(), checkList(), getAndInitPage(), ptrmapGet(), and ptrmapPut().

◆ sqlite3PagerGetExtra()

SQLITE_PRIVATE void * sqlite3PagerGetExtra ( DbPage * pPg )

Definition at line 58899 of file sqlite3.c.

Referenced by backupOnePage(), btreeInitPage(), btreePageFromDbPage(), getAndInitPage(), pageReinit(), and ptrmapPut().

◆ sqlite3PagerGetJournalMode()

SQLITE_PRIVATE int sqlite3PagerGetJournalMode ( Pager * pPager )

Definition at line 59037 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and vdbeCommit().

◆ sqlite3PagerIsMemdb()

SQLITE_PRIVATE int sqlite3PagerIsMemdb ( Pager * pPager )

Definition at line 58497 of file sqlite3.c.

Referenced by backupOnePage(), and vdbeCommit().

◆ sqlite3PagerIsreadonly()

SQLITE_PRIVATE u8 sqlite3PagerIsreadonly ( Pager * pPager )

Definition at line 58410 of file sqlite3.c.

Referenced by sqlite3BtreeBeginTrans(), and sqlite3BtreeOpen().

◆ sqlite3PagerJournalname()

SQLITE_PRIVATE const char * sqlite3PagerJournalname ( Pager * pPager )

Definition at line 58713 of file sqlite3.c.

◆ sqlite3PagerJournalSizeLimit()

SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit	(	Pager *	pPager,
		i64	iLimit )

Definition at line 59059 of file sqlite3.c.

59065 {

References Pager::journalSizeLimit, Pager::pWal, and sqlite3WalLimit().

Referenced by sqlite3Pragma().

◆ sqlite3PagerJrnlFile()

SQLITE_PRIVATE sqlite3_file * sqlite3PagerJrnlFile ( Pager * pPager )

Definition at line 58702 of file sqlite3.c.

58708 {

◆ sqlite3PagerLockingMode()

SQLITE_PRIVATE int sqlite3PagerLockingMode	(	Pager *	pPager,
		int	eMode )

Definition at line 58913 of file sqlite3.c.

                                                                    {
  assert( eMode==PAGER_LOCKINGMODE_QUERY
            || eMode==PAGER_LOCKINGMODE_NORMAL
            || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
  assert( PAGER_LOCKINGMODE_QUERY<0 );
  assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );

References Pager::exclusiveMode, PAGER_LOCKINGMODE_EXCLUSIVE, PAGER_LOCKINGMODE_NORMAL, PAGER_LOCKINGMODE_QUERY, Pager::pWal, sqlite3WalHeapMemory(), and Pager::tempFile.

Referenced by attachFunc(), openDatabase(), and sqlite3Pragma().

◆ sqlite3PagerLookup()

SQLITE_PRIVATE DbPage * sqlite3PagerLookup	(	Pager *	pPager,
		Pgno	pgno )

Definition at line 57362 of file sqlite3.c.

                                                                   {
  sqlite3_pcache_page *pPage;
  assert( pPager!=0 );
  assert( pgno!=0 );

References Pager::hasHeldSharedLock, Pager::pPCache, sqlite3PcacheFetch(), and sqlite3PcacheFetchFinish().

Referenced by btreePageLookup(), pager_end_transaction(), pager_playback_one_page(), pagerUndoCallback(), pagerWriteLargeSector(), and sqlite3PagerMovepage().

◆ sqlite3PagerMaxPageCount()

SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount	(	Pager *	pPager,
		Pgno	mxPage )

Definition at line 55464 of file sqlite3.c.

                                                                        {
  if( mxPage>0 ){
    pPager->mxPgno = mxPage;
  }
  assert( pPager->eState!=PAGER_OPEN );      /* Called only by OP_MaxPgcnt */

References Pager::eState, Pager::mxPgno, and PAGER_OPEN.

Referenced by sqlite3BtreeMaxPageCount().

◆ sqlite3PagerMemUsed()

SQLITE_PRIVATE int sqlite3PagerMemUsed ( Pager * pPager )

Definition at line 58427 of file sqlite3.c.

58433 {

References Pager::nExtra, Pager::pageSize, Pager::pPCache, sqlite3MallocSize(), and sqlite3PcachePagecount().

◆ sqlite3PagerMovepage()

SQLITE_PRIVATE int sqlite3PagerMovepage	(	Pager *	pPager,
		DbPage *	pPg,
		Pgno	pgno,
		int	isCommit )

Definition at line 58743 of file sqlite3.c.

                                                                                            {
  PgHdr *pPgOld;               /* The page being overwritten. */
  Pgno needSyncPgno = 0;       /* Old value of pPg->pgno, if sync is required */
  int rc;                      /* Return code */
  Pgno origPgno;               /* The original page number */
 
  assert( pPg->nRef>0 );
  assert( pPager->eState==PAGER_WRITER_CACHEMOD
       || pPager->eState==PAGER_WRITER_DBMOD
  );
  assert( assert_pager_state(pPager) );
 
  /* In order to be able to rollback, an in-memory database must journal
  ** the page we are moving from.
  */
  assert( pPager->tempFile || !MEMDB );
  if( pPager->tempFile ){
    rc = sqlite3PagerWrite(pPg);
    if( rc ) return rc;
  }
 
  /* If the page being moved is dirty and has not been saved by the latest
  ** savepoint, then save the current contents of the page into the
  ** sub-journal now. This is required to handle the following scenario:
  **
  **   BEGIN;
  **     <journal page X, then modify it in memory>
  **     SAVEPOINT one;
  **       <Move page X to location Y>
  **     ROLLBACK TO one;
  **
  ** If page X were not written to the sub-journal here, it would not
  ** be possible to restore its contents when the "ROLLBACK TO one"
  ** statement were is processed.
  **
  ** subjournalPage() may need to allocate space to store pPg->pgno into
  ** one or more savepoint bitvecs. This is the reason this function
  ** may return SQLITE_NOMEM.
  */
  if( (pPg->flags & PGHDR_DIRTY)!=0
   && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
  ){
    return rc;
  }
 
  PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
      PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
  IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
 
  /* If the journal needs to be sync()ed before page pPg->pgno can
  ** be written to, store pPg->pgno in local variable needSyncPgno.
  **
  ** If the isCommit flag is set, there is no need to remember that
  ** the journal needs to be sync()ed before database page pPg->pgno
  ** can be written to. The caller has already promised not to write to it.
  */
  if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
    needSyncPgno = pPg->pgno;
    assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
            pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
    assert( pPg->flags&PGHDR_DIRTY );
  }
 
  /* If the cache contains a page with page-number pgno, remove it
  ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
  ** page pgno before the 'move' operation, it needs to be retained
  ** for the page moved there.
  */
  pPg->flags &= ~PGHDR_NEED_SYNC;
  pPgOld = sqlite3PagerLookup(pPager, pgno);
  assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
  if( pPgOld ){
    if( pPgOld->nRef>1 ){
      sqlite3PagerUnrefNotNull(pPgOld);
      return SQLITE_CORRUPT_BKPT;
    }
    pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
    if( pPager->tempFile ){
      /* Do not discard pages from an in-memory database since we might
      ** need to rollback later.  Just move the page out of the way. */
      sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
    }else{
      sqlite3PcacheDrop(pPgOld);
    }
  }
 
  origPgno = pPg->pgno;
  sqlite3PcacheMove(pPg, pgno);
  sqlite3PcacheMakeDirty(pPg);
 
  /* For an in-memory database, make sure the original page continues
  ** to exist, in case the transaction needs to roll back.  Use pPgOld
  ** as the original page since it has already been allocated.
  */
  if( pPager->tempFile && pPgOld ){
    sqlite3PcacheMove(pPgOld, origPgno);
    sqlite3PagerUnrefNotNull(pPgOld);
  }
 
  if( needSyncPgno ){
    /* If needSyncPgno is non-zero, then the journal file needs to be
    ** sync()ed before any data is written to database file page needSyncPgno.
    ** Currently, no such page exists in the page-cache and the
    ** "is journaled" bitvec flag has been set. This needs to be remedied by
    ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
    ** flag.
    **
    ** If the attempt to load the page into the page-cache fails, (due
    ** to a malloc() or IO failure), clear the bit in the pInJournal[]
    ** array. Otherwise, if the page is loaded and written again in
    ** this transaction, it may be written to the database file before
    ** it is synced into the journal file. This way, it may end up in
    ** the journal file twice, but that is not a problem.
    */
    PgHdr *pPgHdr;
    rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
    if( rc!=SQLITE_OK ){
      if( needSyncPgno<=pPager->dbOrigSize ){
        assert( pPager->pTmpSpace!=0 );
        sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
      }
      return rc;
    }
    pPgHdr->flags |= PGHDR_NEED_SYNC;

References CORRUPT_DB, Pager::dbOrigSize, Pager::dbSize, Pager::eState, PgHdr::flags, IOTRACE, Pager::journalMode, MEMDB, PgHdr::nRef, PAGER_JOURNALMODE_OFF, PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGERID, PAGERTRACE, PGHDR_DIRTY, PGHDR_NEED_SYNC, PgHdr::pgno, Pager::pInJournal, Pager::pTmpSpace, sqlite3BitvecClear(), sqlite3PagerGet(), sqlite3PagerLookup(), sqlite3PagerUnrefNotNull(), sqlite3PagerWrite(), sqlite3PcacheDrop(), sqlite3PcacheMakeDirty(), sqlite3PcacheMove(), SQLITE_CORRUPT_BKPT, SQLITE_OK, subjournalPageIfRequired(), and Pager::tempFile.

Referenced by relocatePage().

◆ sqlite3PagerOkToChangeJournalMode()

SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode ( Pager * pPager )

Definition at line 59046 of file sqlite3.c.

References Pager::eState, isOpen, Pager::jfd, Pager::journalOff, NEVER, and PAGER_WRITER_CACHEMOD.

Referenced by sqlite3VdbeExec().

◆ sqlite3PagerOpen()

SQLITE_PRIVATE int sqlite3PagerOpen	(	sqlite3_vfs *	pVfs,
		Pager **	ppPager,
		const char *	zFilename,
		int	nExtra,
		int	flags,
		int	vfsFlags,
		void()(DbPage )	xReinit )

Definition at line 56342 of file sqlite3.c.

 {
  u8 *pPtr;
  Pager *pPager = 0;       /* Pager object to allocate and return */
  int rc = SQLITE_OK;      /* Return code */
  int tempFile = 0;        /* True for temp files (incl. in-memory files) */
  int memDb = 0;           /* True if this is an in-memory file */
#ifdef SQLITE_ENABLE_DESERIALIZE
  int memJM = 0;           /* Memory journal mode */
#else
# define memJM 0
#endif
  int readOnly = 0;        /* True if this is a read-only file */
  int journalFileSize;     /* Bytes to allocate for each journal fd */
  char *zPathname = 0;     /* Full path to database file */
  int nPathname = 0;       /* Number of bytes in zPathname */
  int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
  int pcacheSize = sqlite3PcacheSize();       /* Bytes to allocate for PCache */
  u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE;  /* Default page size */
  const char *zUri = 0;    /* URI args to copy */
  int nUriByte = 1;        /* Number of bytes of URI args at *zUri */
  int nUri = 0;            /* Number of URI parameters */
 
  /* Figure out how much space is required for each journal file-handle
  ** (there are two of them, the main journal and the sub-journal).  */
  journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
 
  /* Set the output variable to NULL in case an error occurs. */
  *ppPager = 0;
 
#ifndef SQLITE_OMIT_MEMORYDB
  if( flags & PAGER_MEMORY ){
    memDb = 1;
    if( zFilename && zFilename[0] ){
      zPathname = sqlite3DbStrDup(0, zFilename);
      if( zPathname==0  ) return SQLITE_NOMEM_BKPT;
      nPathname = sqlite3Strlen30(zPathname);
      zFilename = 0;
    }
  }
#endif
 
  /* Compute and store the full pathname in an allocated buffer pointed
  ** to by zPathname, length nPathname. Or, if this is a temporary file,
  ** leave both nPathname and zPathname set to 0.
  */
  if( zFilename && zFilename[0] ){
    const char *z;
    nPathname = pVfs->mxPathname+1;
    zPathname = sqlite3DbMallocRaw(0, nPathname*2);
    if( zPathname==0 ){
      return SQLITE_NOMEM_BKPT;
    }
    zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
    rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
    if( rc!=SQLITE_OK ){
      if( rc==SQLITE_OK_SYMLINK ){
        if( vfsFlags & SQLITE_OPEN_NOFOLLOW ){
          rc = SQLITE_CANTOPEN_SYMLINK;
        }else{
          rc = SQLITE_OK;
        }
      }
    }
    nPathname = sqlite3Strlen30(zPathname);
    z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
    while( *z ){
      z += strlen(z)+1;
      z += strlen(z)+1;
      nUri++;
    }
    nUriByte = (int)(&z[1] - zUri);
    assert( nUriByte>=1 );
    if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
      /* This branch is taken when the journal path required by
      ** the database being opened will be more than pVfs->mxPathname
      ** bytes in length. This means the database cannot be opened,
      ** as it will not be possible to open the journal file or even
      ** check for a hot-journal before reading.
      */
      rc = SQLITE_CANTOPEN_BKPT;
    }
    if( rc!=SQLITE_OK ){
      sqlite3DbFree(0, zPathname);
      return rc;
    }
  }
 
  /* Allocate memory for the Pager structure, PCache object, the
  ** three file descriptors, the database file name and the journal
  ** file name. The layout in memory is as follows:
  **
  **     Pager object                    (sizeof(Pager) bytes)
  **     PCache object                   (sqlite3PcacheSize() bytes)
  **     Database file handle            (pVfs->szOsFile bytes)
  **     Sub-journal file handle         (journalFileSize bytes)
  **     Main journal file handle        (journalFileSize bytes)
  **     Ptr back to the Pager           (sizeof(Pager*) bytes)
  **     \0\0\0\0 database prefix        (4 bytes)
  **     Database file name              (nPathname+1 bytes)
  **     URI query parameters            (nUriByte bytes)
  **     Journal filename                (nPathname+8+1 bytes)
  **     WAL filename                    (nPathname+4+1 bytes)
  **     \0\0\0 terminator               (3 bytes)
  **
  ** Some 3rd-party software, over which we have no control, depends on
  ** the specific order of the filenames and the \0 separators between them
  ** so that it can (for example) find the database filename given the WAL
  ** filename without using the sqlite3_filename_database() API.  This is a
  ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party
  ** software is in widespread use, so we try to avoid changing the filename
  ** order and formatting if possible.  In particular, the details of the
  ** filename format expected by 3rd-party software should be as follows:
  **
  **   - Main Database Path
  **   - \0
  **   - Multiple URI components consisting of:
  **     - Key
  **     - \0
  **     - Value
  **     - \0
  **   - \0
  **   - Journal Path
  **   - \0
  **   - WAL Path (zWALName)
  **   - \0
  **
  ** The sqlite3_create_filename() interface and the databaseFilename() utility
  ** that is used by sqlite3_filename_database() and kin also depend on the
  ** specific formatting and order of the various filenames, so if the format
  ** changes here, be sure to change it there as well.
  */
  pPtr = (u8 *)sqlite3MallocZero(
    ROUND8(sizeof(*pPager)) +            /* Pager structure */
    ROUND8(pcacheSize) +                 /* PCache object */
    ROUND8(pVfs->szOsFile) +             /* The main db file */
    journalFileSize * 2 +                /* The two journal files */
    sizeof(pPager) +                     /* Space to hold a pointer */
    4 +                                  /* Database prefix */
    nPathname + 1 +                      /* database filename */
    nUriByte +                           /* query parameters */
    nPathname + 8 + 1 +                  /* Journal filename */
#ifndef SQLITE_OMIT_WAL
    nPathname + 4 + 1 +                  /* WAL filename */
#endif
    3                                    /* Terminator */
  );
  assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
  if( !pPtr ){
    sqlite3DbFree(0, zPathname);
    return SQLITE_NOMEM_BKPT;
  }
  pPager = (Pager*)pPtr;                  pPtr += ROUND8(sizeof(*pPager));
  pPager->pPCache = (PCache*)pPtr;        pPtr += ROUND8(pcacheSize);
  pPager->fd = (sqlite3_file*)pPtr;       pPtr += ROUND8(pVfs->szOsFile);
  pPager->sjfd = (sqlite3_file*)pPtr;     pPtr += journalFileSize;
  pPager->jfd =  (sqlite3_file*)pPtr;     pPtr += journalFileSize;
  assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
  memcpy(pPtr, &pPager, sizeof(pPager));  pPtr += sizeof(pPager);
 
  /* Fill in the Pager.zFilename and pPager.zQueryParam fields */
                                          pPtr += 4;  /* Skip zero prefix */
  pPager->zFilename = (char*)pPtr;
  if( nPathname>0 ){
    memcpy(pPtr, zPathname, nPathname);   pPtr += nPathname + 1;
    if( zUri ){
      memcpy(pPtr, zUri, nUriByte);       pPtr += nUriByte;
    }else{
                                          pPtr++;
    }
  }
 
 
  /* Fill in Pager.zJournal */
  if( nPathname>0 ){
    pPager->zJournal = (char*)pPtr;
    memcpy(pPtr, zPathname, nPathname);   pPtr += nPathname;
    memcpy(pPtr, "-journal",8);           pPtr += 8 + 1;
#ifdef SQLITE_ENABLE_8_3_NAMES
    sqlite3FileSuffix3(zFilename,pPager->zJournal);
    pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1);
#endif
  }else{
    pPager->zJournal = 0;
  }
 
#ifndef SQLITE_OMIT_WAL
  /* Fill in Pager.zWal */
  if( nPathname>0 ){
    pPager->zWal = (char*)pPtr;
    memcpy(pPtr, zPathname, nPathname);   pPtr += nPathname;
    memcpy(pPtr, "-wal", 4);              pPtr += 4 + 1;
#ifdef SQLITE_ENABLE_8_3_NAMES
    sqlite3FileSuffix3(zFilename, pPager->zWal);
    pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
#endif
  }else{
    pPager->zWal = 0;
  }
#endif
 
  if( nPathname ) sqlite3DbFree(0, zPathname);
  pPager->pVfs = pVfs;
  pPager->vfsFlags = vfsFlags;
 
  /* Open the pager file.
  */
  if( zFilename && zFilename[0] ){
    int fout = 0;                    /* VFS flags returned by xOpen() */
    rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
    assert( !memDb );
#ifdef SQLITE_ENABLE_DESERIALIZE
    memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
#endif
    readOnly = (fout&SQLITE_OPEN_READONLY)!=0;
 
    /* If the file was successfully opened for read/write access,
    ** choose a default page size in case we have to create the
    ** database file. The default page size is the maximum of:
    **
    **    + SQLITE_DEFAULT_PAGE_SIZE,
    **    + The value returned by sqlite3OsSectorSize()
    **    + The largest page size that can be written atomically.
    */
    if( rc==SQLITE_OK ){
      int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
      if( !readOnly ){
        setSectorSize(pPager);
        assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
        if( szPageDflt<pPager->sectorSize ){
          if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
            szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
          }else{
            szPageDflt = (u32)pPager->sectorSize;
          }
        }
#ifdef SQLITE_ENABLE_ATOMIC_WRITE
        {
          int ii;
          assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
          assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
          assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
          for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
            if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
              szPageDflt = ii;
            }
          }
        }
#endif
      }
      pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
      if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0
       || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
          vfsFlags |= SQLITE_OPEN_READONLY;
          goto act_like_temp_file;
      }
    }
  }else{
    /* If a temporary file is requested, it is not opened immediately.
    ** In this case we accept the default page size and delay actually
    ** opening the file until the first call to OsWrite().
    **
    ** This branch is also run for an in-memory database. An in-memory
    ** database is the same as a temp-file that is never written out to
    ** disk and uses an in-memory rollback journal.
    **
    ** This branch also runs for files marked as immutable.
    */
act_like_temp_file:
    tempFile = 1;
    pPager->eState = PAGER_READER;     /* Pretend we already have a lock */
    pPager->eLock = EXCLUSIVE_LOCK;    /* Pretend we are in EXCLUSIVE mode */
    pPager->noLock = 1;                /* Do no locking */
    readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
  }
 
  /* The following call to PagerSetPagesize() serves to set the value of
  ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
  */
  if( rc==SQLITE_OK ){
    assert( pPager->memDb==0 );
    rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
    testcase( rc!=SQLITE_OK );
  }
 
  /* Initialize the PCache object. */
  if( rc==SQLITE_OK ){
    nExtra = ROUND8(nExtra);
    assert( nExtra>=8 && nExtra<1000 );
    rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
                       !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
  }
 
  /* If an error occurred above, free the  Pager structure and close the file.
  */
  if( rc!=SQLITE_OK ){
    sqlite3OsClose(pPager->fd);
    sqlite3PageFree(pPager->pTmpSpace);
    sqlite3_free(pPager);
    return rc;
  }
 
  PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
  IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
 
  pPager->useJournal = (u8)useJournal;
  /* pPager->stmtOpen = 0; */
  /* pPager->stmtInUse = 0; */
  /* pPager->nRef = 0; */
  /* pPager->stmtSize = 0; */
  /* pPager->stmtJSize = 0; */
  /* pPager->nPage = 0; */
  pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
  /* pPager->state = PAGER_UNLOCK; */
  /* pPager->errMask = 0; */
  pPager->tempFile = (u8)tempFile;
  assert( tempFile==PAGER_LOCKINGMODE_NORMAL
          || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
  assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
  pPager->exclusiveMode = (u8)tempFile;
  pPager->changeCountDone = pPager->tempFile;
  pPager->memDb = (u8)memDb;
  pPager->readOnly = (u8)readOnly;
  assert( useJournal || pPager->tempFile );
  pPager->noSync = pPager->tempFile;
  if( pPager->noSync ){
    assert( pPager->fullSync==0 );
    assert( pPager->extraSync==0 );
    assert( pPager->syncFlags==0 );
    assert( pPager->walSyncFlags==0 );
  }else{
    pPager->fullSync = 1;
    pPager->extraSync = 0;
    pPager->syncFlags = SQLITE_SYNC_NORMAL;
    pPager->walSyncFlags = SQLITE_SYNC_NORMAL | (SQLITE_SYNC_NORMAL<<2);
  }
  /* pPager->pFirst = 0; */
  /* pPager->pFirstSynced = 0; */
  /* pPager->pLast = 0; */
  pPager->nExtra = (u16)nExtra;
  pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
  assert( isOpen(pPager->fd) || tempFile );
  setSectorSize(pPager);
  if( !useJournal ){
    pPager->journalMode = PAGER_JOURNALMODE_OFF;
  }else if( memDb || memJM ){
    pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
  }
  /* pPager->xBusyHandler = 0; */
  /* pPager->pBusyHandlerArg = 0; */
  pPager->xReiniter = xReinit;
  setGetterMethod(pPager);

References Pager::changeCountDone, EIGHT_BYTE_ALIGNMENT, Pager::eLock, Pager::eState, EXCLUSIVE_LOCK, Pager::exclusiveMode, Pager::extraSync, Pager::fd, FILEHANDLEID, Pager::fullSync, IOTRACE, isOpen, Pager::jfd, Pager::journalMode, Pager::journalSizeLimit, Pager::memDb, memJM, sqlite3_vfs::mxPathname, Pager::mxPgno, Pager::nExtra, Pager::noLock, Pager::noSync, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_LOCKINGMODE_EXCLUSIVE, PAGER_LOCKINGMODE_NORMAL, PAGER_MEMORY, PAGER_OMIT_JOURNAL, PAGER_READER, pagerStress(), PAGERTRACE, Pager::pPCache, Pager::pTmpSpace, Pager::pVfs, Pager::readOnly, ROUND8, Pager::sectorSize, setGetterMethod(), setSectorSize(), Pager::sjfd, sqlite3_free(), sqlite3_uri_boolean(), sqlite3DbFree(), sqlite3DbMallocRaw(), sqlite3DbStrDup(), sqlite3FileSuffix3, sqlite3JournalSize(), sqlite3MallocZero(), sqlite3OsClose(), sqlite3OsDeviceCharacteristics(), sqlite3OsFullPathname(), sqlite3OsOpen(), sqlite3PageFree(), sqlite3PagerSetPagesize(), sqlite3PcacheOpen(), sqlite3PcacheSize(), sqlite3Strlen30(), SQLITE_CANTOPEN_BKPT, SQLITE_CANTOPEN_SYMLINK, SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT, SQLITE_DEFAULT_PAGE_SIZE, SQLITE_INT_TO_PTR, SQLITE_IOCAP_ATOMIC, SQLITE_IOCAP_ATOMIC512, SQLITE_IOCAP_ATOMIC64K, SQLITE_IOCAP_IMMUTABLE, SQLITE_MAX_DEFAULT_PAGE_SIZE, SQLITE_MAX_PAGE_COUNT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OK_SYMLINK, SQLITE_OPEN_MEMORY, SQLITE_OPEN_NOFOLLOW, SQLITE_OPEN_READONLY, SQLITE_SYNC_NORMAL, Pager::syncFlags, sqlite3_vfs::szOsFile, Pager::tempFile, testcase, Pager::useJournal, Pager::vfsFlags, Pager::walSyncFlags, Pager::xReiniter, Pager::zFilename, Pager::zJournal, and Pager::zWal.

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerOpenSavepoint()

SQLITE_PRIVATE int sqlite3PagerOpenSavepoint	(	Pager *	pPager,
		int	n )

Definition at line 58556 of file sqlite3.c.

                                                                           {
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
 

Referenced by sqlite3BtreeBeginStmt(), and sqlite3BtreeBeginTrans().

◆ sqlite3PagerOpenWal()

SQLITE_PRIVATE int sqlite3PagerOpenWal	(	Pager *	pPager,
		int *	pisOpen )

Definition at line 59198 of file sqlite3.c.

 {
  int rc = SQLITE_OK;             /* Return code */
 
  assert( assert_pager_state(pPager) );
  assert( pPager->eState==PAGER_OPEN   || pbOpen );
  assert( pPager->eState==PAGER_READER || !pbOpen );
  assert( pbOpen==0 || *pbOpen==0 );
  assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
 
  if( !pPager->tempFile && !pPager->pWal ){
    if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
 
    /* Close any rollback journal previously open */
    sqlite3OsClose(pPager->jfd);
 
    rc = pagerOpenWal(pPager);
    if( rc==SQLITE_OK ){
      pPager->journalMode = PAGER_JOURNALMODE_WAL;
      pPager->eState = PAGER_OPEN;
    }

References Pager::eState, Pager::jfd, Pager::journalMode, PAGER_JOURNALMODE_WAL, PAGER_OPEN, PAGER_READER, pagerOpenWal(), Pager::pWal, sqlite3OsClose(), sqlite3PagerWalSupported(), SQLITE_CANTOPEN, SQLITE_OK, and Pager::tempFile.

Referenced by lockBtree(), and pagerOpenWalIfPresent().

◆ sqlite3PagerPagecount()

SQLITE_PRIVATE void sqlite3PagerPagecount	(	Pager *	pPager,
		int *	pnPage )

Definition at line 55542 of file sqlite3.c.

References Pager::dbSize, Pager::eState, PAGER_READER, and PAGER_WRITER_FINISHED.

Referenced by lockBtree().

◆ sqlite3PagerPageRefcount()

SQLITE_PRIVATE int sqlite3PagerPageRefcount ( DbPage * pPage )

Definition at line 58438 of file sqlite3.c.

Referenced by allocateBtreePage(), btreeGetUnusedPage(), and pageReinit().

◆ sqlite3PagerReadFileheader()

SQLITE_PRIVATE int sqlite3PagerReadFileheader	(	Pager *	pPager,
		int	N,
		unsigned char *	pDest )

Definition at line 55514 of file sqlite3.c.

                                                                                         {
  int rc = SQLITE_OK;
  memset(pDest, 0, N);
  assert( isOpen(pPager->fd) || pPager->tempFile );
 
  /* This routine is only called by btree immediately after creating
  ** the Pager object.  There has not been an opportunity to transition
  ** to WAL mode yet.
  */
  assert( !pagerUseWal(pPager) );
 
  if( isOpen(pPager->fd) ){
    IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
    rc = sqlite3OsRead(pPager->fd, pDest, N, 0);

References Pager::fd, IOTRACE, isOpen, pagerUseWal, sqlite3OsRead(), SQLITE_IOERR_SHORT_READ, SQLITE_OK, and Pager::tempFile.

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerRef()

SQLITE_PRIVATE void sqlite3PagerRef ( DbPage * pPg )

Definition at line 55854 of file sqlite3.c.

Referenced by freePage2().

◆ sqlite3PagerRekey()

SQLITE_PRIVATE void sqlite3PagerRekey	(	DbPage *	pPg,
		Pgno	iNew,
		u16	flags )

Definition at line 58881 of file sqlite3.c.

References PgHdr::flags, and PgHdr::pgno.

Referenced by balance_nonroot().

◆ sqlite3PagerRollback()

SQLITE_PRIVATE int sqlite3PagerRollback ( Pager * pPager )

Definition at line 58360 of file sqlite3.c.

                                                      {
  int rc = SQLITE_OK;                  /* Return code */
  PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
 
  /* PagerRollback() is a no-op if called in READER or OPEN state. If
  ** the pager is already in the ERROR state, the rollback is not
  ** attempted here. Instead, the error code is returned to the caller.
  */
  assert( assert_pager_state(pPager) );
  if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
  if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
 
  if( pagerUseWal(pPager) ){
    int rc2;
    rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
    rc2 = pager_end_transaction(pPager, pPager->setSuper, 0);
    if( rc==SQLITE_OK ) rc = rc2;
  }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
    int eState = pPager->eState;
    rc = pager_end_transaction(pPager, 0, 0);
    if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
      /* This can happen using journal_mode=off. Move the pager to the error
      ** state to indicate that the contents of the cache may not be trusted.
      ** Any active readers will get SQLITE_ABORT.
      */
      pPager->errCode = SQLITE_ABORT;
      pPager->eState = PAGER_ERROR;
      setGetterMethod(pPager);
      return rc;
    }
  }else{
    rc = pager_playback(pPager, 0);
  }
 
  assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
  assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
          || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR
          || rc==SQLITE_CANTOPEN
  );

References Pager::errCode, Pager::eState, isOpen, Pager::jfd, MEMDB, pager_end_transaction(), PAGER_ERROR, pager_error(), pager_playback(), PAGER_READER, PAGER_WRITER_LOCKED, PAGERID, PAGERTRACE, pagerUseWal, SAVEPOINT_ROLLBACK, setGetterMethod(), Pager::setSuper, sqlite3PagerSavepoint(), SQLITE_ABORT, SQLITE_CANTOPEN, SQLITE_CORRUPT, SQLITE_FULL, SQLITE_IOERR, SQLITE_NOMEM, and SQLITE_OK.

Referenced by autoVacuumCommit(), pagerUnlockAndRollback(), and sqlite3BtreeRollback().

◆ sqlite3PagerSavepoint()

SQLITE_PRIVATE int sqlite3PagerSavepoint	(	Pager *	pPager,
		int	op,
		int	iSavepoint )

Definition at line 58598 of file sqlite3.c.

                                                                               {
  int rc = pPager->errCode;
 
#ifdef SQLITE_ENABLE_ZIPVFS
  if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK;
#endif
 
  assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
  assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
 
  if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
    int ii;            /* Iterator variable */
    int nNew;          /* Number of remaining savepoints after this op. */
 
    /* Figure out how many savepoints will still be active after this
    ** operation. Store this value in nNew. Then free resources associated
    ** with any savepoints that are destroyed by this operation.
    */
    nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
    for(ii=nNew; ii<pPager->nSavepoint; ii++){
      sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
    }
    pPager->nSavepoint = nNew;
 
    /* If this is a release of the outermost savepoint, truncate
    ** the sub-journal to zero bytes in size. */
    if( op==SAVEPOINT_RELEASE ){
      if( nNew==0 && isOpen(pPager->sjfd) ){
        /* Only truncate if it is an in-memory sub-journal. */
        if( sqlite3JournalIsInMemory(pPager->sjfd) ){
          rc = sqlite3OsTruncate(pPager->sjfd, 0);
          assert( rc==SQLITE_OK );
        }
        pPager->nSubRec = 0;
      }
    }
    /* Else this is a rollback operation, playback the specified savepoint.
    ** If this is a temp-file, it is possible that the journal file has
    ** not yet been opened. In this case there have been no changes to
    ** the database file, so the playback operation can be skipped.
    */
    else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
      PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
      rc = pagerPlaybackSavepoint(pPager, pSavepoint);
      assert(rc!=SQLITE_DONE);
    }
 
#ifdef SQLITE_ENABLE_ZIPVFS
    /* If the cache has been modified but the savepoint cannot be rolled
    ** back journal_mode=off, put the pager in the error state. This way,
    ** if the VFS used by this pager includes ZipVFS, the entire transaction
    ** can be rolled back at the ZipVFS level.  */
    else if(
        pPager->journalMode==PAGER_JOURNALMODE_OFF
     && pPager->eState>=PAGER_WRITER_CACHEMOD
    ){
      pPager->errCode = SQLITE_ABORT;
      pPager->eState = PAGER_ERROR;
      setGetterMethod(pPager);

References Pager::aSavepoint, Pager::errCode, Pager::eState, isOpen, Pager::jfd, Pager::journalMode, Pager::nSavepoint, Pager::nSubRec, PAGER_ERROR, PAGER_JOURNALMODE_OFF, PAGER_WRITER_CACHEMOD, pagerPlaybackSavepoint(), pagerUseWal, PagerSavepoint::pInSavepoint, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, setGetterMethod(), Pager::sjfd, sqlite3BitvecDestroy(), sqlite3JournalIsInMemory(), sqlite3OsTruncate(), SQLITE_ABORT, SQLITE_DONE, and SQLITE_OK.

Referenced by sqlite3BtreeSavepoint(), and sqlite3PagerRollback().

◆ sqlite3PagerSetBusyHandler()

SQLITE_PRIVATE void sqlite3PagerSetBusyHandler	(	Pager *	pPager,
		int()(void )	xBusyHandler,
		void *	pBusyHandlerArg )

Definition at line 55341 of file sqlite3.c.

 {
  void **ap;
  pPager->xBusyHandler = xBusyHandler;

References Pager::fd, Pager::pBusyHandlerArg, sqlite3OsFileControlHint(), SQLITE_FCNTL_BUSYHANDLER, and Pager::xBusyHandler.

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerSetCachesize()

SQLITE_PRIVATE void sqlite3PagerSetCachesize	(	Pager *	pPager,
		int	mxPage )

Definition at line 55147 of file sqlite3.c.

Referenced by sqlite3BtreeOpen(), and sqlite3BtreeSetCacheSize().

◆ sqlite3PagerSetFlags()

SQLITE_PRIVATE void sqlite3PagerSetFlags	(	Pager *	pPager,
		unsigned	pgFlags )

Definition at line 55242 of file sqlite3.c.

 {
  unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK;
  if( pPager->tempFile ){
    pPager->noSync = 1;
    pPager->fullSync = 0;
    pPager->extraSync = 0;
  }else{
    pPager->noSync =  level==PAGER_SYNCHRONOUS_OFF ?1:0;
    pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
    pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
  }
  if( pPager->noSync ){
    pPager->syncFlags = 0;
  }else if( pgFlags & PAGER_FULLFSYNC ){
    pPager->syncFlags = SQLITE_SYNC_FULL;
  }else{
    pPager->syncFlags = SQLITE_SYNC_NORMAL;
  }
  pPager->walSyncFlags = (pPager->syncFlags<<2);
  if( pPager->fullSync ){
    pPager->walSyncFlags |= pPager->syncFlags;
  }
  if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){
    pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2);
  }

References Pager::doNotSpill, Pager::extraSync, Pager::fullSync, Pager::noSync, PAGER_CACHESPILL, PAGER_CKPT_FULLFSYNC, PAGER_FULLFSYNC, PAGER_SYNCHRONOUS_EXTRA, PAGER_SYNCHRONOUS_FULL, PAGER_SYNCHRONOUS_MASK, PAGER_SYNCHRONOUS_OFF, SPILLFLAG_OFF, SQLITE_SYNC_FULL, SQLITE_SYNC_NORMAL, Pager::syncFlags, Pager::tempFile, and Pager::walSyncFlags.

Referenced by sqlite3BtreeSetPagerFlags().

◆ sqlite3PagerSetJournalMode()

SQLITE_PRIVATE int sqlite3PagerSetJournalMode	(	Pager *	pPager,
		int	eMode )

Definition at line 58946 of file sqlite3.c.

                                                                       {
  u8 eOld = pPager->journalMode;    /* Prior journalmode */
 
  /* The eMode parameter is always valid */
  assert(      eMode==PAGER_JOURNALMODE_DELETE
            || eMode==PAGER_JOURNALMODE_TRUNCATE
            || eMode==PAGER_JOURNALMODE_PERSIST
            || eMode==PAGER_JOURNALMODE_OFF
            || eMode==PAGER_JOURNALMODE_WAL
            || eMode==PAGER_JOURNALMODE_MEMORY );
 
  /* This routine is only called from the OP_JournalMode opcode, and
  ** the logic there will never allow a temporary file to be changed
  ** to WAL mode.
  */
  assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
 
  /* Do allow the journalmode of an in-memory database to be set to
  ** anything other than MEMORY or OFF
  */
  if( MEMDB ){
    assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
    if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
      eMode = eOld;
    }
  }
 
  if( eMode!=eOld ){
 
    /* Change the journal mode. */
    assert( pPager->eState!=PAGER_ERROR );
    pPager->journalMode = (u8)eMode;
 
    /* When transistioning from TRUNCATE or PERSIST to any other journal
    ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
    ** delete the journal file.
    */
    assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
    assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
    assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
    assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
    assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
    assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
 
    assert( isOpen(pPager->fd) || pPager->exclusiveMode );
    if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
 
      /* In this case we would like to delete the journal file. If it is
      ** not possible, then that is not a problem. Deleting the journal file
      ** here is an optimization only.
      **
      ** Before deleting the journal file, obtain a RESERVED lock on the
      ** database file. This ensures that the journal file is not deleted
      ** while it is in use by some other client.
      */
      sqlite3OsClose(pPager->jfd);
      if( pPager->eLock>=RESERVED_LOCK ){
        sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
      }else{
        int rc = SQLITE_OK;
        int state = pPager->eState;
        assert( state==PAGER_OPEN || state==PAGER_READER );
        if( state==PAGER_OPEN ){
          rc = sqlite3PagerSharedLock(pPager);
        }
        if( pPager->eState==PAGER_READER ){
          assert( rc==SQLITE_OK );
          rc = pagerLockDb(pPager, RESERVED_LOCK);
        }
        if( rc==SQLITE_OK ){
          sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
        }
        if( rc==SQLITE_OK && state==PAGER_READER ){
          pagerUnlockDb(pPager, SHARED_LOCK);
        }else if( state==PAGER_OPEN ){
          pager_unlock(pPager);
        }
        assert( state==pPager->eState );
      }
    }else if( eMode==PAGER_JOURNALMODE_OFF ){
      sqlite3OsClose(pPager->jfd);

References Pager::eLock, Pager::eState, Pager::exclusiveMode, Pager::fd, isOpen, Pager::jfd, Pager::journalMode, MEMDB, PAGER_ERROR, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_PERSIST, PAGER_JOURNALMODE_TRUNCATE, PAGER_JOURNALMODE_WAL, PAGER_OPEN, PAGER_READER, pager_unlock(), pagerLockDb(), pagerUnlockDb(), Pager::pVfs, RESERVED_LOCK, SHARED_LOCK, sqlite3OsClose(), sqlite3OsDelete(), sqlite3PagerSharedLock(), SQLITE_OK, Pager::tempFile, and Pager::zJournal.

Referenced by sqlite3VdbeExec().

◆ sqlite3PagerSetMmapLimit()

SQLITE_PRIVATE void sqlite3PagerSetMmapLimit	(	Pager *	pPager,
		sqlite3_int64	szMmap )

Definition at line 55178 of file sqlite3.c.

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerSetPagesize()

SQLITE_PRIVATE int sqlite3PagerSetPagesize	(	Pager *	pPager,
		u32 *	pPageSize,
		int	nReserve )

Definition at line 55385 of file sqlite3.c.

                                                                                       {
  int rc = SQLITE_OK;
 
  /* It is not possible to do a full assert_pager_state() here, as this
  ** function may be called from within PagerOpen(), before the state
  ** of the Pager object is internally consistent.
  **
  ** At one point this function returned an error if the pager was in
  ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
  ** there is at least one outstanding page reference, this function
  ** is a no-op for that case anyhow.
  */
 
  u32 pageSize = *pPageSize;
  assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
  if( (pPager->memDb==0 || pPager->dbSize==0)
   && sqlite3PcacheRefCount(pPager->pPCache)==0
   && pageSize && pageSize!=(u32)pPager->pageSize
  ){
    char *pNew = NULL;             /* New temp space */
    i64 nByte = 0;
 
    if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
      rc = sqlite3OsFileSize(pPager->fd, &nByte);
    }
    if( rc==SQLITE_OK ){
      /* 8 bytes of zeroed overrun space is sufficient so that the b-tree
      * cell header parser will never run off the end of the allocation */
      pNew = (char *)sqlite3PageMalloc(pageSize+8);
      if( !pNew ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        memset(pNew+pageSize, 0, 8);
      }
    }
 
    if( rc==SQLITE_OK ){
      pager_reset(pPager);
      rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
    }
    if( rc==SQLITE_OK ){
      sqlite3PageFree(pPager->pTmpSpace);
      pPager->pTmpSpace = pNew;
      pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
      pPager->pageSize = pageSize;
    }else{
      sqlite3PageFree(pNew);
    }
  }
 
  *pPageSize = pPager->pageSize;
  if( rc==SQLITE_OK ){
    if( nReserve<0 ) nReserve = pPager->nReserve;

References Pager::dbSize, Pager::eState, Pager::fd, isOpen, Pager::memDb, Pager::nReserve, NULL, PAGER_OPEN, pager_reset(), pagerFixMaplimit(), Pager::pageSize, Pager::pPCache, Pager::pTmpSpace, sqlite3OsFileSize(), sqlite3PageFree(), sqlite3PageMalloc(), sqlite3PcacheRefCount(), sqlite3PcacheSetPageSize(), SQLITE_MAX_PAGE_SIZE, SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by lockBtree(), pager_playback(), readJournalHdr(), sqlite3BtreeOpen(), sqlite3BtreeSetPageSize(), and sqlite3PagerOpen().

◆ sqlite3PagerSetSpillsize()

SQLITE_PRIVATE int sqlite3PagerSetSpillsize	(	Pager *	pPager,
		int	mxPage )

Definition at line 55155 of file sqlite3.c.

Referenced by sqlite3BtreeSetSpillSize().

◆ sqlite3PagerSharedLock()

SQLITE_PRIVATE int sqlite3PagerSharedLock ( Pager * pPager )

Definition at line 56874 of file sqlite3.c.

                                                        {
  int rc = SQLITE_OK;                /* Return code */
 
  /* This routine is only called from b-tree and only when there are no
  ** outstanding pages. This implies that the pager state should either
  ** be OPEN or READER. READER is only possible if the pager is or was in
  ** exclusive access mode.  */
  assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
  assert( assert_pager_state(pPager) );
  assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
  assert( pPager->errCode==SQLITE_OK );
 
  if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
    int bHotJournal = 1;          /* True if there exists a hot journal-file */
 
    assert( !MEMDB );
    assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
 
    rc = pager_wait_on_lock(pPager, SHARED_LOCK);
    if( rc!=SQLITE_OK ){
      assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
      goto failed;
    }
 
    /* If a journal file exists, and there is no RESERVED lock on the
    ** database file, then it either needs to be played back or deleted.
    */
    if( pPager->eLock<=SHARED_LOCK ){
      rc = hasHotJournal(pPager, &bHotJournal);
    }
    if( rc!=SQLITE_OK ){
      goto failed;
    }
    if( bHotJournal ){
      if( pPager->readOnly ){
        rc = SQLITE_READONLY_ROLLBACK;
        goto failed;
      }
 
      /* Get an EXCLUSIVE lock on the database file. At this point it is
      ** important that a RESERVED lock is not obtained on the way to the
      ** EXCLUSIVE lock. If it were, another process might open the
      ** database file, detect the RESERVED lock, and conclude that the
      ** database is safe to read while this process is still rolling the
      ** hot-journal back.
      **
      ** Because the intermediate RESERVED lock is not requested, any
      ** other process attempting to access the database file will get to
      ** this point in the code and fail to obtain its own EXCLUSIVE lock
      ** on the database file.
      **
      ** Unless the pager is in locking_mode=exclusive mode, the lock is
      ** downgraded to SHARED_LOCK before this function returns.
      */
      rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
      if( rc!=SQLITE_OK ){
        goto failed;
      }
 
      /* If it is not already open and the file exists on disk, open the
      ** journal for read/write access. Write access is required because
      ** in exclusive-access mode the file descriptor will be kept open
      ** and possibly used for a transaction later on. Also, write-access
      ** is usually required to finalize the journal in journal_mode=persist
      ** mode (and also for journal_mode=truncate on some systems).
      **
      ** If the journal does not exist, it usually means that some
      ** other connection managed to get in and roll it back before
      ** this connection obtained the exclusive lock above. Or, it
      ** may mean that the pager was in the error-state when this
      ** function was called and the journal file does not exist.
      */
      if( !isOpen(pPager->jfd) ){
        sqlite3_vfs * const pVfs = pPager->pVfs;
        int bExists;              /* True if journal file exists */
        rc = sqlite3OsAccess(
            pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
        if( rc==SQLITE_OK && bExists ){
          int fout = 0;
          int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
          assert( !pPager->tempFile );
          rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
          assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
          if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
            rc = SQLITE_CANTOPEN_BKPT;
            sqlite3OsClose(pPager->jfd);
          }
        }
      }
 
      /* Playback and delete the journal.  Drop the database write
      ** lock and reacquire the read lock. Purge the cache before
      ** playing back the hot-journal so that we don't end up with
      ** an inconsistent cache.  Sync the hot journal before playing
      ** it back since the process that crashed and left the hot journal
      ** probably did not sync it and we are required to always sync
      ** the journal before playing it back.
      */
      if( isOpen(pPager->jfd) ){
        assert( rc==SQLITE_OK );
        rc = pagerSyncHotJournal(pPager);
        if( rc==SQLITE_OK ){
          rc = pager_playback(pPager, !pPager->tempFile);
          pPager->eState = PAGER_OPEN;
        }
      }else if( !pPager->exclusiveMode ){
        pagerUnlockDb(pPager, SHARED_LOCK);
      }
 
      if( rc!=SQLITE_OK ){
        /* This branch is taken if an error occurs while trying to open
        ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
        ** pager_unlock() routine will be called before returning to unlock
        ** the file. If the unlock attempt fails, then Pager.eLock must be
        ** set to UNKNOWN_LOCK (see the comment above the #define for
        ** UNKNOWN_LOCK above for an explanation).
        **
        ** In order to get pager_unlock() to do this, set Pager.eState to
        ** PAGER_ERROR now. This is not actually counted as a transition
        ** to ERROR state in the state diagram at the top of this file,
        ** since we know that the same call to pager_unlock() will very
        ** shortly transition the pager object to the OPEN state. Calling
        ** assert_pager_state() would fail now, as it should not be possible
        ** to be in ERROR state when there are zero outstanding page
        ** references.
        */
        pager_error(pPager, rc);
        goto failed;
      }
 
      assert( pPager->eState==PAGER_OPEN );
      assert( (pPager->eLock==SHARED_LOCK)
           || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
      );
    }
 
    if( !pPager->tempFile && pPager->hasHeldSharedLock ){
      /* The shared-lock has just been acquired then check to
      ** see if the database has been modified.  If the database has changed,
      ** flush the cache.  The hasHeldSharedLock flag prevents this from
      ** occurring on the very first access to a file, in order to save a
      ** single unnecessary sqlite3OsRead() call at the start-up.
      **
      ** Database changes are detected by looking at 15 bytes beginning
      ** at offset 24 into the file.  The first 4 of these 16 bytes are
      ** a 32-bit counter that is incremented with each change.  The
      ** other bytes change randomly with each file change when
      ** a codec is in use.
      **
      ** There is a vanishingly small chance that a change will not be
      ** detected.  The chance of an undetected change is so small that
      ** it can be neglected.
      */
      char dbFileVers[sizeof(pPager->dbFileVers)];
 
      IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
      rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
      if( rc!=SQLITE_OK ){
        if( rc!=SQLITE_IOERR_SHORT_READ ){
          goto failed;
        }
        memset(dbFileVers, 0, sizeof(dbFileVers));
      }
 
      if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
        pager_reset(pPager);
 
        /* Unmap the database file. It is possible that external processes
        ** may have truncated the database file and then extended it back
        ** to its original size while this process was not holding a lock.
        ** In this case there may exist a Pager.pMap mapping that appears
        ** to be the right size but is not actually valid. Avoid this
        ** possibility by unmapping the db here. */
        if( USEFETCH(pPager) ){
          sqlite3OsUnfetch(pPager->fd, 0, 0);
        }
      }
    }
 
    /* If there is a WAL file in the file-system, open this database in WAL
    ** mode. Otherwise, the following function call is a no-op.
    */
    rc = pagerOpenWalIfPresent(pPager);
#ifndef SQLITE_OMIT_WAL
    assert( pPager->pWal==0 || rc==SQLITE_OK );
#endif
  }
 
  if( pagerUseWal(pPager) ){
    assert( rc==SQLITE_OK );
    rc = pagerBeginReadTransaction(pPager);
  }
 
  if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
    rc = pagerPagecount(pPager, &pPager->dbSize);
  }
 
 failed:
  if( rc!=SQLITE_OK ){
    assert( !MEMDB );
    pager_unlock(pPager);
    assert( pPager->eState==PAGER_OPEN );

References Pager::dbFileVers, Pager::dbSize, Pager::eLock, Pager::errCode, Pager::eState, EXCLUSIVE_LOCK, Pager::exclusiveMode, Pager::fd, Pager::hasHeldSharedLock, hasHotJournal(), IOTRACE, isOpen, Pager::jfd, MEMDB, NO_LOCK, pager_error(), PAGER_OPEN, pager_playback(), PAGER_READER, pager_reset(), pager_unlock(), pager_wait_on_lock(), pagerBeginReadTransaction(), pagerLockDb(), pagerOpenWalIfPresent(), pagerPagecount(), pagerSyncHotJournal(), pagerUnlockDb(), pagerUseWal, Pager::pPCache, Pager::pVfs, Pager::pWal, Pager::readOnly, SHARED_LOCK, sqlite3OsAccess(), sqlite3OsClose(), sqlite3OsOpen(), sqlite3OsRead(), sqlite3OsUnfetch(), sqlite3PcacheRefCount(), SQLITE_ACCESS_EXISTS, SQLITE_CANTOPEN_BKPT, SQLITE_IOERR_SHORT_READ, SQLITE_OK, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_READONLY_ROLLBACK, Pager::tempFile, UNKNOWN_LOCK, USEFETCH, and Pager::zJournal.

Referenced by lockBtree(), and sqlite3PagerSetJournalMode().

◆ sqlite3PagerShrink()

SQLITE_PRIVATE void sqlite3PagerShrink ( Pager * pPager )

Definition at line 55186 of file sqlite3.c.

◆ sqlite3PagerSync()

SQLITE_PRIVATE int sqlite3PagerSync	(	Pager *	pPager,
		const char *	zSuper )

Definition at line 57999 of file sqlite3.c.

                                                                      {
  int rc = SQLITE_OK;
  void *pArg = (void*)zSuper;
  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
  if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;

References Pager::fd, MEMDB, Pager::noSync, sqlite3OsFileControl(), sqlite3OsSync(), SQLITE_FCNTL_SYNC, SQLITE_NOTFOUND, SQLITE_OK, and Pager::syncFlags.

Referenced by pager_playback(), and sqlite3PagerCommitPhaseOne().

◆ sqlite3PagerTempSpace()

SQLITE_PRIVATE void * sqlite3PagerTempSpace ( Pager * pPager )

Definition at line 55453 of file sqlite3.c.

References Pager::pTmpSpace.

Referenced by defragmentPage(), editPage(), and rebuildPage().

◆ sqlite3PagerTruncateImage()

SQLITE_PRIVATE void sqlite3PagerTruncateImage	(	Pager *	pPager,
		Pgno	nPage )

Definition at line 55627 of file sqlite3.c.

                                                                        {
  assert( pPager->dbSize>=nPage );
  assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
  pPager->dbSize = nPage;
 
  /* At one point the code here called assertTruncateConstraint() to
  ** ensure that all pages being truncated away by this operation are,
  ** if one or more savepoints are open, present in the savepoint
  ** journal so that they can be restored if the savepoint is rolled

References Pager::dbSize, Pager::eState, and PAGER_WRITER_CACHEMOD.

Referenced by sqlite3BtreeCommitPhaseOne().

◆ sqlite3PagerUnref()

SQLITE_PRIVATE void sqlite3PagerUnref ( DbPage * pPg )

Definition at line 57397 of file sqlite3.c.

       {
    sqlite3PcacheRelease(pPg);
  }

Referenced by accessPayload(), backupOnePage(), checkList(), pager_incr_changecounter(), ptrmapGet(), ptrmapPut(), and sqlite3PagerCommitPhaseOne().

◆ sqlite3PagerUnrefNotNull()

SQLITE_PRIVATE void sqlite3PagerUnrefNotNull ( DbPage * pPg )

Definition at line 57385 of file sqlite3.c.

                                                         {
  TESTONLY( Pager *pPager = pPg->pPager; )
  assert( pPg!=0 );
  if( pPg->flags & PGHDR_MMAP ){
    assert( pPg->pgno!=1 );  /* Page1 is never memory mapped */
    pagerReleaseMapPage(pPg);

References PgHdr::flags, pagerReleaseMapPage(), PGHDR_MMAP, PgHdr::pgno, PgHdr::pPager, and TESTONLY.

Referenced by pager_end_transaction(), pagerUndoCallback(), pagerWriteLargeSector(), and sqlite3PagerMovepage().

◆ sqlite3PagerUnrefPageOne()

SQLITE_PRIVATE void sqlite3PagerUnrefPageOne ( DbPage * pPg )

Definition at line 57400 of file sqlite3.c.

                                                  {
  if( pPg ) sqlite3PagerUnrefNotNull(pPg);
}
SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){
  Pager *pPager;
  assert( pPg!=0 );

◆ sqlite3PagerVfs()

SQLITE_PRIVATE sqlite3_vfs * sqlite3PagerVfs ( Pager * pPager )

Definition at line 58685 of file sqlite3.c.

                                                    : pPager->zFilename;
}
 

Referenced by sqlite3BtreeOpen().

◆ sqlite3PagerWalCallback()

SQLITE_PRIVATE int sqlite3PagerWalCallback ( Pager * pPager )

Definition at line 59115 of file sqlite3.c.

Referenced by doWalCallbacks().

◆ sqlite3PagerWalSupported()

SQLITE_PRIVATE int sqlite3PagerWalSupported ( Pager * pPager )

Definition at line 59123 of file sqlite3.c.

Referenced by sqlite3PagerOpenWal(), and sqlite3VdbeExec().

◆ sqlite3PagerWrite()

SQLITE_PRIVATE int sqlite3PagerWrite ( DbPage * pPg )

Definition at line 57833 of file sqlite3.c.

                                                {
  Pager *pPager = pPg->pPager;
  assert( (pPg->flags & PGHDR_MMAP)==0 );
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
    if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
    return SQLITE_OK;
  }else if( pPager->errCode ){
    return pPager->errCode;
  }else if( pPager->sectorSize > (u32)pPager->pageSize ){

References Pager::dbSize, Pager::errCode, Pager::eState, PgHdr::flags, Pager::nSavepoint, pager_write(), PAGER_WRITER_LOCKED, pagerWriteLargeSector(), Pager::pageSize, PGHDR_MMAP, PGHDR_WRITEABLE, PgHdr::pgno, PgHdr::pPager, Pager::sectorSize, SQLITE_OK, subjournalPageIfRequired(), and Pager::tempFile.

Referenced by allocateBtreePage(), autoVacuumCommit(), backupOnePage(), balance(), balance_deeper(), balance_nonroot(), btreeCreateTable(), copyPayload(), freePage2(), insertCell(), newDatabase(), pager_incr_changecounter(), ptrmapPut(), relocatePage(), sqlite3BtreeBeginTrans(), sqlite3BtreeDelete(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreeSetVersion(), and sqlite3PagerMovepage().

◆ sqlite3Parser() [1/2]

SQLITE_PRIVATE void sqlite3Parser	(	void *	,
		int	,
		Token	)

Referenced by sqlite3RunParser().

◆ sqlite3Parser() [2/2]

SQLITE_PRIVATE void sqlite3Parser	(	void *	yyp,
		int	yymajor,
		sqlite3ParserTOKENTYPE yyminor	sqlite3ParserARG_PDECL )

Definition at line 159071 of file sqlite3.c.

          :
** None.
*/
SQLITE_PRIVATE void sqlite3Parser(
  void *yyp,                   /* The parser */
  int yymajor,                 /* The major token code number */
  sqlite3ParserTOKENTYPE yyminor       /* The value for the token */
  sqlite3ParserARG_PDECL               /* Optional %extra_argument parameter */
){
  YYMINORTYPE yyminorunion;
  YYACTIONTYPE yyact;   /* The parser action. */
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
  int yyendofinput;     /* True if we are at the end of input */
#endif
#ifdef YYERRORSYMBOL
  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
#endif
  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
  sqlite3ParserCTX_FETCH
  sqlite3ParserARG_STORE
 
  assert( yypParser->yytos!=0 );
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
  yyendofinput = (yymajor==0);
#endif
 
  yyact = yypParser->yytos->stateno;
#ifndef NDEBUG
  if( yyTraceFILE ){
    if( yyact < YY_MIN_REDUCE ){
      fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
              yyTracePrompt,yyTokenName[yymajor],yyact);
    }else{
      fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
    }
  }
#endif
 
  do{
    assert( yyact==yypParser->yytos->stateno );
    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
    if( yyact >= YY_MIN_REDUCE ){
      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
                        yyminor sqlite3ParserCTX_PARAM);
    }else if( yyact <= YY_MAX_SHIFTREDUCE ){
      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
#ifndef YYNOERRORRECOVERY
      yypParser->yyerrcnt--;
#endif
      break;
    }else if( yyact==YY_ACCEPT_ACTION ){
      yypParser->yytos--;
      yy_accept(yypParser);
      return;
    }else{
      assert( yyact == YY_ERROR_ACTION );
      yyminorunion.yy0 = yyminor;
#ifdef YYERRORSYMBOL
      int yymx;
#endif
#ifndef NDEBUG
      if( yyTraceFILE ){
        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
      }
#endif
#ifdef YYERRORSYMBOL
      /* A syntax error has occurred.
      ** The response to an error depends upon whether or not the
      ** grammar defines an error token "ERROR".
      **
      ** This is what we do if the grammar does define ERROR:
      **
      **  * Call the %syntax_error function.
      **
      **  * Begin popping the stack until we enter a state where
      **    it is legal to shift the error symbol, then shift
      **    the error symbol.
      **
      **  * Set the error count to three.
      **
      **  * Begin accepting and shifting new tokens.  No new error
      **    processing will occur until three tokens have been
      **    shifted successfully.
      **
      */
      if( yypParser->yyerrcnt<0 ){
        yy_syntax_error(yypParser,yymajor,yyminor);
      }
      yymx = yypParser->yytos->major;
      if( yymx==YYERRORSYMBOL || yyerrorhit ){
#ifndef NDEBUG
        if( yyTraceFILE ){
          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
             yyTracePrompt,yyTokenName[yymajor]);
        }
#endif
        yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
        yymajor = YYNOCODE;
      }else{
        while( yypParser->yytos >= yypParser->yystack
            && (yyact = yy_find_reduce_action(
                        yypParser->yytos->stateno,
                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
        ){
          yy_pop_parser_stack(yypParser);
        }
        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
          yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
          yypParser->yyerrcnt = -1;
#endif
          yymajor = YYNOCODE;
        }else if( yymx!=YYERRORSYMBOL ){
          yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
        }
      }
      yypParser->yyerrcnt = 3;
      yyerrorhit = 1;
      if( yymajor==YYNOCODE ) break;
      yyact = yypParser->yytos->stateno;
#elif defined(YYNOERRORRECOVERY)
      /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
      ** do any kind of error recovery.  Instead, simply invoke the syntax
      ** error routine and continue going as if nothing had happened.
      **
      ** Applications can set this macro (for example inside %include) if
      ** they intend to abandon the parse upon the first syntax error seen.
      */
      yy_syntax_error(yypParser,yymajor, yyminor);
      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
      break;
#else  /* YYERRORSYMBOL is not defined */
      /* This is what we do if the grammar does not define ERROR:
      **
      **  * Report an error message, and throw away the input token.
      **
      **  * If the input token is $, then fail the parse.
      **
      ** As before, subsequent error messages are suppressed until
      ** three input tokens have been successfully shifted.
      */
      if( yypParser->yyerrcnt<=0 ){
        yy_syntax_error(yypParser,yymajor, yyminor);
      }
      yypParser->yyerrcnt = 3;
      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
      if( yyendofinput ){
        yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
        yypParser->yyerrcnt = -1;
#endif
      }
      break;
#endif
    }
  }while( yypParser->yytos>yypParser->yystack );
#ifndef NDEBUG
  if( yyTraceFILE ){
    yyStackEntry *i;
    char cDiv = '[';
    fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
    for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
      fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
      cDiv = ' ';

References yyStackEntry::major, sqlite3ParserARG_STORE, sqlite3ParserCTX_FETCH, sqlite3ParserCTX_PARAM, yyStackEntry::stateno, YYMINORTYPE::yy0, yy_accept(), YY_ACCEPT_ACTION, yy_destructor(), YY_ERROR_ACTION, yy_find_reduce_action(), yy_find_shift_action(), YY_MAX_SHIFTREDUCE, YY_MIN_REDUCE, yy_pop_parser_stack(), yy_reduce(), yy_shift(), yy_syntax_error(), YYACTIONTYPE, YYCODETYPE, YYNOCODE, yyParser::yystack, and yyParser::yytos.

◆ sqlite3ParserFallback()

SQLITE_PRIVATE int sqlite3ParserFallback ( int iToken )

Definition at line 159245 of file sqlite3.c.

                                                    {
#ifdef YYFALLBACK
  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );

Referenced by getToken().

◆ sqlite3ParserFinalize()

SQLITE_PRIVATE void sqlite3ParserFinalize ( void * p )

Definition at line 156409 of file sqlite3.c.

156415 {

Referenced by sqlite3RunParser().

◆ sqlite3ParserInit()

SQLITE_PRIVATE void sqlite3ParserInit ( void *yypRawParser sqlite3ParserCTX_PDECL )

Definition at line 156209 of file sqlite3.c.

                                                                                {
  yyParser *yypParser = (yyParser*)yypRawParser;
  sqlite3ParserCTX_STORE
#ifdef YYTRACKMAXSTACKDEPTH
  yypParser->yyhwm = 0;
#endif
#if YYSTACKDEPTH<=0
  yypParser->yytos = NULL;
  yypParser->yystack = NULL;
  yypParser->yystksz = 0;
  if( yyGrowStack(yypParser) ){
    yypParser->yystack = &yypParser->yystk0;
    yypParser->yystksz = 1;
  }
#endif
#ifndef YYNOERRORRECOVERY
  yypParser->yyerrcnt = -1;
#endif
  yypParser->yytos = yypParser->yystack;

References yyStackEntry::major, NULL, sqlite3ParserCTX_STORE, yyStackEntry::stateno, yyParser::yystack, YYSTACKDEPTH, yyParser::yystackEnd, and yyParser::yytos.

Referenced by sqlite3RunParser().

◆ sqlite3ParserReset()

SQLITE_PRIVATE void sqlite3ParserReset ( Parse * pParse )

Definition at line 128891 of file sqlite3.c.

                                                     {
  sqlite3 *db = pParse->db;
  AggInfo *pThis = pParse->pAggList;
  while( pThis ){
    AggInfo *pNext = pThis->pNext;
    agginfoFree(db, pThis);
    pThis = pNext;
  }
  sqlite3DbFree(db, pParse->aLabel);
  sqlite3ExprListDelete(db, pParse->pConstExpr);
  if( db ){

Referenced by findBtree(), and sqlite3_declare_vtab().

◆ sqlite3ParseUri()

SQLITE_PRIVATE int sqlite3ParseUri	(	const char *	zDefaultVfs,
		const char *	zUri,
		unsigned int *	pFlags,
		sqlite3_vfs **	ppVfs,
		char **	pzFile,
		char **	pzErrMsg )

Definition at line 163798 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  unsigned int flags = *pFlags;
  const char *zVfs = zDefaultVfs;
  char *zFile;
  char c;
  int nUri = sqlite3Strlen30(zUri);
 
  assert( *pzErrMsg==0 );
 
  if( ((flags & SQLITE_OPEN_URI)             /* IMP: R-48725-32206 */
            || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */
   && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */
  ){
    char *zOpt;
    int eState;                   /* Parser state when parsing URI */
    int iIn;                      /* Input character index */
    int iOut = 0;                 /* Output character index */
    u64 nByte = nUri+8;           /* Bytes of space to allocate */
 
    /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
    ** method that there may be extra parameters following the file-name.  */
    flags |= SQLITE_OPEN_URI;
 
    for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
    zFile = sqlite3_malloc64(nByte);
    if( !zFile ) return SQLITE_NOMEM_BKPT;
 
    memset(zFile, 0, 4);  /* 4-byte of 0x00 is the start of DB name marker */
    zFile += 4;
 
    iIn = 5;
#ifdef SQLITE_ALLOW_URI_AUTHORITY
    if( strncmp(zUri+5, "///", 3)==0 ){
      iIn = 7;
      /* The following condition causes URIs with five leading / characters
      ** like file://///host/path to be converted into UNCs like //host/path.
      ** The correct URI for that UNC has only two or four leading / characters
      ** file://host/path or file:////host/path.  But 5 leading slashes is a
      ** common error, we are told, so we handle it as a special case. */
      if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
    }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
      iIn = 16;
    }
#else
    /* Discard the scheme and authority segments of the URI. */
    if( zUri[5]=='/' && zUri[6]=='/' ){
      iIn = 7;
      while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
      if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
        *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
            iIn-7, &zUri[7]);
        rc = SQLITE_ERROR;
        goto parse_uri_out;
      }
    }
#endif
 
    /* Copy the filename and any query parameters into the zFile buffer.
    ** Decode %HH escape codes along the way.
    **
    ** Within this loop, variable eState may be set to 0, 1 or 2, depending
    ** on the parsing context. As follows:
    **
    **   0: Parsing file-name.
    **   1: Parsing name section of a name=value query parameter.
    **   2: Parsing value section of a name=value query parameter.
    */
    eState = 0;
    while( (c = zUri[iIn])!=0 && c!='#' ){
      iIn++;
      if( c=='%'
       && sqlite3Isxdigit(zUri[iIn])
       && sqlite3Isxdigit(zUri[iIn+1])
      ){
        int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
        octet += sqlite3HexToInt(zUri[iIn++]);
 
        assert( octet>=0 && octet<256 );
        if( octet==0 ){
#ifndef SQLITE_ENABLE_URI_00_ERROR
          /* This branch is taken when "%00" appears within the URI. In this
          ** case we ignore all text in the remainder of the path, name or
          ** value currently being parsed. So ignore the current character
          ** and skip to the next "?", "=" or "&", as appropriate. */
          while( (c = zUri[iIn])!=0 && c!='#'
              && (eState!=0 || c!='?')
              && (eState!=1 || (c!='=' && c!='&'))
              && (eState!=2 || c!='&')
          ){
            iIn++;
          }
          continue;
#else
          /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */
          *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri");
          rc = SQLITE_ERROR;
          goto parse_uri_out;
#endif
        }
        c = octet;
      }else if( eState==1 && (c=='&' || c=='=') ){
        if( zFile[iOut-1]==0 ){
          /* An empty option name. Ignore this option altogether. */
          while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
          continue;
        }
        if( c=='&' ){
          zFile[iOut++] = '\0';
        }else{
          eState = 2;
        }
        c = 0;
      }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
        c = 0;
        eState = 1;
      }
      zFile[iOut++] = c;
    }
    if( eState==1 ) zFile[iOut++] = '\0';
    memset(zFile+iOut, 0, 4); /* end-of-options + empty journal filenames */
 
    /* Check if there were any options specified that should be interpreted
    ** here. Options that are interpreted here include "vfs" and those that
    ** correspond to flags that may be passed to the sqlite3_open_v2()
    ** method. */
    zOpt = &zFile[sqlite3Strlen30(zFile)+1];
    while( zOpt[0] ){
      int nOpt = sqlite3Strlen30(zOpt);
      char *zVal = &zOpt[nOpt+1];
      int nVal = sqlite3Strlen30(zVal);
 
      if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
        zVfs = zVal;
      }else{
        struct OpenMode {
          const char *z;
          int mode;
        } *aMode = 0;
        char *zModeType = 0;
        int mask = 0;
        int limit = 0;
 
        if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
          static struct OpenMode aCacheMode[] = {
            { "shared",  SQLITE_OPEN_SHAREDCACHE },
            { "private", SQLITE_OPEN_PRIVATECACHE },
            { 0, 0 }
          };
 
          mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
          aMode = aCacheMode;
          limit = mask;
          zModeType = "cache";
        }
        if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
          static struct OpenMode aOpenMode[] = {
            { "ro",  SQLITE_OPEN_READONLY },
            { "rw",  SQLITE_OPEN_READWRITE },
            { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
            { "memory", SQLITE_OPEN_MEMORY },
            { 0, 0 }
          };
 
          mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE
                   | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY;
          aMode = aOpenMode;
          limit = mask & flags;
          zModeType = "access";
        }
 
        if( aMode ){
          int i;
          int mode = 0;
          for(i=0; aMode[i].z; i++){
            const char *z = aMode[i].z;
            if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
              mode = aMode[i].mode;
              break;
            }
          }
          if( mode==0 ){
            *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
            rc = SQLITE_ERROR;
            goto parse_uri_out;
          }
          if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
            *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
                                        zModeType, zVal);
            rc = SQLITE_PERM;
            goto parse_uri_out;
          }
          flags = (flags & ~mask) | mode;
        }
      }
 
      zOpt = &zVal[nVal+1];
    }
 
  }else{
    zFile = sqlite3_malloc64(nUri+8);
    if( !zFile ) return SQLITE_NOMEM_BKPT;
    memset(zFile, 0, 4);
    zFile += 4;
    if( nUri ){
      memcpy(zFile, zUri, nUri);
    }
    memset(zFile+nUri, 0, 4);
    flags &= ~SQLITE_OPEN_URI;
  }
 
  *ppVfs = sqlite3_vfs_find(zVfs);
  if( *ppVfs==0 ){
    *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
    rc = SQLITE_ERROR;
  }
 parse_uri_out:
  if( rc!=SQLITE_OK ){
    sqlite3_free_filename(zFile);

References mask, sqlite3_free_filename(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3_vfs_find(), sqlite3GlobalConfig, sqlite3HexToInt(), sqlite3Isxdigit, sqlite3Strlen30(), SQLITE_ERROR, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_MEMORY, SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_OPEN_SHAREDCACHE, SQLITE_OPEN_URI, and SQLITE_PERM.

Referenced by attachFunc(), and openDatabase().

◆ sqlite3Pcache1Mutex()

SQLITE_PRIVATE sqlite3_mutex * sqlite3Pcache1Mutex ( void )

Definition at line 50974 of file sqlite3.c.

                                                 { return ROUND8(sizeof(PgHdr1)); }
 
/*

References ROUND8.

Referenced by sqlite3StatusHighwater(), sqlite3StatusUp(), and sqlite3StatusValue().

◆ sqlite3PCacheBufferSetup()

SQLITE_PRIVATE void sqlite3PCacheBufferSetup	(	void *	pBuf,
		int	sz,
		int	n )

Definition at line 50022 of file sqlite3.c.

                                                                       {
  if( pcache1.isInit ){
    PgFreeslot *p;
    if( pBuf==0 ) sz = n = 0;
    if( n==0 ) sz = 0;
    sz = ROUNDDOWN8(sz);
    pcache1.szSlot = sz;
    pcache1.nSlot = pcache1.nFreeSlot = n;
    pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
    pcache1.pStart = pBuf;
    pcache1.pFree = 0;
    pcache1.bUnderPressure = 0;
    while( n-- ){
      p = (PgFreeslot*)pBuf;
      p->pNext = pcache1.pFree;

References pcache1, PgFreeslot::pNext, and ROUNDDOWN8.

Referenced by sqlite3_initialize().

◆ sqlite3PcacheCleanAll()

SQLITE_PRIVATE void sqlite3PcacheCleanAll ( PCache * pCache )

Definition at line 49459 of file sqlite3.c.

49465 {

Referenced by pager_end_transaction(), and sqlite3PagerCommitPhaseOne().

◆ sqlite3PcacheClear()

SQLITE_PRIVATE void sqlite3PcacheClear ( PCache * pCache )

Definition at line 49557 of file sqlite3.c.

◆ sqlite3PcacheClearSyncFlags()

SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags ( PCache * pCache )

Definition at line 49482 of file sqlite3.c.

49488 {

Referenced by syncJournal().

◆ sqlite3PcacheClearWritable()

SQLITE_PRIVATE void sqlite3PcacheClearWritable ( PCache * pCache )

Definition at line 49470 of file sqlite3.c.

49476 {

49477 PgHdr *p;

Referenced by pager_end_transaction().

◆ sqlite3PcacheClose()

SQLITE_PRIVATE void sqlite3PcacheClose ( PCache * pCache )

Definition at line 49548 of file sqlite3.c.

Referenced by sqlite3PagerClose().

◆ sqlite3PcacheDirtyList()

SQLITE_PRIVATE PgHdr * sqlite3PcacheDirtyList ( PCache * pCache )

Definition at line 49637 of file sqlite3.c.

49643 {

Referenced by pagerWalFrames(), and sqlite3PagerCommitPhaseOne().

◆ sqlite3PcacheDrop()

SQLITE_PRIVATE void sqlite3PcacheDrop ( PgHdr * p )

Definition at line 49409 of file sqlite3.c.

                                               {
  assert( p->nRef==1 );
  assert( sqlite3PcachePageSanity(p) );

References PgHdr::flags, PgHdr::nRef, PCache::nRefSum, PgHdr::pCache, PCache::pCache, PCACHE_DIRTYLIST_REMOVE, pcacheManageDirtyList(), PGHDR_DIRTY, PgHdr::pPage, and sqlite3GlobalConfig.

Referenced by getPageNormal(), pagerUndoCallback(), and sqlite3PagerMovepage().

◆ sqlite3PcacheFetch()

SQLITE_PRIVATE sqlite3_pcache_page * sqlite3PcacheFetch	(	PCache *	pCache,
		Pgno	pgno,
		int	createFlag )

Definition at line 49236 of file sqlite3.c.

 {
  int eCreate;
  sqlite3_pcache_page *pRes;
 
  assert( pCache!=0 );
  assert( pCache->pCache!=0 );
  assert( createFlag==3 || createFlag==0 );
  assert( pCache->eCreate==((pCache->bPurgeable && pCache->pDirty) ? 1 : 2) );
 
  /* eCreate defines what to do if the page does not exist.
  **    0     Do not allocate a new page.  (createFlag==0)
  **    1     Allocate a new page if doing so is inexpensive.
  **          (createFlag==1 AND bPurgeable AND pDirty)
  **    2     Allocate a new page even it doing so is difficult.
  **          (createFlag==1 AND !(bPurgeable AND pDirty)
  */
  eCreate = createFlag & pCache->eCreate;
  assert( eCreate==0 || eCreate==1 || eCreate==2 );
  assert( createFlag==0 || pCache->eCreate==eCreate );

References PCache::bPurgeable, PCache::eCreate, PCache::pCache, pcacheTrace, PCache::pDirty, and sqlite3GlobalConfig.

Referenced by getPageNormal(), and sqlite3PagerLookup().

◆ sqlite3PcacheFetchFinish()

SQLITE_PRIVATE PgHdr * sqlite3PcacheFetchFinish	(	PCache *	pCache,
		Pgno	pgno,
		sqlite3_pcache_page *	pPage )

Definition at line 49359 of file sqlite3.c.

 {
  PgHdr *pPgHdr;
 
  assert( pPage!=0 );
  pPgHdr = (PgHdr *)pPage->pExtra;
 
  if( !pPgHdr->pPage ){
    return pcacheFetchFinishWithInit(pCache, pgno, pPage);

References PgHdr::nRef, PCache::nRefSum, pcacheFetchFinishWithInit(), sqlite3_pcache_page::pExtra, and PgHdr::pPage.

Referenced by getPageNormal(), pcacheFetchFinishWithInit(), and sqlite3PagerLookup().

◆ sqlite3PcacheFetchStress()

SQLITE_PRIVATE int sqlite3PcacheFetchStress	(	PCache *	pCache,
		Pgno	pgno,
		sqlite3_pcache_page **	ppPage )

Definition at line 49277 of file sqlite3.c.

 {
  PgHdr *pPg;
  if( pCache->eCreate==2 ) return 0;
 
  if( sqlite3PcachePagecount(pCache)>pCache->szSpill ){
    /* Find a dirty page to write-out and recycle. First try to find a
    ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
    ** cleared), but if that is not possible settle for any other
    ** unreferenced dirty page.
    **
    ** If the LRU page in the dirty list that has a clear PGHDR_NEED_SYNC
    ** flag is currently referenced, then the following may leave pSynced
    ** set incorrectly (pointing to other than the LRU page with NEED_SYNC
    ** cleared). This is Ok, as pSynced is just an optimization.  */
    for(pPg=pCache->pSynced;
        pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
        pPg=pPg->pDirtyPrev
    );
    pCache->pSynced = pPg;
    if( !pPg ){
      for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
    }
    if( pPg ){
      int rc;
#ifdef SQLITE_LOG_CACHE_SPILL
      sqlite3_log(SQLITE_FULL,
                  "spill page %d making room for %d - cache used: %d/%d",
                  pPg->pgno, pgno,
                  sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache),
                numberOfCachePages(pCache));
#endif
      pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
      rc = pCache->xStress(pCache->pStress, pPg);
      pcacheDump(pCache);
      if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
        return rc;

References PCache::eCreate, PgHdr::flags, PgHdr::nRef, numberOfCachePages(), PCache::pCache, pcacheDump, pcacheTrace, PgHdr::pDirtyPrev, PCache::pDirtyTail, PGHDR_NEED_SYNC, PgHdr::pgno, PCache::pStress, PCache::pSynced, sqlite3_log(), sqlite3GlobalConfig, sqlite3PcachePagecount(), SQLITE_BUSY, SQLITE_FULL, SQLITE_NOMEM_BKPT, SQLITE_OK, PCache::szSpill, and PCache::xStress.

Referenced by getPageNormal().

◆ sqlite3PcacheInitialize()

SQLITE_PRIVATE int sqlite3PcacheInitialize ( void )

Definition at line 49132 of file sqlite3.c.

                                                {
  if( sqlite3GlobalConfig.pcache2.xInit==0 ){
    /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
    ** built-in default page cache is used instead of the application defined

References sqlite3GlobalConfig.

Referenced by sqlite3_initialize().

◆ sqlite3PcacheMakeClean()

SQLITE_PRIVATE void sqlite3PcacheMakeClean ( PgHdr * p )

Definition at line 49442 of file sqlite3.c.

                                                    {
  assert( sqlite3PcachePageSanity(p) );
  assert( (p->flags & PGHDR_DIRTY)!=0 );
  assert( (p->flags & PGHDR_CLEAN)==0 );
  pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
  p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
  p->flags |= PGHDR_CLEAN;

Referenced by pagerStress(), and sqlite3PcacheTruncate().

◆ sqlite3PcacheMakeDirty()

SQLITE_PRIVATE void sqlite3PcacheMakeDirty ( PgHdr * p )

Definition at line 49423 of file sqlite3.c.

                                                    {
  assert( p->nRef>0 );
  assert( sqlite3PcachePageSanity(p) );
  if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){    /*OPTIMIZATION-IF-FALSE*/
    p->flags &= ~PGHDR_DONT_WRITE;
    if( p->flags & PGHDR_CLEAN ){
      p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN);
      pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno));

Referenced by pager_playback_one_page(), pager_write(), and sqlite3PagerMovepage().

◆ sqlite3PcacheMove()

SQLITE_PRIVATE void sqlite3PcacheMove	(	PgHdr *	p,
		Pgno	newPgno )

Definition at line 49493 of file sqlite3.c.

                                                             {
  PCache *pCache = p->pCache;
  assert( p->nRef>0 );
  assert( newPgno>0 );
  assert( sqlite3PcachePageSanity(p) );
  pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));

Referenced by sqlite3PagerMovepage().

◆ sqlite3PcacheOpen()

SQLITE_PRIVATE int sqlite3PcacheOpen	(	int	szPage,
		int	szExtra,
		int	bPurgeable,
		int()(void , PgHdr *)	xStress,
		void *	pStress,
		PCache *	pToInit )

Definition at line 49166 of file sqlite3.c.

 {
  memset(p, 0, sizeof(PCache));
  p->szPage = 1;
  p->szExtra = szExtra;
  assert( szExtra>=8 );  /* First 8 bytes will be zeroed */
  p->bPurgeable = bPurgeable;
  p->eCreate = 2;
  p->xStress = xStress;

References PCache::bPurgeable, PCache::eCreate, pcacheTrace, PCache::pStress, sqlite3PcacheSetPageSize(), PCache::szCache, PCache::szExtra, PCache::szPage, PCache::szSpill, and PCache::xStress.

Referenced by sqlite3PagerOpen().

◆ sqlite3PcachePagecount()

SQLITE_PRIVATE int sqlite3PcachePagecount ( PCache * pCache )

Definition at line 49665 of file sqlite3.c.

Referenced by pagerOpenWalIfPresent(), sqlite3PagerMemUsed(), and sqlite3PcacheFetchStress().

◆ sqlite3PcachePageRefcount()

SQLITE_PRIVATE int sqlite3PcachePageRefcount ( PgHdr * p )

Definition at line 49658 of file sqlite3.c.

Referenced by pagerUndoCallback().

◆ sqlite3PCachePercentDirty()

SQLITE_PRIVATE int sqlite3PCachePercentDirty ( PCache * pCache )

Definition at line 49726 of file sqlite3.c.

                                                { return ROUND8(sizeof(PgHdr)); }
 
/*
** Return the number of dirty pages currently in the cache, as a percentage
** of the configured cache size.
*/
SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){

References ROUND8.

Referenced by pagerFlushOnCommit().

◆ sqlite3PcacheRef()

SQLITE_PRIVATE void sqlite3PcacheRef ( PgHdr * p )

Definition at line 49397 of file sqlite3.c.

◆ sqlite3PcacheRefCount()

SQLITE_PRIVATE int sqlite3PcacheRefCount ( PCache * pCache )

Definition at line 49651 of file sqlite3.c.

Referenced by pager_end_transaction(), pagerUnlockIfUnused(), sqlite3PagerSetPagesize(), and sqlite3PagerSharedLock().

◆ sqlite3PcacheRelease()

SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease ( PgHdr * p )

Definition at line 49382 of file sqlite3.c.

                                                                  {
  assert( p->nRef>0 );
  p->pCache->nRefSum--;
  if( (--p->nRef)==0 ){
    if( p->flags&PGHDR_CLEAN ){

Referenced by pager_playback_one_page().

◆ sqlite3PcacheSetCachesize()

SQLITE_PRIVATE void sqlite3PcacheSetCachesize	(	PCache *	pCache,
		int	mxPage )

Definition at line 49682 of file sqlite3.c.

◆ sqlite3PCacheSetDefault()

SQLITE_PRIVATE void sqlite3PCacheSetDefault ( void )

Definition at line 50946 of file sqlite3.c.

                                                 {
  static const sqlite3_pcache_methods2 defaultMethods = {
    1,                       /* iVersion */
    0,                       /* pArg */
    pcache1Init,             /* xInit */
    pcache1Shutdown,         /* xShutdown */
    pcache1Create,           /* xCreate */
    pcache1Cachesize,        /* xCachesize */
    pcache1Pagecount,        /* xPagecount */
    pcache1Fetch,            /* xFetch */
    pcache1Unpin,            /* xUnpin */
    pcache1Rekey,            /* xRekey */

References pcache1Cachesize(), pcache1Create(), pcache1Destroy(), pcache1Fetch(), pcache1Init(), pcache1Pagecount(), pcache1Rekey(), pcache1Shrink(), pcache1Shutdown(), pcache1Truncate(), and pcache1Unpin().

Referenced by sqlite3_config().

◆ sqlite3PcacheSetPageSize()

SQLITE_PRIVATE int sqlite3PcacheSetPageSize	(	PCache *	pCache,
		int	szPage )

Definition at line 49192 of file sqlite3.c.

                                                                       {
  assert( pCache->nRefSum==0 && pCache->pDirty==0 );
  if( pCache->szPage ){
    sqlite3_pcache *pNew;
    pNew = sqlite3GlobalConfig.pcache2.xCreate(
                szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
                pCache->bPurgeable
    );
    if( pNew==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
    if( pCache->pCache ){
      sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
    }

Referenced by sqlite3PagerSetPagesize(), and sqlite3PcacheOpen().

◆ sqlite3PcacheSetSpillsize()

SQLITE_PRIVATE int sqlite3PcacheSetSpillsize	(	PCache *	p,
		int	mxPage )

Definition at line 49694 of file sqlite3.c.

                                                                   {
  int res;
  assert( p->pCache!=0 );
  if( mxPage ){
    if( mxPage<0 ){
      mxPage = (int)((-1024*(i64)mxPage)/(p->szPage+p->szExtra));
    }

References numberOfCachePages(), PCache::pCache, PCache::szExtra, PCache::szPage, and PCache::szSpill.

◆ sqlite3PcacheShrink()

SQLITE_PRIVATE void sqlite3PcacheShrink ( PCache * pCache )

Definition at line 49711 of file sqlite3.c.

◆ sqlite3PcacheShutdown()

SQLITE_PRIVATE void sqlite3PcacheShutdown ( void )

Definition at line 49142 of file sqlite3.c.

Referenced by sqlite3_shutdown().

◆ sqlite3PcacheSize()

SQLITE_PRIVATE int sqlite3PcacheSize ( void )

Definition at line 49152 of file sqlite3.c.

Referenced by sqlite3PagerOpen().

◆ sqlite3PcacheTruncate()

SQLITE_PRIVATE void sqlite3PcacheTruncate	(	PCache *	pCache,
		Pgno	x )

Definition at line 49515 of file sqlite3.c.

                                                                    {
  if( pCache->pCache ){
    PgHdr *p;
    PgHdr *pNext;
    pcacheTrace(("%p.TRUNCATE %d\n",pCache,pgno));
    for(p=pCache->pDirty; p; p=pNext){
      pNext = p->pDirtyNext;
      /* This routine never gets call with a positive pgno except right
      ** after sqlite3PcacheCleanAll().  So if there are dirty pages,
      ** it must be that pgno==0.
      */
      assert( p->pgno>0 );
      if( p->pgno>pgno ){
        assert( p->flags&PGHDR_DIRTY );
        sqlite3PcacheMakeClean(p);
      }
    }
    if( pgno==0 && pCache->nRefSum ){
      sqlite3_pcache_page *pPage1;
      pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0);
      if( ALWAYS(pPage1) ){  /* Page 1 is always available in cache, because
                             ** pCache->nRefSum>0 */
        memset(pPage1->pBuf, 0, pCache->szPage);

References ALWAYS, PgHdr::flags, PCache::nRefSum, sqlite3_pcache_page::pBuf, PCache::pCache, pcacheTrace, PCache::pDirty, PgHdr::pDirtyNext, PGHDR_DIRTY, PgHdr::pgno, sqlite3GlobalConfig, sqlite3PcacheMakeClean(), and PCache::szPage.

Referenced by pager_end_transaction().

◆ sqlite3PExpr()

SQLITE_PRIVATE Expr * sqlite3PExpr	(	Parse *	pParse,
		int	op,
		Expr *	pLeft,
		Expr *	pRight )

Definition at line 100601 of file sqlite3.c.

 {
  Expr *p;
  p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
  if( p ){
    memset(p, 0, sizeof(Expr));
    p->op = op & 0xff;
    p->iAgg = -1;
    sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
    sqlite3ExprCheckHeight(pParse, p->nHeight);

References Parse::db, Expr::iAgg, Expr::nHeight, Expr::op, sqlite3DbMallocRawNN(), sqlite3ExprAttachSubtrees(), sqlite3ExprCheckHeight(), and sqlite3ExprDelete().

Referenced by addWhereTerm(), exprAnalyze(), exprAnalyzeOrTerm(), exprRowColumn(), fkActionTrigger(), fkScanChildren(), flattenSubquery(), selectExpander(), sqlite3CodeSubselect(), sqlite3ExprAnd(), sqlite3ExprForVectorField(), sqlite3WhereTabFuncArgs(), updateFromSelect(), updateVirtualTable(), and yy_reduce().

◆ sqlite3PExprAddSelect()

SQLITE_PRIVATE void sqlite3PExprAddSelect	(	Parse *	pParse,
		Expr *	pExpr,
		Select *	pSelect )

Definition at line 100626 of file sqlite3.c.

                                                                                      {
  if( pExpr ){
    pExpr->x.pSelect = pSelect;
    ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);

Referenced by yy_reduce().

◆ sqlite3Pow10()

static LONGDOUBLE_TYPE sqlite3Pow10 ( int E )

static

Definition at line 31519 of file sqlite3.c.

                                          {
#if defined(_MSC_VER)
  static const LONGDOUBLE_TYPE x[] = {
    1.0e+001L,
    1.0e+002L,
    1.0e+004L,
    1.0e+008L,
    1.0e+016L,
    1.0e+032L,
    1.0e+064L,
    1.0e+128L,
    1.0e+256L
  };
  LONGDOUBLE_TYPE r = 1.0;
  int i;
  assert( E>=0 && E<=307 );
  for(i=0; E!=0; i++, E >>=1){
    if( E & 1 ) r *= x[i];
  }
  return r;
#else
  LONGDOUBLE_TYPE x = 10.0;
  LONGDOUBLE_TYPE r = 1.0;
  while(1){
    if( E & 1 ) r *= x;
    E >>= 1;

References LONGDOUBLE_TYPE.

Referenced by sqlite3AtoF().

◆ sqlite3Pragma()

SQLITE_PRIVATE void sqlite3Pragma	(	Parse *	pParse,
		Token *	pId1,
		Token *	pId2,
		Token *	pValue,
		int	minusFlag )

Definition at line 126117 of file sqlite3.c.

 {
  char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
  char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
  const char *zDb = 0;   /* The database name */
  Token *pId;            /* Pointer to <id> token */
  char *aFcntl[4];       /* Argument to SQLITE_FCNTL_PRAGMA */
  int iDb;               /* Database index for <database> */
  int rc;                      /* return value form SQLITE_FCNTL_PRAGMA */
  sqlite3 *db = pParse->db;    /* The database connection */
  Db *pDb;                     /* The specific database being pragmaed */
  Vdbe *v = sqlite3GetVdbe(pParse);  /* Prepared statement */
  const PragmaName *pPragma;   /* The pragma */
 
  if( v==0 ) return;
  sqlite3VdbeRunOnlyOnce(v);
  pParse->nMem = 2;
 
  /* Interpret the [schema.] part of the pragma statement. iDb is the
  ** index of the database this pragma is being applied to in db.aDb[]. */
  iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
  if( iDb<0 ) return;
  pDb = &db->aDb[iDb];
 
  /* If the temp database has been explicitly named as part of the
  ** pragma, make sure it is open.
  */
  if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
    return;
  }
 
  zLeft = sqlite3NameFromToken(db, pId);
  if( !zLeft ) return;
  if( minusFlag ){
    zRight = sqlite3MPrintf(db, "-%T", pValue);
  }else{
    zRight = sqlite3NameFromToken(db, pValue);
  }
 
  assert( pId2 );
  zDb = pId2->n>0 ? pDb->zDbSName : 0;
  if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
    goto pragma_out;
  }
 
  /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS
  ** connection.  If it returns SQLITE_OK, then assume that the VFS
  ** handled the pragma and generate a no-op prepared statement.
  **
  ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed,
  ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file
  ** object corresponding to the database file to which the pragma
  ** statement refers.
  **
  ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
  ** file control is an array of pointers to strings (char**) in which the
  ** second element of the array is the name of the pragma and the third
  ** element is the argument to the pragma or NULL if the pragma has no
  ** argument.
  */
  aFcntl[0] = 0;
  aFcntl[1] = zLeft;
  aFcntl[2] = zRight;
  aFcntl[3] = 0;
  db->busyHandler.nBusy = 0;
  rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);
  if( rc==SQLITE_OK ){
    sqlite3VdbeSetNumCols(v, 1);
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT);
    returnSingleText(v, aFcntl[0]);
    sqlite3_free(aFcntl[0]);
    goto pragma_out;
  }
  if( rc!=SQLITE_NOTFOUND ){
    if( aFcntl[0] ){
      sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);
      sqlite3_free(aFcntl[0]);
    }
    pParse->nErr++;
    pParse->rc = rc;
    goto pragma_out;
  }
 
  /* Locate the pragma in the lookup table */
  pPragma = pragmaLocate(zLeft);
  if( pPragma==0 ) goto pragma_out;
 
  /* Make sure the database schema is loaded if the pragma requires that */
  if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){
    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  }
 
  /* Register the result column names for pragmas that return results */
  if( (pPragma->mPragFlg & PragFlg_NoColumns)==0
   && ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0)
  ){
    setPragmaResultColumnNames(v, pPragma);
  }
 
  /* Jump to the appropriate pragma handler */
  switch( pPragma->ePragTyp ){
 
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
  /*
  **  PRAGMA [schema.]default_cache_size
  **  PRAGMA [schema.]default_cache_size=N
  **
  ** The first form reports the current persistent setting for the
  ** page cache size.  The value returned is the maximum number of
  ** pages in the page cache.  The second form sets both the current
  ** page cache size value and the persistent page cache size value
  ** stored in the database file.
  **
  ** Older versions of SQLite would set the default cache size to a
  ** negative number to indicate synchronous=OFF.  These days, synchronous
  ** is always on by default regardless of the sign of the default cache
  ** size.  But continue to take the absolute value of the default cache
  ** size of historical compatibility.
  */
  case PragTyp_DEFAULT_CACHE_SIZE: {
    static const int iLn = VDBE_OFFSET_LINENO(2);
    static const VdbeOpList getCacheSize[] = {
      { OP_Transaction, 0, 0,        0},                         /* 0 */
      { OP_ReadCookie,  0, 1,        BTREE_DEFAULT_CACHE_SIZE},  /* 1 */
      { OP_IfPos,       1, 8,        0},
      { OP_Integer,     0, 2,        0},
      { OP_Subtract,    1, 2,        1},
      { OP_IfPos,       1, 8,        0},
      { OP_Integer,     0, 1,        0},                         /* 6 */
      { OP_Noop,        0, 0,        0},
      { OP_ResultRow,   1, 1,        0},
    };
    VdbeOp *aOp;
    sqlite3VdbeUsesBtree(v, iDb);
    if( !zRight ){
      pParse->nMem += 2;
      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize));
      aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn);
      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
      aOp[0].p1 = iDb;
      aOp[1].p1 = iDb;
      aOp[6].p1 = SQLITE_DEFAULT_CACHE_SIZE;
    }else{
      int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
      sqlite3BeginWriteOperation(pParse, 0, iDb);
      sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
      assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
      pDb->pSchema->cache_size = size;
      sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
    }
    break;
  }
#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */
 
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
  /*
  **  PRAGMA [schema.]page_size
  **  PRAGMA [schema.]page_size=N
  **
  ** The first form reports the current setting for the
  ** database page size in bytes.  The second form sets the
  ** database page size value.  The value can only be set if
  ** the database has not yet been created.
  */
  case PragTyp_PAGE_SIZE: {
    Btree *pBt = pDb->pBt;
    assert( pBt!=0 );
    if( !zRight ){
      int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
      returnSingleInt(v, size);
    }else{
      /* Malloc may fail when setting the page-size, as there is an internal
      ** buffer that the pager module resizes using sqlite3_realloc().
      */
      db->nextPagesize = sqlite3Atoi(zRight);
      if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,0,0) ){
        sqlite3OomFault(db);
      }
    }
    break;
  }
 
  /*
  **  PRAGMA [schema.]secure_delete
  **  PRAGMA [schema.]secure_delete=ON/OFF/FAST
  **
  ** The first form reports the current setting for the
  ** secure_delete flag.  The second form changes the secure_delete
  ** flag setting and reports the new value.
  */
  case PragTyp_SECURE_DELETE: {
    Btree *pBt = pDb->pBt;
    int b = -1;
    assert( pBt!=0 );
    if( zRight ){
      if( sqlite3_stricmp(zRight, "fast")==0 ){
        b = 2;
      }else{
        b = sqlite3GetBoolean(zRight, 0);
      }
    }
    if( pId2->n==0 && b>=0 ){
      int ii;
      for(ii=0; ii<db->nDb; ii++){
        sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
      }
    }
    b = sqlite3BtreeSecureDelete(pBt, b);
    returnSingleInt(v, b);
    break;
  }
 
  /*
  **  PRAGMA [schema.]max_page_count
  **  PRAGMA [schema.]max_page_count=N
  **
  ** The first form reports the current setting for the
  ** maximum number of pages in the database file.  The
  ** second form attempts to change this setting.  Both
  ** forms return the current setting.
  **
  ** The absolute value of N is used.  This is undocumented and might
  ** change.  The only purpose is to provide an easy way to test
  ** the sqlite3AbsInt32() function.
  **
  **  PRAGMA [schema.]page_count
  **
  ** Return the number of pages in the specified database.
  */
  case PragTyp_PAGE_COUNT: {
    int iReg;
    i64 x = 0;
    sqlite3CodeVerifySchema(pParse, iDb);
    iReg = ++pParse->nMem;
    if( sqlite3Tolower(zLeft[0])=='p' ){
      sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
    }else{
      if( zRight && sqlite3DecOrHexToI64(zRight,&x)==0 ){
        if( x<0 ) x = 0;
        else if( x>0xfffffffe ) x = 0xfffffffe;
      }else{
        x = 0;
      }
      sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
    }
    sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
    break;
  }
 
  /*
  **  PRAGMA [schema.]locking_mode
  **  PRAGMA [schema.]locking_mode = (normal|exclusive)
  */
  case PragTyp_LOCKING_MODE: {
    const char *zRet = "normal";
    int eMode = getLockingMode(zRight);
 
    if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
      /* Simple "PRAGMA locking_mode;" statement. This is a query for
      ** the current default locking mode (which may be different to
      ** the locking-mode of the main database).
      */
      eMode = db->dfltLockMode;
    }else{
      Pager *pPager;
      if( pId2->n==0 ){
        /* This indicates that no database name was specified as part
        ** of the PRAGMA command. In this case the locking-mode must be
        ** set on all attached databases, as well as the main db file.
        **
        ** Also, the sqlite3.dfltLockMode variable is set so that
        ** any subsequently attached databases also use the specified
        ** locking mode.
        */
        int ii;
        assert(pDb==&db->aDb[0]);
        for(ii=2; ii<db->nDb; ii++){
          pPager = sqlite3BtreePager(db->aDb[ii].pBt);
          sqlite3PagerLockingMode(pPager, eMode);
        }
        db->dfltLockMode = (u8)eMode;
      }
      pPager = sqlite3BtreePager(pDb->pBt);
      eMode = sqlite3PagerLockingMode(pPager, eMode);
    }
 
    assert( eMode==PAGER_LOCKINGMODE_NORMAL
            || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
    if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
      zRet = "exclusive";
    }
    returnSingleText(v, zRet);
    break;
  }
 
  /*
  **  PRAGMA [schema.]journal_mode
  **  PRAGMA [schema.]journal_mode =
  **                      (delete|persist|off|truncate|memory|wal|off)
  */
  case PragTyp_JOURNAL_MODE: {
    int eMode;        /* One of the PAGER_JOURNALMODE_XXX symbols */
    int ii;           /* Loop counter */
 
    if( zRight==0 ){
      /* If there is no "=MODE" part of the pragma, do a query for the
      ** current mode */
      eMode = PAGER_JOURNALMODE_QUERY;
    }else{
      const char *zMode;
      int n = sqlite3Strlen30(zRight);
      for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){
        if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;
      }
      if( !zMode ){
        /* If the "=MODE" part does not match any known journal mode,
        ** then do a query */
        eMode = PAGER_JOURNALMODE_QUERY;
      }
      if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){
        /* Do not allow journal-mode "OFF" in defensive since the database
        ** can become corrupted using ordinary SQL when the journal is off */
        eMode = PAGER_JOURNALMODE_QUERY;
      }
    }
    if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
      /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
      iDb = 0;
      pId2->n = 1;
    }
    for(ii=db->nDb-1; ii>=0; ii--){
      if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
        sqlite3VdbeUsesBtree(v, ii);
        sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
      }
    }
    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
    break;
  }
 
  /*
  **  PRAGMA [schema.]journal_size_limit
  **  PRAGMA [schema.]journal_size_limit=N
  **
  ** Get or set the size limit on rollback journal files.
  */
  case PragTyp_JOURNAL_SIZE_LIMIT: {
    Pager *pPager = sqlite3BtreePager(pDb->pBt);
    i64 iLimit = -2;
    if( zRight ){
      sqlite3DecOrHexToI64(zRight, &iLimit);
      if( iLimit<-1 ) iLimit = -1;
    }
    iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
    returnSingleInt(v, iLimit);
    break;
  }
 
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 
  /*
  **  PRAGMA [schema.]auto_vacuum
  **  PRAGMA [schema.]auto_vacuum=N
  **
  ** Get or set the value of the database 'auto-vacuum' parameter.
  ** The value is one of:  0 NONE 1 FULL 2 INCREMENTAL
  */
#ifndef SQLITE_OMIT_AUTOVACUUM
  case PragTyp_AUTO_VACUUM: {
    Btree *pBt = pDb->pBt;
    assert( pBt!=0 );
    if( !zRight ){
      returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt));
    }else{
      int eAuto = getAutoVacuum(zRight);
      assert( eAuto>=0 && eAuto<=2 );
      db->nextAutovac = (u8)eAuto;
      /* Call SetAutoVacuum() to set initialize the internal auto and
      ** incr-vacuum flags. This is required in case this connection
      ** creates the database file. It is important that it is created
      ** as an auto-vacuum capable db.
      */
      rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
      if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
        /* When setting the auto_vacuum mode to either "full" or
        ** "incremental", write the value of meta[6] in the database
        ** file. Before writing to meta[6], check that meta[3] indicates
        ** that this really is an auto-vacuum capable database.
        */
        static const int iLn = VDBE_OFFSET_LINENO(2);
        static const VdbeOpList setMeta6[] = {
          { OP_Transaction,    0,         1,                 0},    /* 0 */
          { OP_ReadCookie,     0,         1,         BTREE_LARGEST_ROOT_PAGE},
          { OP_If,             1,         0,                 0},    /* 2 */
          { OP_Halt,           SQLITE_OK, OE_Abort,          0},    /* 3 */
          { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 0},    /* 4 */
        };
        VdbeOp *aOp;
        int iAddr = sqlite3VdbeCurrentAddr(v);
        sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6));
        aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
        if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
        aOp[0].p1 = iDb;
        aOp[1].p1 = iDb;
        aOp[2].p2 = iAddr+4;
        aOp[4].p1 = iDb;
        aOp[4].p3 = eAuto - 1;
        sqlite3VdbeUsesBtree(v, iDb);
      }
    }
    break;
  }
#endif
 
  /*
  **  PRAGMA [schema.]incremental_vacuum(N)
  **
  ** Do N steps of incremental vacuuming on a database.
  */
#ifndef SQLITE_OMIT_AUTOVACUUM
  case PragTyp_INCREMENTAL_VACUUM: {
    int iLimit, addr;
    if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
      iLimit = 0x7fffffff;
    }
    sqlite3BeginWriteOperation(pParse, 0, iDb);
    sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
    addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
    sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
    sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
    sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr);
    break;
  }
#endif
 
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
  /*
  **  PRAGMA [schema.]cache_size
  **  PRAGMA [schema.]cache_size=N
  **
  ** The first form reports the current local setting for the
  ** page cache size. The second form sets the local
  ** page cache size value.  If N is positive then that is the
  ** number of pages in the cache.  If N is negative, then the
  ** number of pages is adjusted so that the cache uses -N kibibytes
  ** of memory.
  */
  case PragTyp_CACHE_SIZE: {
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( !zRight ){
      returnSingleInt(v, pDb->pSchema->cache_size);
    }else{
      int size = sqlite3Atoi(zRight);
      pDb->pSchema->cache_size = size;
      sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
    }
    break;
  }
 
  /*
  **  PRAGMA [schema.]cache_spill
  **  PRAGMA cache_spill=BOOLEAN
  **  PRAGMA [schema.]cache_spill=N
  **
  ** The first form reports the current local setting for the
  ** page cache spill size. The second form turns cache spill on
  ** or off.  When turnning cache spill on, the size is set to the
  ** current cache_size.  The third form sets a spill size that
  ** may be different form the cache size.
  ** If N is positive then that is the
  ** number of pages in the cache.  If N is negative, then the
  ** number of pages is adjusted so that the cache uses -N kibibytes
  ** of memory.
  **
  ** If the number of cache_spill pages is less then the number of
  ** cache_size pages, no spilling occurs until the page count exceeds
  ** the number of cache_size pages.
  **
  ** The cache_spill=BOOLEAN setting applies to all attached schemas,
  ** not just the schema specified.
  */
  case PragTyp_CACHE_SPILL: {
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( !zRight ){
      returnSingleInt(v,
         (db->flags & SQLITE_CacheSpill)==0 ? 0 :
            sqlite3BtreeSetSpillSize(pDb->pBt,0));
    }else{
      int size = 1;
      if( sqlite3GetInt32(zRight, &size) ){
        sqlite3BtreeSetSpillSize(pDb->pBt, size);
      }
      if( sqlite3GetBoolean(zRight, size!=0) ){
        db->flags |= SQLITE_CacheSpill;
      }else{
        db->flags &= ~(u64)SQLITE_CacheSpill;
      }
      setAllPagerFlags(db);
    }
    break;
  }
 
  /*
  **  PRAGMA [schema.]mmap_size(N)
  **
  ** Used to set mapping size limit. The mapping size limit is
  ** used to limit the aggregate size of all memory mapped regions of the
  ** database file. If this parameter is set to zero, then memory mapping
  ** is not used at all.  If N is negative, then the default memory map
  ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
  ** The parameter N is measured in bytes.
  **
  ** This value is advisory.  The underlying VFS is free to memory map
  ** as little or as much as it wants.  Except, if N is set to 0 then the
  ** upper layers will never invoke the xFetch interfaces to the VFS.
  */
  case PragTyp_MMAP_SIZE: {
    sqlite3_int64 sz;
#if SQLITE_MAX_MMAP_SIZE>0
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( zRight ){
      int ii;
      sqlite3DecOrHexToI64(zRight, &sz);
      if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;
      if( pId2->n==0 ) db->szMmap = sz;
      for(ii=db->nDb-1; ii>=0; ii--){
        if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
          sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
        }
      }
    }
    sz = -1;
    rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz);
#else
    sz = 0;
    rc = SQLITE_OK;
#endif
    if( rc==SQLITE_OK ){
      returnSingleInt(v, sz);
    }else if( rc!=SQLITE_NOTFOUND ){
      pParse->nErr++;
      pParse->rc = rc;
    }
    break;
  }
 
  /*
  **   PRAGMA temp_store
  **   PRAGMA temp_store = "default"|"memory"|"file"
  **
  ** Return or set the local value of the temp_store flag.  Changing
  ** the local value does not make changes to the disk file and the default
  ** value will be restored the next time the database is opened.
  **
  ** Note that it is possible for the library compile-time options to
  ** override this setting
  */
  case PragTyp_TEMP_STORE: {
    if( !zRight ){
      returnSingleInt(v, db->temp_store);
    }else{
      changeTempStorage(pParse, zRight);
    }
    break;
  }
 
  /*
  **   PRAGMA temp_store_directory
  **   PRAGMA temp_store_directory = ""|"directory_name"
  **
  ** Return or set the local value of the temp_store_directory flag.  Changing
  ** the value sets a specific directory to be used for temporary files.
  ** Setting to a null string reverts to the default temporary directory search.
  ** If temporary directory is changed, then invalidateTempStorage.
  **
  */
  case PragTyp_TEMP_STORE_DIRECTORY: {
    if( !zRight ){
      returnSingleText(v, sqlite3_temp_directory);
    }else{
#ifndef SQLITE_OMIT_WSD
      if( zRight[0] ){
        int res;
        rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
        if( rc!=SQLITE_OK || res==0 ){
          sqlite3ErrorMsg(pParse, "not a writable directory");
          goto pragma_out;
        }
      }
      if( SQLITE_TEMP_STORE==0
       || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
       || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
      ){
        invalidateTempStorage(pParse);
      }
      sqlite3_free(sqlite3_temp_directory);
      if( zRight[0] ){
        sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
      }else{
        sqlite3_temp_directory = 0;
      }
#endif /* SQLITE_OMIT_WSD */
    }
    break;
  }
 
#if SQLITE_OS_WIN
  /*
  **   PRAGMA data_store_directory
  **   PRAGMA data_store_directory = ""|"directory_name"
  **
  ** Return or set the local value of the data_store_directory flag.  Changing
  ** the value sets a specific directory to be used for database files that
  ** were specified with a relative pathname.  Setting to a null string reverts
  ** to the default database directory, which for database files specified with
  ** a relative path will probably be based on the current directory for the
  ** process.  Database file specified with an absolute path are not impacted
  ** by this setting, regardless of its value.
  **
  */
  case PragTyp_DATA_STORE_DIRECTORY: {
    if( !zRight ){
      returnSingleText(v, sqlite3_data_directory);
    }else{
#ifndef SQLITE_OMIT_WSD
      if( zRight[0] ){
        int res;
        rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
        if( rc!=SQLITE_OK || res==0 ){
          sqlite3ErrorMsg(pParse, "not a writable directory");
          goto pragma_out;
        }
      }
      sqlite3_free(sqlite3_data_directory);
      if( zRight[0] ){
        sqlite3_data_directory = sqlite3_mprintf("%s", zRight);
      }else{
        sqlite3_data_directory = 0;
      }
#endif /* SQLITE_OMIT_WSD */
    }
    break;
  }
#endif
 
#if SQLITE_ENABLE_LOCKING_STYLE
  /*
  **   PRAGMA [schema.]lock_proxy_file
  **   PRAGMA [schema.]lock_proxy_file = ":auto:"|"lock_file_path"
  **
  ** Return or set the value of the lock_proxy_file flag.  Changing
  ** the value sets a specific file to be used for database access locks.
  **
  */
  case PragTyp_LOCK_PROXY_FILE: {
    if( !zRight ){
      Pager *pPager = sqlite3BtreePager(pDb->pBt);
      char *proxy_file_path = NULL;
      sqlite3_file *pFile = sqlite3PagerFile(pPager);
      sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
                           &proxy_file_path);
      returnSingleText(v, proxy_file_path);
    }else{
      Pager *pPager = sqlite3BtreePager(pDb->pBt);
      sqlite3_file *pFile = sqlite3PagerFile(pPager);
      int res;
      if( zRight[0] ){
        res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
                                     zRight);
      } else {
        res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
                                     NULL);
      }
      if( res!=SQLITE_OK ){
        sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
        goto pragma_out;
      }
    }
    break;
  }
#endif /* SQLITE_ENABLE_LOCKING_STYLE */
 
  /*
  **   PRAGMA [schema.]synchronous
  **   PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL|EXTRA
  **
  ** Return or set the local value of the synchronous flag.  Changing
  ** the local value does not make changes to the disk file and the
  ** default value will be restored the next time the database is
  ** opened.
  */
  case PragTyp_SYNCHRONOUS: {
    if( !zRight ){
      returnSingleInt(v, pDb->safety_level-1);
    }else{
      if( !db->autoCommit ){
        sqlite3ErrorMsg(pParse,
            "Safety level may not be changed inside a transaction");
      }else if( iDb!=1 ){
        int iLevel = (getSafetyLevel(zRight,0,1)+1) & PAGER_SYNCHRONOUS_MASK;
        if( iLevel==0 ) iLevel = 1;
        pDb->safety_level = iLevel;
        pDb->bSyncSet = 1;
        setAllPagerFlags(db);
      }
    }
    break;
  }
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 
#ifndef SQLITE_OMIT_FLAG_PRAGMAS
  case PragTyp_FLAG: {
    if( zRight==0 ){
      setPragmaResultColumnNames(v, pPragma);
      returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
    }else{
      u64 mask = pPragma->iArg;    /* Mask of bits to set or clear. */
      if( db->autoCommit==0 ){
        /* Foreign key support may not be enabled or disabled while not
        ** in auto-commit mode.  */
        mask &= ~(SQLITE_ForeignKeys);
      }
#if SQLITE_USER_AUTHENTICATION
      if( db->auth.authLevel==UAUTH_User ){
        /* Do not allow non-admin users to modify the schema arbitrarily */
        mask &= ~(SQLITE_WriteSchema);
      }
#endif
 
      if( sqlite3GetBoolean(zRight, 0) ){
        db->flags |= mask;
      }else{
        db->flags &= ~mask;
        if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
      }
 
      /* Many of the flag-pragmas modify the code generated by the SQL
      ** compiler (eg. count_changes). So add an opcode to expire all
      ** compiled SQL statements after modifying a pragma value.
      */
      sqlite3VdbeAddOp0(v, OP_Expire);
      setAllPagerFlags(db);
    }
    break;
  }
#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
 
#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
  /*
  **   PRAGMA table_info(<table>)
  **
  ** Return a single row for each column of the named table. The columns of
  ** the returned data set are:
  **
  ** cid:        Column id (numbered from left to right, starting at 0)
  ** name:       Column name
  ** type:       Column declaration type.
  ** notnull:    True if 'NOT NULL' is part of column declaration
  ** dflt_value: The default value for the column, if any.
  ** pk:         Non-zero for PK fields.
  */
  case PragTyp_TABLE_INFO: if( zRight ){
    Table *pTab;
    sqlite3CodeVerifyNamedSchema(pParse, zDb);
    pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
    if( pTab ){
      int i, k;
      int nHidden = 0;
      Column *pCol;
      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
      pParse->nMem = 7;
      sqlite3ViewGetColumnNames(pParse, pTab);
      for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
        int isHidden = 0;
        if( pCol->colFlags & COLFLAG_NOINSERT ){
          if( pPragma->iArg==0 ){
            nHidden++;
            continue;
          }
          if( pCol->colFlags & COLFLAG_VIRTUAL ){
            isHidden = 2;  /* GENERATED ALWAYS AS ... VIRTUAL */
          }else if( pCol->colFlags & COLFLAG_STORED ){
            isHidden = 3;  /* GENERATED ALWAYS AS ... STORED */
          }else{ assert( pCol->colFlags & COLFLAG_HIDDEN );
            isHidden = 1;  /* HIDDEN */
          }
        }
        if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){
          k = 0;
        }else if( pPk==0 ){
          k = 1;
        }else{
          for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
        }
        assert( pCol->pDflt==0 || pCol->pDflt->op==TK_SPAN || isHidden>=2 );
        sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
               i-nHidden,
               pCol->zName,
               sqlite3ColumnType(pCol,""),
               pCol->notNull ? 1 : 0,
               pCol->pDflt && isHidden<2 ? pCol->pDflt->u.zToken : 0,
               k,
               isHidden);
      }
    }
  }
  break;
 
#ifdef SQLITE_DEBUG
  case PragTyp_STATS: {
    Index *pIdx;
    HashElem *i;
    pParse->nMem = 5;
    sqlite3CodeVerifySchema(pParse, iDb);
    for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
      Table *pTab = sqliteHashData(i);
      sqlite3VdbeMultiLoad(v, 1, "ssiii",
           pTab->zName,
           0,
           pTab->szTabRow,
           pTab->nRowLogEst,
           pTab->tabFlags);
      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
        sqlite3VdbeMultiLoad(v, 2, "siiiX",
           pIdx->zName,
           pIdx->szIdxRow,
           pIdx->aiRowLogEst[0],
           pIdx->hasStat1);
        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
      }
    }
  }
  break;
#endif
 
  case PragTyp_INDEX_INFO: if( zRight ){
    Index *pIdx;
    Table *pTab;
    pIdx = sqlite3FindIndex(db, zRight, zDb);
    if( pIdx==0 ){
      /* If there is no index named zRight, check to see if there is a
      ** WITHOUT ROWID table named zRight, and if there is, show the
      ** structure of the PRIMARY KEY index for that table. */
      pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
      if( pTab && !HasRowid(pTab) ){
        pIdx = sqlite3PrimaryKeyIndex(pTab);
      }
    }
    if( pIdx ){
      int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
      int i;
      int mx;
      if( pPragma->iArg ){
        /* PRAGMA index_xinfo (newer version with more rows and columns) */
        mx = pIdx->nColumn;
        pParse->nMem = 6;
      }else{
        /* PRAGMA index_info (legacy version) */
        mx = pIdx->nKeyCol;
        pParse->nMem = 3;
      }
      pTab = pIdx->pTable;
      sqlite3CodeVerifySchema(pParse, iIdxDb);
      assert( pParse->nMem<=pPragma->nPragCName );
      for(i=0; i<mx; i++){
        i16 cnum = pIdx->aiColumn[i];
        sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
                             cnum<0 ? 0 : pTab->aCol[cnum].zName);
        if( pPragma->iArg ){
          sqlite3VdbeMultiLoad(v, 4, "isiX",
            pIdx->aSortOrder[i],
            pIdx->azColl[i],
            i<pIdx->nKeyCol);
        }
        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
      }
    }
  }
  break;
 
  case PragTyp_INDEX_LIST: if( zRight ){
    Index *pIdx;
    Table *pTab;
    int i;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){
      int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      pParse->nMem = 5;
      sqlite3CodeVerifySchema(pParse, iTabDb);
      for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
        const char *azOrigin[] = { "c", "u", "pk" };
        sqlite3VdbeMultiLoad(v, 1, "isisi",
           i,
           pIdx->zName,
           IsUniqueIndex(pIdx),
           azOrigin[pIdx->idxType],
           pIdx->pPartIdxWhere!=0);
      }
    }
  }
  break;
 
  case PragTyp_DATABASE_LIST: {
    int i;
    pParse->nMem = 3;
    for(i=0; i<db->nDb; i++){
      if( db->aDb[i].pBt==0 ) continue;
      assert( db->aDb[i].zDbSName!=0 );
      sqlite3VdbeMultiLoad(v, 1, "iss",
         i,
         db->aDb[i].zDbSName,
         sqlite3BtreeGetFilename(db->aDb[i].pBt));
    }
  }
  break;
 
  case PragTyp_COLLATION_LIST: {
    int i = 0;
    HashElem *p;
    pParse->nMem = 2;
    for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
      CollSeq *pColl = (CollSeq *)sqliteHashData(p);
      sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
    }
  }
  break;
 
#ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS
  case PragTyp_FUNCTION_LIST: {
    int i;
    HashElem *j;
    FuncDef *p;
    int showInternFunc = (db->mDbFlags & DBFLAG_InternalFunc)!=0;
    pParse->nMem = 6;
    for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){
        pragmaFunclistLine(v, p, 1, showInternFunc);
      }
    }
    for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){
      p = (FuncDef*)sqliteHashData(j);
      pragmaFunclistLine(v, p, 0, showInternFunc);
    }
  }
  break;
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  case PragTyp_MODULE_LIST: {
    HashElem *j;
    pParse->nMem = 1;
    for(j=sqliteHashFirst(&db->aModule); j; j=sqliteHashNext(j)){
      Module *pMod = (Module*)sqliteHashData(j);
      sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
    }
  }
  break;
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
  case PragTyp_PRAGMA_LIST: {
    int i;
    for(i=0; i<ArraySize(aPragmaName); i++){
      sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
    }
  }
  break;
#endif /* SQLITE_INTROSPECTION_PRAGMAS */
 
#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
 
#ifndef SQLITE_OMIT_FOREIGN_KEY
  case PragTyp_FOREIGN_KEY_LIST: if( zRight ){
    FKey *pFK;
    Table *pTab;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){
      pFK = pTab->pFKey;
      if( pFK ){
        int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
        int i = 0;
        pParse->nMem = 8;
        sqlite3CodeVerifySchema(pParse, iTabDb);
        while(pFK){
          int j;
          for(j=0; j<pFK->nCol; j++){
            sqlite3VdbeMultiLoad(v, 1, "iissssss",
                   i,
                   j,
                   pFK->zTo,
                   pTab->aCol[pFK->aCol[j].iFrom].zName,
                   pFK->aCol[j].zCol,
                   actionName(pFK->aAction[1]),  /* ON UPDATE */
                   actionName(pFK->aAction[0]),  /* ON DELETE */
                   "NONE");
          }
          ++i;
          pFK = pFK->pNextFrom;
        }
      }
    }
  }
  break;
#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 
#ifndef SQLITE_OMIT_FOREIGN_KEY
#ifndef SQLITE_OMIT_TRIGGER
  case PragTyp_FOREIGN_KEY_CHECK: {
    FKey *pFK;             /* A foreign key constraint */
    Table *pTab;           /* Child table contain "REFERENCES" keyword */
    Table *pParent;        /* Parent table that child points to */
    Index *pIdx;           /* Index in the parent table */
    int i;                 /* Loop counter:  Foreign key number for pTab */
    int j;                 /* Loop counter:  Field of the foreign key */
    HashElem *k;           /* Loop counter:  Next table in schema */
    int x;                 /* result variable */
    int regResult;         /* 3 registers to hold a result row */
    int regKey;            /* Register to hold key for checking the FK */
    int regRow;            /* Registers to hold a row from pTab */
    int addrTop;           /* Top of a loop checking foreign keys */
    int addrOk;            /* Jump here if the key is OK */
    int *aiCols;           /* child to parent column mapping */
 
    regResult = pParse->nMem+1;
    pParse->nMem += 4;
    regKey = ++pParse->nMem;
    regRow = ++pParse->nMem;
    k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
    while( k ){
      if( zRight ){
        pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
        k = 0;
      }else{
        pTab = (Table*)sqliteHashData(k);
        k = sqliteHashNext(k);
      }
      if( pTab==0 || pTab->pFKey==0 ) continue;
      iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      zDb = db->aDb[iDb].zDbSName;
      sqlite3CodeVerifySchema(pParse, iDb);
      sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
      if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
      sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
      sqlite3VdbeLoadString(v, regResult, pTab->zName);
      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
        pParent = sqlite3FindTable(db, pFK->zTo, zDb);
        if( pParent==0 ) continue;
        pIdx = 0;
        sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
        x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
        if( x==0 ){
          if( pIdx==0 ){
            sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
          }else{
            sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
            sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
          }
        }else{
          k = 0;
          break;
        }
      }
      assert( pParse->nErr>0 || pFK==0 );
      if( pFK ) break;
      if( pParse->nTab<i ) pParse->nTab = i;
      addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
        pParent = sqlite3FindTable(db, pFK->zTo, zDb);
        pIdx = 0;
        aiCols = 0;
        if( pParent ){
          x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
          assert( x==0 );
        }
        addrOk = sqlite3VdbeMakeLabel(pParse);
 
        /* Generate code to read the child key values into registers
        ** regRow..regRow+n. If any of the child key values are NULL, this
        ** row cannot cause an FK violation. Jump directly to addrOk in
        ** this case. */
        for(j=0; j<pFK->nCol; j++){
          int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
          sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
          sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v);
        }
 
        /* Generate code to query the parent index for a matching parent
        ** key. If a match is found, jump to addrOk. */
        if( pIdx ){
          sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
              sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
          sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0);
          VdbeCoverage(v);
        }else if( pParent ){
          int jmp = sqlite3VdbeCurrentAddr(v)+2;
          sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v);
          sqlite3VdbeGoto(v, addrOk);
          assert( pFK->nCol==1 );
        }
 
        /* Generate code to report an FK violation to the caller. */
        if( HasRowid(pTab) ){
          sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);
        }else{
          sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1);
        }
        sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1);
        sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4);
        sqlite3VdbeResolveLabel(v, addrOk);
        sqlite3DbFree(db, aiCols);
      }
      sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v);
      sqlite3VdbeJumpHere(v, addrTop);
    }
  }
  break;
#endif /* !defined(SQLITE_OMIT_TRIGGER) */
#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 
#ifndef SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA
  /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
  ** used will be case sensitive or not depending on the RHS.
  */
  case PragTyp_CASE_SENSITIVE_LIKE: {
    if( zRight ){
      sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0));
    }
  }
  break;
#endif /* SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA */
 
#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
#endif
 
#ifndef SQLITE_OMIT_INTEGRITY_CHECK
  /*    PRAGMA integrity_check
  **    PRAGMA integrity_check(N)
  **    PRAGMA quick_check
  **    PRAGMA quick_check(N)
  **
  ** Verify the integrity of the database.
  **
  ** The "quick_check" is reduced version of
  ** integrity_check designed to detect most database corruption
  ** without the overhead of cross-checking indexes.  Quick_check
  ** is linear time wherease integrity_check is O(NlogN).
  **
  ** The maximum nubmer of errors is 100 by default.  A different default
  ** can be specified using a numeric parameter N.
  **
  ** Or, the parameter N can be the name of a table.  In that case, only
  ** the one table named is verified.  The freelist is only verified if
  ** the named table is "sqlite_schema" (or one of its aliases).
  **
  ** All schemas are checked by default.  To check just a single
  ** schema, use the form:
  **
  **      PRAGMA schema.integrity_check;
  */
  case PragTyp_INTEGRITY_CHECK: {
    int i, j, addr, mxErr;
    Table *pObjTab = 0;     /* Check only this one table, if not NULL */
 
    int isQuick = (sqlite3Tolower(zLeft[0])=='q');
 
    /* If the PRAGMA command was of the form "PRAGMA <db>.integrity_check",
    ** then iDb is set to the index of the database identified by <db>.
    ** In this case, the integrity of database iDb only is verified by
    ** the VDBE created below.
    **
    ** Otherwise, if the command was simply "PRAGMA integrity_check" (or
    ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
    ** to -1 here, to indicate that the VDBE should verify the integrity
    ** of all attached databases.  */
    assert( iDb>=0 );
    assert( iDb==0 || pId2->z );
    if( pId2->z==0 ) iDb = -1;
 
    /* Initialize the VDBE program */
    pParse->nMem = 6;
 
    /* Set the maximum error count */
    mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
    if( zRight ){
      if( sqlite3GetInt32(zRight, &mxErr) ){
        if( mxErr<=0 ){
          mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
        }
      }else{
        pObjTab = sqlite3LocateTable(pParse, 0, zRight,
                      iDb>=0 ? db->aDb[iDb].zDbSName : 0);
      }
    }
    sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
 
    /* Do an integrity check on each database file */
    for(i=0; i<db->nDb; i++){
      HashElem *x;     /* For looping over tables in the schema */
      Hash *pTbls;     /* Set of all tables in the schema */
      int *aRoot;      /* Array of root page numbers of all btrees */
      int cnt = 0;     /* Number of entries in aRoot[] */
      int mxIdx = 0;   /* Maximum number of indexes for any table */
 
      if( OMIT_TEMPDB && i==1 ) continue;
      if( iDb>=0 && i!=iDb ) continue;
 
      sqlite3CodeVerifySchema(pParse, i);
 
      /* Do an integrity check of the B-Tree
      **
      ** Begin by finding the root pages numbers
      ** for all tables and indices in the database.
      */
      assert( sqlite3SchemaMutexHeld(db, i, 0) );
      pTbls = &db->aDb[i].pSchema->tblHash;
      for(cnt=0, x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
        Table *pTab = sqliteHashData(x);  /* Current table */
        Index *pIdx;                      /* An index on pTab */
        int nIdx;                         /* Number of indexes on pTab */
        if( pObjTab && pObjTab!=pTab ) continue;
        if( HasRowid(pTab) ) cnt++;
        for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
        if( nIdx>mxIdx ) mxIdx = nIdx;
      }
      if( cnt==0 ) continue;
      if( pObjTab ) cnt++;
      aRoot = sqlite3DbMallocRawNN(db, sizeof(int)*(cnt+1));
      if( aRoot==0 ) break;
      cnt = 0;
      if( pObjTab ) aRoot[++cnt] = 0;
      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
        Table *pTab = sqliteHashData(x);
        Index *pIdx;
        if( pObjTab && pObjTab!=pTab ) continue;
        if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum;
        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
          aRoot[++cnt] = pIdx->tnum;
        }
      }
      aRoot[0] = cnt;
 
      /* Make sure sufficient number of registers have been allocated */
      pParse->nMem = MAX( pParse->nMem, 8+mxIdx );
      sqlite3ClearTempRegCache(pParse);
 
      /* Do the b-tree integrity checks */
      sqlite3VdbeAddOp4(v, OP_IntegrityCk, 2, cnt, 1, (char*)aRoot,P4_INTARRAY);
      sqlite3VdbeChangeP5(v, (u8)i);
      addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
      sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
         sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zDbSName),
         P4_DYNAMIC);
      sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 3);
      integrityCheckResultRow(v);
      sqlite3VdbeJumpHere(v, addr);
 
      /* Make sure all the indices are constructed correctly.
      */
      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
        Table *pTab = sqliteHashData(x);
        Index *pIdx, *pPk;
        Index *pPrior = 0;
        int loopTop;
        int iDataCur, iIdxCur;
        int r1 = -1;
 
        if( pTab->tnum<1 ) continue;  /* Skip VIEWs or VIRTUAL TABLEs */
        if( pObjTab && pObjTab!=pTab ) continue;
        pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
        sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
                                   1, 0, &iDataCur, &iIdxCur);
        /* reg[7] counts the number of entries in the table.
        ** reg[8+i] counts the number of entries in the i-th index
        */
        sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
          sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */
        }
        assert( pParse->nMem>=8+j );
        assert( sqlite3NoTempsInRange(pParse,1,7+j) );
        sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
        loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
        if( !isQuick ){
          /* Sanity check on record header decoding */
          sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nNVCol-1,3);
          sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
        }
        /* Verify that all NOT NULL columns really are NOT NULL */
        for(j=0; j<pTab->nCol; j++){
          char *zErr;
          int jmp2;
          if( j==pTab->iPKey ) continue;
          if( pTab->aCol[j].notNull==0 ) continue;
          sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
          if( sqlite3VdbeGetOp(v,-1)->opcode==OP_Column ){
            sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
          }
          jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
          zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
                              pTab->aCol[j].zName);
          sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
          integrityCheckResultRow(v);
          sqlite3VdbeJumpHere(v, jmp2);
        }
        /* Verify CHECK constraints */
        if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
          ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0);
          if( db->mallocFailed==0 ){
            int addrCkFault = sqlite3VdbeMakeLabel(pParse);
            int addrCkOk = sqlite3VdbeMakeLabel(pParse);
            char *zErr;
            int k;
            pParse->iSelfTab = iDataCur + 1;
            for(k=pCheck->nExpr-1; k>0; k--){
              sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
            }
            sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
                SQLITE_JUMPIFNULL);
            sqlite3VdbeResolveLabel(v, addrCkFault);
            pParse->iSelfTab = 0;
            zErr = sqlite3MPrintf(db, "CHECK constraint failed in %s",
                pTab->zName);
            sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
            integrityCheckResultRow(v);
            sqlite3VdbeResolveLabel(v, addrCkOk);
          }
          sqlite3ExprListDelete(db, pCheck);
        }
        if( !isQuick ){ /* Omit the remaining tests for quick_check */
          /* Validate index entries for the current row */
          for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
            int jmp2, jmp3, jmp4, jmp5;
            int ckUniq = sqlite3VdbeMakeLabel(pParse);
            if( pPk==pIdx ) continue;
            r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
                                         pPrior, r1);
            pPrior = pIdx;
            sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */
            /* Verify that an index entry exists for the current table row */
            jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
                                        pIdx->nColumn); VdbeCoverage(v);
            sqlite3VdbeLoadString(v, 3, "row ");
            sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
            sqlite3VdbeLoadString(v, 4, " missing from index ");
            sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
            jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
            sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
            jmp4 = integrityCheckResultRow(v);
            sqlite3VdbeJumpHere(v, jmp2);
            /* For UNIQUE indexes, verify that only one entry exists with the
            ** current key.  The entry is unique if (1) any column is NULL
            ** or (2) the next entry has a different key */
            if( IsUniqueIndex(pIdx) ){
              int uniqOk = sqlite3VdbeMakeLabel(pParse);
              int jmp6;
              int kk;
              for(kk=0; kk<pIdx->nKeyCol; kk++){
                int iCol = pIdx->aiColumn[kk];
                assert( iCol!=XN_ROWID && iCol<pTab->nCol );
                if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
                sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk);
                VdbeCoverage(v);
              }
              jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
              sqlite3VdbeGoto(v, uniqOk);
              sqlite3VdbeJumpHere(v, jmp6);
              sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
                                   pIdx->nKeyCol); VdbeCoverage(v);
              sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
              sqlite3VdbeGoto(v, jmp5);
              sqlite3VdbeResolveLabel(v, uniqOk);
            }
            sqlite3VdbeJumpHere(v, jmp4);
            sqlite3ResolvePartIdxLabel(pParse, jmp3);
          }
        }
        sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
        sqlite3VdbeJumpHere(v, loopTop-1);
        if( !isQuick ){
          sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
          for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
            if( pPk==pIdx ) continue;
            sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
            addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v);
            sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
            sqlite3VdbeLoadString(v, 4, pIdx->zName);
            sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
            integrityCheckResultRow(v);
            sqlite3VdbeJumpHere(v, addr);
          }
        }
      }
    }
    {
      static const int iLn = VDBE_OFFSET_LINENO(2);
      static const VdbeOpList endCode[] = {
        { OP_AddImm,      1, 0,        0},    /* 0 */
        { OP_IfNotZero,   1, 4,        0},    /* 1 */
        { OP_String8,     0, 3,        0},    /* 2 */
        { OP_ResultRow,   3, 1,        0},    /* 3 */
        { OP_Halt,        0, 0,        0},    /* 4 */
        { OP_String8,     0, 3,        0},    /* 5 */
        { OP_Goto,        0, 3,        0},    /* 6 */
      };
      VdbeOp *aOp;
 
      aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
      if( aOp ){
        aOp[0].p2 = 1-mxErr;
        aOp[2].p4type = P4_STATIC;
        aOp[2].p4.z = "ok";
        aOp[5].p4type = P4_STATIC;
        aOp[5].p4.z = (char*)sqlite3ErrStr(SQLITE_CORRUPT);
      }
      sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2);
    }
  }
  break;
#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
 
#ifndef SQLITE_OMIT_UTF16
  /*
  **   PRAGMA encoding
  **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
  **
  ** In its first form, this pragma returns the encoding of the main
  ** database. If the database is not initialized, it is initialized now.
  **
  ** The second form of this pragma is a no-op if the main database file
  ** has not already been initialized. In this case it sets the default
  ** encoding that will be used for the main database file if a new file
  ** is created. If an existing main database file is opened, then the
  ** default text encoding for the existing database is used.
  **
  ** In all cases new databases created using the ATTACH command are
  ** created to use the same default text encoding as the main database. If
  ** the main database has not been initialized and/or created when ATTACH
  ** is executed, this is done before the ATTACH operation.
  **
  ** In the second form this pragma sets the text encoding to be used in
  ** new database files created using this database handle. It is only
  ** useful if invoked immediately after the main database i
  */
  case PragTyp_ENCODING: {
    static const struct EncName {
      char *zName;
      u8 enc;
    } encnames[] = {
      { "UTF8",     SQLITE_UTF8        },
      { "UTF-8",    SQLITE_UTF8        },  /* Must be element [1] */
      { "UTF-16le", SQLITE_UTF16LE     },  /* Must be element [2] */
      { "UTF-16be", SQLITE_UTF16BE     },  /* Must be element [3] */
      { "UTF16le",  SQLITE_UTF16LE     },
      { "UTF16be",  SQLITE_UTF16BE     },
      { "UTF-16",   0                  }, /* SQLITE_UTF16NATIVE */
      { "UTF16",    0                  }, /* SQLITE_UTF16NATIVE */
      { 0, 0 }
    };
    const struct EncName *pEnc;
    if( !zRight ){    /* "PRAGMA encoding" */
      if( sqlite3ReadSchema(pParse) ) goto pragma_out;
      assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
      assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
      assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
      returnSingleText(v, encnames[ENC(pParse->db)].zName);
    }else{                        /* "PRAGMA encoding = XXX" */
      /* Only change the value of sqlite.enc if the database handle is not
      ** initialized. If the main database exists, the new sqlite.enc value
      ** will be overwritten when the schema is next loaded. If it does not
      ** already exists, it will be created to use the new encoding value.
      */
      if( (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
        for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
          if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
            u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
            SCHEMA_ENC(db) = enc;
            sqlite3SetTextEncoding(db, enc);
            break;
          }
        }
        if( !pEnc->zName ){
          sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
        }
      }
    }
  }
  break;
#endif /* SQLITE_OMIT_UTF16 */
 
#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
  /*
  **   PRAGMA [schema.]schema_version
  **   PRAGMA [schema.]schema_version = <integer>
  **
  **   PRAGMA [schema.]user_version
  **   PRAGMA [schema.]user_version = <integer>
  **
  **   PRAGMA [schema.]freelist_count
  **
  **   PRAGMA [schema.]data_version
  **
  **   PRAGMA [schema.]application_id
  **   PRAGMA [schema.]application_id = <integer>
  **
  ** The pragma's schema_version and user_version are used to set or get
  ** the value of the schema-version and user-version, respectively. Both
  ** the schema-version and the user-version are 32-bit signed integers
  ** stored in the database header.
  **
  ** The schema-cookie is usually only manipulated internally by SQLite. It
  ** is incremented by SQLite whenever the database schema is modified (by
  ** creating or dropping a table or index). The schema version is used by
  ** SQLite each time a query is executed to ensure that the internal cache
  ** of the schema used when compiling the SQL query matches the schema of
  ** the database against which the compiled query is actually executed.
  ** Subverting this mechanism by using "PRAGMA schema_version" to modify
  ** the schema-version is potentially dangerous and may lead to program
  ** crashes or database corruption. Use with caution!
  **
  ** The user-version is not used internally by SQLite. It may be used by
  ** applications for any purpose.
  */
  case PragTyp_HEADER_VALUE: {
    int iCookie = pPragma->iArg;  /* Which cookie to read or write */
    sqlite3VdbeUsesBtree(v, iDb);
    if( zRight && (pPragma->mPragFlg & PragFlg_ReadOnly)==0 ){
      /* Write the specified cookie value */
      static const VdbeOpList setCookie[] = {
        { OP_Transaction,    0,  1,  0},    /* 0 */
        { OP_SetCookie,      0,  0,  0},    /* 1 */
      };
      VdbeOp *aOp;
      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie));
      aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
      aOp[0].p1 = iDb;
      aOp[1].p1 = iDb;
      aOp[1].p2 = iCookie;
      aOp[1].p3 = sqlite3Atoi(zRight);
      aOp[1].p5 = 1;
    }else{
      /* Read the specified cookie value */
      static const VdbeOpList readCookie[] = {
        { OP_Transaction,     0,  0,  0},    /* 0 */
        { OP_ReadCookie,      0,  1,  0},    /* 1 */
        { OP_ResultRow,       1,  1,  0}
      };
      VdbeOp *aOp;
      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie));
      aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0);
      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
      aOp[0].p1 = iDb;
      aOp[1].p1 = iDb;
      aOp[1].p3 = iCookie;
      sqlite3VdbeReusable(v);
    }
  }
  break;
#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
 
#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
  /*
  **   PRAGMA compile_options
  **
  ** Return the names of all compile-time options used in this build,
  ** one option per row.
  */
  case PragTyp_COMPILE_OPTIONS: {
    int i = 0;
    const char *zOpt;
    pParse->nMem = 1;
    while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){
      sqlite3VdbeLoadString(v, 1, zOpt);
      sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
    }
    sqlite3VdbeReusable(v);
  }
  break;
#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 
#ifndef SQLITE_OMIT_WAL
  /*
  **   PRAGMA [schema.]wal_checkpoint = passive|full|restart|truncate
  **
  ** Checkpoint the database.
  */
  case PragTyp_WAL_CHECKPOINT: {
    int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
    int eMode = SQLITE_CHECKPOINT_PASSIVE;
    if( zRight ){
      if( sqlite3StrICmp(zRight, "full")==0 ){
        eMode = SQLITE_CHECKPOINT_FULL;
      }else if( sqlite3StrICmp(zRight, "restart")==0 ){
        eMode = SQLITE_CHECKPOINT_RESTART;
      }else if( sqlite3StrICmp(zRight, "truncate")==0 ){
        eMode = SQLITE_CHECKPOINT_TRUNCATE;
      }
    }
    pParse->nMem = 3;
    sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
  }
  break;
 
  /*
  **   PRAGMA wal_autocheckpoint
  **   PRAGMA wal_autocheckpoint = N
  **
  ** Configure a database connection to automatically checkpoint a database
  ** after accumulating N frames in the log. Or query for the current value
  ** of N.
  */
  case PragTyp_WAL_AUTOCHECKPOINT: {
    if( zRight ){
      sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight));
    }
    returnSingleInt(v,
       db->xWalCallback==sqlite3WalDefaultHook ?
           SQLITE_PTR_TO_INT(db->pWalArg) : 0);
  }
  break;
#endif
 
  /*
  **  PRAGMA shrink_memory
  **
  ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database
  ** connection on which it is invoked to free up as much memory as it
  ** can, by calling sqlite3_db_release_memory().
  */
  case PragTyp_SHRINK_MEMORY: {
    sqlite3_db_release_memory(db);
    break;
  }
 
  /*
  **  PRAGMA optimize
  **  PRAGMA optimize(MASK)
  **  PRAGMA schema.optimize
  **  PRAGMA schema.optimize(MASK)
  **
  ** Attempt to optimize the database.  All schemas are optimized in the first
  ** two forms, and only the specified schema is optimized in the latter two.
  **
  ** The details of optimizations performed by this pragma are expected
  ** to change and improve over time.  Applications should anticipate that
  ** this pragma will perform new optimizations in future releases.
  **
  ** The optional argument is a bitmask of optimizations to perform:
  **
  **    0x0001    Debugging mode.  Do not actually perform any optimizations
  **              but instead return one line of text for each optimization
  **              that would have been done.  Off by default.
  **
  **    0x0002    Run ANALYZE on tables that might benefit.  On by default.
  **              See below for additional information.
  **
  **    0x0004    (Not yet implemented) Record usage and performance
  **              information from the current session in the
  **              database file so that it will be available to "optimize"
  **              pragmas run by future database connections.
  **
  **    0x0008    (Not yet implemented) Create indexes that might have
  **              been helpful to recent queries
  **
  ** The default MASK is and always shall be 0xfffe.  0xfffe means perform all
  ** of the optimizations listed above except Debug Mode, including new
  ** optimizations that have not yet been invented.  If new optimizations are
  ** ever added that should be off by default, those off-by-default
  ** optimizations will have bitmasks of 0x10000 or larger.
  **
  ** DETERMINATION OF WHEN TO RUN ANALYZE
  **
  ** In the current implementation, a table is analyzed if only if all of
  ** the following are true:
  **
  ** (1) MASK bit 0x02 is set.
  **
  ** (2) The query planner used sqlite_stat1-style statistics for one or
  **     more indexes of the table at some point during the lifetime of
  **     the current connection.
  **
  ** (3) One or more indexes of the table are currently unanalyzed OR
  **     the number of rows in the table has increased by 25 times or more
  **     since the last time ANALYZE was run.
  **
  ** The rules for when tables are analyzed are likely to change in
  ** future releases.
  */
  case PragTyp_OPTIMIZE: {
    int iDbLast;           /* Loop termination point for the schema loop */
    int iTabCur;           /* Cursor for a table whose size needs checking */
    HashElem *k;           /* Loop over tables of a schema */
    Schema *pSchema;       /* The current schema */
    Table *pTab;           /* A table in the schema */
    Index *pIdx;           /* An index of the table */
    LogEst szThreshold;    /* Size threshold above which reanalysis is needd */
    char *zSubSql;         /* SQL statement for the OP_SqlExec opcode */
    u32 opMask;            /* Mask of operations to perform */
 
    if( zRight ){
      opMask = (u32)sqlite3Atoi(zRight);
      if( (opMask & 0x02)==0 ) break;
    }else{
      opMask = 0xfffe;
    }
    iTabCur = pParse->nTab++;
    for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
      if( iDb==1 ) continue;
      sqlite3CodeVerifySchema(pParse, iDb);
      pSchema = db->aDb[iDb].pSchema;
      for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
        pTab = (Table*)sqliteHashData(k);
 
        /* If table pTab has not been used in a way that would benefit from
        ** having analysis statistics during the current session, then skip it.
        ** This also has the effect of skipping virtual tables and views */
        if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue;
 
        /* Reanalyze if the table is 25 times larger than the last analysis */
        szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
          if( !pIdx->hasStat1 ){
            szThreshold = 0; /* Always analyze if any index lacks statistics */
            break;
          }
        }
        if( szThreshold ){
          sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
          sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur,
                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold);
          VdbeCoverage(v);
        }
        zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"",
                                 db->aDb[iDb].zDbSName, pTab->zName);
        if( opMask & 0x01 ){
          int r1 = sqlite3GetTempReg(pParse);
          sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
          sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
        }else{
          sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC);
        }
      }
    }
    sqlite3VdbeAddOp0(v, OP_Expire);
    break;
  }
 
  /*
  **   PRAGMA busy_timeout
  **   PRAGMA busy_timeout = N
  **
  ** Call sqlite3_busy_timeout(db, N).  Return the current timeout value
  ** if one is set.  If no busy handler or a different busy handler is set
  ** then 0 is returned.  Setting the busy_timeout to 0 or negative
  ** disables the timeout.
  */
  /*case PragTyp_BUSY_TIMEOUT*/ default: {
    assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT );
    if( zRight ){
      sqlite3_busy_timeout(db, sqlite3Atoi(zRight));
    }
    returnSingleInt(v, db->busyTimeout);
    break;
  }
 
  /*
  **   PRAGMA soft_heap_limit
  **   PRAGMA soft_heap_limit = N
  **
  ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the
  ** sqlite3_soft_heap_limit64() interface with the argument N, if N is
  ** specified and is a non-negative integer.
  ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always
  ** returns the same integer that would be returned by the
  ** sqlite3_soft_heap_limit64(-1) C-language function.
  */
  case PragTyp_SOFT_HEAP_LIMIT: {
    sqlite3_int64 N;
    if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
      sqlite3_soft_heap_limit64(N);
    }
    returnSingleInt(v, sqlite3_soft_heap_limit64(-1));
    break;
  }
 
  /*
  **   PRAGMA hard_heap_limit
  **   PRAGMA hard_heap_limit = N
  **
  ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap
  ** limit.  The hard heap limit can be activated or lowered by this
  ** pragma, but not raised or deactivated.  Only the
  ** sqlite3_hard_heap_limit64() C-language API can raise or deactivate
  ** the hard heap limit.  This allows an application to set a heap limit
  ** constraint that cannot be relaxed by an untrusted SQL script.
  */
  case PragTyp_HARD_HEAP_LIMIT: {
    sqlite3_int64 N;
    if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
      sqlite3_int64 iPrior = sqlite3_hard_heap_limit64(-1);
      if( N>0 && (iPrior==0 || iPrior>N) ) sqlite3_hard_heap_limit64(N);
    }
    returnSingleInt(v, sqlite3_hard_heap_limit64(-1));
    break;
  }
 
  /*
  **   PRAGMA threads
  **   PRAGMA threads = N
  **
  ** Configure the maximum number of worker threads.  Return the new
  ** maximum, which might be less than requested.
  */
  case PragTyp_THREADS: {
    sqlite3_int64 N;
    if( zRight
     && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
     && N>=0
    ){
      sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff));
    }
    returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
    break;
  }
 
  /*
  **   PRAGMA analysis_limit
  **   PRAGMA analysis_limit = N
  **
  ** Configure the maximum number of rows that ANALYZE will examine
  ** in each index that it looks at.  Return the new limit.
  */
  case PragTyp_ANALYSIS_LIMIT: {
    sqlite3_int64 N;
    if( zRight
     && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
     && N>=0
    ){
      db->nAnalysisLimit = (int)(N&0x7fffffff);
    }
    returnSingleInt(v, db->nAnalysisLimit);
    break;
  }
 
#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
  /*
  ** Report the current state of file logs for all databases
  */
  case PragTyp_LOCK_STATUS: {
    static const char *const azLockName[] = {
      "unlocked", "shared", "reserved", "pending", "exclusive"
    };
    int i;
    pParse->nMem = 2;
    for(i=0; i<db->nDb; i++){
      Btree *pBt;
      const char *zState = "unknown";
      int j;
      if( db->aDb[i].zDbSName==0 ) continue;
      pBt = db->aDb[i].pBt;
      if( pBt==0 || sqlite3BtreePager(pBt)==0 ){
        zState = "closed";
      }else if( sqlite3_file_control(db, i ? db->aDb[i].zDbSName : 0,
                                     SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
         zState = azLockName[j];
      }
      sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState);
    }
    break;
  }
#endif
 
#if defined(SQLITE_ENABLE_CEROD)
  case PragTyp_ACTIVATE_EXTENSIONS: if( zRight ){
    if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
      sqlite3_activate_cerod(&zRight[6]);
    }
  }
  break;
#endif
 
  } /* End of the PRAGMA switch */
 
  /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only
  ** purpose is to execute assert() statements to verify that if the
  ** PragFlg_NoColumns1 flag is set and the caller specified an argument
  ** to the PRAGMA, the implementation has not added any OP_ResultRow
  ** instructions to the VM.  */
  if( (pPragma->mPragFlg & PragFlg_NoColumns1) && zRight ){
    sqlite3VdbeVerifyNoResultRow(v);

References ExprList::a, FuncDefHash::a, FKey::aAction, Table::aCol, FKey::aCol, sqlite3::aCollSeq, actionName(), sqlite3::aDb, sqlite3::aFunc, Index::aiColumn, Index::aiRowLogEst, ALWAYS, sqlite3::aModule, aPragmaName, ArraySize, Index::aSortOrder, sqlite3::autoCommit, Index::azColl, Db::bSyncSet, BTREE_DEFAULT_CACHE_SIZE, BTREE_INCR_VACUUM, BTREE_LARGEST_ROOT_PAGE, sqlite3::busyHandler, sqlite3::busyTimeout, Schema::cache_size, changeTempStorage(), COLFLAG_HIDDEN, COLFLAG_NOINSERT, COLFLAG_PRIMKEY, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, COLNAME_NAME, Parse::db, DBFLAG_EncodingFixed, DBFLAG_InternalFunc, sqlite3::dfltLockMode, ENC, PragmaName::ePragTyp, sqlite3::flags, getAutoVacuum(), getLockingMode(), getSafetyLevel(), HasRowid, Index::hasStat1, PragmaName::iArg, Index::idxType, FKey::sColMap::iFrom, integrityCheckResultRow(), invalidateTempStorage(), Table::iPKey, Parse::iSelfTab, IsUniqueIndex, LOCATE_NOERR, sqlite3::mallocFailed, mask, MAX, sqlite3::mDbFlags, PragmaName::mPragFlg, Token::n, sqlite3::nAnalysisLimit, BusyHandler::nBusy, Table::nCol, FKey::nCol, Index::nColumn, sqlite3::nDb, sqlite3::nDeferredImmCons, Parse::nErr, ExprList::nExpr, sqlite3::nextAutovac, sqlite3::nextPagesize, Index::nKeyCol, Parse::nMem, Table::nNVCol, Column::notNull, PragmaName::nPragCName, Table::nRowLogEst, Parse::nTab, NULL, OE_Abort, OMIT_TEMPDB, ONLY_IF_REALLOC_STRESS, Expr::op, OP_AddImm, OP_Checkpoint, OP_Column, OP_Concat, OP_Count, OP_Eq, OP_Expire, OP_Found, OP_Goto, OP_Halt, OP_IdxGT, OP_If, OP_IfNotZero, OP_IfPos, OP_IfSmaller, OP_IncrVacuum, OP_Integer, OP_IntegrityCk, OP_IsNull, OP_JournalMode, OP_MakeRecord, OP_MaxPgcnt, OP_Next, OP_Noop, OP_NotNull, OP_Null, OP_OpenRead, OP_Pagecount, OP_ReadCookie, OP_ResultRow, OP_Rewind, OP_Rowid, OP_SeekRowid, OP_SetCookie, OP_SqlExec, OP_String8, OP_Subtract, OP_Transaction, OPFLAG_TYPEOFARG, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, VdbeOp::p4, P4_DYNAMIC, P4_INTARRAY, P4_STATIC, VdbeOp::p4type, VdbeOp::p5, PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_QUERY, PAGER_LOCKINGMODE_EXCLUSIVE, PAGER_LOCKINGMODE_NORMAL, PAGER_LOCKINGMODE_QUERY, PAGER_SYNCHRONOUS_MASK, Db::pBt, Table::pCheck, Column::pDflt, ExprList::ExprList_item::pExpr, Table::pFKey, FuncDef::pHash, Table::pIndex, Index::pNext, FKey::pNextFrom, Index::pPartIdxWhere, PragFlg_NeedSchema, PragFlg_NoColumns, PragFlg_NoColumns1, PragFlg_ReadOnly, pragmaFunclistLine(), pragmaLocate(), PragTyp_ACTIVATE_EXTENSIONS, PragTyp_ANALYSIS_LIMIT, PragTyp_AUTO_VACUUM, PragTyp_BUSY_TIMEOUT, PragTyp_CACHE_SIZE, PragTyp_CACHE_SPILL, PragTyp_CASE_SENSITIVE_LIKE, PragTyp_COLLATION_LIST, PragTyp_COMPILE_OPTIONS, PragTyp_DATA_STORE_DIRECTORY, PragTyp_DATABASE_LIST, PragTyp_DEFAULT_CACHE_SIZE, PragTyp_ENCODING, PragTyp_FLAG, PragTyp_FOREIGN_KEY_CHECK, PragTyp_FOREIGN_KEY_LIST, PragTyp_FUNCTION_LIST, PragTyp_HARD_HEAP_LIMIT, PragTyp_HEADER_VALUE, PragTyp_INCREMENTAL_VACUUM, PragTyp_INDEX_INFO, PragTyp_INDEX_LIST, PragTyp_INTEGRITY_CHECK, PragTyp_JOURNAL_MODE, PragTyp_JOURNAL_SIZE_LIMIT, PragTyp_LOCK_PROXY_FILE, PragTyp_LOCK_STATUS, PragTyp_LOCKING_MODE, PragTyp_MMAP_SIZE, PragTyp_MODULE_LIST, PragTyp_OPTIMIZE, PragTyp_PAGE_COUNT, PragTyp_PAGE_SIZE, PragTyp_PRAGMA_LIST, PragTyp_SECURE_DELETE, PragTyp_SHRINK_MEMORY, PragTyp_SOFT_HEAP_LIMIT, PragTyp_STATS, PragTyp_SYNCHRONOUS, PragTyp_TABLE_INFO, PragTyp_TEMP_STORE, PragTyp_TEMP_STORE_DIRECTORY, PragTyp_THREADS, PragTyp_WAL_AUTOCHECKPOINT, PragTyp_WAL_CHECKPOINT, Db::pSchema, Table::pSchema, Index::pSchema, Index::pTable, sqlite3::pVfs, sqlite3::pWalArg, Parse::rc, returnSingleInt(), returnSingleText(), Db::safety_level, SCHEMA_ENC, setAllPagerFlags(), setPragmaResultColumnNames(), sqlite3_busy_timeout(), sqlite3_compileoption_get(), sqlite3_data_directory, sqlite3_db_release_memory(), sqlite3_file_control(), sqlite3_free(), sqlite3_hard_heap_limit64(), sqlite3_limit(), sqlite3_mprintf(), sqlite3_soft_heap_limit64(), sqlite3_stricmp(), sqlite3_temp_directory, sqlite3_wal_autocheckpoint(), sqlite3AbsInt32(), sqlite3Atoi(), sqlite3AuthCheck(), sqlite3BeginWriteOperation(), sqlite3BtreeGetAutoVacuum(), sqlite3BtreeGetFilename(), sqlite3BtreeGetPageSize(), sqlite3BtreePager(), sqlite3BtreeSecureDelete(), sqlite3BtreeSetAutoVacuum(), sqlite3BtreeSetCacheSize(), sqlite3BtreeSetPageSize(), sqlite3BtreeSetSpillSize(), sqlite3BuiltinFunctions, sqlite3ClearTempRegCache(), sqlite3CodeVerifyNamedSchema(), sqlite3CodeVerifySchema(), sqlite3ColumnType(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3DecOrHexToI64(), sqlite3ErrorMsg(), sqlite3ErrStr(), sqlite3ExprCodeGetColumnOfTable(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3ExprListDelete(), sqlite3ExprListDup(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3FkLocateIndex(), sqlite3GenerateIndexKey(), sqlite3GetBoolean(), sqlite3GetInt32(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3GlobalConfig, sqlite3IndexAffinityStr(), sqlite3JournalModename(), sqlite3LocateTable(), sqlite3LogEst(), sqlite3MPrintf(), sqlite3NameFromToken(), sqlite3OomFault(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3OpenTempDatabase(), sqlite3OsAccess(), sqlite3OsFileControl(), sqlite3OsFileControlHint(), sqlite3PagerFile(), sqlite3PagerJournalSizeLimit(), sqlite3PagerLockingMode(), sqlite3PrimaryKeyIndex(), sqlite3ReadSchema(), sqlite3RegisterLikeFunctions(), sqlite3ResolvePartIdxLabel(), sqlite3SchemaToIndex(), sqlite3SetTextEncoding(), sqlite3StrICmp(), sqlite3Strlen30(), sqlite3StrNICmp, sqlite3TableLock(), sqlite3Tolower, sqlite3TwoPartName(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAddOpList(), sqlite3VdbeChangeP3(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeLoadString(), sqlite3VdbeMakeLabel(), sqlite3VdbeMultiLoad(), sqlite3VdbeResolveLabel(), sqlite3VdbeReusable(), sqlite3VdbeRunOnlyOnce(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), sqlite3VdbeSetP4KeyInfo(), sqlite3VdbeUsesBtree(), sqlite3VdbeVerifyNoMallocRequired, sqlite3VdbeVerifyNoResultRow, sqlite3ViewGetColumnNames(), sqlite3WalDefaultHook(), SQLITE_ACCESS_READWRITE, SQLITE_CacheSpill, SQLITE_CHECKPOINT_FULL, SQLITE_CHECKPOINT_PASSIVE, SQLITE_CHECKPOINT_RESTART, SQLITE_CHECKPOINT_TRUNCATE, SQLITE_CORRUPT, SQLITE_DEFAULT_CACHE_SIZE, SQLITE_Defensive, SQLITE_DeferFKs, SQLITE_FCNTL_LOCKSTATE, SQLITE_FCNTL_MMAP_SIZE, SQLITE_FCNTL_PRAGMA, SQLITE_ForeignKeys, SQLITE_FUNC_HASH_SZ, SQLITE_GET_LOCKPROXYFILE, SQLITE_IgnoreChecks, SQLITE_INTEGRITY_CHECK_ERROR_MAX, SQLITE_JUMPIFNULL, SQLITE_LIMIT_WORKER_THREADS, SQLITE_MAX_ATTACHED, SQLITE_NOMEM, SQLITE_NOTFOUND, SQLITE_NOTNULL, SQLITE_OK, SQLITE_PRAGMA, SQLITE_PTR_TO_INT, SQLITE_SET_LOCKPROXYFILE, SQLITE_TEMP_STORE, SQLITE_TRANSIENT, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF16NATIVE, SQLITE_UTF8, SQLITE_WriteSchema, sqliteHashData, sqliteHashFirst, sqliteHashNext, Index::szIdxRow, sqlite3::szMmap, Table::szTabRow, Table::tabFlags, Schema::tblHash, sqlite3::temp_store, TF_StatsUsed, TK_SPAN, Table::tnum, Index::tnum, FuncDef::u, Expr::u, VDBE_OFFSET_LINENO, VdbeCoverage, XN_ROWID, sqlite3::xWalCallback, VdbeOp::p4union::z, Token::z, FKey::sColMap::zCol, Db::zDbSName, Module::zName, Column::zName, CollSeq::zName, Table::zName, Index::zName, zName, FKey::zTo, and Expr::zToken.

Referenced by yy_reduce().

◆ sqlite3PragmaVtabRegister()

SQLITE_PRIVATE Module * sqlite3PragmaVtabRegister	(	sqlite3 *	db,
		const char *	zName )

Definition at line 128318 of file sqlite3.c.

                                                                                {
  const PragmaName *pName;
  assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );

References sqlite3::aModule, PragmaName::mPragFlg, PragFlg_Result0, PragFlg_Result1, pragmaLocate(), pragmaVtabModule, sqlite3_strnicmp(), sqlite3HashFind(), sqlite3VtabCreateModule(), and zName.

Referenced by sqlite3LocateTable().

◆ sqlite3Prepare()

static int sqlite3Prepare	(	sqlite3 *	db,
		const char *	zSql,
		int	nBytes,
		u32	prepFlags,
		Vdbe *	pReprepare,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

static

Definition at line 128912 of file sqlite3.c.

 {
  char *zErrMsg = 0;        /* Error message */
  int rc = SQLITE_OK;       /* Result code */
  int i;                    /* Loop counter */
  Parse sParse;             /* Parsing context */
 
  memset(&sParse, 0, PARSE_HDR_SZ);
  memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ);
  sParse.pReprepare = pReprepare;
  assert( ppStmt && *ppStmt==0 );
  /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
  assert( sqlite3_mutex_held(db->mutex) );
 
  /* For a long-term use prepared statement avoid the use of
  ** lookaside memory.
  */
  if( prepFlags & SQLITE_PREPARE_PERSISTENT ){
    sParse.disableLookaside++;
    DisableLookaside;
  }
  sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0;
 
  /* Check to verify that it is possible to get a read lock on all
  ** database schemas.  The inability to get a read lock indicates that
  ** some other database connection is holding a write-lock, which in
  ** turn means that the other connection has made uncommitted changes
  ** to the schema.
  **
  ** Were we to proceed and prepare the statement against the uncommitted
  ** schema changes and if those schema changes are subsequently rolled
  ** back and different changes are made in their place, then when this
  ** prepared statement goes to run the schema cookie would fail to detect
  ** the schema change.  Disaster would follow.
  **
  ** This thread is currently holding mutexes on all Btrees (because
  ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
  ** is not possible for another thread to start a new schema change
  ** while this routine is running.  Hence, we do not need to hold
  ** locks on the schema, we just need to make sure nobody else is
  ** holding them.
  **
  ** Note that setting READ_UNCOMMITTED overrides most lock detection,
  ** but it does *not* override schema lock detection, so this all still
  ** works even if READ_UNCOMMITTED is set.
  */
  if( !db->noSharedCache ){
    for(i=0; i<db->nDb; i++) {
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        assert( sqlite3BtreeHoldsMutex(pBt) );
        rc = sqlite3BtreeSchemaLocked(pBt);
        if( rc ){
          const char *zDb = db->aDb[i].zDbSName;
          sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb);
          testcase( db->flags & SQLITE_ReadUncommit );
          goto end_prepare;
        }
      }
    }
  }
 
  sqlite3VtabUnlockList(db);
 
  sParse.db = db;
  if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
    char *zSqlCopy;
    int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
    testcase( nBytes==mxLen );
    testcase( nBytes==mxLen+1 );
    if( nBytes>mxLen ){
      sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long");
      rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
      goto end_prepare;
    }
    zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
    if( zSqlCopy ){
      sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
      sParse.zTail = &zSql[sParse.zTail-zSqlCopy];
      sqlite3DbFree(db, zSqlCopy);
    }else{
      sParse.zTail = &zSql[nBytes];
    }
  }else{
    sqlite3RunParser(&sParse, zSql, &zErrMsg);
  }
  assert( 0==sParse.nQueryLoop );
 
  if( sParse.rc==SQLITE_DONE ){
    sParse.rc = SQLITE_OK;
  }
  if( sParse.checkSchema ){
    schemaIsValid(&sParse);
  }
  if( pzTail ){
    *pzTail = sParse.zTail;
  }
 
  if( db->init.busy==0 ){
    sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags);
  }
  if( db->mallocFailed ){
    sParse.rc = SQLITE_NOMEM_BKPT;
  }
  rc = sParse.rc;
  if( rc!=SQLITE_OK ){
    if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe);
    assert(!(*ppStmt));
  }else{
    *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
  }
 
  if( zErrMsg ){
    sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg);
    sqlite3DbFree(db, zErrMsg);
  }else{
    sqlite3Error(db, rc);
  }
 
  /* Delete any TriggerPrg structures allocated while parsing this statement. */
  while( sParse.pTriggerPrg ){
    TriggerPrg *pT = sParse.pTriggerPrg;
    sParse.pTriggerPrg = pT->pNext;
    sqlite3DbFree(db, pT);
  }

Referenced by sqlite3InitCallback().

◆ sqlite3Prepare16()

static int sqlite3Prepare16	(	sqlite3 *	db,
		const void *	zSql,
		int	nBytes,
		u32	prepFlags,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

static

Definition at line 129192 of file sqlite3.c.

 {
  /* This function currently works by first transforming the UTF-16
  ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
  ** tricky bit is figuring out the pointer to return in *pzTail.
  */
  char *zSql8;
  const char *zTail8 = 0;
  int rc = SQLITE_OK;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppStmt = 0;
  if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
    return SQLITE_MISUSE_BKPT;
  }
  if( nBytes>=0 ){
    int sz;
    const char *z = (const char*)zSql;
    for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
    nBytes = sz;
  }
  sqlite3_mutex_enter(db->mutex);
  zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
  if( zSql8 ){
    rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
  }
 
  if( zTail8 && pzTail ){
    /* If sqlite3_prepare returns a tail pointer, we calculate the
    ** equivalent pointer into the UTF-16 string by counting the unicode
    ** characters between zSql8 and zTail8, and then returning a pointer
    ** the same number of characters into the UTF-16 string.
    */
    int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
    *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);

References sqlite3::mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3LockAndPrepare(), sqlite3SafetyCheckOk(), sqlite3Utf16ByteLen(), sqlite3Utf16to8(), sqlite3Utf8CharLen(), SQLITE_MISUSE_BKPT, SQLITE_OK, and SQLITE_UTF16NATIVE.

Referenced by sqlite3_prepare16_v2(), and sqlite3_prepare16_v3().

◆ sqlite3PrimaryKeyIndex()

SQLITE_PRIVATE Index * sqlite3PrimaryKeyIndex ( Table * pTab )

Definition at line 111310 of file sqlite3.c.

Referenced by analysisLoader(), analyzeOneTable(), convertToWithoutRowidTable(), generateSortTail(), sqlite3_declare_vtab(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowIndexDelete(), sqlite3OpenTable(), sqlite3Pragma(), sqlite3Select(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3WhereEnd(), and updateVirtualTable().

◆ sqlite3PrngRestoreState()

SQLITE_PRIVATE void sqlite3PrngRestoreState ( void )

Definition at line 30355 of file sqlite3.c.

30361 {

◆ sqlite3PrngSaveState()

SQLITE_PRIVATE void sqlite3PrngSaveState ( void )

Definition at line 30348 of file sqlite3.c.

30354 {

◆ sqlite3Put4byte() [1/2]

SQLITE_PRIVATE void sqlite3Put4byte	(	u8 *	,
		u32	)

Referenced by backupOnePage(), walEncodeFrame(), and walRestartHdr().

◆ sqlite3Put4byte() [2/2]

SQLITE_PRIVATE void sqlite3Put4byte	(	unsigned char *	p,
		u32	v )

Definition at line 32458 of file sqlite3.c.

                                                            {
#if SQLITE_BYTEORDER==4321
  memcpy(p,&v,4);
#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
  u32 x = __builtin_bswap32(v);
  memcpy(p,&x,4);
#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
  u32 x = _byteswap_ulong(v);
  memcpy(p,&x,4);
#else

◆ sqlite3PutVarint()

SQLITE_PRIVATE int sqlite3PutVarint	(	unsigned char *	p,
		u64	v )

Definition at line 32117 of file sqlite3.c.

                                 {
    p[i] = buf[j];
  }
  return n;
}
SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
  if( v<=0x7f ){
    p[0] = v&0x7f;
    return 1;
  }
  if( v<=0x3fff ){

◆ sqlite3ReadOnlyShadowTables()

SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables ( sqlite3 * db )

Definition at line 113403 of file sqlite3.c.

                                                           {
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( (db->flags & SQLITE_Defensive)!=0
   && db->pVtabCtx==0
   && db->nVdbeExec==0

Referenced by isAlterableTable(), sqlite3CheckObjectName(), and tabIsReadOnly().

◆ sqlite3ReadSchema()

SQLITE_PRIVATE int sqlite3ReadSchema ( Parse * pParse )

Definition at line 128781 of file sqlite3.c.

                                                   {
  int rc = SQLITE_OK;
  sqlite3 *db = pParse->db;
  assert( sqlite3_mutex_held(db->mutex) );
  if( !db->init.busy ){
    rc = sqlite3Init(db, &pParse->zErrMsg);
    if( rc!=SQLITE_OK ){
      pParse->rc = rc;
      pParse->nErr++;

Referenced by sqlite3Analyze(), sqlite3CreateIndex(), sqlite3DropTrigger(), sqlite3LocateTable(), sqlite3Pragma(), sqlite3Reindex(), and sqlite3StartTable().

◆ sqlite3Realloc()

SQLITE_PRIVATE void * sqlite3Realloc	(	void *	pOld,
		u64	nBytes )

Definition at line 27765 of file sqlite3.c.

                                                           {
  int nOld, nNew, nDiff;
  void *pNew;
  assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
  assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
  if( pOld==0 ){
    return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */
  }
  if( nBytes==0 ){
    sqlite3_free(pOld); /* IMP: R-26507-47431 */
    return 0;
  }
  if( nBytes>=0x7fffff00 ){
    /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
    return 0;
  }
  nOld = sqlite3MallocSize(pOld);
  /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
  ** argument to xRealloc is always a value returned by a prior call to
  ** xRoundup. */
  nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
  if( nOld==nNew ){
    pNew = pOld;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
    nDiff = nNew - nOld;
    if( nDiff>0 && sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
          mem0.alarmThreshold-nDiff ){
      sqlite3MallocAlarm(nDiff);
    }
    pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    if( pNew==0 && mem0.alarmThreshold>0 ){
      sqlite3MallocAlarm((int)nBytes);
      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
    }
#endif
    if( pNew ){
      nNew = sqlite3MallocSize(pNew);
      sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
    }
    sqlite3_mutex_leave(mem0.mutex);
  }else{

Referenced by accessPayload(), pagerOpenSavepoint(), replaceFunc(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3StrAccumEnlarge(), sqlite3VdbeMemGrow(), sqlite3VtabMakeWritable(), vdbePmaReadBlob(), and walIndexPageRealloc().

◆ sqlite3RealSameAsInt()

SQLITE_PRIVATE int sqlite3RealSameAsInt	(	double	r1,
		sqlite3_int64	i )

Definition at line 76536 of file sqlite3.c.

Referenced by alsoAnInt(), and sqlite3VdbeMemNumerify().

◆ sqlite3RefillIndex()

static void sqlite3RefillIndex	(	Parse *	pParse,
		Index *	pIndex,
		int	memRootPage )

static

Definition at line 113702 of file sqlite3.c.

                                                                             {
  Table *pTab = pIndex->pTable;  /* The table that is indexed */
  int iTab = pParse->nTab++;     /* Btree cursor used for pTab */
  int iIdx = pParse->nTab++;     /* Btree cursor used for pIndex */
  int iSorter;                   /* Cursor opened by OpenSorter (if in use) */
  int addr1;                     /* Address of top of loop */
  int addr2;                     /* Address to jump to for next iteration */
  Pgno tnum;                     /* Root page of index */
  int iPartIdxLabel;             /* Jump to this label to skip a row */
  Vdbe *v;                       /* Generate code into this virtual machine */
  KeyInfo *pKey;                 /* KeyInfo for index */
  int regRecord;                 /* Register holding assembled index record */
  sqlite3 *db = pParse->db;      /* The database connection */
  int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
      db->aDb[iDb].zDbSName ) ){
    return;
  }
#endif
 
  /* Require a write-lock on the table to perform this operation */
  sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
 
  v = sqlite3GetVdbe(pParse);
  if( v==0 ) return;
  if( memRootPage>=0 ){
    tnum = (Pgno)memRootPage;
  }else{
    tnum = pIndex->tnum;
  }
  pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
  assert( pKey!=0 || db->mallocFailed || pParse->nErr );
 
  /* Open the sorter cursor if we are to use one. */
  iSorter = pParse->nTab++;
  sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
                    sqlite3KeyInfoRef(pKey), P4_KEYINFO);
 
  /* Open the table. Loop through all rows of the table, inserting index
  ** records into the sorter. */
  sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
  addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
  regRecord = sqlite3GetTempReg(pParse);
  sqlite3MultiWrite(pParse);
 
  sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
  sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
  sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
  sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
  sqlite3VdbeJumpHere(v, addr1);
  if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
  sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
                    (char *)pKey, P4_KEYINFO);
  sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
 
  addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
  if( IsUniqueIndex(pIndex) ){
    int j2 = sqlite3VdbeGoto(v, 1);
    addr2 = sqlite3VdbeCurrentAddr(v);
    sqlite3VdbeVerifyAbortable(v, OE_Abort);
    sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
                         pIndex->nKeyCol); VdbeCoverage(v);
    sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
    sqlite3VdbeJumpHere(v, j2);
  }else{
    /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
    ** abort. The exception is if one of the indexed expressions contains a
    ** user function that throws an exception when it is evaluated. But the
    ** overhead of adding a statement journal to a CREATE INDEX statement is
    ** very small (since most of the pages written do not contain content that
    ** needs to be restored if the statement aborts), so we call
    ** sqlite3MayAbort() for all CREATE INDEX statements.  */
    sqlite3MayAbort(pParse);
    addr2 = sqlite3VdbeCurrentAddr(v);
  }
  sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
  if( !pIndex->bAscKeyBug ){
    /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
    ** faster by avoiding unnecessary seeks.  But the optimization does
    ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
    ** with DESC primary keys, since those indexes have there keys in
    ** a different order from the main table.
    ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
    */
    sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
  }
  sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
  sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
  sqlite3ReleaseTempReg(pParse, regRecord);
  sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);

References sqlite3::aDb, Index::bAscKeyBug, Parse::db, IsUniqueIndex, sqlite3::mallocFailed, Parse::nErr, Index::nKeyCol, Parse::nTab, OE_Abort, OP_Clear, OP_Close, OP_IdxInsert, OP_Next, OP_OpenRead, OP_OpenWrite, OP_Rewind, OP_SeekEnd, OP_SorterCompare, OP_SorterData, OP_SorterInsert, OP_SorterNext, OP_SorterOpen, OP_SorterSort, OPFLAG_BULKCSR, OPFLAG_P2ISREG, OPFLAG_USESEEKRESULT, P4_KEYINFO, Index::pSchema, Index::pTable, sqlite3AuthCheck(), sqlite3GenerateIndexKey(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3KeyInfoOfIndex(), sqlite3KeyInfoRef(), sqlite3MayAbort(), sqlite3MultiWrite(), sqlite3OpenTable(), sqlite3ReleaseTempReg(), sqlite3ResolvePartIdxLabel(), sqlite3SchemaToIndex(), sqlite3TableLock(), sqlite3UniqueConstraint(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeVerifyAbortable, SQLITE_REINDEX, Table::tnum, Index::tnum, VdbeCoverage, Db::zDbSName, Table::zName, and Index::zName.

Referenced by reindexTable(), sqlite3CreateIndex(), and sqlite3Reindex().

◆ sqlite3RegisterBuiltinFunctions()

SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions ( void )

Definition at line 118958 of file sqlite3.c.

                                                         {
  /*
  ** The following array holds FuncDef structures for all of the functions
  ** defined in this file.
  **
  ** The array cannot be constant since changes are made to the
  ** FuncDef.pHash elements at start-time.  The elements of this array
  ** are read-only after initialization is complete.
  **
  ** For peak efficiency, put the most frequently used function last.
  */
  static FuncDef aBuiltinFunc[] = {
/***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
    TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0),
    TEST_FUNC(expr_compare,        2, INLINEFUNC_expr_compare,        0),
    TEST_FUNC(expr_implies_expr,   2, INLINEFUNC_expr_implies_expr,   0),
#ifdef SQLITE_DEBUG
    TEST_FUNC(affinity,          1, INLINEFUNC_affinity, 0),
#endif
/***** Regular functions *****/
#ifdef SQLITE_SOUNDEX
    FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
#endif
#ifndef SQLITE_OMIT_LOAD_EXTENSION
    SFUNCTION(load_extension,    1, 0, 0, loadExt          ),
    SFUNCTION(load_extension,    2, 0, 0, loadExt          ),
#endif
#if SQLITE_USER_AUTHENTICATION
    FUNCTION(sqlite_crypt,       2, 0, 0, sqlite3CryptFunc ),
#endif
#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
    DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
    DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
    INLINE_FUNC(unlikely,        1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
    INLINE_FUNC(likelihood,      2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
    INLINE_FUNC(likely,          1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
    FUNCTION2(sqlite_offset,     1, 0, 0, noopFunc,  SQLITE_FUNC_OFFSET|
                                                     SQLITE_FUNC_TYPEOF),
#endif
    FUNCTION(ltrim,              1, 1, 0, trimFunc         ),
    FUNCTION(ltrim,              2, 1, 0, trimFunc         ),
    FUNCTION(rtrim,              1, 2, 0, trimFunc         ),
    FUNCTION(rtrim,              2, 2, 0, trimFunc         ),
    FUNCTION(trim,               1, 3, 0, trimFunc         ),
    FUNCTION(trim,               2, 3, 0, trimFunc         ),
    FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
    FUNCTION(min,                0, 0, 1, 0                ),
    WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
                                          SQLITE_FUNC_MINMAX ),
    FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
    FUNCTION(max,                0, 1, 1, 0                ),
    WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
                                          SQLITE_FUNC_MINMAX ),
    FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
    FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
    FUNCTION(instr,              2, 0, 0, instrFunc        ),
    FUNCTION(printf,            -1, 0, 0, printfFunc       ),
    FUNCTION(unicode,            1, 0, 0, unicodeFunc      ),
    FUNCTION(char,              -1, 0, 0, charFunc         ),
    FUNCTION(abs,                1, 0, 0, absFunc          ),
#ifndef SQLITE_OMIT_FLOATING_POINT
    FUNCTION(round,              1, 0, 0, roundFunc        ),
    FUNCTION(round,              2, 0, 0, roundFunc        ),
#endif
    FUNCTION(upper,              1, 0, 0, upperFunc        ),
    FUNCTION(lower,              1, 0, 0, lowerFunc        ),
    FUNCTION(hex,                1, 0, 0, hexFunc          ),
    INLINE_FUNC(ifnull,          2, INLINEFUNC_coalesce, 0 ),
    VFUNCTION(random,            0, 0, 0, randomFunc       ),
    VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
    FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
    DFUNCTION(sqlite_version,    0, 0, 0, versionFunc      ),
    DFUNCTION(sqlite_source_id,  0, 0, 0, sourceidFunc     ),
    FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
    FUNCTION(quote,              1, 0, 0, quoteFunc        ),
    VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
    VFUNCTION(changes,           0, 0, 0, changes          ),
    VFUNCTION(total_changes,     0, 0, 0, total_changes    ),
    FUNCTION(replace,            3, 0, 0, replaceFunc      ),
    FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
    FUNCTION(substr,             2, 0, 0, substrFunc       ),
    FUNCTION(substr,             3, 0, 0, substrFunc       ),
    WAGGREGATE(sum,   1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0),
    WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
    WAGGREGATE(avg,   1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
    WAGGREGATE(count, 0,0,0, countStep,
        countFinalize, countFinalize, countInverse, SQLITE_FUNC_COUNT  ),
    WAGGREGATE(count, 1,0,0, countStep,
        countFinalize, countFinalize, countInverse, 0  ),
    WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
    WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
 
    LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
#ifdef SQLITE_CASE_SENSITIVE_LIKE
    LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
    LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
#else
    LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
    LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
#endif
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
    FUNCTION(unknown,           -1, 0, 0, unknownFunc      ),
#endif
    FUNCTION(coalesce,           1, 0, 0, 0                ),
    FUNCTION(coalesce,           0, 0, 0, 0                ),
    INLINE_FUNC(coalesce,       -1, INLINEFUNC_coalesce, 0 ),
    INLINE_FUNC(iif,             3, INLINEFUNC_iif,      0 ),
  };
#ifndef SQLITE_OMIT_ALTERTABLE
  sqlite3AlterFunctions();
#endif
  sqlite3WindowFunctions();
  sqlite3RegisterDateTimeFunctions();
  sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
 
#if 0  /* Enable to print out how the built-in functions are hashed */
  {
    int i;
    FuncDef *p;
    for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
      printf("FUNC-HASH %02d:", i);
      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
        int n = sqlite3Strlen30(p->zName);
        int h = p->zName[0] + n;
        printf(" %s(%d)", p->zName, h);

References FuncDefHash::a, absFunc(), ArraySize, avgFinalize(), changes(), charFunc(), compileoptiongetFunc(), compileoptionusedFunc(), countFinalize(), countInverse(), countStep(), DFUNCTION, errlogFunc(), FUNCTION, FUNCTION2, globInfo, groupConcatFinalize(), groupConcatInverse(), groupConcatStep(), groupConcatValue(), hexFunc(), INLINE_FUNC, INLINEFUNC_affinity, INLINEFUNC_coalesce, INLINEFUNC_expr_compare, INLINEFUNC_expr_implies_expr, INLINEFUNC_iif, INLINEFUNC_implies_nonnull_row, INLINEFUNC_unlikely, instrFunc(), last_insert_rowid(), lengthFunc(), LIKEFUNC, likeInfoAlt, likeInfoNorm, likely, loadExt(), lowerFunc(), minMaxFinalize(), minmaxFunc(), minmaxStep(), minMaxValue(), noopFunc, nullifFunc(), FuncDef::pHash, printf, printfFunc(), quoteFunc(), randomBlob(), randomFunc(), replaceFunc(), roundFunc(), SFUNCTION, sourceidFunc(), sqlite3AlterFunctions(), sqlite3BuiltinFunctions, sqlite3InsertBuiltinFuncs(), sqlite3RegisterDateTimeFunctions(), sqlite3Strlen30(), sqlite3WindowFunctions(), SQLITE_FUNC_CASE, SQLITE_FUNC_COUNT, SQLITE_FUNC_HASH_SZ, SQLITE_FUNC_LENGTH, SQLITE_FUNC_LIKE, SQLITE_FUNC_MINMAX, SQLITE_FUNC_OFFSET, SQLITE_FUNC_TYPEOF, SQLITE_FUNC_UNLIKELY, substrFunc(), sumFinalize(), sumInverse(), sumStep(), TEST_FUNC, total_changes(), totalFinalize(), trim, trimFunc(), typeofFunc(), FuncDef::u, unicodeFunc(), unlikely, upperFunc(), versionFunc(), VFUNCTION, WAGGREGATE, zeroblobFunc(), and FuncDef::zName.

Referenced by sqlite3_initialize().

◆ sqlite3RegisterDateTimeFunctions()

SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions ( void )

Definition at line 22940 of file sqlite3.c.

                                                          {
  static FuncDef aDateTimeFuncs[] = {
#ifndef SQLITE_OMIT_DATETIME_FUNCS
    PURE_DATE(julianday,        -1, 0, 0, juliandayFunc ),
    PURE_DATE(date,             -1, 0, 0, dateFunc      ),
    PURE_DATE(time,             -1, 0, 0, timeFunc      ),
    PURE_DATE(datetime,         -1, 0, 0, datetimeFunc  ),
    PURE_DATE(strftime,         -1, 0, 0, strftimeFunc  ),
    DFUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
    DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
    DFUNCTION(current_date,      0, 0, 0, cdateFunc     ),
#else
    STR_FUNCTION(current_time,      0, "%H:%M:%S",          0, currentTimeFunc),
    STR_FUNCTION(current_date,      0, "%Y-%m-%d",          0, currentTimeFunc),

References ArraySize, cdateFunc(), ctimeFunc(), ctimestampFunc(), dateFunc(), datetimeFunc(), DFUNCTION, juliandayFunc(), PURE_DATE, sqlite3InsertBuiltinFuncs(), STR_FUNCTION, strftimeFunc(), and timeFunc().

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sqlite3RegisterLikeFunctions()

SQLITE_PRIVATE void sqlite3RegisterLikeFunctions	(	sqlite3 *	db,
		int	caseSensitive )

Definition at line 118876 of file sqlite3.c.

                                                                                {
  struct compareInfo *pInfo;
  int flags;
  if( caseSensitive ){
    pInfo = (struct compareInfo*)&likeInfoAlt;
    flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
  }else{
    pInfo = (struct compareInfo*)&likeInfoNorm;
    flags = SQLITE_FUNC_LIKE;

References FuncDef::funcFlags, likeFunc(), likeInfoAlt, likeInfoNorm, sqlite3CreateFunc(), sqlite3FindFunction(), SQLITE_FUNC_CASE, SQLITE_FUNC_LIKE, and SQLITE_UTF8.

Referenced by sqlite3Pragma().

◆ sqlite3RegisterPerConnectionBuiltinFunctions()

SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions ( sqlite3 * db )

Definition at line 118863 of file sqlite3.c.

118869 {

References sqlite3_overload_function(), sqlite3OomFault(), SQLITE_NOMEM, and SQLITE_OK.

Referenced by openDatabase().

◆ sqlite3Reindex()

SQLITE_PRIVATE void sqlite3Reindex	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2 )

Definition at line 115366 of file sqlite3.c.

                                                                               {
  CollSeq *pColl;             /* Collating sequence to be reindexed, or NULL */
  char *z;                    /* Name of a table or index */
  const char *zDb;            /* Name of the database */
  Table *pTab;                /* A table in the database */
  Index *pIndex;              /* An index associated with pTab */
  int iDb;                    /* The database index number */
  sqlite3 *db = pParse->db;   /* The database connection */
  Token *pObjName;            /* Name of the table or index to be reindexed */
 
  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    return;
  }
 
  if( pName1==0 ){
    reindexDatabases(pParse, 0);
    return;
  }else if( NEVER(pName2==0) || pName2->z==0 ){
    char *zColl;
    assert( pName1->z );
    zColl = sqlite3NameFromToken(pParse->db, pName1);
    if( !zColl ) return;
    pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
    if( pColl ){
      reindexDatabases(pParse, zColl);
      sqlite3DbFree(db, zColl);
      return;
    }
    sqlite3DbFree(db, zColl);
  }
  iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
  if( iDb<0 ) return;
  z = sqlite3NameFromToken(db, pObjName);
  if( z==0 ) return;
  zDb = db->aDb[iDb].zDbSName;
  pTab = sqlite3FindTable(db, z, zDb);
  if( pTab ){
    reindexTable(pParse, pTab, 0);
    sqlite3DbFree(db, z);
    return;
  }
  pIndex = sqlite3FindIndex(db, z, zDb);
  sqlite3DbFree(db, z);
  if( pIndex ){

References sqlite3::aDb, Parse::db, ENC, NEVER, reindexDatabases(), reindexTable(), sqlite3BeginWriteOperation(), sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3FindCollSeq(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3NameFromToken(), sqlite3ReadSchema(), sqlite3RefillIndex(), sqlite3TwoPartName(), SQLITE_OK, Token::z, and Db::zDbSName.

Referenced by yy_reduce().

◆ sqlite3ReleaseTempRange()

SQLITE_PRIVATE void sqlite3ReleaseTempRange	(	Parse *	pParse,
		int	iReg,
		int	nReg )

Definition at line 105744 of file sqlite3.c.

       {
    i = pParse->nMem+1;
    pParse->nMem += nReg;
  }
  return i;
}
SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
  if( nReg==1 ){
    sqlite3ReleaseTempReg(pParse, iReg);
    return;
  }

Referenced by analyzeOneTable(), fkLookupParent(), generateSortTail(), selectInnerLoop(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3GenerateIndexKey(), sqlite3Insert(), sqlite3Select(), updateAccumulator(), windowAggStep(), windowCodeOp(), and windowFullScan().

◆ sqlite3ReleaseTempReg()

SQLITE_PRIVATE void sqlite3ReleaseTempReg	(	Parse *	pParse,
		int	iReg )

◆ sqlite3RenameExprlistUnmap()

SQLITE_PRIVATE void sqlite3RenameExprlistUnmap	(	Parse *	pParse,
		ExprList *	pEList )

Definition at line 106632 of file sqlite3.c.

                                                                               {
  if( pEList ){
    int i;
    Walker sWalker;
    memset(&sWalker, 0, sizeof(Walker));
    sWalker.pParse = pParse;
    sWalker.xExprCallback = renameUnmapExprCb;
    sqlite3WalkExprList(&sWalker, pEList);
    for(i=0; i<pEList->nExpr; i++){

◆ sqlite3RenameExprUnmap()

SQLITE_PRIVATE void sqlite3RenameExprUnmap	(	Parse *	pParse,
		Expr *	pExpr )

Definition at line 106616 of file sqlite3.c.

                                                                      {
  u8 eMode = pParse->eParseMode;
  Walker sWalker;
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = pParse;

Referenced by sqlite3AddDefaultValue(), and sqlite3WindowOffsetExpr().

◆ sqlite3RenameTokenMap()

SQLITE_PRIVATE void * sqlite3RenameTokenMap	(	Parse *	pParse,
		void *	pPtr,
		Token *	pToken )

Definition at line 106507 of file sqlite3.c.

                                                                                    {
  RenameToken *pNew;
  assert( pPtr || pParse->db->mallocFailed );
  renameTokenCheckAll(pParse, pPtr);
  if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){
    pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
    if( pNew ){
      pNew->p = pPtr;
      pNew->t = *pToken;
      pNew->pNext = pParse->pRename;

References ALWAYS, Parse::db, Parse::eParseMode, sqlite3::mallocFailed, RenameToken::p, PARSE_MODE_UNMAP, RenameToken::pNext, Parse::pRename, renameTokenCheckAll, sqlite3DbMallocZero(), and RenameToken::t.

Referenced by sqlite3AddColumn(), sqlite3CreateForeignKey(), sqlite3ExprListSetName(), sqlite3IdListAppend(), sqlite3SrcListAppendFromTerm(), sqlite3StartTable(), tokenExpr(), triggerStepAllocate(), and yy_reduce().

◆ sqlite3RenameTokenRemap()

SQLITE_PRIVATE void sqlite3RenameTokenRemap	(	Parse *	pParse,
		void *	pTo,
		void *	pFrom )

Definition at line 106529 of file sqlite3.c.

                                                                                  {
  RenameToken *p;
  renameTokenCheckAll(pParse, pTo);
  for(p=pParse->pRename; p; p=p->pNext){

References RenameToken::p, RenameToken::pNext, Parse::pRename, and renameTokenCheckAll.

Referenced by convertToWithoutRowidTable(), lookupName(), resolveExprStep(), sqlite3AddPrimaryKey(), sqlite3BeginTrigger(), sqlite3CreateForeignKey(), and sqlite3ExprForVectorField().

◆ sqlite3ReportError()

SQLITE_PRIVATE int sqlite3ReportError	(	int	iErr,
		int	lineno,
		const char *	zType )

Definition at line 164582 of file sqlite3.c.

◆ sqlite3Reprepare()

SQLITE_PRIVATE int sqlite3Reprepare ( Vdbe * p )

Definition at line 129095 of file sqlite3.c.

                                            {
  int rc;
  sqlite3_stmt *pNew;
  const char *zSql;
  sqlite3 *db;
  u8 prepFlags;
 
  assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
  zSql = sqlite3_sql((sqlite3_stmt *)p);
  assert( zSql!=0 );  /* Reprepare only called for prepare_v2() statements */
  db = sqlite3VdbeDb(p);
  assert( sqlite3_mutex_held(db->mutex) );
  prepFlags = sqlite3VdbePrepareFlags(p);
  rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
  if( rc ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(db);
    }
    assert( pNew==0 );
    return rc;
  }else{
    assert( pNew!=0 );
  }

References sqlite3::mutex, mutex, sqlite3_mutex_held(), sqlite3_sql(), sqlite3LockAndPrepare(), sqlite3OomFault(), sqlite3TransferBindings(), sqlite3VdbeDb(), sqlite3VdbeFinalize(), sqlite3VdbePrepareFlags(), sqlite3VdbeResetStepResult(), sqlite3VdbeSwap(), SQLITE_NOMEM, and SQLITE_OK.

Referenced by sqlite3_step().

◆ sqlite3ResetAllSchemasOfConnection()

SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection ( sqlite3 * db )

Definition at line 110989 of file sqlite3.c.

                                                                   {
  int i;
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      if( db->nSchemaLock==0 ){
        sqlite3SchemaClear(pDb->pSchema);
      }else{
        DbSetProperty(db, i, DB_ResetWanted);
      }
    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);

Referenced by attachFunc(), invalidateTempStorage(), sqlite3InitOne(), sqlite3RollbackAll(), and sqlite3VdbeExec().

◆ sqlite3ResetOneSchema()

SQLITE_PRIVATE void sqlite3ResetOneSchema	(	sqlite3 *	db,
		int	iDb )

Definition at line 110965 of file sqlite3.c.

                                                               {
  int i;
  assert( iDb<db->nDb );
 
  if( iDb>=0 ){
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    DbSetProperty(db, iDb, DB_ResetWanted);
    DbSetProperty(db, 1, DB_ResetWanted);
    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
  }
 
  if( db->nSchemaLock==0 ){
    for(i=0; i<db->nDb; i++){

References sqlite3::aDb, DB_ResetWanted, DbHasProperty, DbSetProperty, sqlite3::mDbFlags, sqlite3::nDb, sqlite3::nSchemaLock, Db::pSchema, and sqlite3SchemaClear().

Referenced by schemaIsValid(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3ResolveExprListNames()

SQLITE_PRIVATE int sqlite3ResolveExprListNames	(	NameContext *	pNC,
		ExprList *	pList )

Definition at line 99583 of file sqlite3.c.

 {
  int i;
  int savedHasAgg = 0;
  Walker w;
  if( pList==0 ) return WRC_Continue;
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  for(i=0; i<pList->nExpr; i++){
    Expr *pExpr = pList->a[i].pExpr;
    if( pExpr==0 ) continue;
#if SQLITE_MAX_EXPR_DEPTH>0
    w.pParse->nHeight += pExpr->nHeight;
    if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
      return WRC_Abort;
    }
#endif
    sqlite3WalkExpr(&w, pExpr);
#if SQLITE_MAX_EXPR_DEPTH>0
    w.pParse->nHeight -= pExpr->nHeight;
#endif
    assert( EP_Agg==NC_HasAgg );
    assert( EP_Win==NC_HasWin );
    testcase( pNC->ncFlags & NC_HasAgg );
    testcase( pNC->ncFlags & NC_HasWin );
    if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
      ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
      savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
      pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);

References ExprList::a, EP_Agg, EP_Win, ExprSetProperty, NC_HasAgg, NC_HasWin, NC_MinMaxAgg, NameContext::ncFlags, NameContext::nErr, Parse::nErr, ExprList::nExpr, Expr::nHeight, Parse::nHeight, ExprList::ExprList_item::pExpr, Walker::pNC, NameContext::pParse, Walker::pParse, resolveExprStep(), resolveSelectStep(), sqlite3ExprCheckHeight(), sqlite3WalkExpr(), testcase, Walker::u, WRC_Abort, WRC_Continue, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by renameResolveTrigger(), sqlite3Insert(), sqlite3ResolveSelfReference(), and sqlite3UpsertAnalyzeTarget().

◆ sqlite3ResolveExprNames()

SQLITE_PRIVATE int sqlite3ResolveExprNames	(	NameContext *	pNC,
		Expr *	pExpr )

Definition at line 99544 of file sqlite3.c.

 {
  int savedHasAgg;
  Walker w;
 
  if( pExpr==0 ) return SQLITE_OK;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight += pExpr->nHeight;
  if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
    return SQLITE_ERROR;
  }
#endif
  sqlite3WalkExpr(&w, pExpr);
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight -= pExpr->nHeight;
#endif
  assert( EP_Agg==NC_HasAgg );
  assert( EP_Win==NC_HasWin );

References EP_Agg, EP_Win, ExprSetProperty, NC_HasAgg, NC_HasWin, NC_MinMaxAgg, NameContext::ncFlags, NameContext::nErr, Parse::nErr, Expr::nHeight, Parse::nHeight, Walker::pNC, NameContext::pParse, Walker::pParse, resolveExprStep(), resolveSelectStep(), sqlite3ExprCheckHeight(), sqlite3WalkExpr(), SQLITE_ERROR, SQLITE_OK, testcase, Walker::u, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by fkScanChildren(), renameResolveTrigger(), resolveAttachExpr(), resolveOrderByTermToExprList(), resolveOrderGroupBy(), sqlite3DeleteFrom(), sqlite3ResolveSelfReference(), sqlite3Update(), and sqlite3UpsertAnalyzeTarget().

◆ sqlite3ResolveOrderGroupBy()

SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy	(	Parse *	pParse,
		Select *	pSelect,
		ExprList *	pOrderBy,
		const char *	zType )

Definition at line 99118 of file sqlite3.c.

 {
  int i;
  sqlite3 *db = pParse->db;
  ExprList *pEList;
  struct ExprList_item *pItem;
 
  if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
  if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
    return 1;
  }
  pEList = pSelect->pEList;
  assert( pEList!=0 );  /* sqlite3SelectNew() guarantees this */
  for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
    if( pItem->u.x.iOrderByCol ){
      if( pItem->u.x.iOrderByCol>pEList->nExpr ){
        resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
        return 1;
      }

References ExprList::a, sqlite3::aLimit, Parse::db, IN_RENAME_OBJECT, sqlite3::mallocFailed, ExprList::nExpr, Select::pEList, resolveAlias(), resolveOutOfRangeError(), sqlite3ErrorMsg(), and SQLITE_LIMIT_COLUMN.

Referenced by multiSelectOrderBy().

◆ sqlite3ResolvePartIdxLabel()

SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel	(	Parse *	pParse,
		int	iLabel )

Definition at line 117037 of file sqlite3.c.

References Parse::pVdbe, and sqlite3VdbeResolveLabel().

Referenced by sqlite3GenerateRowIndexDelete(), sqlite3Pragma(), and sqlite3RefillIndex().

◆ sqlite3ResolveSelectNames()

SQLITE_PRIVATE void sqlite3ResolveSelectNames	(	Parse *	pParse,
		Select *	p,
		NameContext *	pOuterNC )

Definition at line 99638 of file sqlite3.c.

 {
  Walker w;
 
  assert( p!=0 );
  w.xExprCallback = resolveExprStep;

References Walker::pNC, Walker::pParse, resolveExprStep(), resolveSelectStep(), sqlite3WalkSelect(), Walker::u, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3SelectPrep().

◆ sqlite3ResolveSelfReference()

SQLITE_PRIVATE int sqlite3ResolveSelfReference	(	Parse *	pParse,
		Table *	pTab,
		int	type,
		Expr *	pExpr,
		ExprList *	pList )

Definition at line 99672 of file sqlite3.c.

 {
  SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  NameContext sNC;                /* Name context for pParse->pNewTable */
  int rc;
 
  assert( type==0 || pTab!=0 );
  assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
          || type==NC_GenCol || pTab==0 );
  memset(&sNC, 0, sizeof(sNC));
  memset(&sSrc, 0, sizeof(sSrc));
  if( pTab ){
    sSrc.nSrc = 1;
    sSrc.a[0].zName = pTab->zName;
    sSrc.a[0].pTab = pTab;
    sSrc.a[0].iCursor = -1;
    if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
      /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
      ** schema elements */
      type |= NC_FromDDL;
    }
  }
  sNC.pParse = pParse;

References SrcList::a, sqlite3::aDb, Parse::db, SrcList::SrcList_item::iCursor, NC_FromDDL, NC_GenCol, NC_IdxExpr, NC_IsCheck, NC_IsDDL, NC_PartIdx, NameContext::ncFlags, SrcList::nSrc, NameContext::pParse, Db::pSchema, Table::pSchema, NameContext::pSrcList, SrcList::SrcList_item::pTab, sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), SQLITE_OK, Table::zName, and SrcList::SrcList_item::zName.

Referenced by sqlite3CreateIndex(), sqlite3EndTable(), and sqlite3Vacuum().

◆ sqlite3ResultIntReal()

SQLITE_PRIVATE void sqlite3ResultIntReal ( sqlite3_context * pCtx )

Definition at line 83552 of file sqlite3.c.

83558 {

References sqlite3_value::db, sqlite3_value::flags, MEM_Int, MEM_IntReal, sqlite3::mutex, sqlite3_context::pOut, and sqlite3_mutex_held().

◆ sqlite3ResultSetOfSelect()

SQLITE_PRIVATE Table * sqlite3ResultSetOfSelect	(	Parse *	pParse,
		Select *	pSelect,
		char	aff )

Definition at line 131409 of file sqlite3.c.

                                                                                        {
  Table *pTab;
  sqlite3 *db = pParse->db;
  u64 savedFlags;
 
  savedFlags = db->flags;
  db->flags &= ~(u64)SQLITE_FullColNames;
  db->flags |= SQLITE_ShortColNames;
  sqlite3SelectPrep(pParse, pSelect, 0);
  db->flags = savedFlags;
  if( pParse->nErr ) return 0;
  while( pSelect->pPrior ) pSelect = pSelect->pPrior;
  pTab = sqlite3DbMallocZero(db, sizeof(Table) );
  if( pTab==0 ){
    return 0;
  }
  pTab->nTabRef = 1;
  pTab->zName = 0;
  pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
  sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
  sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);
  pTab->iPKey = -1;

Referenced by sqlite3EndTable(), sqlite3ViewGetColumnNames(), and sqlite3WindowRewrite().

◆ sqlite3RollbackAll()

SQLITE_PRIVATE void sqlite3RollbackAll	(	sqlite3 *	db,
		int	tripCode )

Definition at line 162378 of file sqlite3.c.

                                                                 {
  int i;
  int inTrans = 0;
  int schemaChange;
  assert( sqlite3_mutex_held(db->mutex) );
  sqlite3BeginBenignMalloc();
 
  /* Obtain all b-tree mutexes before making any calls to BtreeRollback().
  ** This is important in case the transaction being rolled back has
  ** modified the database schema. If the b-tree mutexes are not taken
  ** here, then another shared-cache connection might sneak in between
  ** the database rollback and schema reset, which can cause false
  ** corruption reports in some cases.  */
  sqlite3BtreeEnterAll(db);
  schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0;
 
  for(i=0; i<db->nDb; i++){
    Btree *p = db->aDb[i].pBt;
    if( p ){
      if( sqlite3BtreeIsInTrans(p) ){
        inTrans = 1;
      }
      sqlite3BtreeRollback(p, tripCode, !schemaChange);
    }
  }
  sqlite3VtabRollback(db);
  sqlite3EndBenignMalloc();
 
  if( schemaChange ){
    sqlite3ExpirePreparedStatements(db, 0);
    sqlite3ResetAllSchemasOfConnection(db);
  }
  sqlite3BtreeLeaveAll(db);
 
  /* Any deferred constraint violations have now been resolved. */
  db->nDeferredCons = 0;
  db->nDeferredImmCons = 0;
  db->flags &= ~(u64)SQLITE_DeferFKs;

References sqlite3::aDb, sqlite3::autoCommit, sqlite3::sqlite3InitInfo::busy, DBFLAG_SchemaChange, sqlite3::flags, sqlite3::init, sqlite3::mDbFlags, sqlite3::mutex, sqlite3::nDb, sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, Db::pBt, sqlite3::pRollbackArg, sqlite3_mutex_held(), sqlite3BeginBenignMalloc(), sqlite3BtreeEnterAll(), sqlite3BtreeIsInTrans(), sqlite3BtreeLeaveAll(), sqlite3BtreeRollback(), sqlite3EndBenignMalloc(), sqlite3ExpirePreparedStatements(), sqlite3ResetAllSchemasOfConnection(), sqlite3VtabRollback(), SQLITE_DeferFKs, and sqlite3::xRollbackCallback.

Referenced by sqlite3LeaveMutexAndCloseZombie(), sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3RootPageMoved()

SQLITE_PRIVATE void sqlite3RootPageMoved	(	sqlite3 *	db,
		int	iDb,
		Pgno	iFrom,
		Pgno	iTo )

Definition at line 113198 of file sqlite3.c.

                                                                                    {
  HashElem *pElem;
  Hash *pHash;
  Db *pDb;
 
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  pDb = &db->aDb[iDb];
  pHash = &pDb->pSchema->tblHash;
  for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
    Table *pTab = sqliteHashData(pElem);
    if( pTab->tnum==iFrom ){
      pTab->tnum = iTo;
    }
  }
  pHash = &pDb->pSchema->idxHash;
  for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){

References sqlite3::aDb, Schema::idxHash, Db::pSchema, sqliteHashData, sqliteHashFirst, sqliteHashNext, Schema::tblHash, Table::tnum, and Index::tnum.

Referenced by sqlite3VdbeExec().

◆ sqlite3RowidConstraint()

SQLITE_PRIVATE void sqlite3RowidConstraint	(	Parse *	pParse,
		int	onError,
		Table *	pTab )

Definition at line 115270 of file sqlite3.c.

 {
  char *zMsg;
  int rc;
  if( pTab->iPKey>=0 ){
    zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
                          pTab->aCol[pTab->iPKey].zName);
    rc = SQLITE_CONSTRAINT_PRIMARYKEY;
  }else{

Referenced by sqlite3GenerateConstraintChecks(), and xferOptimization().

◆ sqlite3RowSetClear()

SQLITE_PRIVATE void sqlite3RowSetClear ( void * pArg )

Definition at line 51190 of file sqlite3.c.

                                                  {
  RowSet *p = (RowSet*)pArg;
  struct RowSetChunk *pChunk, *pNextChunk;
  for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
    pNextChunk = pChunk->pNextChunk;
    sqlite3DbFree(p->db, pChunk);
  }
  p->pChunk = 0;

References RowSet::db, RowSet::nFresh, RowSet::pChunk, RowSet::pEntry, RowSet::pForest, RowSet::pLast, RowSetChunk::pNextChunk, ROWSET_SORTED, RowSet::rsFlags, and sqlite3DbFree().

Referenced by sqlite3RowSetDelete(), and sqlite3RowSetNext().

◆ sqlite3RowSetDelete()

SQLITE_PRIVATE void sqlite3RowSetDelete ( void * pArg )

Definition at line 51210 of file sqlite3.c.

References sqlite3DbFree(), and sqlite3RowSetClear().

Referenced by sqlite3VdbeMemSetRowSet().

◆ sqlite3RowSetInit()

SQLITE_PRIVATE RowSet * sqlite3RowSetInit ( sqlite3 * db )

Definition at line 51168 of file sqlite3.c.

                                                     {
  RowSet *p = sqlite3DbMallocRawNN(db, sizeof(*p));
  if( p ){
    int N = sqlite3DbMallocSize(db, p);
    p->pChunk = 0;
    p->db = db;
    p->pEntry = 0;
    p->pLast = 0;
    p->pForest = 0;
    p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);

References RowSet::db, RowSet::iBatch, RowSet::nFresh, RowSet::pChunk, RowSet::pEntry, RowSet::pForest, RowSet::pFresh, RowSet::pLast, ROUND8, ROWSET_SORTED, RowSet::rsFlags, sqlite3DbMallocRawNN(), and sqlite3DbMallocSize().

Referenced by sqlite3VdbeMemSetRowSet().

◆ sqlite3RowSetInsert()

SQLITE_PRIVATE void sqlite3RowSetInsert	(	RowSet *	p,
		i64	rowid )

Definition at line 51248 of file sqlite3.c.

                                                             {
  struct RowSetEntry *pEntry;  /* The new entry */
  struct RowSetEntry *pLast;   /* The last prior entry */
 
  /* This routine is never called after sqlite3RowSetNext() */
  assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
 
  pEntry = rowSetEntryAlloc(p);
  if( pEntry==0 ) return;
  pEntry->v = rowid;
  pEntry->pRight = 0;
  pLast = p->pLast;
  if( pLast ){
    if( rowid<=pLast->v ){  /*OPTIMIZATION-IF-FALSE*/
      /* Avoid unnecessary sorts by preserving the ROWSET_SORTED flags
      ** where possible */
      p->rsFlags &= ~ROWSET_SORTED;
    }

References RowSet::pEntry, RowSet::pLast, RowSetEntry::pRight, ROWSET_NEXT, rowSetEntryAlloc(), RowSet::rsFlags, and RowSetEntry::v.

Referenced by sqlite3VdbeExec().

◆ sqlite3RowSetNext()

SQLITE_PRIVATE int sqlite3RowSetNext	(	RowSet *	p,
		i64 *	pRowid )

Definition at line 51446 of file sqlite3.c.

                                                            {
  assert( p!=0 );
  assert( p->pForest==0 );  /* Cannot be used with sqlite3RowSetText() */
 
  /* Merge the forest into a single sorted list on first call */
  if( (p->rsFlags & ROWSET_NEXT)==0 ){  /*OPTIMIZATION-IF-FALSE*/
    if( (p->rsFlags & ROWSET_SORTED)==0 ){  /*OPTIMIZATION-IF-FALSE*/
      p->pEntry = rowSetEntrySort(p->pEntry);
    }
    p->rsFlags |= ROWSET_SORTED|ROWSET_NEXT;
  }
 
  /* Return the next entry on the list */
  if( p->pEntry ){
    *pRowid = p->pEntry->v;
    p->pEntry = p->pEntry->pRight;
    if( p->pEntry==0 ){ /*OPTIMIZATION-IF-TRUE*/
      /* Free memory immediately, rather than waiting on sqlite3_finalize() */
      sqlite3RowSetClear(p);

References RowSet::pEntry, RowSet::pForest, RowSetEntry::pRight, ROWSET_NEXT, ROWSET_SORTED, rowSetEntrySort(), RowSet::rsFlags, sqlite3RowSetClear(), and RowSetEntry::v.

Referenced by sqlite3VdbeExec().

◆ sqlite3RowSetTest()

SQLITE_PRIVATE int sqlite3RowSetTest	(	RowSet *	pRowSet,
		int	iBatch,
		i64	iRowid )

Definition at line 51480 of file sqlite3.c.

                                                                                       {
  struct RowSetEntry *p, *pTree;
 
  /* This routine is never called after sqlite3RowSetNext() */
  assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 );
 
  /* Sort entries into the forest on the first test of a new batch.
  ** To save unnecessary work, only do this when the batch number changes.
  */
  if( iBatch!=pRowSet->iBatch ){  /*OPTIMIZATION-IF-FALSE*/
    p = pRowSet->pEntry;
    if( p ){
      struct RowSetEntry **ppPrevTree = &pRowSet->pForest;
      if( (pRowSet->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/
        /* Only sort the current set of entries if they need it */
        p = rowSetEntrySort(p);
      }
      for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){
        ppPrevTree = &pTree->pRight;
        if( pTree->pLeft==0 ){
          pTree->pLeft = rowSetListToTree(p);
          break;
        }else{
          struct RowSetEntry *pAux, *pTail;
          rowSetTreeToList(pTree->pLeft, &pAux, &pTail);
          pTree->pLeft = 0;
          p = rowSetEntryMerge(pAux, p);
        }
      }
      if( pTree==0 ){
        *ppPrevTree = pTree = rowSetEntryAlloc(pRowSet);
        if( pTree ){
          pTree->v = 0;
          pTree->pRight = 0;
          pTree->pLeft = rowSetListToTree(p);
        }
      }
      pRowSet->pEntry = 0;
      pRowSet->pLast = 0;
      pRowSet->rsFlags |= ROWSET_SORTED;
    }
    pRowSet->iBatch = iBatch;
  }
 
  /* Test to see if the iRowid value appears anywhere in the forest.
  ** Return 1 if it does and 0 if not.
  */
  for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){
    p = pTree->pLeft;
    while( p ){
      if( p->v<iRowid ){
        p = p->pRight;
      }else if( p->v>iRowid ){
        p = p->pLeft;
      }else{

References RowSet::iBatch, RowSet::pEntry, RowSet::pForest, RowSet::pLast, RowSetEntry::pLeft, RowSetEntry::pRight, ROWSET_NEXT, ROWSET_SORTED, rowSetEntryAlloc(), rowSetEntryMerge(), rowSetEntrySort(), rowSetListToTree(), rowSetTreeToList(), RowSet::rsFlags, and RowSetEntry::v.

Referenced by sqlite3VdbeExec().

◆ sqlite3RunParser()

SQLITE_PRIVATE int sqlite3RunParser	(	Parse *	pParse,
		const char *	zSql,
		char **	pzErrMsg )

Definition at line 160294 of file sqlite3.c.

                                                                                     {
  int nErr = 0;                   /* Number of errors encountered */
  void *pEngine;                  /* The LEMON-generated LALR(1) parser */
  int n = 0;                      /* Length of the next token token */
  int tokenType;                  /* type of the next token */
  int lastTokenParsed = -1;       /* type of the previous token */
  sqlite3 *db = pParse->db;       /* The database connection */
  int mxSqlLen;                   /* Max length of an SQL string */
#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
  yyParser sEngine;    /* Space to hold the Lemon-generated Parser object */
#endif
  VVA_ONLY( u8 startedWithOom = db->mallocFailed );
 
  assert( zSql!=0 );
  mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
  if( db->nVdbeActive==0 ){
    AtomicStore(&db->u1.isInterrupted, 0);
  }
  pParse->rc = SQLITE_OK;
  pParse->zTail = zSql;
  assert( pzErrMsg!=0 );
#ifdef SQLITE_DEBUG
  if( db->flags & SQLITE_ParserTrace ){
    printf("parser: [[[%s]]]\n", zSql);
    sqlite3ParserTrace(stdout, "parser: ");
  }else{
    sqlite3ParserTrace(0, 0);
  }
#endif
#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
  pEngine = &sEngine;
  sqlite3ParserInit(pEngine, pParse);
#else
  pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse);
  if( pEngine==0 ){
    sqlite3OomFault(db);
    return SQLITE_NOMEM_BKPT;
  }
#endif
  assert( pParse->pNewTable==0 );
  assert( pParse->pNewTrigger==0 );
  assert( pParse->nVar==0 );
  assert( pParse->pVList==0 );
  pParse->pParentParse = db->pParse;
  db->pParse = pParse;
  while( 1 ){
    n = sqlite3GetToken((u8*)zSql, &tokenType);
    mxSqlLen -= n;
    if( mxSqlLen<0 ){
      pParse->rc = SQLITE_TOOBIG;
      break;
    }
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( tokenType>=TK_WINDOW ){
      assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER
           || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW
      );
#else
    if( tokenType>=TK_SPACE ){
      assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
#endif /* SQLITE_OMIT_WINDOWFUNC */
      if( AtomicLoad(&db->u1.isInterrupted) ){
        pParse->rc = SQLITE_INTERRUPT;
        break;
      }
      if( tokenType==TK_SPACE ){
        zSql += n;
        continue;
      }
      if( zSql[0]==0 ){
        /* Upon reaching the end of input, call the parser two more times
        ** with tokens TK_SEMI and 0, in that order. */
        if( lastTokenParsed==TK_SEMI ){
          tokenType = 0;
        }else if( lastTokenParsed==0 ){
          break;
        }else{
          tokenType = TK_SEMI;
        }
        n = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
      }else if( tokenType==TK_WINDOW ){
        assert( n==6 );
        tokenType = analyzeWindowKeyword((const u8*)&zSql[6]);
      }else if( tokenType==TK_OVER ){
        assert( n==4 );
        tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed);
      }else if( tokenType==TK_FILTER ){
        assert( n==6 );
        tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed);
#endif /* SQLITE_OMIT_WINDOWFUNC */
      }else{
        sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
        break;
      }
    }
    pParse->sLastToken.z = zSql;
    pParse->sLastToken.n = n;
    sqlite3Parser(pEngine, tokenType, pParse->sLastToken);
    lastTokenParsed = tokenType;
    zSql += n;
    assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
    if( pParse->rc!=SQLITE_OK ) break;
  }
  assert( nErr==0 );
#ifdef YYTRACKMAXSTACKDEPTH
  sqlite3_mutex_enter(sqlite3MallocMutex());
  sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
      sqlite3ParserStackPeak(pEngine)
  );
  sqlite3_mutex_leave(sqlite3MallocMutex());
#endif /* YYDEBUG */
#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
  sqlite3ParserFinalize(pEngine);
#else
  sqlite3ParserFree(pEngine, sqlite3_free);
#endif
  if( db->mallocFailed ){
    pParse->rc = SQLITE_NOMEM_BKPT;
  }
  if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
    pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc));
  }
  assert( pzErrMsg!=0 );
  if( pParse->zErrMsg ){
    *pzErrMsg = pParse->zErrMsg;
    sqlite3_log(pParse->rc, "%s in \"%s\"",
                *pzErrMsg, pParse->zTail);
    pParse->zErrMsg = 0;
    nErr++;
  }
  pParse->zTail = zSql;
  if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
    sqlite3VdbeDelete(pParse->pVdbe);
    pParse->pVdbe = 0;
  }
#ifndef SQLITE_OMIT_SHARED_CACHE
  if( pParse->nested==0 ){
    sqlite3DbFree(db, pParse->aTableLock);
    pParse->aTableLock = 0;
    pParse->nTableLock = 0;
  }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
  sqlite3_free(pParse->apVtabLock);
#endif
 
  if( !IN_SPECIAL_PARSE ){
    /* If the pParse->declareVtab flag is set, do not delete any table
    ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
    ** will take responsibility for freeing the Table structure.
    */
    sqlite3DeleteTable(db, pParse->pNewTable);
  }
  if( !IN_RENAME_OBJECT ){
    sqlite3DeleteTrigger(db, pParse->pNewTrigger);
  }
 
  if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree);
  sqlite3DbFree(db, pParse->pVList);
  while( pParse->pAinc ){
    AutoincInfo *p = pParse->pAinc;
    pParse->pAinc = p->pNext;
    sqlite3DbFreeNN(db, p);
  }
  while( pParse->pZombieTab ){
    Table *p = pParse->pZombieTab;
    pParse->pZombieTab = p->pNextZombie;
    sqlite3DeleteTable(db, p);

References sqlite3_str::accError, sqlite3::aLimit, analyzeFilterKeyword(), analyzeOverKeyword(), analyzeWindowKeyword(), Parse::apVtabLock, Parse::aTableLock, AtomicLoad, AtomicStore, Parse::db, eType, sqlite3::flags, IN_RENAME_OBJECT, IN_SPECIAL_PARSE, sqlite3::isInterrupted, sqlite3::mallocFailed, Token::n, sqlite3_str::nChar, Parse::nErr, Parse::nested, NEVER, Parse::nTableLock, Parse::nVar, sqlite3::nVdbeActive, Parse::pAinc, Parse::pNewTable, Parse::pNewTrigger, AutoincInfo::pNext, Table::pNextZombie, Parse::pParentParse, sqlite3::pParse, printf, Parse::pVdbe, Parse::pVList, Parse::pWithToFree, Parse::pZombieTab, Parse::rc, Parse::sLastToken, sqlite3_free(), sqlite3_log(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_str_append(), sqlite3_str_appendf(), sqlite3_str_finish(), sqlite3_str_new(), sqlite3DbFree(), sqlite3DbFreeNN(), sqlite3DbStrNDup(), sqlite3DeleteTable(), sqlite3DeleteTrigger(), sqlite3Dequote(), sqlite3ErrorMsg(), sqlite3ErrStr(), sqlite3GetToken(), sqlite3IsIdChar(), sqlite3Isquote, sqlite3Malloc(), sqlite3MallocMutex(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3Parser(), sqlite3ParserFinalize(), sqlite3ParserInit(), sqlite3StatusHighwater(), sqlite3Strlen30(), sqlite3Tolower, sqlite3Toupper, sqlite3VdbeDb(), sqlite3VdbeDelete(), sqlite3WithDelete(), SQLITE_DONE, SQLITE_INTERRUPT, SQLITE_LIMIT_SQL_LENGTH, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_PRIVATE, SQLITE_STATUS_PARSER_STACK, SQLITE_TOOBIG, TK_BLOB, TK_FILTER, TK_FLOAT, TK_ID, TK_ILLEGAL, TK_IN, TK_INTEGER, TK_IS, TK_LP, TK_NOT, TK_NULL, TK_OVER, TK_RP, TK_SELECT, TK_SEMI, TK_SPACE, TK_STRING, TK_VARIABLE, TK_WINDOW, sqlite3::u1, VVA_ONLY, Token::z, Parse::zErrMsg, Parse::zTail, and sqlite3_str::zText.

Referenced by renameParseSql(), sqlite3_declare_vtab(), and sqlite3NestedParse().

◆ sqlite3RunVacuum()

SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum	(	char **	pzErrMsg,
		sqlite3 *	db,
		int	iDb,
		sqlite3_value *	pOut )

Definition at line 139307 of file sqlite3.c.

 {
  int rc = SQLITE_OK;     /* Return code from service routines */
  Btree *pMain;           /* The database being vacuumed */
  Btree *pTemp;           /* The temporary database we vacuum into */
  u32 saved_mDbFlags;     /* Saved value of db->mDbFlags */
  u64 saved_flags;        /* Saved value of db->flags */
  int saved_nChange;      /* Saved value of db->nChange */
  int saved_nTotalChange; /* Saved value of db->nTotalChange */
  u32 saved_openFlags;    /* Saved value of db->openFlags */
  u8 saved_mTrace;        /* Saved trace settings */
  Db *pDb = 0;            /* Database to detach at end of vacuum */
  int isMemDb;            /* True if vacuuming a :memory: database */
  int nRes;               /* Bytes of reserved space at the end of each page */
  int nDb;                /* Number of attached databases */
  const char *zDbMain;    /* Schema name of database to vacuum */
  const char *zOut;       /* Name of output file */
 
  if( !db->autoCommit ){
    sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
    return SQLITE_ERROR; /* IMP: R-12218-18073 */
  }
  if( db->nVdbeActive>1 ){
    sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
    return SQLITE_ERROR; /* IMP: R-15610-35227 */
  }
  saved_openFlags = db->openFlags;
  if( pOut ){
    if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){
      sqlite3SetString(pzErrMsg, db, "non-text filename");
      return SQLITE_ERROR;
    }
    zOut = (const char*)sqlite3_value_text(pOut);
    db->openFlags &= ~SQLITE_OPEN_READONLY;
    db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE;
  }else{
    zOut = "";
  }
 
  /* Save the current value of the database flags so that it can be
  ** restored before returning. Then set the writable-schema flag, and
  ** disable CHECK and foreign key constraints.  */
  saved_flags = db->flags;
  saved_mDbFlags = db->mDbFlags;
  saved_nChange = db->nChange;
  saved_nTotalChange = db->nTotalChange;
  saved_mTrace = db->mTrace;
  db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
  db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum;
  db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder
                   | SQLITE_Defensive | SQLITE_CountRows);
  db->mTrace = 0;
 
  zDbMain = db->aDb[iDb].zDbSName;
  pMain = db->aDb[iDb].pBt;
  isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain));
 
  /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
  ** can be set to 'off' for this file, as it is not recovered if a crash
  ** occurs anyway. The integrity of the database is maintained by a
  ** (possibly synchronous) transaction opened on the main database before
  ** sqlite3BtreeCopyFile() is called.
  **
  ** An optimisation would be to use a non-journaled pager.
  ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but
  ** that actually made the VACUUM run slower.  Very little journalling
  ** actually occurs when doing a vacuum since the vacuum_db is initially
  ** empty.  Only the journal header is written.  Apparently it takes more
  ** time to parse and run the PRAGMA to turn journalling off than it does
  ** to write the journal header file.
  */
  nDb = db->nDb;
  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut);
  db->openFlags = saved_openFlags;
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
  assert( (db->nDb-1)==nDb );
  pDb = &db->aDb[nDb];
  assert( strcmp(pDb->zDbSName,"vacuum_db")==0 );
  pTemp = pDb->pBt;
  if( pOut ){
    sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp));
    i64 sz = 0;
    if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){
      rc = SQLITE_ERROR;
      sqlite3SetString(pzErrMsg, db, "output file already exists");
      goto end_of_vacuum;
    }
    db->mDbFlags |= DBFLAG_VacuumInto;
  }
  nRes = sqlite3BtreeGetRequestedReserve(pMain);
 
  sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
  sqlite3BtreeSetSpillSize(pTemp, sqlite3BtreeSetSpillSize(pMain,0));
  sqlite3BtreeSetPagerFlags(pTemp, PAGER_SYNCHRONOUS_OFF|PAGER_CACHESPILL);
 
  /* Begin a transaction and take an exclusive lock on the main database
  ** file. This is done before the sqlite3BtreeGetPageSize(pMain) call below,
  ** to ensure that we do not try to change the page-size on a WAL database.
  */
  rc = execSql(db, pzErrMsg, "BEGIN");
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
  rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0);
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
 
  /* Do not attempt to change the page size for a WAL database */
  if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain))
                                               ==PAGER_JOURNALMODE_WAL ){
    db->nextPagesize = 0;
  }
 
  if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0)
   || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
   || NEVER(db->mallocFailed)
  ){
    rc = SQLITE_NOMEM_BKPT;
    goto end_of_vacuum;
  }
 
#ifndef SQLITE_OMIT_AUTOVACUUM
  sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
                                           sqlite3BtreeGetAutoVacuum(pMain));
#endif
 
  /* Query the schema of the main database. Create a mirror schema
  ** in the temporary database.
  */
  db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
  rc = execSqlF(db, pzErrMsg,
      "SELECT sql FROM \"%w\".sqlite_schema"
      " WHERE type='table'AND name<>'sqlite_sequence'"
      " AND coalesce(rootpage,1)>0",
      zDbMain
  );
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
  rc = execSqlF(db, pzErrMsg,
      "SELECT sql FROM \"%w\".sqlite_schema"
      " WHERE type='index'",
      zDbMain
  );
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
  db->init.iDb = 0;
 
  /* Loop through the tables in the main database. For each, do
  ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy
  ** the contents to the temporary database.
  */
  rc = execSqlF(db, pzErrMsg,
      "SELECT'INSERT INTO vacuum_db.'||quote(name)"
      "||' SELECT*FROM\"%w\".'||quote(name)"
      "FROM vacuum_db.sqlite_schema "
      "WHERE type='table'AND coalesce(rootpage,1)>0",
      zDbMain
  );
  assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 );
  db->mDbFlags &= ~DBFLAG_Vacuum;
  if( rc!=SQLITE_OK ) goto end_of_vacuum;
 
  /* Copy the triggers, views, and virtual tables from the main database
  ** over to the temporary database.  None of these objects has any
  ** associated storage, so all we have to do is copy their entries
  ** from the schema table.
  */
  rc = execSqlF(db, pzErrMsg,
      "INSERT INTO vacuum_db.sqlite_schema"
      " SELECT*FROM \"%w\".sqlite_schema"
      " WHERE type IN('view','trigger')"
      " OR(type='table'AND rootpage=0)",
      zDbMain
  );
  if( rc ) goto end_of_vacuum;
 
  /* At this point, there is a write transaction open on both the
  ** vacuum database and the main database. Assuming no error occurs,
  ** both transactions are closed by this block - the main database
  ** transaction by sqlite3BtreeCopyFile() and the other by an explicit
  ** call to sqlite3BtreeCommit().
  */
  {
    u32 meta;
    int i;
 
    /* This array determines which meta meta values are preserved in the
    ** vacuum.  Even entries are the meta value number and odd entries
    ** are an increment to apply to the meta value after the vacuum.
    ** The increment is used to increase the schema cookie so that other
    ** connections to the same database will know to reread the schema.
    */
    static const unsigned char aCopy[] = {
       BTREE_SCHEMA_VERSION,     1,  /* Add one to the old schema cookie */
       BTREE_DEFAULT_CACHE_SIZE, 0,  /* Preserve the default page cache size */
       BTREE_TEXT_ENCODING,      0,  /* Preserve the text encoding */
       BTREE_USER_VERSION,       0,  /* Preserve the user version */
       BTREE_APPLICATION_ID,     0,  /* Preserve the application id */
    };
 
    assert( 1==sqlite3BtreeIsInTrans(pTemp) );
    assert( pOut!=0 || 1==sqlite3BtreeIsInTrans(pMain) );
 
    /* Copy Btree meta values */
    for(i=0; i<ArraySize(aCopy); i+=2){
      /* GetMeta() and UpdateMeta() cannot fail in this context because
      ** we already have page 1 loaded into cache and marked dirty. */
      sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
      rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
      if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
    }
 
    if( pOut==0 ){
      rc = sqlite3BtreeCopyFile(pMain, pTemp);
    }
    if( rc!=SQLITE_OK ) goto end_of_vacuum;
    rc = sqlite3BtreeCommit(pTemp);
    if( rc!=SQLITE_OK ) goto end_of_vacuum;
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pOut==0 ){
      sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp));
    }
#endif
  }
 
  assert( rc==SQLITE_OK );
  if( pOut==0 ){
    rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
  }
 
end_of_vacuum:
  /* Restore the original value of db->flags */
  db->init.iDb = 0;
  db->mDbFlags = saved_mDbFlags;
  db->flags = saved_flags;
  db->nChange = saved_nChange;
  db->nTotalChange = saved_nTotalChange;
  db->mTrace = saved_mTrace;
  sqlite3BtreeSetPageSize(pMain, -1, 0, 1);
 
  /* Currently there is an SQL level transaction open on the vacuum
  ** database. No locks are held on any other files (since the main file
  ** was committed at the btree level). So it safe to end the transaction
  ** by manually setting the autoCommit flag to true and detaching the
  ** vacuum database. The vacuum_db journal file is deleted when the pager
  ** is closed by the DETACH.
  */
  db->autoCommit = 1;
 
  if( pDb ){
    sqlite3BtreeClose(pDb->pBt);
    pDb->pBt = 0;
    pDb->pSchema = 0;
  }
 

Referenced by sqlite3VdbeExec().

◆ sqlite3SafetyCheckOk()

SQLITE_PRIVATE int sqlite3SafetyCheckOk ( sqlite3 * db )

Definition at line 32542 of file sqlite3.c.

                                                    {
  u32 magic;
  if( db==0 ){
    logBadConnection("NULL");
    return 0;
  }
  magic = db->magic;
  if( magic!=SQLITE_MAGIC_OPEN ){
    if( sqlite3SafetyCheckSickOrOk(db) ){
      testcase( sqlite3GlobalConfig.xLog!=0 );
      logBadConnection("unopened");

References logBadConnection(), sqlite3::magic, sqlite3GlobalConfig, sqlite3SafetyCheckSickOrOk(), SQLITE_MAGIC_OPEN, and testcase.

Referenced by createFunctionApi(), sqlite3_backup_init(), sqlite3_busy_timeout(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_get_autocommit(), sqlite3_get_table(), sqlite3_limit(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_set_authorizer(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vtab_config(), sqlite3_vtab_on_conflict(), sqlite3_wal_autocheckpoint(), and sqlite3Prepare16().

◆ sqlite3SafetyCheckSickOrOk()

SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk ( sqlite3 * db )

Definition at line 32559 of file sqlite3.c.

       {
    return 1;
  }
}
SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
  u32 magic;
  magic = db->magic;
  if( magic!=SQLITE_MAGIC_SICK &&
      magic!=SQLITE_MAGIC_OPEN &&
      magic!=SQLITE_MAGIC_BUSY ){
    testcase( sqlite3GlobalConfig.xLog!=0 );

Referenced by sqlite3_errcode(), sqlite3_errmsg16(), and sqlite3SafetyCheckOk().

◆ sqlite3Savepoint()

SQLITE_PRIVATE void sqlite3Savepoint	(	Parse *	pParse,
		int	op,
		Token *	pName )

Definition at line 115071 of file sqlite3.c.

                                                                         {
  char *zName = sqlite3NameFromToken(pParse->db, pName);
  if( zName ){
    Vdbe *v = sqlite3GetVdbe(pParse);
#ifndef SQLITE_OMIT_AUTHORIZATION
    static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
    assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
#endif
    if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){

Referenced by yy_reduce().

◆ sqlite3SchemaClear()

SQLITE_PRIVATE void sqlite3SchemaClear ( void * p )

Definition at line 116023 of file sqlite3.c.

                                               {
  Hash temp1;
  Hash temp2;
  HashElem *pElem;
  Schema *pSchema = (Schema *)p;
 
  temp1 = pSchema->tblHash;
  temp2 = pSchema->trigHash;
  sqlite3HashInit(&pSchema->trigHash);
  sqlite3HashClear(&pSchema->idxHash);
  for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
    sqlite3DeleteTrigger(0, (Trigger*)sqliteHashData(pElem));
  }
  sqlite3HashClear(&temp2);
  sqlite3HashInit(&pSchema->tblHash);
  for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
    Table *pTab = sqliteHashData(pElem);
    sqlite3DeleteTable(0, pTab);
  }
  sqlite3HashClear(&temp1);
  sqlite3HashClear(&pSchema->fkeyHash);

References DB_ResetWanted, DB_SchemaLoaded, Schema::fkeyHash, Schema::idxHash, Schema::iGeneration, Schema::pSeqTab, Schema::schemaFlags, sqlite3DeleteTable(), sqlite3DeleteTrigger(), sqlite3HashClear(), sqlite3HashInit(), sqliteHashData, sqliteHashFirst, sqliteHashNext, Schema::tblHash, and Schema::trigHash.

Referenced by sqlite3LeaveMutexAndCloseZombie(), sqlite3ResetOneSchema(), and sqlite3VdbeExec().

◆ sqlite3SchemaGet()

SQLITE_PRIVATE Schema * sqlite3SchemaGet	(	sqlite3 *	db,
		Btree *	pBt )

Definition at line 116055 of file sqlite3.c.

                                                                {
  Schema * p;
  if( pBt ){
    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
  }else{
    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
  }
  if( !p ){
    sqlite3OomFault(db);
  }else if ( 0==p->file_format ){
    sqlite3HashInit(&p->tblHash);
    sqlite3HashInit(&p->idxHash);

Referenced by attachFunc(), and openDatabase().

◆ sqlite3SchemaToIndex()

SQLITE_PRIVATE int sqlite3SchemaToIndex	(	sqlite3 *	db,
		Schema *	pSchema )

Definition at line 128852 of file sqlite3.c.

                                                                     {
  int i = -32768;
 
  /* If pSchema is NULL, then return -32768. This happens when code in
  ** expr.c is trying to resolve a reference to a transient table (i.e. one
  ** created by a sub-select). In this case the return value of this
  ** function should never be used.
  **
  ** We return -32768 instead of the more usual -1 simply because using
  ** -32768 as the incorrect index into db->aDb[] is much
  ** more likely to cause a segfault than -1 (of course there are assert()
  ** statements too, but it never hurts to play the odds) and
  ** -32768 will still fit into a 16-bit signed integer.
  */
  assert( sqlite3_mutex_held(db->mutex) );
  if( pSchema ){
    for(i=0; 1; i++){
      assert( i<db->nDb );
      if( db->aDb[i].pSchema==pSchema ){
        break;

References sqlite3::aDb, sqlite3::mutex, Db::pSchema, and sqlite3_mutex_held().

Referenced by analyzeOneTable(), analyzeTable(), columnTypeImpl(), destroyTable(), generateSortTail(), reindexTable(), renameResolveTrigger(), renameTableTest(), selectExpander(), sqlite3AlterBeginAddColumn(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3AuthRead(), sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3FindInIndex(), sqlite3FkCheck(), sqlite3Insert(), sqlite3LocateTableItem(), sqlite3MaterializeView(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), sqlite3VtabBeginParse(), sqlite3WhereBegin(), vtabCallConstructor(), and xferOptimization().

◆ sqlite3SectorSize()

SQLITE_PRIVATE int sqlite3SectorSize ( sqlite3_file * pFile )

Definition at line 54333 of file sqlite3.c.

                                                         {
  int iRet = sqlite3OsSectorSize(pFile);
  if( iRet<32 ){
    iRet = 512;

Referenced by setSectorSize().

◆ sqlite3Select()

SQLITE_PRIVATE int sqlite3Select	(	Parse *	pParse,
		Select *	p,
		SelectDest *	pDest )

Definition at line 135064 of file sqlite3.c.

 {
  int i, j;              /* Loop counters */
  WhereInfo *pWInfo;     /* Return from sqlite3WhereBegin() */
  Vdbe *v;               /* The virtual machine under construction */
  int isAgg;             /* True for select lists like "count(*)" */
  ExprList *pEList = 0;  /* List of columns to extract. */
  SrcList *pTabList;     /* List of tables to select from */
  Expr *pWhere;          /* The WHERE clause.  May be NULL */
  ExprList *pGroupBy;    /* The GROUP BY clause.  May be NULL */
  Expr *pHaving;         /* The HAVING clause.  May be NULL */
  AggInfo *pAggInfo = 0; /* Aggregate information */
  int rc = 1;            /* Value to return from this function */
  DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */
  SortCtx sSort;         /* Info on how to code the ORDER BY clause */
  int iEnd;              /* Address of the end of the query */
  sqlite3 *db;           /* The database connection */
  ExprList *pMinMaxOrderBy = 0;  /* Added ORDER BY for min/max queries */
  u8 minMaxFlag;                 /* Flag for min/max queries */
 
  db = pParse->db;
  v = sqlite3GetVdbe(pParse);
  if( p==0 || db->mallocFailed || pParse->nErr ){
    return 1;
  }
  if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
#if SELECTTRACE_ENABLED
  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
  if( sqlite3_unsupported_selecttrace & 0x100 ){
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
 
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
  if( IgnorableOrderby(pDest) ){
    assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
           pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard ||
           pDest->eDest==SRT_Queue  || pDest->eDest==SRT_DistFifo ||
           pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_Fifo);
    /* If ORDER BY makes no difference in the output then neither does
    ** DISTINCT so it can be removed too. */
    sqlite3ExprListDelete(db, p->pOrderBy);
    p->pOrderBy = 0;
    p->selFlags &= ~SF_Distinct;
    p->selFlags |= SF_NoopOrderBy;
  }
  sqlite3SelectPrep(pParse, p, 0);
  if( pParse->nErr || db->mallocFailed ){
    goto select_end;
  }
  assert( p->pEList!=0 );
#if SELECTTRACE_ENABLED
  if( sqlite3_unsupported_selecttrace & 0x104 ){
    SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
 
  /* If the SF_UpdateFrom flag is set, then this function is being called
  ** as part of populating the temp table for an UPDATE...FROM statement.
  ** In this case, it is an error if the target object (pSrc->a[0]) name
  ** or alias is duplicated within FROM clause (pSrc->a[1..n]).  */
  if( p->selFlags & SF_UpdateFrom ){
    struct SrcList_item *p0 = &p->pSrc->a[0];
    for(i=1; i<p->pSrc->nSrc; i++){
      struct SrcList_item *p1 = &p->pSrc->a[i];
      if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
        sqlite3ErrorMsg(pParse,
            "target object/alias may not appear in FROM clause: %s",
            p0->zAlias ? p0->zAlias : p0->pTab->zName
        );
        goto select_end;
      }
    }
  }
 
  if( pDest->eDest==SRT_Output ){
    generateColumnNames(pParse, p);
  }
 
#ifndef SQLITE_OMIT_WINDOWFUNC
  rc = sqlite3WindowRewrite(pParse, p);
  if( rc ){
    assert( db->mallocFailed || pParse->nErr>0 );
    goto select_end;
  }
#if SELECTTRACE_ENABLED
  if( p->pWin && (sqlite3_unsupported_selecttrace & 0x108)!=0 ){
    SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
#endif /* SQLITE_OMIT_WINDOWFUNC */
  pTabList = p->pSrc;
  isAgg = (p->selFlags & SF_Aggregate)!=0;
  memset(&sSort, 0, sizeof(sSort));
  sSort.pOrderBy = p->pOrderBy;
 
  /* Try to do various optimizations (flattening subqueries, and strength
  ** reduction of join operators) in the FROM clause up into the main query
  */
#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
  for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
    struct SrcList_item *pItem = &pTabList->a[i];
    Select *pSub = pItem->pSelect;
    Table *pTab = pItem->pTab;
 
    /* The expander should have already created transient Table objects
    ** even for FROM clause elements such as subqueries that do not correspond
    ** to a real table */
    assert( pTab!=0 );
 
    /* Convert LEFT JOIN into JOIN if there are terms of the right table
    ** of the LEFT JOIN used in the WHERE clause.
    */
    if( (pItem->fg.jointype & JT_LEFT)!=0
     && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)
     && OptimizationEnabled(db, SQLITE_SimplifyJoin)
    ){
      SELECTTRACE(0x100,pParse,p,
                ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
      pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
      unsetJoinExpr(p->pWhere, pItem->iCursor);
    }
 
    /* No futher action if this term of the FROM clause is no a subquery */
    if( pSub==0 ) continue;
 
    /* Catch mismatch in the declared columns of a view and the number of
    ** columns in the SELECT on the RHS */
    if( pTab->nCol!=pSub->pEList->nExpr ){
      sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
                      pTab->nCol, pTab->zName, pSub->pEList->nExpr);
      goto select_end;
    }
 
    /* Do not try to flatten an aggregate subquery.
    **
    ** Flattening an aggregate subquery is only possible if the outer query
    ** is not a join.  But if the outer query is not a join, then the subquery
    ** will be implemented as a co-routine and there is no advantage to
    ** flattening in that case.
    */
    if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
    assert( pSub->pGroupBy==0 );
 
    /* If the outer query contains a "complex" result set (that is,
    ** if the result set of the outer query uses functions or subqueries)
    ** and if the subquery contains an ORDER BY clause and if
    ** it will be implemented as a co-routine, then do not flatten.  This
    ** restriction allows SQL constructs like this:
    **
    **  SELECT expensive_function(x)
    **    FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
    **
    ** The expensive_function() is only computed on the 10 rows that
    ** are output, rather than every row of the table.
    **
    ** The requirement that the outer query have a complex result set
    ** means that flattening does occur on simpler SQL constraints without
    ** the expensive_function() like:
    **
    **  SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
    */
    if( pSub->pOrderBy!=0
     && i==0
     && (p->selFlags & SF_ComplexResult)!=0
     && (pTabList->nSrc==1
         || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)
    ){
      continue;
    }
 
    if( flattenSubquery(pParse, p, i, isAgg) ){
      if( pParse->nErr ) goto select_end;
      /* This subquery can be absorbed into its parent. */
      i = -1;
    }
    pTabList = p->pSrc;
    if( db->mallocFailed ) goto select_end;
    if( !IgnorableOrderby(pDest) ){
      sSort.pOrderBy = p->pOrderBy;
    }
  }
#endif
 
#ifndef SQLITE_OMIT_COMPOUND_SELECT
  /* Handle compound SELECT statements using the separate multiSelect()
  ** procedure.
  */
  if( p->pPrior ){
    rc = multiSelect(pParse, p, pDest);
#if SELECTTRACE_ENABLED
    SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
    if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
    if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
    return rc;
  }
#endif
 
  /* Do the WHERE-clause constant propagation optimization if this is
  ** a join.  No need to speed time on this operation for non-join queries
  ** as the equivalent optimization will be handled by query planner in
  ** sqlite3WhereBegin().
  */
  if( pTabList->nSrc>1
   && OptimizationEnabled(db, SQLITE_PropagateConst)
   && propagateConstants(pParse, p)
  ){
#if SELECTTRACE_ENABLED
    if( sqlite3_unsupported_selecttrace & 0x100 ){
      SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
  }else{
    SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
  }
 
#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
  if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
   && countOfViewOptimization(pParse, p)
  ){
    if( db->mallocFailed ) goto select_end;
    pEList = p->pEList;
    pTabList = p->pSrc;
  }
#endif
 
  /* For each term in the FROM clause, do two things:
  ** (1) Authorized unreferenced tables
  ** (2) Generate code for all sub-queries
  */
  for(i=0; i<pTabList->nSrc; i++){
    struct SrcList_item *pItem = &pTabList->a[i];
    SelectDest dest;
    Select *pSub;
#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
    const char *zSavedAuthContext;
#endif
 
    /* Issue SQLITE_READ authorizations with a fake column name for any
    ** tables that are referenced but from which no values are extracted.
    ** Examples of where these kinds of null SQLITE_READ authorizations
    ** would occur:
    **
    **     SELECT count(*) FROM t1;   -- SQLITE_READ t1.""
    **     SELECT t1.* FROM t1, t2;   -- SQLITE_READ t2.""
    **
    ** The fake column name is an empty string.  It is possible for a table to
    ** have a column named by the empty string, in which case there is no way to
    ** distinguish between an unreferenced table and an actual reference to the
    ** "" column. The original design was for the fake column name to be a NULL,
    ** which would be unambiguous.  But legacy authorization callbacks might
    ** assume the column name is non-NULL and segfault.  The use of an empty
    ** string for the fake column name seems safer.
    */
    if( pItem->colUsed==0 && pItem->zName!=0 ){
      sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
    }
 
#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
    /* Generate code for all sub-queries in the FROM clause
    */
    pSub = pItem->pSelect;
    if( pSub==0 ) continue;
 
    /* The code for a subquery should only be generated once, though it is
    ** technically harmless for it to be generated multiple times. The
    ** following assert() will detect if something changes to cause
    ** the same subquery to be coded multiple times, as a signal to the
    ** developers to try to optimize the situation.
    **
    ** Update 2019-07-24:
    ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
    ** The dbsqlfuzz fuzzer found a case where the same subquery gets
    ** coded twice.  So this assert() now becomes a testcase().  It should
    ** be very rare, though.
    */
    testcase( pItem->addrFillSub!=0 );
 
    /* Increment Parse.nHeight by the height of the largest expression
    ** tree referred to by this, the parent select. The child select
    ** may contain expression trees of at most
    ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
    ** more conservative than necessary, but much easier than enforcing
    ** an exact limit.
    */
    pParse->nHeight += sqlite3SelectExprHeight(p);
 
    /* Make copies of constant WHERE-clause terms in the outer query down
    ** inside the subquery.  This can help the subquery to run more efficiently.
    */
    if( OptimizationEnabled(db, SQLITE_PushDown)
     && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
                           (pItem->fg.jointype & JT_OUTER)!=0)
    ){
#if SELECTTRACE_ENABLED
      if( sqlite3_unsupported_selecttrace & 0x100 ){
        SELECTTRACE(0x100,pParse,p,
            ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
        sqlite3TreeViewSelect(0, p, 0);
      }
#endif
    }else{
      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
    }
 
    zSavedAuthContext = pParse->zAuthContext;
    pParse->zAuthContext = pItem->zName;
 
    /* Generate code to implement the subquery
    **
    ** The subquery is implemented as a co-routine if the subquery is
    ** guaranteed to be the outer loop (so that it does not need to be
    ** computed more than once)
    **
    ** TODO: Are there other reasons beside (1) to use a co-routine
    ** implementation?
    */
    if( i==0
     && (pTabList->nSrc==1
            || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)  /* (1) */
    ){
      /* Implement a co-routine that will return a single row of the result
      ** set on each invocation.
      */
      int addrTop = sqlite3VdbeCurrentAddr(v)+1;
 
      pItem->regReturn = ++pParse->nMem;
      sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
      VdbeComment((v, "%s", pItem->pTab->zName));
      pItem->addrFillSub = addrTop;
      sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
      ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId));
      sqlite3Select(pParse, pSub, &dest);
      pItem->pTab->nRowLogEst = pSub->nSelectRow;
      pItem->fg.viaCoroutine = 1;
      pItem->regResult = dest.iSdst;
      sqlite3VdbeEndCoroutine(v, pItem->regReturn);
      sqlite3VdbeJumpHere(v, addrTop-1);
      sqlite3ClearTempRegCache(pParse);
    }else{
      /* Generate a subroutine that will fill an ephemeral table with
      ** the content of this subquery.  pItem->addrFillSub will point
      ** to the address of the generated subroutine.  pItem->regReturn
      ** is a register allocated to hold the subroutine return address
      */
      int topAddr;
      int onceAddr = 0;
      int retAddr;
      struct SrcList_item *pPrior;
 
      testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
      pItem->regReturn = ++pParse->nMem;
      topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
      pItem->addrFillSub = topAddr+1;
      if( pItem->fg.isCorrelated==0 ){
        /* If the subquery is not correlated and if we are not inside of
        ** a trigger, then we only need to compute the value of the subquery
        ** once. */
        onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
        VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
      }else{
        VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
      }
      pPrior = isSelfJoinView(pTabList, pItem);
      if( pPrior ){
        sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
        assert( pPrior->pSelect!=0 );
        pSub->nSelectRow = pPrior->pSelect->nSelectRow;
      }else{
        sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
        ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId));
        sqlite3Select(pParse, pSub, &dest);
      }
      pItem->pTab->nRowLogEst = pSub->nSelectRow;
      if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
      retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
      VdbeComment((v, "end %s", pItem->pTab->zName));
      sqlite3VdbeChangeP1(v, topAddr, retAddr);
      sqlite3ClearTempRegCache(pParse);
    }
    if( db->mallocFailed ) goto select_end;
    pParse->nHeight -= sqlite3SelectExprHeight(p);
    pParse->zAuthContext = zSavedAuthContext;
#endif
  }
 
  /* Various elements of the SELECT copied into local variables for
  ** convenience */
  pEList = p->pEList;
  pWhere = p->pWhere;
  pGroupBy = p->pGroupBy;
  pHaving = p->pHaving;
  sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
 
#if SELECTTRACE_ENABLED
  if( sqlite3_unsupported_selecttrace & 0x400 ){
    SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
 
  /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
  ** if the select-list is the same as the ORDER BY list, then this query
  ** can be rewritten as a GROUP BY. In other words, this:
  **
  **     SELECT DISTINCT xyz FROM ... ORDER BY xyz
  **
  ** is transformed to:
  **
  **     SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
  **
  ** The second form is preferred as a single index (or temp-table) may be
  ** used for both the ORDER BY and DISTINCT processing. As originally
  ** written the query must use a temp-table for at least one of the ORDER
  ** BY and DISTINCT, and an index or separate temp-table for the other.
  */
  if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
   && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
#ifndef SQLITE_OMIT_WINDOWFUNC
   && p->pWin==0
#endif
  ){
    p->selFlags &= ~SF_Distinct;
    pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
    p->selFlags |= SF_Aggregate;
    /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
    ** the sDistinct.isTnct is still set.  Hence, isTnct represents the
    ** original setting of the SF_Distinct flag, not the current setting */
    assert( sDistinct.isTnct );
 
#if SELECTTRACE_ENABLED
    if( sqlite3_unsupported_selecttrace & 0x400 ){
      SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
  }
 
  /* If there is an ORDER BY clause, then create an ephemeral index to
  ** do the sorting.  But this sorting ephemeral index might end up
  ** being unused if the data can be extracted in pre-sorted order.
  ** If that is the case, then the OP_OpenEphemeral instruction will be
  ** changed to an OP_Noop once we figure out that the sorting index is
  ** not needed.  The sSort.addrSortIndex variable is used to facilitate
  ** that change.
  */
  if( sSort.pOrderBy ){
    KeyInfo *pKeyInfo;
    pKeyInfo = sqlite3KeyInfoFromExprList(
        pParse, sSort.pOrderBy, 0, pEList->nExpr);
    sSort.iECursor = pParse->nTab++;
    sSort.addrSortIndex =
      sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
          sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0,
          (char*)pKeyInfo, P4_KEYINFO
      );
  }else{
    sSort.addrSortIndex = -1;
  }
 
  /* If the output is destined for a temporary table, open that table.
  */
  if( pDest->eDest==SRT_EphemTab ){
    sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
  }
 
  /* Set the limiter.
  */
  iEnd = sqlite3VdbeMakeLabel(pParse);
  if( (p->selFlags & SF_FixedLimit)==0 ){
    p->nSelectRow = 320;  /* 4 billion rows */
  }
  computeLimitRegisters(pParse, p, iEnd);
  if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
    sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
    sSort.sortFlags |= SORTFLAG_UseSorter;
  }
 
  /* Open an ephemeral index to use for the distinct set.
  */
  if( p->selFlags & SF_Distinct ){
    sDistinct.tabTnct = pParse->nTab++;
    sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
                       sDistinct.tabTnct, 0, 0,
                       (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
                       P4_KEYINFO);
    sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
    sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
  }else{
    sDistinct.eTnctType = WHERE_DISTINCT_NOOP;
  }
 
  if( !isAgg && pGroupBy==0 ){
    /* No aggregate functions and no GROUP BY clause */
    u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
                   | (p->selFlags & SF_FixedLimit);
#ifndef SQLITE_OMIT_WINDOWFUNC
    Window *pWin = p->pWin;      /* Main window object (or NULL) */
    if( pWin ){
      sqlite3WindowCodeInit(pParse, p);
    }
#endif
    assert( WHERE_USE_LIMIT==SF_FixedLimit );
 
 
    /* Begin the database scan. */
    SELECTTRACE(1,pParse,p,("WhereBegin\n"));
    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
                               p->pEList, wctrlFlags, p->nSelectRow);
    if( pWInfo==0 ) goto select_end;
    if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
      p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
    }
    if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){
      sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo);
    }
    if( sSort.pOrderBy ){
      sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
      sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
      if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
        sSort.pOrderBy = 0;
      }
    }
 
    /* If sorting index that was created by a prior OP_OpenEphemeral
    ** instruction ended up not being needed, then change the OP_OpenEphemeral
    ** into an OP_Noop.
    */
    if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){
      sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
    }
 
    assert( p->pEList==pEList );
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( pWin ){
      int addrGosub = sqlite3VdbeMakeLabel(pParse);
      int iCont = sqlite3VdbeMakeLabel(pParse);
      int iBreak = sqlite3VdbeMakeLabel(pParse);
      int regGosub = ++pParse->nMem;
 
      sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
 
      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
      sqlite3VdbeResolveLabel(v, addrGosub);
      VdbeNoopComment((v, "inner-loop subroutine"));
      sSort.labelOBLopt = 0;
      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
      sqlite3VdbeResolveLabel(v, iCont);
      sqlite3VdbeAddOp1(v, OP_Return, regGosub);
      VdbeComment((v, "end inner-loop subroutine"));
      sqlite3VdbeResolveLabel(v, iBreak);
    }else
#endif /* SQLITE_OMIT_WINDOWFUNC */
    {
      /* Use the standard inner loop. */
      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
          sqlite3WhereContinueLabel(pWInfo),
          sqlite3WhereBreakLabel(pWInfo));
 
      /* End the database scan loop.
      */
      sqlite3WhereEnd(pWInfo);
    }
  }else{
    /* This case when there exist aggregate functions or a GROUP BY clause
    ** or both */
    NameContext sNC;    /* Name context for processing aggregate information */
    int iAMem;          /* First Mem address for storing current GROUP BY */
    int iBMem;          /* First Mem address for previous GROUP BY */
    int iUseFlag;       /* Mem address holding flag indicating that at least
                        ** one row of the input to the aggregator has been
                        ** processed */
    int iAbortFlag;     /* Mem address which causes query abort if positive */
    int groupBySort;    /* Rows come from source in GROUP BY order */
    int addrEnd;        /* End of processing for this SELECT */
    int sortPTab = 0;   /* Pseudotable used to decode sorting results */
    int sortOut = 0;    /* Output register from the sorter */
    int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */
 
    /* Remove any and all aliases between the result set and the
    ** GROUP BY clause.
    */
    if( pGroupBy ){
      int k;                        /* Loop counter */
      struct ExprList_item *pItem;  /* For looping over expression in a list */
 
      for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
        pItem->u.x.iAlias = 0;
      }
      for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
        pItem->u.x.iAlias = 0;
      }
      assert( 66==sqlite3LogEst(100) );
      if( p->nSelectRow>66 ) p->nSelectRow = 66;
 
      /* If there is both a GROUP BY and an ORDER BY clause and they are
      ** identical, then it may be possible to disable the ORDER BY clause
      ** on the grounds that the GROUP BY will cause elements to come out
      ** in the correct order. It also may not - the GROUP BY might use a
      ** database index that causes rows to be grouped together as required
      ** but not actually sorted. Either way, record the fact that the
      ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
      ** variable.  */
      if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){
        int ii;
        /* The GROUP BY processing doesn't care whether rows are delivered in
        ** ASC or DESC order - only that each group is returned contiguously.
        ** So set the ASC/DESC flags in the GROUP BY to match those in the
        ** ORDER BY to maximize the chances of rows being delivered in an
        ** order that makes the ORDER BY redundant.  */
        for(ii=0; ii<pGroupBy->nExpr; ii++){
          u8 sortFlags = sSort.pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_DESC;
          pGroupBy->a[ii].sortFlags = sortFlags;
        }
        if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){
          orderByGrp = 1;
        }
      }
    }else{
      assert( 0==sqlite3LogEst(1) );
      p->nSelectRow = 0;
    }
 
    /* Create a label to jump to when we want to abort the query */
    addrEnd = sqlite3VdbeMakeLabel(pParse);
 
    /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
    ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
    ** SELECT statement.
    */
    pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) );
    if( pAggInfo==0 ){
      goto select_end;
    }
    pAggInfo->pNext = pParse->pAggList;
    pParse->pAggList = pAggInfo;
    pAggInfo->selId = p->selId;
    memset(&sNC, 0, sizeof(sNC));
    sNC.pParse = pParse;
    sNC.pSrcList = pTabList;
    sNC.uNC.pAggInfo = pAggInfo;
    VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
    pAggInfo->mnReg = pParse->nMem+1;
    pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
    pAggInfo->pGroupBy = pGroupBy;
    sqlite3ExprAnalyzeAggList(&sNC, pEList);
    sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy);
    if( pHaving ){
      if( pGroupBy ){
        assert( pWhere==p->pWhere );
        assert( pHaving==p->pHaving );
        assert( pGroupBy==p->pGroupBy );
        havingToWhere(pParse, p);
        pWhere = p->pWhere;
      }
      sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
    }
    pAggInfo->nAccumulator = pAggInfo->nColumn;
    if( p->pGroupBy==0 && p->pHaving==0 && pAggInfo->nFunc==1 ){
      minMaxFlag = minMaxQuery(db, pAggInfo->aFunc[0].pFExpr, &pMinMaxOrderBy);
    }else{
      minMaxFlag = WHERE_ORDERBY_NORMAL;
    }
    for(i=0; i<pAggInfo->nFunc; i++){
      Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      sNC.ncFlags |= NC_InAggFunc;
      sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
#ifndef SQLITE_OMIT_WINDOWFUNC
      assert( !IsWindowFunc(pExpr) );
      if( ExprHasProperty(pExpr, EP_WinFunc) ){
        sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);
      }
#endif
      sNC.ncFlags &= ~NC_InAggFunc;
    }
    pAggInfo->mxReg = pParse->nMem;
    if( db->mallocFailed ) goto select_end;
#if SELECTTRACE_ENABLED
    if( sqlite3_unsupported_selecttrace & 0x400 ){
      int ii;
      SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo));
      sqlite3TreeViewSelect(0, p, 0);
      for(ii=0; ii<pAggInfo->nColumn; ii++){
        sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
            ii, pAggInfo->aCol[ii].iMem);
        sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);
      }
      for(ii=0; ii<pAggInfo->nFunc; ii++){
        sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
            ii, pAggInfo->aFunc[ii].iMem);
        sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0);
      }
    }
#endif
 
 
    /* Processing for aggregates with GROUP BY is very different and
    ** much more complex than aggregates without a GROUP BY.
    */
    if( pGroupBy ){
      KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
      int addr1;          /* A-vs-B comparision jump */
      int addrOutputRow;  /* Start of subroutine that outputs a result row */
      int regOutputRow;   /* Return address register for output subroutine */
      int addrSetAbort;   /* Set the abort flag and return */
      int addrTopOfLoop;  /* Top of the input loop */
      int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
      int addrReset;      /* Subroutine for resetting the accumulator */
      int regReset;       /* Return address register for reset subroutine */
 
      /* If there is a GROUP BY clause we might need a sorting index to
      ** implement it.  Allocate that sorting index now.  If it turns out
      ** that we do not need it after all, the OP_SorterOpen instruction
      ** will be converted into a Noop.
      */
      pAggInfo->sortingIdx = pParse->nTab++;
      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy,
                                            0, pAggInfo->nColumn);
      addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
          pAggInfo->sortingIdx, pAggInfo->nSortingColumn,
          0, (char*)pKeyInfo, P4_KEYINFO);
 
      /* Initialize memory locations used by GROUP BY aggregate processing
      */
      iUseFlag = ++pParse->nMem;
      iAbortFlag = ++pParse->nMem;
      regOutputRow = ++pParse->nMem;
      addrOutputRow = sqlite3VdbeMakeLabel(pParse);
      regReset = ++pParse->nMem;
      addrReset = sqlite3VdbeMakeLabel(pParse);
      iAMem = pParse->nMem + 1;
      pParse->nMem += pGroupBy->nExpr;
      iBMem = pParse->nMem + 1;
      pParse->nMem += pGroupBy->nExpr;
      sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
      VdbeComment((v, "clear abort flag"));
      sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
 
      /* Begin a loop that will extract all source rows in GROUP BY order.
      ** This might involve two separate loops with an OP_Sort in between, or
      ** it might be a single loop that uses an index to extract information
      ** in the right order to begin with.
      */
      sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
      SELECTTRACE(1,pParse,p,("WhereBegin\n"));
      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
          WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
      );
      if( pWInfo==0 ) goto select_end;
      if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
        /* The optimizer is able to deliver rows in group by order so
        ** we do not have to sort.  The OP_OpenEphemeral table will be
        ** cancelled later because we still need to use the pKeyInfo
        */
        groupBySort = 0;
      }else{
        /* Rows are coming out in undetermined order.  We have to push
        ** each row into a sorting index, terminate the first loop,
        ** then loop over the sorting index in order to get the output
        ** in sorted order
        */
        int regBase;
        int regRecord;
        int nCol;
        int nGroupBy;
 
        explainTempTable(pParse,
            (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
                    "DISTINCT" : "GROUP BY");
 
        groupBySort = 1;
        nGroupBy = pGroupBy->nExpr;
        nCol = nGroupBy;
        j = nGroupBy;
        for(i=0; i<pAggInfo->nColumn; i++){
          if( pAggInfo->aCol[i].iSorterColumn>=j ){
            nCol++;
            j++;
          }
        }
        regBase = sqlite3GetTempRange(pParse, nCol);
        sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0);
        j = nGroupBy;
        for(i=0; i<pAggInfo->nColumn; i++){
          struct AggInfo_col *pCol = &pAggInfo->aCol[i];
          if( pCol->iSorterColumn>=j ){
            int r1 = j + regBase;
            sqlite3ExprCodeGetColumnOfTable(v,
                               pCol->pTab, pCol->iTable, pCol->iColumn, r1);
            j++;
          }
        }
        regRecord = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
        sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
        sqlite3ReleaseTempReg(pParse, regRecord);
        sqlite3ReleaseTempRange(pParse, regBase, nCol);
        sqlite3WhereEnd(pWInfo);
        pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
        sortOut = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
        sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
        VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
        pAggInfo->useSortingIdx = 1;
      }
 
      /* If the index or temporary table used by the GROUP BY sort
      ** will naturally deliver rows in the order required by the ORDER BY
      ** clause, cancel the ephemeral table open coded earlier.
      **
      ** This is an optimization - the correct answer should result regardless.
      ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
      ** disable this optimization for testing purposes.  */
      if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder)
       && (groupBySort || sqlite3WhereIsSorted(pWInfo))
      ){
        sSort.pOrderBy = 0;
        sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
      }
 
      /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
      ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
      ** Then compare the current GROUP BY terms against the GROUP BY terms
      ** from the previous row currently stored in a0, a1, a2...
      */
      addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
      if( groupBySort ){
        sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx,
                          sortOut, sortPTab);
      }
      for(j=0; j<pGroupBy->nExpr; j++){
        if( groupBySort ){
          sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
        }else{
          pAggInfo->directMode = 1;
          sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
        }
      }
      sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
                          (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
      addr1 = sqlite3VdbeCurrentAddr(v);
      sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
 
      /* Generate code that runs whenever the GROUP BY changes.
      ** Changes in the GROUP BY are detected by the previous code
      ** block.  If there were no changes, this block is skipped.
      **
      ** This code copies current group by terms in b0,b1,b2,...
      ** over to a0,a1,a2.  It then calls the output subroutine
      ** and resets the aggregate accumulator registers in preparation
      ** for the next GROUP BY batch.
      */
      sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
      sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
      VdbeComment((v, "output one row"));
      sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
      VdbeComment((v, "check abort flag"));
      sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
      VdbeComment((v, "reset accumulator"));
 
      /* Update the aggregate accumulators based on the content of
      ** the current row
      */
      sqlite3VdbeJumpHere(v, addr1);
      updateAccumulator(pParse, iUseFlag, pAggInfo);
      sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
      VdbeComment((v, "indicate data in accumulator"));
 
      /* End of the loop
      */
      if( groupBySort ){
        sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx, addrTopOfLoop);
        VdbeCoverage(v);
      }else{
        sqlite3WhereEnd(pWInfo);
        sqlite3VdbeChangeToNoop(v, addrSortingIdx);
      }
 
      /* Output the final row of result
      */
      sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
      VdbeComment((v, "output final row"));
 
      /* Jump over the subroutines
      */
      sqlite3VdbeGoto(v, addrEnd);
 
      /* Generate a subroutine that outputs a single row of the result
      ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
      ** is less than or equal to zero, the subroutine is a no-op.  If
      ** the processing calls for the query to abort, this subroutine
      ** increments the iAbortFlag memory location before returning in
      ** order to signal the caller to abort.
      */
      addrSetAbort = sqlite3VdbeCurrentAddr(v);
      sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
      VdbeComment((v, "set abort flag"));
      sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
      sqlite3VdbeResolveLabel(v, addrOutputRow);
      addrOutputRow = sqlite3VdbeCurrentAddr(v);
      sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
      VdbeCoverage(v);
      VdbeComment((v, "Groupby result generator entry point"));
      sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
      finalizeAggFunctions(pParse, pAggInfo);
      sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
      selectInnerLoop(pParse, p, -1, &sSort,
                      &sDistinct, pDest,
                      addrOutputRow+1, addrSetAbort);
      sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
      VdbeComment((v, "end groupby result generator"));
 
      /* Generate a subroutine that will reset the group-by accumulator
      */
      sqlite3VdbeResolveLabel(v, addrReset);
      resetAccumulator(pParse, pAggInfo);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
      VdbeComment((v, "indicate accumulator empty"));
      sqlite3VdbeAddOp1(v, OP_Return, regReset);
 
    } /* endif pGroupBy.  Begin aggregate queries without GROUP BY: */
    else {
      Table *pTab;
      if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
        /* If isSimpleCount() returns a pointer to a Table structure, then
        ** the SQL statement is of the form:
        **
        **   SELECT count(*) FROM <tbl>
        **
        ** where the Table structure returned represents table <tbl>.
        **
        ** This statement is so common that it is optimized specially. The
        ** OP_Count instruction is executed either on the intkey table that
        ** contains the data for table <tbl> or on one of its indexes. It
        ** is better to execute the op on an index, as indexes are almost
        ** always spread across less pages than their corresponding tables.
        */
        const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
        const int iCsr = pParse->nTab++;     /* Cursor to scan b-tree */
        Index *pIdx;                         /* Iterator variable */
        KeyInfo *pKeyInfo = 0;               /* Keyinfo for scanned index */
        Index *pBest = 0;                    /* Best index found so far */
        Pgno iRoot = pTab->tnum;             /* Root page of scanned b-tree */
 
        sqlite3CodeVerifySchema(pParse, iDb);
        sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
 
        /* Search for the index that has the lowest scan cost.
        **
        ** (2011-04-15) Do not do a full scan of an unordered index.
        **
        ** (2013-10-03) Do not count the entries in a partial index.
        **
        ** In practice the KeyInfo structure will not be used. It is only
        ** passed to keep OP_OpenRead happy.
        */
        if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
        if( !p->pSrc->a[0].fg.notIndexed ){
          for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
            if( pIdx->bUnordered==0
             && pIdx->szIdxRow<pTab->szTabRow
             && pIdx->pPartIdxWhere==0
             && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
            ){
              pBest = pIdx;
            }
          }
        }
        if( pBest ){
          iRoot = pBest->tnum;
          pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
        }
 
        /* Open a read-only cursor, execute the OP_Count, close the cursor. */
        sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
        if( pKeyInfo ){
          sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
        }
        sqlite3VdbeAddOp2(v, OP_Count, iCsr, pAggInfo->aFunc[0].iMem);
        sqlite3VdbeAddOp1(v, OP_Close, iCsr);
        explainSimpleCount(pParse, pTab, pBest);
      }else{
        int regAcc = 0;           /* "populate accumulators" flag */
        int addrSkip;
 
        /* If there are accumulator registers but no min() or max() functions
        ** without FILTER clauses, allocate register regAcc. Register regAcc
        ** will contain 0 the first time the inner loop runs, and 1 thereafter.
        ** The code generated by updateAccumulator() uses this to ensure
        ** that the accumulator registers are (a) updated only once if
        ** there are no min() or max functions or (b) always updated for the
        ** first row visited by the aggregate, so that they are updated at
        ** least once even if the FILTER clause means the min() or max()
        ** function visits zero rows.  */
        if( pAggInfo->nAccumulator ){
          for(i=0; i<pAggInfo->nFunc; i++){
            if( ExprHasProperty(pAggInfo->aFunc[i].pFExpr, EP_WinFunc) ){
              continue;
            }
            if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){
              break;
            }
          }
          if( i==pAggInfo->nFunc ){
            regAcc = ++pParse->nMem;
            sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
          }
        }
 
        /* This case runs if the aggregate has no GROUP BY clause.  The
        ** processing is much simpler since there is only a single row
        ** of output.
        */
        assert( p->pGroupBy==0 );
        resetAccumulator(pParse, pAggInfo);
 
        /* If this query is a candidate for the min/max optimization, then
        ** minMaxFlag will have been previously set to either
        ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
        ** be an appropriate ORDER BY expression for the optimization.
        */
        assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
        assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
 
        SELECTTRACE(1,pParse,p,("WhereBegin\n"));
        pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
                                   0, minMaxFlag, 0);
        if( pWInfo==0 ){
          goto select_end;
        }
        updateAccumulator(pParse, regAcc, pAggInfo);
        if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
        addrSkip = sqlite3WhereOrderByLimitOptLabel(pWInfo);
        if( addrSkip!=sqlite3WhereContinueLabel(pWInfo) ){
          sqlite3VdbeGoto(v, addrSkip);
        }
        sqlite3WhereEnd(pWInfo);
        finalizeAggFunctions(pParse, pAggInfo);
      }
 
      sSort.pOrderBy = 0;
      sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
      selectInnerLoop(pParse, p, -1, 0, 0,
                      pDest, addrEnd, addrEnd);
    }
    sqlite3VdbeResolveLabel(v, addrEnd);
 
  } /* endif aggregate query */
 
  if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){
    explainTempTable(pParse, "DISTINCT");
  }
 
  /* If there is an ORDER BY clause, then we need to sort the results
  ** and send them to the callback one by one.
  */
  if( sSort.pOrderBy ){
    explainTempTable(pParse,
                     sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
    assert( p->pEList==pEList );
    generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
  }
 
  /* Jump here to skip this query
  */
  sqlite3VdbeResolveLabel(v, iEnd);
 
  /* The SELECT has been coded. If there is an error in the Parse structure,
  ** set the return code to 1. Otherwise 0. */
  rc = (pParse->nErr>0);
 
  /* Control jumps to here if an error is encountered above, or upon
  ** successful coding of the SELECT.
  */
select_end:
  sqlite3ExprListDelete(db, pMinMaxOrderBy);
#ifdef SQLITE_DEBUG
  if( pAggInfo && !db->mallocFailed ){
    for(i=0; i<pAggInfo->nColumn; i++){
      Expr *pExpr = pAggInfo->aCol[i].pCExpr;
      assert( pExpr!=0 || db->mallocFailed );
      if( pExpr==0 ) continue;
      assert( pExpr->pAggInfo==pAggInfo );
      assert( pExpr->iAgg==i );
    }
    for(i=0; i<pAggInfo->nFunc; i++){
      Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
      assert( pExpr!=0 || db->mallocFailed );
      if( pExpr==0 ) continue;
      assert( pExpr->pAggInfo==pAggInfo );
      assert( pExpr->iAgg==i );
    }
  }
#endif
 
#if SELECTTRACE_ENABLED
  SELECTTRACE(0x1,pParse,p,("end processing\n"));
  if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){

References ExprList::a, SrcList::a, AggInfo::aCol, Parse::addrExplain, SortCtx::addrSortIndex, DistinctCtx::addrTnct, AggInfo::aFunc, BTREE_UNORDERED, Index::bUnordered, computeLimitRegisters(), Parse::db, AggInfo::directMode, SelectDest::eDest, EP_WinFunc, EP_xIsSelect, DistinctCtx::eTnctType, ExplainQueryPlan, ExplainQueryPlanParent, ExplainQueryPlanPop, explainSimpleCount(), explainTempTable(), ExprHasProperty, SrcList::SrcList_item::fg, finalizeAggFunctions(), flattenSubquery(), FuncDef::funcFlags, generateColumnNames(), generateSortTail(), HasRowid, havingToWhere(), Expr::iAgg, SortCtx::iECursor, IgnorableOrderby, Select::iLimit, AggInfo::AggInfo_col::iMem, AggInfo::AggInfo_func::iMem, SelectDest::iSDParm, SelectDest::iSdst, AggInfo::AggInfo_col::iSorterColumn, isSelfJoinView(), isSimpleCount(), DistinctCtx::isTnct, IsWindowFunc, SrcList::SrcList_item::jointype, JT_CROSS, JT_LEFT, JT_OUTER, KEYINFO_ORDER_DESC, SortCtx::labelOBLopt, sqlite3::mallocFailed, minMaxQuery(), AggInfo::mnReg, multiSelect(), AggInfo::mxReg, AggInfo::nAccumulator, NC_InAggFunc, NC_UAggInfo, NameContext::ncFlags, Table::nCol, AggInfo::nColumn, Parse::nErr, ExprList::nExpr, AggInfo::nFunc, Parse::nHeight, Parse::nMem, SortCtx::nOBSat, SrcList::SrcList_item::notIndexed, Select::nSelectRow, AggInfo::nSortingColumn, SrcList::nSrc, Parse::nTab, OP_Close, OP_Column, OP_Compare, OP_Count, OP_Gosub, OP_Goto, OP_IfPos, OP_InitCoroutine, OP_Integer, OP_Jump, OP_MakeRecord, OP_Null, OP_Once, OP_OpenDup, OP_OpenEphemeral, OP_OpenPseudo, OP_OpenRead, OP_Return, OP_SorterData, OP_SorterInsert, OP_SorterNext, OP_SorterOpen, OP_SorterSort, OptimizationEnabled, P4_KEYINFO, Expr::pAggInfo, NameContext::pAggInfo, Parse::pAggList, AggInfo::AggInfo_col::pCExpr, Select::pEList, ExprList::ExprList_item::pExpr, AggInfo::AggInfo_func::pFExpr, Window::pFilter, AggInfo::AggInfo_func::pFunc, AggInfo::pGroupBy, Select::pGroupBy, Select::pHaving, Table::pIndex, Expr::pList, Index::pNext, AggInfo::pNext, Select::pNext, Select::pOrderBy, SortCtx::pOrderBy, NameContext::pParse, Index::pPartIdxWhere, Select::pPrior, propagateConstants(), Table::pSchema, Select::pSrc, NameContext::pSrcList, pushDownWhereTerms(), Select::pWhere, Expr::pWin, Select::pWin, resetAccumulator(), selectInnerLoop(), SELECTTRACE, Select::selFlags, AggInfo::selId, Select::selId, SF_Aggregate, SF_ComplexResult, SF_Distinct, SF_FixedLimit, SF_NoopOrderBy, SF_UpdateFrom, SORTFLAG_UseSorter, ExprList::ExprList_item::sortFlags, SortCtx::sortFlags, AggInfo::sortingIdx, AggInfo::sortingIdxPTab, sqlite3_stricmp(), sqlite3_unsupported_selecttrace, sqlite3AuthCheck(), sqlite3ClearTempRegCache(), sqlite3CodeVerifySchema(), sqlite3DbMallocZero(), sqlite3ErrorMsg(), sqlite3ExprAnalyzeAggList(), sqlite3ExprAnalyzeAggregates(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeGetColumnOfTable(), sqlite3ExprCodeMove(), sqlite3ExprIfFalse(), sqlite3ExprImpliesNonNullRow(), sqlite3ExprListCompare(), sqlite3ExprListDelete(), sqlite3ExprListDup(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3KeyInfoFromExprList(), sqlite3KeyInfoOfIndex(), sqlite3KeyInfoRef(), sqlite3LogEst(), sqlite3PrimaryKeyIndex(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3SchemaToIndex(), sqlite3Select(), sqlite3SelectDestInit(), sqlite3SelectExprHeight(), sqlite3SelectPrep(), sqlite3TableLock(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeOpcode(), sqlite3VdbeChangeP1(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCurrentAddr(), sqlite3VdbeEndCoroutine(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3WhereBegin(), sqlite3WhereBreakLabel(), sqlite3WhereContinueLabel(), sqlite3WhereEnd(), sqlite3WhereIsDistinct(), sqlite3WhereIsOrdered(), sqlite3WhereIsSorted(), sqlite3WhereOrderByLimitOptLabel(), sqlite3WhereOutputRowCount(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), sqlite3WindowRewrite(), SQLITE_CountOfView, SQLITE_FUNC_NEEDCOLL, SQLITE_GroupByOrder, SQLITE_JUMPIFNULL, SQLITE_PropagateConst, SQLITE_PushDown, SQLITE_QueryFlattener, SQLITE_READ, SQLITE_SELECT, SQLITE_SimplifyJoin, SRT_Coroutine, SRT_Discard, SRT_DistFifo, SRT_DistQueue, SRT_EphemTab, SRT_Except, SRT_Exists, SRT_Fifo, SRT_Output, SRT_Queue, SRT_Union, Index::szIdxRow, Table::szTabRow, DistinctCtx::tabTnct, testcase, Table::tnum, Index::tnum, NameContext::uNC, unsetJoinExpr(), updateAccumulator(), AggInfo::useSortingIdx, VdbeComment, VdbeCoverage, VdbeNoopComment, VVA_ONLY, WHERE_DISTINCT_NOOP, WHERE_DISTINCT_UNORDERED, WHERE_GROUPBY, WHERE_ORDERBY_NORMAL, WHERE_SORTBYGROUP, WHERE_USE_LIMIT, WHERE_WANT_DISTINCT, Expr::x, Expr::y, Parse::zAuthContext, and Table::zName.

Referenced by generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3EndTable(), sqlite3Insert(), sqlite3MaterializeView(), sqlite3Select(), updateFromSelect(), and yy_reduce().

◆ sqlite3SelectAddColumnTypeAndCollation()

SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation	(	Parse *	pParse,
		Table *	pTab,
		Select *	pSelect,
		char	aff )

Definition at line 131359 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  NameContext sNC;
  Column *pCol;
  CollSeq *pColl;
  int i;
  Expr *p;
  struct ExprList_item *a;
 
  assert( pSelect!=0 );
  assert( (pSelect->selFlags & SF_Resolved)!=0 );
  assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
  if( db->mallocFailed ) return;
  memset(&sNC, 0, sizeof(sNC));
  sNC.pSrcList = pSelect->pSrc;
  a = pSelect->pEList->a;
  for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
    const char *zType;
    int n, m;
    p = a[i].pExpr;
    zType = columnType(&sNC, p, 0, 0, 0);
    /* pCol->szEst = ... // Column size est for SELECT tables never used */
    pCol->affinity = sqlite3ExprAffinity(p);
    if( zType ){
      m = sqlite3Strlen30(zType);
      n = sqlite3Strlen30(pCol->zName);
      pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
      if( pCol->zName ){
        memcpy(&pCol->zName[n+1], zType, m+1);
        pCol->colFlags |= COLFLAG_HASTYPE;
      }
    }
    if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff;
    pColl = sqlite3ExprCollSeq(pParse, p);

References ExprList::a, Table::aCol, Column::affinity, COLFLAG_HASTYPE, Column::colFlags, columnType, Parse::db, sqlite3::mallocFailed, Table::nCol, ExprList::nExpr, Select::pEList, Select::pSrc, NameContext::pSrcList, Select::selFlags, SF_Resolved, sqlite3DbReallocOrFree(), sqlite3DbStrDup(), sqlite3ExprAffinity(), sqlite3ExprCollSeq(), sqlite3Strlen30(), SQLITE_AFF_NONE, Table::szTabRow, Column::zColl, Column::zName, and CollSeq::zName.

Referenced by selectAddSubqueryTypeInfo(), and sqlite3ViewGetColumnNames().

◆ sqlite3SelectAddTypeInfo()

static void sqlite3SelectAddTypeInfo	(	Parse *	pParse,
		Select *	pSelect )

static

Definition at line 134641 of file sqlite3.c.

                                                                    {
#ifndef SQLITE_OMIT_SUBQUERY
  Walker w;
  w.xSelectCallback = sqlite3SelectWalkNoop;

References Walker::pParse, selectAddSubqueryTypeInfo(), sqlite3ExprWalkNoop(), sqlite3SelectWalkNoop(), sqlite3WalkSelect(), Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3SelectPrep().

◆ sqlite3SelectDelete()

SQLITE_PRIVATE void sqlite3SelectDelete	(	sqlite3 *	db,
		Select *	p )

◆ sqlite3SelectDestInit()

SQLITE_PRIVATE void sqlite3SelectDestInit	(	SelectDest *	pDest,
		int	eDest,
		int	iParm )

Definition at line 129396 of file sqlite3.c.

129402 {

129403 pDest->eDest = (u8)eDest;

Referenced by generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3EndTable(), sqlite3Insert(), sqlite3MaterializeView(), sqlite3Select(), and updateFromSelect().

◆ sqlite3SelectDup()

SQLITE_PRIVATE Select * sqlite3SelectDup	(	sqlite3 *	db,
		Select *	pDup,
		int	flags )

Definition at line 101281 of file sqlite3.c.

                                                                             {
  Select *pRet = 0;
  Select *pNext = 0;
  Select **pp = &pRet;
  Select *p;
 
  assert( db!=0 );
  for(p=pDup; p; p=p->pPrior){
    Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) );
    if( pNew==0 ) break;
    pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
    pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
    pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
    pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
    pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
    pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
    pNew->op = p->op;
    pNew->pNext = pNext;
    pNew->pPrior = 0;
    pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
    pNew->iLimit = 0;
    pNew->iOffset = 0;
    pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
    pNew->addrOpenEphm[0] = -1;
    pNew->addrOpenEphm[1] = -1;
    pNew->nSelectRow = p->nSelectRow;
    pNew->pWith = withDup(db, p->pWith);
#ifndef SQLITE_OMIT_WINDOWFUNC
    pNew->pWin = 0;
    pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
    if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
#endif
    pNew->selId = p->selId;
    *pp = pNew;

Referenced by exprDup(), fkActionTrigger(), flattenSubquery(), selectExpander(), sqlite3SrcListDup(), sqlite3TriggerInsertStep(), sqlite3ViewGetColumnNames(), withDup(), and withExpand().

◆ sqlite3SelectExpand()

static void sqlite3SelectExpand	(	Parse *	pParse,
		Select *	pSelect )

static

Definition at line 134576 of file sqlite3.c.

                                                               {
  Walker w;
  w.xExprCallback = sqlite3ExprWalkNoop;
  w.pParse = pParse;
  if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
    w.xSelectCallback = convertCompoundSelectToSubquery;
    w.xSelectCallback2 = 0;
    sqlite3WalkSelect(&w, pSelect);

References convertCompoundSelectToSubquery(), Walker::eCode, Parse::hasCompound, OK_IF_ALWAYS_TRUE, Walker::pParse, selectExpander(), selectPopWith(), sqlite3ExprWalkNoop(), sqlite3WalkSelect(), Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3SelectPrep().

◆ sqlite3SelectExprHeight()

SQLITE_PRIVATE int sqlite3SelectExprHeight ( Select * p )

Definition at line 100468 of file sqlite3.c.

Referenced by sqlite3Select().

◆ sqlite3SelectNew()

SQLITE_PRIVATE Select * sqlite3SelectNew	(	Parse *	pParse,
		ExprList *	pEList,
		SrcList *	pSrc,
		Expr *	pWhere,
		ExprList *	pGroupBy,
		Expr *	pHaving,
		ExprList *	pOrderBy,
		u32	selFlags,
		Expr *	pLimit )

Definition at line 129410 of file sqlite3.c.

 {
  Select *pNew, *pAllocated;
  Select standin;
  pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
  if( pNew==0 ){
    assert( pParse->db->mallocFailed );
    pNew = &standin;
  }
  if( pEList==0 ){
    pEList = sqlite3ExprListAppend(pParse, 0,
                                   sqlite3Expr(pParse->db,TK_ASTERISK,0));
  }
  pNew->pEList = pEList;
  pNew->op = TK_SELECT;
  pNew->selFlags = selFlags;
  pNew->iLimit = 0;
  pNew->iOffset = 0;
  pNew->selId = ++pParse->nSelect;
  pNew->addrOpenEphm[0] = -1;
  pNew->addrOpenEphm[1] = -1;
  pNew->nSelectRow = 0;
  if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
  pNew->pSrc = pSrc;
  pNew->pWhere = pWhere;
  pNew->pGroupBy = pGroupBy;
  pNew->pHaving = pHaving;
  pNew->pOrderBy = pOrderBy;
  pNew->pPrior = 0;
  pNew->pNext = 0;
  pNew->pLimit = pLimit;
  pNew->pWith = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
  pNew->pWin = 0;
  pNew->pWinDefn = 0;
#endif
  if( pParse->db->mallocFailed ) {
    clearSelect(pParse->db, pNew, pNew!=&standin);

References Select::addrOpenEphm, clearSelect(), Parse::db, Select::iLimit, Select::iOffset, sqlite3::mallocFailed, Parse::nErr, Parse::nSelect, Select::nSelectRow, Select::op, Select::pEList, Select::pGroupBy, Select::pHaving, Select::pLimit, Select::pNext, Select::pOrderBy, Select::pPrior, Select::pSrc, Select::pWhere, Select::pWin, Select::pWinDefn, Select::pWith, Select::selFlags, Select::selId, sqlite3DbMallocRawNN(), sqlite3DbMallocZero(), sqlite3Expr(), sqlite3ExprListAppend(), TK_ASTERISK, and TK_SELECT.

Referenced by fkActionTrigger(), sqlite3MaterializeView(), sqlite3WindowRewrite(), updateFromSelect(), and yy_reduce().

◆ sqlite3SelectPrep()

SQLITE_PRIVATE void sqlite3SelectPrep	(	Parse *	pParse,
		Select *	p,
		NameContext *	pOuterNC )

Definition at line 134665 of file sqlite3.c.

 {
  assert( p!=0 || pParse->db->mallocFailed );
  if( pParse->db->mallocFailed ) return;
  if( p->selFlags & SF_HasTypeInfo ) return;

References Parse::db, sqlite3::mallocFailed, Parse::nErr, Select::selFlags, SF_HasTypeInfo, sqlite3ResolveSelectNames(), sqlite3SelectAddTypeInfo(), and sqlite3SelectExpand().

Referenced by renameColumnFunc(), renameResolveTrigger(), renameTableFunc(), renameTableTest(), and sqlite3Select().

◆ sqlite3SelectWalkFail()

SQLITE_PRIVATE int sqlite3SelectWalkFail	(	Walker *	pWalker,
		Select *	NotUsed )

Definition at line 101605 of file sqlite3.c.

References Walker::eCode, UNUSED_PARAMETER, and WRC_Abort.

Referenced by exprIsDeterministic().

◆ sqlite3SelectWalkNoop()

SQLITE_PRIVATE int sqlite3SelectWalkNoop	(	Walker *	NotUsed,
		Select *	NotUsed2 )

Definition at line 97743 of file sqlite3.c.

Referenced by propagateConstants(), and sqlite3SelectAddTypeInfo().

◆ sqlite3SelectWrongNumTermsError()

SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError	(	Parse *	pParse,
		Select *	p )

Definition at line 132200 of file sqlite3.c.

132206 {

132207 if( p->selFlags & SF_Values ){

References Select::op, selectOpName(), Select::selFlags, SF_Values, and sqlite3ErrorMsg().

◆ sqlite3SetHasNullFlag()

static void sqlite3SetHasNullFlag	(	Vdbe *	v,
		int	iCur,
		int	regHasNull )

static

Definition at line 102119 of file sqlite3.c.

                                                                    {
  int addr1;
  sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull);

References OP_Column, OP_Integer, OP_Rewind, OPFLAG_TYPEOFARG, sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP5(), sqlite3VdbeJumpHere(), VdbeComment, and VdbeCoverage.

Referenced by sqlite3FindInIndex().

◆ sqlite3SetJoinExpr()

SQLITE_PRIVATE void sqlite3SetJoinExpr	(	Expr *	p,
		int	iTable )

Definition at line 129674 of file sqlite3.c.

                                                           {
  while( p ){
    ExprSetProperty(p, EP_FromJoin);
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(p, EP_NoReduce);
    p->iRightJoinTable = (i16)iTable;
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);

References ExprList::a, EP_FromJoin, EP_NoReduce, EP_Reduced, EP_TokenOnly, ExprHasProperty, ExprSetProperty, ExprSetVVAProperty, Expr::iRightJoinTable, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, sqlite3SetJoinExpr(), TK_FUNCTION, and Expr::x.

Referenced by flattenSubquery(), sqlite3SetJoinExpr(), sqlite3WhereTabFuncArgs(), and sqliteProcessJoin().

◆ sqlite3SetString()

SQLITE_PRIVATE void sqlite3SetString	(	char **	pz,
		sqlite3 *	db,
		const char *	zNew )

Definition at line 28060 of file sqlite3.c.

Referenced by execSqlF(), and sqlite3InitOne().

◆ sqlite3SetTextEncoding()

SQLITE_PRIVATE void sqlite3SetTextEncoding	(	sqlite3 *	db,
		u8	enc )

Definition at line 115717 of file sqlite3.c.

115723 {

115724 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );

Referenced by openDatabase(), sqlite3InitOne(), and sqlite3Pragma().

◆ sqlite3ShadowTableName()

SQLITE_PRIVATE int sqlite3ShadowTableName	(	sqlite3 *	db,
		const char *	zName )

Definition at line 112599 of file sqlite3.c.

                                                                         {
  char *zTail;                  /* Pointer to the last "_" in zName */
  Table *pTab;                  /* Table that zName is a shadow of */
  zTail = strrchr(zName, '_');
  if( zTail==0 ) return 0;
  *zTail = 0;

References IsVirtual, sqlite3FindTable(), sqlite3IsShadowTableOf(), and zName.

Referenced by sqlite3CheckObjectName(), and sqlite3EndTable().

◆ sqlite3SkipAccumulatorLoad()

static void sqlite3SkipAccumulatorLoad ( sqlite3_context * context )

static

Definition at line 117084 of file sqlite3.c.

Referenced by minmaxStep().

◆ sqlite3SrcListAppend()

SQLITE_PRIVATE SrcList * sqlite3SrcListAppend	(	Parse *	pParse,
		SrcList *	pList,
		Token *	pTable,
		Token *	pDatabase )

Definition at line 114789 of file sqlite3.c.

 {
  struct SrcList_item *pItem;
  sqlite3 *db;
  assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
  assert( pParse!=0 );
  assert( pParse->db!=0 );
  db = pParse->db;
  if( pList==0 ){
    pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 1;
    pList->nSrc = 1;
    memset(&pList->a[0], 0, sizeof(pList->a[0]));
    pList->a[0].iCursor = -1;
  }else{
    SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
    if( pNew==0 ){
      sqlite3SrcListDelete(db, pList);
      return 0;
    }else{
      pList = pNew;
    }
  }
  pItem = &pList->a[pList->nSrc-1];
  if( pDatabase && pDatabase->z==0 ){
    pDatabase = 0;
  }
  if( pDatabase ){
    pItem->zName = sqlite3NameFromToken(db, pDatabase);
    pItem->zDatabase = sqlite3NameFromToken(db, pTable);

References SrcList::a, Parse::db, SrcList::SrcList_item::iCursor, SrcList::nAlloc, SrcList::nSrc, sqlite3DbMallocRawNN(), sqlite3NameFromToken(), sqlite3SrcListDelete(), sqlite3SrcListEnlarge(), and Token::z.

Referenced by fkActionTrigger(), flattenSubquery(), sqlite3FkCheck(), sqlite3MaterializeView(), sqlite3SrcListAppendFromTerm(), sqlite3TriggerStepSrc(), sqlite3WindowRewrite(), and yy_reduce().

◆ sqlite3SrcListAppendFromTerm()

SQLITE_PRIVATE SrcList * sqlite3SrcListAppendFromTerm	(	Parse *	pParse,
		SrcList *	p,
		Token *	pTable,
		Token *	pDatabase,
		Token *	pAlias,
		Select *	pSubquery,
		Expr *	pOn,
		IdList *	pUsing )

Definition at line 114886 of file sqlite3.c.

 {
  struct SrcList_item *pItem;
  sqlite3 *db = pParse->db;
  if( !p && (pOn || pUsing) ){
    sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
      (pOn ? "ON" : "USING")
    );
    goto append_from_error;
  }
  p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
  if( p==0 ){
    goto append_from_error;
  }
  assert( p->nSrc>0 );
  pItem = &p->a[p->nSrc-1];
  assert( (pTable==0)==(pDatabase==0) );
  assert( pItem->zName==0 || pDatabase!=0 );
  if( IN_RENAME_OBJECT && pItem->zName ){
    Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
    sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
  }
  assert( pAlias!=0 );
  if( pAlias->n ){
    pItem->zAlias = sqlite3NameFromToken(db, pAlias);
  }
  pItem->pSelect = pSubquery;
  pItem->pOn = pOn;
  pItem->pUsing = pUsing;
  return p;
 
 append_from_error:

References SrcList::a, ALWAYS, Parse::db, IN_RENAME_OBJECT, Token::n, SrcList::nSrc, sqlite3ErrorMsg(), sqlite3ExprDelete(), sqlite3IdListDelete(), sqlite3NameFromToken(), sqlite3RenameTokenMap(), sqlite3SelectDelete(), sqlite3SrcListAppend(), and Token::z.

Referenced by convertCompoundSelectToSubquery(), and yy_reduce().

◆ sqlite3SrcListAppendList()

SQLITE_PRIVATE SrcList * sqlite3SrcListAppendList	(	Parse *	pParse,
		SrcList *	p1,
		SrcList *	p2 )

Definition at line 114962 of file sqlite3.c.

                                                                                         {
  assert( p1 && p1->nSrc==1 );
  if( p2 ){
    SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
    if( pNew==0 ){
      sqlite3SrcListDelete(pParse->db, p2);
    }else{
      p1 = pNew;

References SrcList::a, Parse::db, SrcList::nSrc, sqlite3DbFree(), sqlite3SrcListDelete(), and sqlite3SrcListEnlarge().

Referenced by sqlite3TriggerStepSrc(), and yy_reduce().

◆ sqlite3SrcListAssignCursors()

SQLITE_PRIVATE void sqlite3SrcListAssignCursors	(	Parse *	pParse,
		SrcList *	pList )

Definition at line 114834 of file sqlite3.c.

                                                                              {
  int i;
  struct SrcList_item *pItem;
  assert(pList || pParse->db->mallocFailed );
  if( pList ){
    for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
      if( pItem->iCursor>=0 ) break;
      pItem->iCursor = pParse->nTab++;

Referenced by selectExpander(), sqlite3ViewGetColumnNames(), and sqlite3WindowRewrite().

◆ sqlite3SrcListDelete()

SQLITE_PRIVATE void sqlite3SrcListDelete	(	sqlite3 *	db,
		SrcList *	pList )

Definition at line 114852 of file sqlite3.c.

                                                                     {
  int i;
  struct SrcList_item *pItem;
  if( pList==0 ) return;
  for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
    sqlite3DbFree(db, pItem->zDatabase);
    sqlite3DbFree(db, pItem->zName);
    sqlite3DbFree(db, pItem->zAlias);
    if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
    if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
    sqlite3DeleteTable(db, pItem->pTab);

Referenced by clearSelect(), renameResolveTrigger(), sqlite3AlterBeginAddColumn(), sqlite3AlterRenameColumn(), sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3DeleteTriggerStep(), sqlite3DropTrigger(), sqlite3Insert(), sqlite3SrcListAppend(), sqlite3SrcListAppendList(), sqlite3TriggerUpdateStep(), sqlite3Update(), yy_destructor(), and yy_reduce().

◆ sqlite3SrcListDup()

SQLITE_PRIVATE SrcList * sqlite3SrcListDup	(	sqlite3 *	db,
		SrcList *	p,
		int	flags )

Definition at line 101216 of file sqlite3.c.

                                                                             {
  SrcList *pNew;
  int i;
  int nByte;
  assert( db!=0 );
  if( p==0 ) return 0;
  nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
  pNew = sqlite3DbMallocRawNN(db, nByte );
  if( pNew==0 ) return 0;
  pNew->nSrc = pNew->nAlloc = p->nSrc;
  for(i=0; i<p->nSrc; i++){
    struct SrcList_item *pNewItem = &pNew->a[i];
    struct SrcList_item *pOldItem = &p->a[i];
    Table *pTab;
    pNewItem->pSchema = pOldItem->pSchema;
    pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
    pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
    pNewItem->fg = pOldItem->fg;
    pNewItem->iCursor = pOldItem->iCursor;
    pNewItem->addrFillSub = pOldItem->addrFillSub;
    pNewItem->regReturn = pOldItem->regReturn;
    if( pNewItem->fg.isIndexedBy ){
      pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
    }
    pNewItem->pIBIndex = pOldItem->pIBIndex;
    if( pNewItem->fg.isTabFunc ){
      pNewItem->u1.pFuncArg =
          sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
    }
    pTab = pNewItem->pTab = pOldItem->pTab;
    if( pTab ){
      pTab->nTabRef++;
    }
    pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);

References SrcList::a, SrcList::nAlloc, SrcList::nSrc, Table::nTabRef, Table::pSchema, sqlite3DbMallocRawNN(), sqlite3DbStrDup(), sqlite3ExprListDup(), sqlite3SelectDup(), and sqlite3::u1.

Referenced by sqlite3FkDropTable(), sqlite3TriggerStepSrc(), sqlite3TriggerUpdateStep(), sqlite3UpsertDoUpdate(), and updateFromSelect().

◆ sqlite3SrcListEnlarge()

SQLITE_PRIVATE SrcList * sqlite3SrcListEnlarge	(	Parse *	pParse,
		SrcList *	pSrc,
		int	nExtra,
		int	iStart )

Definition at line 114700 of file sqlite3.c.

     : nil, nil, nil, A, B.
**
** If a memory allocation fails or the SrcList becomes too large, leave
** the original SrcList unchanged, return NULL, and leave an error message
** in pParse.
*/
SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
  Parse *pParse,     /* Parsing context into which errors are reported */
  SrcList *pSrc,     /* The SrcList to be enlarged */
  int nExtra,        /* Number of new slots to add to pSrc->a[] */
  int iStart         /* Index in pSrc->a[] of first new slot */
){
  int i;
 
  /* Sanity checking on calling parameters */
  assert( iStart>=0 );
  assert( nExtra>=1 );
  assert( pSrc!=0 );
  assert( iStart<=pSrc->nSrc );
 
  /* Allocate additional space if needed */
  if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
    SrcList *pNew;
    sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
    sqlite3 *db = pParse->db;
 
    if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
      sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
                      SQLITE_MAX_SRCLIST);
      return 0;
    }
    if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
    pNew = sqlite3DbRealloc(db, pSrc,
               sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
    if( pNew==0 ){
      assert( db->mallocFailed );
      return 0;
    }
    pSrc = pNew;
    pSrc->nAlloc = nAlloc;
  }
 
  /* Move existing slots that come after the newly inserted slots
  ** out of the way */
  for(i=pSrc->nSrc-1; i>=iStart; i--){
    pSrc->a[i+nExtra] = pSrc->a[i];
  }
  pSrc->nSrc += nExtra;
 
  /* Zero the newly allocated slots */
  memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
  for(i=iStart; i<iStart+nExtra; i++){

References SrcList::a, Parse::db, SrcList::SrcList_item::iCursor, sqlite3::mallocFailed, SrcList::nAlloc, SrcList::nSrc, sqlite3DbRealloc(), sqlite3ErrorMsg(), and SQLITE_MAX_SRCLIST.

Referenced by flattenSubquery(), sqlite3SrcListAppend(), and sqlite3SrcListAppendList().

◆ sqlite3SrcListFuncArgs()

SQLITE_PRIVATE void sqlite3SrcListFuncArgs	(	Parse *	pParse,
		SrcList *	p,
		ExprList *	pList )

Definition at line 114981 of file sqlite3.c.

                                                                                      {
  if( p ){
    struct SrcList_item *pItem = &p->a[p->nSrc-1];
    assert( pItem->fg.notIndexed==0 );
    assert( pItem->fg.isIndexedBy==0 );
    assert( pItem->fg.isTabFunc==0 );

Referenced by yy_reduce().

◆ sqlite3SrcListIndexedBy()

SQLITE_PRIVATE void sqlite3SrcListIndexedBy	(	Parse *	pParse,
		SrcList *	p,
		Token *	pIndexedBy )

Definition at line 114937 of file sqlite3.c.

                                                                                         {
  assert( pIndexedBy!=0 );
  if( p && pIndexedBy->n>0 ){
    struct SrcList_item *pItem;
    assert( p->nSrc>0 );
    pItem = &p->a[p->nSrc-1];
    assert( pItem->fg.notIndexed==0 );
    assert( pItem->fg.isIndexedBy==0 );
    assert( pItem->fg.isTabFunc==0 );
    if( pIndexedBy->n==1 && !pIndexedBy->z ){
      /* A "NOT INDEXED" clause was supplied. See parse.y
      ** construct "indexed_opt" for details. */
      pItem->fg.notIndexed = 1;

Referenced by yy_reduce().

◆ sqlite3SrcListLookup()

SQLITE_PRIVATE Table * sqlite3SrcListLookup	(	Parse *	pParse,
		SrcList *	pSrc )

Definition at line 116106 of file sqlite3.c.

                                                           :
**
**    pSrc->a[0].pTab       Pointer to the Table object
**    pSrc->a[0].pIndex     Pointer to the INDEXED BY index, if there is one
**
*/
SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
  struct SrcList_item *pItem = pSrc->a;
  Table *pTab;
  assert( pItem && pSrc->nSrc>=1 );
  pTab = sqlite3LocateTableItem(pParse, 0, pItem);
  sqlite3DeleteTable(pParse->db, pItem->pTab);
  pItem->pTab = pTab;
  if( pTab ){
    pTab->nTabRef++;

References SrcList::a, Parse::db, SrcList::nSrc, Table::nTabRef, sqlite3DeleteTable(), sqlite3IndexedByLookup(), and sqlite3LocateTableItem().

Referenced by sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3SrcListShiftJoinType()

SQLITE_PRIVATE void sqlite3SrcListShiftJoinType ( SrcList * p )

Definition at line 115009 of file sqlite3.c.

                                                           {
  if( p ){
    int i;

References SrcList::a, SrcList::SrcList_item::fg, SrcList::SrcList_item::jointype, and SrcList::nSrc.

Referenced by yy_reduce().

◆ sqlite3StartTable()

SQLITE_PRIVATE void sqlite3StartTable	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		int	isTemp,
		int	isView,
		int	isVirtual,
		int	noErr )

Definition at line 111424 of file sqlite3.c.

 {
  Table *pTable;
  char *zName = 0; /* The name of the new table */
  sqlite3 *db = pParse->db;
  Vdbe *v;
  int iDb;         /* Database number to create the table in */
  Token *pName;    /* Unqualified name of the table to create */
 
  if( db->init.busy && db->init.newTnum==1 ){
    /* Special case:  Parsing the sqlite_schema or sqlite_temp_schema schema */
    iDb = db->init.iDb;
    zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
    pName = pName1;
  }else{
    /* The common case */
    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
    if( iDb<0 ) return;
    if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
      /* If creating a temp table, the name may not be qualified. Unless
      ** the database name is "temp" anyway.  */
      sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
      return;
    }
    if( !OMIT_TEMPDB && isTemp ) iDb = 1;
    zName = sqlite3NameFromToken(db, pName);
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, (void*)zName, pName);
    }
  }
  pParse->sNameToken = *pName;
  if( zName==0 ) return;
  if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
    goto begin_table_error;
  }
  if( db->init.iDb==1 ) isTemp = 1;
#ifndef SQLITE_OMIT_AUTHORIZATION
  assert( isTemp==0 || isTemp==1 );
  assert( isView==0 || isView==1 );
  {
    static const u8 aCode[] = {
       SQLITE_CREATE_TABLE,
       SQLITE_CREATE_TEMP_TABLE,
       SQLITE_CREATE_VIEW,
       SQLITE_CREATE_TEMP_VIEW
    };
    char *zDb = db->aDb[iDb].zDbSName;
    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
      goto begin_table_error;
    }
    if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
                                       zName, 0, zDb) ){
      goto begin_table_error;
    }
  }
#endif
 
  /* Make sure the new table name does not collide with an existing
  ** index or table name in the same database.  Issue an error message if
  ** it does. The exception is if the statement being parsed was passed
  ** to an sqlite3_declare_vtab() call. In that case only the column names
  ** and types will be used, so there is no need to test for namespace
  ** collisions.
  */
  if( !IN_SPECIAL_PARSE ){
    char *zDb = db->aDb[iDb].zDbSName;
    if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
      goto begin_table_error;
    }
    pTable = sqlite3FindTable(db, zName, zDb);
    if( pTable ){
      if( !noErr ){
        sqlite3ErrorMsg(pParse, "table %T already exists", pName);
      }else{
        assert( !db->init.busy || CORRUPT_DB );
        sqlite3CodeVerifySchema(pParse, iDb);
      }
      goto begin_table_error;
    }
    if( sqlite3FindIndex(db, zName, zDb)!=0 ){
      sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
      goto begin_table_error;
    }
  }
 
  pTable = sqlite3DbMallocZero(db, sizeof(Table));
  if( pTable==0 ){
    assert( db->mallocFailed );
    pParse->rc = SQLITE_NOMEM_BKPT;
    pParse->nErr++;
    goto begin_table_error;
  }
  pTable->zName = zName;
  pTable->iPKey = -1;
  pTable->pSchema = db->aDb[iDb].pSchema;
  pTable->nTabRef = 1;
#ifdef SQLITE_DEFAULT_ROWEST
  pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
#else
  pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
#endif
  assert( pParse->pNewTable==0 );
  pParse->pNewTable = pTable;
 
  /* If this is the magic sqlite_sequence table used by autoincrement,
  ** then record a pointer to this table in the main database structure
  ** so that INSERT can find the table easily.
  */
#ifndef SQLITE_OMIT_AUTOINCREMENT
  if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    pTable->pSchema->pSeqTab = pTable;
  }
#endif
 
  /* Begin generating the code that will insert the table record into
  ** the schema table.  Note in particular that we must go ahead
  ** and allocate the record number for the table entry now.  Before any
  ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
  ** indices to be created and the table record must come before the
  ** indices.  Hence, the record number for the table must be allocated
  ** now.
  */
  if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
    int addr1;
    int fileFormat;
    int reg1, reg2, reg3;
    /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
    static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
    sqlite3BeginWriteOperation(pParse, 1, iDb);
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( isVirtual ){
      sqlite3VdbeAddOp0(v, OP_VBegin);
    }
#endif
 
    /* If the file format and encoding in the database have not been set,
    ** set them now.
    */
    reg1 = pParse->regRowid = ++pParse->nMem;
    reg2 = pParse->regRoot = ++pParse->nMem;
    reg3 = ++pParse->nMem;
    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
    sqlite3VdbeUsesBtree(v, iDb);
    addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
    fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
                  1 : SQLITE_MAX_FILE_FORMAT;
    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
    sqlite3VdbeJumpHere(v, addr1);
 
    /* This just creates a place-holder record in the sqlite_schema table.
    ** The record created does not contain anything yet.  It will be replaced
    ** by the real entry in code generated at sqlite3EndTable().
    **
    ** The rowid for the new entry is left in register pParse->regRowid.
    ** The root page number of the new table is left in reg pParse->regRoot.
    ** The rowid and root page number values are needed by the code that
    ** sqlite3EndTable will generate.
    */
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
    if( isView || isVirtual ){
      sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
    }else
#endif
    {
      pParse->addrCrTab =
         sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
    }
    sqlite3OpenSchemaTable(pParse, iDb);
    sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
    sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
    sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
    sqlite3VdbeAddOp0(v, OP_Close);
  }
 
  /* Normal (non-error) return. */
  return;

References sqlite3::aDb, Parse::addrCrTab, BTREE_FILE_FORMAT, BTREE_INTKEY, BTREE_TEXT_ENCODING, sqlite3::sqlite3InitInfo::busy, CORRUPT_DB, Parse::db, ENC, sqlite3::flags, sqlite3::sqlite3InitInfo::iDb, IN_RENAME_OBJECT, IN_SPECIAL_PARSE, sqlite3::init, Table::iPKey, sqlite3::mallocFailed, Token::n, Parse::nErr, Parse::nested, sqlite3::sqlite3InitInfo::newTnum, Parse::nMem, Table::nRowLogEst, Table::nTabRef, OMIT_TEMPDB, OP_Blob, OP_Close, OP_CreateBtree, OP_If, OP_Insert, OP_Integer, OP_NewRowid, OP_ReadCookie, OP_SetCookie, OP_VBegin, OPFLAG_APPEND, P4_STATIC, Parse::pNewTable, Db::pSchema, Table::pSchema, Schema::pSeqTab, Parse::rc, Parse::regRoot, Parse::regRowid, SCHEMA_TABLE, Parse::sNameToken, sqlite3AuthCheck(), sqlite3BeginWriteOperation(), sqlite3CheckObjectName(), sqlite3CodeVerifySchema(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3GetVdbe(), sqlite3LogEst(), sqlite3NameFromToken(), sqlite3OpenSchemaTable(), sqlite3ReadSchema(), sqlite3RenameTokenMap(), sqlite3TwoPartName(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeJumpHere(), sqlite3VdbeUsesBtree(), SQLITE_CREATE_TABLE, SQLITE_CREATE_TEMP_TABLE, SQLITE_CREATE_TEMP_VIEW, SQLITE_CREATE_VIEW, SQLITE_INSERT, SQLITE_LegacyFileFmt, SQLITE_MAX_FILE_FORMAT, SQLITE_NOMEM_BKPT, SQLITE_OK, VdbeCoverage, Db::zDbSName, Table::zName, and zName.

Referenced by sqlite3VtabBeginParse(), and yy_reduce().

◆ sqlite3StatusDown()

SQLITE_PRIVATE void sqlite3StatusDown	(	int	op,
		int	N )

Definition at line 21413 of file sqlite3.c.

                                                {
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
}
SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){
  wsdStatInit;
  assert( N>=0 );
  assert( op>=0 && op<ArraySize(statMutex) );

References wsdStat.

◆ sqlite3StatusHighwater()

SQLITE_PRIVATE void sqlite3StatusHighwater	(	int	op,
		int	X )

Definition at line 21427 of file sqlite3.c.

                                                         {
  sqlite3StatValueType newValue;
  wsdStatInit;
  assert( X>=0 );
  newValue = (sqlite3StatValueType)X;
  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
  assert( op>=0 && op<ArraySize(statMutex) );
  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                           : sqlite3MallocMutex()) );
  assert( op==SQLITE_STATUS_MALLOC_SIZE
          || op==SQLITE_STATUS_PAGECACHE_SIZE

References ArraySize, sqlite3_mutex_held(), sqlite3MallocMutex(), sqlite3Pcache1Mutex(), SQLITE_STATUS_MALLOC_SIZE, SQLITE_STATUS_PAGECACHE_SIZE, SQLITE_STATUS_PARSER_STACK, statMutex, wsdStat, and wsdStatInit.

Referenced by mallocWithAlarm(), pcache1Alloc(), and sqlite3RunParser().

◆ sqlite3StatusUp()

SQLITE_PRIVATE void sqlite3StatusUp	(	int	op,
		int	N )

Definition at line 21402 of file sqlite3.c.

                                                  {
  wsdStatInit;
  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
  assert( op>=0 && op<ArraySize(statMutex) );
  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                           : sqlite3MallocMutex()) );

References ArraySize, sqlite3_mutex_held(), sqlite3MallocMutex(), sqlite3Pcache1Mutex(), statMutex, wsdStat, and wsdStatInit.

Referenced by mallocWithAlarm(), and pcache1Alloc().

◆ sqlite3StatusValue()

SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue ( int op )

Definition at line 21382 of file sqlite3.c.

                                                       {
  wsdStatInit;
  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );

References ArraySize, sqlite3_mutex_held(), sqlite3MallocMutex(), sqlite3Pcache1Mutex(), statMutex, wsdStat, and wsdStatInit.

Referenced by mallocWithAlarm(), and sqlite3_soft_heap_limit64().

◆ sqlite3Step()

static int sqlite3Step ( Vdbe * p )

static

Definition at line 83596 of file sqlite3.c.

                               {
  sqlite3 *db;
  int rc;
 
  assert(p);
  if( p->magic!=VDBE_MAGIC_RUN ){
    /* We used to require that sqlite3_reset() be called before retrying
    ** sqlite3_step() after any error or after SQLITE_DONE.  But beginning
    ** with version 3.7.0, we changed this so that sqlite3_reset() would
    ** be called automatically instead of throwing the SQLITE_MISUSE error.
    ** This "automatic-reset" change is not technically an incompatibility,
    ** since any application that receives an SQLITE_MISUSE is broken by
    ** definition.
    **
    ** Nevertheless, some published applications that were originally written
    ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
    ** returns, and those were broken by the automatic-reset change.  As a
    ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
    ** legacy behavior of returning SQLITE_MISUSE for cases where the
    ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
    ** or SQLITE_BUSY error.
    */
#ifdef SQLITE_OMIT_AUTORESET
    if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
      sqlite3_reset((sqlite3_stmt*)p);
    }else{
      return SQLITE_MISUSE_BKPT;
    }
#else
    sqlite3_reset((sqlite3_stmt*)p);
#endif
  }
 
  /* Check that malloc() has not failed. If it has, return early. */
  db = p->db;
  if( db->mallocFailed ){
    p->rc = SQLITE_NOMEM;
    return SQLITE_NOMEM_BKPT;
  }
 
  if( p->pc<0 && p->expired ){
    p->rc = SQLITE_SCHEMA;
    rc = SQLITE_ERROR;
    if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
      /* If this statement was prepared using saved SQL and an
      ** error has occurred, then return the error code in p->rc to the
      ** caller. Set the error code in the database handle to the same value.
      */
      rc = sqlite3VdbeTransferError(p);
    }
    goto end_of_step;
  }
  if( p->pc<0 ){
    /* If there are no other statements currently running, then
    ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
    ** from interrupting a statement that has not yet started.
    */
    if( db->nVdbeActive==0 ){
      AtomicStore(&db->u1.isInterrupted, 0);
    }
 
    assert( db->nVdbeWrite>0 || db->autoCommit==0
        || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
    );
 
#ifndef SQLITE_OMIT_TRACE
    if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
        && !db->init.busy && p->zSql ){
      sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
    }else{
      assert( p->startTime==0 );
    }
#endif
 
    db->nVdbeActive++;
    if( p->readOnly==0 ) db->nVdbeWrite++;
    if( p->bIsReader ) db->nVdbeRead++;
    p->pc = 0;
  }
#ifdef SQLITE_DEBUG
  p->rcApp = SQLITE_OK;
#endif
#ifndef SQLITE_OMIT_EXPLAIN
  if( p->explain ){
    rc = sqlite3VdbeList(p);
  }else
#endif /* SQLITE_OMIT_EXPLAIN */
  {
    db->nVdbeExec++;
    rc = sqlite3VdbeExec(p);
    db->nVdbeExec--;
  }
 
  if( rc!=SQLITE_ROW ){
#ifndef SQLITE_OMIT_TRACE
    /* If the statement completed successfully, invoke the profile callback */
    checkProfileCallback(db, p);
#endif
 
    if( rc==SQLITE_DONE && db->autoCommit ){
      assert( p->rc==SQLITE_OK );
      p->rc = doWalCallbacks(db);
      if( p->rc!=SQLITE_OK ){
        rc = SQLITE_ERROR;
      }
    }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
      /* If this statement was prepared using saved SQL and an
      ** error has occurred, then return the error code in p->rc to the
      ** caller. Set the error code in the database handle to the same value.
      */
      rc = sqlite3VdbeTransferError(p);
    }
  }
 
  db->errCode = rc;
  if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
    p->rc = SQLITE_NOMEM_BKPT;
    if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc;
  }
end_of_step:
  /* There are only a limited number of result codes allowed from the
  ** statements prepared using the legacy sqlite3_prepare() interface */

References AtomicStore, sqlite3::autoCommit, Vdbe::bIsReader, sqlite3::sqlite3InitInfo::busy, checkProfileCallback, Vdbe::db, doWalCallbacks(), sqlite3::errCode, sqlite3::errMask, Vdbe::expired, Vdbe::explain, sqlite3::init, sqlite3::isInterrupted, Vdbe::magic, sqlite3::mallocFailed, sqlite3::mTrace, sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, sqlite3::nVdbeActive, sqlite3::nVdbeExec, sqlite3::nVdbeRead, sqlite3::nVdbeWrite, Vdbe::pc, Vdbe::prepFlags, sqlite3::pVfs, Vdbe::rc, Vdbe::readOnly, sqlite3_reset(), sqlite3ApiExit(), sqlite3OsCurrentTimeInt64(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3VdbeTransferError(), SQLITE_BUSY, SQLITE_DONE, SQLITE_ERROR, SQLITE_LOCKED, SQLITE_MISUSE, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_PREPARE_SAVESQL, SQLITE_ROW, SQLITE_SCHEMA, SQLITE_TRACE_PROFILE, SQLITE_TRACE_XPROFILE, Vdbe::startTime, sqlite3::u1, VDBE_MAGIC_RUN, and Vdbe::zSql.

Referenced by sqlite3_step().

◆ sqlite3StmtCurrentTime()

SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime ( sqlite3_context * p )

Definition at line 83825 of file sqlite3.c.

                                                                       {
  int rc;
#ifndef SQLITE_ENABLE_STAT4
  sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
  assert( p->pVdbe!=0 );
#else
  sqlite3_int64 iTime = 0;
  sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
#endif

References sqlite3_value::db, Vdbe::iCurrentTime, sqlite3_context::pOut, sqlite3_context::pVdbe, sqlite3::pVfs, and sqlite3OsCurrentTimeInt64().

Referenced by setDateTimeToCurrent().

◆ sqlite3StorageColumnToTable()

SQLITE_PRIVATE i16 sqlite3StorageColumnToTable	(	Table *	pTab,
		i16	iCol )

Definition at line 111342 of file sqlite3.c.

                                                                     {
  if( pTab->tabFlags & TF_HasVirtual ){
    int i;

References Table::aCol, COLFLAG_VIRTUAL, Column::colFlags, Table::tabFlags, and TF_HasVirtual.

Referenced by sqlite3WhereEnd().

◆ sqlite3StrAccumEnlarge()

static int sqlite3StrAccumEnlarge	(	StrAccum *	p,
		int	N )

static

Definition at line 29045 of file sqlite3.c.

                                                     {
  char *zNew;
  assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
  if( p->accError ){
    testcase(p->accError==SQLITE_TOOBIG);
    testcase(p->accError==SQLITE_NOMEM);
    return 0;
  }
  if( p->mxAlloc==0 ){
    setStrAccumError(p, SQLITE_TOOBIG);
    return p->nAlloc - p->nChar - 1;
  }else{
    char *zOld = isMalloced(p) ? p->zText : 0;
    i64 szNew = p->nChar;
    szNew += N + 1;
    if( szNew+p->nChar<=p->mxAlloc ){
      /* Force exponential buffer size growth as long as it does not overflow,
      ** to avoid having to call this routine too often */
      szNew += p->nChar;
    }
    if( szNew > p->mxAlloc ){
      sqlite3_str_reset(p);
      setStrAccumError(p, SQLITE_TOOBIG);
      return 0;
    }else{
      p->nAlloc = (int)szNew;
    }
    if( p->db ){
      zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
    }else{
      zNew = sqlite3Realloc(zOld, p->nAlloc);
    }
    if( zNew ){
      assert( p->zText!=0 || p->nChar==0 );
      if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
      p->zText = zNew;
      p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
      p->printfFlags |= SQLITE_PRINTF_MALLOCED;
    }else{
      sqlite3_str_reset(p);

References sqlite3_str::accError, sqlite3_str::db, isMalloced, sqlite3_str::mxAlloc, sqlite3_str::nAlloc, sqlite3_str::nChar, sqlite3_str::printfFlags, setStrAccumError(), sqlite3_str_reset(), sqlite3DbMallocSize(), sqlite3DbRealloc(), sqlite3Realloc(), SQLITE_NOMEM, SQLITE_PRINTF_MALLOCED, SQLITE_TOOBIG, testcase, and sqlite3_str::zText.

Referenced by enlargeAndAppend().

◆ sqlite3StrAccumFinish()

SQLITE_PRIVATE char * sqlite3StrAccumFinish ( StrAccum * p )

Definition at line 29163 of file sqlite3.c.

       {
    setStrAccumError(p, SQLITE_NOMEM);
  }
  p->zText = zText;
  return zText;
}
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    p->zText[p->nChar] = 0;

Referenced by sqlite3BtreeIntegrityCheck(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), sqlite3VdbeMemTranslate(), and sqlite3WhereExplainOneScan().

◆ sqlite3StrAccumInit()

SQLITE_PRIVATE void sqlite3StrAccumInit	(	StrAccum *	p,
		sqlite3 *	db,
		char *	zBase,
		int	n,
		int	mx )

Definition at line 29240 of file sqlite3.c.

    :     Size of zBase in bytes.  If total space requirements never exceed
**        n then no memory allocations ever occur.
** mx:    Maximum number of bytes to accumulate.  If mx==0 then no memory
**        allocations will ever occur.
*/
SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
  p->zText = zBase;
  p->db = db;

References sqlite3_str::db, sqlite3_str::mxAlloc, sqlite3_str::nAlloc, and sqlite3_str::zText.

Referenced by renderLogMsg(), sqlite3BtreeIntegrityCheck(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), sqlite3VdbeMemTranslate(), sqlite3WhereExplainOneScan(), and vdbeMemRenderNum().

◆ sqlite3StrICmp()

SQLITE_PRIVATE int sqlite3StrICmp	(	const char *	zLeft,
		const char *	zRight )

Definition at line 31468 of file sqlite3.c.

                       : 0;
  }else if( zRight==0 ){
    return 1;
  }
  return sqlite3StrICmp(zLeft, zRight);
}
SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
  unsigned char *a, *b;
  int c, x;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  for(;;){
    c = *a;
    x = *b;
    if( c==x ){
      if( c==0 ) break;
    }else{
      c = (int)UpperToLower[c] - (int)UpperToLower[x];
      if( c ) break;

Referenced by collationMatch(), findElementWithHash(), findIndexCol(), fkParentIsModified(), getAutoVacuum(), getLockingMode(), getTempStore(), isAuxiliaryVtabOperator(), isDupColumn(), lookupName(), minMaxQuery(), nameInUsingClause(), parseDateOrTime(), searchWith(), selectExpander(), sqlite3_table_column_metadata(), sqlite3AddPrimaryKey(), sqlite3AlterRenameColumn(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3ExprCompare(), sqlite3FindInIndex(), sqlite3FindTable(), sqlite3FkLocateIndex(), sqlite3IndexedByLookup(), sqlite3Insert(), sqlite3IsTrueOrFalse(), sqlite3MatchEName(), sqlite3Pragma(), sqlite3TriggerList(), sqlite3Update(), sqlite3VdbeExec(), sqlite3WithAdd(), whereIndexExprTrans(), wherePathSatisfiesOrderBy(), whereRangeVectorLen(), whereScanNext(), and withExpand().

◆ sqlite3StrIHash()

SQLITE_PRIVATE u8 sqlite3StrIHash ( const char * z )

Definition at line 31503 of file sqlite3.c.

                 : UpperToLower[*a] - UpperToLower[*b];
}
 
/*
** Compute an 8-bit hash on a string that is insensitive to case differences
*/
SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){
  u8 h = 0;
  if( z==0 ) return 0;

Referenced by lookupName(), sqlite3AddColumn(), sqlite3AlterBeginAddColumn(), and sqlite3ColumnsFromExprList().

◆ sqlite3StringToId()

static void sqlite3StringToId ( Expr * p )

static

Definition at line 111892 of file sqlite3.c.

111898 {

References Expr::op, Expr::pLeft, TK_COLLATE, TK_ID, and TK_STRING.

Referenced by sqlite3AddPrimaryKey(), and sqlite3CreateIndex().

◆ sqlite3Strlen30()

SQLITE_PRIVATE int sqlite3Strlen30 ( const char * z )

Definition at line 31259 of file sqlite3.c.

Referenced by codeReal(), createTableStmt(), exprAnalyze(), exprDup(), exprProbability(), findCollSeqEntry(), findCreateFileMode(), fkActionTrigger(), generateSortTail(), getSafetyLevel(), pager_delsuper(), parseDateOrTime(), parseModifier(), renameEditSql(), renameParseSql(), resolveExprStep(), selectInnerLoop(), sqlite3_compileoption_used(), sqlite3_filename_wal(), sqlite3_get_table_cb(), sqlite3AddColumn(), sqlite3BtreeOpen(), sqlite3ColumnsFromExprList(), sqlite3CreateForeignKey(), sqlite3CreateFunc(), sqlite3CreateIndex(), sqlite3DecOrHexToI64(), sqlite3ExprAssignVarNumber(), sqlite3ExprCodeTarget(), sqlite3FindFunction(), sqlite3IsShadowTableOf(), sqlite3LoadExtension(), sqlite3PagerOpen(), sqlite3ParseUri(), sqlite3Pragma(), sqlite3RegisterBuiltinFunctions(), sqlite3RunParser(), sqlite3SelectAddColumnTypeAndCollation(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VtabCreateModule(), sqlite3VtabOverloadFunction(), statGet(), strftimeFunc(), unixFullPathname(), valueFromExpr(), vdbeCommit(), and vtabCallConstructor().

◆ sqlite3SubInt64()

SQLITE_PRIVATE int sqlite3SubInt64	(	i64 *	pA,
		i64	iB )

Definition at line 32599 of file sqlite3.c.

                                                   {
#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
  return __builtin_sub_overflow(*pA, iB, pA);
#else
  testcase( iB==SMALLEST_INT64+1 );
  if( iB==SMALLEST_INT64 ){
    testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
    if( (*pA)>=0 ) return 1;
    *pA -= iB;

Referenced by sqlite3VdbeExec().

◆ sqlite3SubselectError()

SQLITE_PRIVATE void sqlite3SubselectError	(	Parse *	pParse,
		int	nActual,
		int	nExpect )

Definition at line 102484 of file sqlite3.c.

References Parse::nErr, and sqlite3ErrorMsg().

Referenced by sqlite3ExprCheckIN(), sqlite3ExprCodeTarget(), and sqlite3VectorErrorMsg().

◆ sqlite3SystemError()

SQLITE_PRIVATE void sqlite3SystemError	(	sqlite3 *	db,
		int	rc )

Definition at line 31301 of file sqlite3.c.

31307 {

Referenced by sqlite3ErrorFinish(), sqlite3ErrorWithMsg(), and sqlite3VdbeExec().

◆ sqlite3TableAffinity()

SQLITE_PRIVATE void sqlite3TableAffinity	(	Vdbe *	v,
		Table *	pTab,
		int	iReg )

Definition at line 120678 of file sqlite3.c.

                                                                        {
  int i, j;
  char *zColAff = pTab->zColAff;
  if( zColAff==0 ){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
      sqlite3OomFault(db);
      return;
    }
 
    for(i=j=0; i<pTab->nCol; i++){
      assert( pTab->aCol[i].affinity!=0 );
      if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
        zColAff[j++] = pTab->aCol[i].affinity;
      }
    }
    do{
      zColAff[j--] = 0;
    }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB );
    pTab->zColAff = zColAff;
  }
  assert( zColAff!=0 );
  i = sqlite3Strlen30NN(zColAff);
  if( i ){
    if( iReg ){

References Table::aCol, Column::affinity, COLFLAG_VIRTUAL, Column::colFlags, Table::nCol, OP_Affinity, sqlite3DbMallocRaw(), sqlite3OomFault(), sqlite3Strlen30NN, sqlite3VdbeAddOp4(), sqlite3VdbeChangeP4(), sqlite3VdbeDb(), SQLITE_AFF_BLOB, and Table::zColAff.

Referenced by sqlite3ComputeGeneratedColumns(), sqlite3EndTable(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3TableColumnAffinity()

SQLITE_PRIVATE char sqlite3TableColumnAffinity	(	Table *	pTab,
		int	iCol )

Definition at line 99732 of file sqlite3.c.

Referenced by sqlite3ExprAffinity(), sqlite3ExprCodeTarget(), sqlite3FindInIndex(), and whereRangeVectorLen().

◆ sqlite3TableColumnToIndex()

SQLITE_PRIVATE i16 sqlite3TableColumnToIndex	(	Index *	pIdx,
		i16	iCol )

Definition at line 111322 of file sqlite3.c.

111328 {

References Index::aiColumn, and Index::nColumn.

Referenced by analyzeOneTable(), exprIdxCover(), sqlite3CreateIndex(), sqlite3GenerateConstraintChecks(), sqlite3UpsertDoUpdate(), and sqlite3WhereEnd().

◆ sqlite3TableColumnToStorage()

SQLITE_PRIVATE i16 sqlite3TableColumnToStorage	(	Table *	pTab,
		i16	iCol )

Definition at line 111390 of file sqlite3.c.

                                                                     {
  int i;
  i16 n;
  assert( iCol<pTab->nCol );
  if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
  for(i=0, n=0; i<iCol; i++){
    if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
  }
  if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
    /* iCol is a virtual column itself */

References Table::aCol, COLFLAG_VIRTUAL, Column::colFlags, Table::nNVCol, Table::tabFlags, and TF_HasVirtual.

Referenced by codeDeferredSeek(), exprTableRegister(), fkLookupParent(), lookupName(), sqlite3ComputeGeneratedColumns(), sqlite3ExprCodeTarget(), sqlite3FkCheck(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3TableLock()

SQLITE_PRIVATE void sqlite3TableLock	(	Parse *	pParse,
		int	iDb,
		Pgno	iTab,
		u8	isWriteLock,
		const char *	zName )

Definition at line 110437 of file sqlite3.c.

 {
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i;
  int nBytes;
  TableLock *p;
  assert( iDb>=0 );
 
  if( iDb==1 ) return;
  if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
  for(i=0; i<pToplevel->nTableLock; i++){
    p = &pToplevel->aTableLock[i];
    if( p->iDb==iDb && p->iTab==iTab ){
      p->isWriteLock = (p->isWriteLock || isWriteLock);
      return;
    }
  }
 
  nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
  pToplevel->aTableLock =
      sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
  if( pToplevel->aTableLock ){
    p = &pToplevel->aTableLock[pToplevel->nTableLock++];
    p->iDb = iDb;
    p->iTab = iTab;
    p->isWriteLock = isWriteLock;

References sqlite3::aDb, Parse::aTableLock, Parse::db, TableLock::iDb, TableLock::isWriteLock, TableLock::iTab, Parse::nTableLock, Db::pBt, sqlite3BtreeSharable(), sqlite3DbReallocOrFree(), sqlite3OomFault(), sqlite3ParseToplevel, TableLock::zLockName, and zName.

Referenced by analyzeOneTable(), openStatTable(), sqlite3DeleteFrom(), sqlite3FindInIndex(), sqlite3FkCheck(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3WhereBegin(), and xferOptimization().

◆ sqlite3TempInMemory()

SQLITE_PRIVATE int sqlite3TempInMemory ( const sqlite3 * db )

Definition at line 163462 of file sqlite3.c.

                                                         {
#if SQLITE_TEMP_STORE==1
  return ( db->temp_store==2 );
#endif
#if SQLITE_TEMP_STORE==2
  return ( db->temp_store!=1 );
#endif
#if SQLITE_TEMP_STORE==3
  UNUSED_PARAMETER(db);
  return 1;

References sqlite3::temp_store, and UNUSED_PARAMETER.

Referenced by sqlite3BtreeBeginTrans(), sqlite3BtreeOpen(), and sqlite3VdbeSorterInit().

◆ sqlite3TestExtInit()

static int sqlite3TestExtInit ( sqlite3 * db )

static

Definition at line 161027 of file sqlite3.c.

References sqlite3FaultSim().

◆ sqlite3ThreadCreate() [1/2]

SQLITE_PRIVATE int sqlite3ThreadCreate	(	SQLiteThread **	,
		void *	)(void ,
		void *	)

◆ sqlite3ThreadCreate() [2/2]

SQLITE_PRIVATE int sqlite3ThreadCreate	(	SQLiteThread **	ppThread,
		void ()(void *)	xTask,
		void *	pIn )

Definition at line 30416 of file sqlite3.c.

 {
  SQLiteThread *p;
  int rc;
 
  assert( ppThread!=0 );
  assert( xTask!=0 );
  /* This routine is never used in single-threaded mode */
  assert( sqlite3GlobalConfig.bCoreMutex!=0 );
 
  *ppThread = 0;
  p = sqlite3Malloc(sizeof(*p));
  if( p==0 ) return SQLITE_NOMEM_BKPT;
  memset(p, 0, sizeof(*p));
  p->xTask = xTask;
  p->pIn = pIn;
  /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a
  ** function that returns SQLITE_ERROR when passed the argument 200, that
  ** forces worker threads to run sequentially and deterministically
  ** for testing purposes. */
  if( sqlite3FaultSim(200) ){
    rc = 1;
  }else{
    rc = pthread_create(&p->tid, 0, xTask, pIn);
  }
  if( rc ){

◆ sqlite3ThreadJoin()

SQLITE_PRIVATE int sqlite3ThreadJoin	(	SQLiteThread *	p,
		void **	ppOut )

Definition at line 30453 of file sqlite3.c.

                                                                   {
  int rc;
 
  assert( ppOut!=0 );
  if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT;
  if( p->done ){
    *ppOut = p->pOut;
    rc = SQLITE_OK;

Referenced by vdbeSorterJoinThread().

◆ sqlite3TokenInit()

SQLITE_PRIVATE void sqlite3TokenInit	(	Token *	p,
		char *	z )

Definition at line 31442 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), fkActionTrigger(), selectExpander(), and sqlite3CreateIndex().

◆ sqlite3TransferBindings()

SQLITE_PRIVATE int sqlite3TransferBindings	(	sqlite3_stmt *	pFromStmt,
		sqlite3_stmt *	pToStmt )

Definition at line 84595 of file sqlite3.c.

                                                                                          {
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  int i;
  assert( pTo->db==pFrom->db );
  assert( pTo->nVar==pFrom->nVar );
  sqlite3_mutex_enter(pTo->db->mutex);

Referenced by sqlite3_transfer_bindings(), and sqlite3Reprepare().

◆ sqlite3TriggerColmask()

SQLITE_PRIVATE u32 sqlite3TriggerColmask	(	Parse *	pParse,
		Trigger *	pTrigger,
		ExprList *	pChanges,
		int	isNew,
		int	tr_tm,
		Table *	pTab,
		int	orconf )

Definition at line 137563 of file sqlite3.c.

 {
  const int op = pChanges ? TK_UPDATE : TK_DELETE;
  u32 mask = 0;
  Trigger *p;
 
  assert( isNew==1 || isNew==0 );
  for(p=pTrigger; p; p=p->pNext){
    if( p->op==op && (tr_tm&p->tr_tm)
     && checkColumnOverlap(p->pColumns,pChanges)
    ){
      TriggerPrg *pPrg;
      pPrg = getRowTrigger(pParse, p, pTab, orconf);
      if( pPrg ){
        mask |= pPrg->aColmask[isNew];

References TriggerPrg::aColmask, checkColumnOverlap(), getRowTrigger(), mask, Trigger::op, Trigger::pColumns, Trigger::pNext, TK_DELETE, TK_UPDATE, and Trigger::tr_tm.

Referenced by sqlite3GenerateRowDelete(), and sqlite3Update().

◆ sqlite3TriggerDeleteStep()

SQLITE_PRIVATE TriggerStep * sqlite3TriggerDeleteStep	(	Parse *	pParse,
		Token *	pTableName,
		Expr *	pWhere,
		const char *	zStart,
		const char *	zEnd )

Definition at line 136911 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;
 
  pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pWhere = pWhere;
      pWhere = 0;
    }else{
      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);

References Parse::db, EXPRDUP_REDUCE, IN_RENAME_OBJECT, OE_Default, TriggerStep::orconf, TriggerStep::pWhere, sqlite3ExprDelete(), sqlite3ExprDup(), TK_DELETE, and triggerStepAllocate().

Referenced by yy_reduce().

◆ sqlite3TriggerInsertStep()

SQLITE_PRIVATE TriggerStep * sqlite3TriggerInsertStep	(	Parse *	pParse,
		Token *	pTableName,
		IdList *	pColumn,
		Select *	pSelect,
		u8	orconf,
		Upsert *	pUpsert,
		const char *	zStart,
		const char *	zEnd )

Definition at line 136826 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;
 
  assert(pSelect != 0 || db->mallocFailed);
 
  pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pSelect = pSelect;
      pSelect = 0;
    }else{
      pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
    }
    pTriggerStep->pIdList = pColumn;
    pTriggerStep->pUpsert = pUpsert;
    pTriggerStep->orconf = orconf;
    if( pUpsert ){
      sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
    }
  }else{
    testcase( pColumn );
    sqlite3IdListDelete(db, pColumn);
    testcase( pUpsert );

References Parse::db, EXPRDUP_REDUCE, IN_RENAME_OBJECT, sqlite3::mallocFailed, TriggerStep::orconf, TriggerStep::pIdList, TriggerStep::pSelect, TriggerStep::pUpsert, Upsert::pUpsertTarget, sqlite3HasExplicitNulls(), sqlite3IdListDelete(), sqlite3SelectDelete(), sqlite3SelectDup(), sqlite3UpsertDelete(), testcase, TK_INSERT, and triggerStepAllocate().

Referenced by yy_reduce().

◆ sqlite3TriggerList()

SQLITE_PRIVATE Trigger * sqlite3TriggerList	(	Parse *	pParse,
		Table *	pTab )

Definition at line 136434 of file sqlite3.c.

                          :  This routine returns a list of all triggers
** that fire off of pTab.  The list will include any TEMP triggers on
** pTab as well as the triggers lised in pTab->pTrigger.
*/
SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
  Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
  Trigger *pList = 0;                  /* List of triggers to return */
 
  if( pParse->disableTriggers ){
    return 0;
  }
 
  if( pTmpSchema!=pTab->pSchema ){
    HashElem *p;
    assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
    for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){
      Trigger *pTrig = (Trigger *)sqliteHashData(p);
      if( pTrig->pTabSchema==pTab->pSchema
       && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
      ){
        pTrig->pNext = (pList ? pList : pTab->pTrigger);
        pList = pTrig;

References sqlite3::aDb, Parse::db, Parse::disableTriggers, Trigger::pNext, Db::pSchema, Table::pSchema, Trigger::pTabSchema, Table::pTrigger, sqlite3StrICmp(), sqliteHashData, sqliteHashFirst, sqliteHashNext, Trigger::table, Schema::trigHash, and Table::zName.

Referenced by sqlite3TriggersExist(), and xferOptimization().

◆ sqlite3TriggerSelectStep()

SQLITE_PRIVATE TriggerStep * sqlite3TriggerSelectStep	(	sqlite3 *	db,
		Select *	pSelect,
		const char *	zStart,
		const char *	zEnd )

Definition at line 136770 of file sqlite3.c.

 {
  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
  if( pTriggerStep==0 ) {
    sqlite3SelectDelete(db, pSelect);
    return 0;
  }

References OE_Default, TriggerStep::op, TriggerStep::orconf, TriggerStep::pSelect, sqlite3DbMallocZero(), sqlite3SelectDelete(), TK_SELECT, triggerSpanDup(), and TriggerStep::zSpan.

Referenced by yy_reduce().

◆ sqlite3TriggersExist()

SQLITE_PRIVATE Trigger * sqlite3TriggersExist	(	Parse *	pParse,
		Table *	pTab,
		int	op,
		ExprList *	pChanges,
		int *	pMask )

Definition at line 137093 of file sqlite3.c.

 {
  int mask = 0;
  Trigger *pList = 0;
  Trigger *p;
 
  if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
    pList = sqlite3TriggerList(pParse, pTab);
  }
  assert( pList==0 || IsVirtual(pTab)==0 );
  for(p=pList; p; p=p->pNext){
    if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
      mask |= p->tr_tm;
    }

References checkColumnOverlap(), Parse::db, sqlite3::flags, IsVirtual, mask, Trigger::op, Trigger::pColumns, Trigger::pNext, sqlite3TriggerList(), SQLITE_EnableTrigger, and Trigger::tr_tm.

Referenced by sqlite3DeleteFrom(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3TriggerStepSrc()

SQLITE_PRIVATE SrcList * sqlite3TriggerStepSrc	(	Parse *	pParse,
		TriggerStep *	pStep )

Definition at line 137129 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  SrcList *pSrc;                  /* SrcList to be returned */
  char *zName = sqlite3DbStrDup(db, pStep->zTarget);
  pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
  assert( pSrc==0 || pSrc->nSrc==1 );
  assert( zName || pSrc==0 );
  if( pSrc ){
    Schema *pSchema = pStep->pTrig->pSchema;
    pSrc->a[0].zName = zName;
    if( pSchema!=db->aDb[1].pSchema ){
      pSrc->a[0].pSchema = pSchema;
    }
    if( pStep->pFrom ){
      SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
      pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup);

References SrcList::a, sqlite3::aDb, Parse::db, SrcList::nSrc, TriggerStep::pFrom, Db::pSchema, SrcList::SrcList_item::pSchema, Trigger::pSchema, TriggerStep::pTrig, sqlite3DbFree(), sqlite3DbStrDup(), sqlite3SrcListAppend(), sqlite3SrcListAppendList(), sqlite3SrcListDup(), SrcList::SrcList_item::zName, zName, and TriggerStep::zTarget.

Referenced by renameResolveTrigger().

◆ sqlite3TriggerUpdateStep()

SQLITE_PRIVATE TriggerStep * sqlite3TriggerUpdateStep	(	Parse *	pParse,
		Token *	pTableName,
		SrcList *	pFrom,
		ExprList *	pEList,
		Expr *	pWhere,
		u8	orconf,
		const char *	zStart,
		const char *	zEnd )

Definition at line 136871 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;
 
  pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pExprList = pEList;
      pTriggerStep->pWhere = pWhere;
      pTriggerStep->pFrom = pFrom;
      pEList = 0;
      pWhere = 0;
      pFrom = 0;
    }else{
      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
      pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
    }
    pTriggerStep->orconf = orconf;

References Parse::db, EXPRDUP_REDUCE, IN_RENAME_OBJECT, TriggerStep::orconf, TriggerStep::pExprList, TriggerStep::pFrom, TriggerStep::pWhere, sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListDelete(), sqlite3ExprListDup(), sqlite3SrcListDelete(), sqlite3SrcListDup(), TK_UPDATE, and triggerStepAllocate().

Referenced by yy_reduce().

◆ sqlite3TwoPartName()

SQLITE_PRIVATE int sqlite3TwoPartName	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		Token **	pUnqual )

Definition at line 111217 of file sqlite3.c.

 {
  int iDb;                    /* Database holding the object */
  sqlite3 *db = pParse->db;
 
  assert( pName2!=0 );
  if( pName2->n>0 ){
    if( db->init.busy ) {
      sqlite3ErrorMsg(pParse, "corrupt database");
      return -1;
    }
    *pUnqual = pName2;
    iDb = sqlite3FindDb(db, pName1);
    if( iDb<0 ){
      sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
      return -1;
    }
  }else{
    assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT

References sqlite3::sqlite3InitInfo::busy, Parse::db, DBFLAG_Vacuum, sqlite3::sqlite3InitInfo::iDb, IN_RENAME_OBJECT, sqlite3::init, sqlite3::mDbFlags, Token::n, sqlite3ErrorMsg(), and sqlite3FindDb().

Referenced by sqlite3Analyze(), sqlite3BeginTrigger(), sqlite3CreateIndex(), sqlite3Pragma(), sqlite3Reindex(), sqlite3StartTable(), and sqlite3Vacuum().

◆ sqlite3UniqueConstraint()

SQLITE_PRIVATE void sqlite3UniqueConstraint	(	Parse *	pParse,
		int	onError,
		Index *	pIdx )

Definition at line 115234 of file sqlite3.c.

 {
  char *zErr;
  int j;
  StrAccum errMsg;
  Table *pTab = pIdx->pTable;
 
  sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
                      pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
  if( pIdx->aColExpr ){
    sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
  }else{
    for(j=0; j<pIdx->nKeyCol; j++){
      char *zCol;
      assert( pIdx->aiColumn[j]>=0 );
      zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
      if( j ) sqlite3_str_append(&errMsg, ", ", 2);
      sqlite3_str_appendall(&errMsg, pTab->zName);
      sqlite3_str_append(&errMsg, ".", 1);
      sqlite3_str_appendall(&errMsg, zCol);
    }
  }

Referenced by sqlite3GenerateConstraintChecks(), and sqlite3RefillIndex().

◆ sqlite3UnlinkAndDeleteIndex()

SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex	(	sqlite3 *	db,
		int	iDb,
		const char *	zIdxName )

Definition at line 110905 of file sqlite3.c.

                                                                                           {
  Index *pIndex;
  Hash *pHash;
 
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  pHash = &db->aDb[iDb].pSchema->idxHash;
  pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
  if( ALWAYS(pIndex) ){
    if( pIndex->pTable->pIndex==pIndex ){
      pIndex->pTable->pIndex = pIndex->pNext;
    }else{
      Index *p;
      /* Justification of ALWAYS();  The index must be on the list of
      ** indices. */
      p = pIndex->pTable->pIndex;
      while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
      if( ALWAYS(p && p->pNext==pIndex) ){
        p->pNext = pIndex->pNext;

References sqlite3::aDb, ALWAYS, DBFLAG_SchemaChange, Schema::idxHash, sqlite3::mDbFlags, Table::pIndex, Index::pNext, Db::pSchema, Index::pTable, sqlite3FreeIndex(), and sqlite3HashInsert().

Referenced by sqlite3VdbeExec().

◆ sqlite3UnlinkAndDeleteTable()

SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable	(	sqlite3 *	db,
		int	iDb,
		const char *	zTabName )

Definition at line 111114 of file sqlite3.c.

                                                                                           {
  Table *p;
  Db *pDb;
 
  assert( db!=0 );
  assert( iDb>=0 && iDb<db->nDb );
  assert( zTabName );
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

References sqlite3::aDb, DBFLAG_SchemaChange, sqlite3::mDbFlags, Db::pSchema, sqlite3DeleteTable(), sqlite3HashInsert(), Schema::tblHash, and testcase.

Referenced by sqlite3VdbeExec().

◆ sqlite3UnlinkAndDeleteTrigger()

SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger	(	sqlite3 *	db,
		int	iDb,
		const char *	zName )

Definition at line 137044 of file sqlite3.c.

                                                                                          {
  Trigger *pTrigger;
  Hash *pHash;
 
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  pHash = &(db->aDb[iDb].pSchema->trigHash);
  pTrigger = sqlite3HashInsert(pHash, zName, 0);
  if( ALWAYS(pTrigger) ){
    if( pTrigger->pSchema==pTrigger->pTabSchema ){
      Table *pTab = tableOfTrigger(pTrigger);
      if( pTab ){
        Trigger **pp;
        for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
          if( *pp==pTrigger ){
            *pp = (*pp)->pNext;
            break;
          }
        }

Referenced by sqlite3VdbeExec().

◆ sqlite3Update()

SQLITE_PRIVATE void sqlite3Update	(	Parse *	pParse,
		SrcList *	pTabList,
		ExprList *	pChanges,
		Expr *	pWhere,
		int	onError,
		ExprList *	pOrderBy,
		Expr *	pLimit,
		Upsert *	pUpsert )

Definition at line 137872 of file sqlite3.c.

 {
  int i, j, k;           /* Loop counters */
  Table *pTab;           /* The table to be updated */
  int addrTop = 0;       /* VDBE instruction address of the start of the loop */
  WhereInfo *pWInfo = 0; /* Information about the WHERE clause */
  Vdbe *v;               /* The virtual database engine */
  Index *pIdx;           /* For looping over indices */
  Index *pPk;            /* The PRIMARY KEY index for WITHOUT ROWID tables */
  int nIdx;              /* Number of indices that need updating */
  int nAllIdx;           /* Total number of indexes */
  int iBaseCur;          /* Base cursor number */
  int iDataCur;          /* Cursor for the canonical data btree */
  int iIdxCur;           /* Cursor for the first index */
  sqlite3 *db;           /* The database structure */
  int *aRegIdx = 0;      /* Registers for to each index and the main table */
  int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
                         ** an expression for the i-th column of the table.
                         ** aXRef[i]==-1 if the i-th column is not changed. */
  u8 *aToOpen;           /* 1 for tables and indices to be opened */
  u8 chngPk;             /* PRIMARY KEY changed in a WITHOUT ROWID table */
  u8 chngRowid;          /* Rowid changed in a normal table */
  u8 chngKey;            /* Either chngPk or chngRowid */
  Expr *pRowidExpr = 0;  /* Expression defining the new record number */
  int iRowidExpr = -1;   /* Index of "rowid=" (or IPK) assignment in pChanges */
  AuthContext sContext;  /* The authorization context */
  NameContext sNC;       /* The name-context to resolve expressions in */
  int iDb;               /* Database containing the table being updated */
  int eOnePass;          /* ONEPASS_XXX value from where.c */
  int hasFK;             /* True if foreign key processing is required */
  int labelBreak;        /* Jump here to break out of UPDATE loop */
  int labelContinue;     /* Jump here to continue next step of UPDATE loop */
  int flags;             /* Flags for sqlite3WhereBegin() */
 
#ifndef SQLITE_OMIT_TRIGGER
  int isView;            /* True when updating a view (INSTEAD OF trigger) */
  Trigger *pTrigger;     /* List of triggers on pTab, if required */
  int tmask;             /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
#endif
  int newmask;           /* Mask of NEW.* columns accessed by BEFORE triggers */
  int iEph = 0;          /* Ephemeral table holding all primary key values */
  int nKey = 0;          /* Number of elements in regKey for WITHOUT ROWID */
  int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
  int addrOpen = 0;      /* Address of OP_OpenEphemeral */
  int iPk = 0;           /* First of nPk cells holding PRIMARY KEY value */
  i16 nPk = 0;           /* Number of components of the PRIMARY KEY */
  int bReplace = 0;      /* True if REPLACE conflict resolution might happen */
  int bFinishSeek = 1;   /* The OP_FinishSeek opcode is needed */
  int nChangeFrom = 0;   /* If there is a FROM, pChanges->nExpr, else 0 */
 
  /* Register Allocations */
  int regRowCount = 0;   /* A count of rows changed */
  int regOldRowid = 0;   /* The old rowid */
  int regNewRowid = 0;   /* The new rowid */
  int regNew = 0;        /* Content of the NEW.* table in triggers */
  int regOld = 0;        /* Content of OLD.* table in triggers */
  int regRowSet = 0;     /* Rowset of rows to be updated */
  int regKey = 0;        /* composite PRIMARY KEY value */
 
  memset(&sContext, 0, sizeof(sContext));
  db = pParse->db;
  if( pParse->nErr || db->mallocFailed ){
    goto update_cleanup;
  }
 
  /* Locate the table which we want to update.
  */
  pTab = sqlite3SrcListLookup(pParse, pTabList);
  if( pTab==0 ) goto update_cleanup;
  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
 
  /* Figure out if we have any triggers and if the table being
  ** updated is a view.
  */
#ifndef SQLITE_OMIT_TRIGGER
  pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
  isView = pTab->pSelect!=0;
  assert( pTrigger || tmask==0 );
#else
# define pTrigger 0
# define isView 0
# define tmask 0
#endif
#ifdef SQLITE_OMIT_VIEW
# undef isView
# define isView 0
#endif
 
  /* If there was a FROM clause, set nChangeFrom to the number of expressions
  ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
  ** clause if this function is being called to generate code for part of
  ** an UPSERT statement.  */
  nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0;
  assert( nChangeFrom==0 || pUpsert==0 );
 
#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
  if( !isView && nChangeFrom==0 ){
    pWhere = sqlite3LimitWhere(
        pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
    );
    pOrderBy = 0;
    pLimit = 0;
  }
#endif
 
  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
    goto update_cleanup;
  }
  if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
    goto update_cleanup;
  }
 
  /* Allocate a cursors for the main database table and for all indices.
  ** The index cursors might not be used, but if they are used they
  ** need to occur right after the database cursor.  So go ahead and
  ** allocate enough space, just in case.
  */
  iBaseCur = iDataCur = pParse->nTab++;
  iIdxCur = iDataCur+1;
  pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
  testcase( pPk!=0 && pPk!=pTab->pIndex );
  for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
    if( pPk==pIdx ){
      iDataCur = pParse->nTab;
    }
    pParse->nTab++;
  }
  if( pUpsert ){
    /* On an UPSERT, reuse the same cursors already opened by INSERT */
    iDataCur = pUpsert->iDataCur;
    iIdxCur = pUpsert->iIdxCur;
    pParse->nTab = iBaseCur;
  }
  pTabList->a[0].iCursor = iDataCur;
 
  /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
  ** Initialize aXRef[] and aToOpen[] to their default values.
  */
  aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
  if( aXRef==0 ) goto update_cleanup;
  aRegIdx = aXRef+pTab->nCol;
  aToOpen = (u8*)(aRegIdx+nIdx+1);
  memset(aToOpen, 1, nIdx+1);
  aToOpen[nIdx+1] = 0;
  for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
 
  /* Initialize the name-context */
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pParse;
  sNC.pSrcList = pTabList;
  sNC.uNC.pUpsert = pUpsert;
  sNC.ncFlags = NC_UUpsert;
 
  /* Begin generating code. */
  v = sqlite3GetVdbe(pParse);
  if( v==0 ) goto update_cleanup;
 
  /* Resolve the column names in all the expressions of the
  ** of the UPDATE statement.  Also find the column index
  ** for each column to be updated in the pChanges array.  For each
  ** column to be updated, make sure we have authorization to change
  ** that column.
  */
  chngRowid = chngPk = 0;
  for(i=0; i<pChanges->nExpr; i++){
    /* If this is an UPDATE with a FROM clause, do not resolve expressions
    ** here. The call to sqlite3Select() below will do that. */
    if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
      goto update_cleanup;
    }
    for(j=0; j<pTab->nCol; j++){
      if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){
        if( j==pTab->iPKey ){
          chngRowid = 1;
          pRowidExpr = pChanges->a[i].pExpr;
          iRowidExpr = i;
        }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
          chngPk = 1;
        }
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
        else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
          testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
          testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
          sqlite3ErrorMsg(pParse,
             "cannot UPDATE generated column \"%s\"",
             pTab->aCol[j].zName);
          goto update_cleanup;
        }
#endif
        aXRef[j] = i;
        break;
      }
    }
    if( j>=pTab->nCol ){
      if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){
        j = -1;
        chngRowid = 1;
        pRowidExpr = pChanges->a[i].pExpr;
        iRowidExpr = i;
      }else{
        sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
        pParse->checkSchema = 1;
        goto update_cleanup;
      }
    }
#ifndef SQLITE_OMIT_AUTHORIZATION
    {
      int rc;
      rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
                            j<0 ? "ROWID" : pTab->aCol[j].zName,
                            db->aDb[iDb].zDbSName);
      if( rc==SQLITE_DENY ){
        goto update_cleanup;
      }else if( rc==SQLITE_IGNORE ){
        aXRef[j] = -1;
      }
    }
#endif
  }
  assert( (chngRowid & chngPk)==0 );
  assert( chngRowid==0 || chngRowid==1 );
  assert( chngPk==0 || chngPk==1 );
  chngKey = chngRowid + chngPk;
 
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  /* Mark generated columns as changing if their generator expressions
  ** reference any changing column.  The actual aXRef[] value for
  ** generated expressions is not used, other than to check to see that it
  ** is non-negative, so the value of aXRef[] for generated columns can be
  ** set to any non-negative number.  We use 99999 so that the value is
  ** obvious when looking at aXRef[] in a symbolic debugger.
  */
  if( pTab->tabFlags & TF_HasGenerated ){
    int bProgress;
    testcase( pTab->tabFlags & TF_HasVirtual );
    testcase( pTab->tabFlags & TF_HasStored );
    do{
      bProgress = 0;
      for(i=0; i<pTab->nCol; i++){
        if( aXRef[i]>=0 ) continue;
        if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
        if( sqlite3ExprReferencesUpdatedColumn(pTab->aCol[i].pDflt,
                                               aXRef, chngRowid) ){
          aXRef[i] = 99999;
          bProgress = 1;
        }
      }
    }while( bProgress );
  }
#endif
 
  /* The SET expressions are not actually used inside the WHERE loop.
  ** So reset the colUsed mask. Unless this is a virtual table. In that
  ** case, set all bits of the colUsed mask (to ensure that the virtual
  ** table implementation makes all columns available).
  */
  pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
 
  hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
 
  /* There is one entry in the aRegIdx[] array for each index on the table
  ** being updated.  Fill in aRegIdx[] with a register number that will hold
  ** the key for accessing each index.
  */
  if( onError==OE_Replace ) bReplace = 1;
  for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
    int reg;
    if( chngKey || hasFK>1 || pIdx==pPk
     || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
    ){
      reg = ++pParse->nMem;
      pParse->nMem += pIdx->nColumn;
    }else{
      reg = 0;
      for(i=0; i<pIdx->nKeyCol; i++){
        if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
          reg = ++pParse->nMem;
          pParse->nMem += pIdx->nColumn;
          if( onError==OE_Default && pIdx->onError==OE_Replace ){
            bReplace = 1;
          }
          break;
        }
      }
    }
    if( reg==0 ) aToOpen[nAllIdx+1] = 0;
    aRegIdx[nAllIdx] = reg;
  }
  aRegIdx[nAllIdx] = ++pParse->nMem;  /* Register storing the table record */
  if( bReplace ){
    /* If REPLACE conflict resolution might be invoked, open cursors on all
    ** indexes in case they are needed to delete records.  */
    memset(aToOpen, 1, nIdx+1);
  }
 
  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
  sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
 
  /* Allocate required registers. */
  if( !IsVirtual(pTab) ){
    /* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
    ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
    ** reallocated.  aRegIdx[nAllIdx] is the register in which the main
    ** table record is written.  regRowSet holds the RowSet for the
    ** two-pass update algorithm. */
    assert( aRegIdx[nAllIdx]==pParse->nMem );
    regRowSet = aRegIdx[nAllIdx];
    regOldRowid = regNewRowid = ++pParse->nMem;
    if( chngPk || pTrigger || hasFK ){
      regOld = pParse->nMem + 1;
      pParse->nMem += pTab->nCol;
    }
    if( chngKey || pTrigger || hasFK ){
      regNewRowid = ++pParse->nMem;
    }
    regNew = pParse->nMem + 1;
    pParse->nMem += pTab->nCol;
  }
 
  /* Start the view context. */
  if( isView ){
    sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
  }
 
  /* If we are trying to update a view, realize that view into
  ** an ephemeral table.
  */
#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
  if( nChangeFrom==0 && isView ){
    sqlite3MaterializeView(pParse, pTab,
        pWhere, pOrderBy, pLimit, iDataCur
    );
    pOrderBy = 0;
    pLimit = 0;
  }
#endif
 
  /* Resolve the column names in all the expressions in the
  ** WHERE clause.
  */
  if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){
    goto update_cleanup;
  }
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Virtual tables must be handled separately */
  if( IsVirtual(pTab) ){
    updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
                       pWhere, onError);
    goto update_cleanup;
  }
#endif
 
  /* Jump to labelBreak to abandon further processing of this UPDATE */
  labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse);
 
  /* Not an UPSERT.  Normal processing.  Begin by
  ** initialize the count of updated rows */
  if( (db->flags&SQLITE_CountRows)!=0
   && !pParse->pTriggerTab
   && !pParse->nested
   && pUpsert==0
  ){
    regRowCount = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
  }
 
  if( nChangeFrom==0 && HasRowid(pTab) ){
    sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
  }else{
    assert( pPk!=0 || HasRowid(pTab) );
    nPk = pPk ? pPk->nKeyCol : 0;
    iPk = pParse->nMem+1;
    pParse->nMem += nPk;
    pParse->nMem += nChangeFrom;
    regKey = ++pParse->nMem;
    if( pUpsert==0 ){
      int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
      iEph = pParse->nTab++;
      if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
      addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
      if( pPk ){
        KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
        if( pKeyInfo ){
          pKeyInfo->nAllField = nEphCol;
          sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
        }
      }
      if( nChangeFrom ){
        updateFromSelect(
            pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit
        );
#ifndef SQLITE_OMIT_SUBQUERY
        if( isView ) iDataCur = iEph;
#endif
      }
    }
  }
 
  if( nChangeFrom ){
    sqlite3MultiWrite(pParse);
    eOnePass = ONEPASS_OFF;
    nKey = nPk;
    regKey = iPk;
  }else{
    if( pUpsert ){
      /* If this is an UPSERT, then all cursors have already been opened by
      ** the outer INSERT and the data cursor should be pointing at the row
      ** that is to be updated.  So bypass the code that searches for the
      ** row(s) to be updated.
      */
      pWInfo = 0;
      eOnePass = ONEPASS_SINGLE;
      sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL);
      bFinishSeek = 0;
    }else{
      /* Begin the database scan.
      **
      ** Do not consider a single-pass strategy for a multi-row update if
      ** there are any triggers or foreign keys to process, or rows may
      ** be deleted as a result of REPLACE conflict handling. Any of these
      ** things might disturb a cursor being used to scan through the table
      ** or index, causing a single-pass approach to malfunction.  */
      flags = WHERE_ONEPASS_DESIRED|WHERE_SEEK_UNIQ_TABLE;
      if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
        flags |= WHERE_ONEPASS_MULTIROW;
      }
      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags,iIdxCur);
      if( pWInfo==0 ) goto update_cleanup;
 
      /* A one-pass strategy that might update more than one row may not
      ** be used if any column of the index used for the scan is being
      ** updated. Otherwise, if there is an index on "b", statements like
      ** the following could create an infinite loop:
      **
      **   UPDATE t1 SET b=b+1 WHERE b>?
      **
      ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
      ** strategy that uses an index for which one or more columns are being
      ** updated.  */
      eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
      bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo);
      if( eOnePass!=ONEPASS_SINGLE ){
        sqlite3MultiWrite(pParse);
        if( eOnePass==ONEPASS_MULTI ){
          int iCur = aiCurOnePass[1];
          if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
            eOnePass = ONEPASS_OFF;
          }
          assert( iCur!=iDataCur || !HasRowid(pTab) );
        }
      }
    }
 
    if( HasRowid(pTab) ){
      /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
      ** mode, write the rowid into the FIFO. In either of the one-pass modes,
      ** leave it in register regOldRowid.  */
      sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
      if( eOnePass==ONEPASS_OFF ){
        /* We need to use regRowSet, so reallocate aRegIdx[nAllIdx] */
        aRegIdx[nAllIdx] = ++pParse->nMem;
        sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
      }
    }else{
      /* Read the PK of the current row into an array of registers. In
      ** ONEPASS_OFF mode, serialize the array into a record and store it in
      ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
      ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
      ** is not required) and leave the PK fields in the array of registers.  */
      for(i=0; i<nPk; i++){
        assert( pPk->aiColumn[i]>=0 );
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
                                        pPk->aiColumn[i], iPk+i);
      }
      if( eOnePass ){
        if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
        nKey = nPk;
        regKey = iPk;
      }else{
        sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
                          sqlite3IndexAffinityStr(db, pPk), nPk);
        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
      }
    }
  }
 
  if( pUpsert==0 ){
    if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){
      sqlite3WhereEnd(pWInfo);
    }
 
    if( !isView ){
      int addrOnce = 0;
 
      /* Open every index that needs updating. */
      if( eOnePass!=ONEPASS_OFF ){
        if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
        if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
      }
 
      if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
        addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
      }
      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
                                 aToOpen, 0, 0);
      if( addrOnce ){
        sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
      }
    }
 
    /* Top of the update loop */
    if( eOnePass!=ONEPASS_OFF ){
      if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){
        assert( pPk );
        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
        VdbeCoverage(v);
      }
      if( eOnePass!=ONEPASS_SINGLE ){
        labelContinue = sqlite3VdbeMakeLabel(pParse);
      }
      sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
      VdbeCoverageIf(v, pPk==0);
      VdbeCoverageIf(v, pPk!=0);
    }else if( pPk || nChangeFrom ){
      labelContinue = sqlite3VdbeMakeLabel(pParse);
      sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
      addrTop = sqlite3VdbeCurrentAddr(v);
      if( nChangeFrom ){
        if( !isView ){
          if( pPk ){
            for(i=0; i<nPk; i++){
              sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
            }
            sqlite3VdbeAddOp4Int(
                v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
            ); VdbeCoverage(v);
          }else{
            sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
            sqlite3VdbeAddOp3(
                v, OP_NotExists, iDataCur, labelContinue, regOldRowid
            ); VdbeCoverage(v);
          }
        }
      }else{
        sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
        VdbeCoverage(v);
      }
    }else{
      labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet,labelBreak,
                               regOldRowid);
      VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
      VdbeCoverage(v);
    }
  }
 
  /* If the rowid value will change, set register regNewRowid to
  ** contain the new value. If the rowid is not being modified,
  ** then regNewRowid is the same register as regOldRowid, which is
  ** already populated.  */
  assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
  if( chngRowid ){
    assert( iRowidExpr>=0 );
    if( nChangeFrom==0 ){
      sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
    }else{
      sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid);
    }
    sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
  }
 
  /* Compute the old pre-UPDATE content of the row being changed, if that
  ** information is needed */
  if( chngPk || hasFK || pTrigger ){
    u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
    oldmask |= sqlite3TriggerColmask(pParse,
        pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
    );
    for(i=0; i<pTab->nCol; i++){
      u32 colFlags = pTab->aCol[i].colFlags;
      k = sqlite3TableColumnToStorage(pTab, i) + regOld;
      if( oldmask==0xffffffff
       || (i<32 && (oldmask & MASKBIT32(i))!=0)
       || (colFlags & COLFLAG_PRIMKEY)!=0
      ){
        testcase(  oldmask!=0xffffffff && i==31 );
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
      }else{
        sqlite3VdbeAddOp2(v, OP_Null, 0, k);
      }
    }
    if( chngRowid==0 && pPk==0 ){
      sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
    }
  }
 
  /* Populate the array of registers beginning at regNew with the new
  ** row data. This array is used to check constants, create the new
  ** table and index records, and as the values for any new.* references
  ** made by triggers.
  **
  ** If there are one or more BEFORE triggers, then do not populate the
  ** registers associated with columns that are (a) not modified by
  ** this UPDATE statement and (b) not accessed by new.* references. The
  ** values for registers not modified by the UPDATE must be reloaded from
  ** the database after the BEFORE triggers are fired anyway (as the trigger
  ** may have modified them). So not loading those that are not going to
  ** be used eliminates some redundant opcodes.
  */
  newmask = sqlite3TriggerColmask(
      pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
  );
  for(i=0, k=regNew; i<pTab->nCol; i++, k++){
    if( i==pTab->iPKey ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, k);
    }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
      if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
    }else{
      j = aXRef[i];
      if( j>=0 ){
        if( nChangeFrom ){
          int nOff = (isView ? pTab->nCol : nPk);
          assert( eOnePass==ONEPASS_OFF );
          sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k);
        }else{
          sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
        }
      }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
        /* This branch loads the value of a column that will not be changed
        ** into a register. This is done if there are no BEFORE triggers, or
        ** if there are one or more BEFORE triggers that use this value via
        ** a new.* reference in a trigger program.
        */
        testcase( i==31 );
        testcase( i==32 );
        sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
        bFinishSeek = 0;
      }else{
        sqlite3VdbeAddOp2(v, OP_Null, 0, k);
      }
    }
  }
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  if( pTab->tabFlags & TF_HasGenerated ){
    testcase( pTab->tabFlags & TF_HasVirtual );
    testcase( pTab->tabFlags & TF_HasStored );
    sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
  }
#endif
 
  /* Fire any BEFORE UPDATE triggers. This happens before constraints are
  ** verified. One could argue that this is wrong.
  */
  if( tmask&TRIGGER_BEFORE ){
    sqlite3TableAffinity(v, pTab, regNew);
    sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
        TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
 
    if( !isView ){
      /* The row-trigger may have deleted the row being updated. In this
      ** case, jump to the next row. No updates or AFTER triggers are
      ** required. This behavior - what happens when the row being updated
      ** is deleted or renamed by a BEFORE trigger - is left undefined in the
      ** documentation.
      */
      if( pPk ){
        sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
        VdbeCoverage(v);
      }else{
        sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
        VdbeCoverage(v);
      }
 
      /* After-BEFORE-trigger-reload-loop:
      ** If it did not delete it, the BEFORE trigger may still have modified
      ** some of the columns of the row being updated. Load the values for
      ** all columns not modified by the update statement into their registers
      ** in case this has happened. Only unmodified columns are reloaded.
      ** The values computed for modified columns use the values before the
      ** BEFORE trigger runs.  See test case trigger1-18.0 (added 2018-04-26)
      ** for an example.
      */
      for(i=0, k=regNew; i<pTab->nCol; i++, k++){
        if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
          if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
        }else if( aXRef[i]<0 && i!=pTab->iPKey ){
          sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
        }
      }
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
      if( pTab->tabFlags & TF_HasGenerated ){
        testcase( pTab->tabFlags & TF_HasVirtual );
        testcase( pTab->tabFlags & TF_HasStored );
        sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
      }
#endif
    }
  }
 
  if( !isView ){
    /* Do constraint checks. */
    assert( regOldRowid>0 );
    sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
        regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
        aXRef, 0);
 
    /* If REPLACE conflict handling may have been used, or if the PK of the
    ** row is changing, then the GenerateConstraintChecks() above may have
    ** moved cursor iDataCur. Reseek it. */
    if( bReplace || chngKey ){
      if( pPk ){
        sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
      }else{
        sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
      }
      VdbeCoverageNeverTaken(v);
    }
 
    /* Do FK constraint checks. */
    if( hasFK ){
      sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
    }
 
    /* Delete the index entries associated with the current record.  */
    sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
 
    /* We must run the OP_FinishSeek opcode to resolve a prior
    ** OP_DeferredSeek if there is any possibility that there have been
    ** no OP_Column opcodes since the OP_DeferredSeek was issued.  But
    ** we want to avoid the OP_FinishSeek if possible, as running it
    ** costs CPU cycles. */
    if( bFinishSeek ){
      sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur);
    }
 
    /* If changing the rowid value, or if there are foreign key constraints
    ** to process, delete the old record. Otherwise, add a noop OP_Delete
    ** to invoke the pre-update hook.
    **
    ** That (regNew==regnewRowid+1) is true is also important for the
    ** pre-update hook. If the caller invokes preupdate_new(), the returned
    ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
    ** is the column index supplied by the user.
    */
    assert( regNew==regNewRowid+1 );
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
        OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP),
        regNewRowid
    );
    if( eOnePass==ONEPASS_MULTI ){
      assert( hasFK==0 && chngKey==0 );
      sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
    }
    if( !pParse->nested ){
      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
    }
#else
    if( hasFK>1 || chngKey ){
      sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
    }
#endif
 
    if( hasFK ){
      sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
    }
 
    /* Insert the new index entries and the new record. */
    sqlite3CompleteInsertion(
        pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
        OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0),
        0, 0
    );
 
    /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
    ** handle rows (possibly in other tables) that refer via a foreign key
    ** to the row just updated. */
    if( hasFK ){
      sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
    }
  }
 
  /* Increment the row counter
  */
  if( regRowCount ){
    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
  }
 
  sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
      TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
 
  /* Repeat the above with the next record to be updated, until
  ** all record selected by the WHERE clause have been updated.
  */
  if( eOnePass==ONEPASS_SINGLE ){
    /* Nothing to do at end-of-loop for a single-pass */
  }else if( eOnePass==ONEPASS_MULTI ){
    sqlite3VdbeResolveLabel(v, labelContinue);
    sqlite3WhereEnd(pWInfo);
  }else if( pPk || nChangeFrom ){
    sqlite3VdbeResolveLabel(v, labelContinue);
    sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
  }else{
    sqlite3VdbeGoto(v, labelContinue);
  }
  sqlite3VdbeResolveLabel(v, labelBreak);
 
  /* Update the sqlite_sequence table by storing the content of the
  ** maximum rowid counter values recorded while inserting into
  ** autoincrement tables.
  */
  if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
    sqlite3AutoincrementEnd(pParse);
  }
 
  /*
  ** Return the number of rows that were changed, if we are tracking
  ** that information.
  */
  if( regRowCount ){
    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
    sqlite3VdbeSetNumCols(v, 1);
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
  }
 
update_cleanup:
  sqlite3AuthContextPop(&sContext);
  sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
  sqlite3SrcListDelete(db, pTabList);
  sqlite3ExprListDelete(db, pChanges);
  sqlite3ExprDelete(db, pWhere);

References ExprList::a, SrcList::a, Table::aCol, sqlite3::aDb, Index::aiColumn, ALLBITS, Parse::checkSchema, COLFLAG_GENERATED, COLFLAG_PRIMKEY, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, COLNAME_NAME, SrcList::SrcList_item::colUsed, Parse::db, sqlite3::flags, HasRowid, SrcList::SrcList_item::iCursor, Upsert::iDataCur, Upsert::iIdxCur, indexColumnIsBeingUpdated(), indexWhereClauseMightChange(), Table::iPKey, IsVirtual, sqlite3::mallocFailed, MASKBIT32, KeyInfo::nAllField, NC_UUpsert, NameContext::ncFlags, Table::nCol, Index::nColumn, Parse::nErr, Parse::nested, ExprList::nExpr, Index::nKeyCol, Parse::nMem, SrcList::nSrc, Parse::nTab, OE_Default, OE_Replace, ONEPASS_MULTI, ONEPASS_OFF, ONEPASS_SINGLE, Index::onError, OP_AddImm, OP_Column, OP_Copy, OP_Delete, OP_FinishSeek, OP_IdxInsert, OP_Integer, OP_IsNull, OP_MakeRecord, OP_MustBeInt, OP_Next, OP_NotExists, OP_NotFound, OP_Null, OP_Once, OP_OpenEphemeral, OP_OpenWrite, OP_ResultRow, OP_Rewind, OP_RowData, OP_Rowid, OP_RowSetAdd, OP_RowSetRead, OPFLAG_ISNOOP, OPFLAG_ISUPDATE, OPFLAG_SAVEPOSITION, P4_KEYINFO, P4_TABLE, Column::pDflt, ExprList::ExprList_item::pExpr, Table::pIndex, Index::pNext, NameContext::pParse, Table::pSchema, Table::pSelect, NameContext::pSrcList, Parse::pTriggerTab, NameContext::pUpsert, sqlite3AuthCheck(), sqlite3AuthContextPop(), sqlite3AuthContextPush(), sqlite3AutoincrementEnd(), sqlite3BeginWriteOperation(), sqlite3CodeRowTrigger(), sqlite3CompleteInsertion(), sqlite3ComputeGeneratedColumns(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3ErrorMsg(), sqlite3ExprCode(), sqlite3ExprCodeGetColumnOfTable(), sqlite3ExprDelete(), sqlite3ExprIfFalse(), sqlite3ExprListDelete(), sqlite3ExprReferencesUpdatedColumn(), sqlite3FkActions(), sqlite3FkCheck(), sqlite3FkOldmask(), sqlite3FkRequired(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowIndexDelete(), sqlite3GetVdbe(), sqlite3IndexAffinityStr(), sqlite3IsReadOnly(), sqlite3IsRowid(), sqlite3KeyInfoOfIndex(), sqlite3MaterializeView(), sqlite3MultiWrite(), sqlite3OpenTableAndIndices(), sqlite3PrimaryKeyIndex(), sqlite3ResolveExprNames(), sqlite3SchemaToIndex(), sqlite3SrcListDelete(), sqlite3SrcListLookup(), sqlite3StrICmp(), sqlite3TableAffinity(), sqlite3TableColumnToStorage(), sqlite3TriggerColmask(), sqlite3TriggersExist(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeCountChanges(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGoto(), sqlite3VdbeJumpHereOrPopInst(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), sqlite3ViewGetColumnNames(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereOkOnePass(), sqlite3WhereUsesDeferredSeek(), SQLITE_CountRows, SQLITE_DENY, SQLITE_IGNORE, SQLITE_JUMPIFNULL, SQLITE_STATIC, SQLITE_UPDATE, Table::tabFlags, testcase, TF_HasGenerated, TF_HasStored, TF_HasVirtual, TK_UPDATE, TRIGGER_AFTER, TRIGGER_BEFORE, NameContext::uNC, updateFromSelect(), updateVirtualTable(), VdbeCoverage, VdbeCoverageIf, VdbeCoverageNeverTaken, WHERE_ONEPASS_DESIRED, WHERE_ONEPASS_MULTIROW, WHERE_SEEK_UNIQ_TABLE, Db::zDbSName, ExprList::ExprList_item::zEName, Column::zName, and Table::zName.

Referenced by sqlite3UpsertDoUpdate(), and yy_reduce().

◆ sqlite3UpsertAnalyzeTarget()

SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget	(	Parse *	pParse,
		SrcList *	pTabList,
		Upsert *	pUpsert )

Definition at line 138981 of file sqlite3.c.

 {
  Table *pTab;            /* That table into which we are inserting */
  int rc;                 /* Result code */
  int iCursor;            /* Cursor used by pTab */
  Index *pIdx;            /* One of the indexes of pTab */
  ExprList *pTarget;      /* The conflict-target clause */
  Expr *pTerm;            /* One term of the conflict-target clause */
  NameContext sNC;        /* Context for resolving symbolic names */
  Expr sCol[2];           /* Index column converted into an Expr */
 
  assert( pTabList->nSrc==1 );
  assert( pTabList->a[0].pTab!=0 );
  assert( pUpsert!=0 );
  assert( pUpsert->pUpsertTarget!=0 );
 
  /* Resolve all symbolic names in the conflict-target clause, which
  ** includes both the list of columns and the optional partial-index
  ** WHERE clause.
  */
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pParse;
  sNC.pSrcList = pTabList;
  rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
  if( rc ) return rc;
  rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
  if( rc ) return rc;
 
  /* Check to see if the conflict target matches the rowid. */
  pTab = pTabList->a[0].pTab;
  pTarget = pUpsert->pUpsertTarget;
  iCursor = pTabList->a[0].iCursor;
  if( HasRowid(pTab)
   && pTarget->nExpr==1
   && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
   && pTerm->iColumn==XN_ROWID
  ){
    /* The conflict-target is the rowid of the primary table */
    assert( pUpsert->pUpsertIdx==0 );
    return SQLITE_OK;
  }
 
  /* Initialize sCol[0..1] to be an expression parse tree for a
  ** single column of an index.  The sCol[0] node will be the TK_COLLATE
  ** operator and sCol[1] will be the TK_COLUMN operator.  Code below
  ** will populate the specific collation and column number values
  ** prior to comparing against the conflict-target expression.
  */
  memset(sCol, 0, sizeof(sCol));
  sCol[0].op = TK_COLLATE;
  sCol[0].pLeft = &sCol[1];
  sCol[1].op = TK_COLUMN;
  sCol[1].iTable = pTabList->a[0].iCursor;
 
  /* Check for matches against other indexes */
  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    int ii, jj, nn;
    if( !IsUniqueIndex(pIdx) ) continue;
    if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
    if( pIdx->pPartIdxWhere ){
      if( pUpsert->pUpsertTargetWhere==0 ) continue;
      if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
                             pIdx->pPartIdxWhere, iCursor)!=0 ){
        continue;
      }
    }
    nn = pIdx->nKeyCol;
    for(ii=0; ii<nn; ii++){
      Expr *pExpr;
      sCol[0].u.zToken = (char*)pIdx->azColl[ii];
      if( pIdx->aiColumn[ii]==XN_EXPR ){
        assert( pIdx->aColExpr!=0 );
        assert( pIdx->aColExpr->nExpr>ii );
        pExpr = pIdx->aColExpr->a[ii].pExpr;
        if( pExpr->op!=TK_COLLATE ){
          sCol[0].pLeft = pExpr;
          pExpr = &sCol[0];
        }
      }else{
        sCol[0].pLeft = &sCol[1];
        sCol[1].iColumn = pIdx->aiColumn[ii];
        pExpr = &sCol[0];
      }
      for(jj=0; jj<nn; jj++){
        if( sqlite3ExprCompare(pParse, pTarget->a[jj].pExpr, pExpr,iCursor)<2 ){
          break;  /* Column ii of the index matches column jj of target */
        }
      }
      if( jj>=nn ){
        /* The target contains no match for column jj of the index */
        break;
      }
    }
    if( ii<nn ){
      /* Column ii of the index did not match any term of the conflict target.
      ** Continue the search with the next index. */
      continue;
    }
    pUpsert->pUpsertIdx = pIdx;

References ExprList::a, SrcList::a, Index::aColExpr, Index::aiColumn, Index::azColl, HasRowid, Expr::iColumn, SrcList::SrcList_item::iCursor, IsUniqueIndex, Expr::iTable, ExprList::nExpr, Index::nKeyCol, SrcList::nSrc, Expr::op, ExprList::ExprList_item::pExpr, Table::pIndex, Expr::pLeft, Index::pNext, NameContext::pParse, Index::pPartIdxWhere, NameContext::pSrcList, SrcList::SrcList_item::pTab, Upsert::pUpsertIdx, Upsert::pUpsertTarget, Upsert::pUpsertTargetWhere, sqlite3ErrorMsg(), sqlite3ExprCompare(), sqlite3ResolveExprListNames(), sqlite3ResolveExprNames(), SQLITE_ERROR, SQLITE_OK, TK_COLLATE, TK_COLUMN, Expr::u, XN_EXPR, XN_ROWID, and Expr::zToken.

Referenced by sqlite3Insert().

◆ sqlite3UpsertDelete()

SQLITE_PRIVATE void sqlite3UpsertDelete	(	sqlite3 *	db,
		Upsert *	p )

Definition at line 138923 of file sqlite3.c.

                                                               {
  if( p ){
    sqlite3ExprListDelete(db, p->pUpsertTarget);

References Upsert::pUpsertSet, Upsert::pUpsertTarget, Upsert::pUpsertTargetWhere, Upsert::pUpsertWhere, sqlite3DbFree(), sqlite3ExprDelete(), and sqlite3ExprListDelete().

Referenced by sqlite3DeleteTriggerStep(), sqlite3Insert(), and sqlite3TriggerInsertStep().

◆ sqlite3UpsertDoUpdate()

SQLITE_PRIVATE void sqlite3UpsertDoUpdate	(	Parse *	pParse,
		Upsert *	pUpsert,
		Table *	pTab,
		Index *	pIdx,
		int	iCur )

Definition at line 139099 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;
  SrcList *pSrc;            /* FROM clause for the UPDATE */
  int iDataCur;
  int i;
 
  assert( v!=0 );
  assert( pUpsert!=0 );
  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
  iDataCur = pUpsert->iDataCur;
  if( pIdx && iCur!=iDataCur ){
    if( HasRowid(pTab) ){
      int regRowid = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
      sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid);
      VdbeCoverage(v);
      sqlite3ReleaseTempReg(pParse, regRowid);
    }else{
      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
      int nPk = pPk->nKeyCol;
      int iPk = pParse->nMem+1;
      pParse->nMem += nPk;
      for(i=0; i<nPk; i++){
        int k;
        assert( pPk->aiColumn[i]>=0 );
        k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
        sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
        VdbeComment((v, "%s.%s", pIdx->zName,
                    pTab->aCol[pPk->aiColumn[i]].zName));
      }
      sqlite3VdbeVerifyAbortable(v, OE_Abort);
      i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
      VdbeCoverage(v);
      sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0,
            "corrupt database", P4_STATIC);
      sqlite3MayAbort(pParse);
      sqlite3VdbeJumpHere(v, i);
    }
  }
  /* pUpsert does not own pUpsertSrc - the outer INSERT statement does.  So
  ** we have to make a copy before passing it down into sqlite3Update() */
  pSrc = sqlite3SrcListDup(db, pUpsert->pUpsertSrc, 0);
  /* excluded.* columns of type REAL need to be converted to a hard real */
  for(i=0; i<pTab->nCol; i++){
    if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
      sqlite3VdbeAddOp1(v, OP_RealAffinity, pUpsert->regData+i);
    }
  }

References Table::aCol, Column::affinity, Index::aiColumn, Parse::db, HasRowid, Upsert::iDataCur, Table::nCol, Index::nKeyCol, Parse::nMem, OE_Abort, OP_Column, OP_Found, OP_Halt, OP_IdxRowid, OP_RealAffinity, OP_SeekRowid, P4_STATIC, Upsert::pUpsertSet, Upsert::pUpsertSrc, Upsert::pUpsertWhere, Parse::pVdbe, Upsert::regData, sqlite3GetTempReg(), sqlite3MayAbort(), sqlite3PrimaryKeyIndex(), sqlite3ReleaseTempReg(), sqlite3SrcListDup(), sqlite3TableColumnToIndex(), sqlite3Update(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeJumpHere(), sqlite3VdbeVerifyAbortable, SQLITE_AFF_REAL, SQLITE_CORRUPT, VdbeComment, VdbeCoverage, VdbeNoopComment, Column::zName, and Index::zName.

Referenced by sqlite3GenerateConstraintChecks().

◆ sqlite3UpsertDup()

SQLITE_PRIVATE Upsert * sqlite3UpsertDup	(	sqlite3 *	db,
		Upsert *	p )

Definition at line 138936 of file sqlite3.c.

                                                               {
  if( p==0 ) return 0;
  return sqlite3UpsertNew(db,

◆ sqlite3UpsertNew()

SQLITE_PRIVATE Upsert * sqlite3UpsertNew	(	sqlite3 *	db,
		ExprList *	pTarget,
		Expr *	pTargetWhere,
		ExprList *	pSet,
		Expr *	pWhere )

Definition at line 138949 of file sqlite3.c.

 {
  Upsert *pNew;
  pNew = sqlite3DbMallocRaw(db, sizeof(Upsert));
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pTarget);
    sqlite3ExprDelete(db, pTargetWhere);
    sqlite3ExprListDelete(db, pSet);
    sqlite3ExprDelete(db, pWhere);
    return 0;
  }else{
    pNew->pUpsertTarget = pTarget;
    pNew->pUpsertTargetWhere = pTargetWhere;

Referenced by yy_reduce().

◆ sqlite3Utf16ByteLen()

SQLITE_PRIVATE int sqlite3Utf16ByteLen	(	const void *	pData,
		int	nChar )

Definition at line 31132 of file sqlite3.c.

                                                                  {
  int c;
  unsigned char const *z = zIn;
  int n = 0;
 
  if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++;
  while( n<nChar ){
    c = z[0];
    z += 2;

References SQLITE_UTF16LE, and SQLITE_UTF16NATIVE.

Referenced by sqlite3Prepare16().

◆ sqlite3Utf16to8()

SQLITE_PRIVATE char * sqlite3Utf16to8	(	sqlite3 *	db,
		const void *	z,
		int	nByte,
		u8	enc )

Definition at line 31111 of file sqlite3.c.

                                                                                   {
  Mem m;
  memset(&m, 0, sizeof(m));
  m.db = db;
  sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
  if( db->mallocFailed ){
    sqlite3VdbeMemRelease(&m);
    m.z = 0;

References sqlite3_value::db, sqlite3_value::flags, sqlite3::mallocFailed, MEM_Str, MEM_Term, sqlite3VdbeChangeEncoding(), sqlite3VdbeMemRelease(), sqlite3VdbeMemSetStr(), SQLITE_STATIC, SQLITE_UTF8, and sqlite3_value::z.

Referenced by sqlite3Prepare16().

◆ sqlite3Utf8CharLen()

SQLITE_PRIVATE int sqlite3Utf8CharLen	(	const char *	pData,
		int	nByte )

Definition at line 31057 of file sqlite3.c.

                                                                 {
  int r = 0;
  const u8 *z = (const u8*)zIn;
  const u8 *zTerm;
  if( nByte>=0 ){
    zTerm = &z[nByte];
  }else{
    zTerm = (const u8*)(-1);
  }
  assert( z<=zTerm );

References SQLITE_SKIP_UTF8.

Referenced by likeFunc(), sqlite3EndTable(), and sqlite3Prepare16().

◆ sqlite3Utf8Read() [1/2]

SQLITE_PRIVATE u32 sqlite3Utf8Read ( const u8 ** )

Referenced by likeFunc(), and patternCompare().

◆ sqlite3Utf8Read() [2/2]

SQLITE_PRIVATE u32 sqlite3Utf8Read ( const unsigned char ** pz )

Definition at line 30788 of file sqlite3.c.

                                   {  c = 0xFFFD; }        \
  }
SQLITE_PRIVATE u32 sqlite3Utf8Read(
  const unsigned char **pz    /* Pointer to string from which to read char */
){
  unsigned int c;
 
  /* Same as READ_UTF8() above but without the zTerm parameter.
  ** For this routine, we assume the UTF8 string is always zero-terminated.
  */
  c = *((*pz)++);
  if( c>=0xc0 ){
    c = sqlite3Utf8Trans1[c-0xc0];
    while( (*(*pz) & 0xc0)==0x80 ){
      c = (c<<6) + (0x3f & *((*pz)++));
    }

References sqlite3Utf8Trans1.

◆ sqlite3Vacuum()

SQLITE_PRIVATE void sqlite3Vacuum	(	Parse *	pParse,
		Token *	pNm,
		Expr *	pInto )

Definition at line 139269 of file sqlite3.c.

                                                                         {
  Vdbe *v = sqlite3GetVdbe(pParse);
  int iDb = 0;
  if( v==0 ) goto build_vacuum_end;
  if( pParse->nErr ) goto build_vacuum_end;
  if( pNm ){
#ifndef SQLITE_BUG_COMPATIBLE_20160819
    /* Default behavior:  Report an error if the argument to VACUUM is
    ** not recognized */
    iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
    if( iDb<0 ) goto build_vacuum_end;
#else
    /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
    ** to VACUUM are silently ignored.  This is a back-out of a bug fix that
    ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
    ** The buggy behavior is required for binary compatibility with some
    ** legacy applications. */
    iDb = sqlite3FindDb(pParse->db, pNm);
    if( iDb<0 ) iDb = 0;
#endif
  }
  if( iDb!=1 ){
    int iIntoReg = 0;
    if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){
      iIntoReg = ++pParse->nMem;
      sqlite3ExprCode(pParse, pInto, iIntoReg);
    }
    sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);

References Parse::db, Parse::nErr, Parse::nMem, OP_Vacuum, sqlite3ExprCode(), sqlite3ExprDelete(), sqlite3FindDb(), sqlite3GetVdbe(), sqlite3ResolveSelfReference(), sqlite3TwoPartName(), sqlite3VdbeAddOp2(), and sqlite3VdbeUsesBtree().

Referenced by yy_reduce().

◆ sqlite3ValueApplyAffinity()

SQLITE_PRIVATE void sqlite3ValueApplyAffinity	(	sqlite3_value *	pVal,
		u8	affinity,
		u8	enc )

Definition at line 85654 of file sqlite3.c.

Referenced by sqlite3VdbeGetBoundValue(), sqlite3VdbeMemCast(), and valueFromExpr().

◆ sqlite3ValueBytes()

SQLITE_PRIVATE int sqlite3ValueBytes	(	sqlite3_value *	pVal,
		u8	enc )

Definition at line 77714 of file sqlite3.c.

                                                                  {
  return valueToText(pVal, enc)!=0 ? pVal->n : 0;
}
SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
  Mem *p = (Mem*)pVal;
  assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
  if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
    return p->n;
  }
  if( (p->flags & MEM_Blob)!=0 ){
    if( p->flags & MEM_Zero ){
      return p->n + p->u.nZero;
    }else{

References sqlite3_value::n, and valueToText().

Referenced by sqlite3_value_double(), and sqlite3_value_int().

◆ sqlite3ValueFree()

SQLITE_PRIVATE void sqlite3ValueFree ( sqlite3_value * v )

Definition at line 77700 of file sqlite3.c.

Referenced by callCollNeeded(), exprCompareVariable(), isLikeOrGlob(), sqlite3_complete16(), sqlite3AlterFinishAddColumn(), sqlite3LeaveMutexAndCloseZombie(), valueFromExpr(), and windowExprGtZero().

◆ sqlite3ValueFromExpr()

SQLITE_PRIVATE int sqlite3ValueFromExpr	(	sqlite3 *	db,
		Expr *	pExpr,
		u8	enc,
		u8	affinity,
		sqlite3_value **	ppVal )

Definition at line 77458 of file sqlite3.c.

References valueFromExpr().

Referenced by exprCompareVariable(), sqlite3AlterFinishAddColumn(), sqlite3ColumnDefault(), and windowExprGtZero().

◆ sqlite3ValueNew()

SQLITE_PRIVATE sqlite3_value * sqlite3ValueNew ( sqlite3 * db )

Definition at line 77116 of file sqlite3.c.

77122 {

77123 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));

Referenced by callCollNeeded(), sqlite3_complete16(), sqlite3ErrorWithMsg(), sqlite3VdbeGetBoundValue(), sqlite3VdbeTransferError(), and valueNew().

◆ sqlite3ValueSetNull()

SQLITE_PRIVATE void sqlite3ValueSetNull ( sqlite3_value * p )

Definition at line 76653 of file sqlite3.c.

                            {
    vdbeMemClearExternAndSetNull(pMem);
  }else{

References vdbeMemClearExternAndSetNull().

Referenced by sqlite3ErrorFinish(), and sqlite3VdbeTransferError().

◆ sqlite3ValueSetStr()

SQLITE_PRIVATE void sqlite3ValueSetStr	(	sqlite3_value *	v,
		int	n,
		const void *	z,
		u8	enc,
		void()(void )	xDel )

Definition at line 77687 of file sqlite3.c.

Referenced by callCollNeeded(), sqlite3_complete16(), sqlite3ErrorWithMsg(), sqlite3VdbeTransferError(), and valueFromExpr().

◆ sqlite3ValueText()

SQLITE_PRIVATE const void * sqlite3ValueText	(	sqlite3_value *	pVal,
		u8	enc )

Definition at line 77098 of file sqlite3.c.

              :)  The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
** If that is the case, then the result must be aligned on an even byte
** boundary.
*/
SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
  if( !pVal ) return 0;
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    return pVal->z;

References sqlite3_value::db, sqlite3_value::enc, sqlite3_value::flags, MEM_Null, MEM_Str, MEM_Term, sqlite3::mutex, sqlite3_mutex_held(), SQLITE_UTF16_ALIGNED, and sqlite3_value::z.

Referenced by callCollNeeded(), sqlite3_complete16(), sqlite3_value_text16le(), and vdbeCompareMemString().

◆ sqlite3VarintLen()

SQLITE_PRIVATE int sqlite3VarintLen ( u64 v )

Definition at line 32430 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), sqlite3VdbeRecordCompareWithSkip(), vdbeIncrPopulate(), and vdbeSorterListToPMA().

◆ sqlite3VdbeAddFunctionCall()

SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall	(	Parse *	pParse,
		int	p1,
		int	p2,
		int	p3,
		int	nArg,
		const FuncDef *	pFunc,
		int	eCallCtx )

Definition at line 78084 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  int nByte;
  int addr;
  sqlite3_context *pCtx;
  assert( v );
  nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
  pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
  if( pCtx==0 ){
    assert( pParse->db->mallocFailed );
    freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
    return 0;
  }
  pCtx->pOut = 0;
  pCtx->pFunc = (FuncDef*)pFunc;
  pCtx->pVdbe = 0;
  pCtx->isError = 0;
  pCtx->argc = nArg;

References sqlite3_context::argc, Parse::db, freeEphemeralFunction(), sqlite3_context::iOp, sqlite3_context::isError, sqlite3::mallocFailed, NC_SelfRef, OP_Function, OP_PureFunc, P4_FUNCCTX, sqlite3_context::pFunc, sqlite3_context::pOut, ValueNewStat4Ctx::pParse, Parse::pVdbe, sqlite3_context::pVdbe, sqlite3DbMallocRawNN(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), and sqlite3VdbeCurrentAddr().

Referenced by analyzeOneTable(), and sqlite3ExprCodeTarget().

◆ sqlite3VdbeAddOp0()

SQLITE_PRIVATE int sqlite3VdbeAddOp0	(	Vdbe *	p,
		int	op )

◆ sqlite3VdbeAddOp1()

SQLITE_PRIVATE int sqlite3VdbeAddOp1	(	Vdbe *	p,
		int	op,
		int	p1 )

Definition at line 78006 of file sqlite3.c.

Referenced by analyzeOneTable(), codeAllEqualityTerms(), codeEqualityTerm(), computeLimitRegisters(), constructAutomaticIndex(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), loadAnalysis(), multiSelect(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3ColumnDefault(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), updateAccumulator(), updateVirtualTable(), windowAggFinal(), windowAggStep(), windowCodeOp(), windowCodeRangeTest(), windowInitAccum(), and xferOptimization().

◆ sqlite3VdbeAddOp2()

SQLITE_PRIVATE int sqlite3VdbeAddOp2	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2 )

Definition at line 78009 of file sqlite3.c.

                                                     {
  return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
}

References sqlite3VdbeAddOp3().

Referenced by analyzeOneTable(), autoIncStep(), codeAllEqualityTerms(), codeEqualityTerm(), codeInteger(), codeVectorCompare(), computeLimitRegisters(), constructAutomaticIndex(), fkLookupParent(), fkScanChildren(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), integrityCheckResultRow(), multiSelect(), multiSelectOrderBy(), openStatTable(), selectInnerLoop(), sqlite3AlterFinishAddColumn(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3CompleteInsertion(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3EndTransaction(), sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3Vacuum(), sqlite3VdbeMultiLoad(), sqlite3WhereEnd(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), sqlite3WindowRewrite(), updateAccumulator(), updateVirtualTable(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), windowIfNewPeer(), windowInitAccum(), windowReturnOneRow(), and xferOptimization().

◆ sqlite3VdbeAddOp3()

SQLITE_PRIVATE int sqlite3VdbeAddOp3	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2,
		int	p3 )

Definition at line 77966 of file sqlite3.c.

                                                                           {
  assert( p->nOpAlloc<=p->nOp );
  if( growOpArray(p, 1) ) return 1;
  assert( p->nOpAlloc>p->nOp );
  return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
}
SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
  int i;
  VdbeOp *pOp;
 
  i = p->nOp;
  assert( p->magic==VDBE_MAGIC_INIT );
  assert( op>=0 && op<0xff );
  if( p->nOpAlloc<=i ){
    return growOp3(p, op, p1, p2, p3);
  }
  p->nOp++;
  pOp = &p->aOp[i];
  pOp->opcode = (u8)op;
  pOp->p5 = 0;
  pOp->p1 = p1;
  pOp->p2 = p2;
  pOp->p3 = p3;
  pOp->p4.p = 0;
  pOp->p4type = P4_NOTUSED;
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
  pOp->zComment = 0;
#endif
#ifdef SQLITE_DEBUG
  if( p->db->flags & SQLITE_VdbeAddopTrace ){
    sqlite3VdbePrintOp(0, i, &p->aOp[i]);
    test_addop_breakpoint(i, &p->aOp[i]);
  }
#endif
#ifdef VDBE_PROFILE
  pOp->cycles = 0;
  pOp->cnt = 0;

References growOpArray(), Vdbe::nOp, Vdbe::nOpAlloc, and sqlite3VdbeAddOp3().

Referenced by analyzeOneTable(), autoIncrementEnd(), codeAllEqualityTerms(), codeDeferredSeek(), codeDistinct(), codeEqualityTerm(), codeExprOrVector(), computeLimitRegisters(), constructAutomaticIndex(), destroyRootPage(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), integrityCheckResultRow(), makeSorterRecord(), multiSelect(), multiSelectOrderBy(), resetAccumulator(), selectInnerLoop(), sqlite3AlterFinishAddColumn(), sqlite3ChangeCookie(), sqlite3CodeSubselect(), sqlite3CompleteInsertion(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FindInIndex(), sqlite3GenerateConstraintChecks(), sqlite3GenerateIndexKey(), sqlite3GenerateRowIndexDelete(), sqlite3Insert(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeGoto(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), updateAccumulator(), updateVirtualTable(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), windowIfNewPeer(), windowReturnOneRow(), and xferOptimization().

◆ sqlite3VdbeAddOp4()

SQLITE_PRIVATE int sqlite3VdbeAddOp4	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2,
		int	p3,
		const char *	zP4,
		int	p4type )

Definition at line 78060 of file sqlite3.c.

Referenced by analyzeOneTable(), codeApplyAffinity(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), multiSelectOrderBy(), resetAccumulator(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3CodeRowTriggerDirect(), sqlite3CompleteInsertion(), sqlite3DeleteFrom(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3HaltConstraint(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3StartTable(), sqlite3TableAffinity(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3VdbeAddFunctionCall(), sqlite3VdbeAddParseSchemaOp(), sqlite3VdbeExplain(), sqlite3VdbeMultiLoad(), sqlite3WhereBegin(), sqlite3WhereExplainOneScan(), updateAccumulator(), updateVirtualTable(), windowAggStep(), windowCheckValue(), windowCodeRangeTest(), and xferOptimization().

◆ sqlite3VdbeAddOp4Dup8()

SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2,
		int	p3,
		const u8 *	zP4,
		int	p4type )

Definition at line 78121 of file sqlite3.c.

Referenced by codeInteger(), codeReal(), sqlite3FindInIndex(), and sqlite3WhereBegin().

◆ sqlite3VdbeAddOp4Int()

SQLITE_PRIVATE int sqlite3VdbeAddOp4Int	(	Vdbe *	p,
		int	op,
		int	p1,
		int	p2,
		int	p3,
		int	p4 )

Definition at line 78215 of file sqlite3.c.

 {
  int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
  if( p->db->mallocFailed==0 ){

Referenced by analyzeOneTable(), codeAllEqualityTerms(), codeDistinct(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), multiSelect(), openStatTable(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3CompleteInsertion(), sqlite3DeleteFrom(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3OpenTable(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), sqlite3UpsertDoUpdate(), sqlite3WhereEnd(), and windowAggStep().

◆ sqlite3VdbeAddOpList()

SQLITE_PRIVATE VdbeOp * sqlite3VdbeAddOpList	(	Vdbe *	p,
		int	nOp,
		VdbeOpList const *	aOp,
		int	iLineno )

Definition at line 78700 of file sqlite3.c.

 {
  int i;
  VdbeOp *pOut, *pFirst;
  assert( nOp>0 );
  assert( p->magic==VDBE_MAGIC_INIT );
  if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
    return 0;
  }
  pFirst = pOut = &p->aOp[p->nOp];
  for(i=0; i<nOp; i++, aOp++, pOut++){
    pOut->opcode = aOp->opcode;
    pOut->p1 = aOp->p1;
    pOut->p2 = aOp->p2;
    assert( aOp->p2>=0 );
    if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
      pOut->p2 += p->nOp;
    }
    pOut->p3 = aOp->p3;
    pOut->p4type = P4_NOTUSED;
    pOut->p4.p = 0;
    pOut->p5 = 0;
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
    pOut->zComment = 0;
#endif
#ifdef SQLITE_VDBE_COVERAGE
    pOut->iSrcLine = iLineno+i;
#else
    (void)iLineno;
#endif
#ifdef SQLITE_DEBUG
    if( p->db->flags & SQLITE_VdbeAddopTrace ){
      sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);

References Vdbe::aOp, Vdbe::db, sqlite3::flags, growOpArray(), Vdbe::magic, Vdbe::nOp, Vdbe::nOpAlloc, VdbeOp::opcode, VdbeOpList::opcode, OPFLG_JUMP, VdbeOp::p4union::p, VdbeOp::p1, VdbeOpList::p1, VdbeOp::p2, VdbeOpList::p2, VdbeOp::p3, VdbeOpList::p3, VdbeOp::p4, P4_NOTUSED, VdbeOp::p4type, VdbeOp::p5, sqlite3OpcodeProperty, and VDBE_MAGIC_INIT.

Referenced by autoIncrementEnd(), and sqlite3Pragma().

◆ sqlite3VdbeAddParseSchemaOp()

SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp	(	Vdbe *	p,
		int	iDb,
		char *	zWhere )

Definition at line 78206 of file sqlite3.c.

References OP_ParseSchema, P4_DYNAMIC, and sqlite3VdbeAddOp4().

Referenced by sqlite3CreateIndex(), and sqlite3EndTable().

◆ sqlite3VdbeAllocUnpackedRecord()

SQLITE_PRIVATE UnpackedRecord * sqlite3VdbeAllocUnpackedRecord ( KeyInfo * pKeyInfo )

Definition at line 81728 of file sqlite3.c.

 {
  UnpackedRecord *p;              /* Unpacked record to return */
  int nByte;                      /* Number of bytes required for *p */
  nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
  p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
  if( !p ) return 0;

References UnpackedRecord::aMem, KeyInfo::aSortFlags, KeyInfo::db, UnpackedRecord::nField, KeyInfo::nKeyField, UnpackedRecord::pKeyInfo, ROUND8, and sqlite3DbMallocRaw().

Referenced by btreeMoveto(), sqlite3VdbeExec(), sqlite3VdbeSorterCompare(), and vdbeSortAllocUnpacked().

◆ sqlite3VdbeAppendP4()

SQLITE_PRIVATE void sqlite3VdbeAppendP4	(	Vdbe *	p,
		void *	pP4,
		int	p4type )

Definition at line 79071 of file sqlite3.c.

                                                                  {
  VdbeOp *pOp;
  assert( n!=P4_INT32 && n!=P4_VTAB );
  assert( n<=0 );
  if( p->db->mallocFailed ){
    freeP4(p->db, n, pP4);
  }else{
    assert( pP4!=0 );
    assert( p->nOp>0 );

References Vdbe::aOp, Vdbe::db, freeP4(), sqlite3::mallocFailed, Vdbe::nOp, VdbeOp::p4union::p, VdbeOp::p4, P4_INT32, P4_NOTUSED, P4_VTAB, and VdbeOp::p4type.

Referenced by sqlite3ColumnDefault(), sqlite3CompleteInsertion(), sqlite3ExprCodeTarget(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Update(), sqlite3WindowCodeInit(), sqlite3WindowCodeStep(), updateAccumulator(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowFullScan(), and windowIfNewPeer().

◆ sqlite3VdbeBooleanValue()

SQLITE_PRIVATE int sqlite3VdbeBooleanValue	(	Mem *	pMem,
		int	ifNull )

Definition at line 76465 of file sqlite3.c.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeChangeEncoding()

SQLITE_PRIVATE int sqlite3VdbeChangeEncoding	(	Mem *	pMem,
		int	desiredEnc )

Definition at line 76021 of file sqlite3.c.

                                                                       {
#ifndef SQLITE_OMIT_UTF16
  int rc;
#endif
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
           || desiredEnc==SQLITE_UTF16BE );
  if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
    return SQLITE_OK;
  }
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
#ifdef SQLITE_OMIT_UTF16
  return SQLITE_ERROR;
#else
 
  /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
  ** then the encoding of the value may not have changed.
  */
  rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);

References sqlite3_value::db, sqlite3_value::enc, sqlite3_value::flags, MEM_Str, sqlite3::mutex, sqlite3_mutex_held(), sqlite3VdbeMemTranslate(), SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, SQLITE_UTF16BE, SQLITE_UTF16LE, and SQLITE_UTF8.

Referenced by sqlite3Utf16to8(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeMemCast(), sqlite3VdbeMemStringify(), valueFromExpr(), and valueToText().

◆ sqlite3VdbeChangeOpcode()

SQLITE_PRIVATE void sqlite3VdbeChangeOpcode	(	Vdbe *	p,
		int	addr,
		u8	iNewOpcode )

Definition at line 78776 of file sqlite3.c.

Referenced by convertToWithoutRowidTable(), and sqlite3Select().

◆ sqlite3VdbeChangeP1()

SQLITE_PRIVATE void sqlite3VdbeChangeP1	(	Vdbe *	p,
		int	addr,
		int	P1 )

Definition at line 78779 of file sqlite3.c.

Referenced by sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3Select(), and sqlite3WindowCodeStep().

◆ sqlite3VdbeChangeP2()

SQLITE_PRIVATE void sqlite3VdbeChangeP2	(	Vdbe *	p,
		int	addr,
		int	P2 )

Definition at line 78782 of file sqlite3.c.

                                                                             {
  sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode;
}

References VdbeOp::opcode, and sqlite3VdbeGetOp().

Referenced by constructAutomaticIndex(), multiSelect(), sqlite3VdbeJumpHereOrPopInst(), and windowCodeRangeTest().

◆ sqlite3VdbeChangeP3()

SQLITE_PRIVATE void sqlite3VdbeChangeP3	(	Vdbe *	p,
		int	addr,
		int	P3 )

Definition at line 78785 of file sqlite3.c.

                                                                   {
  sqlite3VdbeGetOp(p,addr)->p1 = val;
}

References VdbeOp::p1, and sqlite3VdbeGetOp().

Referenced by convertToWithoutRowidTable(), isLikeOrGlob(), sqlite3ExprCodeTarget(), and sqlite3Pragma().

◆ sqlite3VdbeChangeP4()

SQLITE_PRIVATE void sqlite3VdbeChangeP4	(	Vdbe *	p,
		int	addr,
		const char *	zP4,
		int	N )

Definition at line 79028 of file sqlite3.c.

       {
    if( n==0 ) n = sqlite3Strlen30(zP4);
    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
    pOp->p4type = P4_DYNAMIC;
  }
}
SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
  Op *pOp;
  sqlite3 *db;
  assert( p!=0 );
  db = p->db;
  assert( p->magic==VDBE_MAGIC_INIT );
  assert( p->aOp!=0 || db->mallocFailed );
  if( db->mallocFailed ){
    if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
    return;
  }
  assert( p->nOp>0 );
  assert( addr<p->nOp );
  if( addr<0 ){
    addr = p->nOp - 1;
  }
  pOp = &p->aOp[addr];
  if( n>=0 || pOp->p4type ){
    vdbeChangeP4Full(p, pOp, zP4, n);
    return;
  }
  if( n==P4_INT32 ){
    /* Note: this cast is safe, because the origin data point was an int
    ** that was cast to a (const char *). */
    pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
    pOp->p4type = P4_INT32;
  }else if( zP4!=0 ){

Referenced by analyzeOneTable(), codeDeferredSeek(), multiSelect(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3GenerateIndexKey(), sqlite3Select(), sqlite3TableAffinity(), sqlite3WhereBegin(), and vdbeChangeP4Full().

◆ sqlite3VdbeChangeP5()

SQLITE_PRIVATE void sqlite3VdbeChangeP5	(	Vdbe *	p,
		u16	P5 )

Definition at line 78788 of file sqlite3.c.

                                                                   {
  sqlite3VdbeGetOp(p,addr)->p2 = val;
}
SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){

References VdbeOp::p2, and sqlite3VdbeGetOp().

Referenced by analyzeOneTable(), codeDistinct(), constructAutomaticIndex(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), multiSelectOrderBy(), openStatTable(), selectInnerLoop(), sqlite3CodeRowTriggerDirect(), sqlite3CompleteInsertion(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeIN(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3GenerateRowIndexDelete(), sqlite3Insert(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3Update(), sqlite3VdbeAddFunctionCall(), sqlite3WhereBegin(), sqlite3WhereEnd(), updateAccumulator(), updateVirtualTable(), windowAggStep(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), and xferOptimization().

◆ sqlite3VdbeChangeToNoop()

SQLITE_PRIVATE int sqlite3VdbeChangeToNoop	(	Vdbe *	p,
		int	addr )

Definition at line 78933 of file sqlite3.c.

                                                             {
  VdbeOp *pOp;
  if( p->db->mallocFailed ) return 0;
  assert( addr>=0 && addr<p->nOp );
  pOp = &p->aOp[addr];

Referenced by selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3DeleteFrom(), sqlite3Select(), sqlite3Update(), and updateVirtualTable().

◆ sqlite3VdbeCheckFk()

SQLITE_PRIVATE int sqlite3VdbeCheckFk	(	Vdbe *	p,
		int	deferred )

Definition at line 80728 of file sqlite3.c.

                                                            {
  sqlite3 *db = p->db;
  if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0)
   || (!deferred && p->nFkConstraint>0)
  ){
    p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;

References Vdbe::db, Vdbe::errorAction, sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, Vdbe::nFkConstraint, OE_Abort, Vdbe::rc, sqlite3VdbeError(), SQLITE_CONSTRAINT_FOREIGNKEY, SQLITE_ERROR, and SQLITE_OK.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3VdbeClearObject()

SQLITE_PRIVATE void sqlite3VdbeClearObject	(	sqlite3 *	db,
		Vdbe *	p )

Definition at line 81168 of file sqlite3.c.

                                                                {
  SubProgram *pSub, *pNext;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  if( p->magic!=VDBE_MAGIC_INIT ){
    releaseMemArray(p->aVar, p->nVar);
    sqlite3DbFree(db, p->pVList);
    sqlite3DbFree(db, p->pFree);
  }
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
#ifdef SQLITE_ENABLE_NORMALIZE
  sqlite3DbFree(db, p->zNormSql);
  {
    DblquoteStr *pThis, *pNext;
    for(pThis=p->pDblStr; pThis; pThis=pNext){
      pNext = pThis->pNextStr;
      sqlite3DbFree(db, pThis);
    }
  }
#endif
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  {
    int i;
    for(i=0; i<p->nScan; i++){

References Vdbe::aColName, SubProgram::aOp, Vdbe::aOp, Vdbe::aVar, COLNAME_N, Vdbe::db, Vdbe::magic, SubProgram::nOp, Vdbe::nOp, Vdbe::nResColumn, Vdbe::nVar, Vdbe::pFree, SubProgram::pNext, DblquoteStr::pNextStr, Vdbe::pProgram, Vdbe::pVList, releaseMemArray(), sqlite3DbFree(), VDBE_MAGIC_INIT, vdbeFreeOpArray(), and Vdbe::zSql.

◆ sqlite3VdbeCloseStatement()

SQLITE_PRIVATE int sqlite3VdbeCloseStatement	(	Vdbe *	p,
		int	eOp )

Definition at line 80709 of file sqlite3.c.

                               {
    db->nDeferredCons = p->nStmtDefCons;
    db->nDeferredImmCons = p->nStmtDefImmCons;
  }
  return rc;
}

References sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, Vdbe::nStmtDefCons, and Vdbe::nStmtDefImmCons.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3VdbeCountChanges()

SQLITE_PRIVATE void sqlite3VdbeCountChanges ( Vdbe * v )

Definition at line 82757 of file sqlite3.c.

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), and sqlite3Update().

◆ sqlite3VdbeCreate()

SQLITE_PRIVATE Vdbe * sqlite3VdbeCreate ( Parse * pParse )

Definition at line 77757 of file sqlite3.c.

                                                     {
  sqlite3 *db = pParse->db;
  Vdbe *p;
  p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) );
  if( p==0 ) return 0;
  memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp));
  p->db = db;
  if( db->pVdbe ){
    db->pVdbe->pPrev = p;
  }
  p->pNext = db->pVdbe;
  p->pPrev = 0;
  db->pVdbe = p;
  p->magic = VDBE_MAGIC_INIT;
  p->pParse = pParse;
  pParse->pVdbe = p;
  assert( pParse->aLabel==0 );

◆ sqlite3VdbeCurrentAddr()

SQLITE_PRIVATE int sqlite3VdbeCurrentAddr ( Vdbe * p )

Definition at line 78623 of file sqlite3.c.

Referenced by analyzeOneTable(), autoIncrementEnd(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), integrityCheckResultRow(), isLikeOrGlob(), multiSelect(), multiSelectOrderBy(), readsTable(), selectInnerLoop(), sqlite3AlterFinishAddColumn(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3CompleteInsertion(), sqlite3EndTable(), sqlite3FkCheck(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), sqlite3VdbeAddFunctionCall(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereExplainOneScan(), sqlite3WindowCodeStep(), translateColumnToCopy(), windowAggFinal(), windowAggStep(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowFullScan(), and windowIfNewPeer().

◆ sqlite3VdbeCursorMoveto()

SQLITE_PRIVATE int sqlite3VdbeCursorMoveto	(	VdbeCursor **	pp,
		u32 *	piCol )

Definition at line 81297 of file sqlite3.c.

                                                                       {
  VdbeCursor *p = *pp;
  assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
  if( p->deferredMoveto ){
    u32 iMap;
    if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 && !p->nullRow ){
      *pp = p->pAltCursor;
      *piCol = iMap - 1;
      return SQLITE_OK;
    }
    return sqlite3VdbeFinishMoveto(p);

References VdbeCursor::aAltMap, CURTYPE_BTREE, CURTYPE_PSEUDO, VdbeCursor::deferredMoveto, VdbeCursor::eCurType, handleMovedCursor(), VdbeCursor::nullRow, VdbeCursor::pAltCursor, VdbeCursor::pCursor, sqlite3BtreeCursorHasMoved(), sqlite3VdbeFinishMoveto(), SQLITE_OK, and VdbeCursor::uc.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeCursorRestore()

SQLITE_PRIVATE int sqlite3VdbeCursorRestore ( VdbeCursor * p )

Definition at line 81276 of file sqlite3.c.

81282 {

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeDb()

SQLITE_PRIVATE sqlite3 * sqlite3VdbeDb ( Vdbe * v )

Definition at line 82789 of file sqlite3.c.

Referenced by openStatTable(), sqlite3ColumnDefault(), sqlite3ExprCodeTarget(), sqlite3Reprepare(), sqlite3RunParser(), and sqlite3TableAffinity().

◆ sqlite3VdbeDelete()

SQLITE_PRIVATE void sqlite3VdbeDelete ( Vdbe * p )

Definition at line 81209 of file sqlite3.c.

                                              {
  sqlite3 *db;
 
  assert( p!=0 );
  db = p->db;
  assert( sqlite3_mutex_held(db->mutex) );
  sqlite3VdbeClearObject(db, p);
  if( p->pPrev ){
    p->pPrev->pNext = p->pNext;
  }else{
    assert( db->pVdbe==p );
    db->pVdbe = p->pNext;
  }
  if( p->pNext ){

Referenced by sqlite3RunParser().

◆ sqlite3VdbeDeleteAuxData()

SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData	(	sqlite3 *	db,
		AuxData **	pp,
		int	iOp,
		int	mask )

Definition at line 81140 of file sqlite3.c.

                                                                                          {
  while( *pp ){
    AuxData *pAux = *pp;
    if( (iOp<0)
     || (pAux->iAuxOp==iOp
          && pAux->iAuxArg>=0
          && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
    ){
      testcase( pAux->iAuxArg==31 );
      if( pAux->xDeleteAux ){
        pAux->xDeleteAux(pAux->pAux);
      }
      *pp = pAux->pNextAux;

References AuxData::iAuxArg, AuxData::iAuxOp, mask, MASKBIT32, AuxData::pAux, AuxData::pNextAux, sqlite3DbFree(), testcase, and AuxData::xDeleteAux.

Referenced by closeAllCursors(), sqlite3VdbeExec(), sqlite3VdbeFrameDelete(), and sqlite3VdbeFrameRestore().

◆ sqlite3VdbeDeletePriorOpcode()

SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode	(	Vdbe *	p,
		u8	op )

Definition at line 78949 of file sqlite3.c.

78955 {

Referenced by sqlite3GenerateIndexKey().

◆ sqlite3VdbeDisplayP4()

SQLITE_PRIVATE char * sqlite3VdbeDisplayP4	(	sqlite3 *	db,
		Op *	pOp )

Definition at line 79365 of file sqlite3.c.

                                                               {
  char *zP4 = 0;
  StrAccum x;
 
  sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH);
  switch( pOp->p4type ){
    case P4_KEYINFO: {
      int j;
      KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
      assert( pKeyInfo->aSortFlags!=0 );
      sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
      for(j=0; j<pKeyInfo->nKeyField; j++){
        CollSeq *pColl = pKeyInfo->aColl[j];
        const char *zColl = pColl ? pColl->zName : "";
        if( strcmp(zColl, "BINARY")==0 ) zColl = "B";
        sqlite3_str_appendf(&x, ",%s%s%s",
               (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
               (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
               zColl);
      }
      sqlite3_str_append(&x, ")", 1);
      break;
    }
#ifdef SQLITE_ENABLE_CURSOR_HINTS
    case P4_EXPR: {
      displayP4Expr(&x, pOp->p4.pExpr);
      break;
    }
#endif
    case P4_COLLSEQ: {
      static const char *const encnames[] = {"?", "8", "16LE", "16BE"};
      CollSeq *pColl = pOp->p4.pColl;
      assert( pColl->enc>=0 && pColl->enc<4 );
      sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
                          encnames[pColl->enc]);
      break;
    }
    case P4_FUNCDEF: {
      FuncDef *pDef = pOp->p4.pFunc;
      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
      break;
    }
    case P4_FUNCCTX: {
      FuncDef *pDef = pOp->p4.pCtx->pFunc;
      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
      break;
    }
    case P4_INT64: {
      sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
      break;
    }
    case P4_INT32: {
      sqlite3_str_appendf(&x, "%d", pOp->p4.i);
      break;
    }
    case P4_REAL: {
      sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
      break;
    }
    case P4_MEM: {
      Mem *pMem = pOp->p4.pMem;
      if( pMem->flags & MEM_Str ){
        zP4 = pMem->z;
      }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
        sqlite3_str_appendf(&x, "%lld", pMem->u.i);
      }else if( pMem->flags & MEM_Real ){
        sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
      }else if( pMem->flags & MEM_Null ){
        zP4 = "NULL";
      }else{
        assert( pMem->flags & MEM_Blob );
        zP4 = "(blob)";
      }
      break;
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    case P4_VTAB: {
      sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
      sqlite3_str_appendf(&x, "vtab:%p", pVtab);
      break;
    }
#endif
    case P4_INTARRAY: {
      u32 i;
      u32 *ai = pOp->p4.ai;
      u32 n = ai[0];   /* The first element of an INTARRAY is always the
                       ** count of the number of elements to follow */
      for(i=1; i<=n; i++){
        sqlite3_str_appendf(&x, "%c%u", (i==1 ? '[' : ','), ai[i]);
      }
      sqlite3_str_append(&x, "]", 1);
      break;
    }
    case P4_SUBPROGRAM: {
      zP4 = "program";
      break;
    }
    case P4_DYNBLOB:
    case P4_ADVANCE: {
      break;
    }
    case P4_TABLE: {
      zP4 = pOp->p4.pTab->zName;
      break;
    }
    default: {
      zP4 = pOp->p4.z;
    }
  }

References sqlite3_str::accError, KeyInfo::aColl, VdbeOp::p4union::ai, KeyInfo::aSortFlags, CollSeq::enc, sqlite3_value::flags, VdbeOp::p4union::i, sqlite3_value::MemValue::i, KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, FuncDef::nArg, KeyInfo::nKeyField, VdbeOp::p4, P4_ADVANCE, P4_COLLSEQ, P4_DYNBLOB, P4_EXPR, P4_FUNCCTX, P4_FUNCDEF, P4_INT32, P4_INT64, P4_INTARRAY, P4_KEYINFO, P4_MEM, P4_REAL, P4_SUBPROGRAM, P4_TABLE, P4_VTAB, VdbeOp::p4type, VdbeOp::p4union::pColl, VdbeOp::p4union::pCtx, VdbeOp::p4union::pFunc, sqlite3_context::pFunc, VdbeOp::p4union::pI64, VdbeOp::p4union::pKeyInfo, VdbeOp::p4union::pMem, VdbeOp::p4union::pReal, VdbeOp::p4union::pTab, VdbeOp::p4union::pVtab, VTable::pVtab, sqlite3_value::MemValue::r, sqlite3_str_append(), sqlite3_str_appendall(), sqlite3_str_appendf(), sqlite3OomFault(), sqlite3StrAccumFinish(), sqlite3StrAccumInit(), SQLITE_MAX_LENGTH, SQLITE_NOMEM, sqlite3_value::u, VdbeOp::p4union::z, sqlite3_value::z, FuncDef::zName, CollSeq::zName, and Table::zName.

Referenced by sqlite3VdbeList().

◆ sqlite3VdbeEndCoroutine()

SQLITE_PRIVATE void sqlite3VdbeEndCoroutine	(	Vdbe *	v,
		int	regYield )

Definition at line 78234 of file sqlite3.c.

                                                                  {
  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
 
  /* Clear the temporary register cache, thereby ensuring that each
  ** co-routine has its own independent set of registers, because co-routines
  ** might expect their registers to be preserved across an OP_Yield, and

Referenced by multiSelectOrderBy(), sqlite3EndTable(), sqlite3Insert(), and sqlite3Select().

◆ sqlite3VdbeEnter()

SQLITE_PRIVATE void sqlite3VdbeEnter ( Vdbe * p )

Definition at line 79521 of file sqlite3.c.

                                             {
  int i;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( DbMaskAllZero(p->lockMask) ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;

References sqlite3::aDb, ALWAYS, Vdbe::db, DbMaskAllZero, DbMaskTest, Vdbe::lockMask, sqlite3::nDb, and sqlite3BtreeEnter().

Referenced by sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3VdbeError()

SQLITE_PRIVATE void sqlite3VdbeError	(	Vdbe *	p,
		const char *	zFormat,
			... )

Definition at line 77791 of file sqlite3.c.

77797 {

Referenced by sqlite3VdbeCheckFk(), sqlite3VdbeExec(), and sqlite3VdbeList().

◆ sqlite3VdbeExec()

SQLITE_PRIVATE int sqlite3VdbeExec ( Vdbe * p )

Definition at line 85979 of file sqlite3.c.

 {
  Op *aOp = p->aOp;          /* Copy of p->aOp */
  Op *pOp = aOp;             /* Current operation */
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
  Op *pOrigOp;               /* Value of pOp at the top of the loop */
#endif
#ifdef SQLITE_DEBUG
  int nExtraDelete = 0;      /* Verifies FORDELETE and AUXDELETE flags */
#endif
  int rc = SQLITE_OK;        /* Value to return */
  sqlite3 *db = p->db;       /* The database */
  u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
  u8 encoding = ENC(db);     /* The database encoding */
  int iCompare = 0;          /* Result of last comparison */
  u64 nVmStep = 0;           /* Number of virtual machine steps */
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  u64 nProgressLimit;        /* Invoke xProgress() when nVmStep reaches this */
#endif
  Mem *aMem = p->aMem;       /* Copy of p->aMem */
  Mem *pIn1 = 0;             /* 1st input operand */
  Mem *pIn2 = 0;             /* 2nd input operand */
  Mem *pIn3 = 0;             /* 3rd input operand */
  Mem *pOut = 0;             /* Output operand */
#ifdef VDBE_PROFILE
  u64 start;                 /* CPU clock count at start of opcode */
#endif
  /*** INSERT STACK UNION HERE ***/
 
  assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
  sqlite3VdbeEnter(p);
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  if( db->xProgress ){
    u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
    assert( 0 < db->nProgressOps );
    nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
  }else{
    nProgressLimit = LARGEST_UINT64;
  }
#endif
  if( p->rc==SQLITE_NOMEM ){
    /* This happens if a malloc() inside a call to sqlite3_column_text() or
    ** sqlite3_column_text16() failed.  */
    goto no_mem;
  }
  assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
  testcase( p->rc!=SQLITE_OK );
  p->rc = SQLITE_OK;
  assert( p->bIsReader || p->readOnly!=0 );
  p->iCurrentTime = 0;
  assert( p->explain==0 );
  p->pResultSet = 0;
  db->busyHandler.nBusy = 0;
  if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
  sqlite3VdbeIOTraceSql(p);
#ifdef SQLITE_DEBUG
  sqlite3BeginBenignMalloc();
  if( p->pc==0
   && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
  ){
    int i;
    int once = 1;
    sqlite3VdbePrintSql(p);
    if( p->db->flags & SQLITE_VdbeListing ){
      printf("VDBE Program Listing:\n");
      for(i=0; i<p->nOp; i++){
        sqlite3VdbePrintOp(stdout, i, &aOp[i]);
      }
    }
    if( p->db->flags & SQLITE_VdbeEQP ){
      for(i=0; i<p->nOp; i++){
        if( aOp[i].opcode==OP_Explain ){
          if( once ) printf("VDBE Query Plan:\n");
          printf("%s\n", aOp[i].p4.z);
          once = 0;
        }
      }
    }
    if( p->db->flags & SQLITE_VdbeTrace )  printf("VDBE Trace:\n");
  }
  sqlite3EndBenignMalloc();
#endif
  for(pOp=&aOp[p->pc]; 1; pOp++){
    /* Errors are detected by individual opcodes, with an immediate
    ** jumps to abort_due_to_error. */
    assert( rc==SQLITE_OK );
 
    assert( pOp>=aOp && pOp<&aOp[p->nOp]);
#ifdef VDBE_PROFILE
    start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
#endif
    nVmStep++;
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
    if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
#endif
 
    /* Only allow tracing if SQLITE_DEBUG is defined.
    */
#ifdef SQLITE_DEBUG
    if( db->flags & SQLITE_VdbeTrace ){
      sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
      test_trace_breakpoint((int)(pOp - aOp),pOp,p);
    }
#endif
 
 
    /* Check to see if we need to simulate an interrupt.  This only happens
    ** if we have a special test build.
    */
#ifdef SQLITE_TEST
    if( sqlite3_interrupt_count>0 ){
      sqlite3_interrupt_count--;
      if( sqlite3_interrupt_count==0 ){
        sqlite3_interrupt(db);
      }
    }
#endif
 
    /* Sanity checking on other operands */
#ifdef SQLITE_DEBUG
    {
      u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
      if( (opProperty & OPFLG_IN1)!=0 ){
        assert( pOp->p1>0 );
        assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
        assert( memIsValid(&aMem[pOp->p1]) );
        assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
        REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
      }
      if( (opProperty & OPFLG_IN2)!=0 ){
        assert( pOp->p2>0 );
        assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
        assert( memIsValid(&aMem[pOp->p2]) );
        assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
        REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
      }
      if( (opProperty & OPFLG_IN3)!=0 ){
        assert( pOp->p3>0 );
        assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
        assert( memIsValid(&aMem[pOp->p3]) );
        assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
        REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
      }
      if( (opProperty & OPFLG_OUT2)!=0 ){
        assert( pOp->p2>0 );
        assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
        memAboutToChange(p, &aMem[pOp->p2]);
      }
      if( (opProperty & OPFLG_OUT3)!=0 ){
        assert( pOp->p3>0 );
        assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
        memAboutToChange(p, &aMem[pOp->p3]);
      }
    }
#endif
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
    pOrigOp = pOp;
#endif
 
    switch( pOp->opcode ){
 
/*****************************************************************************
** What follows is a massive switch statement where each case implements a
** separate instruction in the virtual machine.  If we follow the usual
** indentation conventions, each case should be indented by 6 spaces.  But
** that is a lot of wasted space on the left margin.  So the code within
** the switch statement will break with convention and be flush-left. Another
** big comment (similar to this one) will mark the point in the code where
** we transition back to normal indentation.
**
** The formatting of each case is important.  The makefile for SQLite
** generates two C files "opcodes.h" and "opcodes.c" by scanning this
** file looking for lines that begin with "case OP_".  The opcodes.h files
** will be filled with #defines that give unique integer values to each
** opcode and the opcodes.c file is filled with an array of strings where
** each string is the symbolic name for the corresponding opcode.  If the
** case statement is followed by a comment of the form "/# same as ... #/"
** that comment is used to determine the particular value of the opcode.
**
** Other keywords in the comment that follows each case are used to
** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
** Keywords include: in1, in2, in3, out2, out3.  See
** the mkopcodeh.awk script for additional information.
**
** Documentation about VDBE opcodes is generated by scanning this file
** for lines of that contain "Opcode:".  That line and all subsequent
** comment lines are used in the generation of the opcode.html documentation
** file.
**
** SUMMARY:
**
**     Formatting is important to scripts that scan this file.
**     Do not deviate from the formatting style currently in use.
**
*****************************************************************************/
 
/* Opcode:  Goto * P2 * * *
**
** An unconditional jump to address P2.
** The next instruction executed will be
** the one at index P2 from the beginning of
** the program.
**
** The P1 parameter is not actually used by this opcode.  However, it
** is sometimes set to 1 instead of 0 as a hint to the command-line shell
** that this Goto is the bottom of a loop and that the lines from P2 down
** to the current line should be indented for EXPLAIN output.
*/
case OP_Goto: {             /* jump */
 
#ifdef SQLITE_DEBUG
  /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
  ** means we should really jump back to the preceeding OP_ReleaseReg
  ** instruction. */
  if( pOp->p5 ){
    assert( pOp->p2 < (int)(pOp - aOp) );
    assert( pOp->p2 > 1 );
    pOp = &aOp[pOp->p2 - 2];
    assert( pOp[1].opcode==OP_ReleaseReg );
    goto check_for_interrupt;
  }
#endif
 
jump_to_p2_and_check_for_interrupt:
  pOp = &aOp[pOp->p2 - 1];
 
  /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
  ** OP_VNext, or OP_SorterNext) all jump here upon
  ** completion.  Check to see if sqlite3_interrupt() has been called
  ** or if the progress callback needs to be invoked.
  **
  ** This code uses unstructured "goto" statements and does not look clean.
  ** But that is not due to sloppy coding habits. The code is written this
  ** way for performance, to avoid having to run the interrupt and progress
  ** checks on every opcode.  This helps sqlite3_step() to run about 1.5%
  ** faster according to "valgrind --tool=cachegrind" */
check_for_interrupt:
  if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  /* Call the progress callback if it is configured and the required number
  ** of VDBE ops have been executed (either since this invocation of
  ** sqlite3VdbeExec() or since last time the progress callback was called).
  ** If the progress callback returns non-zero, exit the virtual machine with
  ** a return code SQLITE_ABORT.
  */
  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
    assert( db->nProgressOps!=0 );
    nProgressLimit += db->nProgressOps;
    if( db->xProgress(db->pProgressArg) ){
      nProgressLimit = LARGEST_UINT64;
      rc = SQLITE_INTERRUPT;
      goto abort_due_to_error;
    }
  }
#endif
 
  break;
}
 
/* Opcode:  Gosub P1 P2 * * *
**
** Write the current address onto register P1
** and then jump to address P2.
*/
case OP_Gosub: {            /* jump */
  assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
  pIn1 = &aMem[pOp->p1];
  assert( VdbeMemDynamic(pIn1)==0 );
  memAboutToChange(p, pIn1);
  pIn1->flags = MEM_Int;
  pIn1->u.i = (int)(pOp-aOp);
  REGISTER_TRACE(pOp->p1, pIn1);
 
  /* Most jump operations do a goto to this spot in order to update
  ** the pOp pointer. */
jump_to_p2:
  pOp = &aOp[pOp->p2 - 1];
  break;
}
 
/* Opcode:  Return P1 * * * *
**
** Jump to the next instruction after the address in register P1.  After
** the jump, register P1 becomes undefined.
*/
case OP_Return: {           /* in1 */
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags==MEM_Int );
  pOp = &aOp[pIn1->u.i];
  pIn1->flags = MEM_Undefined;
  break;
}
 
/* Opcode: InitCoroutine P1 P2 P3 * *
**
** Set up register P1 so that it will Yield to the coroutine
** located at address P3.
**
** If P2!=0 then the coroutine implementation immediately follows
** this opcode.  So jump over the coroutine implementation to
** address P2.
**
** See also: EndCoroutine
*/
case OP_InitCoroutine: {     /* jump */
  assert( pOp->p1>0 &&  pOp->p1<=(p->nMem+1 - p->nCursor) );
  assert( pOp->p2>=0 && pOp->p2<p->nOp );
  assert( pOp->p3>=0 && pOp->p3<p->nOp );
  pOut = &aMem[pOp->p1];
  assert( !VdbeMemDynamic(pOut) );
  pOut->u.i = pOp->p3 - 1;
  pOut->flags = MEM_Int;
  if( pOp->p2 ) goto jump_to_p2;
  break;
}
 
/* Opcode:  EndCoroutine P1 * * * *
**
** The instruction at the address in register P1 is a Yield.
** Jump to the P2 parameter of that Yield.
** After the jump, register P1 becomes undefined.
**
** See also: InitCoroutine
*/
case OP_EndCoroutine: {           /* in1 */
  VdbeOp *pCaller;
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags==MEM_Int );
  assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
  pCaller = &aOp[pIn1->u.i];
  assert( pCaller->opcode==OP_Yield );
  assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
  pOp = &aOp[pCaller->p2 - 1];
  pIn1->flags = MEM_Undefined;
  break;
}
 
/* Opcode:  Yield P1 P2 * * *
**
** Swap the program counter with the value in register P1.  This
** has the effect of yielding to a coroutine.
**
** If the coroutine that is launched by this instruction ends with
** Yield or Return then continue to the next instruction.  But if
** the coroutine launched by this instruction ends with
** EndCoroutine, then jump to P2 rather than continuing with the
** next instruction.
**
** See also: InitCoroutine
*/
case OP_Yield: {            /* in1, jump */
  int pcDest;
  pIn1 = &aMem[pOp->p1];
  assert( VdbeMemDynamic(pIn1)==0 );
  pIn1->flags = MEM_Int;
  pcDest = (int)pIn1->u.i;
  pIn1->u.i = (int)(pOp - aOp);
  REGISTER_TRACE(pOp->p1, pIn1);
  pOp = &aOp[pcDest];
  break;
}
 
/* Opcode:  HaltIfNull  P1 P2 P3 P4 P5
** Synopsis: if r[P3]=null halt
**
** Check the value in register P3.  If it is NULL then Halt using
** parameter P1, P2, and P4 as if this were a Halt instruction.  If the
** value in register P3 is not NULL, then this routine is a no-op.
** The P5 parameter should be 1.
*/
case OP_HaltIfNull: {      /* in3 */
  pIn3 = &aMem[pOp->p3];
#ifdef SQLITE_DEBUG
  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
#endif
  if( (pIn3->flags & MEM_Null)==0 ) break;
  /* Fall through into OP_Halt */
  /* no break */ deliberate_fall_through
}
 
/* Opcode:  Halt P1 P2 * P4 P5
**
** Exit immediately.  All open cursors, etc are closed
** automatically.
**
** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).
** For errors, it can be some other value.  If P1!=0 then P2 will determine
** whether or not to rollback the current transaction.  Do not rollback
** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
** then back out all changes that have occurred during this execution of the
** VDBE, but do not rollback the transaction.
**
** If P4 is not null then it is an error message string.
**
** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
**
**    0:  (no change)
**    1:  NOT NULL contraint failed: P4
**    2:  UNIQUE constraint failed: P4
**    3:  CHECK constraint failed: P4
**    4:  FOREIGN KEY constraint failed: P4
**
** If P5 is not zero and P4 is NULL, then everything after the ":" is
** omitted.
**
** There is an implied "Halt 0 0 0" instruction inserted at the very end of
** every program.  So a jump past the last instruction of the program
** is the same as executing Halt.
*/
case OP_Halt: {
  VdbeFrame *pFrame;
  int pcx;
 
  pcx = (int)(pOp - aOp);
#ifdef SQLITE_DEBUG
  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
#endif
  if( pOp->p1==SQLITE_OK && p->pFrame ){
    /* Halt the sub-program. Return control to the parent frame. */
    pFrame = p->pFrame;
    p->pFrame = pFrame->pParent;
    p->nFrame--;
    sqlite3VdbeSetChanges(db, p->nChange);
    pcx = sqlite3VdbeFrameRestore(pFrame);
    if( pOp->p2==OE_Ignore ){
      /* Instruction pcx is the OP_Program that invoked the sub-program
      ** currently being halted. If the p2 instruction of this OP_Halt
      ** instruction is set to OE_Ignore, then the sub-program is throwing
      ** an IGNORE exception. In this case jump to the address specified
      ** as the p2 of the calling OP_Program.  */
      pcx = p->aOp[pcx].p2-1;
    }
    aOp = p->aOp;
    aMem = p->aMem;
    pOp = &aOp[pcx];
    break;
  }
  p->rc = pOp->p1;
  p->errorAction = (u8)pOp->p2;
  p->pc = pcx;
  assert( pOp->p5<=4 );
  if( p->rc ){
    if( pOp->p5 ){
      static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
                                             "FOREIGN KEY" };
      testcase( pOp->p5==1 );
      testcase( pOp->p5==2 );
      testcase( pOp->p5==3 );
      testcase( pOp->p5==4 );
      sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
      if( pOp->p4.z ){
        p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
      }
    }else{
      sqlite3VdbeError(p, "%s", pOp->p4.z);
    }
    sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
  }
  rc = sqlite3VdbeHalt(p);
  assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
  if( rc==SQLITE_BUSY ){
    p->rc = SQLITE_BUSY;
  }else{
    assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
    assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
    rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
  }
  goto vdbe_return;
}
 
/* Opcode: Integer P1 P2 * * *
** Synopsis: r[P2]=P1
**
** The 32-bit integer value P1 is written into register P2.
*/
case OP_Integer: {         /* out2 */
  pOut = out2Prerelease(p, pOp);
  pOut->u.i = pOp->p1;
  break;
}
 
/* Opcode: Int64 * P2 * P4 *
** Synopsis: r[P2]=P4
**
** P4 is a pointer to a 64-bit integer value.
** Write that value into register P2.
*/
case OP_Int64: {           /* out2 */
  pOut = out2Prerelease(p, pOp);
  assert( pOp->p4.pI64!=0 );
  pOut->u.i = *pOp->p4.pI64;
  break;
}
 
#ifndef SQLITE_OMIT_FLOATING_POINT
/* Opcode: Real * P2 * P4 *
** Synopsis: r[P2]=P4
**
** P4 is a pointer to a 64-bit floating point value.
** Write that value into register P2.
*/
case OP_Real: {            /* same as TK_FLOAT, out2 */
  pOut = out2Prerelease(p, pOp);
  pOut->flags = MEM_Real;
  assert( !sqlite3IsNaN(*pOp->p4.pReal) );
  pOut->u.r = *pOp->p4.pReal;
  break;
}
#endif
 
/* Opcode: String8 * P2 * P4 *
** Synopsis: r[P2]='P4'
**
** P4 points to a nul terminated UTF-8 string. This opcode is transformed
** into a String opcode before it is executed for the first time.  During
** this transformation, the length of string P4 is computed and stored
** as the P1 parameter.
*/
case OP_String8: {         /* same as TK_STRING, out2 */
  assert( pOp->p4.z!=0 );
  pOut = out2Prerelease(p, pOp);
  pOp->p1 = sqlite3Strlen30(pOp->p4.z);
 
#ifndef SQLITE_OMIT_UTF16
  if( encoding!=SQLITE_UTF8 ){
    rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
    assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
    if( rc ) goto too_big;
    if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
    assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
    assert( VdbeMemDynamic(pOut)==0 );
    pOut->szMalloc = 0;
    pOut->flags |= MEM_Static;
    if( pOp->p4type==P4_DYNAMIC ){
      sqlite3DbFree(db, pOp->p4.z);
    }
    pOp->p4type = P4_DYNAMIC;
    pOp->p4.z = pOut->z;
    pOp->p1 = pOut->n;
  }
#endif
  if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
    goto too_big;
  }
  pOp->opcode = OP_String;
  assert( rc==SQLITE_OK );
  /* Fall through to the next case, OP_String */
  /* no break */ deliberate_fall_through
}
 
/* Opcode: String P1 P2 P3 P4 P5
** Synopsis: r[P2]='P4' (len=P1)
**
** The string value P4 of length P1 (bytes) is stored in register P2.
**
** If P3 is not zero and the content of register P3 is equal to P5, then
** the datatype of the register P2 is converted to BLOB.  The content is
** the same sequence of bytes, it is merely interpreted as a BLOB instead
** of a string, as if it had been CAST.  In other words:
**
** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
*/
case OP_String: {          /* out2 */
  assert( pOp->p4.z!=0 );
  pOut = out2Prerelease(p, pOp);
  pOut->flags = MEM_Str|MEM_Static|MEM_Term;
  pOut->z = pOp->p4.z;
  pOut->n = pOp->p1;
  pOut->enc = encoding;
  UPDATE_MAX_BLOBSIZE(pOut);
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
  if( pOp->p3>0 ){
    assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
    pIn3 = &aMem[pOp->p3];
    assert( pIn3->flags & MEM_Int );
    if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
  }
#endif
  break;
}
 
/* Opcode: Null P1 P2 P3 * *
** Synopsis: r[P2..P3]=NULL
**
** Write a NULL into registers P2.  If P3 greater than P2, then also write
** NULL into register P3 and every register in between P2 and P3.  If P3
** is less than P2 (typically P3 is zero) then only register P2 is
** set to NULL.
**
** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
** NULL values will not compare equal even if SQLITE_NULLEQ is set on
** OP_Ne or OP_Eq.
*/
case OP_Null: {           /* out2 */
  int cnt;
  u16 nullFlag;
  pOut = out2Prerelease(p, pOp);
  cnt = pOp->p3-pOp->p2;
  assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
  pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
  pOut->n = 0;
#ifdef SQLITE_DEBUG
  pOut->uTemp = 0;
#endif
  while( cnt>0 ){
    pOut++;
    memAboutToChange(p, pOut);
    sqlite3VdbeMemSetNull(pOut);
    pOut->flags = nullFlag;
    pOut->n = 0;
    cnt--;
  }
  break;
}
 
/* Opcode: SoftNull P1 * * * *
** Synopsis: r[P1]=NULL
**
** Set register P1 to have the value NULL as seen by the OP_MakeRecord
** instruction, but do not free any string or blob memory associated with
** the register, so that if the value was a string or blob that was
** previously copied using OP_SCopy, the copies will continue to be valid.
*/
case OP_SoftNull: {
  assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
  pOut = &aMem[pOp->p1];
  pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
  break;
}
 
/* Opcode: Blob P1 P2 * P4 *
** Synopsis: r[P2]=P4 (len=P1)
**
** P4 points to a blob of data P1 bytes long.  Store this
** blob in register P2.
*/
case OP_Blob: {                /* out2 */
  assert( pOp->p1 <= SQLITE_MAX_LENGTH );
  pOut = out2Prerelease(p, pOp);
  sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
  pOut->enc = encoding;
  UPDATE_MAX_BLOBSIZE(pOut);
  break;
}
 
/* Opcode: Variable P1 P2 * P4 *
** Synopsis: r[P2]=parameter(P1,P4)
**
** Transfer the values of bound parameter P1 into register P2
**
** If the parameter is named, then its name appears in P4.
** The P4 value is used by sqlite3_bind_parameter_name().
*/
case OP_Variable: {            /* out2 */
  Mem *pVar;       /* Value being transferred */
 
  assert( pOp->p1>0 && pOp->p1<=p->nVar );
  assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
  pVar = &p->aVar[pOp->p1 - 1];
  if( sqlite3VdbeMemTooBig(pVar) ){
    goto too_big;
  }
  pOut = &aMem[pOp->p2];
  if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
  memcpy(pOut, pVar, MEMCELLSIZE);
  pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
  pOut->flags |= MEM_Static|MEM_FromBind;
  UPDATE_MAX_BLOBSIZE(pOut);
  break;
}
 
/* Opcode: Move P1 P2 P3 * *
** Synopsis: r[P2@P3]=r[P1@P3]
**
** Move the P3 values in register P1..P1+P3-1 over into
** registers P2..P2+P3-1.  Registers P1..P1+P3-1 are
** left holding a NULL.  It is an error for register ranges
** P1..P1+P3-1 and P2..P2+P3-1 to overlap.  It is an error
** for P3 to be less than 1.
*/
case OP_Move: {
  int n;           /* Number of registers left to copy */
  int p1;          /* Register to copy from */
  int p2;          /* Register to copy to */
 
  n = pOp->p3;
  p1 = pOp->p1;
  p2 = pOp->p2;
  assert( n>0 && p1>0 && p2>0 );
  assert( p1+n<=p2 || p2+n<=p1 );
 
  pIn1 = &aMem[p1];
  pOut = &aMem[p2];
  do{
    assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
    assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
    assert( memIsValid(pIn1) );
    memAboutToChange(p, pOut);
    sqlite3VdbeMemMove(pOut, pIn1);
#ifdef SQLITE_DEBUG
    pIn1->pScopyFrom = 0;
    { int i;
      for(i=1; i<p->nMem; i++){
        if( aMem[i].pScopyFrom==pIn1 ){
          aMem[i].pScopyFrom = pOut;
        }
      }
    }
#endif
    Deephemeralize(pOut);
    REGISTER_TRACE(p2++, pOut);
    pIn1++;
    pOut++;
  }while( --n );
  break;
}
 
/* Opcode: Copy P1 P2 P3 * *
** Synopsis: r[P2@P3+1]=r[P1@P3+1]
**
** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
**
** This instruction makes a deep copy of the value.  A duplicate
** is made of any string or blob constant.  See also OP_SCopy.
*/
case OP_Copy: {
  int n;
 
  n = pOp->p3;
  pIn1 = &aMem[pOp->p1];
  pOut = &aMem[pOp->p2];
  assert( pOut!=pIn1 );
  while( 1 ){
    memAboutToChange(p, pOut);
    sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
    Deephemeralize(pOut);
#ifdef SQLITE_DEBUG
    pOut->pScopyFrom = 0;
#endif
    REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
    if( (n--)==0 ) break;
    pOut++;
    pIn1++;
  }
  break;
}
 
/* Opcode: SCopy P1 P2 * * *
** Synopsis: r[P2]=r[P1]
**
** Make a shallow copy of register P1 into register P2.
**
** This instruction makes a shallow copy of the value.  If the value
** is a string or blob, then the copy is only a pointer to the
** original and hence if the original changes so will the copy.
** Worse, if the original is deallocated, the copy becomes invalid.
** Thus the program must guarantee that the original will not change
** during the lifetime of the copy.  Use OP_Copy to make a complete
** copy.
*/
case OP_SCopy: {            /* out2 */
  pIn1 = &aMem[pOp->p1];
  pOut = &aMem[pOp->p2];
  assert( pOut!=pIn1 );
  sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
#ifdef SQLITE_DEBUG
  pOut->pScopyFrom = pIn1;
  pOut->mScopyFlags = pIn1->flags;
#endif
  break;
}
 
/* Opcode: IntCopy P1 P2 * * *
** Synopsis: r[P2]=r[P1]
**
** Transfer the integer value held in register P1 into register P2.
**
** This is an optimized version of SCopy that works only for integer
** values.
*/
case OP_IntCopy: {            /* out2 */
  pIn1 = &aMem[pOp->p1];
  assert( (pIn1->flags & MEM_Int)!=0 );
  pOut = &aMem[pOp->p2];
  sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
  break;
}
 
/* Opcode: ResultRow P1 P2 * * *
** Synopsis: output=r[P1@P2]
**
** The registers P1 through P1+P2-1 contain a single row of
** results. This opcode causes the sqlite3_step() call to terminate
** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
** structure to provide access to the r(P1)..r(P1+P2-1) values as
** the result row.
*/
case OP_ResultRow: {
  Mem *pMem;
  int i;
  assert( p->nResColumn==pOp->p2 );
  assert( pOp->p1>0 );
  assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
 
  /* If this statement has violated immediate foreign key constraints, do
  ** not return the number of rows modified. And do not RELEASE the statement
  ** transaction. It needs to be rolled back.  */
  if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
    assert( db->flags&SQLITE_CountRows );
    assert( p->usesStmtJournal );
    goto abort_due_to_error;
  }
 
  /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
  ** DML statements invoke this opcode to return the number of rows
  ** modified to the user. This is the only way that a VM that
  ** opens a statement transaction may invoke this opcode.
  **
  ** In case this is such a statement, close any statement transaction
  ** opened by this VM before returning control to the user. This is to
  ** ensure that statement-transactions are always nested, not overlapping.
  ** If the open statement-transaction is not closed here, then the user
  ** may step another VM that opens its own statement transaction. This
  ** may lead to overlapping statement transactions.
  **
  ** The statement transaction is never a top-level transaction.  Hence
  ** the RELEASE call below can never fail.
  */
  assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
  rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
  assert( rc==SQLITE_OK );
 
  /* Invalidate all ephemeral cursor row caches */
  p->cacheCtr = (p->cacheCtr + 2)|1;
 
  /* Make sure the results of the current row are \000 terminated
  ** and have an assigned type.  The results are de-ephemeralized as
  ** a side effect.
  */
  pMem = p->pResultSet = &aMem[pOp->p1];
  for(i=0; i<pOp->p2; i++){
    assert( memIsValid(&pMem[i]) );
    Deephemeralize(&pMem[i]);
    assert( (pMem[i].flags & MEM_Ephem)==0
            || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
    sqlite3VdbeMemNulTerminate(&pMem[i]);
    REGISTER_TRACE(pOp->p1+i, &pMem[i]);
#ifdef SQLITE_DEBUG
    /* The registers in the result will not be used again when the
    ** prepared statement restarts.  This is because sqlite3_column()
    ** APIs might have caused type conversions of made other changes to
    ** the register values.  Therefore, we can go ahead and break any
    ** OP_SCopy dependencies. */
    pMem[i].pScopyFrom = 0;
#endif
  }
  if( db->mallocFailed ) goto no_mem;
 
  if( db->mTrace & SQLITE_TRACE_ROW ){
    db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
  }
 
 
  /* Return SQLITE_ROW
  */
  p->pc = (int)(pOp - aOp) + 1;
  rc = SQLITE_ROW;
  goto vdbe_return;
}
 
/* Opcode: Concat P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]+r[P1]
**
** Add the text in register P1 onto the end of the text in
** register P2 and store the result in register P3.
** If either the P1 or P2 text are NULL then store NULL in P3.
**
**   P3 = P2 || P1
**
** It is illegal for P1 and P3 to be the same register. Sometimes,
** if P3 is the same register as P2, the implementation is able
** to avoid a memcpy().
*/
case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
  i64 nByte;          /* Total size of the output string or blob */
  u16 flags1;         /* Initial flags for P1 */
  u16 flags2;         /* Initial flags for P2 */
 
  pIn1 = &aMem[pOp->p1];
  pIn2 = &aMem[pOp->p2];
  pOut = &aMem[pOp->p3];
  testcase( pOut==pIn2 );
  assert( pIn1!=pOut );
  flags1 = pIn1->flags;
  testcase( flags1 & MEM_Null );
  testcase( pIn2->flags & MEM_Null );
  if( (flags1 | pIn2->flags) & MEM_Null ){
    sqlite3VdbeMemSetNull(pOut);
    break;
  }
  if( (flags1 & (MEM_Str|MEM_Blob))==0 ){
    if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem;
    flags1 = pIn1->flags & ~MEM_Str;
  }else if( (flags1 & MEM_Zero)!=0 ){
    if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem;
    flags1 = pIn1->flags & ~MEM_Str;
  }
  flags2 = pIn2->flags;
  if( (flags2 & (MEM_Str|MEM_Blob))==0 ){
    if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem;
    flags2 = pIn2->flags & ~MEM_Str;
  }else if( (flags2 & MEM_Zero)!=0 ){
    if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem;
    flags2 = pIn2->flags & ~MEM_Str;
  }
  nByte = pIn1->n + pIn2->n;
  if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
    goto too_big;
  }
  if( sqlite3VdbeMemGrow(pOut, (int)nByte+3, pOut==pIn2) ){
    goto no_mem;
  }
  MemSetTypeFlag(pOut, MEM_Str);
  if( pOut!=pIn2 ){
    memcpy(pOut->z, pIn2->z, pIn2->n);
    assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
    pIn2->flags = flags2;
  }
  memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
  assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
  pIn1->flags = flags1;
  pOut->z[nByte]=0;
  pOut->z[nByte+1] = 0;
  pOut->z[nByte+2] = 0;
  pOut->flags |= MEM_Term;
  pOut->n = (int)nByte;
  pOut->enc = encoding;
  UPDATE_MAX_BLOBSIZE(pOut);
  break;
}
 
/* Opcode: Add P1 P2 P3 * *
** Synopsis: r[P3]=r[P1]+r[P2]
**
** Add the value in register P1 to the value in register P2
** and store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: Multiply P1 P2 P3 * *
** Synopsis: r[P3]=r[P1]*r[P2]
**
**
** Multiply the value in register P1 by the value in register P2
** and store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: Subtract P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]-r[P1]
**
** Subtract the value in register P1 from the value in register P2
** and store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: Divide P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]/r[P1]
**
** Divide the value in register P1 by the value in register P2
** and store the result in register P3 (P3=P2/P1). If the value in
** register P1 is zero, then the result is NULL. If either input is
** NULL, the result is NULL.
*/
/* Opcode: Remainder P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]%r[P1]
**
** Compute the remainder after integer register P2 is divided by
** register P1 and store the result in register P3.
** If the value in register P1 is zero the result is NULL.
** If either operand is NULL, the result is NULL.
*/
case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
  u16 flags;      /* Combined MEM_* flags from both inputs */
  u16 type1;      /* Numeric type of left operand */
  u16 type2;      /* Numeric type of right operand */
  i64 iA;         /* Integer value of left operand */
  i64 iB;         /* Integer value of right operand */
  double rA;      /* Real value of left operand */
  double rB;      /* Real value of right operand */
 
  pIn1 = &aMem[pOp->p1];
  type1 = numericType(pIn1);
  pIn2 = &aMem[pOp->p2];
  type2 = numericType(pIn2);
  pOut = &aMem[pOp->p3];
  flags = pIn1->flags | pIn2->flags;
  if( (type1 & type2 & MEM_Int)!=0 ){
    iA = pIn1->u.i;
    iB = pIn2->u.i;
    switch( pOp->opcode ){
      case OP_Add:       if( sqlite3AddInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Subtract:  if( sqlite3SubInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Multiply:  if( sqlite3MulInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Divide: {
        if( iA==0 ) goto arithmetic_result_is_null;
        if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
        iB /= iA;
        break;
      }
      default: {
        if( iA==0 ) goto arithmetic_result_is_null;
        if( iA==-1 ) iA = 1;
        iB %= iA;
        break;
      }
    }
    pOut->u.i = iB;
    MemSetTypeFlag(pOut, MEM_Int);
  }else if( (flags & MEM_Null)!=0 ){
    goto arithmetic_result_is_null;
  }else{
fp_math:
    rA = sqlite3VdbeRealValue(pIn1);
    rB = sqlite3VdbeRealValue(pIn2);
    switch( pOp->opcode ){
      case OP_Add:         rB += rA;       break;
      case OP_Subtract:    rB -= rA;       break;
      case OP_Multiply:    rB *= rA;       break;
      case OP_Divide: {
        /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
        if( rA==(double)0 ) goto arithmetic_result_is_null;
        rB /= rA;
        break;
      }
      default: {
        iA = sqlite3VdbeIntValue(pIn1);
        iB = sqlite3VdbeIntValue(pIn2);
        if( iA==0 ) goto arithmetic_result_is_null;
        if( iA==-1 ) iA = 1;
        rB = (double)(iB % iA);
        break;
      }
    }
#ifdef SQLITE_OMIT_FLOATING_POINT
    pOut->u.i = rB;
    MemSetTypeFlag(pOut, MEM_Int);
#else
    if( sqlite3IsNaN(rB) ){
      goto arithmetic_result_is_null;
    }
    pOut->u.r = rB;
    MemSetTypeFlag(pOut, MEM_Real);
#endif
  }
  break;
 
arithmetic_result_is_null:
  sqlite3VdbeMemSetNull(pOut);
  break;
}
 
/* Opcode: CollSeq P1 * * P4
**
** P4 is a pointer to a CollSeq object. If the next call to a user function
** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
** be returned. This is used by the built-in min(), max() and nullif()
** functions.
**
** If P1 is not zero, then it is a register that a subsequent min() or
** max() aggregate will set to 1 if the current row is not the minimum or
** maximum.  The P1 register is initialized to 0 by this instruction.
**
** The interface used by the implementation of the aforementioned functions
** to retrieve the collation sequence set by this opcode is not available
** publicly.  Only built-in functions have access to this feature.
*/
case OP_CollSeq: {
  assert( pOp->p4type==P4_COLLSEQ );
  if( pOp->p1 ){
    sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
  }
  break;
}
 
/* Opcode: BitAnd P1 P2 P3 * *
** Synopsis: r[P3]=r[P1]&r[P2]
**
** Take the bit-wise AND of the values in register P1 and P2 and
** store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: BitOr P1 P2 P3 * *
** Synopsis: r[P3]=r[P1]|r[P2]
**
** Take the bit-wise OR of the values in register P1 and P2 and
** store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: ShiftLeft P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]<<r[P1]
**
** Shift the integer value in register P2 to the left by the
** number of bits specified by the integer in register P1.
** Store the result in register P3.
** If either input is NULL, the result is NULL.
*/
/* Opcode: ShiftRight P1 P2 P3 * *
** Synopsis: r[P3]=r[P2]>>r[P1]
**
** Shift the integer value in register P2 to the right by the
** number of bits specified by the integer in register P1.
** Store the result in register P3.
** If either input is NULL, the result is NULL.
*/
case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
  i64 iA;
  u64 uA;
  i64 iB;
  u8 op;
 
  pIn1 = &aMem[pOp->p1];
  pIn2 = &aMem[pOp->p2];
  pOut = &aMem[pOp->p3];
  if( (pIn1->flags | pIn2->flags) & MEM_Null ){
    sqlite3VdbeMemSetNull(pOut);
    break;
  }
  iA = sqlite3VdbeIntValue(pIn2);
  iB = sqlite3VdbeIntValue(pIn1);
  op = pOp->opcode;
  if( op==OP_BitAnd ){
    iA &= iB;
  }else if( op==OP_BitOr ){
    iA |= iB;
  }else if( iB!=0 ){
    assert( op==OP_ShiftRight || op==OP_ShiftLeft );
 
    /* If shifting by a negative amount, shift in the other direction */
    if( iB<0 ){
      assert( OP_ShiftRight==OP_ShiftLeft+1 );
      op = 2*OP_ShiftLeft + 1 - op;
      iB = iB>(-64) ? -iB : 64;
    }
 
    if( iB>=64 ){
      iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
    }else{
      memcpy(&uA, &iA, sizeof(uA));
      if( op==OP_ShiftLeft ){
        uA <<= iB;
      }else{
        uA >>= iB;
        /* Sign-extend on a right shift of a negative number */
        if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
      }
      memcpy(&iA, &uA, sizeof(iA));
    }
  }
  pOut->u.i = iA;
  MemSetTypeFlag(pOut, MEM_Int);
  break;
}
 
/* Opcode: AddImm  P1 P2 * * *
** Synopsis: r[P1]=r[P1]+P2
**
** Add the constant P2 to the value in register P1.
** The result is always an integer.
**
** To force any register to be an integer, just add 0.
*/
case OP_AddImm: {            /* in1 */
  pIn1 = &aMem[pOp->p1];
  memAboutToChange(p, pIn1);
  sqlite3VdbeMemIntegerify(pIn1);
  pIn1->u.i += pOp->p2;
  break;
}
 
/* Opcode: MustBeInt P1 P2 * * *
**
** Force the value in register P1 to be an integer.  If the value
** in P1 is not an integer and cannot be converted into an integer
** without data loss, then jump immediately to P2, or if P2==0
** raise an SQLITE_MISMATCH exception.
*/
case OP_MustBeInt: {            /* jump, in1 */
  pIn1 = &aMem[pOp->p1];
  if( (pIn1->flags & MEM_Int)==0 ){
    applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
    if( (pIn1->flags & MEM_Int)==0 ){
      VdbeBranchTaken(1, 2);
      if( pOp->p2==0 ){
        rc = SQLITE_MISMATCH;
        goto abort_due_to_error;
      }else{
        goto jump_to_p2;
      }
    }
  }
  VdbeBranchTaken(0, 2);
  MemSetTypeFlag(pIn1, MEM_Int);
  break;
}
 
#ifndef SQLITE_OMIT_FLOATING_POINT
/* Opcode: RealAffinity P1 * * * *
**
** If register P1 holds an integer convert it to a real value.
**
** This opcode is used when extracting information from a column that
** has REAL affinity.  Such column values may still be stored as
** integers, for space efficiency, but after extraction we want them
** to have only a real value.
*/
case OP_RealAffinity: {                  /* in1 */
  pIn1 = &aMem[pOp->p1];
  if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
    testcase( pIn1->flags & MEM_Int );
    testcase( pIn1->flags & MEM_IntReal );
    sqlite3VdbeMemRealify(pIn1);
    REGISTER_TRACE(pOp->p1, pIn1);
  }
  break;
}
#endif
 
#ifndef SQLITE_OMIT_CAST
/* Opcode: Cast P1 P2 * * *
** Synopsis: affinity(r[P1])
**
** Force the value in register P1 to be the type defined by P2.
**
** <ul>
** <li> P2=='A' &rarr; BLOB
** <li> P2=='B' &rarr; TEXT
** <li> P2=='C' &rarr; NUMERIC
** <li> P2=='D' &rarr; INTEGER
** <li> P2=='E' &rarr; REAL
** </ul>
**
** A NULL value is not changed by this routine.  It remains NULL.
*/
case OP_Cast: {                  /* in1 */
  assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
  testcase( pOp->p2==SQLITE_AFF_TEXT );
  testcase( pOp->p2==SQLITE_AFF_BLOB );
  testcase( pOp->p2==SQLITE_AFF_NUMERIC );
  testcase( pOp->p2==SQLITE_AFF_INTEGER );
  testcase( pOp->p2==SQLITE_AFF_REAL );
  pIn1 = &aMem[pOp->p1];
  memAboutToChange(p, pIn1);
  rc = ExpandBlob(pIn1);
  if( rc ) goto abort_due_to_error;
  rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
  if( rc ) goto abort_due_to_error;
  UPDATE_MAX_BLOBSIZE(pIn1);
  REGISTER_TRACE(pOp->p1, pIn1);
  break;
}
#endif /* SQLITE_OMIT_CAST */
 
/* Opcode: Eq P1 P2 P3 P4 P5
** Synopsis: IF r[P3]==r[P1]
**
** Compare the values in register P1 and P3.  If reg(P3)==reg(P1) then
** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5, then
** store the result of comparison in register P2.
**
** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
** to coerce both inputs according to this affinity before the
** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
** affinity is used. Note that the affinity conversions are stored
** back into the input registers P1 and P3.  So this opcode can cause
** persistent changes to registers P1 and P3.
**
** Once any conversions have taken place, and neither value is NULL,
** the values are compared. If both values are blobs then memcmp() is
** used to determine the results of the comparison.  If both values
** are text, then the appropriate collating function specified in
** P4 is used to do the comparison.  If P4 is not specified then
** memcmp() is used to compare text string.  If both values are
** numeric, then a numeric comparison is used. If the two values
** are of different types, then numbers are considered less than
** strings and strings are considered less than blobs.
**
** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
** true or false and is never NULL.  If both operands are NULL then the result
** of comparison is true.  If either operand is NULL then the result is false.
** If neither operand is NULL the result is the same as it would be if
** the SQLITE_NULLEQ flag were omitted from P5.
**
** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
** content of r[P2] is only changed if the new value is NULL or 0 (false).
** In other words, a prior r[P2] value will not be overwritten by 1 (true).
*/
/* Opcode: Ne P1 P2 P3 P4 P5
** Synopsis: IF r[P3]!=r[P1]
**
** This works just like the Eq opcode except that the jump is taken if
** the operands in registers P1 and P3 are not equal.  See the Eq opcode for
** additional information.
**
** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
** content of r[P2] is only changed if the new value is NULL or 1 (true).
** In other words, a prior r[P2] value will not be overwritten by 0 (false).
*/
/* Opcode: Lt P1 P2 P3 P4 P5
** Synopsis: IF r[P3]<r[P1]
**
** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5 store
** the result of comparison (0 or 1 or NULL) into register P2.
**
** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
** reg(P3) is NULL then the take the jump.  If the SQLITE_JUMPIFNULL
** bit is clear then fall through if either operand is NULL.
**
** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
** to coerce both inputs according to this affinity before the
** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
** affinity is used. Note that the affinity conversions are stored
** back into the input registers P1 and P3.  So this opcode can cause
** persistent changes to registers P1 and P3.
**
** Once any conversions have taken place, and neither value is NULL,
** the values are compared. If both values are blobs then memcmp() is
** used to determine the results of the comparison.  If both values
** are text, then the appropriate collating function specified in
** P4 is  used to do the comparison.  If P4 is not specified then
** memcmp() is used to compare text string.  If both values are
** numeric, then a numeric comparison is used. If the two values
** are of different types, then numbers are considered less than
** strings and strings are considered less than blobs.
*/
/* Opcode: Le P1 P2 P3 P4 P5
** Synopsis: IF r[P3]<=r[P1]
**
** This works just like the Lt opcode except that the jump is taken if
** the content of register P3 is less than or equal to the content of
** register P1.  See the Lt opcode for additional information.
*/
/* Opcode: Gt P1 P2 P3 P4 P5
** Synopsis: IF r[P3]>r[P1]
**
** This works just like the Lt opcode except that the jump is taken if
** the content of register P3 is greater than the content of
** register P1.  See the Lt opcode for additional information.
*/
/* Opcode: Ge P1 P2 P3 P4 P5
** Synopsis: IF r[P3]>=r[P1]
**
** This works just like the Lt opcode except that the jump is taken if
** the content of register P3 is greater than or equal to the content of
** register P1.  See the Lt opcode for additional information.
*/
case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
case OP_Le:               /* same as TK_LE, jump, in1, in3 */
case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
  int res, res2;      /* Result of the comparison of pIn1 against pIn3 */
  char affinity;      /* Affinity to use for comparison */
  u16 flags1;         /* Copy of initial value of pIn1->flags */
  u16 flags3;         /* Copy of initial value of pIn3->flags */
 
  pIn1 = &aMem[pOp->p1];
  pIn3 = &aMem[pOp->p3];
  flags1 = pIn1->flags;
  flags3 = pIn3->flags;
  if( (flags1 | flags3)&MEM_Null ){
    /* One or both operands are NULL */
    if( pOp->p5 & SQLITE_NULLEQ ){
      /* If SQLITE_NULLEQ is set (which will only happen if the operator is
      ** OP_Eq or OP_Ne) then take the jump or not depending on whether
      ** or not both operands are null.
      */
      assert( (flags1 & MEM_Cleared)==0 );
      assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
      testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
      if( (flags1&flags3&MEM_Null)!=0
       && (flags3&MEM_Cleared)==0
      ){
        res = 0;  /* Operands are equal */
      }else{
        res = ((flags3 & MEM_Null) ? -1 : +1);  /* Operands are not equal */
      }
    }else{
      /* SQLITE_NULLEQ is clear and at least one operand is NULL,
      ** then the result is always NULL.
      ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
      */
      if( pOp->p5 & SQLITE_STOREP2 ){
        pOut = &aMem[pOp->p2];
        iCompare = 1;    /* Operands are not equal */
        memAboutToChange(p, pOut);
        MemSetTypeFlag(pOut, MEM_Null);
        REGISTER_TRACE(pOp->p2, pOut);
      }else{
        VdbeBranchTaken(2,3);
        if( pOp->p5 & SQLITE_JUMPIFNULL ){
          goto jump_to_p2;
        }
      }
      break;
    }
  }else{
    /* Neither operand is NULL.  Do a comparison. */
    affinity = pOp->p5 & SQLITE_AFF_MASK;
    if( affinity>=SQLITE_AFF_NUMERIC ){
      if( (flags1 | flags3)&MEM_Str ){
        if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
          applyNumericAffinity(pIn1,0);
          testcase( flags3==pIn3->flags );
          flags3 = pIn3->flags;
        }
        if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
          applyNumericAffinity(pIn3,0);
        }
      }
      /* Handle the common case of integer comparison here, as an
      ** optimization, to avoid a call to sqlite3MemCompare() */
      if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){
        if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; }
        if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; }
        res = 0;
        goto compare_op;
      }
    }else if( affinity==SQLITE_AFF_TEXT ){
      if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
        testcase( pIn1->flags & MEM_Int );
        testcase( pIn1->flags & MEM_Real );
        testcase( pIn1->flags & MEM_IntReal );
        sqlite3VdbeMemStringify(pIn1, encoding, 1);
        testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
        flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
        if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str;
      }
      if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
        testcase( pIn3->flags & MEM_Int );
        testcase( pIn3->flags & MEM_Real );
        testcase( pIn3->flags & MEM_IntReal );
        sqlite3VdbeMemStringify(pIn3, encoding, 1);
        testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
        flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
      }
    }
    assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
    res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
  }
compare_op:
  /* At this point, res is negative, zero, or positive if reg[P1] is
  ** less than, equal to, or greater than reg[P3], respectively.  Compute
  ** the answer to this operator in res2, depending on what the comparison
  ** operator actually is.  The next block of code depends on the fact
  ** that the 6 comparison operators are consecutive integers in this
  ** order:  NE, EQ, GT, LE, LT, GE */
  assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
  assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
  if( res<0 ){                        /* ne, eq, gt, le, lt, ge */
    static const unsigned char aLTb[] = { 1,  0,  0,  1,  1,  0 };
    res2 = aLTb[pOp->opcode - OP_Ne];
  }else if( res==0 ){
    static const unsigned char aEQb[] = { 0,  1,  0,  1,  0,  1 };
    res2 = aEQb[pOp->opcode - OP_Ne];
  }else{
    static const unsigned char aGTb[] = { 1,  0,  1,  0,  0,  1 };
    res2 = aGTb[pOp->opcode - OP_Ne];
  }
 
  /* Undo any changes made by applyAffinity() to the input registers. */
  assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
  pIn3->flags = flags3;
  assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
  pIn1->flags = flags1;
 
  if( pOp->p5 & SQLITE_STOREP2 ){
    pOut = &aMem[pOp->p2];
    iCompare = res;
    if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){
      /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1
      ** and prevents OP_Ne from overwriting NULL with 0.  This flag
      ** is only used in contexts where either:
      **   (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0)
      **   (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1)
      ** Therefore it is not necessary to check the content of r[P2] for
      ** NULL. */
      assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq );
      assert( res2==0 || res2==1 );
      testcase( res2==0 && pOp->opcode==OP_Eq );
      testcase( res2==1 && pOp->opcode==OP_Eq );
      testcase( res2==0 && pOp->opcode==OP_Ne );
      testcase( res2==1 && pOp->opcode==OP_Ne );
      if( (pOp->opcode==OP_Eq)==res2 ) break;
    }
    memAboutToChange(p, pOut);
    MemSetTypeFlag(pOut, MEM_Int);
    pOut->u.i = res2;
    REGISTER_TRACE(pOp->p2, pOut);
  }else{
    VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
    if( res2 ){
      goto jump_to_p2;
    }
  }
  break;
}
 
/* Opcode: ElseNotEq * P2 * * *
**
** This opcode must follow an OP_Lt or OP_Gt comparison operator.  There
** can be zero or more OP_ReleaseReg opcodes intervening, but no other
** opcodes are allowed to occur between this instruction and the previous
** OP_Lt or OP_Gt.  Furthermore, the prior OP_Lt or OP_Gt must have the
** SQLITE_STOREP2 bit set in the P5 field.
**
** If result of an OP_Eq comparison on the same two operands as the
** prior OP_Lt or OP_Gt would have been NULL or false (0), then then
** jump to P2.  If the result of an OP_Eq comparison on the two previous
** operands would have been true (1), then fall through.
*/
case OP_ElseNotEq: {       /* same as TK_ESCAPE, jump */
 
#ifdef SQLITE_DEBUG
  /* Verify the preconditions of this opcode - that it follows an OP_Lt or
  ** OP_Gt with the SQLITE_STOREP2 flag set, with zero or more intervening
  ** OP_ReleaseReg opcodes */
  int iAddr;
  for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
    if( aOp[iAddr].opcode==OP_ReleaseReg ) continue;
    assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt );
    assert( aOp[iAddr].p5 & SQLITE_STOREP2 );
    break;
  }
#endif /* SQLITE_DEBUG */
  VdbeBranchTaken(iCompare!=0, 2);
  if( iCompare!=0 ) goto jump_to_p2;
  break;
}
 
 
/* Opcode: Permutation * * * P4 *
**
** Set the permutation used by the OP_Compare operator in the next
** instruction.  The permutation is stored in the P4 operand.
**
** The permutation is only valid until the next OP_Compare that has
** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should
** occur immediately prior to the OP_Compare.
**
** The first integer in the P4 integer array is the length of the array
** and does not become part of the permutation.
*/
case OP_Permutation: {
  assert( pOp->p4type==P4_INTARRAY );
  assert( pOp->p4.ai );
  assert( pOp[1].opcode==OP_Compare );
  assert( pOp[1].p5 & OPFLAG_PERMUTE );
  break;
}
 
/* Opcode: Compare P1 P2 P3 P4 P5
** Synopsis: r[P1@P3] <-> r[P2@P3]
**
** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
** vector "A") and in reg(P2)..reg(P2+P3-1) ("B").  Save the result of
** the comparison for use by the next OP_Jump instruct.
**
** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
** determined by the most recent OP_Permutation operator.  If the
** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
** order.
**
** P4 is a KeyInfo structure that defines collating sequences and sort
** orders for the comparison.  The permutation applies to registers
** only.  The KeyInfo elements are used sequentially.
**
** The comparison is a sort comparison, so NULLs compare equal,
** NULLs are less than numbers, numbers are less than strings,
** and strings are less than blobs.
*/
case OP_Compare: {
  int n;
  int i;
  int p1;
  int p2;
  const KeyInfo *pKeyInfo;
  u32 idx;
  CollSeq *pColl;    /* Collating sequence to use on this term */
  int bRev;          /* True for DESCENDING sort order */
  u32 *aPermute;     /* The permutation */
 
  if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
    aPermute = 0;
  }else{
    assert( pOp>aOp );
    assert( pOp[-1].opcode==OP_Permutation );
    assert( pOp[-1].p4type==P4_INTARRAY );
    aPermute = pOp[-1].p4.ai + 1;
    assert( aPermute!=0 );
  }
  n = pOp->p3;
  pKeyInfo = pOp->p4.pKeyInfo;
  assert( n>0 );
  assert( pKeyInfo!=0 );
  p1 = pOp->p1;
  p2 = pOp->p2;
#ifdef SQLITE_DEBUG
  if( aPermute ){
    int k, mx = 0;
    for(k=0; k<n; k++) if( aPermute[k]>(u32)mx ) mx = aPermute[k];
    assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
    assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
  }else{
    assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
    assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
  }
#endif /* SQLITE_DEBUG */
  for(i=0; i<n; i++){
    idx = aPermute ? aPermute[i] : (u32)i;
    assert( memIsValid(&aMem[p1+idx]) );
    assert( memIsValid(&aMem[p2+idx]) );
    REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
    REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
    assert( i<pKeyInfo->nKeyField );
    pColl = pKeyInfo->aColl[i];
    bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
    iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
    if( iCompare ){
      if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
       && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))
      ){
        iCompare = -iCompare;
      }
      if( bRev ) iCompare = -iCompare;
      break;
    }
  }
  break;
}
 
/* Opcode: Jump P1 P2 P3 * *
**
** Jump to the instruction at address P1, P2, or P3 depending on whether
** in the most recent OP_Compare instruction the P1 vector was less than
** equal to, or greater than the P2 vector, respectively.
*/
case OP_Jump: {             /* jump */
  if( iCompare<0 ){
    VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
  }else if( iCompare==0 ){
    VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
  }else{
    VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
  }
  break;
}
 
/* Opcode: And P1 P2 P3 * *
** Synopsis: r[P3]=(r[P1] && r[P2])
**
** Take the logical AND of the values in registers P1 and P2 and
** write the result into register P3.
**
** If either P1 or P2 is 0 (false) then the result is 0 even if
** the other input is NULL.  A NULL and true or two NULLs give
** a NULL output.
*/
/* Opcode: Or P1 P2 P3 * *
** Synopsis: r[P3]=(r[P1] || r[P2])
**
** Take the logical OR of the values in register P1 and P2 and
** store the answer in register P3.
**
** If either P1 or P2 is nonzero (true) then the result is 1 (true)
** even if the other input is NULL.  A NULL and false or two NULLs
** give a NULL output.
*/
case OP_And:              /* same as TK_AND, in1, in2, out3 */
case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
  int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
  int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
 
  v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
  v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
  if( pOp->opcode==OP_And ){
    static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
    v1 = and_logic[v1*3+v2];
  }else{
    static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
    v1 = or_logic[v1*3+v2];
  }
  pOut = &aMem[pOp->p3];
  if( v1==2 ){
    MemSetTypeFlag(pOut, MEM_Null);
  }else{
    pOut->u.i = v1;
    MemSetTypeFlag(pOut, MEM_Int);
  }
  break;
}
 
/* Opcode: IsTrue P1 P2 P3 P4 *
** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4
**
** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and
** IS NOT FALSE operators.
**
** Interpret the value in register P1 as a boolean value.  Store that
** boolean (a 0 or 1) in register P2.  Or if the value in register P1 is
** NULL, then the P3 is stored in register P2.  Invert the answer if P4
** is 1.
**
** The logic is summarized like this:
**
** <ul>
** <li> If P3==0 and P4==0  then  r[P2] := r[P1] IS TRUE
** <li> If P3==1 and P4==1  then  r[P2] := r[P1] IS FALSE
** <li> If P3==0 and P4==1  then  r[P2] := r[P1] IS NOT TRUE
** <li> If P3==1 and P4==0  then  r[P2] := r[P1] IS NOT FALSE
** </ul>
*/
case OP_IsTrue: {               /* in1, out2 */
  assert( pOp->p4type==P4_INT32 );
  assert( pOp->p4.i==0 || pOp->p4.i==1 );
  assert( pOp->p3==0 || pOp->p3==1 );
  sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
      sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
  break;
}
 
/* Opcode: Not P1 P2 * * *
** Synopsis: r[P2]= !r[P1]
**
** Interpret the value in register P1 as a boolean value.  Store the
** boolean complement in register P2.  If the value in register P1 is
** NULL, then a NULL is stored in P2.
*/
case OP_Not: {                /* same as TK_NOT, in1, out2 */
  pIn1 = &aMem[pOp->p1];
  pOut = &aMem[pOp->p2];
  if( (pIn1->flags & MEM_Null)==0 ){
    sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
  }else{
    sqlite3VdbeMemSetNull(pOut);
  }
  break;
}
 
/* Opcode: BitNot P1 P2 * * *
** Synopsis: r[P2]= ~r[P1]
**
** Interpret the content of register P1 as an integer.  Store the
** ones-complement of the P1 value into register P2.  If P1 holds
** a NULL then store a NULL in P2.
*/
case OP_BitNot: {             /* same as TK_BITNOT, in1, out2 */
  pIn1 = &aMem[pOp->p1];
  pOut = &aMem[pOp->p2];
  sqlite3VdbeMemSetNull(pOut);
  if( (pIn1->flags & MEM_Null)==0 ){
    pOut->flags = MEM_Int;
    pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
  }
  break;
}
 
/* Opcode: Once P1 P2 * * *
**
** Fall through to the next instruction the first time this opcode is
** encountered on each invocation of the byte-code program.  Jump to P2
** on the second and all subsequent encounters during the same invocation.
**
** Top-level programs determine first invocation by comparing the P1
** operand against the P1 operand on the OP_Init opcode at the beginning
** of the program.  If the P1 values differ, then fall through and make
** the P1 of this opcode equal to the P1 of OP_Init.  If P1 values are
** the same then take the jump.
**
** For subprograms, there is a bitmask in the VdbeFrame that determines
** whether or not the jump should be taken.  The bitmask is necessary
** because the self-altering code trick does not work for recursive
** triggers.
*/
case OP_Once: {             /* jump */
  u32 iAddr;                /* Address of this instruction */
  assert( p->aOp[0].opcode==OP_Init );
  if( p->pFrame ){
    iAddr = (int)(pOp - p->aOp);
    if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
      VdbeBranchTaken(1, 2);
      goto jump_to_p2;
    }
    p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
  }else{
    if( p->aOp[0].p1==pOp->p1 ){
      VdbeBranchTaken(1, 2);
      goto jump_to_p2;
    }
  }
  VdbeBranchTaken(0, 2);
  pOp->p1 = p->aOp[0].p1;
  break;
}
 
/* Opcode: If P1 P2 P3 * *
**
** Jump to P2 if the value in register P1 is true.  The value
** is considered true if it is numeric and non-zero.  If the value
** in P1 is NULL then take the jump if and only if P3 is non-zero.
*/
case OP_If:  {               /* jump, in1 */
  int c;
  c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
  VdbeBranchTaken(c!=0, 2);
  if( c ) goto jump_to_p2;
  break;
}
 
/* Opcode: IfNot P1 P2 P3 * *
**
** Jump to P2 if the value in register P1 is False.  The value
** is considered false if it has a numeric value of zero.  If the value
** in P1 is NULL then take the jump if and only if P3 is non-zero.
*/
case OP_IfNot: {            /* jump, in1 */
  int c;
  c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
  VdbeBranchTaken(c!=0, 2);
  if( c ) goto jump_to_p2;
  break;
}
 
/* Opcode: IsNull P1 P2 * * *
** Synopsis: if r[P1]==NULL goto P2
**
** Jump to P2 if the value in register P1 is NULL.
*/
case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
  pIn1 = &aMem[pOp->p1];
  VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
  if( (pIn1->flags & MEM_Null)!=0 ){
    goto jump_to_p2;
  }
  break;
}
 
/* Opcode: NotNull P1 P2 * * *
** Synopsis: if r[P1]!=NULL goto P2
**
** Jump to P2 if the value in register P1 is not NULL.
*/
case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
  pIn1 = &aMem[pOp->p1];
  VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
  if( (pIn1->flags & MEM_Null)==0 ){
    goto jump_to_p2;
  }
  break;
}
 
/* Opcode: IfNullRow P1 P2 P3 * *
** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2
**
** Check the cursor P1 to see if it is currently pointing at a NULL row.
** If it is, then set register P3 to NULL and jump immediately to P2.
** If P1 is not on a NULL row, then fall through without making any
** changes.
*/
case OP_IfNullRow: {         /* jump */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( p->apCsr[pOp->p1]!=0 );
  if( p->apCsr[pOp->p1]->nullRow ){
    sqlite3VdbeMemSetNull(aMem + pOp->p3);
    goto jump_to_p2;
  }
  break;
}
 
#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
/* Opcode: Offset P1 P2 P3 * *
** Synopsis: r[P3] = sqlite_offset(P1)
**
** Store in register r[P3] the byte offset into the database file that is the
** start of the payload for the record at which that cursor P1 is currently
** pointing.
**
** P2 is the column number for the argument to the sqlite_offset() function.
** This opcode does not use P2 itself, but the P2 value is used by the
** code generator.  The P1, P2, and P3 operands to this opcode are the
** same as for OP_Column.
**
** This opcode is only available if SQLite is compiled with the
** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option.
*/
case OP_Offset: {          /* out3 */
  VdbeCursor *pC;    /* The VDBE cursor */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  pOut = &p->aMem[pOp->p3];
  if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){
    sqlite3VdbeMemSetNull(pOut);
  }else{
    sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
  }
  break;
}
#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */
 
/* Opcode: Column P1 P2 P3 P4 P5
** Synopsis: r[P3]=PX
**
** Interpret the data that cursor P1 points to as a structure built using
** the MakeRecord instruction.  (See the MakeRecord opcode for additional
** information about the format of the data.)  Extract the P2-th column
** from this record.  If there are less that (P2+1)
** values in the record, extract a NULL.
**
** The value extracted is stored in register P3.
**
** If the record contains fewer than P2 fields, then extract a NULL.  Or,
** if the P4 argument is a P4_MEM use the value of the P4 argument as
** the result.
**
** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 then
** the result is guaranteed to only be used as the argument of a length()
** or typeof() function, respectively.  The loading of large blobs can be
** skipped for length() and all content loading can be skipped for typeof().
*/
case OP_Column: {
  u32 p2;            /* column number to retrieve */
  VdbeCursor *pC;    /* The VDBE cursor */
  BtCursor *pCrsr;   /* The BTree cursor */
  u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
  int len;           /* The length of the serialized data for the column */
  int i;             /* Loop counter */
  Mem *pDest;        /* Where to write the extracted value */
  Mem sMem;          /* For storing the record being decoded */
  const u8 *zData;   /* Part of the record being decoded */
  const u8 *zHdr;    /* Next unparsed byte of the header */
  const u8 *zEndHdr; /* Pointer to first byte after the header */
  u64 offset64;      /* 64-bit offset */
  u32 t;             /* A type code from the record header */
  Mem *pReg;         /* PseudoTable input register */
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  p2 = (u32)pOp->p2;
 
  /* If the cursor cache is stale (meaning it is not currently point at
  ** the correct row) then bring it up-to-date by doing the necessary
  ** B-Tree seek. */
  rc = sqlite3VdbeCursorMoveto(&pC, &p2);
  if( rc ) goto abort_due_to_error;
 
  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  pDest = &aMem[pOp->p3];
  memAboutToChange(p, pDest);
  assert( pC!=0 );
  assert( p2<(u32)pC->nField );
  aOffset = pC->aOffset;
  assert( pC->eCurType!=CURTYPE_VTAB );
  assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
  assert( pC->eCurType!=CURTYPE_SORTER );
 
  if( pC->cacheStatus!=p->cacheCtr ){                /*OPTIMIZATION-IF-FALSE*/
    if( pC->nullRow ){
      if( pC->eCurType==CURTYPE_PSEUDO ){
        /* For the special case of as pseudo-cursor, the seekResult field
        ** identifies the register that holds the record */
        assert( pC->seekResult>0 );
        pReg = &aMem[pC->seekResult];
        assert( pReg->flags & MEM_Blob );
        assert( memIsValid(pReg) );
        pC->payloadSize = pC->szRow = pReg->n;
        pC->aRow = (u8*)pReg->z;
      }else{
        sqlite3VdbeMemSetNull(pDest);
        goto op_column_out;
      }
    }else{
      pCrsr = pC->uc.pCursor;
      assert( pC->eCurType==CURTYPE_BTREE );
      assert( pCrsr );
      assert( sqlite3BtreeCursorIsValid(pCrsr) );
      pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
      pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
      assert( pC->szRow<=pC->payloadSize );
      assert( pC->szRow<=65536 );  /* Maximum page size is 64KiB */
      if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
        goto too_big;
      }
    }
    pC->cacheStatus = p->cacheCtr;
    pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
    pC->nHdrParsed = 0;
 
 
    if( pC->szRow<aOffset[0] ){      /*OPTIMIZATION-IF-FALSE*/
      /* pC->aRow does not have to hold the entire row, but it does at least
      ** need to cover the header of the record.  If pC->aRow does not contain
      ** the complete header, then set it to zero, forcing the header to be
      ** dynamically allocated. */
      pC->aRow = 0;
      pC->szRow = 0;
 
      /* Make sure a corrupt database has not given us an oversize header.
      ** Do this now to avoid an oversize memory allocation.
      **
      ** Type entries can be between 1 and 5 bytes each.  But 4 and 5 byte
      ** types use so much data space that there can only be 4096 and 32 of
      ** them, respectively.  So the maximum header length results from a
      ** 3-byte type for each of the maximum of 32768 columns plus three
      ** extra bytes for the header length itself.  32768*3 + 3 = 98307.
      */
      if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
        goto op_column_corrupt;
      }
    }else{
      /* This is an optimization.  By skipping over the first few tests
      ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
      ** measurable performance gain.
      **
      ** This branch is taken even if aOffset[0]==0.  Such a record is never
      ** generated by SQLite, and could be considered corruption, but we
      ** accept it for historical reasons.  When aOffset[0]==0, the code this
      ** branch jumps to reads past the end of the record, but never more
      ** than a few bytes.  Even if the record occurs at the end of the page
      ** content area, the "page header" comes after the page content and so
      ** this overread is harmless.  Similar overreads can occur for a corrupt
      ** database file.
      */
      zData = pC->aRow;
      assert( pC->nHdrParsed<=p2 );         /* Conditional skipped */
      testcase( aOffset[0]==0 );
      goto op_column_read_header;
    }
  }
 
  /* Make sure at least the first p2+1 entries of the header have been
  ** parsed and valid information is in aOffset[] and pC->aType[].
  */
  if( pC->nHdrParsed<=p2 ){
    /* If there is more header available for parsing in the record, try
    ** to extract additional fields up through the p2+1-th field
    */
    if( pC->iHdrOffset<aOffset[0] ){
      /* Make sure zData points to enough of the record to cover the header. */
      if( pC->aRow==0 ){
        memset(&sMem, 0, sizeof(sMem));
        rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
        if( rc!=SQLITE_OK ) goto abort_due_to_error;
        zData = (u8*)sMem.z;
      }else{
        zData = pC->aRow;
      }
 
      /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
    op_column_read_header:
      i = pC->nHdrParsed;
      offset64 = aOffset[i];
      zHdr = zData + pC->iHdrOffset;
      zEndHdr = zData + aOffset[0];
      testcase( zHdr>=zEndHdr );
      do{
        if( (pC->aType[i] = t = zHdr[0])<0x80 ){
          zHdr++;
          offset64 += sqlite3VdbeOneByteSerialTypeLen(t);
        }else{
          zHdr += sqlite3GetVarint32(zHdr, &t);
          pC->aType[i] = t;
          offset64 += sqlite3VdbeSerialTypeLen(t);
        }
        aOffset[++i] = (u32)(offset64 & 0xffffffff);
      }while( (u32)i<=p2 && zHdr<zEndHdr );
 
      /* The record is corrupt if any of the following are true:
      ** (1) the bytes of the header extend past the declared header size
      ** (2) the entire header was used but not all data was used
      ** (3) the end of the data extends beyond the end of the record.
      */
      if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
       || (offset64 > pC->payloadSize)
      ){
        if( aOffset[0]==0 ){
          i = 0;
          zHdr = zEndHdr;
        }else{
          if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
          goto op_column_corrupt;
        }
      }
 
      pC->nHdrParsed = i;
      pC->iHdrOffset = (u32)(zHdr - zData);
      if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
    }else{
      t = 0;
    }
 
    /* If after trying to extract new entries from the header, nHdrParsed is
    ** still not up to p2, that means that the record has fewer than p2
    ** columns.  So the result will be either the default value or a NULL.
    */
    if( pC->nHdrParsed<=p2 ){
      if( pOp->p4type==P4_MEM ){
        sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
      }else{
        sqlite3VdbeMemSetNull(pDest);
      }
      goto op_column_out;
    }
  }else{
    t = pC->aType[p2];
  }
 
  /* Extract the content for the p2+1-th column.  Control can only
  ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
  ** all valid.
  */
  assert( p2<pC->nHdrParsed );
  assert( rc==SQLITE_OK );
  assert( sqlite3VdbeCheckMemInvariants(pDest) );
  if( VdbeMemDynamic(pDest) ){
    sqlite3VdbeMemSetNull(pDest);
  }
  assert( t==pC->aType[p2] );
  if( pC->szRow>=aOffset[p2+1] ){
    /* This is the common case where the desired content fits on the original
    ** page - where the content is not on an overflow page */
    zData = pC->aRow + aOffset[p2];
    if( t<12 ){
      sqlite3VdbeSerialGet(zData, t, pDest);
    }else{
      /* If the column value is a string, we need a persistent value, not
      ** a MEM_Ephem value.  This branch is a fast short-cut that is equivalent
      ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize().
      */
      static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term };
      pDest->n = len = (t-12)/2;
      pDest->enc = encoding;
      if( pDest->szMalloc < len+2 ){
        pDest->flags = MEM_Null;
        if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
      }else{
        pDest->z = pDest->zMalloc;
      }
      memcpy(pDest->z, zData, len);
      pDest->z[len] = 0;
      pDest->z[len+1] = 0;
      pDest->flags = aFlag[t&1];
    }
  }else{
    pDest->enc = encoding;
    /* This branch happens only when content is on overflow pages */
    if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
          && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
     || (len = sqlite3VdbeSerialTypeLen(t))==0
    ){
      /* Content is irrelevant for
      **    1. the typeof() function,
      **    2. the length(X) function if X is a blob, and
      **    3. if the content length is zero.
      ** So we might as well use bogus content rather than reading
      ** content from disk.
      **
      ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the
      ** buffer passed to it, debugging function VdbeMemPrettyPrint() may
      ** read more.  Use the global constant sqlite3CtypeMap[] as the array,
      ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint())
      ** and it begins with a bunch of zeros.
      */
      sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest);
    }else{
      rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
      if( rc!=SQLITE_OK ) goto abort_due_to_error;
      sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
      pDest->flags &= ~MEM_Ephem;
    }
  }
 
op_column_out:
  UPDATE_MAX_BLOBSIZE(pDest);
  REGISTER_TRACE(pOp->p3, pDest);
  break;
 
op_column_corrupt:
  if( aOp[0].p3>0 ){
    pOp = &aOp[aOp[0].p3-1];
    break;
  }else{
    rc = SQLITE_CORRUPT_BKPT;
    goto abort_due_to_error;
  }
}
 
/* Opcode: Affinity P1 P2 * P4 *
** Synopsis: affinity(r[P1@P2])
**
** Apply affinities to a range of P2 registers starting with P1.
**
** P4 is a string that is P2 characters long. The N-th character of the
** string indicates the column affinity that should be used for the N-th
** memory cell in the range.
*/
case OP_Affinity: {
  const char *zAffinity;   /* The affinity to be applied */
 
  zAffinity = pOp->p4.z;
  assert( zAffinity!=0 );
  assert( pOp->p2>0 );
  assert( zAffinity[pOp->p2]==0 );
  pIn1 = &aMem[pOp->p1];
  while( 1 /*exit-by-break*/ ){
    assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
    assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) );
    applyAffinity(pIn1, zAffinity[0], encoding);
    if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
      /* When applying REAL affinity, if the result is still an MEM_Int
      ** that will fit in 6 bytes, then change the type to MEM_IntReal
      ** so that we keep the high-resolution integer value but know that
      ** the type really wants to be REAL. */
      testcase( pIn1->u.i==140737488355328LL );
      testcase( pIn1->u.i==140737488355327LL );
      testcase( pIn1->u.i==-140737488355328LL );
      testcase( pIn1->u.i==-140737488355329LL );
      if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){
        pIn1->flags |= MEM_IntReal;
        pIn1->flags &= ~MEM_Int;
      }else{
        pIn1->u.r = (double)pIn1->u.i;
        pIn1->flags |= MEM_Real;
        pIn1->flags &= ~MEM_Int;
      }
    }
    REGISTER_TRACE((int)(pIn1-aMem), pIn1);
    zAffinity++;
    if( zAffinity[0]==0 ) break;
    pIn1++;
  }
  break;
}
 
/* Opcode: MakeRecord P1 P2 P3 P4 *
** Synopsis: r[P3]=mkrec(r[P1@P2])
**
** Convert P2 registers beginning with P1 into the [record format]
** use as a data record in a database table or as a key
** in an index.  The OP_Column opcode can decode the record later.
**
** P4 may be a string that is P2 characters long.  The N-th character of the
** string indicates the column affinity that should be used for the N-th
** field of the index key.
**
** The mapping from character to affinity is given by the SQLITE_AFF_
** macros defined in sqliteInt.h.
**
** If P4 is NULL then all index fields have the affinity BLOB.
**
** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM
** compile-time option is enabled:
**
**   * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index
**     of the right-most table that can be null-trimmed.
**
**   * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value
**     OPFLAG_NOCHNG_MAGIC if the OP_MakeRecord opcode is allowed to
**     accept no-change records with serial_type 10.  This value is
**     only used inside an assert() and does not affect the end result.
*/
case OP_MakeRecord: {
  Mem *pRec;             /* The new record */
  u64 nData;             /* Number of bytes of data space */
  int nHdr;              /* Number of bytes of header space */
  i64 nByte;             /* Data space required for this record */
  i64 nZero;             /* Number of zero bytes at the end of the record */
  int nVarint;           /* Number of bytes in a varint */
  u32 serial_type;       /* Type field */
  Mem *pData0;           /* First field to be combined into the record */
  Mem *pLast;            /* Last field of the record */
  int nField;            /* Number of fields in the record */
  char *zAffinity;       /* The affinity string for the record */
  int file_format;       /* File format to use for encoding */
  u32 len;               /* Length of a field */
  u8 *zHdr;              /* Where to write next byte of the header */
  u8 *zPayload;          /* Where to write next byte of the payload */
 
  /* Assuming the record contains N fields, the record format looks
  ** like this:
  **
  ** ------------------------------------------------------------------------
  ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
  ** ------------------------------------------------------------------------
  **
  ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
  ** and so forth.
  **
  ** Each type field is a varint representing the serial type of the
  ** corresponding data element (see sqlite3VdbeSerialType()). The
  ** hdr-size field is also a varint which is the offset from the beginning
  ** of the record to data0.
  */
  nData = 0;         /* Number of bytes of data space */
  nHdr = 0;          /* Number of bytes of header space */
  nZero = 0;         /* Number of zero bytes at the end of the record */
  nField = pOp->p1;
  zAffinity = pOp->p4.z;
  assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
  pData0 = &aMem[nField];
  nField = pOp->p2;
  pLast = &pData0[nField-1];
  file_format = p->minWriteFileFormat;
 
  /* Identify the output register */
  assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
  pOut = &aMem[pOp->p3];
  memAboutToChange(p, pOut);
 
  /* Apply the requested affinity to all inputs
  */
  assert( pData0<=pLast );
  if( zAffinity ){
    pRec = pData0;
    do{
      applyAffinity(pRec, zAffinity[0], encoding);
      if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
        pRec->flags |= MEM_IntReal;
        pRec->flags &= ~(MEM_Int);
      }
      REGISTER_TRACE((int)(pRec-aMem), pRec);
      zAffinity++;
      pRec++;
      assert( zAffinity[0]==0 || pRec<=pLast );
    }while( zAffinity[0] );
  }
 
#ifdef SQLITE_ENABLE_NULL_TRIM
  /* NULLs can be safely trimmed from the end of the record, as long as
  ** as the schema format is 2 or more and none of the omitted columns
  ** have a non-NULL default value.  Also, the record must be left with
  ** at least one field.  If P5>0 then it will be one more than the
  ** index of the right-most column with a non-NULL default value */
  if( pOp->p5 ){
    while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
      pLast--;
      nField--;
    }
  }
#endif
 
  /* Loop through the elements that will make up the record to figure
  ** out how much space is required for the new record.  After this loop,
  ** the Mem.uTemp field of each term should hold the serial-type that will
  ** be used for that term in the generated record:
  **
  **   Mem.uTemp value    type
  **   ---------------    ---------------
  **      0               NULL
  **      1               1-byte signed integer
  **      2               2-byte signed integer
  **      3               3-byte signed integer
  **      4               4-byte signed integer
  **      5               6-byte signed integer
  **      6               8-byte signed integer
  **      7               IEEE float
  **      8               Integer constant 0
  **      9               Integer constant 1
  **     10,11            reserved for expansion
  **    N>=12 and even    BLOB
  **    N>=13 and odd     text
  **
  ** The following additional values are computed:
  **     nHdr        Number of bytes needed for the record header
  **     nData       Number of bytes of data space needed for the record
  **     nZero       Zero bytes at the end of the record
  */
  pRec = pLast;
  do{
    assert( memIsValid(pRec) );
    if( pRec->flags & MEM_Null ){
      if( pRec->flags & MEM_Zero ){
        /* Values with MEM_Null and MEM_Zero are created by xColumn virtual
        ** table methods that never invoke sqlite3_result_xxxxx() while
        ** computing an unchanging column value in an UPDATE statement.
        ** Give such values a special internal-use-only serial-type of 10
        ** so that they can be passed through to xUpdate and have
        ** a true sqlite3_value_nochange(). */
#ifndef SQLITE_ENABLE_NULL_TRIM
        assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
#endif
        pRec->uTemp = 10;
      }else{
        pRec->uTemp = 0;
      }
      nHdr++;
    }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){
      /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
      i64 i = pRec->u.i;
      u64 uu;
      testcase( pRec->flags & MEM_Int );
      testcase( pRec->flags & MEM_IntReal );
      if( i<0 ){
        uu = ~i;
      }else{
        uu = i;
      }
      nHdr++;
      testcase( uu==127 );               testcase( uu==128 );
      testcase( uu==32767 );             testcase( uu==32768 );
      testcase( uu==8388607 );           testcase( uu==8388608 );
      testcase( uu==2147483647 );        testcase( uu==2147483648 );
      testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL );
      if( uu<=127 ){
        if( (i&1)==i && file_format>=4 ){
          pRec->uTemp = 8+(u32)uu;
        }else{
          nData++;
          pRec->uTemp = 1;
        }
      }else if( uu<=32767 ){
        nData += 2;
        pRec->uTemp = 2;
      }else if( uu<=8388607 ){
        nData += 3;
        pRec->uTemp = 3;
      }else if( uu<=2147483647 ){
        nData += 4;
        pRec->uTemp = 4;
      }else if( uu<=140737488355327LL ){
        nData += 6;
        pRec->uTemp = 5;
      }else{
        nData += 8;
        if( pRec->flags & MEM_IntReal ){
          /* If the value is IntReal and is going to take up 8 bytes to store
          ** as an integer, then we might as well make it an 8-byte floating
          ** point value */
          pRec->u.r = (double)pRec->u.i;
          pRec->flags &= ~MEM_IntReal;
          pRec->flags |= MEM_Real;
          pRec->uTemp = 7;
        }else{
          pRec->uTemp = 6;
        }
      }
    }else if( pRec->flags & MEM_Real ){
      nHdr++;
      nData += 8;
      pRec->uTemp = 7;
    }else{
      assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) );
      assert( pRec->n>=0 );
      len = (u32)pRec->n;
      serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0);
      if( pRec->flags & MEM_Zero ){
        serial_type += pRec->u.nZero*2;
        if( nData ){
          if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
          len += pRec->u.nZero;
        }else{
          nZero += pRec->u.nZero;
        }
      }
      nData += len;
      nHdr += sqlite3VarintLen(serial_type);
      pRec->uTemp = serial_type;
    }
    if( pRec==pData0 ) break;
    pRec--;
  }while(1);
 
  /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
  ** which determines the total number of bytes in the header. The varint
  ** value is the size of the header in bytes including the size varint
  ** itself. */
  testcase( nHdr==126 );
  testcase( nHdr==127 );
  if( nHdr<=126 ){
    /* The common case */
    nHdr += 1;
  }else{
    /* Rare case of a really large header */
    nVarint = sqlite3VarintLen(nHdr);
    nHdr += nVarint;
    if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
  }
  nByte = nHdr+nData;
 
  /* Make sure the output register has a buffer large enough to store
  ** the new record. The output register (pOp->p3) is not allowed to
  ** be one of the input registers (because the following call to
  ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
  */
  if( nByte+nZero<=pOut->szMalloc ){
    /* The output register is already large enough to hold the record.
    ** No error checks or buffer enlargement is required */
    pOut->z = pOut->zMalloc;
  }else{
    /* Need to make sure that the output is not too big and then enlarge
    ** the output register to hold the full result */
    if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
      goto too_big;
    }
    if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
      goto no_mem;
    }
  }
  pOut->n = (int)nByte;
  pOut->flags = MEM_Blob;
  if( nZero ){
    pOut->u.nZero = nZero;
    pOut->flags |= MEM_Zero;
  }
  UPDATE_MAX_BLOBSIZE(pOut);
  zHdr = (u8 *)pOut->z;
  zPayload = zHdr + nHdr;
 
  /* Write the record */
  zHdr += putVarint32(zHdr, nHdr);
  assert( pData0<=pLast );
  pRec = pData0;
  do{
    serial_type = pRec->uTemp;
    /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
    ** additional varints, one per column. */
    zHdr += putVarint32(zHdr, serial_type);            /* serial type */
    /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
    ** immediately follow the header. */
    zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */
  }while( (++pRec)<=pLast );
  assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
  assert( nByte==(int)(zPayload - (u8*)pOut->z) );
 
  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  REGISTER_TRACE(pOp->p3, pOut);
  break;
}
 
/* Opcode: Count P1 P2 p3 * *
** Synopsis: r[P2]=count()
**
** Store the number of entries (an integer value) in the table or index
** opened by cursor P1 in register P2.
**
** If P3==0, then an exact count is obtained, which involves visiting
** every btree page of the table.  But if P3 is non-zero, an estimate
** is returned based on the current cursor position.
*/
case OP_Count: {         /* out2 */
  i64 nEntry;
  BtCursor *pCrsr;
 
  assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
  pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
  assert( pCrsr );
  if( pOp->p3 ){
    nEntry = sqlite3BtreeRowCountEst(pCrsr);
  }else{
    nEntry = 0;  /* Not needed.  Only used to silence a warning. */
    rc = sqlite3BtreeCount(db, pCrsr, &nEntry);
    if( rc ) goto abort_due_to_error;
  }
  pOut = out2Prerelease(p, pOp);
  pOut->u.i = nEntry;
  goto check_for_interrupt;
}
 
/* Opcode: Savepoint P1 * * P4 *
**
** Open, release or rollback the savepoint named by parameter P4, depending
** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE).
** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK).
*/
case OP_Savepoint: {
  int p1;                         /* Value of P1 operand */
  char *zName;                    /* Name of savepoint */
  int nName;
  Savepoint *pNew;
  Savepoint *pSavepoint;
  Savepoint *pTmp;
  int iSavepoint;
  int ii;
 
  p1 = pOp->p1;
  zName = pOp->p4.z;
 
  /* Assert that the p1 parameter is valid. Also that if there is no open
  ** transaction, then there cannot be any savepoints.
  */
  assert( db->pSavepoint==0 || db->autoCommit==0 );
  assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
  assert( db->pSavepoint || db->isTransactionSavepoint==0 );
  assert( checkSavepointCount(db) );
  assert( p->bIsReader );
 
  if( p1==SAVEPOINT_BEGIN ){
    if( db->nVdbeWrite>0 ){
      /* A new savepoint cannot be created if there are active write
      ** statements (i.e. open read/write incremental blob handles).
      */
      sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
      rc = SQLITE_BUSY;
    }else{
      nName = sqlite3Strlen30(zName);
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
      /* This call is Ok even if this savepoint is actually a transaction
      ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
      ** If this is a transaction savepoint being opened, it is guaranteed
      ** that the db->aVTrans[] array is empty.  */
      assert( db->autoCommit==0 || db->nVTrans==0 );
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
                                db->nStatement+db->nSavepoint);
      if( rc!=SQLITE_OK ) goto abort_due_to_error;
#endif
 
      /* Create a new savepoint structure. */
      pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
      if( pNew ){
        pNew->zName = (char *)&pNew[1];
        memcpy(pNew->zName, zName, nName+1);
 
        /* If there is no open transaction, then mark this as a special
        ** "transaction savepoint". */
        if( db->autoCommit ){
          db->autoCommit = 0;
          db->isTransactionSavepoint = 1;
        }else{
          db->nSavepoint++;
        }
 
        /* Link the new savepoint into the database handle's list. */
        pNew->pNext = db->pSavepoint;
        db->pSavepoint = pNew;
        pNew->nDeferredCons = db->nDeferredCons;
        pNew->nDeferredImmCons = db->nDeferredImmCons;
      }
    }
  }else{
    assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK );
    iSavepoint = 0;
 
    /* Find the named savepoint. If there is no such savepoint, then an
    ** an error is returned to the user.  */
    for(
      pSavepoint = db->pSavepoint;
      pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
      pSavepoint = pSavepoint->pNext
    ){
      iSavepoint++;
    }
    if( !pSavepoint ){
      sqlite3VdbeError(p, "no such savepoint: %s", zName);
      rc = SQLITE_ERROR;
    }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
      /* It is not possible to release (commit) a savepoint if there are
      ** active write statements.
      */
      sqlite3VdbeError(p, "cannot release savepoint - "
                          "SQL statements in progress");
      rc = SQLITE_BUSY;
    }else{
 
      /* Determine whether or not this is a transaction savepoint. If so,
      ** and this is a RELEASE command, then the current transaction
      ** is committed.
      */
      int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
      if( isTransaction && p1==SAVEPOINT_RELEASE ){
        if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
          goto vdbe_return;
        }
        db->autoCommit = 1;
        if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
          p->pc = (int)(pOp - aOp);
          db->autoCommit = 0;
          p->rc = rc = SQLITE_BUSY;
          goto vdbe_return;
        }
        rc = p->rc;
        if( rc ){
          db->autoCommit = 0;
        }else{
          db->isTransactionSavepoint = 0;
        }
      }else{
        int isSchemaChange;
        iSavepoint = db->nSavepoint - iSavepoint - 1;
        if( p1==SAVEPOINT_ROLLBACK ){
          isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0;
          for(ii=0; ii<db->nDb; ii++){
            rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
                                       SQLITE_ABORT_ROLLBACK,
                                       isSchemaChange==0);
            if( rc!=SQLITE_OK ) goto abort_due_to_error;
          }
        }else{
          assert( p1==SAVEPOINT_RELEASE );
          isSchemaChange = 0;
        }
        for(ii=0; ii<db->nDb; ii++){
          rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
          if( rc!=SQLITE_OK ){
            goto abort_due_to_error;
          }
        }
        if( isSchemaChange ){
          sqlite3ExpirePreparedStatements(db, 0);
          sqlite3ResetAllSchemasOfConnection(db);
          db->mDbFlags |= DBFLAG_SchemaChange;
        }
      }
      if( rc ) goto abort_due_to_error;
 
      /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
      ** savepoints nested inside of the savepoint being operated on. */
      while( db->pSavepoint!=pSavepoint ){
        pTmp = db->pSavepoint;
        db->pSavepoint = pTmp->pNext;
        sqlite3DbFree(db, pTmp);
        db->nSavepoint--;
      }
 
      /* If it is a RELEASE, then destroy the savepoint being operated on
      ** too. If it is a ROLLBACK TO, then set the number of deferred
      ** constraint violations present in the database to the value stored
      ** when the savepoint was created.  */
      if( p1==SAVEPOINT_RELEASE ){
        assert( pSavepoint==db->pSavepoint );
        db->pSavepoint = pSavepoint->pNext;
        sqlite3DbFree(db, pSavepoint);
        if( !isTransaction ){
          db->nSavepoint--;
        }
      }else{
        assert( p1==SAVEPOINT_ROLLBACK );
        db->nDeferredCons = pSavepoint->nDeferredCons;
        db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
      }
 
      if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){
        rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
        if( rc!=SQLITE_OK ) goto abort_due_to_error;
      }
    }
  }
  if( rc ) goto abort_due_to_error;
 
  break;
}
 
/* Opcode: AutoCommit P1 P2 * * *
**
** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
** back any currently active btree transactions. If there are any active
** VMs (apart from this one), then a ROLLBACK fails.  A COMMIT fails if
** there are active writing VMs or active VMs that use shared cache.
**
** This instruction causes the VM to halt.
*/
case OP_AutoCommit: {
  int desiredAutoCommit;
  int iRollback;
 
  desiredAutoCommit = pOp->p1;
  iRollback = pOp->p2;
  assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
  assert( desiredAutoCommit==1 || iRollback==0 );
  assert( db->nVdbeActive>0 );  /* At least this one VM is active */
  assert( p->bIsReader );
 
  if( desiredAutoCommit!=db->autoCommit ){
    if( iRollback ){
      assert( desiredAutoCommit==1 );
      sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
      db->autoCommit = 1;
    }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
      /* If this instruction implements a COMMIT and other VMs are writing
      ** return an error indicating that the other VMs must complete first.
      */
      sqlite3VdbeError(p, "cannot commit transaction - "
                          "SQL statements in progress");
      rc = SQLITE_BUSY;
      goto abort_due_to_error;
    }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
      goto vdbe_return;
    }else{
      db->autoCommit = (u8)desiredAutoCommit;
    }
    if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
      p->pc = (int)(pOp - aOp);
      db->autoCommit = (u8)(1-desiredAutoCommit);
      p->rc = rc = SQLITE_BUSY;
      goto vdbe_return;
    }
    sqlite3CloseSavepoints(db);
    if( p->rc==SQLITE_OK ){
      rc = SQLITE_DONE;
    }else{
      rc = SQLITE_ERROR;
    }
    goto vdbe_return;
  }else{
    sqlite3VdbeError(p,
        (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
        (iRollback)?"cannot rollback - no transaction is active":
                   "cannot commit - no transaction is active"));
 
    rc = SQLITE_ERROR;
    goto abort_due_to_error;
  }
  /*NOTREACHED*/ assert(0);
}
 
/* Opcode: Transaction P1 P2 P3 P4 P5
**
** Begin a transaction on database P1 if a transaction is not already
** active.
** If P2 is non-zero, then a write-transaction is started, or if a
** read-transaction is already active, it is upgraded to a write-transaction.
** If P2 is zero, then a read-transaction is started.
**
** P1 is the index of the database file on which the transaction is
** started.  Index 0 is the main database file and index 1 is the
** file used for temporary tables.  Indices of 2 or more are used for
** attached databases.
**
** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
** true (this flag is set if the Vdbe may modify more than one row and may
** throw an ABORT exception), a statement transaction may also be opened.
** More specifically, a statement transaction is opened iff the database
** connection is currently not in autocommit mode, or if there are other
** active statements. A statement transaction allows the changes made by this
** VDBE to be rolled back after an error without having to roll back the
** entire transaction. If no error is encountered, the statement transaction
** will automatically commit when the VDBE halts.
**
** If P5!=0 then this opcode also checks the schema cookie against P3
** and the schema generation counter against P4.
** The cookie changes its value whenever the database schema changes.
** This operation is used to detect when that the cookie has changed
** and that the current process needs to reread the schema.  If the schema
** cookie in P3 differs from the schema cookie in the database header or
** if the schema generation counter in P4 differs from the current
** generation counter, then an SQLITE_SCHEMA error is raised and execution
** halts.  The sqlite3_step() wrapper function might then reprepare the
** statement and rerun it from the beginning.
*/
case OP_Transaction: {
  Btree *pBt;
  int iMeta = 0;
 
  assert( p->bIsReader );
  assert( p->readOnly==0 || pOp->p2==0 );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
  if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
    rc = SQLITE_READONLY;
    goto abort_due_to_error;
  }
  pBt = db->aDb[pOp->p1].pBt;
 
  if( pBt ){
    rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
    testcase( rc==SQLITE_BUSY_SNAPSHOT );
    testcase( rc==SQLITE_BUSY_RECOVERY );
    if( rc!=SQLITE_OK ){
      if( (rc&0xff)==SQLITE_BUSY ){
        p->pc = (int)(pOp - aOp);
        p->rc = rc;
        goto vdbe_return;
      }
      goto abort_due_to_error;
    }
 
    if( p->usesStmtJournal
     && pOp->p2
     && (db->autoCommit==0 || db->nVdbeRead>1)
    ){
      assert( sqlite3BtreeIsInTrans(pBt) );
      if( p->iStatement==0 ){
        assert( db->nStatement>=0 && db->nSavepoint>=0 );
        db->nStatement++;
        p->iStatement = db->nSavepoint + db->nStatement;
      }
 
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
      if( rc==SQLITE_OK ){
        rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
      }
 
      /* Store the current value of the database handles deferred constraint
      ** counter. If the statement transaction needs to be rolled back,
      ** the value of this counter needs to be restored too.  */
      p->nStmtDefCons = db->nDeferredCons;
      p->nStmtDefImmCons = db->nDeferredImmCons;
    }
  }
  assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
  if( pOp->p5
   && (iMeta!=pOp->p3
      || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
  ){
    /*
    ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
    ** version is checked to ensure that the schema has not changed since the
    ** SQL statement was prepared.
    */
    sqlite3DbFree(db, p->zErrMsg);
    p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
    /* If the schema-cookie from the database file matches the cookie
    ** stored with the in-memory representation of the schema, do
    ** not reload the schema from the database file.
    **
    ** If virtual-tables are in use, this is not just an optimization.
    ** Often, v-tables store their data in other SQLite tables, which
    ** are queried from within xNext() and other v-table methods using
    ** prepared queries. If such a query is out-of-date, we do not want to
    ** discard the database schema, as the user code implementing the
    ** v-table would have to be ready for the sqlite3_vtab structure itself
    ** to be invalidated whenever sqlite3_step() is called from within
    ** a v-table method.
    */
    if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
      sqlite3ResetOneSchema(db, pOp->p1);
    }
    p->expired = 1;
    rc = SQLITE_SCHEMA;
  }
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: ReadCookie P1 P2 P3 * *
**
** Read cookie number P3 from database P1 and write it into register P2.
** P3==1 is the schema version.  P3==2 is the database format.
** P3==3 is the recommended pager cache size, and so forth.  P1==0 is
** the main database file and P1==1 is the database file used to store
** temporary tables.
**
** There must be a read-lock on the database (either a transaction
** must be started or there must be an open cursor) before
** executing this instruction.
*/
case OP_ReadCookie: {               /* out2 */
  int iMeta;
  int iDb;
  int iCookie;
 
  assert( p->bIsReader );
  iDb = pOp->p1;
  iCookie = pOp->p3;
  assert( pOp->p3<SQLITE_N_BTREE_META );
  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pBt!=0 );
  assert( DbMaskTest(p->btreeMask, iDb) );
 
  sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
  pOut = out2Prerelease(p, pOp);
  pOut->u.i = iMeta;
  break;
}
 
/* Opcode: SetCookie P1 P2 P3 * P5
**
** Write the integer value P3 into cookie number P2 of database P1.
** P2==1 is the schema version.  P2==2 is the database format.
** P2==3 is the recommended pager cache
** size, and so forth.  P1==0 is the main database file and P1==1 is the
** database file used to store temporary tables.
**
** A transaction must be started before executing this opcode.
**
** If P2 is the SCHEMA_VERSION cookie (cookie number 1) then the internal
** schema version is set to P3-P5.  The "PRAGMA schema_version=N" statement
** has P5 set to 1, so that the internal schema version will be different
** from the database schema version, resulting in a schema reset.
*/
case OP_SetCookie: {
  Db *pDb;
 
  sqlite3VdbeIncrWriteCounter(p, 0);
  assert( pOp->p2<SQLITE_N_BTREE_META );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
  assert( p->readOnly==0 );
  pDb = &db->aDb[pOp->p1];
  assert( pDb->pBt!=0 );
  assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
  /* See note about index shifting on OP_ReadCookie */
  rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
  if( pOp->p2==BTREE_SCHEMA_VERSION ){
    /* When the schema cookie changes, record the new cookie internally */
    pDb->pSchema->schema_cookie = pOp->p3 - pOp->p5;
    db->mDbFlags |= DBFLAG_SchemaChange;
  }else if( pOp->p2==BTREE_FILE_FORMAT ){
    /* Record changes in the file format */
    pDb->pSchema->file_format = pOp->p3;
  }
  if( pOp->p1==1 ){
    /* Invalidate all prepared statements whenever the TEMP database
    ** schema is changed.  Ticket #1644 */
    sqlite3ExpirePreparedStatements(db, 0);
    p->expired = 0;
  }
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: OpenRead P1 P2 P3 P4 P5
** Synopsis: root=P2 iDb=P3
**
** Open a read-only cursor for the database table whose root page is
** P2 in a database file.  The database file is determined by P3.
** P3==0 means the main database, P3==1 means the database used for
** temporary tables, and P3>1 means used the corresponding attached
** database.  Give the new cursor an identifier of P1.  The P1
** values need not be contiguous but all P1 values should be small integers.
** It is an error for P1 to be negative.
**
** Allowed P5 bits:
** <ul>
** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
**       of OP_SeekLE/OP_IdxLT)
** </ul>
**
** The P4 value may be either an integer (P4_INT32) or a pointer to
** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
** object, then table being opened must be an [index b-tree] where the
** KeyInfo object defines the content and collating
** sequence of that index b-tree. Otherwise, if P4 is an integer
** value, then the table being opened must be a [table b-tree] with a
** number of columns no less than the value of P4.
**
** See also: OpenWrite, ReopenIdx
*/
/* Opcode: ReopenIdx P1 P2 P3 P4 P5
** Synopsis: root=P2 iDb=P3
**
** The ReopenIdx opcode works like OP_OpenRead except that it first
** checks to see if the cursor on P1 is already open on the same
** b-tree and if it is this opcode becomes a no-op.  In other words,
** if the cursor is already open, do not reopen it.
**
** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
** and with P4 being a P4_KEYINFO object.  Furthermore, the P3 value must
** be the same as every other ReopenIdx or OpenRead for the same cursor
** number.
**
** Allowed P5 bits:
** <ul>
** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
**       of OP_SeekLE/OP_IdxLT)
** </ul>
**
** See also: OP_OpenRead, OP_OpenWrite
*/
/* Opcode: OpenWrite P1 P2 P3 P4 P5
** Synopsis: root=P2 iDb=P3
**
** Open a read/write cursor named P1 on the table or index whose root
** page is P2 (or whose root page is held in register P2 if the
** OPFLAG_P2ISREG bit is set in P5 - see below).
**
** The P4 value may be either an integer (P4_INT32) or a pointer to
** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
** object, then table being opened must be an [index b-tree] where the
** KeyInfo object defines the content and collating
** sequence of that index b-tree. Otherwise, if P4 is an integer
** value, then the table being opened must be a [table b-tree] with a
** number of columns no less than the value of P4.
**
** Allowed P5 bits:
** <ul>
** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
**       of OP_SeekLE/OP_IdxLT)
** <li>  <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek
**       and subsequently delete entries in an index btree.  This is a
**       hint to the storage engine that the storage engine is allowed to
**       ignore.  The hint is not used by the official SQLite b*tree storage
**       engine, but is used by COMDB2.
** <li>  <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2
**       as the root page, not the value of P2 itself.
** </ul>
**
** This instruction works like OpenRead except that it opens the cursor
** in read/write mode.
**
** See also: OP_OpenRead, OP_ReopenIdx
*/
case OP_ReopenIdx: {
  int nField;
  KeyInfo *pKeyInfo;
  u32 p2;
  int iDb;
  int wrFlag;
  Btree *pX;
  VdbeCursor *pCur;
  Db *pDb;
 
  assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
  assert( pOp->p4type==P4_KEYINFO );
  pCur = p->apCsr[pOp->p1];
  if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
    assert( pCur->iDb==pOp->p3 );      /* Guaranteed by the code generator */
    goto open_cursor_set_hints;
  }
  /* If the cursor is not currently open or is open on a different
  ** index, then fall through into OP_OpenRead to force a reopen */
case OP_OpenRead:
case OP_OpenWrite:
 
  assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
  assert( p->bIsReader );
  assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
          || p->readOnly==0 );
 
  if( p->expired==1 ){
    rc = SQLITE_ABORT_ROLLBACK;
    goto abort_due_to_error;
  }
 
  nField = 0;
  pKeyInfo = 0;
  p2 = (u32)pOp->p2;
  iDb = pOp->p3;
  assert( iDb>=0 && iDb<db->nDb );
  assert( DbMaskTest(p->btreeMask, iDb) );
  pDb = &db->aDb[iDb];
  pX = pDb->pBt;
  assert( pX!=0 );
  if( pOp->opcode==OP_OpenWrite ){
    assert( OPFLAG_FORDELETE==BTREE_FORDELETE );
    wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( pDb->pSchema->file_format < p->minWriteFileFormat ){
      p->minWriteFileFormat = pDb->pSchema->file_format;
    }
  }else{
    wrFlag = 0;
  }
  if( pOp->p5 & OPFLAG_P2ISREG ){
    assert( p2>0 );
    assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
    assert( pOp->opcode==OP_OpenWrite );
    pIn2 = &aMem[p2];
    assert( memIsValid(pIn2) );
    assert( (pIn2->flags & MEM_Int)!=0 );
    sqlite3VdbeMemIntegerify(pIn2);
    p2 = (int)pIn2->u.i;
    /* The p2 value always comes from a prior OP_CreateBtree opcode and
    ** that opcode will always set the p2 value to 2 or more or else fail.
    ** If there were a failure, the prepared statement would have halted
    ** before reaching this instruction. */
    assert( p2>=2 );
  }
  if( pOp->p4type==P4_KEYINFO ){
    pKeyInfo = pOp->p4.pKeyInfo;
    assert( pKeyInfo->enc==ENC(db) );
    assert( pKeyInfo->db==db );
    nField = pKeyInfo->nAllField;
  }else if( pOp->p4type==P4_INT32 ){
    nField = pOp->p4.i;
  }
  assert( pOp->p1>=0 );
  assert( nField>=0 );
  testcase( nField==0 );  /* Table with INTEGER PRIMARY KEY and nothing else */
  pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
  if( pCur==0 ) goto no_mem;
  pCur->nullRow = 1;
  pCur->isOrdered = 1;
  pCur->pgnoRoot = p2;
#ifdef SQLITE_DEBUG
  pCur->wrFlag = wrFlag;
#endif
  rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
  pCur->pKeyInfo = pKeyInfo;
  /* Set the VdbeCursor.isTable variable. Previous versions of
  ** SQLite used to check if the root-page flags were sane at this point
  ** and report database corruption if they were not, but this check has
  ** since moved into the btree layer.  */
  pCur->isTable = pOp->p4type!=P4_KEYINFO;
 
open_cursor_set_hints:
  assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
  assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
  testcase( pOp->p5 & OPFLAG_BULKCSR );
  testcase( pOp->p2 & OPFLAG_SEEKEQ );
  sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
                               (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: OpenDup P1 P2 * * *
**
** Open a new cursor P1 that points to the same ephemeral table as
** cursor P2.  The P2 cursor must have been opened by a prior OP_OpenEphemeral
** opcode.  Only ephemeral cursors may be duplicated.
**
** Duplicate ephemeral cursors are used for self-joins of materialized views.
*/
case OP_OpenDup: {
  VdbeCursor *pOrig;    /* The original cursor to be duplicated */
  VdbeCursor *pCx;      /* The new cursor */
 
  pOrig = p->apCsr[pOp->p2];
  assert( pOrig );
  assert( pOrig->pBtx!=0 );  /* Only ephemeral cursors can be duplicated */
 
  pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE);
  if( pCx==0 ) goto no_mem;
  pCx->nullRow = 1;
  pCx->isEphemeral = 1;
  pCx->pKeyInfo = pOrig->pKeyInfo;
  pCx->isTable = pOrig->isTable;
  pCx->pgnoRoot = pOrig->pgnoRoot;
  pCx->isOrdered = pOrig->isOrdered;
  rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
                          pCx->pKeyInfo, pCx->uc.pCursor);
  /* The sqlite3BtreeCursor() routine can only fail for the first cursor
  ** opened for a database.  Since there is already an open cursor when this
  ** opcode is run, the sqlite3BtreeCursor() cannot fail */
  assert( rc==SQLITE_OK );
  break;
}
 
 
/* Opcode: OpenEphemeral P1 P2 * P4 P5
** Synopsis: nColumn=P2
**
** Open a new cursor P1 to a transient table.
** The cursor is always opened read/write even if
** the main database is read-only.  The ephemeral
** table is deleted automatically when the cursor is closed.
**
** If the cursor P1 is already opened on an ephemeral table, the table
** is cleared (all content is erased).
**
** P2 is the number of columns in the ephemeral table.
** The cursor points to a BTree table if P4==0 and to a BTree index
** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
** that defines the format of keys in the index.
**
** The P5 parameter can be a mask of the BTREE_* flags defined
** in btree.h.  These flags control aspects of the operation of
** the btree.  The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
** added automatically.
*/
/* Opcode: OpenAutoindex P1 P2 * P4 *
** Synopsis: nColumn=P2
**
** This opcode works the same as OP_OpenEphemeral.  It has a
** different name to distinguish its use.  Tables created using
** by this opcode will be used for automatically created transient
** indices in joins.
*/
case OP_OpenAutoindex:
case OP_OpenEphemeral: {
  VdbeCursor *pCx;
  KeyInfo *pKeyInfo;
 
  static const int vfsFlags =
      SQLITE_OPEN_READWRITE |
      SQLITE_OPEN_CREATE |
      SQLITE_OPEN_EXCLUSIVE |
      SQLITE_OPEN_DELETEONCLOSE |
      SQLITE_OPEN_TRANSIENT_DB;
  assert( pOp->p1>=0 );
  assert( pOp->p2>=0 );
  pCx = p->apCsr[pOp->p1];
  if( pCx && pCx->pBtx ){
    /* If the ephermeral table is already open, erase all existing content
    ** so that the table is empty again, rather than creating a new table. */
    assert( pCx->isEphemeral );
    pCx->seqCount = 0;
    pCx->cacheStatus = CACHE_STALE;
    rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0);
  }else{
    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE);
    if( pCx==0 ) goto no_mem;
    pCx->isEphemeral = 1;
    rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx,
                          BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
                          vfsFlags);
    if( rc==SQLITE_OK ){
      rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0);
    }
    if( rc==SQLITE_OK ){
      /* If a transient index is required, create it by calling
      ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
      ** opening it. If a transient table is required, just use the
      ** automatically created table with root-page 1 (an BLOB_INTKEY table).
      */
      if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
        assert( pOp->p4type==P4_KEYINFO );
        rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot,
                                     BTREE_BLOBKEY | pOp->p5);
        if( rc==SQLITE_OK ){
          assert( pCx->pgnoRoot==SCHEMA_ROOT+1 );
          assert( pKeyInfo->db==db );
          assert( pKeyInfo->enc==ENC(db) );
          rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
                                  pKeyInfo, pCx->uc.pCursor);
        }
        pCx->isTable = 0;
      }else{
        pCx->pgnoRoot = SCHEMA_ROOT;
        rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR,
                                0, pCx->uc.pCursor);
        pCx->isTable = 1;
      }
    }
    pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
  }
  if( rc ) goto abort_due_to_error;
  pCx->nullRow = 1;
  break;
}
 
/* Opcode: SorterOpen P1 P2 P3 P4 *
**
** This opcode works like OP_OpenEphemeral except that it opens
** a transient index that is specifically designed to sort large
** tables using an external merge-sort algorithm.
**
** If argument P3 is non-zero, then it indicates that the sorter may
** assume that a stable sort considering the first P3 fields of each
** key is sufficient to produce the required results.
*/
case OP_SorterOpen: {
  VdbeCursor *pCx;
 
  assert( pOp->p1>=0 );
  assert( pOp->p2>=0 );
  pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER);
  if( pCx==0 ) goto no_mem;
  pCx->pKeyInfo = pOp->p4.pKeyInfo;
  assert( pCx->pKeyInfo->db==db );
  assert( pCx->pKeyInfo->enc==ENC(db) );
  rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: SequenceTest P1 P2 * * *
** Synopsis: if( cursor[P1].ctr++ ) pc = P2
**
** P1 is a sorter cursor. If the sequence counter is currently zero, jump
** to P2. Regardless of whether or not the jump is taken, increment the
** the sequence value.
*/
case OP_SequenceTest: {
  VdbeCursor *pC;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( isSorter(pC) );
  if( (pC->seqCount++)==0 ){
    goto jump_to_p2;
  }
  break;
}
 
/* Opcode: OpenPseudo P1 P2 P3 * *
** Synopsis: P3 columns in r[P2]
**
** Open a new cursor that points to a fake table that contains a single
** row of data.  The content of that one row is the content of memory
** register P2.  In other words, cursor P1 becomes an alias for the
** MEM_Blob content contained in register P2.
**
** A pseudo-table created by this opcode is used to hold a single
** row output from the sorter so that the row can be decomposed into
** individual columns using the OP_Column opcode.  The OP_Column opcode
** is the only cursor opcode that works with a pseudo-table.
**
** P3 is the number of fields in the records that will be stored by
** the pseudo-table.
*/
case OP_OpenPseudo: {
  VdbeCursor *pCx;
 
  assert( pOp->p1>=0 );
  assert( pOp->p3>=0 );
  pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO);
  if( pCx==0 ) goto no_mem;
  pCx->nullRow = 1;
  pCx->seekResult = pOp->p2;
  pCx->isTable = 1;
  /* Give this pseudo-cursor a fake BtCursor pointer so that pCx
  ** can be safely passed to sqlite3VdbeCursorMoveto().  This avoids a test
  ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto()
  ** which is a performance optimization */
  pCx->uc.pCursor = sqlite3BtreeFakeValidCursor();
  assert( pOp->p5==0 );
  break;
}
 
/* Opcode: Close P1 * * * *
**
** Close a cursor previously opened as P1.  If P1 is not
** currently open, this instruction is a no-op.
*/
case OP_Close: {
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
  p->apCsr[pOp->p1] = 0;
  break;
}
 
#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
/* Opcode: ColumnsUsed P1 * * P4 *
**
** This opcode (which only exists if SQLite was compiled with
** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the
** table or index for cursor P1 are used.  P4 is a 64-bit integer
** (P4_INT64) in which the first 63 bits are one for each of the
** first 63 columns of the table or index that are actually used
** by the cursor.  The high-order bit is set if any column after
** the 64th is used.
*/
case OP_ColumnsUsed: {
  VdbeCursor *pC;
  pC = p->apCsr[pOp->p1];
  assert( pC->eCurType==CURTYPE_BTREE );
  pC->maskUsed = *(u64*)pOp->p4.pI64;
  break;
}
#endif
 
/* Opcode: SeekGE P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
** use the value in register P3 as the key.  If cursor P1 refers
** to an SQL index, then P3 is the first in an array of P4 registers
** that are used as an unpacked index key.
**
** Reposition cursor P1 so that  it points to the smallest entry that
** is greater than or equal to the key value. If there are no records
** greater than or equal to the key and P2 is not zero, then jump to P2.
**
** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
** opcode will either land on a record that exactly matches the key, or
** else it will cause a jump to P2.  When the cursor is OPFLAG_SEEKEQ,
** this opcode must be followed by an IdxLE opcode with the same arguments.
** The IdxGT opcode will be skipped if this opcode succeeds, but the
** IdxGT opcode will be used on subsequent loop iterations.  The
** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
** is an equality search.
**
** This opcode leaves the cursor configured to move in forward order,
** from the beginning toward the end.  In other words, the cursor is
** configured to use Next, not Prev.
**
** See also: Found, NotFound, SeekLt, SeekGt, SeekLe
*/
/* Opcode: SeekGT P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
** use the value in register P3 as a key. If cursor P1 refers
** to an SQL index, then P3 is the first in an array of P4 registers
** that are used as an unpacked index key.
**
** Reposition cursor P1 so that it points to the smallest entry that
** is greater than the key value. If there are no records greater than
** the key and P2 is not zero, then jump to P2.
**
** This opcode leaves the cursor configured to move in forward order,
** from the beginning toward the end.  In other words, the cursor is
** configured to use Next, not Prev.
**
** See also: Found, NotFound, SeekLt, SeekGe, SeekLe
*/
/* Opcode: SeekLT P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
** use the value in register P3 as a key. If cursor P1 refers
** to an SQL index, then P3 is the first in an array of P4 registers
** that are used as an unpacked index key.
**
** Reposition cursor P1 so that  it points to the largest entry that
** is less than the key value. If there are no records less than
** the key and P2 is not zero, then jump to P2.
**
** This opcode leaves the cursor configured to move in reverse order,
** from the end toward the beginning.  In other words, the cursor is
** configured to use Prev, not Next.
**
** See also: Found, NotFound, SeekGt, SeekGe, SeekLe
*/
/* Opcode: SeekLE P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
** use the value in register P3 as a key. If cursor P1 refers
** to an SQL index, then P3 is the first in an array of P4 registers
** that are used as an unpacked index key.
**
** Reposition cursor P1 so that it points to the largest entry that
** is less than or equal to the key value. If there are no records
** less than or equal to the key and P2 is not zero, then jump to P2.
**
** This opcode leaves the cursor configured to move in reverse order,
** from the end toward the beginning.  In other words, the cursor is
** configured to use Prev, not Next.
**
** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
** opcode will either land on a record that exactly matches the key, or
** else it will cause a jump to P2.  When the cursor is OPFLAG_SEEKEQ,
** this opcode must be followed by an IdxLE opcode with the same arguments.
** The IdxGE opcode will be skipped if this opcode succeeds, but the
** IdxGE opcode will be used on subsequent loop iterations.  The
** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
** is an equality search.
**
** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
*/
case OP_SeekLT:         /* jump, in3, group */
case OP_SeekLE:         /* jump, in3, group */
case OP_SeekGE:         /* jump, in3, group */
case OP_SeekGT: {       /* jump, in3, group */
  int res;           /* Comparison result */
  int oc;            /* Opcode */
  VdbeCursor *pC;    /* The cursor to seek */
  UnpackedRecord r;  /* The key to seek for */
  int nField;        /* Number of columns or fields in the key */
  i64 iKey;          /* The rowid we are to seek to */
  int eqOnly;        /* Only interested in == results */
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p2!=0 );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( OP_SeekLE == OP_SeekLT+1 );
  assert( OP_SeekGE == OP_SeekLT+2 );
  assert( OP_SeekGT == OP_SeekLT+3 );
  assert( pC->isOrdered );
  assert( pC->uc.pCursor!=0 );
  oc = pOp->opcode;
  eqOnly = 0;
  pC->nullRow = 0;
#ifdef SQLITE_DEBUG
  pC->seekOp = pOp->opcode;
#endif
 
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;
  if( pC->isTable ){
    u16 flags3, newType;
    /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
    assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
              || CORRUPT_DB );
 
    /* The input value in P3 might be of any type: integer, real, string,
    ** blob, or NULL.  But it needs to be an integer before we can do
    ** the seek, so convert it. */
    pIn3 = &aMem[pOp->p3];
    flags3 = pIn3->flags;
    if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){
      applyNumericAffinity(pIn3, 0);
    }
    iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */
    newType = pIn3->flags; /* Record the type after applying numeric affinity */
    pIn3->flags = flags3;  /* But convert the type back to its original */
 
    /* If the P3 value could not be converted into an integer without
    ** loss of information, then special processing is required... */
    if( (newType & (MEM_Int|MEM_IntReal))==0 ){
      if( (newType & MEM_Real)==0 ){
        if( (newType & MEM_Null) || oc>=OP_SeekGE ){
          VdbeBranchTaken(1,2);
          goto jump_to_p2;
        }else{
          rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
          if( rc!=SQLITE_OK ) goto abort_due_to_error;
          goto seek_not_found;
        }
      }else
 
      /* If the approximation iKey is larger than the actual real search
      ** term, substitute >= for > and < for <=. e.g. if the search term
      ** is 4.9 and the integer approximation 5:
      **
      **        (x >  4.9)    ->     (x >= 5)
      **        (x <= 4.9)    ->     (x <  5)
      */
      if( pIn3->u.r<(double)iKey ){
        assert( OP_SeekGE==(OP_SeekGT-1) );
        assert( OP_SeekLT==(OP_SeekLE-1) );
        assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
        if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
      }
 
      /* If the approximation iKey is smaller than the actual real search
      ** term, substitute <= for < and > for >=.  */
      else if( pIn3->u.r>(double)iKey ){
        assert( OP_SeekLE==(OP_SeekLT+1) );
        assert( OP_SeekGT==(OP_SeekGE+1) );
        assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
        if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
      }
    }
    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
    pC->movetoTarget = iKey;  /* Used by OP_Delete */
    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
  }else{
    /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the
    ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be
    ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively,
    ** with the same key.
    */
    if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
      eqOnly = 1;
      assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
      assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
      assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT );
      assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT );
      assert( pOp[1].p1==pOp[0].p1 );
      assert( pOp[1].p2==pOp[0].p2 );
      assert( pOp[1].p3==pOp[0].p3 );
      assert( pOp[1].p4.i==pOp[0].p4.i );
    }
 
    nField = pOp->p4.i;
    assert( pOp->p4type==P4_INT32 );
    assert( nField>0 );
    r.pKeyInfo = pC->pKeyInfo;
    r.nField = (u16)nField;
 
    /* The next line of code computes as follows, only faster:
    **   if( oc==OP_SeekGT || oc==OP_SeekLE ){
    **     r.default_rc = -1;
    **   }else{
    **     r.default_rc = +1;
    **   }
    */
    r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
    assert( oc!=OP_SeekGT || r.default_rc==-1 );
    assert( oc!=OP_SeekLE || r.default_rc==-1 );
    assert( oc!=OP_SeekGE || r.default_rc==+1 );
    assert( oc!=OP_SeekLT || r.default_rc==+1 );
 
    r.aMem = &aMem[pOp->p3];
#ifdef SQLITE_DEBUG
    { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
#endif
    r.eqSeen = 0;
    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
    if( eqOnly && r.eqSeen==0 ){
      assert( res!=0 );
      goto seek_not_found;
    }
  }
#ifdef SQLITE_TEST
  sqlite3_search_count++;
#endif
  if( oc>=OP_SeekGE ){  assert( oc==OP_SeekGE || oc==OP_SeekGT );
    if( res<0 || (res==0 && oc==OP_SeekGT) ){
      res = 0;
      rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
      if( rc!=SQLITE_OK ){
        if( rc==SQLITE_DONE ){
          rc = SQLITE_OK;
          res = 1;
        }else{
          goto abort_due_to_error;
        }
      }
    }else{
      res = 0;
    }
  }else{
    assert( oc==OP_SeekLT || oc==OP_SeekLE );
    if( res>0 || (res==0 && oc==OP_SeekLT) ){
      res = 0;
      rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
      if( rc!=SQLITE_OK ){
        if( rc==SQLITE_DONE ){
          rc = SQLITE_OK;
          res = 1;
        }else{
          goto abort_due_to_error;
        }
      }
    }else{
      /* res might be negative because the table is empty.  Check to
      ** see if this is the case.
      */
      res = sqlite3BtreeEof(pC->uc.pCursor);
    }
  }
seek_not_found:
  assert( pOp->p2>0 );
  VdbeBranchTaken(res!=0,2);
  if( res ){
    goto jump_to_p2;
  }else if( eqOnly ){
    assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
    pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */
  }
  break;
}
 
/* Opcode: SeekHit P1 P2 * * *
** Synopsis: seekHit=P2
**
** Set the seekHit flag on cursor P1 to the value in P2.
** The seekHit flag is used by the IfNoHope opcode.
**
** P1 must be a valid b-tree cursor.  P2 must be a boolean value,
** either 0 or 1.
*/
case OP_SeekHit: {
  VdbeCursor *pC;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pOp->p2==0 || pOp->p2==1 );
  pC->seekHit = pOp->p2 & 1;
  break;
}
 
/* Opcode: IfNotOpen P1 P2 * * *
** Synopsis: if( !csr[P1] ) goto P2
**
** If cursor P1 is not open, jump to instruction P2. Otherwise, fall through.
*/
case OP_IfNotOpen: {        /* jump */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  VdbeBranchTaken(p->apCsr[pOp->p1]==0, 2);
  if( !p->apCsr[pOp->p1] ){
    goto jump_to_p2_and_check_for_interrupt;
  }
  break;
}
 
/* Opcode: Found P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
** P4>0 then register P3 is the first of P4 registers that form an unpacked
** record.
**
** Cursor P1 is on an index btree.  If the record identified by P3 and P4
** is a prefix of any entry in P1 then a jump is made to P2 and
** P1 is left pointing at the matching entry.
**
** This operation leaves the cursor in a state where it can be
** advanced in the forward direction.  The Next instruction will work,
** but not the Prev instruction.
**
** See also: NotFound, NoConflict, NotExists. SeekGe
*/
/* Opcode: NotFound P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
** P4>0 then register P3 is the first of P4 registers that form an unpacked
** record.
**
** Cursor P1 is on an index btree.  If the record identified by P3 and P4
** is not the prefix of any entry in P1 then a jump is made to P2.  If P1
** does contain an entry whose prefix matches the P3/P4 record then control
** falls through to the next instruction and P1 is left pointing at the
** matching entry.
**
** This operation leaves the cursor in a state where it cannot be
** advanced in either direction.  In other words, the Next and Prev
** opcodes do not work after this operation.
**
** See also: Found, NotExists, NoConflict, IfNoHope
*/
/* Opcode: IfNoHope P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** Register P3 is the first of P4 registers that form an unpacked
** record.
**
** Cursor P1 is on an index btree.  If the seekHit flag is set on P1, then
** this opcode is a no-op.  But if the seekHit flag of P1 is clear, then
** check to see if there is any entry in P1 that matches the
** prefix identified by P3 and P4.  If no entry matches the prefix,
** jump to P2.  Otherwise fall through.
**
** This opcode behaves like OP_NotFound if the seekHit
** flag is clear and it behaves like OP_Noop if the seekHit flag is set.
**
** This opcode is used in IN clause processing for a multi-column key.
** If an IN clause is attached to an element of the key other than the
** left-most element, and if there are no matches on the most recent
** seek over the whole key, then it might be that one of the key element
** to the left is prohibiting a match, and hence there is "no hope" of
** any match regardless of how many IN clause elements are checked.
** In such a case, we abandon the IN clause search early, using this
** opcode.  The opcode name comes from the fact that the
** jump is taken if there is "no hope" of achieving a match.
**
** See also: NotFound, SeekHit
*/
/* Opcode: NoConflict P1 P2 P3 P4 *
** Synopsis: key=r[P3@P4]
**
** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
** P4>0 then register P3 is the first of P4 registers that form an unpacked
** record.
**
** Cursor P1 is on an index btree.  If the record identified by P3 and P4
** contains any NULL value, jump immediately to P2.  If all terms of the
** record are not-NULL then a check is done to determine if any row in the
** P1 index btree has a matching key prefix.  If there are no matches, jump
** immediately to P2.  If there is a match, fall through and leave the P1
** cursor pointing to the matching row.
**
** This opcode is similar to OP_NotFound with the exceptions that the
** branch is always taken if any part of the search key input is NULL.
**
** This operation leaves the cursor in a state where it cannot be
** advanced in either direction.  In other words, the Next and Prev
** opcodes do not work after this operation.
**
** See also: NotFound, Found, NotExists
*/
case OP_IfNoHope: {     /* jump, in3 */
  VdbeCursor *pC;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  if( pC->seekHit ) break;
  /* Fall through into OP_NotFound */
  /* no break */ deliberate_fall_through
}
case OP_NoConflict:     /* jump, in3 */
case OP_NotFound:       /* jump, in3 */
case OP_Found: {        /* jump, in3 */
  int alreadyExists;
  int takeJump;
  int ii;
  VdbeCursor *pC;
  int res;
  UnpackedRecord *pFree;
  UnpackedRecord *pIdxKey;
  UnpackedRecord r;
 
#ifdef SQLITE_TEST
  if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
#endif
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p4type==P4_INT32 );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
#ifdef SQLITE_DEBUG
  pC->seekOp = pOp->opcode;
#endif
  pIn3 = &aMem[pOp->p3];
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0 );
  assert( pC->isTable==0 );
  if( pOp->p4.i>0 ){
    r.pKeyInfo = pC->pKeyInfo;
    r.nField = (u16)pOp->p4.i;
    r.aMem = pIn3;
#ifdef SQLITE_DEBUG
    for(ii=0; ii<r.nField; ii++){
      assert( memIsValid(&r.aMem[ii]) );
      assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
      if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
    }
#endif
    pIdxKey = &r;
    pFree = 0;
  }else{
    assert( pIn3->flags & MEM_Blob );
    rc = ExpandBlob(pIn3);
    assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
    if( rc ) goto no_mem;
    pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
    if( pIdxKey==0 ) goto no_mem;
    sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
  }
  pIdxKey->default_rc = 0;
  takeJump = 0;
  if( pOp->opcode==OP_NoConflict ){
    /* For the OP_NoConflict opcode, take the jump if any of the
    ** input fields are NULL, since any key with a NULL will not
    ** conflict */
    for(ii=0; ii<pIdxKey->nField; ii++){
      if( pIdxKey->aMem[ii].flags & MEM_Null ){
        takeJump = 1;
        break;
      }
    }
  }
  rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
  if( pFree ) sqlite3DbFreeNN(db, pFree);
  if( rc!=SQLITE_OK ){
    goto abort_due_to_error;
  }
  pC->seekResult = res;
  alreadyExists = (res==0);
  pC->nullRow = 1-alreadyExists;
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;
  if( pOp->opcode==OP_Found ){
    VdbeBranchTaken(alreadyExists!=0,2);
    if( alreadyExists ) goto jump_to_p2;
  }else{
    VdbeBranchTaken(takeJump||alreadyExists==0,2);
    if( takeJump || !alreadyExists ) goto jump_to_p2;
  }
  break;
}
 
/* Opcode: SeekRowid P1 P2 P3 * *
** Synopsis: intkey=r[P3]
**
** P1 is the index of a cursor open on an SQL table btree (with integer
** keys).  If register P3 does not contain an integer or if P1 does not
** contain a record with rowid P3 then jump immediately to P2.
** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain
** a record with rowid P3 then
** leave the cursor pointing at that record and fall through to the next
** instruction.
**
** The OP_NotExists opcode performs the same operation, but with OP_NotExists
** the P3 register must be guaranteed to contain an integer value.  With this
** opcode, register P3 might not contain an integer.
**
** The OP_NotFound opcode performs the same operation on index btrees
** (with arbitrary multi-value keys).
**
** This opcode leaves the cursor in a state where it cannot be advanced
** in either direction.  In other words, the Next and Prev opcodes will
** not work following this opcode.
**
** See also: Found, NotFound, NoConflict, SeekRowid
*/
/* Opcode: NotExists P1 P2 P3 * *
** Synopsis: intkey=r[P3]
**
** P1 is the index of a cursor open on an SQL table btree (with integer
** keys).  P3 is an integer rowid.  If P1 does not contain a record with
** rowid P3 then jump immediately to P2.  Or, if P2 is 0, raise an
** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then
** leave the cursor pointing at that record and fall through to the next
** instruction.
**
** The OP_SeekRowid opcode performs the same operation but also allows the
** P3 register to contain a non-integer value, in which case the jump is
** always taken.  This opcode requires that P3 always contain an integer.
**
** The OP_NotFound opcode performs the same operation on index btrees
** (with arbitrary multi-value keys).
**
** This opcode leaves the cursor in a state where it cannot be advanced
** in either direction.  In other words, the Next and Prev opcodes will
** not work following this opcode.
**
** See also: Found, NotFound, NoConflict, SeekRowid
*/
case OP_SeekRowid: {        /* jump, in3 */
  VdbeCursor *pC;
  BtCursor *pCrsr;
  int res;
  u64 iKey;
 
  pIn3 = &aMem[pOp->p3];
  testcase( pIn3->flags & MEM_Int );
  testcase( pIn3->flags & MEM_IntReal );
  testcase( pIn3->flags & MEM_Real );
  testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
  if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
    /* If pIn3->u.i does not contain an integer, compute iKey as the
    ** integer value of pIn3.  Jump to P2 if pIn3 cannot be converted
    ** into an integer without loss of information.  Take care to avoid
    ** changing the datatype of pIn3, however, as it is used by other
    ** parts of the prepared statement. */
    Mem x = pIn3[0];
    applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding);
    if( (x.flags & MEM_Int)==0 ) goto jump_to_p2;
    iKey = x.u.i;
    goto notExistsWithKey;
  }
  /* Fall through into OP_NotExists */
  /* no break */ deliberate_fall_through
case OP_NotExists:          /* jump, in3 */
  pIn3 = &aMem[pOp->p3];
  assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  iKey = pIn3->u.i;
notExistsWithKey:
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
#ifdef SQLITE_DEBUG
  if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
#endif
  assert( pC->isTable );
  assert( pC->eCurType==CURTYPE_BTREE );
  pCrsr = pC->uc.pCursor;
  assert( pCrsr!=0 );
  res = 0;
  rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
  assert( rc==SQLITE_OK || res==0 );
  pC->movetoTarget = iKey;  /* Used by OP_Delete */
  pC->nullRow = 0;
  pC->cacheStatus = CACHE_STALE;
  pC->deferredMoveto = 0;
  VdbeBranchTaken(res!=0,2);
  pC->seekResult = res;
  if( res!=0 ){
    assert( rc==SQLITE_OK );
    if( pOp->p2==0 ){
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      goto jump_to_p2;
    }
  }
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: Sequence P1 P2 * * *
** Synopsis: r[P2]=cursor[P1].ctr++
**
** Find the next available sequence number for cursor P1.
** Write the sequence number into register P2.
** The sequence number on the cursor is incremented after this
** instruction.
*/
case OP_Sequence: {           /* out2 */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( p->apCsr[pOp->p1]!=0 );
  assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
  pOut = out2Prerelease(p, pOp);
  pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
  break;
}
 
 
/* Opcode: NewRowid P1 P2 P3 * *
** Synopsis: r[P2]=rowid
**
** Get a new integer record number (a.k.a "rowid") used as the key to a table.
** The record number is not previously used as a key in the database
** table that cursor P1 points to.  The new record number is written
** written to register P2.
**
** If P3>0 then P3 is a register in the root frame of this VDBE that holds
** the largest previously generated record number. No new record numbers are
** allowed to be less than this value. When this value reaches its maximum,
** an SQLITE_FULL error is generated. The P3 register is updated with the '
** generated record number. This P3 mechanism is used to help implement the
** AUTOINCREMENT feature.
*/
case OP_NewRowid: {           /* out2 */
  i64 v;                 /* The new rowid */
  VdbeCursor *pC;        /* Cursor of table to get the new rowid */
  int res;               /* Result of an sqlite3BtreeLast() */
  int cnt;               /* Counter to limit the number of searches */
  Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
  VdbeFrame *pFrame;     /* Root frame of VDBE */
 
  v = 0;
  res = 0;
  pOut = out2Prerelease(p, pOp);
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->isTable );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0 );
  {
    /* The next rowid or record number (different terms for the same
    ** thing) is obtained in a two-step algorithm.
    **
    ** First we attempt to find the largest existing rowid and add one
    ** to that.  But if the largest existing rowid is already the maximum
    ** positive integer, we have to fall through to the second
    ** probabilistic algorithm
    **
    ** The second algorithm is to select a rowid at random and see if
    ** it already exists in the table.  If it does not exist, we have
    ** succeeded.  If the random rowid does exist, we select a new one
    ** and try again, up to 100 times.
    */
    assert( pC->isTable );
 
#ifdef SQLITE_32BIT_ROWID
#   define MAX_ROWID 0x7fffffff
#else
    /* Some compilers complain about constants of the form 0x7fffffffffffffff.
    ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
    ** to provide the constant while making all compilers happy.
    */
#   define MAX_ROWID  (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
#endif
 
    if( !pC->useRandomRowid ){
      rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
      if( rc!=SQLITE_OK ){
        goto abort_due_to_error;
      }
      if( res ){
        v = 1;   /* IMP: R-61914-48074 */
      }else{
        assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
        v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
        if( v>=MAX_ROWID ){
          pC->useRandomRowid = 1;
        }else{
          v++;   /* IMP: R-29538-34987 */
        }
      }
    }
 
#ifndef SQLITE_OMIT_AUTOINCREMENT
    if( pOp->p3 ){
      /* Assert that P3 is a valid memory cell. */
      assert( pOp->p3>0 );
      if( p->pFrame ){
        for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
        /* Assert that P3 is a valid memory cell. */
        assert( pOp->p3<=pFrame->nMem );
        pMem = &pFrame->aMem[pOp->p3];
      }else{
        /* Assert that P3 is a valid memory cell. */
        assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
        pMem = &aMem[pOp->p3];
        memAboutToChange(p, pMem);
      }
      assert( memIsValid(pMem) );
 
      REGISTER_TRACE(pOp->p3, pMem);
      sqlite3VdbeMemIntegerify(pMem);
      assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
      if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
        rc = SQLITE_FULL;   /* IMP: R-17817-00630 */
        goto abort_due_to_error;
      }
      if( v<pMem->u.i+1 ){
        v = pMem->u.i + 1;
      }
      pMem->u.i = v;
    }
#endif
    if( pC->useRandomRowid ){
      /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
      ** largest possible integer (9223372036854775807) then the database
      ** engine starts picking positive candidate ROWIDs at random until
      ** it finds one that is not previously used. */
      assert( pOp->p3==0 );  /* We cannot be in random rowid mode if this is
                             ** an AUTOINCREMENT table. */
      cnt = 0;
      do{
        sqlite3_randomness(sizeof(v), &v);
        v &= (MAX_ROWID>>1); v++;  /* Ensure that v is greater than zero */
      }while(  ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
                                                 0, &res))==SQLITE_OK)
            && (res==0)
            && (++cnt<100));
      if( rc ) goto abort_due_to_error;
      if( res==0 ){
        rc = SQLITE_FULL;   /* IMP: R-38219-53002 */
        goto abort_due_to_error;
      }
      assert( v>0 );  /* EV: R-40812-03570 */
    }
    pC->deferredMoveto = 0;
    pC->cacheStatus = CACHE_STALE;
  }
  pOut->u.i = v;
  break;
}
 
/* Opcode: Insert P1 P2 P3 P4 P5
** Synopsis: intkey=r[P3] data=r[P2]
**
** Write an entry into the table of cursor P1.  A new entry is
** created if it doesn't already exist or the data for an existing
** entry is overwritten.  The data is the value MEM_Blob stored in register
** number P2. The key is stored in register P3. The key must
** be a MEM_Int.
**
** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
** then rowid is stored for subsequent return by the
** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
**
** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
** run faster by avoiding an unnecessary seek on cursor P1.  However,
** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
** seeks on the cursor or if the most recent seek used a key equal to P3.
**
** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
** UPDATE operation.  Otherwise (if the flag is clear) then this opcode
** is part of an INSERT operation.  The difference is only important to
** the update hook.
**
** Parameter P4 may point to a Table structure, or may be NULL. If it is
** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked
** following a successful insert.
**
** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
** allocated, then ownership of P2 is transferred to the pseudo-cursor
** and register P2 becomes ephemeral.  If the cursor is changed, the
** value of register P2 will then change.  Make sure this does not
** cause any problems.)
**
** This instruction only works on tables.  The equivalent instruction
** for indices is OP_IdxInsert.
*/
case OP_Insert: {
  Mem *pData;       /* MEM cell holding data for the record to be inserted */
  Mem *pKey;        /* MEM cell holding key  for the record */
  VdbeCursor *pC;   /* Cursor to table into which insert is written */
  int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
  const char *zDb;  /* database name - used by the update hook */
  Table *pTab;      /* Table structure - used by update and pre-update hooks */
  BtreePayload x;   /* Payload to be inserted */
 
  pData = &aMem[pOp->p2];
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( memIsValid(pData) );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->deferredMoveto==0 );
  assert( pC->uc.pCursor!=0 );
  assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
  assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
  REGISTER_TRACE(pOp->p2, pData);
  sqlite3VdbeIncrWriteCounter(p, pC);
 
  pKey = &aMem[pOp->p3];
  assert( pKey->flags & MEM_Int );
  assert( memIsValid(pKey) );
  REGISTER_TRACE(pOp->p3, pKey);
  x.nKey = pKey->u.i;
 
  if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
    assert( pC->iDb>=0 );
    zDb = db->aDb[pC->iDb].zDbSName;
    pTab = pOp->p4.pTab;
    assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
  }else{
    pTab = 0;
    zDb = 0;  /* Not needed.  Silence a compiler warning. */
  }
 
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  /* Invoke the pre-update hook, if any */
  if( pTab ){
    if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
      sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
    }
    if( db->xUpdateCallback==0 || pTab->aCol==0 ){
      /* Prevent post-update hook from running in cases when it should not */
      pTab = 0;
    }
  }
  if( pOp->p5 & OPFLAG_ISNOOP ) break;
#endif
 
  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
  if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
  assert( pData->flags & (MEM_Blob|MEM_Str) );
  x.pData = pData->z;
  x.nData = pData->n;
  seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
  if( pData->flags & MEM_Zero ){
    x.nZero = pData->u.nZero;
  }else{
    x.nZero = 0;
  }
  x.pKey = 0;
  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult
  );
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;
 
  /* Invoke the update-hook if required. */
  if( rc ) goto abort_due_to_error;
  if( pTab ){
    assert( db->xUpdateCallback!=0 );
    assert( pTab->aCol!=0 );
    db->xUpdateCallback(db->pUpdateArg,
           (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
           zDb, pTab->zName, x.nKey);
  }
  break;
}
 
/* Opcode: Delete P1 P2 P3 P4 P5
**
** Delete the record at which the P1 cursor is currently pointing.
**
** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
** the cursor will be left pointing at  either the next or the previous
** record in the table. If it is left pointing at the next record, then
** the next Next instruction will be a no-op. As a result, in this case
** it is ok to delete a record from within a Next loop. If
** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
** left in an undefined state.
**
** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
** delete one of several associated with deleting a table row and all its
** associated index entries.  Exactly one of those deletes is the "primary"
** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
** marked with the AUXDELETE flag.
**
** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
** change count is incremented (otherwise not).
**
** P1 must not be pseudo-table.  It has to be a real table with
** multiple rows.
**
** If P4 is not NULL then it points to a Table object. In this case either
** the update or pre-update hook, or both, may be invoked. The P1 cursor must
** have been positioned using OP_NotFound prior to invoking this opcode in
** this case. Specifically, if one is configured, the pre-update hook is
** invoked if P4 is not NULL. The update-hook is invoked if one is configured,
** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
**
** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
** of the memory cell that contains the value that the rowid of the row will
** be set to by the update.
*/
case OP_Delete: {
  VdbeCursor *pC;
  const char *zDb;
  Table *pTab;
  int opflags;
 
  opflags = pOp->p2;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0 );
  assert( pC->deferredMoveto==0 );
  sqlite3VdbeIncrWriteCounter(p, pC);
 
#ifdef SQLITE_DEBUG
  if( pOp->p4type==P4_TABLE
   && HasRowid(pOp->p4.pTab)
   && pOp->p5==0
   && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
  ){
    /* If p5 is zero, the seek operation that positioned the cursor prior to
    ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
    ** the row that is being deleted */
    i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
    assert( CORRUPT_DB || pC->movetoTarget==iKey );
  }
#endif
 
  /* If the update-hook or pre-update-hook will be invoked, set zDb to
  ** the name of the db to pass as to it. Also set local pTab to a copy
  ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
  ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set
  ** VdbeCursor.movetoTarget to the current rowid.  */
  if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
    assert( pC->iDb>=0 );
    assert( pOp->p4.pTab!=0 );
    zDb = db->aDb[pC->iDb].zDbSName;
    pTab = pOp->p4.pTab;
    if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
      pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
    }
  }else{
    zDb = 0;   /* Not needed.  Silence a compiler warning. */
    pTab = 0;  /* Not needed.  Silence a compiler warning. */
  }
 
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  /* Invoke the pre-update-hook if required. */
  if( db->xPreUpdateCallback && pOp->p4.pTab ){
    assert( !(opflags & OPFLAG_ISUPDATE)
         || HasRowid(pTab)==0
         || (aMem[pOp->p3].flags & MEM_Int)
    );
    sqlite3VdbePreUpdateHook(p, pC,
        (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE,
        zDb, pTab, pC->movetoTarget,
        pOp->p3
    );
  }
  if( opflags & OPFLAG_ISNOOP ) break;
#endif
 
  /* Only flags that can be set are SAVEPOISTION and AUXDELETE */
  assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
  assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
  assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
 
#ifdef SQLITE_DEBUG
  if( p->pFrame==0 ){
    if( pC->isEphemeral==0
        && (pOp->p5 & OPFLAG_AUXDELETE)==0
        && (pC->wrFlag & OPFLAG_FORDELETE)==0
      ){
      nExtraDelete++;
    }
    if( pOp->p2 & OPFLAG_NCHANGE ){
      nExtraDelete--;
    }
  }
#endif
 
  rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
  pC->cacheStatus = CACHE_STALE;
  pC->seekResult = 0;
  if( rc ) goto abort_due_to_error;
 
  /* Invoke the update-hook if required. */
  if( opflags & OPFLAG_NCHANGE ){
    p->nChange++;
    if( db->xUpdateCallback && HasRowid(pTab) ){
      db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
          pC->movetoTarget);
      assert( pC->iDb>=0 );
    }
  }
 
  break;
}
/* Opcode: ResetCount * * * * *
**
** The value of the change counter is copied to the database handle
** change counter (returned by subsequent calls to sqlite3_changes()).
** Then the VMs internal change counter resets to 0.
** This is used by trigger programs.
*/
case OP_ResetCount: {
  sqlite3VdbeSetChanges(db, p->nChange);
  p->nChange = 0;
  break;
}
 
/* Opcode: SorterCompare P1 P2 P3 P4
** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
**
** P1 is a sorter cursor. This instruction compares a prefix of the
** record blob in register P3 against a prefix of the entry that
** the sorter cursor currently points to.  Only the first P4 fields
** of r[P3] and the sorter record are compared.
**
** If either P3 or the sorter contains a NULL in one of their significant
** fields (not counting the P4 fields at the end which are ignored) then
** the comparison is assumed to be equal.
**
** Fall through to next instruction if the two records compare equal to
** each other.  Jump to P2 if they are different.
*/
case OP_SorterCompare: {
  VdbeCursor *pC;
  int res;
  int nKeyCol;
 
  pC = p->apCsr[pOp->p1];
  assert( isSorter(pC) );
  assert( pOp->p4type==P4_INT32 );
  pIn3 = &aMem[pOp->p3];
  nKeyCol = pOp->p4.i;
  res = 0;
  rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
  VdbeBranchTaken(res!=0,2);
  if( rc ) goto abort_due_to_error;
  if( res ) goto jump_to_p2;
  break;
};
 
/* Opcode: SorterData P1 P2 P3 * *
** Synopsis: r[P2]=data
**
** Write into register P2 the current sorter data for sorter cursor P1.
** Then clear the column header cache on cursor P3.
**
** This opcode is normally use to move a record out of the sorter and into
** a register that is the source for a pseudo-table cursor created using
** OpenPseudo.  That pseudo-table cursor is the one that is identified by
** parameter P3.  Clearing the P3 column cache as part of this opcode saves
** us from having to issue a separate NullRow instruction to clear that cache.
*/
case OP_SorterData: {
  VdbeCursor *pC;
 
  pOut = &aMem[pOp->p2];
  pC = p->apCsr[pOp->p1];
  assert( isSorter(pC) );
  rc = sqlite3VdbeSorterRowkey(pC, pOut);
  assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  if( rc ) goto abort_due_to_error;
  p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
  break;
}
 
/* Opcode: RowData P1 P2 P3 * *
** Synopsis: r[P2]=data
**
** Write into register P2 the complete row content for the row at
** which cursor P1 is currently pointing.
** There is no interpretation of the data.
** It is just copied onto the P2 register exactly as
** it is found in the database file.
**
** If cursor P1 is an index, then the content is the key of the row.
** If cursor P2 is a table, then the content extracted is the data.
**
** If the P1 cursor must be pointing to a valid row (not a NULL row)
** of a real table, not a pseudo-table.
**
** If P3!=0 then this opcode is allowed to make an ephemeral pointer
** into the database page.  That means that the content of the output
** register will be invalidated as soon as the cursor moves - including
** moves caused by other cursors that "save" the current cursors
** position in order that they can write to the same table.  If P3==0
** then a copy of the data is made into memory.  P3!=0 is faster, but
** P3==0 is safer.
**
** If P3!=0 then the content of the P2 register is unsuitable for use
** in OP_Result and any OP_Result will invalidate the P2 register content.
** The P2 register content is invalidated by opcodes like OP_Function or
** by any use of another cursor pointing to the same table.
*/
case OP_RowData: {
  VdbeCursor *pC;
  BtCursor *pCrsr;
  u32 n;
 
  pOut = out2Prerelease(p, pOp);
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( isSorter(pC)==0 );
  assert( pC->nullRow==0 );
  assert( pC->uc.pCursor!=0 );
  pCrsr = pC->uc.pCursor;
 
  /* The OP_RowData opcodes always follow OP_NotExists or
  ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions
  ** that might invalidate the cursor.
  ** If this where not the case, on of the following assert()s
  ** would fail.  Should this ever change (because of changes in the code
  ** generator) then the fix would be to insert a call to
  ** sqlite3VdbeCursorMoveto().
  */
  assert( pC->deferredMoveto==0 );
  assert( sqlite3BtreeCursorIsValid(pCrsr) );
 
  n = sqlite3BtreePayloadSize(pCrsr);
  if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
    goto too_big;
  }
  testcase( n==0 );
  rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
  if( rc ) goto abort_due_to_error;
  if( !pOp->p3 ) Deephemeralize(pOut);
  UPDATE_MAX_BLOBSIZE(pOut);
  REGISTER_TRACE(pOp->p2, pOut);
  break;
}
 
/* Opcode: Rowid P1 P2 * * *
** Synopsis: r[P2]=rowid
**
** Store in register P2 an integer which is the key of the table entry that
** P1 is currently point to.
**
** P1 can be either an ordinary table or a virtual table.  There used to
** be a separate OP_VRowid opcode for use with virtual tables, but this
** one opcode now works for both table types.
*/
case OP_Rowid: {                 /* out2 */
  VdbeCursor *pC;
  i64 v;
  sqlite3_vtab *pVtab;
  const sqlite3_module *pModule;
 
  pOut = out2Prerelease(p, pOp);
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
  if( pC->nullRow ){
    pOut->flags = MEM_Null;
    break;
  }else if( pC->deferredMoveto ){
    v = pC->movetoTarget;
#ifndef SQLITE_OMIT_VIRTUALTABLE
  }else if( pC->eCurType==CURTYPE_VTAB ){
    assert( pC->uc.pVCur!=0 );
    pVtab = pC->uc.pVCur->pVtab;
    pModule = pVtab->pModule;
    assert( pModule->xRowid );
    rc = pModule->xRowid(pC->uc.pVCur, &v);
    sqlite3VtabImportErrmsg(p, pVtab);
    if( rc ) goto abort_due_to_error;
#endif /* SQLITE_OMIT_VIRTUALTABLE */
  }else{
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0 );
    rc = sqlite3VdbeCursorRestore(pC);
    if( rc ) goto abort_due_to_error;
    if( pC->nullRow ){
      pOut->flags = MEM_Null;
      break;
    }
    v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
  }
  pOut->u.i = v;
  break;
}
 
/* Opcode: NullRow P1 * * * *
**
** Move the cursor P1 to a null row.  Any OP_Column operations
** that occur while the cursor is on the null row will always
** write a NULL.
*/
case OP_NullRow: {
  VdbeCursor *pC;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  pC->nullRow = 1;
  pC->cacheStatus = CACHE_STALE;
  if( pC->eCurType==CURTYPE_BTREE ){
    assert( pC->uc.pCursor!=0 );
    sqlite3BtreeClearCursor(pC->uc.pCursor);
  }
#ifdef SQLITE_DEBUG
  if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
#endif
  break;
}
 
/* Opcode: SeekEnd P1 * * * *
**
** Position cursor P1 at the end of the btree for the purpose of
** appending a new entry onto the btree.
**
** It is assumed that the cursor is used only for appending and so
** if the cursor is valid, then the cursor must already be pointing
** at the end of the btree and so no changes are made to
** the cursor.
*/
/* Opcode: Last P1 P2 * * *
**
** The next use of the Rowid or Column or Prev instruction for P1
** will refer to the last entry in the database table or index.
** If the table or index is empty and P2>0, then jump immediately to P2.
** If P2 is 0 or if the table or index is not empty, fall through
** to the following instruction.
**
** This opcode leaves the cursor configured to move in reverse order,
** from the end toward the beginning.  In other words, the cursor is
** configured to use Prev, not Next.
*/
case OP_SeekEnd:
case OP_Last: {        /* jump */
  VdbeCursor *pC;
  BtCursor *pCrsr;
  int res;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  pCrsr = pC->uc.pCursor;
  res = 0;
  assert( pCrsr!=0 );
#ifdef SQLITE_DEBUG
  pC->seekOp = pOp->opcode;
#endif
  if( pOp->opcode==OP_SeekEnd ){
    assert( pOp->p2==0 );
    pC->seekResult = -1;
    if( sqlite3BtreeCursorIsValidNN(pCrsr) ){
      break;
    }
  }
  rc = sqlite3BtreeLast(pCrsr, &res);
  pC->nullRow = (u8)res;
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;
  if( rc ) goto abort_due_to_error;
  if( pOp->p2>0 ){
    VdbeBranchTaken(res!=0,2);
    if( res ) goto jump_to_p2;
  }
  break;
}
 
/* Opcode: IfSmaller P1 P2 P3 * *
**
** Estimate the number of rows in the table P1.  Jump to P2 if that
** estimate is less than approximately 2**(0.1*P3).
*/
case OP_IfSmaller: {        /* jump */
  VdbeCursor *pC;
  BtCursor *pCrsr;
  int res;
  i64 sz;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  pCrsr = pC->uc.pCursor;
  assert( pCrsr );
  rc = sqlite3BtreeFirst(pCrsr, &res);
  if( rc ) goto abort_due_to_error;
  if( res==0 ){
    sz = sqlite3BtreeRowCountEst(pCrsr);
    if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
  }
  VdbeBranchTaken(res!=0,2);
  if( res ) goto jump_to_p2;
  break;
}
 
 
/* Opcode: SorterSort P1 P2 * * *
**
** After all records have been inserted into the Sorter object
** identified by P1, invoke this opcode to actually do the sorting.
** Jump to P2 if there are no records to be sorted.
**
** This opcode is an alias for OP_Sort and OP_Rewind that is used
** for Sorter objects.
*/
/* Opcode: Sort P1 P2 * * *
**
** This opcode does exactly the same thing as OP_Rewind except that
** it increments an undocumented global variable used for testing.
**
** Sorting is accomplished by writing records into a sorting index,
** then rewinding that index and playing it back from beginning to
** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
** rewinding so that the global variable will be incremented and
** regression tests can determine whether or not the optimizer is
** correctly optimizing out sorts.
*/
case OP_SorterSort:    /* jump */
case OP_Sort: {        /* jump */
#ifdef SQLITE_TEST
  sqlite3_sort_count++;
  sqlite3_search_count--;
#endif
  p->aCounter[SQLITE_STMTSTATUS_SORT]++;
  /* Fall through into OP_Rewind */
  /* no break */ deliberate_fall_through
}
/* Opcode: Rewind P1 P2 * * *
**
** The next use of the Rowid or Column or Next instruction for P1
** will refer to the first entry in the database table or index.
** If the table or index is empty, jump immediately to P2.
** If the table or index is not empty, fall through to the following
** instruction.
**
** This opcode leaves the cursor configured to move in forward order,
** from the beginning toward the end.  In other words, the cursor is
** configured to use Next, not Prev.
*/
case OP_Rewind: {        /* jump */
  VdbeCursor *pC;
  BtCursor *pCrsr;
  int res;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p5==0 );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
  res = 1;
#ifdef SQLITE_DEBUG
  pC->seekOp = OP_Rewind;
#endif
  if( isSorter(pC) ){
    rc = sqlite3VdbeSorterRewind(pC, &res);
  }else{
    assert( pC->eCurType==CURTYPE_BTREE );
    pCrsr = pC->uc.pCursor;
    assert( pCrsr );
    rc = sqlite3BtreeFirst(pCrsr, &res);
    pC->deferredMoveto = 0;
    pC->cacheStatus = CACHE_STALE;
  }
  if( rc ) goto abort_due_to_error;
  pC->nullRow = (u8)res;
  assert( pOp->p2>0 && pOp->p2<p->nOp );
  VdbeBranchTaken(res!=0,2);
  if( res ) goto jump_to_p2;
  break;
}
 
/* Opcode: Next P1 P2 P3 P4 P5
**
** Advance cursor P1 so that it points to the next key/data pair in its
** table or index.  If there are no more key/value pairs then fall through
** to the following instruction.  But if the cursor advance was successful,
** jump immediately to P2.
**
** The Next opcode is only valid following an SeekGT, SeekGE, or
** OP_Rewind opcode used to position the cursor.  Next is not allowed
** to follow SeekLT, SeekLE, or OP_Last.
**
** The P1 cursor must be for a real table, not a pseudo-table.  P1 must have
** been opened prior to this opcode or the program will segfault.
**
** The P3 value is a hint to the btree implementation. If P3==1, that
** means P1 is an SQL index and that this instruction could have been
** omitted if that index had been unique.  P3 is usually 0.  P3 is
** always either 0 or 1.
**
** P4 is always of type P4_ADVANCE. The function pointer points to
** sqlite3BtreeNext().
**
** If P5 is positive and the jump is taken, then event counter
** number P5-1 in the prepared statement is incremented.
**
** See also: Prev
*/
/* Opcode: Prev P1 P2 P3 P4 P5
**
** Back up cursor P1 so that it points to the previous key/data pair in its
** table or index.  If there is no previous key/value pairs then fall through
** to the following instruction.  But if the cursor backup was successful,
** jump immediately to P2.
**
**
** The Prev opcode is only valid following an SeekLT, SeekLE, or
** OP_Last opcode used to position the cursor.  Prev is not allowed
** to follow SeekGT, SeekGE, or OP_Rewind.
**
** The P1 cursor must be for a real table, not a pseudo-table.  If P1 is
** not open then the behavior is undefined.
**
** The P3 value is a hint to the btree implementation. If P3==1, that
** means P1 is an SQL index and that this instruction could have been
** omitted if that index had been unique.  P3 is usually 0.  P3 is
** always either 0 or 1.
**
** P4 is always of type P4_ADVANCE. The function pointer points to
** sqlite3BtreePrevious().
**
** If P5 is positive and the jump is taken, then event counter
** number P5-1 in the prepared statement is incremented.
*/
/* Opcode: SorterNext P1 P2 * * P5
**
** This opcode works just like OP_Next except that P1 must be a
** sorter object for which the OP_SorterSort opcode has been
** invoked.  This opcode advances the cursor to the next sorted
** record, or jumps to P2 if there are no more sorted records.
*/
case OP_SorterNext: {  /* jump */
  VdbeCursor *pC;
 
  pC = p->apCsr[pOp->p1];
  assert( isSorter(pC) );
  rc = sqlite3VdbeSorterNext(db, pC);
  goto next_tail;
case OP_Prev:          /* jump */
case OP_Next:          /* jump */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p5<ArraySize(p->aCounter) );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->deferredMoveto==0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
  assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
 
  /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found.
  ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
  assert( pOp->opcode!=OP_Next
       || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
       || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
       || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
       || pC->seekOp==OP_IfNoHope);
  assert( pOp->opcode!=OP_Prev
       || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
       || pC->seekOp==OP_Last   || pC->seekOp==OP_IfNoHope
       || pC->seekOp==OP_NullRow);
 
  rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
next_tail:
  pC->cacheStatus = CACHE_STALE;
  VdbeBranchTaken(rc==SQLITE_OK,2);
  if( rc==SQLITE_OK ){
    pC->nullRow = 0;
    p->aCounter[pOp->p5]++;
#ifdef SQLITE_TEST
    sqlite3_search_count++;
#endif
    goto jump_to_p2_and_check_for_interrupt;
  }
  if( rc!=SQLITE_DONE ) goto abort_due_to_error;
  rc = SQLITE_OK;
  pC->nullRow = 1;
  goto check_for_interrupt;
}
 
/* Opcode: IdxInsert P1 P2 P3 P4 P5
** Synopsis: key=r[P2]
**
** Register P2 holds an SQL index key made using the
** MakeRecord instructions.  This opcode writes that key
** into the index P1.  Data for the entry is nil.
**
** If P4 is not zero, then it is the number of values in the unpacked
** key of reg(P2).  In that case, P3 is the index of the first register
** for the unpacked key.  The availability of the unpacked key can sometimes
** be an optimization.
**
** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
** that this insert is likely to be an append.
**
** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
** incremented by this instruction.  If the OPFLAG_NCHANGE bit is clear,
** then the change counter is unchanged.
**
** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
** run faster by avoiding an unnecessary seek on cursor P1.  However,
** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
** seeks on the cursor or if the most recent seek used a key equivalent
** to P2.
**
** This instruction only works for indices.  The equivalent instruction
** for tables is OP_Insert.
*/
case OP_IdxInsert: {        /* in2 */
  VdbeCursor *pC;
  BtreePayload x;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  sqlite3VdbeIncrWriteCounter(p, pC);
  assert( pC!=0 );
  assert( !isSorter(pC) );
  pIn2 = &aMem[pOp->p2];
  assert( pIn2->flags & MEM_Blob );
  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->isTable==0 );
  rc = ExpandBlob(pIn2);
  if( rc ) goto abort_due_to_error;
  x.nKey = pIn2->n;
  x.pKey = pIn2->z;
  x.aMem = aMem + pOp->p3;
  x.nMem = (u16)pOp->p4.i;
  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
       (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)),
      ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
      );
  assert( pC->deferredMoveto==0 );
  pC->cacheStatus = CACHE_STALE;
  if( rc) goto abort_due_to_error;
  break;
}
 
/* Opcode: SorterInsert P1 P2 * * *
** Synopsis: key=r[P2]
**
** Register P2 holds an SQL index key made using the
** MakeRecord instructions.  This opcode writes that key
** into the sorter P1.  Data for the entry is nil.
*/
case OP_SorterInsert: {     /* in2 */
  VdbeCursor *pC;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  sqlite3VdbeIncrWriteCounter(p, pC);
  assert( pC!=0 );
  assert( isSorter(pC) );
  pIn2 = &aMem[pOp->p2];
  assert( pIn2->flags & MEM_Blob );
  assert( pC->isTable==0 );
  rc = ExpandBlob(pIn2);
  if( rc ) goto abort_due_to_error;
  rc = sqlite3VdbeSorterWrite(pC, pIn2);
  if( rc) goto abort_due_to_error;
  break;
}
 
/* Opcode: IdxDelete P1 P2 P3 * P5
** Synopsis: key=r[P2@P3]
**
** The content of P3 registers starting at register P2 form
** an unpacked index key. This opcode removes that entry from the
** index opened by cursor P1.
**
** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error
** if no matching index entry is found.  This happens when running
** an UPDATE or DELETE statement and the index entry to be updated
** or deleted is not found.  For some uses of IdxDelete
** (example:  the EXCEPT operator) it does not matter that no matching
** entry is found.  For those cases, P5 is zero.
*/
case OP_IdxDelete: {
  VdbeCursor *pC;
  BtCursor *pCrsr;
  int res;
  UnpackedRecord r;
 
  assert( pOp->p3>0 );
  assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  sqlite3VdbeIncrWriteCounter(p, pC);
  pCrsr = pC->uc.pCursor;
  assert( pCrsr!=0 );
  r.pKeyInfo = pC->pKeyInfo;
  r.nField = (u16)pOp->p3;
  r.default_rc = 0;
  r.aMem = &aMem[pOp->p2];
  rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
  if( rc ) goto abort_due_to_error;
  if( res==0 ){
    rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
    if( rc ) goto abort_due_to_error;
  }else if( pOp->p5 ){
    rc = SQLITE_CORRUPT_INDEX;
    goto abort_due_to_error;
  }
  assert( pC->deferredMoveto==0 );
  pC->cacheStatus = CACHE_STALE;
  pC->seekResult = 0;
  break;
}
 
/* Opcode: DeferredSeek P1 * P3 P4 *
** Synopsis: Move P3 to P1.rowid if needed
**
** P1 is an open index cursor and P3 is a cursor on the corresponding
** table.  This opcode does a deferred seek of the P3 table cursor
** to the row that corresponds to the current row of P1.
**
** This is a deferred seek.  Nothing actually happens until
** the cursor is used to read a record.  That way, if no reads
** occur, no unnecessary I/O happens.
**
** P4 may be an array of integers (type P4_INTARRAY) containing
** one entry for each column in the P3 table.  If array entry a(i)
** is non-zero, then reading column a(i)-1 from cursor P3 is
** equivalent to performing the deferred seek and then reading column i
** from P1.  This information is stored in P3 and used to redirect
** reads against P3 over to P1, thus possibly avoiding the need to
** seek and read cursor P3.
*/
/* Opcode: IdxRowid P1 P2 * * *
** Synopsis: r[P2]=rowid
**
** Write into register P2 an integer which is the last entry in the record at
** the end of the index key pointed to by cursor P1.  This integer should be
** the rowid of the table entry to which this index entry points.
**
** See also: Rowid, MakeRecord.
*/
case OP_DeferredSeek:
case OP_IdxRowid: {           /* out2 */
  VdbeCursor *pC;             /* The P1 index cursor */
  VdbeCursor *pTabCur;        /* The P2 table cursor (OP_DeferredSeek only) */
  i64 rowid;                  /* Rowid that P1 current points to */
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0 );
  assert( pC->isTable==0 );
  assert( pC->deferredMoveto==0 );
  assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
 
  /* The IdxRowid and Seek opcodes are combined because of the commonality
  ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */
  rc = sqlite3VdbeCursorRestore(pC);
 
  /* sqlite3VbeCursorRestore() can only fail if the record has been deleted
  ** out from under the cursor.  That will never happens for an IdxRowid
  ** or Seek opcode */
  if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
 
  if( !pC->nullRow ){
    rowid = 0;  /* Not needed.  Only used to silence a warning. */
    rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
    if( pOp->opcode==OP_DeferredSeek ){
      assert( pOp->p3>=0 && pOp->p3<p->nCursor );
      pTabCur = p->apCsr[pOp->p3];
      assert( pTabCur!=0 );
      assert( pTabCur->eCurType==CURTYPE_BTREE );
      assert( pTabCur->uc.pCursor!=0 );
      assert( pTabCur->isTable );
      pTabCur->nullRow = 0;
      pTabCur->movetoTarget = rowid;
      pTabCur->deferredMoveto = 1;
      assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
      pTabCur->aAltMap = pOp->p4.ai;
      pTabCur->pAltCursor = pC;
    }else{
      pOut = out2Prerelease(p, pOp);
      pOut->u.i = rowid;
    }
  }else{
    assert( pOp->opcode==OP_IdxRowid );
    sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
  }
  break;
}
 
/* Opcode: FinishSeek P1 * * * *
**
** If cursor P1 was previously moved via OP_DeferredSeek, complete that
** seek operation now, without further delay.  If the cursor seek has
** already occurred, this instruction is a no-op.
*/
case OP_FinishSeek: {
  VdbeCursor *pC;             /* The P1 index cursor */
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  if( pC->deferredMoveto ){
    rc = sqlite3VdbeFinishMoveto(pC);
    if( rc ) goto abort_due_to_error;
  }
  break;
}
 
/* Opcode: IdxGE P1 P2 P3 P4 P5
** Synopsis: key=r[P3@P4]
**
** The P4 register values beginning with P3 form an unpacked index
** key that omits the PRIMARY KEY.  Compare this key value against the index
** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
** fields at the end.
**
** If the P1 index entry is greater than or equal to the key value
** then jump to P2.  Otherwise fall through to the next instruction.
*/
/* Opcode: IdxGT P1 P2 P3 P4 P5
** Synopsis: key=r[P3@P4]
**
** The P4 register values beginning with P3 form an unpacked index
** key that omits the PRIMARY KEY.  Compare this key value against the index
** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
** fields at the end.
**
** If the P1 index entry is greater than the key value
** then jump to P2.  Otherwise fall through to the next instruction.
*/
/* Opcode: IdxLT P1 P2 P3 P4 P5
** Synopsis: key=r[P3@P4]
**
** The P4 register values beginning with P3 form an unpacked index
** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
** ROWID on the P1 index.
**
** If the P1 index entry is less than the key value then jump to P2.
** Otherwise fall through to the next instruction.
*/
/* Opcode: IdxLE P1 P2 P3 P4 P5
** Synopsis: key=r[P3@P4]
**
** The P4 register values beginning with P3 form an unpacked index
** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
** ROWID on the P1 index.
**
** If the P1 index entry is less than or equal to the key value then jump
** to P2. Otherwise fall through to the next instruction.
*/
case OP_IdxLE:          /* jump */
case OP_IdxGT:          /* jump */
case OP_IdxLT:          /* jump */
case OP_IdxGE:  {       /* jump */
  VdbeCursor *pC;
  int res;
  UnpackedRecord r;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->isOrdered );
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0);
  assert( pC->deferredMoveto==0 );
  assert( pOp->p5==0 || pOp->p5==1 );
  assert( pOp->p4type==P4_INT32 );
  r.pKeyInfo = pC->pKeyInfo;
  r.nField = (u16)pOp->p4.i;
  if( pOp->opcode<OP_IdxLT ){
    assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
    r.default_rc = -1;
  }else{
    assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
    r.default_rc = 0;
  }
  r.aMem = &aMem[pOp->p3];
#ifdef SQLITE_DEBUG
  {
    int i;
    for(i=0; i<r.nField; i++){
      assert( memIsValid(&r.aMem[i]) );
      REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
    }
  }
#endif
  res = 0;  /* Not needed.  Only used to silence a warning. */
  rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
  assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
  if( (pOp->opcode&1)==(OP_IdxLT&1) ){
    assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
    res = -res;
  }else{
    assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
    res++;
  }
  VdbeBranchTaken(res>0,2);
  if( rc ) goto abort_due_to_error;
  if( res>0 ) goto jump_to_p2;
  break;
}
 
/* Opcode: Destroy P1 P2 P3 * *
**
** Delete an entire database table or index whose root page in the database
** file is given by P1.
**
** The table being destroyed is in the main database file if P3==0.  If
** P3==1 then the table to be clear is in the auxiliary database file
** that is used to store tables create using CREATE TEMPORARY TABLE.
**
** If AUTOVACUUM is enabled then it is possible that another root page
** might be moved into the newly deleted root page in order to keep all
** root pages contiguous at the beginning of the database.  The former
** value of the root page that moved - its value before the move occurred -
** is stored in register P2. If no page movement was required (because the
** table being dropped was already the last one in the database) then a
** zero is stored in register P2.  If AUTOVACUUM is disabled then a zero
** is stored in register P2.
**
** This opcode throws an error if there are any active reader VMs when
** it is invoked. This is done to avoid the difficulty associated with
** updating existing cursors when a root page is moved in an AUTOVACUUM
** database. This error is thrown even if the database is not an AUTOVACUUM
** db in order to avoid introducing an incompatibility between autovacuum
** and non-autovacuum modes.
**
** See also: Clear
*/
case OP_Destroy: {     /* out2 */
  int iMoved;
  int iDb;
 
  sqlite3VdbeIncrWriteCounter(p, 0);
  assert( p->readOnly==0 );
  assert( pOp->p1>1 );
  pOut = out2Prerelease(p, pOp);
  pOut->flags = MEM_Null;
  if( db->nVdbeRead > db->nVDestroy+1 ){
    rc = SQLITE_LOCKED;
    p->errorAction = OE_Abort;
    goto abort_due_to_error;
  }else{
    iDb = pOp->p3;
    assert( DbMaskTest(p->btreeMask, iDb) );
    iMoved = 0;  /* Not needed.  Only to silence a warning. */
    rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
    pOut->flags = MEM_Int;
    pOut->u.i = iMoved;
    if( rc ) goto abort_due_to_error;
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( iMoved!=0 ){
      sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
      /* All OP_Destroy operations occur on the same btree */
      assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
      resetSchemaOnFault = iDb+1;
    }
#endif
  }
  break;
}
 
/* Opcode: Clear P1 P2 P3
**
** Delete all contents of the database table or index whose root page
** in the database file is given by P1.  But, unlike Destroy, do not
** remove the table or index from the database file.
**
** The table being clear is in the main database file if P2==0.  If
** P2==1 then the table to be clear is in the auxiliary database file
** that is used to store tables create using CREATE TEMPORARY TABLE.
**
** If the P3 value is non-zero, then the table referred to must be an
** intkey table (an SQL table, not an index). In this case the row change
** count is incremented by the number of rows in the table being cleared.
** If P3 is greater than zero, then the value stored in register P3 is
** also incremented by the number of rows in the table being cleared.
**
** See also: Destroy
*/
case OP_Clear: {
  int nChange;
 
  sqlite3VdbeIncrWriteCounter(p, 0);
  nChange = 0;
  assert( p->readOnly==0 );
  assert( DbMaskTest(p->btreeMask, pOp->p2) );
  rc = sqlite3BtreeClearTable(
      db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0)
  );
  if( pOp->p3 ){
    p->nChange += nChange;
    if( pOp->p3>0 ){
      assert( memIsValid(&aMem[pOp->p3]) );
      memAboutToChange(p, &aMem[pOp->p3]);
      aMem[pOp->p3].u.i += nChange;
    }
  }
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: ResetSorter P1 * * * *
**
** Delete all contents from the ephemeral table or sorter
** that is open on cursor P1.
**
** This opcode only works for cursors used for sorting and
** opened with OP_OpenEphemeral or OP_SorterOpen.
*/
case OP_ResetSorter: {
  VdbeCursor *pC;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  if( isSorter(pC) ){
    sqlite3VdbeSorterReset(db, pC->uc.pSorter);
  }else{
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->isEphemeral );
    rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
    if( rc ) goto abort_due_to_error;
  }
  break;
}
 
/* Opcode: CreateBtree P1 P2 P3 * *
** Synopsis: r[P2]=root iDb=P1 flags=P3
**
** Allocate a new b-tree in the main database file if P1==0 or in the
** TEMP database file if P1==1 or in an attached database if
** P1>1.  The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
** The root page number of the new b-tree is stored in register P2.
*/
case OP_CreateBtree: {          /* out2 */
  Pgno pgno;
  Db *pDb;
 
  sqlite3VdbeIncrWriteCounter(p, 0);
  pOut = out2Prerelease(p, pOp);
  pgno = 0;
  assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
  assert( p->readOnly==0 );
  pDb = &db->aDb[pOp->p1];
  assert( pDb->pBt!=0 );
  rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
  if( rc ) goto abort_due_to_error;
  pOut->u.i = pgno;
  break;
}
 
/* Opcode: SqlExec * * * P4 *
**
** Run the SQL statement or statements specified in the P4 string.
*/
case OP_SqlExec: {
  sqlite3VdbeIncrWriteCounter(p, 0);
  db->nSqlExec++;
  rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
  db->nSqlExec--;
  if( rc ) goto abort_due_to_error;
  break;
}
 
/* Opcode: ParseSchema P1 * * P4 *
**
** Read and parse all entries from the schema table of database P1
** that match the WHERE clause P4.  If P4 is a NULL pointer, then the
** entire schema for P1 is reparsed.
**
** This opcode invokes the parser to create a new virtual machine,
** then runs the new virtual machine.  It is thus a re-entrant opcode.
*/
case OP_ParseSchema: {
  int iDb;
  const char *zSchema;
  char *zSql;
  InitData initData;
 
  /* Any prepared statement that invokes this opcode will hold mutexes
  ** on every btree.  This is a prerequisite for invoking
  ** sqlite3InitCallback().
  */
#ifdef SQLITE_DEBUG
  for(iDb=0; iDb<db->nDb; iDb++){
    assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
  }
#endif
 
  iDb = pOp->p1;
  assert( iDb>=0 && iDb<db->nDb );
  assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
 
#ifndef SQLITE_OMIT_ALTERTABLE
  if( pOp->p4.z==0 ){
    sqlite3SchemaClear(db->aDb[iDb].pSchema);
    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
    rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable);
    db->mDbFlags |= DBFLAG_SchemaChange;
    p->expired = 0;
  }else
#endif
  {
    zSchema = DFLT_SCHEMA_TABLE;
    initData.db = db;
    initData.iDb = iDb;
    initData.pzErrMsg = &p->zErrMsg;
    initData.mInitFlags = 0;
    initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
    zSql = sqlite3MPrintf(db,
       "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid",
       db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
    if( zSql==0 ){
      rc = SQLITE_NOMEM_BKPT;
    }else{
      assert( db->init.busy==0 );
      db->init.busy = 1;
      initData.rc = SQLITE_OK;
      initData.nInitRow = 0;
      assert( !db->mallocFailed );
      rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
      if( rc==SQLITE_OK ) rc = initData.rc;
      if( rc==SQLITE_OK && initData.nInitRow==0 ){
        /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse
        ** at least one SQL statement. Any less than that indicates that
        ** the sqlite_schema table is corrupt. */
        rc = SQLITE_CORRUPT_BKPT;
      }
      sqlite3DbFreeNN(db, zSql);
      db->init.busy = 0;
    }
  }
  if( rc ){
    sqlite3ResetAllSchemasOfConnection(db);
    if( rc==SQLITE_NOMEM ){
      goto no_mem;
    }
    goto abort_due_to_error;
  }
  break;
}
 
#if !defined(SQLITE_OMIT_ANALYZE)
/* Opcode: LoadAnalysis P1 * * * *
**
** Read the sqlite_stat1 table for database P1 and load the content
** of that table into the internal index hash table.  This will cause
** the analysis to be used when preparing all subsequent queries.
*/
case OP_LoadAnalysis: {
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  rc = sqlite3AnalysisLoad(db, pOp->p1);
  if( rc ) goto abort_due_to_error;
  break;
}
#endif /* !defined(SQLITE_OMIT_ANALYZE) */
 
/* Opcode: DropTable P1 * * P4 *
**
** Remove the internal (in-memory) data structures that describe
** the table named P4 in database P1.  This is called after a table
** is dropped from disk (using the Destroy opcode) in order to keep
** the internal representation of the
** schema consistent with what is on disk.
*/
case OP_DropTable: {
  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
  break;
}
 
/* Opcode: DropIndex P1 * * P4 *
**
** Remove the internal (in-memory) data structures that describe
** the index named P4 in database P1.  This is called after an index
** is dropped from disk (using the Destroy opcode)
** in order to keep the internal representation of the
** schema consistent with what is on disk.
*/
case OP_DropIndex: {
  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
  break;
}
 
/* Opcode: DropTrigger P1 * * P4 *
**
** Remove the internal (in-memory) data structures that describe
** the trigger named P4 in database P1.  This is called after a trigger
** is dropped from disk (using the Destroy opcode) in order to keep
** the internal representation of the
** schema consistent with what is on disk.
*/
case OP_DropTrigger: {
  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
  break;
}
 
 
#ifndef SQLITE_OMIT_INTEGRITY_CHECK
/* Opcode: IntegrityCk P1 P2 P3 P4 P5
**
** Do an analysis of the currently open database.  Store in
** register P1 the text of an error message describing any problems.
** If no problems are found, store a NULL in register P1.
**
** The register P3 contains one less than the maximum number of allowed errors.
** At most reg(P3) errors will be reported.
** In other words, the analysis stops as soon as reg(P1) errors are
** seen.  Reg(P1) is updated with the number of errors remaining.
**
** The root page numbers of all tables in the database are integers
** stored in P4_INTARRAY argument.
**
** If P5 is not zero, the check is done on the auxiliary database
** file, not the main database file.
**
** This opcode is used to implement the integrity_check pragma.
*/
case OP_IntegrityCk: {
  int nRoot;      /* Number of tables to check.  (Number of root pages.) */
  Pgno *aRoot;    /* Array of rootpage numbers for tables to be checked */
  int nErr;       /* Number of errors reported */
  char *z;        /* Text of the error report */
  Mem *pnErr;     /* Register keeping track of errors remaining */
 
  assert( p->bIsReader );
  nRoot = pOp->p2;
  aRoot = pOp->p4.ai;
  assert( nRoot>0 );
  assert( aRoot[0]==(Pgno)nRoot );
  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  pnErr = &aMem[pOp->p3];
  assert( (pnErr->flags & MEM_Int)!=0 );
  assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
  pIn1 = &aMem[pOp->p1];
  assert( pOp->p5<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p5) );
  z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
                                 (int)pnErr->u.i+1, &nErr);
  sqlite3VdbeMemSetNull(pIn1);
  if( nErr==0 ){
    assert( z==0 );
  }else if( z==0 ){
    goto no_mem;
  }else{
    pnErr->u.i -= nErr-1;
    sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
  }
  UPDATE_MAX_BLOBSIZE(pIn1);
  sqlite3VdbeChangeEncoding(pIn1, encoding);
  goto check_for_interrupt;
}
#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
 
/* Opcode: RowSetAdd P1 P2 * * *
** Synopsis: rowset(P1)=r[P2]
**
** Insert the integer value held by register P2 into a RowSet object
** held in register P1.
**
** An assertion fails if P2 is not an integer.
*/
case OP_RowSetAdd: {       /* in1, in2 */
  pIn1 = &aMem[pOp->p1];
  pIn2 = &aMem[pOp->p2];
  assert( (pIn2->flags & MEM_Int)!=0 );
  if( (pIn1->flags & MEM_Blob)==0 ){
    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
  }
  assert( sqlite3VdbeMemIsRowSet(pIn1) );
  sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
  break;
}
 
/* Opcode: RowSetRead P1 P2 P3 * *
** Synopsis: r[P3]=rowset(P1)
**
** Extract the smallest value from the RowSet object in P1
** and put that value into register P3.
** Or, if RowSet object P1 is initially empty, leave P3
** unchanged and jump to instruction P2.
*/
case OP_RowSetRead: {       /* jump, in1, out3 */
  i64 val;
 
  pIn1 = &aMem[pOp->p1];
  assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
  if( (pIn1->flags & MEM_Blob)==0
   || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
  ){
    /* The boolean index is empty */
    sqlite3VdbeMemSetNull(pIn1);
    VdbeBranchTaken(1,2);
    goto jump_to_p2_and_check_for_interrupt;
  }else{
    /* A value was pulled from the index */
    VdbeBranchTaken(0,2);
    sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
  }
  goto check_for_interrupt;
}
 
/* Opcode: RowSetTest P1 P2 P3 P4
** Synopsis: if r[P3] in rowset(P1) goto P2
**
** Register P3 is assumed to hold a 64-bit integer value. If register P1
** contains a RowSet object and that RowSet object contains
** the value held in P3, jump to register P2. Otherwise, insert the
** integer in P3 into the RowSet and continue on to the
** next opcode.
**
** The RowSet object is optimized for the case where sets of integers
** are inserted in distinct phases, which each set contains no duplicates.
** Each set is identified by a unique P4 value. The first set
** must have P4==0, the final set must have P4==-1, and for all other sets
** must have P4>0.
**
** This allows optimizations: (a) when P4==0 there is no need to test
** the RowSet object for P3, as it is guaranteed not to contain it,
** (b) when P4==-1 there is no need to insert the value, as it will
** never be tested for, and (c) when a value that is part of set X is
** inserted, there is no need to search to see if the same value was
** previously inserted as part of set X (only if it was previously
** inserted as part of some other set).
*/
case OP_RowSetTest: {                     /* jump, in1, in3 */
  int iSet;
  int exists;
 
  pIn1 = &aMem[pOp->p1];
  pIn3 = &aMem[pOp->p3];
  iSet = pOp->p4.i;
  assert( pIn3->flags&MEM_Int );
 
  /* If there is anything other than a rowset object in memory cell P1,
  ** delete it now and initialize P1 with an empty rowset
  */
  if( (pIn1->flags & MEM_Blob)==0 ){
    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
  }
  assert( sqlite3VdbeMemIsRowSet(pIn1) );
  assert( pOp->p4type==P4_INT32 );
  assert( iSet==-1 || iSet>=0 );
  if( iSet ){
    exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
    VdbeBranchTaken(exists!=0,2);
    if( exists ) goto jump_to_p2;
  }
  if( iSet>=0 ){
    sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
  }
  break;
}
 
 
#ifndef SQLITE_OMIT_TRIGGER
 
/* Opcode: Program P1 P2 P3 P4 P5
**
** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
**
** P1 contains the address of the memory cell that contains the first memory
** cell in an array of values used as arguments to the sub-program. P2
** contains the address to jump to if the sub-program throws an IGNORE
** exception using the RAISE() function. Register P3 contains the address
** of a memory cell in this (the parent) VM that is used to allocate the
** memory required by the sub-vdbe at runtime.
**
** P4 is a pointer to the VM containing the trigger program.
**
** If P5 is non-zero, then recursive program invocation is enabled.
*/
case OP_Program: {        /* jump */
  int nMem;               /* Number of memory registers for sub-program */
  int nByte;              /* Bytes of runtime space required for sub-program */
  Mem *pRt;               /* Register to allocate runtime space */
  Mem *pMem;              /* Used to iterate through memory cells */
  Mem *pEnd;              /* Last memory cell in new array */
  VdbeFrame *pFrame;      /* New vdbe frame to execute in */
  SubProgram *pProgram;   /* Sub-program to execute */
  void *t;                /* Token identifying trigger */
 
  pProgram = pOp->p4.pProgram;
  pRt = &aMem[pOp->p3];
  assert( pProgram->nOp>0 );
 
  /* If the p5 flag is clear, then recursive invocation of triggers is
  ** disabled for backwards compatibility (p5 is set if this sub-program
  ** is really a trigger, not a foreign key action, and the flag set
  ** and cleared by the "PRAGMA recursive_triggers" command is clear).
  **
  ** It is recursive invocation of triggers, at the SQL level, that is
  ** disabled. In some cases a single trigger may generate more than one
  ** SubProgram (if the trigger may be executed with more than one different
  ** ON CONFLICT algorithm). SubProgram structures associated with a
  ** single trigger all have the same value for the SubProgram.token
  ** variable.  */
  if( pOp->p5 ){
    t = pProgram->token;
    for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
    if( pFrame ) break;
  }
 
  if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
    rc = SQLITE_ERROR;
    sqlite3VdbeError(p, "too many levels of trigger recursion");
    goto abort_due_to_error;
  }
 
  /* Register pRt is used to store the memory required to save the state
  ** of the current program, and the memory required at runtime to execute
  ** the trigger program. If this trigger has been fired before, then pRt
  ** is already allocated. Otherwise, it must be initialized.  */
  if( (pRt->flags&MEM_Blob)==0 ){
    /* SubProgram.nMem is set to the number of memory cells used by the
    ** program stored in SubProgram.aOp. As well as these, one memory
    ** cell is required for each cursor used by the program. Set local
    ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
    */
    nMem = pProgram->nMem + pProgram->nCsr;
    assert( nMem>0 );
    if( pProgram->nCsr==0 ) nMem++;
    nByte = ROUND8(sizeof(VdbeFrame))
              + nMem * sizeof(Mem)
              + pProgram->nCsr * sizeof(VdbeCursor*)
              + (pProgram->nOp + 7)/8;
    pFrame = sqlite3DbMallocZero(db, nByte);
    if( !pFrame ){
      goto no_mem;
    }
    sqlite3VdbeMemRelease(pRt);
    pRt->flags = MEM_Blob|MEM_Dyn;
    pRt->z = (char*)pFrame;
    pRt->n = nByte;
    pRt->xDel = sqlite3VdbeFrameMemDel;
 
    pFrame->v = p;
    pFrame->nChildMem = nMem;
    pFrame->nChildCsr = pProgram->nCsr;
    pFrame->pc = (int)(pOp - aOp);
    pFrame->aMem = p->aMem;
    pFrame->nMem = p->nMem;
    pFrame->apCsr = p->apCsr;
    pFrame->nCursor = p->nCursor;
    pFrame->aOp = p->aOp;
    pFrame->nOp = p->nOp;
    pFrame->token = pProgram->token;
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
    pFrame->anExec = p->anExec;
#endif
#ifdef SQLITE_DEBUG
    pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
#endif
 
    pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
    for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
      pMem->flags = MEM_Undefined;
      pMem->db = db;
    }
  }else{
    pFrame = (VdbeFrame*)pRt->z;
    assert( pRt->xDel==sqlite3VdbeFrameMemDel );
    assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
        || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
    assert( pProgram->nCsr==pFrame->nChildCsr );
    assert( (int)(pOp - aOp)==pFrame->pc );
  }
 
  p->nFrame++;
  pFrame->pParent = p->pFrame;
  pFrame->lastRowid = db->lastRowid;
  pFrame->nChange = p->nChange;
  pFrame->nDbChange = p->db->nChange;
  assert( pFrame->pAuxData==0 );
  pFrame->pAuxData = p->pAuxData;
  p->pAuxData = 0;
  p->nChange = 0;
  p->pFrame = pFrame;
  p->aMem = aMem = VdbeFrameMem(pFrame);
  p->nMem = pFrame->nChildMem;
  p->nCursor = (u16)pFrame->nChildCsr;
  p->apCsr = (VdbeCursor **)&aMem[p->nMem];
  pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
  memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
  p->aOp = aOp = pProgram->aOp;
  p->nOp = pProgram->nOp;
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  p->anExec = 0;
#endif
#ifdef SQLITE_DEBUG
  /* Verify that second and subsequent executions of the same trigger do not
  ** try to reuse register values from the first use. */
  {
    int i;
    for(i=0; i<p->nMem; i++){
      aMem[i].pScopyFrom = 0;  /* Prevent false-positive AboutToChange() errs */
      MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */
    }
  }
#endif
  pOp = &aOp[-1];
  goto check_for_interrupt;
}
 
/* Opcode: Param P1 P2 * * *
**
** This opcode is only ever present in sub-programs called via the
** OP_Program instruction. Copy a value currently stored in a memory
** cell of the calling (parent) frame to cell P2 in the current frames
** address space. This is used by trigger programs to access the new.*
** and old.* values.
**
** The address of the cell in the parent frame is determined by adding
** the value of the P1 argument to the value of the P1 argument to the
** calling OP_Program instruction.
*/
case OP_Param: {           /* out2 */
  VdbeFrame *pFrame;
  Mem *pIn;
  pOut = out2Prerelease(p, pOp);
  pFrame = p->pFrame;
  pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
  sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
  break;
}
 
#endif /* #ifndef SQLITE_OMIT_TRIGGER */
 
#ifndef SQLITE_OMIT_FOREIGN_KEY
/* Opcode: FkCounter P1 P2 * * *
** Synopsis: fkctr[P1]+=P2
**
** Increment a "constraint counter" by P2 (P2 may be negative or positive).
** If P1 is non-zero, the database constraint counter is incremented
** (deferred foreign key constraints). Otherwise, if P1 is zero, the
** statement counter is incremented (immediate foreign key constraints).
*/
case OP_FkCounter: {
  if( db->flags & SQLITE_DeferFKs ){
    db->nDeferredImmCons += pOp->p2;
  }else if( pOp->p1 ){
    db->nDeferredCons += pOp->p2;
  }else{
    p->nFkConstraint += pOp->p2;
  }
  break;
}
 
/* Opcode: FkIfZero P1 P2 * * *
** Synopsis: if fkctr[P1]==0 goto P2
**
** This opcode tests if a foreign key constraint-counter is currently zero.
** If so, jump to instruction P2. Otherwise, fall through to the next
** instruction.
**
** If P1 is non-zero, then the jump is taken if the database constraint-counter
** is zero (the one that counts deferred constraint violations). If P1 is
** zero, the jump is taken if the statement constraint-counter is zero
** (immediate foreign key constraint violations).
*/
case OP_FkIfZero: {         /* jump */
  if( pOp->p1 ){
    VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
    if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
  }else{
    VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
    if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
  }
  break;
}
#endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
 
#ifndef SQLITE_OMIT_AUTOINCREMENT
/* Opcode: MemMax P1 P2 * * *
** Synopsis: r[P1]=max(r[P1],r[P2])
**
** P1 is a register in the root frame of this VM (the root frame is
** different from the current frame if this instruction is being executed
** within a sub-program). Set the value of register P1 to the maximum of
** its current value and the value in register P2.
**
** This instruction throws an error if the memory cell is not initially
** an integer.
*/
case OP_MemMax: {        /* in2 */
  VdbeFrame *pFrame;
  if( p->pFrame ){
    for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
    pIn1 = &pFrame->aMem[pOp->p1];
  }else{
    pIn1 = &aMem[pOp->p1];
  }
  assert( memIsValid(pIn1) );
  sqlite3VdbeMemIntegerify(pIn1);
  pIn2 = &aMem[pOp->p2];
  sqlite3VdbeMemIntegerify(pIn2);
  if( pIn1->u.i<pIn2->u.i){
    pIn1->u.i = pIn2->u.i;
  }
  break;
}
#endif /* SQLITE_OMIT_AUTOINCREMENT */
 
/* Opcode: IfPos P1 P2 P3 * *
** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
**
** Register P1 must contain an integer.
** If the value of register P1 is 1 or greater, subtract P3 from the
** value in P1 and jump to P2.
**
** If the initial value of register P1 is less than 1, then the
** value is unchanged and control passes through to the next instruction.
*/
case OP_IfPos: {        /* jump, in1 */
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  VdbeBranchTaken( pIn1->u.i>0, 2);
  if( pIn1->u.i>0 ){
    pIn1->u.i -= pOp->p3;
    goto jump_to_p2;
  }
  break;
}
 
/* Opcode: OffsetLimit P1 P2 P3 * *
** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
**
** This opcode performs a commonly used computation associated with
** LIMIT and OFFSET process.  r[P1] holds the limit counter.  r[P3]
** holds the offset counter.  The opcode computes the combined value
** of the LIMIT and OFFSET and stores that value in r[P2].  The r[P2]
** value computed is the total number of rows that will need to be
** visited in order to complete the query.
**
** If r[P3] is zero or negative, that means there is no OFFSET
** and r[P2] is set to be the value of the LIMIT, r[P1].
**
** if r[P1] is zero or negative, that means there is no LIMIT
** and r[P2] is set to -1.
**
** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
*/
case OP_OffsetLimit: {    /* in1, out2, in3 */
  i64 x;
  pIn1 = &aMem[pOp->p1];
  pIn3 = &aMem[pOp->p3];
  pOut = out2Prerelease(p, pOp);
  assert( pIn1->flags & MEM_Int );
  assert( pIn3->flags & MEM_Int );
  x = pIn1->u.i;
  if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){
    /* If the LIMIT is less than or equal to zero, loop forever.  This
    ** is documented.  But also, if the LIMIT+OFFSET exceeds 2^63 then
    ** also loop forever.  This is undocumented.  In fact, one could argue
    ** that the loop should terminate.  But assuming 1 billion iterations
    ** per second (far exceeding the capabilities of any current hardware)
    ** it would take nearly 300 years to actually reach the limit.  So
    ** looping forever is a reasonable approximation. */
    pOut->u.i = -1;
  }else{
    pOut->u.i = x;
  }
  break;
}
 
/* Opcode: IfNotZero P1 P2 * * *
** Synopsis: if r[P1]!=0 then r[P1]--, goto P2
**
** Register P1 must contain an integer.  If the content of register P1 is
** initially greater than zero, then decrement the value in register P1.
** If it is non-zero (negative or positive) and then also jump to P2.
** If register P1 is initially zero, leave it unchanged and fall through.
*/
case OP_IfNotZero: {        /* jump, in1 */
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  VdbeBranchTaken(pIn1->u.i<0, 2);
  if( pIn1->u.i ){
     if( pIn1->u.i>0 ) pIn1->u.i--;
     goto jump_to_p2;
  }
  break;
}
 
/* Opcode: DecrJumpZero P1 P2 * * *
** Synopsis: if (--r[P1])==0 goto P2
**
** Register P1 must hold an integer.  Decrement the value in P1
** and jump to P2 if the new value is exactly zero.
*/
case OP_DecrJumpZero: {      /* jump, in1 */
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--;
  VdbeBranchTaken(pIn1->u.i==0, 2);
  if( pIn1->u.i==0 ) goto jump_to_p2;
  break;
}
 
 
/* Opcode: AggStep * P2 P3 P4 P5
** Synopsis: accum=r[P3] step(r[P2@P5])
**
** Execute the xStep function for an aggregate.
** The function has P5 arguments.  P4 is a pointer to the
** FuncDef structure that specifies the function.  Register P3 is the
** accumulator.
**
** The P5 arguments are taken from register P2 and its
** successors.
*/
/* Opcode: AggInverse * P2 P3 P4 P5
** Synopsis: accum=r[P3] inverse(r[P2@P5])
**
** Execute the xInverse function for an aggregate.
** The function has P5 arguments.  P4 is a pointer to the
** FuncDef structure that specifies the function.  Register P3 is the
** accumulator.
**
** The P5 arguments are taken from register P2 and its
** successors.
*/
/* Opcode: AggStep1 P1 P2 P3 P4 P5
** Synopsis: accum=r[P3] step(r[P2@P5])
**
** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an
** aggregate.  The function has P5 arguments.  P4 is a pointer to the
** FuncDef structure that specifies the function.  Register P3 is the
** accumulator.
**
** The P5 arguments are taken from register P2 and its
** successors.
**
** This opcode is initially coded as OP_AggStep0.  On first evaluation,
** the FuncDef stored in P4 is converted into an sqlite3_context and
** the opcode is changed.  In this way, the initialization of the
** sqlite3_context only happens once, instead of on each call to the
** step function.
*/
case OP_AggInverse:
case OP_AggStep: {
  int n;
  sqlite3_context *pCtx;
 
  assert( pOp->p4type==P4_FUNCDEF );
  n = pOp->p5;
  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
  assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
  pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
               (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
  if( pCtx==0 ) goto no_mem;
  pCtx->pMem = 0;
  pCtx->pOut = (Mem*)&(pCtx->argv[n]);
  sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
  pCtx->pFunc = pOp->p4.pFunc;
  pCtx->iOp = (int)(pOp - aOp);
  pCtx->pVdbe = p;
  pCtx->skipFlag = 0;
  pCtx->isError = 0;
  pCtx->argc = n;
  pOp->p4type = P4_FUNCCTX;
  pOp->p4.pCtx = pCtx;
 
  /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */
  assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
 
  pOp->opcode = OP_AggStep1;
  /* Fall through into OP_AggStep */
  /* no break */ deliberate_fall_through
}
case OP_AggStep1: {
  int i;
  sqlite3_context *pCtx;
  Mem *pMem;
 
  assert( pOp->p4type==P4_FUNCCTX );
  pCtx = pOp->p4.pCtx;
  pMem = &aMem[pOp->p3];
 
#ifdef SQLITE_DEBUG
  if( pOp->p1 ){
    /* This is an OP_AggInverse call.  Verify that xStep has always
    ** been called at least once prior to any xInverse call. */
    assert( pMem->uTemp==0x1122e0e3 );
  }else{
    /* This is an OP_AggStep call.  Mark it as such. */
    pMem->uTemp = 0x1122e0e3;
  }
#endif
 
  /* If this function is inside of a trigger, the register array in aMem[]
  ** might change from one evaluation to the next.  The next block of code
  ** checks to see if the register array has changed, and if so it
  ** reinitializes the relavant parts of the sqlite3_context object */
  if( pCtx->pMem != pMem ){
    pCtx->pMem = pMem;
    for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
  }
 
#ifdef SQLITE_DEBUG
  for(i=0; i<pCtx->argc; i++){
    assert( memIsValid(pCtx->argv[i]) );
    REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
  }
#endif
 
  pMem->n++;
  assert( pCtx->pOut->flags==MEM_Null );
  assert( pCtx->isError==0 );
  assert( pCtx->skipFlag==0 );
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( pOp->p1 ){
    (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
  }else
#endif
  (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
 
  if( pCtx->isError ){
    if( pCtx->isError>0 ){
      sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
      rc = pCtx->isError;
    }
    if( pCtx->skipFlag ){
      assert( pOp[-1].opcode==OP_CollSeq );
      i = pOp[-1].p1;
      if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
      pCtx->skipFlag = 0;
    }
    sqlite3VdbeMemRelease(pCtx->pOut);
    pCtx->pOut->flags = MEM_Null;
    pCtx->isError = 0;
    if( rc ) goto abort_due_to_error;
  }
  assert( pCtx->pOut->flags==MEM_Null );
  assert( pCtx->skipFlag==0 );
  break;
}
 
/* Opcode: AggFinal P1 P2 * P4 *
** Synopsis: accum=r[P1] N=P2
**
** P1 is the memory location that is the accumulator for an aggregate
** or window function.  Execute the finalizer function
** for an aggregate and store the result in P1.
**
** P2 is the number of arguments that the step function takes and
** P4 is a pointer to the FuncDef for this function.  The P2
** argument is not used by this opcode.  It is only there to disambiguate
** functions that can take varying numbers of arguments.  The
** P4 argument is only needed for the case where
** the step function was not previously called.
*/
/* Opcode: AggValue * P2 P3 P4 *
** Synopsis: r[P3]=value N=P2
**
** Invoke the xValue() function and store the result in register P3.
**
** P2 is the number of arguments that the step function takes and
** P4 is a pointer to the FuncDef for this function.  The P2
** argument is not used by this opcode.  It is only there to disambiguate
** functions that can take varying numbers of arguments.  The
** P4 argument is only needed for the case where
** the step function was not previously called.
*/
case OP_AggValue:
case OP_AggFinal: {
  Mem *pMem;
  assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
  assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
  pMem = &aMem[pOp->p1];
  assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( pOp->p3 ){
    memAboutToChange(p, &aMem[pOp->p3]);
    rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
    pMem = &aMem[pOp->p3];
  }else
#endif
  {
    rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
  }
 
  if( rc ){
    sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
    goto abort_due_to_error;
  }
  sqlite3VdbeChangeEncoding(pMem, encoding);
  UPDATE_MAX_BLOBSIZE(pMem);
  if( sqlite3VdbeMemTooBig(pMem) ){
    goto too_big;
  }
  break;
}
 
#ifndef SQLITE_OMIT_WAL
/* Opcode: Checkpoint P1 P2 P3 * *
**
** Checkpoint database P1. This is a no-op if P1 is not currently in
** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
** RESTART, or TRUNCATE.  Write 1 or 0 into mem[P3] if the checkpoint returns
** SQLITE_BUSY or not, respectively.  Write the number of pages in the
** WAL after the checkpoint into mem[P3+1] and the number of pages
** in the WAL that have been checkpointed after the checkpoint
** completes into mem[P3+2].  However on an error, mem[P3+1] and
** mem[P3+2] are initialized to -1.
*/
case OP_Checkpoint: {
  int i;                          /* Loop counter */
  int aRes[3];                    /* Results */
  Mem *pMem;                      /* Write results here */
 
  assert( p->readOnly==0 );
  aRes[0] = 0;
  aRes[1] = aRes[2] = -1;
  assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
       || pOp->p2==SQLITE_CHECKPOINT_FULL
       || pOp->p2==SQLITE_CHECKPOINT_RESTART
       || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
  );
  rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
  if( rc ){
    if( rc!=SQLITE_BUSY ) goto abort_due_to_error;
    rc = SQLITE_OK;
    aRes[0] = 1;
  }
  for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
    sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
  }
  break;
};
#endif
 
#ifndef SQLITE_OMIT_PRAGMA
/* Opcode: JournalMode P1 P2 P3 * *
**
** Change the journal mode of database P1 to P3. P3 must be one of the
** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
** modes (delete, truncate, persist, off and memory), this is a simple
** operation. No IO is required.
**
** If changing into or out of WAL mode the procedure is more complicated.
**
** Write a string containing the final journal-mode to register P2.
*/
case OP_JournalMode: {    /* out2 */
  Btree *pBt;                     /* Btree to change journal mode of */
  Pager *pPager;                  /* Pager associated with pBt */
  int eNew;                       /* New journal mode */
  int eOld;                       /* The old journal mode */
#ifndef SQLITE_OMIT_WAL
  const char *zFilename;          /* Name of database file for pPager */
#endif
 
  pOut = out2Prerelease(p, pOp);
  eNew = pOp->p3;
  assert( eNew==PAGER_JOURNALMODE_DELETE
       || eNew==PAGER_JOURNALMODE_TRUNCATE
       || eNew==PAGER_JOURNALMODE_PERSIST
       || eNew==PAGER_JOURNALMODE_OFF
       || eNew==PAGER_JOURNALMODE_MEMORY
       || eNew==PAGER_JOURNALMODE_WAL
       || eNew==PAGER_JOURNALMODE_QUERY
  );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( p->readOnly==0 );
 
  pBt = db->aDb[pOp->p1].pBt;
  pPager = sqlite3BtreePager(pBt);
  eOld = sqlite3PagerGetJournalMode(pPager);
  if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
  if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
 
#ifndef SQLITE_OMIT_WAL
  zFilename = sqlite3PagerFilename(pPager, 1);
 
  /* Do not allow a transition to journal_mode=WAL for a database
  ** in temporary storage or if the VFS does not support shared memory
  */
  if( eNew==PAGER_JOURNALMODE_WAL
   && (sqlite3Strlen30(zFilename)==0           /* Temp file */
       || !sqlite3PagerWalSupported(pPager))   /* No shared-memory support */
  ){
    eNew = eOld;
  }
 
  if( (eNew!=eOld)
   && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
  ){
    if( !db->autoCommit || db->nVdbeRead>1 ){
      rc = SQLITE_ERROR;
      sqlite3VdbeError(p,
          "cannot change %s wal mode from within a transaction",
          (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
      );
      goto abort_due_to_error;
    }else{
 
      if( eOld==PAGER_JOURNALMODE_WAL ){
        /* If leaving WAL mode, close the log file. If successful, the call
        ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
        ** file. An EXCLUSIVE lock may still be held on the database file
        ** after a successful return.
        */
        rc = sqlite3PagerCloseWal(pPager, db);
        if( rc==SQLITE_OK ){
          sqlite3PagerSetJournalMode(pPager, eNew);
        }
      }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
        /* Cannot transition directly from MEMORY to WAL.  Use mode OFF
        ** as an intermediate */
        sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
      }
 
      /* Open a transaction on the database file. Regardless of the journal
      ** mode, this transaction always uses a rollback journal.
      */
      assert( sqlite3BtreeIsInTrans(pBt)==0 );
      if( rc==SQLITE_OK ){
        rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
      }
    }
  }
#endif /* ifndef SQLITE_OMIT_WAL */
 
  if( rc ) eNew = eOld;
  eNew = sqlite3PagerSetJournalMode(pPager, eNew);
 
  pOut->flags = MEM_Str|MEM_Static|MEM_Term;
  pOut->z = (char *)sqlite3JournalModename(eNew);
  pOut->n = sqlite3Strlen30(pOut->z);
  pOut->enc = SQLITE_UTF8;
  sqlite3VdbeChangeEncoding(pOut, encoding);
  if( rc ) goto abort_due_to_error;
  break;
};
#endif /* SQLITE_OMIT_PRAGMA */
 
#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
/* Opcode: Vacuum P1 P2 * * *
**
** Vacuum the entire database P1.  P1 is 0 for "main", and 2 or more
** for an attached database.  The "temp" database may not be vacuumed.
**
** If P2 is not zero, then it is a register holding a string which is
** the file into which the result of vacuum should be written.  When
** P2 is zero, the vacuum overwrites the original database.
*/
case OP_Vacuum: {
  assert( p->readOnly==0 );
  rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
                        pOp->p2 ? &aMem[pOp->p2] : 0);
  if( rc ) goto abort_due_to_error;
  break;
}
#endif
 
#if !defined(SQLITE_OMIT_AUTOVACUUM)
/* Opcode: IncrVacuum P1 P2 * * *
**
** Perform a single step of the incremental vacuum procedure on
** the P1 database. If the vacuum has finished, jump to instruction
** P2. Otherwise, fall through to the next instruction.
*/
case OP_IncrVacuum: {        /* jump */
  Btree *pBt;
 
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
  assert( p->readOnly==0 );
  pBt = db->aDb[pOp->p1].pBt;
  rc = sqlite3BtreeIncrVacuum(pBt);
  VdbeBranchTaken(rc==SQLITE_DONE,2);
  if( rc ){
    if( rc!=SQLITE_DONE ) goto abort_due_to_error;
    rc = SQLITE_OK;
    goto jump_to_p2;
  }
  break;
}
#endif
 
/* Opcode: Expire P1 P2 * * *
**
** Cause precompiled statements to expire.  When an expired statement
** is executed using sqlite3_step() it will either automatically
** reprepare itself (if it was originally created using sqlite3_prepare_v2())
** or it will fail with SQLITE_SCHEMA.
**
** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
** then only the currently executing statement is expired.
**
** If P2 is 0, then SQL statements are expired immediately.  If P2 is 1,
** then running SQL statements are allowed to continue to run to completion.
** The P2==1 case occurs when a CREATE INDEX or similar schema change happens
** that might help the statement run faster but which does not affect the
** correctness of operation.
*/
case OP_Expire: {
  assert( pOp->p2==0 || pOp->p2==1 );
  if( !pOp->p1 ){
    sqlite3ExpirePreparedStatements(db, pOp->p2);
  }else{
    p->expired = pOp->p2+1;
  }
  break;
}
 
/* Opcode: CursorLock P1 * * * *
**
** Lock the btree to which cursor P1 is pointing so that the btree cannot be
** written by an other cursor.
*/
case OP_CursorLock: {
  VdbeCursor *pC;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  sqlite3BtreeCursorPin(pC->uc.pCursor);
  break;
}
 
/* Opcode: CursorUnlock P1 * * * *
**
** Unlock the btree to which cursor P1 is pointing so that it can be
** written by other cursors.
*/
case OP_CursorUnlock: {
  VdbeCursor *pC;
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
  sqlite3BtreeCursorUnpin(pC->uc.pCursor);
  break;
}
 
#ifndef SQLITE_OMIT_SHARED_CACHE
/* Opcode: TableLock P1 P2 P3 P4 *
** Synopsis: iDb=P1 root=P2 write=P3
**
** Obtain a lock on a particular table. This instruction is only used when
** the shared-cache feature is enabled.
**
** P1 is the index of the database in sqlite3.aDb[] of the database
** on which the lock is acquired.  A readlock is obtained if P3==0 or
** a write lock if P3==1.
**
** P2 contains the root-page of the table to lock.
**
** P4 contains a pointer to the name of the table being locked. This is only
** used to generate an error message if the lock cannot be obtained.
*/
case OP_TableLock: {
  u8 isWriteLock = (u8)pOp->p3;
  if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
    int p1 = pOp->p1;
    assert( p1>=0 && p1<db->nDb );
    assert( DbMaskTest(p->btreeMask, p1) );
    assert( isWriteLock==0 || isWriteLock==1 );
    rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
    if( rc ){
      if( (rc&0xFF)==SQLITE_LOCKED ){
        const char *z = pOp->p4.z;
        sqlite3VdbeError(p, "database table is locked: %s", z);
      }
      goto abort_due_to_error;
    }
  }
  break;
}
#endif /* SQLITE_OMIT_SHARED_CACHE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VBegin * * * P4 *
**
** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
** xBegin method for that table.
**
** Also, whether or not P4 is set, check that this is not being called from
** within a callback to a virtual table xSync() method. If it is, the error
** code will be set to SQLITE_LOCKED.
*/
case OP_VBegin: {
  VTable *pVTab;
  pVTab = pOp->p4.pVtab;
  rc = sqlite3VtabBegin(db, pVTab);
  if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
  if( rc ) goto abort_due_to_error;
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VCreate P1 P2 * * *
**
** P2 is a register that holds the name of a virtual table in database
** P1. Call the xCreate method for that table.
*/
case OP_VCreate: {
  Mem sMem;          /* For storing the record being decoded */
  const char *zTab;  /* Name of the virtual table */
 
  memset(&sMem, 0, sizeof(sMem));
  sMem.db = db;
  /* Because P2 is always a static string, it is impossible for the
  ** sqlite3VdbeMemCopy() to fail */
  assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
  assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
  rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
  assert( rc==SQLITE_OK );
  zTab = (const char*)sqlite3_value_text(&sMem);
  assert( zTab || db->mallocFailed );
  if( zTab ){
    rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
  }
  sqlite3VdbeMemRelease(&sMem);
  if( rc ) goto abort_due_to_error;
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VDestroy P1 * * P4 *
**
** P4 is the name of a virtual table in database P1.  Call the xDestroy method
** of that table.
*/
case OP_VDestroy: {
  db->nVDestroy++;
  rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
  db->nVDestroy--;
  assert( p->errorAction==OE_Abort && p->usesStmtJournal );
  if( rc ) goto abort_due_to_error;
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VOpen P1 * * P4 *
**
** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
** P1 is a cursor number.  This opcode opens a cursor to the virtual
** table and stores that cursor in P1.
*/
case OP_VOpen: {
  VdbeCursor *pCur;
  sqlite3_vtab_cursor *pVCur;
  sqlite3_vtab *pVtab;
  const sqlite3_module *pModule;
 
  assert( p->bIsReader );
  pCur = 0;
  pVCur = 0;
  pVtab = pOp->p4.pVtab->pVtab;
  if( pVtab==0 || NEVER(pVtab->pModule==0) ){
    rc = SQLITE_LOCKED;
    goto abort_due_to_error;
  }
  pModule = pVtab->pModule;
  rc = pModule->xOpen(pVtab, &pVCur);
  sqlite3VtabImportErrmsg(p, pVtab);
  if( rc ) goto abort_due_to_error;
 
  /* Initialize sqlite3_vtab_cursor base class */
  pVCur->pVtab = pVtab;
 
  /* Initialize vdbe cursor object */
  pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
  if( pCur ){
    pCur->uc.pVCur = pVCur;
    pVtab->nRef++;
  }else{
    assert( db->mallocFailed );
    pModule->xClose(pVCur);
    goto no_mem;
  }
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VFilter P1 P2 P3 P4 *
** Synopsis: iplan=r[P3] zplan='P4'
**
** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
** the filtered result set is empty.
**
** P4 is either NULL or a string that was generated by the xBestIndex
** method of the module.  The interpretation of the P4 string is left
** to the module implementation.
**
** This opcode invokes the xFilter method on the virtual table specified
** by P1.  The integer query plan parameter to xFilter is stored in register
** P3. Register P3+1 stores the argc parameter to be passed to the
** xFilter method. Registers P3+2..P3+1+argc are the argc
** additional parameters which are passed to
** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
**
** A jump is made to P2 if the result set after filtering would be empty.
*/
case OP_VFilter: {   /* jump */
  int nArg;
  int iQuery;
  const sqlite3_module *pModule;
  Mem *pQuery;
  Mem *pArgc;
  sqlite3_vtab_cursor *pVCur;
  sqlite3_vtab *pVtab;
  VdbeCursor *pCur;
  int res;
  int i;
  Mem **apArg;
 
  pQuery = &aMem[pOp->p3];
  pArgc = &pQuery[1];
  pCur = p->apCsr[pOp->p1];
  assert( memIsValid(pQuery) );
  REGISTER_TRACE(pOp->p3, pQuery);
  assert( pCur->eCurType==CURTYPE_VTAB );
  pVCur = pCur->uc.pVCur;
  pVtab = pVCur->pVtab;
  pModule = pVtab->pModule;
 
  /* Grab the index number and argc parameters */
  assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
  nArg = (int)pArgc->u.i;
  iQuery = (int)pQuery->u.i;
 
  /* Invoke the xFilter method */
  res = 0;
  apArg = p->apArg;
  for(i = 0; i<nArg; i++){
    apArg[i] = &pArgc[i+1];
  }
  rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
  sqlite3VtabImportErrmsg(p, pVtab);
  if( rc ) goto abort_due_to_error;
  res = pModule->xEof(pVCur);
  pCur->nullRow = 0;
  VdbeBranchTaken(res!=0,2);
  if( res ) goto jump_to_p2;
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VColumn P1 P2 P3 * P5
** Synopsis: r[P3]=vcolumn(P2)
**
** Store in register P3 the value of the P2-th column of
** the current row of the virtual-table of cursor P1.
**
** If the VColumn opcode is being used to fetch the value of
** an unchanging column during an UPDATE operation, then the P5
** value is OPFLAG_NOCHNG.  This will cause the sqlite3_vtab_nochange()
** function to return true inside the xColumn method of the virtual
** table implementation.  The P5 column might also contain other
** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
** unused by OP_VColumn.
*/
case OP_VColumn: {
  sqlite3_vtab *pVtab;
  const sqlite3_module *pModule;
  Mem *pDest;
  sqlite3_context sContext;
 
  VdbeCursor *pCur = p->apCsr[pOp->p1];
  assert( pCur->eCurType==CURTYPE_VTAB );
  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  pDest = &aMem[pOp->p3];
  memAboutToChange(p, pDest);
  if( pCur->nullRow ){
    sqlite3VdbeMemSetNull(pDest);
    break;
  }
  pVtab = pCur->uc.pVCur->pVtab;
  pModule = pVtab->pModule;
  assert( pModule->xColumn );
  memset(&sContext, 0, sizeof(sContext));
  sContext.pOut = pDest;
  assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
  if( pOp->p5 & OPFLAG_NOCHNG ){
    sqlite3VdbeMemSetNull(pDest);
    pDest->flags = MEM_Null|MEM_Zero;
    pDest->u.nZero = 0;
  }else{
    MemSetTypeFlag(pDest, MEM_Null);
  }
  rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
  sqlite3VtabImportErrmsg(p, pVtab);
  if( sContext.isError>0 ){
    sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest));
    rc = sContext.isError;
  }
  sqlite3VdbeChangeEncoding(pDest, encoding);
  REGISTER_TRACE(pOp->p3, pDest);
  UPDATE_MAX_BLOBSIZE(pDest);
 
  if( sqlite3VdbeMemTooBig(pDest) ){
    goto too_big;
  }
  if( rc ) goto abort_due_to_error;
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VNext P1 P2 * * *
**
** Advance virtual table P1 to the next row in its result set and
** jump to instruction P2.  Or, if the virtual table has reached
** the end of its result set, then fall through to the next instruction.
*/
case OP_VNext: {   /* jump */
  sqlite3_vtab *pVtab;
  const sqlite3_module *pModule;
  int res;
  VdbeCursor *pCur;
 
  res = 0;
  pCur = p->apCsr[pOp->p1];
  assert( pCur->eCurType==CURTYPE_VTAB );
  if( pCur->nullRow ){
    break;
  }
  pVtab = pCur->uc.pVCur->pVtab;
  pModule = pVtab->pModule;
  assert( pModule->xNext );
 
  /* Invoke the xNext() method of the module. There is no way for the
  ** underlying implementation to return an error if one occurs during
  ** xNext(). Instead, if an error occurs, true is returned (indicating that
  ** data is available) and the error code returned when xColumn or
  ** some other method is next invoked on the save virtual table cursor.
  */
  rc = pModule->xNext(pCur->uc.pVCur);
  sqlite3VtabImportErrmsg(p, pVtab);
  if( rc ) goto abort_due_to_error;
  res = pModule->xEof(pCur->uc.pVCur);
  VdbeBranchTaken(!res,2);
  if( !res ){
    /* If there is data, jump to P2 */
    goto jump_to_p2_and_check_for_interrupt;
  }
  goto check_for_interrupt;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VRename P1 * * P4 *
**
** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
** This opcode invokes the corresponding xRename method. The value
** in register P1 is passed as the zName argument to the xRename method.
*/
case OP_VRename: {
  sqlite3_vtab *pVtab;
  Mem *pName;
  int isLegacy;
 
  isLegacy = (db->flags & SQLITE_LegacyAlter);
  db->flags |= SQLITE_LegacyAlter;
  pVtab = pOp->p4.pVtab->pVtab;
  pName = &aMem[pOp->p1];
  assert( pVtab->pModule->xRename );
  assert( memIsValid(pName) );
  assert( p->readOnly==0 );
  REGISTER_TRACE(pOp->p1, pName);
  assert( pName->flags & MEM_Str );
  testcase( pName->enc==SQLITE_UTF8 );
  testcase( pName->enc==SQLITE_UTF16BE );
  testcase( pName->enc==SQLITE_UTF16LE );
  rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
  if( rc ) goto abort_due_to_error;
  rc = pVtab->pModule->xRename(pVtab, pName->z);
  if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
  sqlite3VtabImportErrmsg(p, pVtab);
  p->expired = 0;
  if( rc ) goto abort_due_to_error;
  break;
}
#endif
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Opcode: VUpdate P1 P2 P3 P4 P5
** Synopsis: data=r[P3@P2]
**
** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
** This opcode invokes the corresponding xUpdate method. P2 values
** are contiguous memory cells starting at P3 to pass to the xUpdate
** invocation. The value in register (P3+P2-1) corresponds to the
** p2th element of the argv array passed to xUpdate.
**
** The xUpdate method will do a DELETE or an INSERT or both.
** The argv[0] element (which corresponds to memory cell P3)
** is the rowid of a row to delete.  If argv[0] is NULL then no
** deletion occurs.  The argv[1] element is the rowid of the new
** row.  This can be NULL to have the virtual table select the new
** rowid for itself.  The subsequent elements in the array are
** the values of columns in the new row.
**
** If P2==1 then no insert is performed.  argv[0] is the rowid of
** a row to delete.
**
** P1 is a boolean flag. If it is set to true and the xUpdate call
** is successful, then the value returned by sqlite3_last_insert_rowid()
** is set to the value of the rowid for the row just inserted.
**
** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
** apply in the case of a constraint failure on an insert or update.
*/
case OP_VUpdate: {
  sqlite3_vtab *pVtab;
  const sqlite3_module *pModule;
  int nArg;
  int i;
  sqlite_int64 rowid;
  Mem **apArg;
  Mem *pX;
 
  assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback
       || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
  );
  assert( p->readOnly==0 );
  if( db->mallocFailed ) goto no_mem;
  sqlite3VdbeIncrWriteCounter(p, 0);
  pVtab = pOp->p4.pVtab->pVtab;
  if( pVtab==0 || NEVER(pVtab->pModule==0) ){
    rc = SQLITE_LOCKED;
    goto abort_due_to_error;
  }
  pModule = pVtab->pModule;
  nArg = pOp->p2;
  assert( pOp->p4type==P4_VTAB );
  if( ALWAYS(pModule->xUpdate) ){
    u8 vtabOnConflict = db->vtabOnConflict;
    apArg = p->apArg;
    pX = &aMem[pOp->p3];
    for(i=0; i<nArg; i++){
      assert( memIsValid(pX) );
      memAboutToChange(p, pX);
      apArg[i] = pX;
      pX++;
    }
    db->vtabOnConflict = pOp->p5;
    rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
    db->vtabOnConflict = vtabOnConflict;
    sqlite3VtabImportErrmsg(p, pVtab);
    if( rc==SQLITE_OK && pOp->p1 ){
      assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
      db->lastRowid = rowid;
    }
    if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
      if( pOp->p5==OE_Ignore ){
        rc = SQLITE_OK;
      }else{
        p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
      }
    }else{
      p->nChange++;
    }
    if( rc ) goto abort_due_to_error;
  }
  break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
#ifndef  SQLITE_OMIT_PAGER_PRAGMAS
/* Opcode: Pagecount P1 P2 * * *
**
** Write the current number of pages in database P1 to memory cell P2.
*/
case OP_Pagecount: {            /* out2 */
  pOut = out2Prerelease(p, pOp);
  pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
  break;
}
#endif
 
 
#ifndef  SQLITE_OMIT_PAGER_PRAGMAS
/* Opcode: MaxPgcnt P1 P2 P3 * *
**
** Try to set the maximum page count for database P1 to the value in P3.
** Do not let the maximum page count fall below the current page count and
** do not change the maximum page count value if P3==0.
**
** Store the maximum page count after the change in register P2.
*/
case OP_MaxPgcnt: {            /* out2 */
  unsigned int newMax;
  Btree *pBt;
 
  pOut = out2Prerelease(p, pOp);
  pBt = db->aDb[pOp->p1].pBt;
  newMax = 0;
  if( pOp->p3 ){
    newMax = sqlite3BtreeLastPage(pBt);
    if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
  }
  pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
  break;
}
#endif
 
/* Opcode: Function P1 P2 P3 P4 *
** Synopsis: r[P3]=func(r[P2@NP])
**
** Invoke a user function (P4 is a pointer to an sqlite3_context object that
** contains a pointer to the function to be run) with arguments taken
** from register P2 and successors.  The number of arguments is in
** the sqlite3_context object that P4 points to.
** The result of the function is stored
** in register P3.  Register P3 must not be one of the function inputs.
**
** P1 is a 32-bit bitmask indicating whether or not each argument to the
** function was determined to be constant at compile time. If the first
** argument was constant then bit 0 of P1 is set. This is used to determine
** whether meta data associated with a user function argument using the
** sqlite3_set_auxdata() API may be safely retained until the next
** invocation of this opcode.
**
** See also: AggStep, AggFinal, PureFunc
*/
/* Opcode: PureFunc P1 P2 P3 P4 *
** Synopsis: r[P3]=func(r[P2@NP])
**
** Invoke a user function (P4 is a pointer to an sqlite3_context object that
** contains a pointer to the function to be run) with arguments taken
** from register P2 and successors.  The number of arguments is in
** the sqlite3_context object that P4 points to.
** The result of the function is stored
** in register P3.  Register P3 must not be one of the function inputs.
**
** P1 is a 32-bit bitmask indicating whether or not each argument to the
** function was determined to be constant at compile time. If the first
** argument was constant then bit 0 of P1 is set. This is used to determine
** whether meta data associated with a user function argument using the
** sqlite3_set_auxdata() API may be safely retained until the next
** invocation of this opcode.
**
** This opcode works exactly like OP_Function.  The only difference is in
** its name.  This opcode is used in places where the function must be
** purely non-deterministic.  Some built-in date/time functions can be
** either determinitic of non-deterministic, depending on their arguments.
** When those function are used in a non-deterministic way, they will check
** to see if they were called using OP_PureFunc instead of OP_Function, and
** if they were, they throw an error.
**
** See also: AggStep, AggFinal, Function
*/
case OP_PureFunc:              /* group */
case OP_Function: {            /* group */
  int i;
  sqlite3_context *pCtx;
 
  assert( pOp->p4type==P4_FUNCCTX );
  pCtx = pOp->p4.pCtx;
 
  /* If this function is inside of a trigger, the register array in aMem[]
  ** might change from one evaluation to the next.  The next block of code
  ** checks to see if the register array has changed, and if so it
  ** reinitializes the relavant parts of the sqlite3_context object */
  pOut = &aMem[pOp->p3];
  if( pCtx->pOut != pOut ){
    pCtx->pVdbe = p;
    pCtx->pOut = pOut;
    for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
  }
  assert( pCtx->pVdbe==p );
 
  memAboutToChange(p, pOut);
#ifdef SQLITE_DEBUG
  for(i=0; i<pCtx->argc; i++){
    assert( memIsValid(pCtx->argv[i]) );
    REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
  }
#endif
  MemSetTypeFlag(pOut, MEM_Null);
  assert( pCtx->isError==0 );
  (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
 
  /* If the function returned an error, throw an exception */
  if( pCtx->isError ){
    if( pCtx->isError>0 ){
      sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
      rc = pCtx->isError;
    }
    sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
    pCtx->isError = 0;
    if( rc ) goto abort_due_to_error;
  }
 
  /* Copy the result of the function into register P3 */
  if( pOut->flags & (MEM_Str|MEM_Blob) ){
    sqlite3VdbeChangeEncoding(pOut, encoding);
    if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
  }
 
  REGISTER_TRACE(pOp->p3, pOut);
  UPDATE_MAX_BLOBSIZE(pOut);
  break;
}
 
/* Opcode: Trace P1 P2 * P4 *
**
** Write P4 on the statement trace output if statement tracing is
** enabled.
**
** Operand P1 must be 0x7fffffff and P2 must positive.
*/
/* Opcode: Init P1 P2 P3 P4 *
** Synopsis: Start at P2
**
** Programs contain a single instance of this opcode as the very first
** opcode.
**
** If tracing is enabled (by the sqlite3_trace()) interface, then
** the UTF-8 string contained in P4 is emitted on the trace callback.
** Or if P4 is blank, use the string returned by sqlite3_sql().
**
** If P2 is not zero, jump to instruction P2.
**
** Increment the value of P1 so that OP_Once opcodes will jump the
** first time they are evaluated for this run.
**
** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT
** error is encountered.
*/
case OP_Trace:
case OP_Init: {          /* jump */
  int i;
#ifndef SQLITE_OMIT_TRACE
  char *zTrace;
#endif
 
  /* If the P4 argument is not NULL, then it must be an SQL comment string.
  ** The "--" string is broken up to prevent false-positives with srcck1.c.
  **
  ** This assert() provides evidence for:
  ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that
  ** would have been returned by the legacy sqlite3_trace() interface by
  ** using the X argument when X begins with "--" and invoking
  ** sqlite3_expanded_sql(P) otherwise.
  */
  assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
 
  /* OP_Init is always instruction 0 */
  assert( pOp==p->aOp || pOp->opcode==OP_Trace );
 
#ifndef SQLITE_OMIT_TRACE
  if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
   && !p->doingRerun
   && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
  ){
#ifndef SQLITE_OMIT_DEPRECATED
    if( db->mTrace & SQLITE_TRACE_LEGACY ){
      char *z = sqlite3VdbeExpandSql(p, zTrace);
      db->trace.xLegacy(db->pTraceArg, z);
      sqlite3_free(z);
    }else
#endif
    if( db->nVdbeExec>1 ){
      char *z = sqlite3MPrintf(db, "-- %s", zTrace);
      (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
      sqlite3DbFree(db, z);
    }else{
      (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
    }
  }
#ifdef SQLITE_USE_FCNTL_TRACE
  zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
  if( zTrace ){
    int j;
    for(j=0; j<db->nDb; j++){
      if( DbMaskTest(p->btreeMask, j)==0 ) continue;
      sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace);
    }
  }
#endif /* SQLITE_USE_FCNTL_TRACE */
#ifdef SQLITE_DEBUG
  if( (db->flags & SQLITE_SqlTrace)!=0
   && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
  ){
    sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
  }
#endif /* SQLITE_DEBUG */
#endif /* SQLITE_OMIT_TRACE */
  assert( pOp->p2>0 );
  if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
    if( pOp->opcode==OP_Trace ) break;
    for(i=1; i<p->nOp; i++){
      if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0;
    }
    pOp->p1 = 0;
  }
  pOp->p1++;
  p->aCounter[SQLITE_STMTSTATUS_RUN]++;
  goto jump_to_p2;
}
 
#ifdef SQLITE_ENABLE_CURSOR_HINTS
/* Opcode: CursorHint P1 * * P4 *
**
** Provide a hint to cursor P1 that it only needs to return rows that
** satisfy the Expr in P4.  TK_REGISTER terms in the P4 expression refer
** to values currently held in registers.  TK_COLUMN terms in the P4
** expression refer to columns in the b-tree to which cursor P1 is pointing.
*/
case OP_CursorHint: {
  VdbeCursor *pC;
 
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p4type==P4_EXPR );
  pC = p->apCsr[pOp->p1];
  if( pC ){
    assert( pC->eCurType==CURTYPE_BTREE );
    sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
                           pOp->p4.pExpr, aMem);
  }
  break;
}
#endif /* SQLITE_ENABLE_CURSOR_HINTS */
 
#ifdef SQLITE_DEBUG
/* Opcode:  Abortable   * * * * *
**
** Verify that an Abort can happen.  Assert if an Abort at this point
** might cause database corruption.  This opcode only appears in debugging
** builds.
**
** An Abort is safe if either there have been no writes, or if there is
** an active statement journal.
*/
case OP_Abortable: {
  sqlite3VdbeAssertAbortable(p);
  break;
}
#endif
 
#ifdef SQLITE_DEBUG
/* Opcode:  ReleaseReg   P1 P2 P3 * P5
** Synopsis: release r[P1@P2] mask P3
**
** Release registers from service.  Any content that was in the
** the registers is unreliable after this opcode completes.
**
** The registers released will be the P2 registers starting at P1,
** except if bit ii of P3 set, then do not release register P1+ii.
** In other words, P3 is a mask of registers to preserve.
**
** Releasing a register clears the Mem.pScopyFrom pointer.  That means
** that if the content of the released register was set using OP_SCopy,
** a change to the value of the source register for the OP_SCopy will no longer
** generate an assertion fault in sqlite3VdbeMemAboutToChange().
**
** If P5 is set, then all released registers have their type set
** to MEM_Undefined so that any subsequent attempt to read the released
** register (before it is reinitialized) will generate an assertion fault.
**
** P5 ought to be set on every call to this opcode.
** However, there are places in the code generator will release registers
** before their are used, under the (valid) assumption that the registers
** will not be reallocated for some other purpose before they are used and
** hence are safe to release.
**
** This opcode is only available in testing and debugging builds.  It is
** not generated for release builds.  The purpose of this opcode is to help
** validate the generated bytecode.  This opcode does not actually contribute
** to computing an answer.
*/
case OP_ReleaseReg: {
  Mem *pMem;
  int i;
  u32 constMask;
  assert( pOp->p1>0 );
  assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
  pMem = &aMem[pOp->p1];
  constMask = pOp->p3;
  for(i=0; i<pOp->p2; i++, pMem++){
    if( i>=32 || (constMask & MASKBIT32(i))==0 ){
      pMem->pScopyFrom = 0;
      if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
    }
  }
  break;
}
#endif
 
/* Opcode: Noop * * * * *
**
** Do nothing.  This instruction is often useful as a jump
** destination.
*/
/*
** The magic Explain opcode are only inserted when explain==2 (which
** is to say when the EXPLAIN QUERY PLAN syntax is used.)
** This opcode records information from the optimizer.  It is the
** the same as a no-op.  This opcodesnever appears in a real VM program.
*/
default: {          /* This is really OP_Noop, OP_Explain */
  assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
 
  break;
}
 
/*****************************************************************************
** The cases of the switch statement above this line should all be indented
** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
** readability.  From this point on down, the normal indentation rules are
** restored.
*****************************************************************************/
    }
 
#ifdef VDBE_PROFILE
    {
      u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
      if( endTime>start ) pOrigOp->cycles += endTime - start;
      pOrigOp->cnt++;
    }
#endif
 
    /* The following code adds nothing to the actual functionality
    ** of the program.  It is only here for testing and debugging.
    ** On the other hand, it does burn CPU cycles every time through
    ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
    */
#ifndef NDEBUG
    assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
 
#ifdef SQLITE_DEBUG
    if( db->flags & SQLITE_VdbeTrace ){
      u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode];
      if( rc!=0 ) printf("rc=%d\n",rc);
      if( opProperty & (OPFLG_OUT2) ){
        registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
      }
      if( opProperty & OPFLG_OUT3 ){
        registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]);
      }
      if( opProperty==0xff ){
        /* Never happens.  This code exists to avoid a harmless linkage
        ** warning aboud sqlite3VdbeRegisterDump() being defined but not
        ** used. */
        sqlite3VdbeRegisterDump(p);
      }
    }
#endif  /* SQLITE_DEBUG */
#endif  /* NDEBUG */
  }  /* The end of the for(;;) loop the loops through opcodes */
 
  /* If we reach this point, it means that execution is finished with
  ** an error of some kind.
  */
abort_due_to_error:
  if( db->mallocFailed ) rc = SQLITE_NOMEM_BKPT;
  assert( rc );
  if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
    sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
  }
  p->rc = rc;
  sqlite3SystemError(db, rc);
  testcase( sqlite3GlobalConfig.xLog!=0 );
  sqlite3_log(rc, "statement aborts at %d: [%s] %s",
                   (int)(pOp - aOp), p->zSql, p->zErrMsg);
  sqlite3VdbeHalt(p);
  if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
  rc = SQLITE_ERROR;
  if( resetSchemaOnFault>0 ){
    sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
  }
 
  /* This is the only way out of this procedure.  We have to
  ** release the mutexes on btrees that were acquired at the
  ** top. */
vdbe_return:
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
    nProgressLimit += db->nProgressOps;
    if( db->xProgress(db->pProgressArg) ){
      nProgressLimit = LARGEST_UINT64;
      rc = SQLITE_INTERRUPT;
      goto abort_due_to_error;
    }
  }
#endif
  p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
  sqlite3VdbeLeave(p);
  assert( rc!=SQLITE_OK || nExtraDelete==0
       || sqlite3_strlike("DELETE%",p->zSql,0)!=0
  );
  return rc;
 
  /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
  ** is encountered.
  */
too_big:
  sqlite3VdbeError(p, "string or blob too big");
  rc = SQLITE_TOOBIG;
  goto abort_due_to_error;
 
  /* Jump to here if a malloc() fails.
  */
no_mem:
  sqlite3OomFault(db);
  sqlite3VdbeError(p, "out of memory");
  rc = SQLITE_NOMEM_BKPT;
  goto abort_due_to_error;
 
  /* Jump to here if the sqlite3_interrupt() API sets the interrupt
  ** flag.

References VdbeCursor::aAltMap, Table::aCol, KeyInfo::aColl, Vdbe::aCounter, sqlite3::aDb, VdbeOp::p4union::ai, sqlite3::aLimit, allocateCursor(), ALWAYS, BtreePayload::aMem, UnpackedRecord::aMem, VdbeFrame::aMem, Vdbe::aMem, VdbeFrame::anExec, VdbeCursor::aOffset, VdbeFrame::aOnce, SubProgram::aOp, VdbeFrame::aOp, Vdbe::aOp, Vdbe::apArg, VdbeFrame::apCsr, Vdbe::apCsr, applyAffinity(), applyNumericAffinity(), sqlite3_context::argc, sqlite3_context::argv, VdbeCursor::aRow, ArraySize, KeyInfo::aSortFlags, AtomicLoad, VdbeCursor::aType, sqlite3::autoCommit, Vdbe::aVar, VTable::bConstraint, Vdbe::bIsReader, BTREE_AUXDELETE, BTREE_BLOBKEY, BTREE_BULKLOAD, BTREE_FILE_FORMAT, BTREE_FORDELETE, BTREE_HINT_RANGE, BTREE_INTKEY, BTREE_OMIT_JOURNAL, BTREE_SAVEPOSITION, BTREE_SCHEMA_VERSION, BTREE_SEEK_EQ, BTREE_SINGLE, BTREE_UNORDERED, BTREE_WRCSR, Vdbe::btreeMask, sqlite3::sqlite3InitInfo::busy, sqlite3::busyHandler, CACHE_STALE, Vdbe::cacheCtr, VdbeCursor::cacheStatus, CORRUPT_DB, CURTYPE_BTREE, CURTYPE_PSEUDO, CURTYPE_SORTER, CURTYPE_VTAB, KeyInfo::db, InitData::db, sqlite3_value::db, Vdbe::db, DB_SchemaLoaded, DBFLAG_SchemaChange, DbHasProperty, DbMaskTest, Deephemeralize, UnpackedRecord::default_rc, VdbeCursor::deferredMoveto, deliberate_fall_through, DFLT_SCHEMA_TABLE, Vdbe::doingRerun, VdbeCursor::eCurType, ENC, KeyInfo::enc, sqlite3_value::enc, UnpackedRecord::eqSeen, Vdbe::errorAction, ExpandBlob, Vdbe::expired, Vdbe::explain, Schema::file_format, sqlite3::flags, sqlite3_value::flags, getVarint32, HAS_UPDATE_HOOK, HasRowid, VdbeOp::p4union::i, sqlite3_value::MemValue::i, Vdbe::iCurrentTime, InitData::iDb, VdbeCursor::iDb, Schema::iGeneration, VdbeCursor::iHdrOffset, sqlite3::init, INITFLAG_AlterTable, sqlite3_context::iOp, VdbeCursor::isEphemeral, sqlite3_context::isError, sqlite3::isInterrupted, VdbeCursor::isOrdered, isSorter, VdbeCursor::isTable, Vdbe::iStatement, sqlite3::isTransactionSavepoint, KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, LARGEST_UINT64, sqlite3::lastRowid, VdbeFrame::lastRowid, Vdbe::magic, sqlite3::mallocFailed, MASKBIT32, MAX_ROWID, sqlite3::mDbFlags, MEM_AffMask, MEM_Agg, MEM_Blob, MEM_Cleared, MEM_Dyn, MEM_Ephem, MEM_FromBind, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Static, MEM_Str, MEM_Term, MEM_TypeMask, MEM_Undefined, MEM_Zero, memAboutToChange, MEMCELLSIZE, MemSetTypeFlag, InitData::mInitFlags, Vdbe::minWriteFileFormat, VdbeCursor::movetoTarget, sqlite3::mTrace, InitData::mxPage, sqlite3_value::n, KeyInfo::nAllField, BusyHandler::nBusy, sqlite3::nChange, VdbeFrame::nChange, Vdbe::nChange, VdbeFrame::nChildCsr, VdbeFrame::nChildMem, SubProgram::nCsr, VdbeFrame::nCursor, Vdbe::nCursor, BtreePayload::nData, sqlite3::nDb, VdbeFrame::nDbChange, sqlite3::nDeferredCons, Savepoint::nDeferredCons, sqlite3::nDeferredImmCons, Savepoint::nDeferredImmCons, NEVER, UnpackedRecord::nField, VdbeCursor::nField, Vdbe::nFkConstraint, Vdbe::nFrame, VdbeCursor::nHdrParsed, InitData::nInitRow, BtreePayload::nKey, BtreePayload::nMem, SubProgram::nMem, VdbeFrame::nMem, Vdbe::nMem, nName, SubProgram::nOp, VdbeFrame::nOp, Vdbe::nOp, sqlite3::nProgressOps, sqlite3_vtab::nRef, Vdbe::nResColumn, sqlite3::nSavepoint, sqlite3::nSqlExec, sqlite3::nStatement, Vdbe::nStmtDefCons, Vdbe::nStmtDefImmCons, VdbeCursor::nullRow, numericType(), Vdbe::nVar, sqlite3::nVdbeActive, sqlite3::nVdbeExec, sqlite3::nVdbeRead, sqlite3::nVdbeWrite, sqlite3::nVDestroy, sqlite3::nVTrans, BtreePayload::nZero, sqlite3_value::MemValue::nZero, OE_Abort, OE_Fail, OE_Ignore, OE_Replace, OE_Rollback, OP_Abortable, OP_Add, OP_AddImm, OP_Affinity, OP_AggFinal, OP_AggInverse, OP_AggStep, OP_AggStep1, OP_AggValue, OP_And, OP_AutoCommit, OP_BitAnd, OP_BitNot, OP_BitOr, OP_Blob, OP_Cast, OP_Checkpoint, OP_Clear, OP_Close, OP_CollSeq, OP_Column, OP_ColumnsUsed, OP_Compare, OP_Concat, OP_Copy, OP_Count, OP_CreateBtree, OP_CursorHint, OP_CursorLock, OP_CursorUnlock, OP_DecrJumpZero, OP_DeferredSeek, OP_Delete, OP_Destroy, OP_Divide, OP_DropIndex, OP_DropTable, OP_DropTrigger, OP_ElseNotEq, OP_EndCoroutine, OP_Eq, OP_Expire, OP_Explain, OP_FinishSeek, OP_FkCounter, OP_FkIfZero, OP_Found, OP_Function, OP_Ge, OP_Gosub, OP_Goto, OP_Gt, OP_Halt, OP_HaltIfNull, OP_IdxDelete, OP_IdxGE, OP_IdxGT, OP_IdxInsert, OP_IdxLE, OP_IdxLT, OP_IdxRowid, OP_If, OP_IfNoHope, OP_IfNot, OP_IfNotOpen, OP_IfNotZero, OP_IfNullRow, OP_IfPos, OP_IfSmaller, OP_IncrVacuum, OP_Init, OP_InitCoroutine, OP_Insert, OP_Int64, OP_IntCopy, OP_Integer, OP_IntegrityCk, OP_IsNull, OP_IsTrue, OP_JournalMode, OP_Jump, OP_Last, OP_Le, OP_LoadAnalysis, OP_Lt, OP_MakeRecord, OP_MaxPgcnt, OP_MemMax, OP_Move, OP_Multiply, OP_MustBeInt, OP_Ne, OP_NewRowid, OP_Next, OP_NoConflict, OP_Noop, OP_Not, OP_NotExists, OP_NotFound, OP_NotNull, OP_Null, OP_NullRow, OP_Offset, OP_OffsetLimit, OP_Once, OP_OpenAutoindex, OP_OpenDup, OP_OpenEphemeral, OP_OpenPseudo, OP_OpenRead, OP_OpenWrite, OP_Or, OP_Pagecount, OP_Param, OP_ParseSchema, OP_Permutation, OP_Prev, OP_Program, OP_PureFunc, OP_ReadCookie, OP_Real, OP_RealAffinity, OP_ReleaseReg, OP_Remainder, OP_ReopenIdx, OP_ResetCount, OP_ResetSorter, OP_ResultRow, OP_Return, OP_Rewind, OP_RowData, OP_Rowid, OP_RowSetAdd, OP_RowSetRead, OP_RowSetTest, OP_Savepoint, OP_SCopy, OP_SeekEnd, OP_SeekGE, OP_SeekGT, OP_SeekHit, OP_SeekLE, OP_SeekLT, OP_SeekRowid, OP_Sequence, OP_SequenceTest, OP_SetCookie, OP_ShiftLeft, OP_ShiftRight, OP_SoftNull, OP_Sort, OP_SorterCompare, OP_SorterData, OP_SorterInsert, OP_SorterNext, OP_SorterOpen, OP_SorterSort, OP_SqlExec, OP_String, OP_String8, OP_Subtract, OP_TableLock, OP_Trace, OP_Transaction, OP_Vacuum, OP_Variable, OP_VBegin, OP_VColumn, OP_VCreate, OP_VDestroy, OP_VFilter, OP_VNext, OP_VOpen, OP_VRename, OP_VUpdate, OP_Yield, VdbeOp::opcode, OPFLAG_APPEND, OPFLAG_AUXDELETE, OPFLAG_BULKCSR, OPFLAG_FORDELETE, OPFLAG_ISNOOP, OPFLAG_ISUPDATE, OPFLAG_LASTROWID, OPFLAG_LENGTHARG, OPFLAG_NCHANGE, OPFLAG_NOCHNG, OPFLAG_NOCHNG_MAGIC, OPFLAG_P2ISREG, OPFLAG_PERMUTE, OPFLAG_SAVEPOSITION, OPFLAG_SEEKEQ, OPFLAG_TYPEOFARG, OPFLAG_USESEEKRESULT, OPFLG_IN1, OPFLG_IN2, OPFLG_IN3, OPFLG_OUT2, OPFLG_OUT3, out2Prerelease(), VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, VdbeOp::p4, P4_COLLSEQ, P4_DYNAMIC, P4_EXPR, P4_FUNCCTX, P4_FUNCDEF, P4_INT32, P4_INTARRAY, P4_KEYINFO, P4_MEM, P4_STATIC, P4_TABLE, P4_VTAB, VdbeOp::p4type, VdbeOp::p5, PAGER_JOURNALMODE_DELETE, PAGER_JOURNALMODE_MEMORY, PAGER_JOURNALMODE_OFF, PAGER_JOURNALMODE_PERSIST, PAGER_JOURNALMODE_QUERY, PAGER_JOURNALMODE_TRUNCATE, PAGER_JOURNALMODE_WAL, VdbeCursor::pAltCursor, VdbeFrame::pAuxData, Vdbe::pAuxData, VdbeCursor::payloadSize, Db::pBt, VdbeCursor::pBtx, VdbeFrame::pc, Vdbe::pc, VdbeOp::p4union::pColl, VdbeOp::p4union::pCtx, VdbeCursor::pCursor, BtreePayload::pData, Vdbe::pFrame, VdbeOp::p4union::pFunc, sqlite3_context::pFunc, VdbeCursor::pgnoRoot, VdbeOp::p4union::pI64, BtreePayload::pKey, VdbeOp::p4union::pKeyInfo, UnpackedRecord::pKeyInfo, VdbeCursor::pKeyInfo, VdbeOp::p4union::pMem, sqlite3_context::pMem, sqlite3_vtab::pModule, Savepoint::pNext, sqlite3_context::pOut, VdbeFrame::pParent, VdbeOp::p4union::pProgram, sqlite3::pProgressArg, VdbeOp::p4union::pReal, Vdbe::pResultSet, printf, sqlite3::pSavepoint, Db::pSchema, VdbeCursor::pSorter, VdbeOp::p4union::pTab, sqlite3::pTraceArg, sqlite3::pUpdateArg, putVarint32, VdbeCursor::pVCur, sqlite3_context::pVdbe, sqlite3::pVfs, Vdbe::pVList, sqlite3_vtab_cursor::pVtab, VdbeOp::p4union::pVtab, VTable::pVtab, InitData::pzErrMsg, sqlite3_value::MemValue::r, InitData::rc, Vdbe::rc, Vdbe::readOnly, REGISTER_TRACE, ROUND8, SAVEPOINT_BEGIN, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, Schema::schema_cookie, SCHEMA_ROOT, VdbeCursor::seekHit, VdbeCursor::seekResult, VdbeCursor::seqCount, sqlite3_context::skipFlag, SMALLEST_INT64, sqlite3_exec(), sqlite3_file_control(), sqlite3_free(), sqlite3_interrupt(), sqlite3_log(), sqlite3_randomness(), sqlite3_strlike(), sqlite3_value_text(), sqlite3AddInt64(), sqlite3AnalysisLoad(), sqlite3BeginBenignMalloc(), sqlite3BtreeBeginStmt(), sqlite3BtreeBeginTrans(), sqlite3BtreeClearCursor(), sqlite3BtreeClearTable(), sqlite3BtreeClearTableOfCursor(), sqlite3BtreeCount(), sqlite3BtreeCreateTable(), sqlite3BtreeCursor(), sqlite3BtreeCursorHasHint(), sqlite3BtreeCursorHintFlags(), sqlite3BtreeCursorIsValidNN(), sqlite3BtreeCursorPin(), sqlite3BtreeCursorUnpin(), sqlite3BtreeDelete(), sqlite3BtreeDropTable(), sqlite3BtreeEof(), sqlite3BtreeFakeValidCursor(), sqlite3BtreeFirst(), sqlite3BtreeGetMeta(), sqlite3BtreeIncrVacuum(), sqlite3BtreeInsert(), sqlite3BtreeIntegerKey(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeIsInTrans(), sqlite3BtreeLast(), sqlite3BtreeLastPage(), sqlite3BtreeLockTable(), sqlite3BtreeMaxPageCount(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeNext(), sqlite3BtreeOpen(), sqlite3BtreePager(), sqlite3BtreePayloadFetch(), sqlite3BtreePayloadSize(), sqlite3BtreePrevious(), sqlite3BtreeRowCountEst(), sqlite3BtreeSavepoint(), sqlite3BtreeSetVersion(), sqlite3BtreeTripAllCursors(), sqlite3BtreeUpdateMeta(), sqlite3Checkpoint(), sqlite3CloseSavepoints(), sqlite3CtypeMap, sqlite3DbFree(), sqlite3DbFreeNN(), sqlite3DbMallocRawNN(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3EndBenignMalloc(), sqlite3ErrStr(), sqlite3ExpirePreparedStatements(), sqlite3GetVarint32(), sqlite3GlobalConfig, sqlite3InitCallback(), sqlite3InitOne(), sqlite3IsNaN(), sqlite3JournalModename(), sqlite3LogEst(), sqlite3MemCompare(), sqlite3MPrintf(), sqlite3MulInt64(), sqlite3OomFault(), sqlite3OpcodeProperty, sqlite3PagerCloseWal(), sqlite3PagerFilename(), sqlite3PagerGetJournalMode(), sqlite3PagerOkToChangeJournalMode(), sqlite3PagerSetJournalMode(), sqlite3PagerWalSupported(), sqlite3ResetAllSchemasOfConnection(), sqlite3ResetOneSchema(), sqlite3RollbackAll(), sqlite3RootPageMoved(), sqlite3RowSetInsert(), sqlite3RowSetNext(), sqlite3RowSetTest(), sqlite3RunVacuum(), sqlite3SchemaClear(), sqlite3StrICmp(), sqlite3Strlen30(), sqlite3SubInt64(), sqlite3SystemError(), sqlite3UnlinkAndDeleteIndex(), sqlite3UnlinkAndDeleteTable(), sqlite3UnlinkAndDeleteTrigger(), sqlite3VarintLen(), sqlite3VdbeAllocUnpackedRecord(), sqlite3VdbeAssertAbortable, sqlite3VdbeBooleanValue(), sqlite3VdbeChangeEncoding(), sqlite3VdbeCheckFk(), sqlite3VdbeCloseStatement(), sqlite3VdbeCursorMoveto(), sqlite3VdbeCursorRestore(), sqlite3VdbeDeleteAuxData(), sqlite3VdbeEnter(), sqlite3VdbeError(), sqlite3VdbeExpandSql(), sqlite3VdbeFinishMoveto(), sqlite3VdbeFrameMemDel(), sqlite3VdbeFrameRestore(), sqlite3VdbeFreeCursor(), sqlite3VdbeHalt(), sqlite3VdbeIdxKeyCompare(), sqlite3VdbeIdxRowid(), sqlite3VdbeIncrWriteCounter, sqlite3VdbeIntValue(), sqlite3VdbeIOTraceSql, sqlite3VdbeLeave(), sqlite3VdbeMemAggValue(), sqlite3VdbeMemCast(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemCopy(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeMemFinalize(), sqlite3VdbeMemFromBtree(), sqlite3VdbeMemFromBtreeZeroOffset(), sqlite3VdbeMemGrow(), sqlite3VdbeMemInit(), sqlite3VdbeMemIntegerify(), sqlite3VdbeMemMove(), sqlite3VdbeMemNulTerminate(), sqlite3VdbeMemRealify(), sqlite3VdbeMemRelease(), sqlite3VdbeMemSetInt64(), sqlite3VdbeMemSetNull(), sqlite3VdbeMemSetRowSet(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemShallowCopy(), sqlite3VdbeMemStringify(), sqlite3VdbeMemTooBig(), sqlite3VdbeOneByteSerialTypeLen(), sqlite3VdbeRealValue(), sqlite3VdbeRecordUnpack(), sqlite3VdbeSerialGet(), sqlite3VdbeSerialPut(), sqlite3VdbeSerialTypeLen(), sqlite3VdbeSetChanges(), sqlite3VdbeSorterCompare(), sqlite3VdbeSorterInit(), sqlite3VdbeSorterNext(), sqlite3VdbeSorterReset(), sqlite3VdbeSorterRewind(), sqlite3VdbeSorterRowkey(), sqlite3VdbeSorterWrite(), sqlite3VListNumToName(), sqlite3VtabBegin(), sqlite3VtabCallCreate(), sqlite3VtabCallDestroy(), sqlite3VtabImportErrmsg(), sqlite3VtabSavepoint(), SQLITE_ABORT_ROLLBACK, SQLITE_AFF_BLOB, SQLITE_AFF_INTEGER, SQLITE_AFF_MASK, SQLITE_AFF_NONE, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, SQLITE_BUSY, SQLITE_BUSY_RECOVERY, SQLITE_BUSY_SNAPSHOT, SQLITE_CHECKPOINT_FULL, SQLITE_CHECKPOINT_PASSIVE, SQLITE_CHECKPOINT_RESTART, SQLITE_CHECKPOINT_TRUNCATE, SQLITE_CONSTRAINT, SQLITE_CORRUPT_BKPT, SQLITE_CORRUPT_INDEX, SQLITE_CountRows, SQLITE_DeferFKs, SQLITE_DELETE, SQLITE_DONE, SQLITE_ERROR, SQLITE_FCNTL_TRACE, SQLITE_FRAME_MAGIC, SQLITE_FULL, SQLITE_INSERT, SQLITE_INTERRUPT, SQLITE_IOERR_NOMEM, SQLITE_JUMPIFNULL, SQLITE_KEEPNULL, SQLITE_LegacyAlter, SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_LOCKED, SQLITE_MAX_LENGTH, SQLITE_MISMATCH, SQLITE_N_BTREE_META, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_NULLEQ, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_TRANSIENT_DB, SQLITE_QueryOnly, SQLITE_READONLY, SQLITE_ReadUncommit, SQLITE_ROW, SQLITE_SCHEMA, SQLITE_STATIC, SQLITE_STMTSTATUS_RUN, SQLITE_STMTSTATUS_SORT, SQLITE_STMTSTATUS_VM_STEP, SQLITE_STOREP2, SQLITE_TOOBIG, SQLITE_TRACE_LEGACY, SQLITE_TRACE_ROW, SQLITE_TRACE_STMT, SQLITE_UPDATE, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, sqlite3_value::szMalloc, VdbeCursor::szRow, testcase, SubProgram::token, VdbeFrame::token, sqlite3::trace, sqlite3_value::u, sqlite3::u1, VdbeCursor::uc, UPDATE_MAX_BLOBSIZE, VdbeCursor::useRandomRowid, Vdbe::usesStmtJournal, sqlite3_value::uTemp, VdbeFrame::v, VDBE_MAGIC_RUN, VdbeBranchTaken, VdbeFrameMem, VdbeMemDynamic, sqlite3::vtabOnConflict, VdbeOp::p4union::xAdvance, sqlite3_module::xClose, sqlite3_module::xColumn, sqlite3_value::xDel, sqlite3_module::xEof, sqlite3_module::xFilter, FuncDef::xInverse, sqlite3::xLegacy, sqlite3_module::xNext, sqlite3_module::xOpen, sqlite3::xProgress, sqlite3_module::xRename, sqlite3_module::xRowid, FuncDef::xSFunc, sqlite3_module::xUpdate, sqlite3::xUpdateCallback, sqlite3::xV2, VdbeOp::p4union::z, sqlite3_value::z, Db::zDbSName, Vdbe::zErrMsg, sqlite3_value::zMalloc, Savepoint::zName, Table::zName, zName, and Vdbe::zSql.

Referenced by blobSeekToRow(), and sqlite3Step().

◆ sqlite3VdbeExpandSql()

SQLITE_PRIVATE char * sqlite3VdbeExpandSql	(	Vdbe *	p,
		const char *	zRawSql )

Definition at line 85107 of file sqlite3.c.

 {
  sqlite3 *db;             /* The database connection */
  int idx = 0;             /* Index of a host parameter */
  int nextIndex = 1;       /* Index of next ? host parameter */
  int n;                   /* Length of a token prefix */
  int nToken;              /* Length of the parameter token */
  int i;                   /* Loop counter */
  Mem *pVar;               /* Value of a host parameter */
  StrAccum out;            /* Accumulate the output here */
#ifndef SQLITE_OMIT_UTF16
  Mem utf8;                /* Used to convert UTF16 into UTF8 for display */
#endif
  char zBase[100];         /* Initial working space */
 
  db = p->db;
  sqlite3StrAccumInit(&out, 0, zBase, sizeof(zBase),
                      db->aLimit[SQLITE_LIMIT_LENGTH]);
  if( db->nVdbeExec>1 ){
    while( *zRawSql ){
      const char *zStart = zRawSql;
      while( *(zRawSql++)!='\n' && *zRawSql );
      sqlite3_str_append(&out, "-- ", 3);
      assert( (zRawSql - zStart) > 0 );
      sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart));
    }
  }else if( p->nVar==0 ){
    sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql));
  }else{
    while( zRawSql[0] ){
      n = findNextHostParameter(zRawSql, &nToken);
      assert( n>0 );
      sqlite3_str_append(&out, zRawSql, n);
      zRawSql += n;
      assert( zRawSql[0] || nToken==0 );
      if( nToken==0 ) break;
      if( zRawSql[0]=='?' ){
        if( nToken>1 ){
          assert( sqlite3Isdigit(zRawSql[1]) );
          sqlite3GetInt32(&zRawSql[1], &idx);
        }else{
          idx = nextIndex;
        }
      }else{
        assert( zRawSql[0]==':' || zRawSql[0]=='$' ||
                zRawSql[0]=='@' || zRawSql[0]=='#' );
        testcase( zRawSql[0]==':' );
        testcase( zRawSql[0]=='$' );
        testcase( zRawSql[0]=='@' );
        testcase( zRawSql[0]=='#' );
        idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);
        assert( idx>0 );
      }
      zRawSql += nToken;
      nextIndex = idx + 1;
      assert( idx>0 && idx<=p->nVar );
      pVar = &p->aVar[idx-1];
      if( pVar->flags & MEM_Null ){
        sqlite3_str_append(&out, "NULL", 4);
      }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){
        sqlite3_str_appendf(&out, "%lld", pVar->u.i);
      }else if( pVar->flags & MEM_Real ){
        sqlite3_str_appendf(&out, "%!.15g", pVar->u.r);
      }else if( pVar->flags & MEM_Str ){
        int nOut;  /* Number of bytes of the string text to include in output */
#ifndef SQLITE_OMIT_UTF16
        u8 enc = ENC(db);
        if( enc!=SQLITE_UTF8 ){
          memset(&utf8, 0, sizeof(utf8));
          utf8.db = db;
          sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
          if( SQLITE_NOMEM==sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8) ){
            out.accError = SQLITE_NOMEM;
            out.nAlloc = 0;
          }
          pVar = &utf8;
        }
#endif
        nOut = pVar->n;
#ifdef SQLITE_TRACE_SIZE_LIMIT
        if( nOut>SQLITE_TRACE_SIZE_LIMIT ){
          nOut = SQLITE_TRACE_SIZE_LIMIT;
          while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
        }
#endif
        sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
#ifdef SQLITE_TRACE_SIZE_LIMIT
        if( nOut<pVar->n ){
          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
        }
#endif
#ifndef SQLITE_OMIT_UTF16
        if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
#endif
      }else if( pVar->flags & MEM_Zero ){
        sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero);
      }else{
        int nOut;  /* Number of bytes of the blob to include in output */
        assert( pVar->flags & MEM_Blob );
        sqlite3_str_append(&out, "x'", 2);
        nOut = pVar->n;
#ifdef SQLITE_TRACE_SIZE_LIMIT
        if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
#endif
        for(i=0; i<nOut; i++){
          sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
        }
        sqlite3_str_append(&out, "'", 1);
#ifdef SQLITE_TRACE_SIZE_LIMIT
        if( nOut<pVar->n ){
          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
        }
#endif

References sqlite3_str::accError, sqlite3::aLimit, Vdbe::aVar, sqlite3_value::db, Vdbe::db, ENC, findNextHostParameter(), sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, MEM_Zero, sqlite3_value::n, sqlite3_str::nAlloc, Vdbe::nVar, sqlite3::nVdbeExec, sqlite3_value::MemValue::nZero, sqlite3_value::MemValue::r, sqlite3_str_append(), sqlite3_str_appendf(), sqlite3_str_reset(), sqlite3GetInt32(), sqlite3Isdigit, sqlite3StrAccumFinish(), sqlite3StrAccumInit(), sqlite3Strlen30(), sqlite3VdbeChangeEncoding(), sqlite3VdbeMemRelease(), sqlite3VdbeMemSetStr(), sqlite3VdbeParameterIndex(), SQLITE_LIMIT_LENGTH, SQLITE_NOMEM, SQLITE_STATIC, SQLITE_UTF8, testcase, sqlite3_value::u, and sqlite3_value::z.

Referenced by sqlite3_expanded_sql(), and sqlite3VdbeExec().

◆ sqlite3VdbeExplain()

SQLITE_PRIVATE void sqlite3VdbeExplain	(	Parse *	pParse,
		u8	bPush,
		const char *	zFmt,
			... )

Definition at line 78164 of file sqlite3.c.

                                                                                      {
#ifndef SQLITE_DEBUG
  /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
  ** But omit them (for performance) during production builds */
  if( pParse->explain==2 )
#endif
  {
    char *zMsg;
    Vdbe *v;
    va_list ap;
    int iThis;
    va_start(ap, zFmt);
    zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
    va_end(ap);
    v = pParse->pVdbe;
    iThis = v->nOp;
    sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
                      zMsg, P4_DYNAMIC);

References Parse::addrExplain, Parse::db, Parse::explain, Vdbe::nOp, OP_Explain, VdbeOp::p4, P4_DYNAMIC, ValueNewStat4Ctx::pParse, Parse::pVdbe, sqlite3ExplainBreakpoint, sqlite3VdbeAddOp4(), sqlite3VdbeGetOp(), sqlite3VMPrintf(), and VdbeOp::p4union::z.

Referenced by explainSimpleCount().

◆ sqlite3VdbeExplainParent()

SQLITE_PRIVATE int sqlite3VdbeExplainParent ( Parse * pParse )

Definition at line 78140 of file sqlite3.c.

References Parse::addrExplain, VdbeOp::p2, ValueNewStat4Ctx::pParse, Parse::pVdbe, and sqlite3VdbeGetOp().

◆ sqlite3VdbeExplainPop()

SQLITE_PRIVATE void sqlite3VdbeExplainPop ( Parse * pParse )

Definition at line 78192 of file sqlite3.c.

◆ sqlite3VdbeFinalize()

SQLITE_PRIVATE int sqlite3VdbeFinalize ( Vdbe * p )

Definition at line 81114 of file sqlite3.c.

                                               {
  int rc = SQLITE_OK;
  if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){

Referenced by sqlite3_declare_vtab(), sqlite3_exec(), sqlite3_finalize(), and sqlite3Reprepare().

◆ sqlite3VdbeFindCompare()

SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare ( UnpackedRecord * p )

Definition at line 82582 of file sqlite3.c.

                                                                      {
  /* varintRecordCompareInt() and varintRecordCompareString() both assume
  ** that the size-of-header varint that occurs at the start of each record
  ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
  ** also assumes that it is safe to overread a buffer by at least the
  ** maximum possible legal header size plus 8 bytes. Because there is
  ** guaranteed to be at least 74 (but not 136) bytes of padding following each
  ** buffer passed to varintRecordCompareInt() this makes it convenient to
  ** limit the size of the header to 64 bytes in cases where the first field
  ** is an integer.
  **
  ** The easiest way to enforce this limit is to consider only records with
  ** 13 fields or less. If the first field is an integer, the maximum legal
  ** header size is (12*5 + 1 + 1) bytes.  */
  if( p->pKeyInfo->nAllField<=13 ){
    int flags = p->aMem[0].flags;
    if( p->pKeyInfo->aSortFlags[0] ){
      if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
        return sqlite3VdbeRecordCompare;
      }
      p->r1 = 1;
      p->r2 = -1;
    }else{
      p->r1 = -1;
      p->r2 = 1;
    }
    if( (flags & MEM_Int) ){
      return vdbeRecordCompareInt;
    }
    testcase( flags & MEM_Real );
    testcase( flags & MEM_Null );
    testcase( flags & MEM_Blob );
    if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0
     && p->pKeyInfo->aColl[0]==0
    ){
      assert( flags & MEM_Str );

References KeyInfo::aColl, UnpackedRecord::aMem, KeyInfo::aSortFlags, sqlite3_value::flags, KEYINFO_ORDER_BIGNULL, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, KeyInfo::nAllField, UnpackedRecord::pKeyInfo, UnpackedRecord::r1, UnpackedRecord::r2, sqlite3VdbeRecordCompare(), testcase, vdbeRecordCompareInt(), and vdbeRecordCompareString().

Referenced by sqlite3BtreeMovetoUnpacked().

◆ sqlite3VdbeFinishMoveto()

SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto ( VdbeCursor * p )

Definition at line 81235 of file sqlite3.c.

                                                                         {
  int res, rc;
#ifdef SQLITE_TEST
  extern int sqlite3_search_count;
#endif
  assert( p->deferredMoveto );
  assert( p->isTable );
  assert( p->eCurType==CURTYPE_BTREE );
  rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res);
  if( rc ) return rc;
  if( res!=0 ) return SQLITE_CORRUPT_BKPT;
#ifdef SQLITE_TEST

References CACHE_STALE, VdbeCursor::cacheStatus, CURTYPE_BTREE, VdbeCursor::deferredMoveto, VdbeCursor::eCurType, VdbeCursor::isTable, VdbeCursor::movetoTarget, VdbeCursor::pCursor, sqlite3BtreeMovetoUnpacked(), SQLITE_CORRUPT_BKPT, SQLITE_OK, and VdbeCursor::uc.

Referenced by sqlite3VdbeCursorMoveto(), and sqlite3VdbeExec().

◆ sqlite3VdbeFrameDelete()

SQLITE_PRIVATE void sqlite3VdbeFrameDelete ( VdbeFrame * p )

Definition at line 79802 of file sqlite3.c.

                                                        {
  int i;
  Mem *aMem = VdbeFrameMem(p);
  VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
  assert( sqlite3VdbeFrameIsValid(p) );
  for(i=0; i<p->nChildCsr; i++){

References Vdbe::db, VdbeFrame::nChildCsr, VdbeFrame::nChildMem, VdbeFrame::pAuxData, releaseMemArray(), sqlite3DbFree(), sqlite3VdbeDeleteAuxData(), sqlite3VdbeFreeCursor(), VdbeFrame::v, and VdbeFrameMem.

Referenced by closeAllCursors().

◆ sqlite3VdbeFrameMemDel()

SQLITE_PRIVATE void sqlite3VdbeFrameMemDel ( void * pArg )

Definition at line 79675 of file sqlite3.c.

References Vdbe::pDelFrame, VdbeFrame::pParent, and VdbeFrame::v.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeFrameRestore()

SQLITE_PRIVATE int sqlite3VdbeFrameRestore ( VdbeFrame * pFrame )

Definition at line 80255 of file sqlite3.c.

                                                             {
  Vdbe *v = pFrame->v;
  closeCursorsInFrame(v);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  v->anExec = pFrame->anExec;
#endif
  v->aOp = pFrame->aOp;
  v->nOp = pFrame->nOp;
  v->aMem = pFrame->aMem;
  v->nMem = pFrame->nMem;
  v->apCsr = pFrame->apCsr;
  v->nCursor = pFrame->nCursor;
  v->db->lastRowid = pFrame->lastRowid;
  v->nChange = pFrame->nChange;

References VdbeFrame::aMem, Vdbe::aMem, VdbeFrame::anExec, VdbeFrame::aOp, Vdbe::aOp, VdbeFrame::apCsr, Vdbe::apCsr, closeCursorsInFrame(), Vdbe::db, sqlite3::lastRowid, VdbeFrame::lastRowid, sqlite3::nChange, VdbeFrame::nChange, Vdbe::nChange, VdbeFrame::nCursor, Vdbe::nCursor, VdbeFrame::nDbChange, VdbeFrame::nMem, Vdbe::nMem, VdbeFrame::nOp, Vdbe::nOp, VdbeFrame::pAuxData, Vdbe::pAuxData, VdbeFrame::pc, sqlite3VdbeDeleteAuxData(), and VdbeFrame::v.

Referenced by closeAllCursors(), and sqlite3VdbeExec().

◆ sqlite3VdbeFreeCursor()

SQLITE_PRIVATE void sqlite3VdbeFreeCursor	(	Vdbe *	p,
		VdbeCursor *	pCx )

Definition at line 80200 of file sqlite3.c.

                                                                   {
  if( pCx==0 ){
    return;
  }
  assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
  switch( pCx->eCurType ){
    case CURTYPE_SORTER: {
      sqlite3VdbeSorterClose(p->db, pCx);
      break;
    }
    case CURTYPE_BTREE: {
      if( pCx->isEphemeral ){
        if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
        /* The pCx->pCursor will be close automatically, if it exists, by
        ** the call above. */
      }else{
        assert( pCx->uc.pCursor!=0 );
        sqlite3BtreeCloseCursor(pCx->uc.pCursor);
      }
      break;
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    case CURTYPE_VTAB: {
      sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
      const sqlite3_module *pModule = pVCur->pVtab->pModule;
      assert( pVCur->pVtab->nRef>0 );
      pVCur->pVtab->nRef--;

Referenced by allocateCursor(), sqlite3VdbeExec(), and sqlite3VdbeFrameDelete().

◆ sqlite3VdbeGetBoundValue()

SQLITE_PRIVATE sqlite3_value * sqlite3VdbeGetBoundValue	(	Vdbe *	v,
		int	iVar,
		u8	aff )

Definition at line 82808 of file sqlite3.c.

                                                                                 {
  assert( iVar>0 );
  if( v ){
    Mem *pMem = &v->aVar[iVar-1];
    assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
    if( 0==(pMem->flags & MEM_Null) ){
      sqlite3_value *pRet = sqlite3ValueNew(v->db);
      if( pRet ){
        sqlite3VdbeMemCopy((Mem *)pRet, pMem);
        sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);

References Vdbe::aVar, Vdbe::db, sqlite3::flags, sqlite3_value::flags, MEM_Null, sqlite3ValueApplyAffinity(), sqlite3ValueNew(), sqlite3VdbeMemCopy(), SQLITE_EnableQPSG, and SQLITE_UTF8.

Referenced by exprCompareVariable(), and isLikeOrGlob().

◆ sqlite3VdbeGetOp()

SQLITE_PRIVATE VdbeOp * sqlite3VdbeGetOp	(	Vdbe *	p,
		int	addr )

Definition at line 79158 of file sqlite3.c.

                                                          {
  /* C89 specifies that the constant "dummy" will be initialized to all
  ** zeros, which is correct.  MSVC generates a warning, nevertheless. */
  static VdbeOp dummy;  /* Ignore the MSVC warning about no initializer */
  assert( p->magic==VDBE_MAGIC_INIT );
  if( addr<0 ){
    addr = p->nOp - 1;
  }
  assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );

References Vdbe::aOp, Vdbe::db, dummy, Vdbe::magic, sqlite3::mallocFailed, Vdbe::nOp, and VDBE_MAGIC_INIT.

Referenced by readsTable(), selectInnerLoop(), sqlite3ComputeGeneratedColumns(), sqlite3ExprCodeExprList(), sqlite3ExprCodeGetColumn(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3VdbeChangeP2(), sqlite3VdbeChangeP3(), sqlite3VdbeChangeP5(), sqlite3VdbeExplain(), sqlite3VdbeExplainParent(), sqlite3VdbeJumpHereOrPopInst(), sqlite3WhereEnd(), translateColumnToCopy(), whereLikeOptimizationStringFixup(), and windowAggStep().

◆ sqlite3VdbeGoto()

SQLITE_PRIVATE int sqlite3VdbeGoto	(	Vdbe *	p,
		int	iDest )

Definition at line 78015 of file sqlite3.c.

                                                                     {
  return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
}

References sqlite3VdbeAddOp3().

Referenced by analyzeOneTable(), computeLimitRegisters(), constructAutomaticIndex(), fkLookupParent(), generateSortTail(), generateWithRecursiveQuery(), multiSelectOrderBy(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3Update(), and sqlite3WhereEnd().

◆ sqlite3VdbeHalt()

SQLITE_PRIVATE int sqlite3VdbeHalt ( Vdbe * p )

Definition at line 80755 of file sqlite3.c.

                                           {
  int rc;                         /* Used to store transient return codes */
  sqlite3 *db = p->db;
 
  /* This function contains the logic that determines if a statement or
  ** transaction will be committed or rolled back as a result of the
  ** execution of this virtual machine.
  **
  ** If any of the following errors occur:
  **
  **     SQLITE_NOMEM
  **     SQLITE_IOERR
  **     SQLITE_FULL
  **     SQLITE_INTERRUPT
  **
  ** Then the internal cache might have been left in an inconsistent
  ** state.  We need to rollback the statement transaction, if there is
  ** one, or the complete transaction if there is no statement transaction.
  */
 
  if( p->magic!=VDBE_MAGIC_RUN ){
    return SQLITE_OK;
  }
  if( db->mallocFailed ){
    p->rc = SQLITE_NOMEM_BKPT;
  }
  closeAllCursors(p);
  checkActiveVdbeCnt(db);
 
  /* No commit or rollback needed if the program never started or if the
  ** SQL statement does not read or write a database file.  */
  if( p->pc>=0 && p->bIsReader ){
    int mrc;   /* Primary error code from p->rc */
    int eStatementOp = 0;
    int isSpecialError;            /* Set to true if a 'special' error */
 
    /* Lock all btrees used by the statement */
    sqlite3VdbeEnter(p);
 
    /* Check for one of the special errors */
    mrc = p->rc & 0xff;
    isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
                     || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
    if( isSpecialError ){
      /* If the query was read-only and the error code is SQLITE_INTERRUPT,
      ** no rollback is necessary. Otherwise, at least a savepoint
      ** transaction must be rolled back to restore the database to a
      ** consistent state.
      **
      ** Even if the statement is read-only, it is important to perform
      ** a statement or transaction rollback operation. If the error
      ** occurred while writing to the journal, sub-journal or database
      ** file as part of an effort to free up cache space (see function
      ** pagerStress() in pager.c), the rollback is required to restore
      ** the pager to a consistent state.
      */
      if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
        if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
          eStatementOp = SAVEPOINT_ROLLBACK;
        }else{
          /* We are forced to roll back the active transaction. Before doing
          ** so, abort any other statements this handle currently has active.
          */
          sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
          sqlite3CloseSavepoints(db);
          db->autoCommit = 1;
          p->nChange = 0;
        }
      }
    }
 
    /* Check for immediate foreign key violations. */
    if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
      sqlite3VdbeCheckFk(p, 0);
    }
 
    /* If the auto-commit flag is set and this is the only active writer
    ** VM, then we do either a commit or rollback of the current transaction.
    **
    ** Note: This block also runs if one of the special errors handled
    ** above has occurred.
    */
    if( !sqlite3VtabInSync(db)
     && db->autoCommit
     && db->nVdbeWrite==(p->readOnly==0)
    ){
      if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
        rc = sqlite3VdbeCheckFk(p, 1);
        if( rc!=SQLITE_OK ){
          if( NEVER(p->readOnly) ){
            sqlite3VdbeLeave(p);
            return SQLITE_ERROR;
          }
          rc = SQLITE_CONSTRAINT_FOREIGNKEY;
        }else{
          /* The auto-commit flag is true, the vdbe program was successful
          ** or hit an 'OR FAIL' constraint and there are no deferred foreign
          ** key constraints to hold up the transaction. This means a commit
          ** is required. */
          rc = vdbeCommit(db, p);
        }
        if( rc==SQLITE_BUSY && p->readOnly ){
          sqlite3VdbeLeave(p);
          return SQLITE_BUSY;
        }else if( rc!=SQLITE_OK ){
          p->rc = rc;
          sqlite3RollbackAll(db, SQLITE_OK);
          p->nChange = 0;
        }else{
          db->nDeferredCons = 0;
          db->nDeferredImmCons = 0;
          db->flags &= ~(u64)SQLITE_DeferFKs;
          sqlite3CommitInternalChanges(db);
        }
      }else{
        sqlite3RollbackAll(db, SQLITE_OK);
        p->nChange = 0;
      }
      db->nStatement = 0;
    }else if( eStatementOp==0 ){
      if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
        eStatementOp = SAVEPOINT_RELEASE;
      }else if( p->errorAction==OE_Abort ){
        eStatementOp = SAVEPOINT_ROLLBACK;
      }else{
        sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
        sqlite3CloseSavepoints(db);
        db->autoCommit = 1;
        p->nChange = 0;
      }
    }
 
    /* If eStatementOp is non-zero, then a statement transaction needs to
    ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
    ** do so. If this operation returns an error, and the current statement
    ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
    ** current statement error code.
    */
    if( eStatementOp ){
      rc = sqlite3VdbeCloseStatement(p, eStatementOp);
      if( rc ){
        if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
          p->rc = rc;
          sqlite3DbFree(db, p->zErrMsg);
          p->zErrMsg = 0;
        }
        sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
        sqlite3CloseSavepoints(db);
        db->autoCommit = 1;
        p->nChange = 0;
      }
    }
 
    /* If this was an INSERT, UPDATE or DELETE and no statement transaction
    ** has been rolled back, update the database connection change-counter.
    */
    if( p->changeCntOn ){
      if( eStatementOp!=SAVEPOINT_ROLLBACK ){
        sqlite3VdbeSetChanges(db, p->nChange);
      }else{
        sqlite3VdbeSetChanges(db, 0);
      }
      p->nChange = 0;
    }
 
    /* Release the locks */
    sqlite3VdbeLeave(p);
  }
 
  /* We have successfully halted and closed the VM.  Record this fact. */
  if( p->pc>=0 ){
    db->nVdbeActive--;
    if( !p->readOnly ) db->nVdbeWrite--;
    if( p->bIsReader ) db->nVdbeRead--;
    assert( db->nVdbeActive>=db->nVdbeRead );
    assert( db->nVdbeRead>=db->nVdbeWrite );
    assert( db->nVdbeWrite>=0 );
  }
  p->magic = VDBE_MAGIC_HALT;
  checkActiveVdbeCnt(db);
  if( db->mallocFailed ){
    p->rc = SQLITE_NOMEM_BKPT;
  }
 
  /* If the auto-commit flag is set to true, then any locks that were held
  ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
  ** to invoke any required unlock-notify callbacks.
  */
  if( db->autoCommit ){

References sqlite3::autoCommit, Vdbe::bIsReader, Vdbe::changeCntOn, checkActiveVdbeCnt, closeAllCursors(), Vdbe::db, Vdbe::errorAction, sqlite3::flags, Vdbe::magic, sqlite3::mallocFailed, Vdbe::nChange, sqlite3::nDeferredCons, sqlite3::nDeferredImmCons, NEVER, sqlite3::nStatement, sqlite3::nVdbeActive, sqlite3::nVdbeRead, sqlite3::nVdbeWrite, OE_Abort, OE_Fail, Vdbe::pc, Vdbe::rc, Vdbe::readOnly, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, sqlite3CloseSavepoints(), sqlite3CommitInternalChanges(), sqlite3ConnectionUnlocked, sqlite3DbFree(), sqlite3RollbackAll(), sqlite3VdbeCheckFk(), sqlite3VdbeCloseStatement(), sqlite3VdbeEnter(), sqlite3VdbeLeave(), sqlite3VdbeSetChanges(), sqlite3VtabInSync, SQLITE_ABORT_ROLLBACK, SQLITE_BUSY, SQLITE_CONSTRAINT, SQLITE_CONSTRAINT_FOREIGNKEY, SQLITE_DeferFKs, SQLITE_ERROR, SQLITE_FULL, SQLITE_INTERRUPT, SQLITE_IOERR, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, Vdbe::usesStmtJournal, VDBE_MAGIC_HALT, VDBE_MAGIC_RUN, vdbeCommit(), and Vdbe::zErrMsg.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeReset().

◆ sqlite3VdbeHasSubProgram()

SQLITE_PRIVATE int sqlite3VdbeHasSubProgram ( Vdbe * pVdbe )

Definition at line 78926 of file sqlite3.c.

Referenced by sqlite3Insert().

◆ sqlite3VdbeIdxKeyCompare()

SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare	(	sqlite3 *	db,
		VdbeCursor *	pC,
		UnpackedRecord *	pUnpacked,
		int *	res )

Definition at line 82712 of file sqlite3.c.

 {
  i64 nCellKey = 0;
  int rc;
  BtCursor *pCur;
  Mem m;
 
  assert( pC->eCurType==CURTYPE_BTREE );
  pCur = pC->uc.pCursor;
  assert( sqlite3BtreeCursorIsValid(pCur) );
  nCellKey = sqlite3BtreePayloadSize(pCur);
  /* nCellKey will always be between 0 and 0xffffffff because of the way
  ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
  if( nCellKey<=0 || nCellKey>0x7fffffff ){
    *res = 0;
    return SQLITE_CORRUPT_BKPT;
  }
  sqlite3VdbeMemInit(&m, db, 0);
  rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
  if( rc ){

References CURTYPE_BTREE, VdbeCursor::eCurType, sqlite3_value::n, VdbeCursor::pCursor, sqlite3BtreePayloadSize(), sqlite3VdbeMemFromBtreeZeroOffset(), sqlite3VdbeMemInit(), sqlite3VdbeMemRelease(), sqlite3VdbeRecordCompareWithSkip(), SQLITE_CORRUPT_BKPT, SQLITE_OK, VdbeCursor::uc, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeIdxRowid()

SQLITE_PRIVATE int sqlite3VdbeIdxRowid	(	sqlite3 *	db,
		BtCursor *	pCur,
		i64 *	rowid )

Definition at line 82633 of file sqlite3.c.

                                                                               {
  i64 nCellKey = 0;
  int rc;
  u32 szHdr;        /* Size of the header */
  u32 typeRowid;    /* Serial type of the rowid */
  u32 lenRowid;     /* Size of the rowid */
  Mem m, v;
 
  /* Get the size of the index entry.  Only indices entries of less
  ** than 2GiB are support - anything large must be database corruption.
  ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
  ** this code can safely assume that nCellKey is 32-bits
  */
  assert( sqlite3BtreeCursorIsValid(pCur) );
  nCellKey = sqlite3BtreePayloadSize(pCur);
  assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
 
  /* Read in the complete content of the index entry */
  sqlite3VdbeMemInit(&m, db, 0);
  rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
  if( rc ){
    return rc;
  }
 
  /* The index entry must begin with a header size */
  getVarint32NR((u8*)m.z, szHdr);
  testcase( szHdr==3 );
  testcase( szHdr==m.n );
  testcase( szHdr>0x7fffffff );
  assert( m.n>=0 );
  if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){
    goto idx_rowid_corruption;
  }
 
  /* The last field of the index should be an integer - the ROWID.
  ** Verify that the last entry really is an integer. */
  getVarint32NR((u8*)&m.z[szHdr-1], typeRowid);
  testcase( typeRowid==1 );
  testcase( typeRowid==2 );
  testcase( typeRowid==3 );
  testcase( typeRowid==4 );
  testcase( typeRowid==5 );
  testcase( typeRowid==6 );
  testcase( typeRowid==8 );
  testcase( typeRowid==9 );
  if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){
    goto idx_rowid_corruption;
  }
  lenRowid = sqlite3SmallTypeSizes[typeRowid];
  testcase( (u32)m.n==szHdr+lenRowid );
  if( unlikely((u32)m.n<szHdr+lenRowid) ){
    goto idx_rowid_corruption;
  }
 
  /* Fetch the integer off the end of the index record */
  sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
  *rowid = v.u.i;
  sqlite3VdbeMemRelease(&m);
  return SQLITE_OK;
 
  /* Jump here if database corruption is detected after m has been

References getVarint32NR, sqlite3_value::MemValue::i, sqlite3_value::n, sqlite3BtreePayloadSize(), sqlite3SmallTypeSizes, sqlite3VdbeMemFromBtreeZeroOffset(), sqlite3VdbeMemInit(), sqlite3VdbeMemRelease(), sqlite3VdbeSerialGet(), SQLITE_CORRUPT_BKPT, SQLITE_MAX_U32, SQLITE_OK, sqlite3_value::szMalloc, testcase, sqlite3_value::u, unlikely, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeIntegerAffinity()

SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity ( Mem * pMem )

Definition at line 76476 of file sqlite3.c.

                                                         {
  i64 ix;
  assert( pMem->flags & MEM_Real );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
  ix = doubleToInt64(pMem->u.r);
 
  /* Only mark the value as an integer if
  **
  **    (1) the round-trip conversion real->int->real is a no-op, and
  **    (2) The integer is neither the largest nor the smallest
  **        possible integer (ticket #3922)
  **
  ** The second and third terms in the following conditional enforces
  ** the second condition under the assumption that addition overflow causes
  ** values to wrap around.

Referenced by applyAffinity(), and applyNumericAffinity().

◆ sqlite3VdbeIntValue()

SQLITE_PRIVATE i64 sqlite3VdbeIntValue ( Mem * pMem )

Definition at line 76416 of file sqlite3.c.

                                                 {
  i64 value = 0;
  sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
  return value;
}
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & (MEM_Int|MEM_IntReal) ){
    testcase( flags & MEM_IntReal );
    return pMem->u.i;
  }else if( flags & MEM_Real ){
    return doubleToInt64(pMem->u.r);

References sqlite3_value::enc, sqlite3_value::n, sqlite3Atoi64(), value, and sqlite3_value::z.

Referenced by sqlite3_value_subtype(), and sqlite3VdbeExec().

◆ sqlite3VdbeJumpHere()

SQLITE_PRIVATE void sqlite3VdbeJumpHere	(	Vdbe *	p,
		int	addr )

Definition at line 78797 of file sqlite3.c.

Referenced by analyzeOneTable(), codeAllEqualityTerms(), constructAutomaticIndex(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), multiSelect(), multiSelectOrderBy(), selectInnerLoop(), sqlite3CodeRhsOfIN(), sqlite3CodeSubselect(), sqlite3CreateIndex(), sqlite3DeleteFrom(), sqlite3EndTable(), sqlite3ExprCodeGeneratedColumn(), sqlite3ExprCodeIN(), sqlite3ExprCodeRunJustOnce(), sqlite3ExprCodeTarget(), sqlite3FindInIndex(), sqlite3FinishCoding(), sqlite3GenerateConstraintChecks(), sqlite3Insert(), sqlite3Pragma(), sqlite3RefillIndex(), sqlite3Select(), sqlite3SetHasNullFlag(), sqlite3StartTable(), sqlite3UpsertDoUpdate(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), updateVirtualTable(), windowAggFinal(), windowAggStep(), windowCodeRangeTest(), windowFullScan(), and xferOptimization().

◆ sqlite3VdbeJumpHereOrPopInst()

SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst	(	Vdbe *	p,
		int	addr )

Definition at line 78814 of file sqlite3.c.

                                              :
**
**        7   Once 0 8 0
**        8   ...
*/
SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe *p, int addr){
  if( addr==p->nOp-1 ){
    assert( p->aOp[addr].opcode==OP_Once
         || p->aOp[addr].opcode==OP_If
         || p->aOp[addr].opcode==OP_FkIfZero );
    assert( p->aOp[addr].p4type==0 );
#ifdef SQLITE_VDBE_COVERAGE
    sqlite3VdbeGetOp(p,-1)->iSrcLine = 0;  /* Erase VdbeCoverage() macros */

References Vdbe::aOp, Vdbe::nOp, OP_FkIfZero, OP_If, OP_Once, VdbeOp::opcode, VdbeOp::p4type, sqlite3VdbeChangeP2(), and sqlite3VdbeGetOp().

Referenced by fkScanChildren(), sqlite3DeleteFrom(), sqlite3Update(), and updateAccumulator().

◆ sqlite3VdbeLeave()

SQLITE_PRIVATE void sqlite3VdbeLeave ( Vdbe * p )

Definition at line 79556 of file sqlite3.c.

                      {
    if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeLeave(aDb[i].pBt);
    }

References ALWAYS, DbMaskTest, Vdbe::lockMask, and sqlite3BtreeLeave().

Referenced by sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3VdbeLinkSubProgram()

SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram	(	Vdbe *	pVdbe,
		SubProgram *	p )

Definition at line 78918 of file sqlite3.c.

References SubProgram::pNext, and Vdbe::pProgram.

◆ sqlite3VdbeList()

SQLITE_PRIVATE int sqlite3VdbeList ( Vdbe * p )

Definition at line 79834 of file sqlite3.c.

 {
  Mem *pSub = 0;                       /* Memory cell hold array of subprogs */
  sqlite3 *db = p->db;                 /* The database connection */
  int i;                               /* Loop counter */
  int rc = SQLITE_OK;                  /* Return code */
  Mem *pMem = &p->aMem[1];             /* First Mem of result set */
  int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0);
  Op *aOp;                             /* Array of opcodes */
  Op *pOp;                             /* Current opcode */
 
  assert( p->explain );
  assert( p->magic==VDBE_MAGIC_RUN );
  assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
 
  /* Even though this opcode does not use dynamic strings for
  ** the result, result columns may become dynamic if the user calls
  ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
  */
  releaseMemArray(pMem, 8);
  p->pResultSet = 0;
 
  if( p->rc==SQLITE_NOMEM ){
    /* This happens if a malloc() inside a call to sqlite3_column_text() or
    ** sqlite3_column_text16() failed.  */
    sqlite3OomFault(db);
    return SQLITE_ERROR;
  }
 
  if( bListSubprogs ){
    /* The first 8 memory cells are used for the result set.  So we will
    ** commandeer the 9th cell to use as storage for an array of pointers
    ** to trigger subprograms.  The VDBE is guaranteed to have at least 9
    ** cells.  */
    assert( p->nMem>9 );
    pSub = &p->aMem[9];
  }else{
    pSub = 0;
  }
 
  /* Figure out which opcode is next to display */
  rc = sqlite3VdbeNextOpcode(p, pSub, p->explain==2, &p->pc, &i, &aOp);
 
  if( rc==SQLITE_OK ){
    pOp = aOp + i;
    if( AtomicLoad(&db->u1.isInterrupted) ){
      p->rc = SQLITE_INTERRUPT;
      rc = SQLITE_ERROR;
      sqlite3VdbeError(p, sqlite3ErrStr(p->rc));
    }else{
      char *zP4 = sqlite3VdbeDisplayP4(db, pOp);
      if( p->explain==2 ){
        sqlite3VdbeMemSetInt64(pMem, pOp->p1);
        sqlite3VdbeMemSetInt64(pMem+1, pOp->p2);
        sqlite3VdbeMemSetInt64(pMem+2, pOp->p3);
        sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free);
        p->nResColumn = 4;
      }else{
        sqlite3VdbeMemSetInt64(pMem+0, i);
        sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode),
                             -1, SQLITE_UTF8, SQLITE_STATIC);
        sqlite3VdbeMemSetInt64(pMem+2, pOp->p1);
        sqlite3VdbeMemSetInt64(pMem+3, pOp->p2);
        sqlite3VdbeMemSetInt64(pMem+4, pOp->p3);
        /* pMem+5 for p4 is done last */
        sqlite3VdbeMemSetInt64(pMem+6, pOp->p5);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
        {
          char *zCom = sqlite3VdbeDisplayComment(db, pOp, zP4);
          sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free);
        }
#else
        sqlite3VdbeMemSetNull(pMem+7);
#endif
        sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free);
        p->nResColumn = 8;
      }
      p->pResultSet = pMem;
      if( db->mallocFailed ){
        p->rc = SQLITE_NOMEM;
        rc = SQLITE_ERROR;
      }else{
        p->rc = SQLITE_OK;

References Vdbe::aMem, AtomicLoad, Vdbe::db, Vdbe::explain, sqlite3::flags, sqlite3::isInterrupted, Vdbe::magic, sqlite3::mallocFailed, Vdbe::nMem, Vdbe::nResColumn, VdbeOp::opcode, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, VdbeOp::p5, Vdbe::pc, Vdbe::pResultSet, Vdbe::rc, releaseMemArray(), sqlite3_free(), sqlite3ErrStr(), sqlite3OomFault(), sqlite3OpcodeName(), sqlite3VdbeDisplayP4(), sqlite3VdbeError(), sqlite3VdbeMemSetInt64(), sqlite3VdbeMemSetNull(), sqlite3VdbeMemSetStr(), sqlite3VdbeNextOpcode(), SQLITE_BUSY, SQLITE_ERROR, SQLITE_INTERRUPT, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, SQLITE_STATIC, SQLITE_TriggerEQP, SQLITE_UTF8, sqlite3::u1, and VDBE_MAGIC_RUN.

Referenced by sqlite3Step().

◆ sqlite3VdbeLoadString()

SQLITE_PRIVATE int sqlite3VdbeLoadString	(	Vdbe *	p,
		int	iDest,
		const char *	zStr )

Definition at line 78022 of file sqlite3.c.

Referenced by analyzeOneTable(), sqlite3ExprCodeTarget(), and sqlite3Pragma().

◆ sqlite3VdbeMakeLabel()

SQLITE_PRIVATE int sqlite3VdbeMakeLabel ( Parse * pParse )

◆ sqlite3VdbeMakeReady()

SQLITE_PRIVATE void sqlite3VdbeMakeReady	(	Vdbe *	p,
		Parse *	pParse )

Definition at line 80075 of file sqlite3.c.

 {
  sqlite3 *db;                   /* The database connection */
  int nVar;                      /* Number of parameters */
  int nMem;                      /* Number of VM memory registers */
  int nCursor;                   /* Number of cursors required */
  int nArg;                      /* Number of arguments in subprograms */
  int n;                         /* Loop counter */
  struct ReusableSpace x;        /* Reusable bulk memory */
 
  assert( p!=0 );
  assert( p->nOp>0 );
  assert( pParse!=0 );
  assert( p->magic==VDBE_MAGIC_INIT );
  assert( pParse==p->pParse );
  db = p->db;
  assert( db->mallocFailed==0 );
  nVar = pParse->nVar;
  nMem = pParse->nMem;
  nCursor = pParse->nTab;
  nArg = pParse->nMaxArg;
 
  /* Each cursor uses a memory cell.  The first cursor (cursor 0) can
  ** use aMem[0] which is not otherwise used by the VDBE program.  Allocate
  ** space at the end of aMem[] for cursors 1 and greater.
  ** See also: allocateCursor().
  */
  nMem += nCursor;
  if( nCursor==0 && nMem>0 ) nMem++;  /* Space for aMem[0] even if not used */
 
  /* Figure out how much reusable memory is available at the end of the
  ** opcode array.  This extra memory will be reallocated for other elements
  ** of the prepared statement.
  */
  n = ROUND8(sizeof(Op)*p->nOp);              /* Bytes of opcode memory used */
  x.pSpace = &((u8*)p->aOp)[n];               /* Unused opcode memory */
  assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
  x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n);  /* Bytes of unused memory */
  assert( x.nFree>=0 );
  assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
 
  resolveP2Values(p, &nArg);
  p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
  if( pParse->explain ){
    static const char * const azColName[] = {
       "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
       "id", "parent", "notused", "detail"
    };
    int iFirst, mx, i;
    if( nMem<10 ) nMem = 10;
    p->explain = pParse->explain;
    if( pParse->explain==2 ){
      sqlite3VdbeSetNumCols(p, 4);
      iFirst = 8;
      mx = 12;
    }else{
      sqlite3VdbeSetNumCols(p, 8);
      iFirst = 0;
      mx = 8;
    }
    for(i=iFirst; i<mx; i++){
      sqlite3VdbeSetColName(p, i-iFirst, COLNAME_NAME,
                            azColName[i], SQLITE_STATIC);
    }
  }
  p->expired = 0;
 
  /* Memory for registers, parameters, cursor, etc, is allocated in one or two
  ** passes.  On the first pass, we try to reuse unused memory at the
  ** end of the opcode array.  If we are unable to satisfy all memory
  ** requirements by reusing the opcode array tail, then the second
  ** pass will fill in the remainder using a fresh memory allocation.
  **
  ** This two-pass approach that reuses as much memory as possible from
  ** the leftover memory at the end of the opcode array.  This can significantly
  ** reduce the amount of memory held by a prepared statement.
  */
  x.nNeeded = 0;
  p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem));
  p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
  p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
  p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));
#endif
  if( x.nNeeded ){
    x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
    x.nFree = x.nNeeded;
    if( !db->mallocFailed ){
      p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
      p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
      p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
      p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
      p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
#endif
    }
  }
 
  p->pVList = pParse->pVList;
  pParse->pVList =  0;
  if( db->mallocFailed ){
    p->nVar = 0;
    p->nCursor = 0;
    p->nMem = 0;
  }else{
    p->nCursor = nCursor;
    p->nVar = (ynVar)nVar;
    initMemArray(p->aVar, nVar, db, MEM_Null);
    p->nMem = nMem;
    initMemArray(p->aMem, nMem, db, MEM_Undefined);
    memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));

References allocSpace(), Vdbe::aMem, Vdbe::aOp, Vdbe::apArg, Vdbe::apCsr, Vdbe::aVar, COLNAME_NAME, Vdbe::db, EIGHT_BYTE_ALIGNMENT, Vdbe::expired, Parse::explain, Vdbe::explain, initMemArray(), Parse::isMultiWrite, Vdbe::magic, sqlite3::mallocFailed, Parse::mayAbort, MEM_Null, MEM_Undefined, Vdbe::nCursor, ReusableSpace::nFree, Parse::nMaxArg, Parse::nMem, Vdbe::nMem, ReusableSpace::nNeeded, Vdbe::nOp, Parse::nTab, Parse::nVar, Vdbe::nVar, Vdbe::pFree, Vdbe::pParse, ReusableSpace::pSpace, Parse::pVList, Vdbe::pVList, resolveP2Values(), ROUND8, ROUNDDOWN8, sqlite3DbMallocRawNN(), sqlite3VdbeRewind(), sqlite3VdbeSetColName(), sqlite3VdbeSetNumCols(), SQLITE_STATIC, Parse::szOpAlloc, Vdbe::usesStmtJournal, and VDBE_MAGIC_INIT.

Referenced by sqlite3FinishCoding().

◆ sqlite3VdbeMemAggValue()

SQLITE_PRIVATE int sqlite3VdbeMemAggValue	(	Mem *	pAccum,
		Mem *	pOut,
		FuncDef *	pFunc )

Definition at line 76294 of file sqlite3.c.

                                                                                 {
  sqlite3_context ctx;
  assert( pFunc!=0 );
  assert( pFunc->xValue!=0 );
  assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
  assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
  memset(&ctx, 0, sizeof(ctx));
  sqlite3VdbeMemSetNull(pOut);

References sqlite3_value::db, sqlite3_value::flags, sqlite3_context::isError, MEM_Null, sqlite3::mutex, sqlite3_value::MemValue::pDef, sqlite3_context::pFunc, sqlite3_context::pMem, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3VdbeMemSetNull(), sqlite3_value::u, and FuncDef::xValue.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemCast()

SQLITE_PRIVATE int sqlite3VdbeMemCast	(	Mem *	pMem,
		u8	aff,
		u8	encoding )

Definition at line 76583 of file sqlite3.c.

                                                                     {
  if( pMem->flags & MEM_Null ) return SQLITE_OK;
  switch( aff ){
    case SQLITE_AFF_BLOB: {   /* Really a cast to BLOB */
      if( (pMem->flags & MEM_Blob)==0 ){
        sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
        assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
        if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
      }else{
        pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
      }
      break;
    }
    case SQLITE_AFF_NUMERIC: {
      sqlite3VdbeMemNumerify(pMem);
      break;
    }
    case SQLITE_AFF_INTEGER: {
      sqlite3VdbeMemIntegerify(pMem);
      break;
    }
    case SQLITE_AFF_REAL: {
      sqlite3VdbeMemRealify(pMem);
      break;
    }
    default: {
      assert( aff==SQLITE_AFF_TEXT );
      assert( MEM_Str==(MEM_Blob>>3) );
      pMem->flags |= (pMem->flags&MEM_Blob)>>3;
      sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
      assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );

References sqlite3_value::db, sqlite3_value::flags, sqlite3::mallocFailed, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, MEM_TypeMask, MEM_Zero, MemSetTypeFlag, sqlite3ValueApplyAffinity(), sqlite3VdbeChangeEncoding(), sqlite3VdbeMemIntegerify(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemRealify(), SQLITE_AFF_BLOB, SQLITE_AFF_INTEGER, SQLITE_AFF_NUMERIC, SQLITE_AFF_REAL, SQLITE_AFF_TEXT, and SQLITE_OK.

Referenced by sqlite3VdbeExec(), and valueFromExpr().

◆ sqlite3VdbeMemClearAndResize()

SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize	(	Mem *	pMem,
		int	n )

Definition at line 76116 of file sqlite3.c.

                                                                     {
  assert( CORRUPT_DB || szNew>0 );
  assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
  if( pMem->szMalloc<szNew ){
    return sqlite3VdbeMemGrow(pMem, szNew, 0);

References CORRUPT_DB, sqlite3_value::flags, MEM_Dyn, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, sqlite3VdbeMemGrow(), SQLITE_OK, sqlite3_value::szMalloc, sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by allocateCursor(), sqlite3VdbeExec(), sqlite3VdbeMemFromBtree(), sqlite3VdbeMemSetStr(), and sqlite3VdbeMemStringify().

◆ sqlite3VdbeMemCopy()

SQLITE_PRIVATE int sqlite3VdbeMemCopy	(	Mem *	pTo,
		const Mem *	pFrom )

Definition at line 76843 of file sqlite3.c.

                                                                 {
  int rc = SQLITE_OK;
 
  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
  if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
  memcpy(pTo, pFrom, MEMCELLSIZE);
  pTo->flags &= ~MEM_Dyn;
  if( pTo->flags&(MEM_Str|MEM_Blob) ){
    if( 0==(pFrom->flags&MEM_Static) ){
      pTo->flags |= MEM_Ephem;

Referenced by minmaxStep(), sqlite3VdbeExec(), and sqlite3VdbeGetBoundValue().

◆ sqlite3VdbeMemExpandBlob()

SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob ( Mem * pMem )

Definition at line 76177 of file sqlite3.c.

                                                      {
  int nByte;
  assert( pMem->flags & MEM_Zero );
  assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
  testcase( sqlite3_value_nochange(pMem) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
 
  /* Set nByte to the number of bytes required to store the expanded blob. */
  nByte = pMem->n + pMem->u.nZero;
  if( nByte<=0 ){
    if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
    nByte = 1;
  }
  if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
    return SQLITE_NOMEM_BKPT;
  }

References sqlite3_value::db, sqlite3_value::flags, MEM_Blob, MEM_Term, MEM_Zero, MemNullNochng, sqlite3::mutex, sqlite3_value::n, sqlite3_value::MemValue::nZero, sqlite3_mutex_held(), sqlite3_value_nochange(), sqlite3VdbeMemGrow(), SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, sqlite3_value::u, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemFinalize()

SQLITE_PRIVATE int sqlite3VdbeMemFinalize	(	Mem *	pMem,
		FuncDef *	pFunc )

Definition at line 76264 of file sqlite3.c.

                                                                    {
  sqlite3_context ctx;
  Mem t;
  assert( pFunc!=0 );
  assert( pFunc->xFinalize!=0 );
  assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  memset(&ctx, 0, sizeof(ctx));
  memset(&t, 0, sizeof(t));
  t.flags = MEM_Null;
  t.db = pMem->db;
  ctx.pOut = &t;
  ctx.pMem = pMem;
  ctx.pFunc = pFunc;

References sqlite3_value::db, sqlite3_value::flags, sqlite3_context::isError, MEM_Dyn, MEM_Null, sqlite3::mutex, sqlite3_value::MemValue::pDef, sqlite3_context::pFunc, sqlite3_context::pMem, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3DbFreeNN(), sqlite3_value::szMalloc, sqlite3_value::u, FuncDef::xFinalize, and sqlite3_value::zMalloc.

Referenced by sqlite3VdbeExec(), and vdbeMemClearExternAndSetNull().

◆ sqlite3VdbeMemFromBtree()

SQLITE_PRIVATE int sqlite3VdbeMemFromBtree	(	BtCursor *	pCur,
		u32	offset,
		u32	amt,
		Mem *	pMem )

Definition at line 77000 of file sqlite3.c.

 {
  int rc;
  pMem->flags = MEM_Null;
  if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
    return SQLITE_CORRUPT_BKPT;
  }
  if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
    rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
    if( rc==SQLITE_OK ){
      pMem->z[amt] = 0;   /* Overrun area used when reading malformed records */
      pMem->flags = MEM_Blob;
      pMem->n = (int)amt;

References sqlite3_value::flags, MEM_Blob, MEM_Null, sqlite3_value::n, sqlite3BtreeMaxRecordSize(), sqlite3BtreePayload(), sqlite3VdbeMemClearAndResize(), SQLITE_CORRUPT_BKPT, SQLITE_OK, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemFromBtreeZeroOffset()

SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset	(	BtCursor *	pCur,
		u32	amt,
		Mem *	pMem )

Definition at line 77023 of file sqlite3.c.

         {
      sqlite3VdbeMemRelease(pMem);
    }
  }
  return rc;
}
SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset(
  BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
  u32 amt,          /* Number of bytes to return. */
  Mem *pMem         /* OUT: Return data in this Mem structure. */
){
  u32 available = 0;  /* Number of bytes available on the local btree page */
  int rc = SQLITE_OK; /* Return code */
 
  assert( sqlite3BtreeCursorIsValid(pCur) );
  assert( !VdbeMemDynamic(pMem) );
 
  /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
  ** that both the BtShared and database handle mutexes are held. */
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
  assert( pMem->z!=0 );
 
  if( amt<=available ){
    pMem->flags = MEM_Blob|MEM_Ephem;
    pMem->n = (int)amt;

Referenced by sqlite3VdbeExec(), sqlite3VdbeIdxKeyCompare(), and sqlite3VdbeIdxRowid().

◆ sqlite3VdbeMemGrow()

SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow	(	Mem *	pMem,
		int	n,
		int	preserve )

Definition at line 76055 of file sqlite3.c.

                                                                                      {
  assert( sqlite3VdbeCheckMemInvariants(pMem) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  testcase( pMem->db==0 );
 
  /* If the bPreserve flag is set to true, then the memory cell must already
  ** contain a valid string or blob value.  */
  assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
  testcase( bPreserve && pMem->z==0 );
 
  assert( pMem->szMalloc==0
       || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
  if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
    if( pMem->db ){
      pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
    }else{
      pMem->zMalloc = sqlite3Realloc(pMem->z, n);
      if( pMem->zMalloc==0 ) sqlite3_free(pMem->z);
      pMem->z = pMem->zMalloc;
    }
    bPreserve = 0;
  }else{
    if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
    pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
  }
  if( pMem->zMalloc==0 ){
    sqlite3VdbeMemSetNull(pMem);
    pMem->z = 0;
    pMem->szMalloc = 0;
    return SQLITE_NOMEM_BKPT;
  }else{
    pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
  }
 
  if( bPreserve && pMem->z ){
    assert( pMem->z!=pMem->zMalloc );
    memcpy(pMem->zMalloc, pMem->z, pMem->n);
  }
  if( (pMem->flags&MEM_Dyn)!=0 ){
    assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
    pMem->xDel((void *)(pMem->z));

References sqlite3_value::db, sqlite3_value::flags, MEM_Blob, MEM_Dyn, MEM_Ephem, MEM_Static, MEM_Str, sqlite3_value::n, sqlite3_free(), sqlite3DbFreeNN(), sqlite3DbMallocRaw(), sqlite3DbMallocSize(), sqlite3DbReallocOrFree(), sqlite3Realloc(), sqlite3VdbeMemSetNull(), SQLITE_DYNAMIC, SQLITE_NOMEM_BKPT, SQLITE_OK, sqlite3_value::szMalloc, testcase, sqlite3_value::xDel, sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemExpandBlob(), sqlite3VdbeNextOpcode(), and vdbeMemAddTerminator().

◆ sqlite3VdbeMemHandleBom()

SQLITE_PRIVATE int sqlite3VdbeMemHandleBom ( Mem * pMem )

Definition at line 31019 of file sqlite3.c.

                                                     {
  int rc = SQLITE_OK;
  u8 bom = 0;
 
  assert( pMem->n>=0 );
  if( pMem->n>1 ){
    u8 b1 = *(u8 *)pMem->z;
    u8 b2 = *(((u8 *)pMem->z) + 1);
    if( b1==0xFE && b2==0xFF ){
      bom = SQLITE_UTF16BE;
    }
    if( b1==0xFF && b2==0xFE ){
      bom = SQLITE_UTF16LE;
    }
  }
 
  if( bom ){
    rc = sqlite3VdbeMemMakeWriteable(pMem);
    if( rc==SQLITE_OK ){
      pMem->n -= 2;
      memmove(pMem->z, &pMem->z[2], pMem->n);
      pMem->z[pMem->n] = '\0';
      pMem->z[pMem->n+1] = '\0';

References sqlite3_value::enc, sqlite3_value::flags, MEM_Term, sqlite3_value::n, sqlite3VdbeMemMakeWriteable(), SQLITE_OK, SQLITE_UTF16BE, SQLITE_UTF16LE, and sqlite3_value::z.

Referenced by sqlite3VdbeMemSetStr().

◆ sqlite3VdbeMemInit()

SQLITE_PRIVATE void sqlite3VdbeMemInit	(	Mem *	pMem,
		sqlite3 *	db,
		u16	flags )

Definition at line 76626 of file sqlite3.c.

References sqlite3_value::db, sqlite3_value::flags, MEM_TypeMask, and sqlite3_value::szMalloc.

Referenced by sqlite3VdbeExec(), sqlite3VdbeIdxKeyCompare(), sqlite3VdbeIdxRowid(), and vdbeCompareMemString().

◆ sqlite3VdbeMemIntegerify()

SQLITE_PRIVATE int sqlite3VdbeMemIntegerify ( Mem * pMem )

Definition at line 76504 of file sqlite3.c.

                                                      {
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );

Referenced by sqlite3VdbeExec(), and sqlite3VdbeMemCast().

◆ sqlite3VdbeMemMakeWriteable()

SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable ( Mem * pMem )

Definition at line 76154 of file sqlite3.c.

                                                         {
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
    if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
    if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
      int rc = vdbeMemAddTerminator(pMem);
      if( rc ) return rc;
    }
  }
  pMem->flags &= ~MEM_Ephem;

References sqlite3_value::db, ExpandBlob, sqlite3_value::flags, MEM_Blob, MEM_Str, sqlite3::mutex, sqlite3_mutex_held(), SQLITE_NOMEM, SQLITE_OK, sqlite3_value::szMalloc, vdbeMemAddTerminator(), sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by sqlite3VdbeMemHandleBom(), sqlite3VdbeMemTranslate(), and valueToText().

◆ sqlite3VdbeMemMove()

SQLITE_PRIVATE void sqlite3VdbeMemMove	(	Mem *	pTo,
		Mem *	pFrom )

Definition at line 76866 of file sqlite3.c.

                                                            {
  assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
  assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
  assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );

References sqlite3_value::db, sqlite3_value::flags, MEM_Null, sqlite3::mutex, sqlite3_mutex_held(), sqlite3VdbeMemRelease(), and sqlite3_value::szMalloc.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemNulTerminate()

SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate ( Mem * pMem )

Definition at line 76205 of file sqlite3.c.

                                                        {
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
  testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );

Referenced by sqlite3VdbeExec(), and valueToText().

◆ sqlite3VdbeMemNumerify()

SQLITE_PRIVATE int sqlite3VdbeMemNumerify ( Mem * pMem )

Definition at line 76551 of file sqlite3.c.

                                                    {
  testcase( pMem->flags & MEM_Int );
  testcase( pMem->flags & MEM_Real );
  testcase( pMem->flags & MEM_IntReal );
  testcase( pMem->flags & MEM_Null );
  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
    int rc;
    sqlite3_int64 ix;
    assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
    rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
    if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
     || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r))
    ){
      pMem->u.i = ix;
      MemSetTypeFlag(pMem, MEM_Int);
    }else{
      MemSetTypeFlag(pMem, MEM_Real);

References sqlite3_value::db, sqlite3_value::enc, sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, MEM_Zero, MemSetTypeFlag, sqlite3::mutex, sqlite3_value::n, sqlite3_value::MemValue::r, sqlite3_mutex_held(), sqlite3AtoF(), sqlite3Atoi64(), sqlite3RealSameAsInt(), SQLITE_OK, testcase, sqlite3_value::u, and sqlite3_value::z.

Referenced by sqlite3VdbeMemCast(), and valueFromExpr().

◆ sqlite3VdbeMemRealify()

SQLITE_PRIVATE int sqlite3VdbeMemRealify ( Mem * pMem )

Definition at line 76518 of file sqlite3.c.

76524 {

76525 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

Referenced by sqlite3VdbeExec(), and sqlite3VdbeMemCast().

◆ sqlite3VdbeMemRelease()

SQLITE_PRIVATE void sqlite3VdbeMemRelease ( Mem * p )

Definition at line 76363 of file sqlite3.c.

References sqlite3_value::szMalloc, vdbeMemClear(), and VdbeMemDynamic.

Referenced by sqlite3Utf16to8(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeIdxKeyCompare(), sqlite3VdbeIdxRowid(), sqlite3VdbeMemMove(), sqlite3VdbeMemSetRowSet(), sqlite3VdbeMemSetStr(), sqlite3VdbeMemTranslate(), vdbeCompareMemString(), and vdbeUnbind().

◆ sqlite3VdbeMemSetDouble()

SQLITE_PRIVATE void sqlite3VdbeMemSetDouble	(	Mem *	pMem,
		double	val )

Definition at line 76721 of file sqlite3.c.

76727 {

References sqlite3_value::flags, MEM_Real, sqlite3_value::MemValue::r, sqlite3IsNaN(), sqlite3VdbeMemSetNull(), and sqlite3_value::u.

Referenced by sqlite3_bind_int().

◆ sqlite3VdbeMemSetInt64()

SQLITE_PRIVATE void sqlite3VdbeMemSetInt64	(	Mem *	pMem,
		i64	val )

Definition at line 76686 of file sqlite3.c.

76692 {

76693 if( VdbeMemDynamic(pMem) ){

Referenced by sqlite3_bind_null(), sqlite3VdbeExec(), sqlite3VdbeList(), and valueFromExpr().

◆ sqlite3VdbeMemSetNull()

SQLITE_PRIVATE void sqlite3VdbeMemSetNull ( Mem * pMem )

Definition at line 76646 of file sqlite3.c.

76652 {

Referenced by out2Prerelease(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3VdbeMemAggValue(), sqlite3VdbeMemGrow(), sqlite3VdbeMemSetDouble(), sqlite3VdbeMemSetStr(), sqlite3VdbeRecordUnpack(), valueFromExpr(), and vdbeReleaseAndSetInt64().

◆ sqlite3VdbeMemSetPointer()

SQLITE_PRIVATE void sqlite3VdbeMemSetPointer	(	Mem *	pMem,
		void *	pPtr,
		const char *	zPType,
		void()(void )	xDestructor )

Definition at line 76702 of file sqlite3.c.

                                                  { UNUSED_PARAMETER(p); }
 
/*
** Set the value stored in *pMem should already be a NULL.
** Also store a pointer to go with it.
*/
SQLITE_PRIVATE void sqlite3VdbeMemSetPointer(
  Mem *pMem,
  void *pPtr,
  const char *zPType,
  void (*xDestructor)(void*)
){
  assert( pMem->flags==MEM_Null );

References UNUSED_PARAMETER.

◆ sqlite3VdbeMemSetRowSet()

SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet ( Mem * pMem )

Definition at line 76748 of file sqlite3.c.

                                                     {
  sqlite3 *db = pMem->db;
  RowSet *p;
  assert( db!=0 );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  sqlite3VdbeMemRelease(pMem);
  p = sqlite3RowSetInit(db);

References sqlite3_value::db, sqlite3_value::flags, MEM_Blob, MEM_Dyn, sqlite3RowSetDelete(), sqlite3RowSetInit(), sqlite3VdbeMemRelease(), SQLITE_NOMEM, SQLITE_OK, sqlite3_value::xDel, and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemSetStr()

SQLITE_PRIVATE int sqlite3VdbeMemSetStr	(	Mem *	pMem,
		const char *	z,
		int	n,
		u8	enc,
		void()(void )	xDel )

Definition at line 76892 of file sqlite3.c.

 {
  int nByte = n;      /* New value for pMem->n */
  int iLimit;         /* Maximum allowed string or blob size */
  u16 flags = 0;      /* New value for pMem->flags */
 
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
 
  /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
  if( !z ){
    sqlite3VdbeMemSetNull(pMem);
    return SQLITE_OK;
  }
 
  if( pMem->db ){
    iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
  }else{
    iLimit = SQLITE_MAX_LENGTH;
  }
  flags = (enc==0?MEM_Blob:MEM_Str);
  if( nByte<0 ){
    assert( enc!=0 );
    if( enc==SQLITE_UTF8 ){
      nByte = 0x7fffffff & (int)strlen(z);
    }else{
      for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
    }
    flags |= MEM_Term;
  }
 
  /* The following block sets the new values of Mem.z and Mem.xDel. It
  ** also sets a flag in local variable "flags" to indicate the memory
  ** management (one of MEM_Dyn or MEM_Static).
  */
  if( xDel==SQLITE_TRANSIENT ){
    u32 nAlloc = nByte;
    if( flags&MEM_Term ){
      nAlloc += (enc==SQLITE_UTF8?1:2);
    }
    if( nByte>iLimit ){
      return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
    }
    testcase( nAlloc==0 );
    testcase( nAlloc==31 );
    testcase( nAlloc==32 );
    if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){
      return SQLITE_NOMEM_BKPT;
    }
    memcpy(pMem->z, z, nAlloc);
  }else{
    sqlite3VdbeMemRelease(pMem);
    pMem->z = (char *)z;
    if( xDel==SQLITE_DYNAMIC ){
      pMem->zMalloc = pMem->z;
      pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
    }else{
      pMem->xDel = xDel;
      flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
    }
  }
 
  pMem->n = nByte;
  pMem->flags = flags;
  if( enc ){
    pMem->enc = enc;
#ifdef SQLITE_ENABLE_SESSION
  }else if( pMem->db==0 ){
    pMem->enc = SQLITE_UTF8;
#endif
  }else{
    assert( pMem->db!=0 );
    pMem->enc = ENC(pMem->db);
  }
 
#ifndef SQLITE_OMIT_UTF16
  if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
    return SQLITE_NOMEM_BKPT;
  }
#endif
 

References sqlite3::aLimit, sqlite3_value::db, ENC, sqlite3_value::enc, sqlite3_value::flags, MAX, MEM_Blob, MEM_Dyn, MEM_Static, MEM_Str, MEM_Term, sqlite3::mutex, sqlite3_value::n, sqlite3_mutex_held(), sqlite3DbMallocSize(), sqlite3ErrorToParser(), sqlite3VdbeMemClearAndResize(), sqlite3VdbeMemHandleBom(), sqlite3VdbeMemRelease(), sqlite3VdbeMemSetNull(), SQLITE_DYNAMIC, SQLITE_LIMIT_LENGTH, SQLITE_MAX_LENGTH, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_STATIC, SQLITE_TOOBIG, SQLITE_TRANSIENT, SQLITE_UTF8, sqlite3_value::szMalloc, testcase, sqlite3_value::xDel, sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by invokeValueDestructor(), sqlite3_result_error16(), sqlite3_result_int(), sqlite3Utf16to8(), sqlite3VdbeExec(), sqlite3VdbeExpandSql(), sqlite3VdbeList(), sqlite3VdbeSetColName(), and valueFromExpr().

◆ sqlite3VdbeMemSetZeroBlob()

SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob	(	Mem *	pMem,
		int	n )

Definition at line 76661 of file sqlite3.c.

                                                               {
  sqlite3VdbeMemRelease(pMem);
  pMem->flags = MEM_Blob|MEM_Zero;

Referenced by sqlite3_bind_zeroblob64().

◆ sqlite3VdbeMemShallowCopy()

SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy	(	Mem *	pTo,
		const Mem *	pFrom,
		int	srcType )

Definition at line 76827 of file sqlite3.c.

                                                                              {
  vdbeMemClearExternAndSetNull(pTo);
  assert( !VdbeMemDynamic(pTo) );
  sqlite3VdbeMemShallowCopy(pTo, pFrom, eType);
}
SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
  assert( pTo->db==pFrom->db );
  if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
  memcpy(pTo, pFrom, MEMCELLSIZE);

References eType, sqlite3VdbeMemShallowCopy(), vdbeMemClearExternAndSetNull(), and VdbeMemDynamic.

Referenced by sqlite3VdbeExec(), sqlite3VdbeMemShallowCopy(), and vdbeCompareMemString().

◆ sqlite3VdbeMemStringify()

SQLITE_PRIVATE int sqlite3VdbeMemStringify	(	Mem *	pMem,
		u8	enc,
		u8	bForce )

Definition at line 76230 of file sqlite3.c.

                                                                        {
  const int nByte = 32;
 
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !(pMem->flags&MEM_Zero) );
  assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
  assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
 
  if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
    pMem->enc = 0;
    return SQLITE_NOMEM_BKPT;
  }
 
  vdbeMemRenderNum(nByte, pMem->z, pMem);
  assert( pMem->z!=0 );
  pMem->n = sqlite3Strlen30NN(pMem->z);

References sqlite3_value::db, EIGHT_BYTE_ALIGNMENT, sqlite3_value::enc, sqlite3_value::flags, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Real, MEM_Str, MEM_Term, MEM_Zero, sqlite3::mutex, sqlite3_value::n, sqlite3_mutex_held(), sqlite3Strlen30NN, sqlite3VdbeChangeEncoding(), sqlite3VdbeMemClearAndResize(), SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_UTF8, vdbeMemRenderNum(), and sqlite3_value::z.

Referenced by applyAffinity(), sqlite3VdbeExec(), and valueToText().

◆ sqlite3VdbeMemTooBig()

SQLITE_PRIVATE int sqlite3VdbeMemTooBig ( Mem * p )

Definition at line 76766 of file sqlite3.c.

                                               {
  assert( p->db!=0 );
  if( p->flags & (MEM_Str|MEM_Blob) ){
    int n = p->n;
    if( p->flags & MEM_Zero ){

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeMemTranslate()

SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate	(	Mem *	pMem,
		u8	desiredEnc )

Definition at line 30824 of file sqlite3.c.

                                                                                    {
  sqlite3_int64 len;          /* Maximum length of output string in bytes */
  unsigned char *zOut;        /* Output buffer */
  unsigned char *zIn;         /* Input iterator */
  unsigned char *zTerm;       /* End of input */
  unsigned char *z;           /* Output iterator */
  unsigned int c;
 
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( pMem->flags&MEM_Str );
  assert( pMem->enc!=desiredEnc );
  assert( pMem->enc!=0 );
  assert( pMem->n>=0 );
 
#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
  {
    StrAccum acc;
    char zBuf[1000];
    sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
    sqlite3VdbeMemPrettyPrint(pMem, &acc);
    fprintf(stderr, "INPUT:  %s\n", sqlite3StrAccumFinish(&acc));
  }
#endif
 
  /* If the translation is between UTF-16 little and big endian, then
  ** all that is required is to swap the byte order. This case is handled
  ** differently from the others.
  */
  if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
    u8 temp;
    int rc;
    rc = sqlite3VdbeMemMakeWriteable(pMem);
    if( rc!=SQLITE_OK ){
      assert( rc==SQLITE_NOMEM );
      return SQLITE_NOMEM_BKPT;
    }
    zIn = (u8*)pMem->z;
    zTerm = &zIn[pMem->n&~1];
    while( zIn<zTerm ){
      temp = *zIn;
      *zIn = *(zIn+1);
      zIn++;
      *zIn++ = temp;
    }
    pMem->enc = desiredEnc;
    goto translate_out;
  }
 
  /* Set len to the maximum number of bytes required in the output buffer. */
  if( desiredEnc==SQLITE_UTF8 ){
    /* When converting from UTF-16, the maximum growth results from
    ** translating a 2-byte character to a 4-byte UTF-8 character.
    ** A single byte is required for the output string
    ** nul-terminator.
    */
    pMem->n &= ~1;
    len = 2 * (sqlite3_int64)pMem->n + 1;
  }else{
    /* When converting from UTF-8 to UTF-16 the maximum growth is caused
    ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
    ** character. Two bytes are required in the output buffer for the
    ** nul-terminator.
    */
    len = 2 * (sqlite3_int64)pMem->n + 2;
  }
 
  /* Set zIn to point at the start of the input buffer and zTerm to point 1
  ** byte past the end.
  **
  ** Variable zOut is set to point at the output buffer, space obtained
  ** from sqlite3_malloc().
  */
  zIn = (u8*)pMem->z;
  zTerm = &zIn[pMem->n];
  zOut = sqlite3DbMallocRaw(pMem->db, len);
  if( !zOut ){
    return SQLITE_NOMEM_BKPT;
  }
  z = zOut;
 
  if( pMem->enc==SQLITE_UTF8 ){
    if( desiredEnc==SQLITE_UTF16LE ){
      /* UTF-8 -> UTF-16 Little-endian */
      while( zIn<zTerm ){
        READ_UTF8(zIn, zTerm, c);
        WRITE_UTF16LE(z, c);
      }
    }else{
      assert( desiredEnc==SQLITE_UTF16BE );
      /* UTF-8 -> UTF-16 Big-endian */
      while( zIn<zTerm ){
        READ_UTF8(zIn, zTerm, c);
        WRITE_UTF16BE(z, c);
      }
    }
    pMem->n = (int)(z - zOut);
    *z++ = 0;
  }else{
    assert( desiredEnc==SQLITE_UTF8 );
    if( pMem->enc==SQLITE_UTF16LE ){
      /* UTF-16 Little-endian -> UTF-8 */
      while( zIn<zTerm ){
        c = *(zIn++);
        c += (*(zIn++))<<8;
        if( c>=0xd800 && c<0xe000 ){
#ifdef SQLITE_REPLACE_INVALID_UTF
          if( c>=0xdc00 || zIn>=zTerm ){
            c = 0xfffd;
          }else{
            int c2 = *(zIn++);
            c2 += (*(zIn++))<<8;
            if( c2<0xdc00 || c2>=0xe000 ){
              zIn -= 2;
              c = 0xfffd;
            }else{
              c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000;
            }
          }
#else
          if( zIn<zTerm ){
            int c2 = (*zIn++);
            c2 += ((*zIn++)<<8);
            c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);
          }
#endif
        }
        WRITE_UTF8(z, c);
      }
    }else{
      /* UTF-16 Big-endian -> UTF-8 */
      while( zIn<zTerm ){
        c = (*(zIn++))<<8;
        c += *(zIn++);
        if( c>=0xd800 && c<0xe000 ){
#ifdef SQLITE_REPLACE_INVALID_UTF
          if( c>=0xdc00 || zIn>=zTerm ){
            c = 0xfffd;
          }else{
            int c2 = (*(zIn++))<<8;
            c2 += *(zIn++);
            if( c2<0xdc00 || c2>=0xe000 ){
              zIn -= 2;
              c = 0xfffd;
            }else{
              c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000;
            }
          }
#else
          if( zIn<zTerm ){
            int c2 = ((*zIn++)<<8);
            c2 += (*zIn++);
            c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);
          }
#endif
        }
        WRITE_UTF8(z, c);
      }
    }
    pMem->n = (int)(z - zOut);
  }
  *z = 0;
  assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
 
  c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype));
  sqlite3VdbeMemRelease(pMem);
  pMem->flags = c;
  pMem->enc = desiredEnc;
  pMem->z = (char*)zOut;
  pMem->zMalloc = pMem->z;
  pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z);
 
translate_out:
#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
  {
    StrAccum acc;
    char zBuf[1000];
    sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);

References sqlite3_value::db, sqlite3_value::enc, sqlite3_value::flags, MEM_AffMask, MEM_Str, MEM_Subtype, MEM_Term, sqlite3::mutex, sqlite3_value::n, READ_UTF8, sqlite3_mutex_held(), sqlite3DbMallocRaw(), sqlite3DbMallocSize(), sqlite3StrAccumFinish(), sqlite3StrAccumInit(), sqlite3VdbeMemMakeWriteable(), sqlite3VdbeMemRelease(), SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, sqlite3_value::szMalloc, WRITE_UTF16BE, WRITE_UTF16LE, WRITE_UTF8, sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by sqlite3VdbeChangeEncoding().

◆ sqlite3VdbeMultiLoad()

SQLITE_PRIVATE void sqlite3VdbeMultiLoad	(	Vdbe *	p,
		int	iDest,
		const char *	zTypes,
			... )

Definition at line 78037 of file sqlite3.c.

                                                                                     {
  va_list ap;
  int i;
  char c;
  va_start(ap, zTypes);
  for(i=0; (c = zTypes[i])!=0; i++){
    if( c=='s' ){
      const char *z = va_arg(ap, const char*);
      sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
    }else if( c=='i' ){
      sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i);
    }else{
      goto skip_op_resultrow;

References OP_Integer, OP_Null, OP_ResultRow, OP_String8, sqlite3VdbeAddOp2(), and sqlite3VdbeAddOp4().

Referenced by sqlite3Pragma().

◆ sqlite3VdbeNextOpcode()

SQLITE_PRIVATE int sqlite3VdbeNextOpcode	(	Vdbe *	p,
		Mem *	pSub,
		int	eMode,
		int *	piPc,
		int *	piAddr,
		Op **	paOp )

Definition at line 79690 of file sqlite3.c.

 {
  int nRow;                            /* Stop when row count reaches this */
  int nSub = 0;                        /* Number of sub-vdbes seen so far */
  SubProgram **apSub = 0;              /* Array of sub-vdbes */
  int i;                               /* Next instruction address */
  int rc = SQLITE_OK;                  /* Result code */
  Op *aOp = 0;                         /* Opcode array */
  int iPc;                             /* Rowid.  Copy of value in *piPc */
 
  /* When the number of output rows reaches nRow, that means the
  ** listing has finished and sqlite3_step() should return SQLITE_DONE.
  ** nRow is the sum of the number of rows in the main program, plus
  ** the sum of the number of rows in all trigger subprograms encountered
  ** so far.  The nRow value will increase as new trigger subprograms are
  ** encountered, but p->pc will eventually catch up to nRow.
  */
  nRow = p->nOp;
  if( pSub!=0 ){
    if( pSub->flags&MEM_Blob ){
      /* pSub is initiallly NULL.  It is initialized to a BLOB by
      ** the P4_SUBPROGRAM processing logic below */
      nSub = pSub->n/sizeof(Vdbe*);
      apSub = (SubProgram **)pSub->z;
    }
    for(i=0; i<nSub; i++){
      nRow += apSub[i]->nOp;
    }
  }
  iPc = *piPc;
  while(1){  /* Loop exits via break */
    i = iPc++;
    if( i>=nRow ){
      p->rc = SQLITE_OK;
      rc = SQLITE_DONE;
      break;
    }
    if( i<p->nOp ){
      /* The rowid is small enough that we are still in the
      ** main program. */
      aOp = p->aOp;
    }else{
      /* We are currently listing subprograms.  Figure out which one and
      ** pick up the appropriate opcode. */
      int j;
      i -= p->nOp;
      assert( apSub!=0 );
      assert( nSub>0 );
      for(j=0; i>=apSub[j]->nOp; j++){
        i -= apSub[j]->nOp;
        assert( i<apSub[j]->nOp || j+1<nSub );
      }
      aOp = apSub[j]->aOp;
    }
 
    /* When an OP_Program opcode is encounter (the only opcode that has
    ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
    ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
    ** has not already been seen.
    */
    if( pSub!=0 && aOp[i].p4type==P4_SUBPROGRAM ){
      int nByte = (nSub+1)*sizeof(SubProgram*);
      int j;
      for(j=0; j<nSub; j++){
        if( apSub[j]==aOp[i].p4.pProgram ) break;
      }
      if( j==nSub ){
        p->rc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0);
        if( p->rc!=SQLITE_OK ){
          rc = SQLITE_ERROR;
          break;
        }
        apSub = (SubProgram **)pSub->z;
        apSub[nSub++] = aOp[i].p4.pProgram;
        MemSetTypeFlag(pSub, MEM_Blob);
        pSub->n = nSub*sizeof(SubProgram*);
        nRow += aOp[i].p4.pProgram->nOp;
      }
    }
    if( eMode==0 ) break;
#ifdef SQLITE_ENABLE_BYTECODE_VTAB
    if( eMode==2 ){
      Op *pOp = aOp + i;
      if( pOp->opcode==OP_OpenRead ) break;
      if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break;
      if( pOp->opcode==OP_ReopenIdx ) break;
    }else
#endif
    {
      assert( eMode==1 );
      if( aOp[i].opcode==OP_Explain ) break;
      if( aOp[i].opcode==OP_Init && iPc>1 ) break;
    }

References SubProgram::aOp, Vdbe::aOp, sqlite3_value::flags, MEM_Blob, MemSetTypeFlag, sqlite3_value::n, SubProgram::nOp, Vdbe::nOp, OP_Explain, OP_Init, OP_OpenRead, OP_OpenWrite, OP_ReopenIdx, VdbeOp::opcode, OPFLAG_P2ISREG, VdbeOp::p4, P4_SUBPROGRAM, VdbeOp::p5, VdbeOp::p4union::pProgram, Vdbe::rc, sqlite3VdbeMemGrow(), SQLITE_DONE, SQLITE_ERROR, SQLITE_OK, and sqlite3_value::z.

Referenced by sqlite3VdbeList().

◆ sqlite3VdbeOneByteSerialTypeLen()

SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen ( u8 serial_type )

Definition at line 81462 of file sqlite3.c.

       {
    assert( serial_type<12
            || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 );
    return sqlite3SmallTypeSizes[serial_type];

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeParameterIndex()

SQLITE_PRIVATE int sqlite3VdbeParameterIndex	(	Vdbe *	p,
		const char *	zName,
		int	nName )

Definition at line 84584 of file sqlite3.c.

Referenced by sqlite3VdbeExpandSql().

◆ sqlite3VdbeParser()

SQLITE_PRIVATE Parse * sqlite3VdbeParser ( Vdbe * p )

Definition at line 77784 of file sqlite3.c.

◆ sqlite3VdbePrepareFlags()

SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags ( Vdbe * v )

Definition at line 82796 of file sqlite3.c.

Referenced by sqlite3Reprepare().

◆ sqlite3VdbeRealValue()

SQLITE_PRIVATE double sqlite3VdbeRealValue ( Mem * pMem )

Definition at line 76445 of file sqlite3.c.

                                                     {
  /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
  double val = (double)0;
  sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
  return val;
}
SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  if( pMem->flags & MEM_Real ){
    return pMem->u.r;
  }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
    testcase( pMem->flags & MEM_IntReal );
    return (double)pMem->u.i;
  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){

References sqlite3_value::enc, sqlite3_value::n, sqlite3AtoF(), and sqlite3_value::z.

Referenced by sqlite3_value_int64(), and sqlite3VdbeExec().

◆ sqlite3VdbeRecordCompare()

SQLITE_PRIVATE int sqlite3VdbeRecordCompare	(	int	nKey1,
		const void *	pKey1,
		UnpackedRecord *	pPKey2 )

Definition at line 82407 of file sqlite3.c.

Referenced by sqlite3BtreeMovetoUnpacked(), sqlite3VdbeFindCompare(), sqlite3VdbeSorterCompare(), vdbeRecordCompareInt(), and vdbeSorterCompare().

◆ sqlite3VdbeRecordCompareWithSkip()

SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip	(	int	nKey1,
		const void *	pKey1,
		UnpackedRecord *	pPKey2,
		int	bSkip )

Definition at line 82210 of file sqlite3.c.

 {
  u32 d1;                         /* Offset into aKey[] of next data element */
  int i;                          /* Index of next field to compare */
  u32 szHdr1;                     /* Size of record header in bytes */
  u32 idx1;                       /* Offset of first type in header */
  int rc = 0;                     /* Return value */
  Mem *pRhs = pPKey2->aMem;       /* Next field of pPKey2 to compare */
  KeyInfo *pKeyInfo;
  const unsigned char *aKey1 = (const unsigned char *)pKey1;
  Mem mem1;
 
  /* If bSkip is true, then the caller has already determined that the first
  ** two elements in the keys are equal. Fix the various stack variables so
  ** that this routine begins comparing at the second field. */
  if( bSkip ){
    u32 s1;
    idx1 = 1 + getVarint32(&aKey1[1], s1);
    szHdr1 = aKey1[0];
    d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
    i = 1;
    pRhs++;
  }else{
    idx1 = getVarint32(aKey1, szHdr1);
    d1 = szHdr1;
    i = 0;
  }
  if( d1>(unsigned)nKey1 ){
    pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
    return 0;  /* Corruption */
  }
 
  VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
  assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
       || CORRUPT_DB );
  assert( pPKey2->pKeyInfo->aSortFlags!=0 );
  assert( pPKey2->pKeyInfo->nKeyField>0 );
  assert( idx1<=szHdr1 || CORRUPT_DB );
  do{
    u32 serial_type;
 
    /* RHS is an integer */
    if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
      testcase( pRhs->flags & MEM_Int );
      testcase( pRhs->flags & MEM_IntReal );
      serial_type = aKey1[idx1];
      testcase( serial_type==12 );
      if( serial_type>=10 ){
        rc = +1;
      }else if( serial_type==0 ){
        rc = -1;
      }else if( serial_type==7 ){
        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
        rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
      }else{
        i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
        i64 rhs = pRhs->u.i;
        if( lhs<rhs ){
          rc = -1;
        }else if( lhs>rhs ){
          rc = +1;
        }
      }
    }
 
    /* RHS is real */
    else if( pRhs->flags & MEM_Real ){
      serial_type = aKey1[idx1];
      if( serial_type>=10 ){
        /* Serial types 12 or greater are strings and blobs (greater than
        ** numbers). Types 10 and 11 are currently "reserved for future
        ** use", so it doesn't really matter what the results of comparing
        ** them to numberic values are.  */
        rc = +1;
      }else if( serial_type==0 ){
        rc = -1;
      }else{
        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
        if( serial_type==7 ){
          if( mem1.u.r<pRhs->u.r ){
            rc = -1;
          }else if( mem1.u.r>pRhs->u.r ){
            rc = +1;
          }
        }else{
          rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
        }
      }
    }
 
    /* RHS is a string */
    else if( pRhs->flags & MEM_Str ){
      getVarint32NR(&aKey1[idx1], serial_type);
      testcase( serial_type==12 );
      if( serial_type<12 ){
        rc = -1;
      }else if( !(serial_type & 0x01) ){
        rc = +1;
      }else{
        mem1.n = (serial_type - 12) / 2;
        testcase( (d1+mem1.n)==(unsigned)nKey1 );
        testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
        if( (d1+mem1.n) > (unsigned)nKey1
         || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
        ){
          pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
          return 0;                /* Corruption */
        }else if( pKeyInfo->aColl[i] ){
          mem1.enc = pKeyInfo->enc;
          mem1.db = pKeyInfo->db;
          mem1.flags = MEM_Str;
          mem1.z = (char*)&aKey1[d1];
          rc = vdbeCompareMemString(
              &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
          );
        }else{
          int nCmp = MIN(mem1.n, pRhs->n);
          rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
          if( rc==0 ) rc = mem1.n - pRhs->n;
        }
      }
    }
 
    /* RHS is a blob */
    else if( pRhs->flags & MEM_Blob ){
      assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
      getVarint32NR(&aKey1[idx1], serial_type);
      testcase( serial_type==12 );
      if( serial_type<12 || (serial_type & 0x01) ){
        rc = -1;
      }else{
        int nStr = (serial_type - 12) / 2;
        testcase( (d1+nStr)==(unsigned)nKey1 );
        testcase( (d1+nStr+1)==(unsigned)nKey1 );
        if( (d1+nStr) > (unsigned)nKey1 ){
          pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
          return 0;                /* Corruption */
        }else if( pRhs->flags & MEM_Zero ){
          if( !isAllZero((const char*)&aKey1[d1],nStr) ){
            rc = 1;
          }else{
            rc = nStr - pRhs->u.nZero;
          }
        }else{
          int nCmp = MIN(nStr, pRhs->n);
          rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
          if( rc==0 ) rc = nStr - pRhs->n;
        }
      }
    }
 
    /* RHS is null */
    else{
      serial_type = aKey1[idx1];
      rc = (serial_type!=0);
    }
 
    if( rc!=0 ){
      int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
      if( sortFlags ){
        if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0
         || ((sortFlags & KEYINFO_ORDER_DESC)
           !=(serial_type==0 || (pRhs->flags&MEM_Null)))
        ){
          rc = -rc;
        }
      }
      assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
      assert( mem1.szMalloc==0 );  /* See comment below */
      return rc;
    }
 
    i++;
    if( i==pPKey2->nField ) break;
    pRhs++;
    d1 += sqlite3VdbeSerialTypeLen(serial_type);
    idx1 += sqlite3VarintLen(serial_type);
  }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 );
 
  /* No memory allocation is ever used on mem1.  Prove this using
  ** the following assert().  If the assert() fails, it indicates a
  ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).  */
  assert( mem1.szMalloc==0 );
 
  /* rc==0 here means that one or both of the keys ran out of fields and
  ** all the fields up to that point were equal. Return the default_rc
  ** value.  */
  assert( CORRUPT_DB

References KeyInfo::aColl, UnpackedRecord::aMem, KeyInfo::aSortFlags, CORRUPT_DB, KeyInfo::db, sqlite3_value::db, KeyInfo::enc, sqlite3_value::enc, UnpackedRecord::errCode, sqlite3_value::flags, getVarint32, getVarint32NR, sqlite3_value::MemValue::i, isAllZero(), KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, MEM_Blob, MEM_Int, MEM_IntReal, MEM_Null, MEM_Real, MEM_Str, MEM_Zero, MIN, sqlite3_value::n, KeyInfo::nAllField, UnpackedRecord::nField, KeyInfo::nKeyField, sqlite3_value::MemValue::nZero, UnpackedRecord::pKeyInfo, sqlite3_value::MemValue::r, sqlite3IntFloatCompare(), sqlite3VarintLen(), sqlite3VdbeSerialGet(), sqlite3VdbeSerialTypeLen(), SQLITE_CORRUPT_BKPT, sqlite3_value::szMalloc, testcase, sqlite3_value::u, vdbeCompareMemString(), vdbeRecordDecodeInt(), VVA_ONLY, and sqlite3_value::z.

Referenced by sqlite3VdbeIdxKeyCompare(), vdbeRecordCompareInt(), vdbeRecordCompareString(), and vdbeSorterCompareTail().

◆ sqlite3VdbeRecordUnpack()

SQLITE_PRIVATE void sqlite3VdbeRecordUnpack	(	KeyInfo *	pKeyInfo,
		int	nKey,
		const void *	pKey,
		UnpackedRecord *	p )

Definition at line 81748 of file sqlite3.c.

 {
  const unsigned char *aKey = (const unsigned char *)pKey;
  u32 d;
  u32 idx;                        /* Offset in aKey[] to read from */
  u16 u;                          /* Unsigned loop counter */
  u32 szHdr;
  Mem *pMem = p->aMem;
 
  p->default_rc = 0;
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  idx = getVarint32(aKey, szHdr);
  d = szHdr;
  u = 0;
  while( idx<szHdr && d<=(u32)nKey ){
    u32 serial_type;
 
    idx += getVarint32(&aKey[idx], serial_type);
    pMem->enc = pKeyInfo->enc;
    pMem->db = pKeyInfo->db;
    /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
    pMem->szMalloc = 0;
    pMem->z = 0;
    d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
    pMem++;
    if( (++u)>=p->nField ) break;
  }
  if( d>(u32)nKey && u ){
    assert( CORRUPT_DB );
    /* In a corrupt record entry, the last pMem might have been set up using
    ** uninitialized memory. Overwrite its value with NULL, to prevent

References UnpackedRecord::aMem, CORRUPT_DB, KeyInfo::db, sqlite3_value::db, UnpackedRecord::default_rc, EIGHT_BYTE_ALIGNMENT, KeyInfo::enc, sqlite3_value::enc, getVarint32, UnpackedRecord::nField, sqlite3VdbeMemSetNull(), sqlite3VdbeSerialGet(), sqlite3_value::szMalloc, and sqlite3_value::z.

Referenced by btreeMoveto(), sqlite3VdbeExec(), sqlite3VdbeSorterCompare(), vdbeSorterCompare(), and vdbeSorterCompareTail().

◆ sqlite3VdbeReset()

SQLITE_PRIVATE int sqlite3VdbeReset ( Vdbe * p )

Definition at line 81017 of file sqlite3.c.

                                            {
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
  int i;
#endif
 
  sqlite3 *db;
  db = p->db;
 
  /* If the VM did not run to completion or if it encountered an
  ** error, then it might not have been halted properly.  So halt
  ** it now.
  */
  sqlite3VdbeHalt(p);
 
  /* If the VDBE has been run even partially, then transfer the error code
  ** and error message from the VDBE into the main database structure.  But
  ** if the VDBE has just been set to run but has not actually executed any
  ** instructions yet, leave the main database error information unchanged.
  */
  if( p->pc>=0 ){
    vdbeInvokeSqllog(p);
    if( db->pErr || p->zErrMsg ){
      sqlite3VdbeTransferError(p);
    }else{
      db->errCode = p->rc;
    }
    if( p->runOnlyOnce ) p->expired = 1;
  }else if( p->rc && p->expired ){
    /* The expired flag was set on the VDBE before the first call
    ** to sqlite3_step(). For consistency (since sqlite3_step() was
    ** called), set the database error in this case as well.
    */
    sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
  }
 
  /* Reset register contents and reclaim error message memory.
  */
#ifdef SQLITE_DEBUG
  /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
  ** Vdbe.aMem[] arrays have already been cleaned up.  */
  if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
  if( p->aMem ){
    for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
  }
#endif
  if( p->zErrMsg ){
    sqlite3DbFree(db, p->zErrMsg);
    p->zErrMsg = 0;
  }
  p->pResultSet = 0;
#ifdef SQLITE_DEBUG
  p->nWrite = 0;
#endif
 
  /* Save profiling information from this VDBE run.
  */
#ifdef VDBE_PROFILE
  {
    FILE *out = fopen("vdbe_profile.out", "a");
    if( out ){
      fprintf(out, "---- ");
      for(i=0; i<p->nOp; i++){
        fprintf(out, "%02x", p->aOp[i].opcode);
      }
      fprintf(out, "\n");
      if( p->zSql ){
        char c, pc = 0;
        fprintf(out, "-- ");
        for(i=0; (c = p->zSql[i])!=0; i++){
          if( pc=='\n' ) fprintf(out, "-- ");
          putc(c, out);
          pc = c;
        }
        if( pc!='\n' ) fprintf(out, "\n");
      }
      for(i=0; i<p->nOp; i++){
        char zHdr[100];
        sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",
           p->aOp[i].cnt,
           p->aOp[i].cycles,
           p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
        );
        fprintf(out, "%s", zHdr);
        sqlite3VdbePrintOp(out, i, &p->aOp[i]);
      }
      fclose(out);

References Vdbe::aMem, Vdbe::aOp, Vdbe::apCsr, Vdbe::db, sqlite3::errCode, sqlite3::errMask, Vdbe::expired, sqlite3_value::flags, Vdbe::magic, MEM_Undefined, Vdbe::nCursor, Vdbe::nMem, Vdbe::nOp, VdbeOp::opcode, Vdbe::pc, sqlite3::pErr, Vdbe::pResultSet, Vdbe::rc, Vdbe::runOnlyOnce, sqlite3_snprintf(), sqlite3DbFree(), sqlite3ErrorWithMsg(), sqlite3VdbeHalt(), sqlite3VdbeTransferError(), VDBE_MAGIC_RESET, vdbeInvokeSqllog, Vdbe::zErrMsg, and Vdbe::zSql.

Referenced by sqlite3_reset().

◆ sqlite3VdbeResetStepResult()

SQLITE_PRIVATE void sqlite3VdbeResetStepResult ( Vdbe * p )

Definition at line 80956 of file sqlite3.c.

References Vdbe::rc, and SQLITE_OK.

Referenced by sqlite3Reprepare().

◆ sqlite3VdbeResolveLabel()

SQLITE_PRIVATE void sqlite3VdbeResolveLabel	(	Vdbe *	v,
		int	x )

Definition at line 78296 of file sqlite3.c.

                                                           {
  Parse *p = v->pParse;
  int j = ADDR(x);
  assert( v->magic==VDBE_MAGIC_INIT );
  assert( j<-p->nLabel );
  assert( j>=0 );
#ifdef SQLITE_DEBUG
  if( p->db->flags & SQLITE_VdbeAddopTrace ){
    printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
  }
#endif
  if( p->nLabelAlloc + p->nLabel < 0 ){

Referenced by analyzeOneTable(), codeVectorCompare(), constructAutomaticIndex(), fkLookupParent(), generateOutputSubroutine(), generateSortTail(), generateWithRecursiveQuery(), multiSelect(), multiSelectOrderBy(), sqlite3DeleteFrom(), sqlite3ExprCodeIN(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), sqlite3FkDropTable(), sqlite3GenerateConstraintChecks(), sqlite3GenerateRowDelete(), sqlite3Insert(), sqlite3Pragma(), sqlite3ResolvePartIdxLabel(), sqlite3Select(), sqlite3Update(), sqlite3WhereEnd(), sqlite3WindowCodeStep(), updateAccumulator(), windowCodeOp(), windowFullScan(), and windowReturnOneRow().

◆ sqlite3VdbeReusable()

SQLITE_PRIVATE void sqlite3VdbeReusable ( Vdbe * p )

Definition at line 78325 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ sqlite3VdbeRewind()

SQLITE_PRIVATE void sqlite3VdbeRewind ( Vdbe * p )

Definition at line 80022 of file sqlite3.c.

                                              {
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
  int i;
#endif
  assert( p!=0 );
  assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET );
 
  /* There should be at least one opcode.
  */
  assert( p->nOp>0 );
 
  /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
  p->magic = VDBE_MAGIC_RUN;
 
#ifdef SQLITE_DEBUG
  for(i=0; i<p->nMem; i++){
    assert( p->aMem[i].db==p->db );
  }
#endif
  p->pc = -1;
  p->rc = SQLITE_OK;
  p->errorAction = OE_Abort;
  p->nChange = 0;
  p->cacheCtr = 1;
  p->minWriteFileFormat = 255;
  p->iStatement = 0;
  p->nFkConstraint = 0;
#ifdef VDBE_PROFILE

Referenced by sqlite3_reset(), and sqlite3VdbeMakeReady().

◆ sqlite3VdbeRunOnlyOnce()

SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce ( Vdbe * p )

Definition at line 78318 of file sqlite3.c.

Referenced by sqlite3Pragma().

◆ sqlite3VdbeSerialGet()

SQLITE_PRIVATE u32 sqlite3VdbeSerialGet	(	const unsigned char *	buf,
		u32	serial_type,
		Mem *	pMem )

Definition at line 81623 of file sqlite3.c.

                                      : MEM_Real;
  }
  return 8;
}
SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
  const unsigned char *buf,     /* Buffer to deserialize from */
  u32 serial_type,              /* Serial type to deserialize */
  Mem *pMem                     /* Memory cell to write value into */
){
  switch( serial_type ){
    case 10: { /* Internal use only: NULL with virtual table
               ** UPDATE no-change flag set */
      pMem->flags = MEM_Null|MEM_Zero;
      pMem->n = 0;
      pMem->u.nZero = 0;
      break;
    }
    case 11:   /* Reserved for future use */
    case 0: {  /* Null */
      /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
      pMem->flags = MEM_Null;
      break;
    }
    case 1: {
      /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
      ** integer. */
      pMem->u.i = ONE_BYTE_INT(buf);
      pMem->flags = MEM_Int;
      testcase( pMem->u.i<0 );
      return 1;
    }
    case 2: { /* 2-byte signed integer */
      /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
      ** twos-complement integer. */
      pMem->u.i = TWO_BYTE_INT(buf);
      pMem->flags = MEM_Int;
      testcase( pMem->u.i<0 );
      return 2;
    }
    case 3: { /* 3-byte signed integer */
      /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
      ** twos-complement integer. */
      pMem->u.i = THREE_BYTE_INT(buf);
      pMem->flags = MEM_Int;
      testcase( pMem->u.i<0 );
      return 3;
    }
    case 4: { /* 4-byte signed integer */
      /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
      ** twos-complement integer. */
      pMem->u.i = FOUR_BYTE_INT(buf);
#ifdef __HP_cc
      /* Work around a sign-extension bug in the HP compiler for HP/UX */
      if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL;
#endif
      pMem->flags = MEM_Int;
      testcase( pMem->u.i<0 );
      return 4;
    }
    case 5: { /* 6-byte signed integer */
      /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
      ** twos-complement integer. */
      pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
      pMem->flags = MEM_Int;
      testcase( pMem->u.i<0 );
      return 6;
    }
    case 6:   /* 8-byte signed integer */
    case 7: { /* IEEE floating point */
      /* These use local variables, so do them in a separate routine
      ** to avoid having to move the frame pointer in the common case */
      return serialGet(buf,serial_type,pMem);
    }
    case 8:    /* Integer 0 */
    case 9: {  /* Integer 1 */
      /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
      /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
      pMem->u.i = serial_type-8;
      pMem->flags = MEM_Int;
      return 0;
    }
    default: {
      /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
      ** length.
      ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
      ** (N-13)/2 bytes in length. */
      static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem };
      pMem->z = (char *)buf;
      pMem->n = (serial_type-12)/2;

Referenced by sqlite3VdbeExec(), sqlite3VdbeIdxRowid(), sqlite3VdbeRecordCompareWithSkip(), and sqlite3VdbeRecordUnpack().

◆ sqlite3VdbeSerialPut() [1/2]

SQLITE_PRIVATE u32 sqlite3VdbeSerialPut	(	u8 *	buf,
		Mem *	pMem,
		u32	serial_type )

Definition at line 81533 of file sqlite3.c.

                                                                            {
  u32 len;
 
  /* Integer and Real */
  if( serial_type<=7 && serial_type>0 ){
    u64 v;
    u32 i;
    if( serial_type==7 ){
      assert( sizeof(v)==sizeof(pMem->u.r) );
      memcpy(&v, &pMem->u.r, sizeof(v));
      swapMixedEndianFloat(v);
    }else{
      v = pMem->u.i;
    }
    len = i = sqlite3SmallTypeSizes[serial_type];
    assert( i>0 );
    do{
      buf[--i] = (u8)(v&0xFF);
      v >>= 8;
    }while( i );
    return len;
  }
 
  /* String or blob */
  if( serial_type>=12 ){
    assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
             == (int)sqlite3VdbeSerialTypeLen(serial_type) );
    len = pMem->n;
    if( len>0 ) memcpy(buf, pMem->z, len);

References sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Zero, sqlite3_value::n, sqlite3_value::MemValue::nZero, sqlite3_value::MemValue::r, sqlite3SmallTypeSizes, sqlite3VdbeSerialTypeLen(), swapMixedEndianFloat, sqlite3_value::u, and sqlite3_value::z.

◆ sqlite3VdbeSerialPut() [2/2]

SQLITE_PRIVATE u32 sqlite3VdbeSerialPut	(	unsigned char *	,
		Mem *	,
		u32	)

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSerialTypeLen()

SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen ( u32 serial_type )

Definition at line 81453 of file sqlite3.c.

                                                            {
  if( serial_type>=128 ){
    return (serial_type-12)/2;

Referenced by blobSeekToRow(), sqlite3VdbeExec(), sqlite3VdbeRecordCompareWithSkip(), and sqlite3VdbeSerialPut().

◆ sqlite3VdbeSetChanges()

SQLITE_PRIVATE void sqlite3VdbeSetChanges	(	sqlite3 *	db,
		int	nChange )

Definition at line 82747 of file sqlite3.c.

Referenced by sqlite3VdbeExec(), and sqlite3VdbeHalt().

◆ sqlite3VdbeSetColName()

SQLITE_PRIVATE int sqlite3VdbeSetColName	(	Vdbe *	p,
		int	idx,
		int	var,
		const char *	zName,
		void()(void )	xDel )

Definition at line 80339 of file sqlite3.c.

 {
  int rc;
  Mem *pColName;
  assert( idx<p->nResColumn );
  assert( var<COLNAME_N );
  if( p->db->mallocFailed ){
    assert( !zName || xDel!=SQLITE_DYNAMIC );
    return SQLITE_NOMEM_BKPT;
  }

References Vdbe::aColName, COLNAME_N, Vdbe::db, sqlite3_value::flags, sqlite3::mallocFailed, MEM_Term, Vdbe::nResColumn, sqlite3VdbeMemSetStr(), SQLITE_DYNAMIC, SQLITE_NOMEM_BKPT, SQLITE_UTF8, and zName.

Referenced by generateColumnNames(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), and sqlite3VdbeMakeReady().

◆ sqlite3VdbeSetNumCols()

SQLITE_PRIVATE void sqlite3VdbeSetNumCols	(	Vdbe *	p,
		int	nResColumn )

Definition at line 80314 of file sqlite3.c.

                                                                  {
  int n;
  sqlite3 *db = p->db;
 
  if( p->nResColumn ){
    releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
    sqlite3DbFree(db, p->aColName);
  }

References Vdbe::aColName, COLNAME_N, Vdbe::db, initMemArray(), MEM_Null, Vdbe::nResColumn, releaseMemArray(), sqlite3DbFree(), and sqlite3DbMallocRawNN().

Referenced by generateColumnNames(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), sqlite3Update(), and sqlite3VdbeMakeReady().

◆ sqlite3VdbeSetP4KeyInfo()

SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo	(	Parse *	pParse,
		Index *	pIdx )

Definition at line 79091 of file sqlite3.c.

79097 {

79098 Vdbe *v = pParse->pVdbe;

Referenced by analyzeOneTable(), constructAutomaticIndex(), fkLookupParent(), sqlite3DeleteFrom(), sqlite3FindInIndex(), sqlite3OpenTable(), sqlite3OpenTableAndIndices(), sqlite3Pragma(), sqlite3WhereBegin(), and xferOptimization().

◆ sqlite3VdbeSetSql()

SQLITE_PRIVATE void sqlite3VdbeSetSql	(	Vdbe *	p,
		const char *	z,
		int	n,
		u8	prepFlags )

Definition at line 77802 of file sqlite3.c.

                                                                                  {
  if( p==0 ) return;
  p->prepFlags = prepFlags;

◆ sqlite3VdbeSetVarmask()

SQLITE_PRIVATE void sqlite3VdbeSetVarmask	(	Vdbe *	v,
		int	iVar )

Definition at line 82830 of file sqlite3.c.

                                                            {
  assert( iVar>0 );
  assert( (v->db->flags & SQLITE_EnableQPSG)==0 );

References Vdbe::db, Vdbe::expmask, sqlite3::flags, and SQLITE_EnableQPSG.

Referenced by exprCompareVariable(), and isLikeOrGlob().

◆ sqlite3VdbeSorterClose()

SQLITE_PRIVATE void sqlite3VdbeSorterClose	(	sqlite3 *	db,
		VdbeCursor *	pCsr )

Definition at line 95137 of file sqlite3.c.

                                                                         {
  VdbeSorter *pSorter;
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  if( pSorter ){

◆ sqlite3VdbeSorterCompare()

SQLITE_PRIVATE int sqlite3VdbeSorterCompare	(	const VdbeCursor *	pCsr,
		Mem *	pVal,
		int	nKeyCol,
		int *	pRes )

Definition at line 96604 of file sqlite3.c.

 {
  VdbeSorter *pSorter;
  UnpackedRecord *r2;
  KeyInfo *pKeyInfo;
  int i;
  void *pKey; int nKey;           /* Sorter key to compare pVal with */
 
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  r2 = pSorter->pUnpacked;
  pKeyInfo = pCsr->pKeyInfo;
  if( r2==0 ){
    r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
    if( r2==0 ) return SQLITE_NOMEM_BKPT;
    r2->nField = nKeyCol;
  }
  assert( r2->nField==nKeyCol );
 
  pKey = vdbeSorterRowkey(pSorter, &nKey);
  sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
  for(i=0; i<nKeyCol; i++){
    if( r2->aMem[i].flags & MEM_Null ){
      *pRes = -1;
      return SQLITE_OK;

References UnpackedRecord::aMem, CURTYPE_SORTER, VdbeCursor::eCurType, sqlite3_value::flags, MEM_Null, sqlite3_value::n, UnpackedRecord::nField, VdbeCursor::pKeyInfo, VdbeCursor::pSorter, VdbeSorter::pUnpacked, sqlite3VdbeAllocUnpackedRecord(), sqlite3VdbeRecordCompare(), sqlite3VdbeRecordUnpack(), SQLITE_NOMEM_BKPT, SQLITE_OK, VdbeCursor::uc, vdbeSorterRowkey(), and sqlite3_value::z.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterInit()

SQLITE_PRIVATE int sqlite3VdbeSorterInit	(	sqlite3 *	db,
		int	nField,
		VdbeCursor *	pCsr )

Definition at line 94806 of file sqlite3.c.

 {
  int pgsz;                       /* Page size of main database */
  int i;                          /* Used to iterate through aTask[] */
  VdbeSorter *pSorter;            /* The new sorter */
  KeyInfo *pKeyInfo;              /* Copy of pCsr->pKeyInfo with db==0 */
  int szKeyInfo;                  /* Size of pCsr->pKeyInfo in bytes */
  int sz;                         /* Size of pSorter in bytes */
  int rc = SQLITE_OK;
#if SQLITE_MAX_WORKER_THREADS==0
# define nWorker 0
#else
  int nWorker;
#endif
 
  /* Initialize the upper limit on the number of worker threads */
#if SQLITE_MAX_WORKER_THREADS>0
  if( sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex==0 ){
    nWorker = 0;
  }else{
    nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS];
  }
#endif
 
  /* Do not allow the total number of threads (main thread + all workers)
  ** to exceed the maximum merge count */
#if SQLITE_MAX_WORKER_THREADS>=SORTER_MAX_MERGE_COUNT
  if( nWorker>=SORTER_MAX_MERGE_COUNT ){
    nWorker = SORTER_MAX_MERGE_COUNT-1;
  }
#endif
 
  assert( pCsr->pKeyInfo && pCsr->pBtx==0 );
  assert( pCsr->eCurType==CURTYPE_SORTER );
  szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
  sz = sizeof(VdbeSorter) + nWorker * sizeof(SortSubtask);
 
  pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo);
  pCsr->uc.pSorter = pSorter;
  if( pSorter==0 ){
    rc = SQLITE_NOMEM_BKPT;
  }else{
    pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
    memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
    pKeyInfo->db = 0;
    if( nField && nWorker==0 ){
      pKeyInfo->nKeyField = nField;
    }
    pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
    pSorter->nTask = nWorker + 1;
    pSorter->iPrev = (u8)(nWorker - 1);
    pSorter->bUseThreads = (pSorter->nTask>1);
    pSorter->db = db;
    for(i=0; i<pSorter->nTask; i++){
      SortSubtask *pTask = &pSorter->aTask[i];
      pTask->pSorter = pSorter;
    }
 
    if( !sqlite3TempInMemory(db) ){
      i64 mxCache;                /* Cache size in bytes*/
      u32 szPma = sqlite3GlobalConfig.szPma;
      pSorter->mnPmaSize = szPma * pgsz;
 
      mxCache = db->aDb[0].pSchema->cache_size;
      if( mxCache<0 ){
        /* A negative cache-size value C indicates that the cache is abs(C)
        ** KiB in size.  */
        mxCache = mxCache * -1024;
      }else{
        mxCache = mxCache * pgsz;
      }
      mxCache = MIN(mxCache, SQLITE_MAX_PMASZ);
      pSorter->mxPmaSize = MAX(pSorter->mnPmaSize, (int)mxCache);
 
      /* Avoid large memory allocations if the application has requested
      ** SQLITE_CONFIG_SMALL_MALLOC. */
      if( sqlite3GlobalConfig.bSmallMalloc==0 ){
        assert( pSorter->iMemory==0 );
        pSorter->nMemory = pgsz;
        pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz);
        if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT;
      }
    }
 
    if( pKeyInfo->nAllField<13
     && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
     && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0
    ){

References KeyInfo::aColl, sqlite3::aDb, sqlite3::aLimit, SorterList::aMemory, KeyInfo::aSortFlags, VdbeSorter::aTask, VdbeSorter::bUseThreads, Schema::cache_size, CURTYPE_SORTER, KeyInfo::db, VdbeSorter::db, VdbeCursor::eCurType, VdbeSorter::iMemory, VdbeSorter::iPrev, KEYINFO_ORDER_BIGNULL, VdbeSorter::list, MAX, MIN, VdbeSorter::mnPmaSize, VdbeSorter::mxPmaSize, KeyInfo::nAllField, KeyInfo::nKeyField, VdbeSorter::nMemory, VdbeSorter::nTask, Db::pBt, VdbeCursor::pBtx, sqlite3::pDfltColl, VdbeSorter::pgsz, VdbeCursor::pKeyInfo, VdbeSorter::pKeyInfo, Db::pSchema, VdbeCursor::pSorter, SortSubtask::pSorter, SORTER_MAX_MERGE_COUNT, SORTER_TYPE_INTEGER, SORTER_TYPE_TEXT, sqlite3BtreeGetPageSize(), sqlite3DbMallocZero(), sqlite3GlobalConfig, sqlite3Malloc(), sqlite3TempInMemory(), SQLITE_LIMIT_WORKER_THREADS, SQLITE_MAX_PMASZ, SQLITE_NOMEM_BKPT, SQLITE_OK, VdbeSorter::typeMask, and VdbeCursor::uc.

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterNext()

SQLITE_PRIVATE int sqlite3VdbeSorterNext	(	sqlite3 *	db,
		const VdbeCursor *	pCsr )

Definition at line 96506 of file sqlite3.c.

                                                           :
**
**    SQLITE_OK     success
**    SQLITE_DONE   end of data
**    otherwise     some kind of error.
*/
SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){
  VdbeSorter *pSorter;
  int rc;                         /* Return code */
 
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
  if( pSorter->bUsePMA ){
    assert( pSorter->pReader==0 || pSorter->pMerger==0 );
    assert( pSorter->bUseThreads==0 || pSorter->pReader );
    assert( pSorter->bUseThreads==1 || pSorter->pMerger );
#if SQLITE_MAX_WORKER_THREADS>0
    if( pSorter->bUseThreads ){
      rc = vdbePmaReaderNext(pSorter->pReader);
      if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE;
    }else
#endif
    /*if( !pSorter->bUseThreads )*/ {
      int res = 0;
      assert( pSorter->pMerger!=0 );
      assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
      rc = vdbeMergeEngineStep(pSorter->pMerger, &res);
      if( rc==SQLITE_OK && res ) rc = SQLITE_DONE;
    }
  }else{
    SorterRecord *pFree = pSorter->list.pList;
    pSorter->list.pList = pFree->u.pNext;

References SorterList::aMemory, VdbeSorter::aTask, VdbeSorter::bUsePMA, VdbeSorter::bUseThreads, CURTYPE_SORTER, VdbeCursor::eCurType, VdbeSorter::list, PmaReader::pFd, SorterList::pList, VdbeSorter::pMerger, SorterRecord::pNext, VdbeSorter::pReader, VdbeCursor::pSorter, MergeEngine::pTask, SQLITE_DONE, SQLITE_OK, SorterRecord::u, VdbeCursor::uc, vdbeMergeEngineStep(), vdbePmaReaderNext(), and vdbeSorterRecordFree().

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterReset()

SQLITE_PRIVATE void sqlite3VdbeSorterReset	(	sqlite3 *	db,
		VdbeSorter *	pSorter )

Definition at line 95104 of file sqlite3.c.

                                                                            {
  int i;
  (void)vdbeSorterJoinAll(pSorter, SQLITE_OK);
  assert( pSorter->bUseThreads || pSorter->pReader==0 );
#if SQLITE_MAX_WORKER_THREADS>0
  if( pSorter->pReader ){
    vdbePmaReaderClear(pSorter->pReader);
    sqlite3DbFree(db, pSorter->pReader);
    pSorter->pReader = 0;
  }
#endif
  vdbeMergeEngineFree(pSorter->pMerger);
  pSorter->pMerger = 0;
  for(i=0; i<pSorter->nTask; i++){
    SortSubtask *pTask = &pSorter->aTask[i];
    vdbeSortSubtaskCleanup(db, pTask);
    pTask->pSorter = pSorter;
  }
  if( pSorter->list.aMemory==0 ){
    vdbeSorterRecordFree(0, pSorter->list.pList);
  }
  pSorter->list.pList = 0;
  pSorter->list.szPMA = 0;

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterRewind()

SQLITE_PRIVATE int sqlite3VdbeSorterRewind	(	const VdbeCursor *	pCsr,
		int *	pbEof )

Definition at line 96454 of file sqlite3.c.

                                                                              {
  VdbeSorter *pSorter;
  int rc = SQLITE_OK;             /* Return code */
 
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  assert( pSorter );
 
  /* If no data has been written to disk, then do not do so now. Instead,
  ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly
  ** from the in-memory list.  */
  if( pSorter->bUsePMA==0 ){
    if( pSorter->list.pList ){
      *pbEof = 0;
      rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list);
    }else{
      *pbEof = 1;
    }
    return rc;
  }
 
  /* Write the current in-memory list to a PMA. When the VdbeSorterWrite()
  ** function flushes the contents of memory to disk, it immediately always
  ** creates a new list consisting of a single key immediately afterwards.
  ** So the list is never empty at this point.  */
  assert( pSorter->list.pList );
  rc = vdbeSorterFlushPMA(pSorter);
 
  /* Join all threads */
  rc = vdbeSorterJoinAll(pSorter, rc);
 
  vdbeSorterRewindDebug("rewind");
 
  /* Assuming no errors have occurred, set up a merger structure to
  ** incrementally read and merge all remaining PMAs.  */
  assert( pSorter->pReader==0 );
  if( rc==SQLITE_OK ){
    rc = vdbeSorterSetupMerge(pSorter);

References VdbeSorter::aTask, VdbeSorter::bUsePMA, CURTYPE_SORTER, VdbeCursor::eCurType, VdbeSorter::list, SorterList::pList, VdbeSorter::pReader, VdbeCursor::pSorter, SQLITE_OK, VdbeCursor::uc, vdbeSorterFlushPMA(), vdbeSorterJoinAll(), vdbeSorterRewindDebug, vdbeSorterSetupMerge(), and vdbeSorterSort().

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterRowkey()

SQLITE_PRIVATE int sqlite3VdbeSorterRowkey	(	const VdbeCursor *	pCsr,
		Mem *	pOut )

Definition at line 96571 of file sqlite3.c.

                                                                             {
  VdbeSorter *pSorter;
  void *pKey; int nKey;           /* Sorter key to copy into pOut */
 
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  pKey = vdbeSorterRowkey(pSorter, &nKey);
  if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){
    return SQLITE_NOMEM_BKPT;
  }

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSorterWrite()

SQLITE_PRIVATE int sqlite3VdbeSorterWrite	(	const VdbeCursor *	pCsr,
		Mem *	pVal )

Definition at line 95640 of file sqlite3.c.

 {
  VdbeSorter *pSorter;
  int rc = SQLITE_OK;             /* Return Code */
  SorterRecord *pNew;             /* New list element */
  int bFlush;                     /* True to flush contents of memory to PMA */
  int nReq;                       /* Bytes of memory required */
  int nPMA;                       /* Bytes of PMA space required */
  int t;                          /* serial type of first record field */
 
  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  getVarint32NR((const u8*)&pVal->z[1], t);
  if( t>0 && t<10 && t!=7 ){
    pSorter->typeMask &= SORTER_TYPE_INTEGER;
  }else if( t>10 && (t & 0x01) ){
    pSorter->typeMask &= SORTER_TYPE_TEXT;
  }else{
    pSorter->typeMask = 0;
  }
 
  assert( pSorter );
 
  /* Figure out whether or not the current contents of memory should be
  ** flushed to a PMA before continuing. If so, do so.
  **
  ** If using the single large allocation mode (pSorter->aMemory!=0), then
  ** flush the contents of memory to a new PMA if (a) at least one value is
  ** already in memory and (b) the new value will not fit in memory.
  **
  ** Or, if using separate allocations for each record, flush the contents
  ** of memory to a PMA if either of the following are true:
  **
  **   * The total memory allocated for the in-memory list is greater
  **     than (page-size * cache-size), or
  **
  **   * The total memory allocated for the in-memory list is greater
  **     than (page-size * 10) and sqlite3HeapNearlyFull() returns true.
  */
  nReq = pVal->n + sizeof(SorterRecord);
  nPMA = pVal->n + sqlite3VarintLen(pVal->n);
  if( pSorter->mxPmaSize ){
    if( pSorter->list.aMemory ){
      bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize;
    }else{
      bFlush = (
          (pSorter->list.szPMA > pSorter->mxPmaSize)
       || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull())
      );
    }
    if( bFlush ){
      rc = vdbeSorterFlushPMA(pSorter);
      pSorter->list.szPMA = 0;
      pSorter->iMemory = 0;
      assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
    }
  }
 
  pSorter->list.szPMA += nPMA;
  if( nPMA>pSorter->mxKeysize ){
    pSorter->mxKeysize = nPMA;
  }
 
  if( pSorter->list.aMemory ){
    int nMin = pSorter->iMemory + nReq;
 
    if( nMin>pSorter->nMemory ){
      u8 *aNew;
      sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
      int iListOff = -1;
      if( pSorter->list.pList ){
        iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
      }
      while( nNew < nMin ) nNew = nNew*2;
      if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
      if( nNew < nMin ) nNew = nMin;
      aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
      if( !aNew ) return SQLITE_NOMEM_BKPT;
      if( iListOff>=0 ){
        pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
      }
      pSorter->list.aMemory = aNew;
      pSorter->nMemory = nNew;
    }
 
    pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
    pSorter->iMemory += ROUND8(nReq);
    if( pSorter->list.pList ){
      pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
    }
  }else{
    pNew = (SorterRecord *)sqlite3Malloc(nReq);
    if( pNew==0 ){
      return SQLITE_NOMEM_BKPT;
    }
    pNew->u.pNext = pSorter->list.pList;
  }
 

Referenced by sqlite3VdbeExec().

◆ sqlite3VdbeSwap()

SQLITE_PRIVATE void sqlite3VdbeSwap	(	Vdbe *	pA,
		Vdbe *	pB )

Definition at line 77852 of file sqlite3.c.

                                                       {
  Vdbe tmp, *pTmp;
  char *zTmp;
  assert( pA->db==pB->db );
  tmp = *pA;
  *pA = *pB;
  *pB = tmp;
  pTmp = pA->pNext;
  pA->pNext = pB->pNext;
  pB->pNext = pTmp;
  pTmp = pA->pPrev;
  pA->pPrev = pB->pPrev;
  pB->pPrev = pTmp;
  zTmp = pA->zSql;
  pA->zSql = pB->zSql;
  pB->zSql = zTmp;
#ifdef SQLITE_ENABLE_NORMALIZE
  zTmp = pA->zNormSql;
  pA->zNormSql = pB->zNormSql;
  pB->zNormSql = zTmp;

Referenced by sqlite3Reprepare().

◆ sqlite3VdbeTakeOpArray()

SQLITE_PRIVATE VdbeOp * sqlite3VdbeTakeOpArray	(	Vdbe *	p,
		int *	pnOp,
		int *	pnMaxArg )

Definition at line 78680 of file sqlite3.c.

                                                                                {
  VdbeOp *aOp = p->aOp;
  assert( aOp && !p->db->mallocFailed );
 
  /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
  assert( DbMaskAllZero(p->btreeMask) );

References Vdbe::aOp, Vdbe::btreeMask, Vdbe::db, DbMaskAllZero, sqlite3::mallocFailed, Vdbe::nOp, and resolveP2Values().

◆ sqlite3VdbeTransferError()

SQLITE_PRIVATE int sqlite3VdbeTransferError ( Vdbe * p )

Definition at line 80968 of file sqlite3.c.

                                                    {
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
    db->bBenignMalloc++;
    sqlite3BeginBenignMalloc();
    if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
    db->bBenignMalloc--;

References sqlite3::bBenignMalloc, Vdbe::db, sqlite3::errCode, sqlite3::pErr, Vdbe::rc, sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), sqlite3ValueNew(), sqlite3ValueSetNull(), sqlite3ValueSetStr(), SQLITE_TRANSIENT, SQLITE_UTF8, and Vdbe::zErrMsg.

Referenced by sqlite3Step(), and sqlite3VdbeReset().

◆ sqlite3VdbeUsesBtree()

SQLITE_PRIVATE void sqlite3VdbeUsesBtree	(	Vdbe *	p,
		int	i )

Definition at line 79490 of file sqlite3.c.

79496 {

79497 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );

yDbMask

unsigned int yDbMask

Definition sqlite3.c:18655

References sqlite3::aDb, Vdbe::btreeMask, Vdbe::db, DbMaskSet, Vdbe::lockMask, sqlite3::nDb, Db::pBt, and sqlite3BtreeSharable().

Referenced by sqlite3AlterFinishAddColumn(), sqlite3FinishCoding(), sqlite3Pragma(), sqlite3StartTable(), and sqlite3Vacuum().

◆ sqlite3VectorErrorMsg()

SQLITE_PRIVATE void sqlite3VectorErrorMsg	(	Parse *	pParse,
		Expr *	pExpr )

Definition at line 102503 of file sqlite3.c.

                                       :
**
**   "row value misused"
*/
SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
#ifndef SQLITE_OMIT_SUBQUERY
  if( pExpr->flags & EP_xIsSelect ){
    sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);

References EP_xIsSelect, Expr::flags, ExprList::nExpr, Select::pEList, Expr::pSelect, sqlite3ErrorMsg(), sqlite3SubselectError(), and Expr::x.

Referenced by sqlite3ExprCheckIN(), and substExpr().

◆ sqlite3VectorFieldSubexpr()

SQLITE_PRIVATE Expr * sqlite3VectorFieldSubexpr	(	Expr *	pVector,
		int	i )

Definition at line 100153 of file sqlite3.c.

                                                                    {
  assert( i<sqlite3ExprVectorSize(pVector) );
  if( sqlite3ExprIsVector(pVector) ){
    assert( pVector->op2==0 || pVector->op==TK_REGISTER );
    if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){
      return pVector->x.pSelect->pEList->a[i].pExpr;

References ExprList::a, Expr::op, Expr::op2, Select::pEList, ExprList::ExprList_item::pExpr, Expr::pList, Expr::pSelect, sqlite3ExprIsVector(), sqlite3ExprVectorSize(), TK_REGISTER, TK_SELECT, and Expr::x.

Referenced by exprINAffinity(), exprVectorRegister(), sqlite3CodeRhsOfIN(), sqlite3ExprCodeIN(), sqlite3FindInIndex(), and updateRangeAffinityStr().

◆ sqlite3ViewGetColumnNames()

SQLITE_PRIVATE int sqlite3ViewGetColumnNames	(	Parse *	pParse,
		Table *	pTable )

Definition at line 113032 of file sqlite3.c.

                                                                          {
  Table *pSelTab;   /* A fake table from which we get the result set */
  Select *pSel;     /* Copy of the SELECT that implements the view */
  int nErr = 0;     /* Number of errors encountered */
  int n;            /* Temporarily holds the number of cursors assigned */
  sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  int rc;
#endif
#ifndef SQLITE_OMIT_AUTHORIZATION
  sqlite3_xauth xAuth;       /* Saved xAuth pointer */
#endif
 
  assert( pTable );
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  db->nSchemaLock++;
  rc = sqlite3VtabCallConnect(pParse, pTable);
  db->nSchemaLock--;
  if( rc ){
    return 1;
  }
  if( IsVirtual(pTable) ) return 0;
#endif
 
#ifndef SQLITE_OMIT_VIEW
  /* A positive nCol means the columns names for this view are
  ** already known.
  */
  if( pTable->nCol>0 ) return 0;
 
  /* A negative nCol is a special marker meaning that we are currently
  ** trying to compute the column names.  If we enter this routine with
  ** a negative nCol, it means two or more views form a loop, like this:
  **
  **     CREATE VIEW one AS SELECT * FROM two;
  **     CREATE VIEW two AS SELECT * FROM one;
  **
  ** Actually, the error above is now caught prior to reaching this point.
  ** But the following test is still important as it does come up
  ** in the following:
  **
  **     CREATE TABLE main.ex1(a);
  **     CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
  **     SELECT * FROM temp.ex1;
  */
  if( pTable->nCol<0 ){
    sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
    return 1;
  }
  assert( pTable->nCol>=0 );
 
  /* If we get this far, it means we need to compute the table names.
  ** Note that the call to sqlite3ResultSetOfSelect() will expand any
  ** "*" elements in the results set of the view and will assign cursors
  ** to the elements of the FROM clause.  But we do not want these changes
  ** to be permanent.  So the computation is done on a copy of the SELECT
  ** statement that defines the view.
  */
  assert( pTable->pSelect );
  pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
  if( pSel ){
    u8 eParseMode = pParse->eParseMode;
    pParse->eParseMode = PARSE_MODE_NORMAL;
    n = pParse->nTab;
    sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
    pTable->nCol = -1;
    DisableLookaside;
#ifndef SQLITE_OMIT_AUTHORIZATION
    xAuth = db->xAuth;
    db->xAuth = 0;
    pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
    db->xAuth = xAuth;
#else
    pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
#endif
    pParse->nTab = n;
    if( pSelTab==0 ){
      pTable->nCol = 0;
      nErr++;
    }else if( pTable->pCheck ){
      /* CREATE VIEW name(arglist) AS ...
      ** The names of the columns in the table are taken from
      ** arglist which is stored in pTable->pCheck.  The pCheck field
      ** normally holds CHECK constraints on an ordinary table, but for
      ** a VIEW it holds the list of column names.
      */
      sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
                                 &pTable->nCol, &pTable->aCol);
      if( db->mallocFailed==0
       && pParse->nErr==0
       && pTable->nCol==pSel->pEList->nExpr
      ){
        sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel,
                                               SQLITE_AFF_NONE);
      }
    }else{
      /* CREATE VIEW name AS...  without an argument list.  Construct
      ** the column names from the SELECT statement that defines the view.
      */
      assert( pTable->aCol==0 );
      pTable->nCol = pSelTab->nCol;
      pTable->aCol = pSelTab->aCol;
      pSelTab->nCol = 0;
      pSelTab->aCol = 0;
      assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
    }
    pTable->nNVCol = pTable->nCol;
    sqlite3DeleteTable(db, pSelTab);
    sqlite3SelectDelete(db, pSel);
    EnableLookaside;
    pParse->eParseMode = eParseMode;
  } else {
    nErr++;
  }
  pTable->pSchema->schemaFlags |= DB_UnresetViews;
  if( db->mallocFailed ){
    sqlite3DeleteColumnNames(db, pTable);

References Table::aCol, Parse::db, DB_UnresetViews, DisableLookaside, EnableLookaside, Parse::eParseMode, IsVirtual, sqlite3::mallocFailed, Table::nCol, Parse::nErr, ExprList::nExpr, Table::nNVCol, sqlite3::nSchemaLock, Parse::nTab, PARSE_MODE_NORMAL, Table::pCheck, Select::pEList, Table::pSchema, Table::pSelect, Select::pSrc, Schema::schemaFlags, sqlite3ColumnsFromExprList(), sqlite3DeleteColumnNames(), sqlite3DeleteTable(), sqlite3ErrorMsg(), sqlite3ResultSetOfSelect(), sqlite3SelectAddColumnTypeAndCollation(), sqlite3SelectDelete(), sqlite3SelectDup(), sqlite3SrcListAssignCursors(), sqlite3VtabCallConnect(), SQLITE_AFF_NONE, sqlite3::xAuth, and Table::zName.

Referenced by renameResolveTrigger(), selectExpander(), sqlite3DeleteFrom(), sqlite3Insert(), sqlite3Pragma(), and sqlite3Update().

◆ sqlite3VListAdd()

SQLITE_PRIVATE VList * sqlite3VListAdd	(	sqlite3 *	db,
		VList *	pIn,
		const char *	zName,
		int	nName,
		int	iVal )

Definition at line 32809 of file sqlite3.c.

 {
  int nInt;              /* number of sizeof(int) objects needed for zName */
  char *z;               /* Pointer to where zName will be stored */
  int i;                 /* Index in pIn[] where zName is stored */
 
  nInt = nName/4 + 3;
  assert( pIn==0 || pIn[0]>=3 );  /* Verify ok to add new elements */
  if( pIn==0 || pIn[1]+nInt > pIn[0] ){
    /* Enlarge the allocation */
    sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt;
    VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
    if( pOut==0 ) return pIn;
    if( pIn==0 ) pOut[1] = 2;
    pIn = pOut;
    pIn[0] = nAlloc;
  }
  i = pIn[1];
  pIn[i] = iVal;
  pIn[i+1] = nInt;
  z = (char*)&pIn[i+2];

References nName, sqlite3DbRealloc(), and zName.

Referenced by sqlite3ExprAssignVarNumber().

◆ sqlite3VListNameToNum()

SQLITE_PRIVATE int sqlite3VListNameToNum	(	VList *	pIn,
		const char *	zName,
		int	nName )

Definition at line 32863 of file sqlite3.c.

                                                                                  {
  int i, mx;
  if( pIn==0 ) return 0;
  mx = pIn[1];
  i = 2;
  do{

Referenced by sqlite3_bind_parameter_index(), and sqlite3ExprAssignVarNumber().

◆ sqlite3VListNumToName()

SQLITE_PRIVATE const char * sqlite3VListNumToName	(	VList *	pIn,
		int	iVal )

Definition at line 32847 of file sqlite3.c.

                                                                      {
  int i, mx;
  if( pIn==0 ) return 0;
  mx = pIn[1];
  i = 2;

Referenced by sqlite3_bind_parameter_name(), sqlite3ExprAssignVarNumber(), sqlite3ExprCodeTarget(), and sqlite3VdbeExec().

◆ sqlite3VMPrintf()

SQLITE_PRIVATE char * sqlite3VMPrintf	(	sqlite3 *	db,
		const char *	zFormat,
		va_list	ap )

Definition at line 29266 of file sqlite3.c.

                                                                                  {
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
  assert( db!=0 );
  sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                      db->aLimit[SQLITE_LIMIT_LENGTH]);
  acc.printfFlags = SQLITE_PRINTF_INTERNAL;
  sqlite3_str_vappendf(&acc, zFormat, ap);

Referenced by sqlite3ErrorMsg(), sqlite3ErrorWithMsg(), sqlite3NestedParse(), and sqlite3VdbeExplain().

◆ sqlite3VtabArgExtend()

SQLITE_PRIVATE void sqlite3VtabArgExtend	(	Parse *	pParse,
		Token *	p )

Definition at line 140105 of file sqlite3.c.

                                                                 {
  Token *pArg = &pParse->sArg;
  if( pArg->z==0 ){
    pArg->z = p->z;

Referenced by yy_reduce().

◆ sqlite3VtabArgInit()

SQLITE_PRIVATE void sqlite3VtabArgInit ( Parse * pParse )

Definition at line 140095 of file sqlite3.c.

Referenced by yy_reduce().

◆ sqlite3VtabBegin()

SQLITE_PRIVATE int sqlite3VtabBegin	(	sqlite3 *	db,
		VTable *	pVTab )

Definition at line 140564 of file sqlite3.c.

                                                               {
  int rc = SQLITE_OK;
  const sqlite3_module *pModule;
 
  /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
  ** than zero, then this function is being called from within a
  ** virtual module xSync() callback. It is illegal to write to
  ** virtual module tables in this case, so return SQLITE_LOCKED.
  */
  if( sqlite3VtabInSync(db) ){
    return SQLITE_LOCKED;
  }
  if( !pVTab ){
    return SQLITE_OK;
  }
  pModule = pVTab->pVtab->pModule;
 
  if( pModule->xBegin ){
    int i;
 
    /* If pVtab is already in the aVTrans array, return early */
    for(i=0; i<db->nVTrans; i++){
      if( db->aVTrans[i]==pVTab ){
        return SQLITE_OK;
      }
    }
 
    /* Invoke the xBegin method. If successful, add the vtab to the
    ** sqlite3.aVTrans[] array. */
    rc = growVTrans(db);
    if( rc==SQLITE_OK ){
      rc = pModule->xBegin(pVTab->pVtab);
      if( rc==SQLITE_OK ){
        int iSvpt = db->nStatement + db->nSavepoint;
        addToVTrans(db, pVTab);
        if( iSvpt && pModule->xSavepoint ){
          pVTab->iSavepoint = iSvpt;
          rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);

References addToVTrans(), sqlite3::aVTrans, growVTrans(), VTable::iSavepoint, sqlite3::nSavepoint, sqlite3::nStatement, sqlite3::nVTrans, sqlite3_vtab::pModule, VTable::pVtab, sqlite3VtabInSync, SQLITE_LOCKED, SQLITE_OK, sqlite3_module::xBegin, and sqlite3_module::xSavepoint.

Referenced by sqlite3VdbeExec().

◆ sqlite3VtabBeginParse()

SQLITE_PRIVATE void sqlite3VtabBeginParse	(	Parse *	pParse,
		Token *	pName1,
		Token *	pName2,
		Token *	pModuleName,
		int	ifNotExists )

Definition at line 139948 of file sqlite3.c.

 {
  Table *pTable;        /* The new virtual table */
  sqlite3 *db;          /* Database connection */
 
  sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);
  pTable = pParse->pNewTable;
  if( pTable==0 ) return;
  assert( 0==pTable->pIndex );
 
  db = pParse->db;
 
  assert( pTable->nModuleArg==0 );
  addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));
  addModuleArgument(pParse, pTable, 0);
  addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
  assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
       || (pParse->sNameToken.z==pName1->z && pName2->z==0)
  );
  pParse->sNameToken.n = (int)(
      &pModuleName->z[pModuleName->n] - pParse->sNameToken.z
  );
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  /* Creating a virtual table invokes the authorization callback twice.
  ** The first invocation, to obtain permission to INSERT a row into the
  ** sqlite_schema table, has already been made by sqlite3StartTable().
  ** The second call, to obtain permission to create the table, is made now.
  */
  if( pTable->azModuleArg ){
    int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);

References sqlite3::aDb, addModuleArgument(), Table::azModuleArg, Parse::db, Token::n, Table::nModuleArg, Table::pIndex, Parse::pNewTable, Table::pSchema, Parse::sNameToken, sqlite3AuthCheck(), sqlite3DbStrDup(), sqlite3NameFromToken(), sqlite3SchemaToIndex(), sqlite3StartTable(), SQLITE_CREATE_VTABLE, Token::z, Db::zDbSName, and Table::zName.

Referenced by yy_reduce().

◆ sqlite3VtabCallConnect()

SQLITE_PRIVATE int sqlite3VtabCallConnect	(	Parse *	pParse,
		Table *	pTab )

Definition at line 140253 of file sqlite3.c.

                                                                     {
  sqlite3 *db = pParse->db;
  const char *zMod;
  Module *pMod;
  int rc;
 
  assert( pTab );
  if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){
    return SQLITE_OK;
  }
 
  /* Locate the required virtual table module */
  zMod = pTab->azModuleArg[0];
  pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 
  if( !pMod ){
    const char *zModule = pTab->azModuleArg[0];
    sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
    rc = SQLITE_ERROR;
  }else{
    char *zErr = 0;
    rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorMsg(pParse, "%s", zErr);
      pParse->rc = rc;

References sqlite3::aModule, Table::azModuleArg, Parse::db, IsVirtual, Module::pModule, Parse::rc, sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3GetVTable(), sqlite3HashFind(), SQLITE_ERROR, SQLITE_OK, vtabCallConstructor(), and sqlite3_module::xConnect.

Referenced by sqlite3ViewGetColumnNames().

◆ sqlite3VtabCallCreate()

SQLITE_PRIVATE int sqlite3VtabCallCreate	(	sqlite3 *	db,
		int	iDb,
		const char *	zTab,
		char **	pzErr )

Definition at line 140325 of file sqlite3.c.

                                                                                              {
  int rc = SQLITE_OK;
  Table *pTab;
  Module *pMod;
  const char *zMod;
 
  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
  assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
 
  /* Locate the required virtual table module */
  zMod = pTab->azModuleArg[0];
  pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 
  /* If the module has been registered and includes a Create method,
  ** invoke it now. If the module has not been registered, return an
  ** error. Otherwise, do nothing.
  */
  if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){
    *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
    rc = SQLITE_ERROR;
  }else{
    rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
  }
 
  /* Justification of ALWAYS():  The xConstructor method is required to
  ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
  if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
    rc = growVTrans(db);
    if( rc==SQLITE_OK ){

References sqlite3::aDb, addToVTrans(), ALWAYS, sqlite3::aModule, Table::azModuleArg, growVTrans(), IsVirtual, Module::pModule, Table::pVTable, sqlite3FindTable(), sqlite3GetVTable(), sqlite3HashFind(), sqlite3MPrintf(), SQLITE_ERROR, SQLITE_OK, vtabCallConstructor(), sqlite3_module::xCreate, sqlite3_module::xDestroy, and Db::zDbSName.

Referenced by sqlite3VdbeExec().

◆ sqlite3VtabCallDestroy()

SQLITE_PRIVATE int sqlite3VtabCallDestroy	(	sqlite3 *	db,
		int	iDb,
		const char *	zTab )

Definition at line 140451 of file sqlite3.c.

                                                                                 {
  int rc = SQLITE_OK;
  Table *pTab;
 
  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
  if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){
    VTable *p;
    int (*xDestroy)(sqlite3_vtab *);
    for(p=pTab->pVTable; p; p=p->pNext){
      assert( p->pVtab );
      if( p->pVtab->nRef>0 ){
        return SQLITE_LOCKED;
      }
    }
    p = vtabDisconnectAll(db, pTab);
    xDestroy = p->pMod->pModule->xDestroy;
    if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
    assert( xDestroy!=0 );
    pTab->nTabRef++;
    rc = xDestroy(p->pVtab);
    /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
    if( rc==SQLITE_OK ){
      assert( pTab->pVTable==p && p->pNext==0 );
      p->pVtab = 0;
      pTab->pVTable = 0;
      sqlite3VtabUnlock(p);

References sqlite3::aDb, ALWAYS, sqlite3_vtab::nRef, Table::nTabRef, VTable::pMod, Module::pModule, VTable::pNext, VTable::pVtab, Table::pVTable, sqlite3DeleteTable(), sqlite3FindTable(), sqlite3VtabUnlock(), SQLITE_LOCKED, SQLITE_OK, vtabDisconnectAll(), sqlite3_module::xDestroy, sqlite3_module::xDisconnect, and Db::zDbSName.

Referenced by sqlite3VdbeExec().

◆ sqlite3VtabClear()

SQLITE_PRIVATE void sqlite3VtabClear	(	sqlite3 *	db,
		Table *	p )

Definition at line 139908 of file sqlite3.c.

                                                           {
  if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
  if( p->azModuleArg ){
    int i;

References Table::azModuleArg, Table::nModuleArg, sqlite3::pnBytesFreed, sqlite3DbFree(), and vtabDisconnectAll().

Referenced by deleteTable().

◆ sqlite3VtabCommit()

SQLITE_PRIVATE int sqlite3VtabCommit ( sqlite3 * db )

Definition at line 140551 of file sqlite3.c.

Referenced by vdbeCommit().

◆ sqlite3VtabCreateModule()

SQLITE_PRIVATE Module * sqlite3VtabCreateModule	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	pModule,
		void *	pAux,
		void()(void )	xDestroy )

Definition at line 139610 of file sqlite3.c.

 {
  Module *pMod;
  Module *pDel;
  char *zCopy;
  if( pModule==0 ){
    zCopy = (char*)zName;
    pMod = 0;
  }else{
    int nName = sqlite3Strlen30(zName);
    pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1);
    if( pMod==0 ){
      sqlite3OomFault(db);
      return 0;
    }
    zCopy = (char *)(&pMod[1]);
    memcpy(zCopy, zName, nName+1);
    pMod->zName = zCopy;
    pMod->pModule = pModule;
    pMod->pAux = pAux;
    pMod->xDestroy = xDestroy;
    pMod->pEpoTab = 0;
    pMod->nRefModule = 1;
  }
  pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
  if( pDel ){
    if( pDel==pMod ){
      sqlite3OomFault(db);
      sqlite3DbFree(db, pDel);
      pMod = 0;
    }else{

References sqlite3::aModule, nName, Module::nRefModule, Module::pAux, Module::pEpoTab, Module::pModule, sqlite3DbFree(), sqlite3HashInsert(), sqlite3Malloc(), sqlite3OomFault(), sqlite3Strlen30(), sqlite3VtabEponymousTableClear(), sqlite3VtabModuleUnref(), Module::xDestroy, Module::zName, and zName.

Referenced by createModule(), and sqlite3PragmaVtabRegister().

◆ sqlite3VtabDisconnect()

SQLITE_PRIVATE void sqlite3VtabDisconnect	(	sqlite3 *	db,
		Table *	p )

Definition at line 139839 of file sqlite3.c.

                                                                {
  VTable **ppVTab;
 
  assert( IsVirtual(p) );
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  assert( sqlite3_mutex_held(db->mutex) );
 
  for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){
    if( (*ppVTab)->db==db  ){
      VTable *pVTab = *ppVTab;

References IsVirtual, sqlite3::mutex, VTable::pNext, Table::pVTable, sqlite3_mutex_held(), and sqlite3VtabUnlock().

◆ sqlite3VtabEponymousTableClear()

SQLITE_PRIVATE void sqlite3VtabEponymousTableClear	(	sqlite3 *	db,
		Module *	pMod )

Definition at line 140811 of file sqlite3.c.

                                                                             {
  Table *pTab = pMod->pEpoTab;
  if( pTab!=0 ){
    /* Mark the table as Ephemeral prior to deleting it, so that the
    ** sqlite3DeleteTable() routine will know that it is not stored in

Referenced by sqlite3LeaveMutexAndCloseZombie(), sqlite3VtabCreateModule(), and sqlite3VtabEponymousTableInit().

◆ sqlite3VtabEponymousTableInit()

SQLITE_PRIVATE int sqlite3VtabEponymousTableInit	(	Parse *	pParse,
		Module *	pMod )

Definition at line 140774 of file sqlite3.c.

                                                                             {
  const sqlite3_module *pModule = pMod->pModule;
  Table *pTab;
  char *zErr = 0;
  int rc;
  sqlite3 *db = pParse->db;
  if( pMod->pEpoTab ) return 1;
  if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0;
  pTab = sqlite3DbMallocZero(db, sizeof(Table));
  if( pTab==0 ) return 0;
  pTab->zName = sqlite3DbStrDup(db, pMod->zName);
  if( pTab->zName==0 ){
    sqlite3DbFree(db, pTab);
    return 0;
  }
  pMod->pEpoTab = pTab;
  pTab->nTabRef = 1;
  pTab->pSchema = db->aDb[0].pSchema;
  assert( pTab->nModuleArg==0 );
  pTab->iPKey = -1;
  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
  addModuleArgument(pParse, pTab, 0);
  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
  rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
  if( rc ){
    sqlite3ErrorMsg(pParse, "%s", zErr);

References sqlite3::aDb, addModuleArgument(), Parse::db, Table::iPKey, Table::nModuleArg, Table::nTabRef, Module::pEpoTab, Module::pModule, Db::pSchema, Table::pSchema, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3VtabEponymousTableClear(), vtabCallConstructor(), sqlite3_module::xConnect, sqlite3_module::xCreate, Module::zName, and Table::zName.

Referenced by sqlite3LocateTable().

◆ sqlite3VtabFinishParse()

SQLITE_PRIVATE void sqlite3VtabFinishParse	(	Parse *	pParse,
		Token *	pEnd )

Definition at line 140009 of file sqlite3.c.

                                                                      {
  Table *pTab = pParse->pNewTable;  /* The table being constructed */
  sqlite3 *db = pParse->db;         /* The database connection */
 
  if( pTab==0 ) return;
  addArgumentToVtab(pParse);
  pParse->sArg.z = 0;
  if( pTab->nModuleArg<1 ) return;
 
  /* If the CREATE VIRTUAL TABLE statement is being entered for the
  ** first time (in other words if the virtual table is actually being
  ** created now instead of just being read out of sqlite_schema) then
  ** do additional initialization work and store the statement text
  ** in the sqlite_schema table.
  */
  if( !db->init.busy ){
    char *zStmt;
    char *zWhere;
    int iDb;
    int iReg;
    Vdbe *v;
 
    sqlite3MayAbort(pParse);
 
    /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
    if( pEnd ){
      pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
    }
    zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
 
    /* A slot for the record has already been allocated in the
    ** schema table.  We just need to update that slot with all
    ** the information we've collected.
    **
    ** The VM register number pParse->regRowid holds the rowid of an
    ** entry in the sqlite_schema table tht was created for this vtab
    ** by sqlite3StartTable().
    */
    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
    sqlite3NestedParse(pParse,
      "UPDATE %Q." DFLT_SCHEMA_TABLE " "
         "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
       "WHERE rowid=#%d",
      db->aDb[iDb].zDbSName,
      pTab->zName,
      pTab->zName,
      zStmt,
      pParse->regRowid
    );
    v = sqlite3GetVdbe(pParse);
    sqlite3ChangeCookie(pParse, iDb);
 
    sqlite3VdbeAddOp0(v, OP_Expire);
    zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
    sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
    sqlite3DbFree(db, zStmt);
 
    iReg = ++pParse->nMem;
    sqlite3VdbeLoadString(v, iReg, pTab->zName);
    sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
  }
 
  /* If we are rereading the sqlite_schema table create the in-memory
  ** record of the table. The xConnect() method is not called until
  ** the first time the virtual table is used in an SQL statement. This
  ** allows a schema that contains virtual tables to be loaded before
  ** the required virtual table implementations are registered.  */
  else {
    Table *pOld;
    Schema *pSchema = pTab->pSchema;
    const char *zName = pTab->zName;
    assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
    pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
    if( pOld ){
      sqlite3OomFault(db);

Referenced by yy_reduce().

◆ sqlite3VtabImportErrmsg()

SQLITE_PRIVATE void sqlite3VtabImportErrmsg	(	Vdbe *	p,
		sqlite3_vtab *	pVtab )

Definition at line 82880 of file sqlite3.c.

                                                                         {
  if( pVtab->zErrMsg ){
    sqlite3 *db = p->db;

References Vdbe::db, sqlite3_free(), sqlite3DbFree(), sqlite3DbStrDup(), sqlite3_vtab::zErrMsg, and Vdbe::zErrMsg.

Referenced by sqlite3VdbeExec(), and sqlite3VtabSync().

◆ sqlite3VtabLock()

SQLITE_PRIVATE void sqlite3VtabLock ( VTable * pVTab )

Definition at line 139753 of file sqlite3.c.

References VTable::nRef.

Referenced by sqlite3VtabSavepoint().

◆ sqlite3VtabMakeWritable()

SQLITE_PRIVATE void sqlite3VtabMakeWritable	(	Parse *	pParse,
		Table *	pTab )

Definition at line 140741 of file sqlite3.c.

                                                                       {
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i, n;
  Table **apVtabLock;
 
  assert( IsVirtual(pTab) );
  for(i=0; i<pToplevel->nVtabLock; i++){
    if( pTab==pToplevel->apVtabLock[i] ) return;
  }
  n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
  apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n);
  if( apVtabLock ){

References Parse::apVtabLock, Parse::db, IsVirtual, Parse::nVtabLock, sqlite3OomFault(), sqlite3ParseToplevel, and sqlite3Realloc().

Referenced by sqlite3DeleteFrom(), sqlite3Insert(), and updateVirtualTable().

◆ sqlite3VtabModuleUnref()

SQLITE_PRIVATE void sqlite3VtabModuleUnref	(	sqlite3 *	db,
		Module *	pMod )

Definition at line 139733 of file sqlite3.c.

                                                                     {
  assert( pMod->nRefModule>0 );
  pMod->nRefModule--;
  if( pMod->nRefModule==0 ){
    if( pMod->xDestroy ){

Referenced by sqlite3LeaveMutexAndCloseZombie(), and sqlite3VtabCreateModule().

◆ sqlite3VtabOverloadFunction()

SQLITE_PRIVATE FuncDef * sqlite3VtabOverloadFunction	(	sqlite3 *	db,
		FuncDef *	pDef,
		int	nArg,
		Expr *	pExpr )

Definition at line 140672 of file sqlite3.c.

 {
  Table *pTab;
  sqlite3_vtab *pVtab;
  sqlite3_module *pMod;
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
  void *pArg = 0;
  FuncDef *pNew;
  int rc = 0;
 
  /* Check to see the left operand is a column in a virtual table */
  if( NEVER(pExpr==0) ) return pDef;
  if( pExpr->op!=TK_COLUMN ) return pDef;
  pTab = pExpr->y.pTab;
  if( pTab==0 ) return pDef;
  if( !IsVirtual(pTab) ) return pDef;
  pVtab = sqlite3GetVTable(db, pTab)->pVtab;
  assert( pVtab!=0 );
  assert( pVtab->pModule!=0 );
  pMod = (sqlite3_module *)pVtab->pModule;
  if( pMod->xFindFunction==0 ) return pDef;
 
  /* Call the xFindFunction method on the virtual table implementation
  ** to see if the implementation wants to overload this function.
  **
  ** Though undocumented, we have historically always invoked xFindFunction
  ** with an all lower-case function name.  Continue in this tradition to
  ** avoid any chance of an incompatibility.
  */
#ifdef SQLITE_DEBUG
  {
    int i;
    for(i=0; pDef->zName[i]; i++){
      unsigned char x = (unsigned char)pDef->zName[i];
      assert( x==sqlite3UpperToLower[x] );
    }
  }
#endif
  rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
  if( rc==0 ){
    return pDef;
  }
 
  /* Create a new ephemeral function definition for the overloaded
  ** function */
  pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
                             + sqlite3Strlen30(pDef->zName) + 1);
  if( pNew==0 ){
    return pDef;
  }
  *pNew = *pDef;
  pNew->zName = (const char*)&pNew[1];

References FuncDef::funcFlags, IsVirtual, NEVER, Expr::op, sqlite3_vtab::pModule, Expr::pTab, FuncDef::pUserData, VTable::pVtab, sqlite3DbMallocZero(), sqlite3GetVTable(), sqlite3Strlen30(), sqlite3UpperToLower, SQLITE_FUNC_EPHEM, TK_COLUMN, sqlite3_module::xFindFunction, FuncDef::xSFunc, Expr::y, and FuncDef::zName.

Referenced by sqlite3ExprCodeTarget().

◆ sqlite3VtabRollback()

SQLITE_PRIVATE int sqlite3VtabRollback ( sqlite3 * db )

Definition at line 140542 of file sqlite3.c.

Referenced by sqlite3RollbackAll().

◆ sqlite3VtabSavepoint()

SQLITE_PRIVATE int sqlite3VtabSavepoint	(	sqlite3 *	db,
		int	op,
		int	iSavepoint )

Definition at line 140624 of file sqlite3.c.

                                                                            {
  int rc = SQLITE_OK;
 
  assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
  assert( iSavepoint>=-1 );
  if( db->aVTrans ){
    int i;
    for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
      VTable *pVTab = db->aVTrans[i];
      const sqlite3_module *pMod = pVTab->pMod->pModule;
      if( pVTab->pVtab && pMod->iVersion>=2 ){
        int (*xMethod)(sqlite3_vtab *, int);
        sqlite3VtabLock(pVTab);
        switch( op ){
          case SAVEPOINT_BEGIN:
            xMethod = pMod->xSavepoint;
            pVTab->iSavepoint = iSavepoint+1;
            break;
          case SAVEPOINT_ROLLBACK:
            xMethod = pMod->xRollbackTo;
            break;
          default:
            xMethod = pMod->xRelease;
            break;
        }
        if( xMethod && pVTab->iSavepoint>iSavepoint ){
          rc = xMethod(pVTab->pVtab, iSavepoint);
        }

References sqlite3::aVTrans, VTable::iSavepoint, sqlite3_module::iVersion, sqlite3::nVTrans, VTable::pMod, Module::pModule, VTable::pVtab, SAVEPOINT_BEGIN, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, sqlite3VtabLock(), sqlite3VtabUnlock(), SQLITE_OK, sqlite3_module::xRelease, sqlite3_module::xRollbackTo, and sqlite3_module::xSavepoint.

Referenced by sqlite3VdbeExec(), and vdbeCloseStatement().

◆ sqlite3VtabSync()

SQLITE_PRIVATE int sqlite3VtabSync	(	sqlite3 *	db,
		Vdbe *	p )

Definition at line 140520 of file sqlite3.c.

                                                        {
  int i;
  int rc = SQLITE_OK;
  VTable **aVTrans = db->aVTrans;
 
  db->aVTrans = 0;
  for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
    int (*x)(sqlite3_vtab *);
    sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
    if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
      rc = x(pVtab);

References sqlite3::aVTrans, sqlite3::nVTrans, sqlite3_vtab::pModule, VTable::pVtab, sqlite3VtabImportErrmsg(), SQLITE_OK, and sqlite3_module::xSync.

Referenced by vdbeCommit().

◆ sqlite3VtabUnlock()

SQLITE_PRIVATE void sqlite3VtabUnlock ( VTable * pVTab )

Definition at line 139774 of file sqlite3.c.

                                                    {
  sqlite3 *db = pVTab->db;
 
  assert( db );
  assert( pVTab->nRef>0 );
  assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
 
  pVTab->nRef--;
  if( pVTab->nRef==0 ){
    sqlite3_vtab *p = pVTab->pVtab;
    sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);

Referenced by callFinaliser(), sqlite3VtabCallDestroy(), sqlite3VtabDisconnect(), sqlite3VtabSavepoint(), sqlite3VtabUnlockList(), and vtabCallConstructor().

◆ sqlite3VtabUnlockList()

SQLITE_PRIVATE void sqlite3VtabUnlockList ( sqlite3 * db )

Definition at line 139877 of file sqlite3.c.

                                                      {
  VTable *p = db->pDisconnect;
 
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  assert( sqlite3_mutex_held(db->mutex) );
 
  if( p ){
    db->pDisconnect = 0;
    sqlite3ExpirePreparedStatements(db, 0);
    do {

References sqlite3::mutex, sqlite3::pDisconnect, VTable::pNext, sqlite3_mutex_held(), sqlite3ExpirePreparedStatements(), and sqlite3VtabUnlock().

Referenced by sqlite3LeaveMutexAndCloseZombie().

◆ sqlite3WalBeginReadTransaction()

SQLITE_PRIVATE int sqlite3WalBeginReadTransaction	(	Wal *	pWal,
		int *	pChanged )

Definition at line 62303 of file sqlite3.c.

                                                                           {
  int rc;                         /* Return code */
  int cnt = 0;                    /* Number of TryBeginRead attempts */
#ifdef SQLITE_ENABLE_SNAPSHOT
  int bChanged = 0;
  WalIndexHdr *pSnapshot = pWal->pSnapshot;
#endif
 
  assert( pWal->ckptLock==0 );
 
#ifdef SQLITE_ENABLE_SNAPSHOT
  if( pSnapshot ){
    if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
      bChanged = 1;
    }
 
    /* It is possible that there is a checkpointer thread running
    ** concurrent with this code. If this is the case, it may be that the
    ** checkpointer has already determined that it will checkpoint
    ** snapshot X, where X is later in the wal file than pSnapshot, but
    ** has not yet set the pInfo->nBackfillAttempted variable to indicate
    ** its intent. To avoid the race condition this leads to, ensure that
    ** there is no checkpointer process by taking a shared CKPT lock
    ** before checking pInfo->nBackfillAttempted.  */
    (void)walEnableBlocking(pWal);
    rc = walLockShared(pWal, WAL_CKPT_LOCK);
    walDisableBlocking(pWal);
 
    if( rc!=SQLITE_OK ){
      return rc;
    }
    pWal->ckptLock = 1;
  }
#endif
 
  do{
    rc = walTryBeginRead(pWal, pChanged, 0, ++cnt);
  }while( rc==WAL_RETRY );
  testcase( (rc&0xff)==SQLITE_BUSY );
  testcase( (rc&0xff)==SQLITE_IOERR );
  testcase( rc==SQLITE_PROTOCOL );
  testcase( rc==SQLITE_OK );
 
#ifdef SQLITE_ENABLE_SNAPSHOT
  if( rc==SQLITE_OK ){
    if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
      /* At this point the client has a lock on an aReadMark[] slot holding
      ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr
      ** is populated with the wal-index header corresponding to the head
      ** of the wal file. Verify that pSnapshot is still valid before
      ** continuing.  Reasons why pSnapshot might no longer be valid:
      **
      **    (1)  The WAL file has been reset since the snapshot was taken.
      **         In this case, the salt will have changed.
      **
      **    (2)  A checkpoint as been attempted that wrote frames past
      **         pSnapshot->mxFrame into the database file.  Note that the
      **         checkpoint need not have completed for this to cause problems.
      */
      volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
 
      assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 );
      assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame );
 
      /* Check that the wal file has not been wrapped. Assuming that it has
      ** not, also check that no checkpointer has attempted to checkpoint any
      ** frames beyond pSnapshot->mxFrame. If either of these conditions are
      ** true, return SQLITE_ERROR_SNAPSHOT. Otherwise, overwrite pWal->hdr
      ** with *pSnapshot and set *pChanged as appropriate for opening the
      ** snapshot.  */
      if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
       && pSnapshot->mxFrame>=pInfo->nBackfillAttempted
      ){
        assert( pWal->readLock>0 );
        memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr));
        *pChanged = bChanged;
      }else{
        rc = SQLITE_ERROR_SNAPSHOT;
      }
 
      /* A client using a non-current snapshot may not ignore any frames
      ** from the start of the wal file. This is because, for a system
      ** where (minFrame < iSnapshot < maxFrame), a checkpointer may
      ** have omitted to checkpoint a frame earlier than minFrame in
      ** the file because there exists a frame after iSnapshot that
      ** is the same database page.  */
      pWal->minFrame = 1;
 
      if( rc!=SQLITE_OK ){
        sqlite3WalEndReadTransaction(pWal);
      }
    }
  }
 
  /* Release the shared CKPT lock obtained above. */
  if( pWal->ckptLock ){
    assert( pSnapshot );

References WalCkptInfo::aReadMark, WalIndexHdr::aSalt, Wal::ckptLock, Wal::hdr, Wal::minFrame, WalIndexHdr::mxFrame, WalCkptInfo::nBackfillAttempted, Wal::readLock, sqlite3WalEndReadTransaction(), SQLITE_BUSY, SQLITE_ERROR_SNAPSHOT, SQLITE_IOERR, SQLITE_OK, SQLITE_PROTOCOL, testcase, WAL_CKPT_LOCK, WAL_RETRY, walCkptInfo(), walDisableBlocking, walEnableBlocking, walLockShared(), walTryBeginRead(), and walUnlockShared().

Referenced by pagerBeginReadTransaction().

◆ sqlite3WalBeginWriteTransaction()

SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction ( Wal * pWal )

Definition at line 62572 of file sqlite3.c.

                                                             {
  int rc;
 
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  /* If the write-lock is already held, then it was obtained before the
  ** read-transaction was even opened, making this call a no-op.
  ** Return early. */
  if( pWal->writeLock ){
    assert( !memcmp(&pWal->hdr,(void *)walIndexHdr(pWal),sizeof(WalIndexHdr)) );
    return SQLITE_OK;
  }
#endif
 
  /* Cannot start a write transaction without first holding a read
  ** transaction. */
  assert( pWal->readLock>=0 );
  assert( pWal->writeLock==0 && pWal->iReCksum==0 );
 
  if( pWal->readOnly ){
    return SQLITE_READONLY;
  }
 
  /* Only one writer allowed at a time.  Get the write lock.  Return
  ** SQLITE_BUSY if unable.
  */
  rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
  if( rc ){
    return rc;
  }
  pWal->writeLock = 1;
 
  /* If another connection has written to the database file since the
  ** time the read transaction on this connection was started, then
  ** the write is disallowed.
  */
  if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
    walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);

References Wal::hdr, Wal::iReCksum, Wal::readLock, Wal::readOnly, SQLITE_BUSY_SNAPSHOT, SQLITE_OK, SQLITE_READONLY, WAL_WRITE_LOCK, walIndexHdr(), walLockExclusive(), walUnlockExclusive(), and Wal::writeLock.

Referenced by sqlite3PagerBegin().

◆ sqlite3WalCallback()

SQLITE_PRIVATE int sqlite3WalCallback ( Wal * pWal )

Definition at line 63259 of file sqlite3.c.

63265 {

63266 u32 ret = 0;

References Wal::iCallback.

◆ sqlite3WalCheckpoint()

SQLITE_PRIVATE int sqlite3WalCheckpoint	(	Wal *	pWal,
		sqlite3 *	db,
		int	eMode,
		int()(void )	xBusy,
		void *	pBusyArg,
		int	sync_flags,
		int	nBuf,
		u8 *	zBuf,
		int *	pnLog,
		int *	pnCkpt )

Definition at line 63134 of file sqlite3.c.

 {
  int rc;                         /* Return code */
  int isChanged = 0;              /* True if a new wal-index header is loaded */
  int eMode2 = eMode;             /* Mode to pass to walCheckpoint() */
  int (*xBusy2)(void*) = xBusy;   /* Busy handler for eMode2 */
 
  assert( pWal->ckptLock==0 );
  assert( pWal->writeLock==0 );
 
  /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
  ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
  assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
 
  if( pWal->readOnly ) return SQLITE_READONLY;
  WALTRACE(("WAL%p: checkpoint begins\n", pWal));
 
  /* Enable blocking locks, if possible. If blocking locks are successfully
  ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */
  sqlite3WalDb(pWal, db);
  (void)walEnableBlocking(pWal);
 
  /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive
  ** "checkpoint" lock on the database file.
  ** EVIDENCE-OF: R-10421-19736 If any other process is running a
  ** checkpoint operation at the same time, the lock cannot be obtained and
  ** SQLITE_BUSY is returned.
  ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured,
  ** it will not be invoked in this case.
  */
  rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
  testcase( rc==SQLITE_BUSY );
  testcase( rc!=SQLITE_OK && xBusy2!=0 );
  if( rc==SQLITE_OK ){
    pWal->ckptLock = 1;
 
    /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and
    ** TRUNCATE modes also obtain the exclusive "writer" lock on the database
    ** file.
    **
    ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained
    ** immediately, and a busy-handler is configured, it is invoked and the
    ** writer lock retried until either the busy-handler returns 0 or the
    ** lock is successfully obtained.
    */
    if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){
      rc = walBusyLock(pWal, xBusy2, pBusyArg, WAL_WRITE_LOCK, 1);
      if( rc==SQLITE_OK ){
        pWal->writeLock = 1;
      }else if( rc==SQLITE_BUSY ){
        eMode2 = SQLITE_CHECKPOINT_PASSIVE;
        xBusy2 = 0;
        rc = SQLITE_OK;
      }
    }
  }
 
 
  /* Read the wal-index header. */
  if( rc==SQLITE_OK ){
    walDisableBlocking(pWal);
    rc = walIndexReadHdr(pWal, &isChanged);
    (void)walEnableBlocking(pWal);
    if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){
      sqlite3OsUnfetch(pWal->pDbFd, 0, 0);
    }
  }
 
  /* Copy data from the log to the database file. */
  if( rc==SQLITE_OK ){
 
    if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      rc = walCheckpoint(pWal, db, eMode2, xBusy2, pBusyArg, sync_flags, zBuf);
    }
 
    /* If no error occurred, set the output variables. */
    if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
      if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
      if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
    }
  }
 
  if( isChanged ){
    /* If a new wal-index header was loaded before the checkpoint was
    ** performed, then the pager-cache associated with pWal is now
    ** out of date. So zero the cached wal-index header to ensure that
    ** next time the pager opens a snapshot on this database it knows that
    ** the cache needs to be reset.
    */
    memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
  }
 
  walDisableBlocking(pWal);
  sqlite3WalDb(pWal, 0);
 
  /* Release the locks. */
  sqlite3WalEndWriteTransaction(pWal);
  if( pWal->ckptLock ){
    walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
    pWal->ckptLock = 0;
  }

References Wal::ckptLock, Wal::hdr, sqlite3_io_methods::iVersion, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, Wal::pDbFd, sqlite3_file::pMethods, Wal::readOnly, sqlite3OsUnfetch(), sqlite3WalDb, sqlite3WalEndWriteTransaction(), SQLITE_BUSY, SQLITE_BUSY_TIMEOUT, SQLITE_CHECKPOINT_PASSIVE, SQLITE_CORRUPT_BKPT, SQLITE_OK, SQLITE_READONLY, testcase, WAL_CKPT_LOCK, WAL_WRITE_LOCK, walBusyLock(), walCheckpoint(), walCkptInfo(), walDisableBlocking, walEnableBlocking, walIndexReadHdr(), walLockExclusive(), walPagesize(), WALTRACE, walUnlockExclusive(), and Wal::writeLock.

Referenced by sqlite3PagerCheckpoint().

◆ sqlite3WalClose()

SQLITE_PRIVATE int sqlite3WalClose	(	Wal *	pWal,
		sqlite3 *	db,
		int	sync_flags,
		int	nBuf,
		u8 *	zBuf )

Definition at line 61533 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  if( pWal ){
    int isDelete = 0;             /* True to unlink wal and wal-index files */
 
    /* If an EXCLUSIVE lock can be obtained on the database file (using the
    ** ordinary, rollback-mode locking methods, this guarantees that the
    ** connection associated with this log file is the only connection to
    ** the database. In this case checkpoint the database and unlink both
    ** the wal and wal-index files.
    **
    ** The EXCLUSIVE lock is not released before returning.
    */
    if( zBuf!=0
     && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
    ){
      if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
        pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
      }
      rc = sqlite3WalCheckpoint(pWal, db,
          SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
      );
      if( rc==SQLITE_OK ){
        int bPersist = -1;
        sqlite3OsFileControlHint(
            pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
        );
        if( bPersist!=1 ){
          /* Try to delete the WAL file if the checkpoint completed and
          ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
          ** mode (!bPersist) */
          isDelete = 1;
        }else if( pWal->mxWalSize>=0 ){
          /* Try to truncate the WAL file to zero bytes if the checkpoint
          ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
          ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
          ** non-negative value (pWal->mxWalSize>=0).  Note that we truncate
          ** to zero bytes as truncating to the journal_size_limit might
          ** leave a corrupt WAL file on disk. */
          walLimitSize(pWal, 0);
        }
      }
    }
 
    walIndexClose(pWal, isDelete);
    sqlite3OsClose(pWal->pWalFd);
    if( isDelete ){
      sqlite3BeginBenignMalloc();
      sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
      sqlite3EndBenignMalloc();
    }

Referenced by sqlite3PagerClose(), and sqlite3PagerCloseWal().

◆ sqlite3WalDbsize()

SQLITE_PRIVATE Pgno sqlite3WalDbsize ( Wal * pWal )

Definition at line 62551 of file sqlite3.c.

                                                         : nOut), iOffset);
}
 
/*
** Return the size of the database in pages (or zero, if unknown).
*/

Referenced by pagerPagecount().

◆ sqlite3WalDefaultHook()

SQLITE_PRIVATE int sqlite3WalDefaultHook	(	void *	pClientData,
		sqlite3 *	db,
		const char *	zDb,
		int	nFrame )

Definition at line 163255 of file sqlite3.c.

163266 {

163267 if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){

References sqlite3_wal_checkpoint(), sqlite3BeginBenignMalloc(), sqlite3EndBenignMalloc(), SQLITE_OK, and SQLITE_PTR_TO_INT.

Referenced by sqlite3_wal_autocheckpoint(), and sqlite3Pragma().

◆ sqlite3WalEndReadTransaction()

SQLITE_PRIVATE void sqlite3WalEndReadTransaction ( Wal * pWal )

Definition at line 62411 of file sqlite3.c.

62417 {

Referenced by pager_unlock(), pagerBeginReadTransaction(), sqlite3WalBeginReadTransaction(), and walBeginShmUnreliable().

◆ sqlite3WalEndWriteTransaction()

SQLITE_PRIVATE int sqlite3WalEndWriteTransaction ( Wal * pWal )

Definition at line 62620 of file sqlite3.c.

                                                           {
  if( pWal->writeLock ){
    walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);

Referenced by pager_end_transaction(), and sqlite3WalCheckpoint().

◆ sqlite3WalExclusiveMode()

SQLITE_PRIVATE int sqlite3WalExclusiveMode	(	Wal *	pWal,
		int	op )

Definition at line 63292 of file sqlite3.c.

                                                             {
  int rc;
  assert( pWal->writeLock==0 );
  assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
 
  /* pWal->readLock is usually set, but might be -1 if there was a
  ** prior error while attempting to acquire are read-lock. This cannot
  ** happen if the connection is actually in exclusive mode (as no xShmLock
  ** locks are taken in this case). Nor should the pager attempt to
  ** upgrade to exclusive-mode following such an error.
  */
  assert( pWal->readLock>=0 || pWal->lockError );
  assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
 
  if( op==0 ){
    if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){
      pWal->exclusiveMode = WAL_NORMAL_MODE;
      if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
        pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
      }
      rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
    }else{
      /* Already in locking_mode=NORMAL */
      rc = 0;
    }
  }else if( op>0 ){
    assert( pWal->exclusiveMode==WAL_NORMAL_MODE );
    assert( pWal->readLock>=0 );
    walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
    pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;

References Wal::exclusiveMode, Wal::readLock, SQLITE_OK, WAL_EXCLUSIVE_MODE, WAL_HEAPMEMORY_MODE, WAL_NORMAL_MODE, WAL_READ_LOCK, walLockShared(), walUnlockShared(), and Wal::writeLock.

Referenced by pager_end_transaction(), and sqlite3PagerBegin().

◆ sqlite3WalFile()

SQLITE_PRIVATE sqlite3_file * sqlite3WalFile ( Wal * pWal )

Definition at line 63443 of file sqlite3.c.

                              : 0);
}
#endif

◆ sqlite3WalFindFrame()

SQLITE_PRIVATE int sqlite3WalFindFrame	(	Wal *	pWal,
		Pgno	pgno,
		u32 *	piRead )

Definition at line 62427 of file sqlite3.c.

 {
  u32 iRead = 0;                  /* If !=0, WAL frame to return data from */
  u32 iLast = pWal->hdr.mxFrame;  /* Last page in WAL for this reader */
  int iHash;                      /* Used to loop through N hash tables */
  int iMinHash;
 
  /* This routine is only be called from within a read transaction. */
  assert( pWal->readLock>=0 || pWal->lockError );
 
  /* If the "last page" field of the wal-index header snapshot is 0, then
  ** no data will be read from the wal under any circumstances. Return early
  ** in this case as an optimization.  Likewise, if pWal->readLock==0,
  ** then the WAL is ignored by the reader so return early, as if the
  ** WAL were empty.
  */
  if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){
    *piRead = 0;
    return SQLITE_OK;
  }
 
  /* Search the hash table or tables for an entry matching page number
  ** pgno. Each iteration of the following for() loop searches one
  ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).
  **
  ** This code might run concurrently to the code in walIndexAppend()
  ** that adds entries to the wal-index (and possibly to this hash
  ** table). This means the value just read from the hash
  ** slot (aHash[iKey]) may have been added before or after the
  ** current read transaction was opened. Values added after the
  ** read transaction was opened may have been written incorrectly -
  ** i.e. these slots may contain garbage data. However, we assume
  ** that any slots written before the current read transaction was
  ** opened remain unmodified.
  **
  ** For the reasons above, the if(...) condition featured in the inner
  ** loop of the following block is more stringent that would be required
  ** if we had exclusive access to the hash-table:
  **
  **   (aPgno[iFrame]==pgno):
  **     This condition filters out normal hash-table collisions.
  **
  **   (iFrame<=iLast):
  **     This condition filters out entries that were added to the hash
  **     table after the current read-transaction had started.
  */
  iMinHash = walFramePage(pWal->minFrame);
  for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){
    WalHashLoc sLoc;              /* Hash table location */
    int iKey;                     /* Hash slot index */
    int nCollide;                 /* Number of hash collisions remaining */
    int rc;                       /* Error code */
    u32 iH;
 
    rc = walHashGet(pWal, iHash, &sLoc);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    nCollide = HASHTABLE_NSLOT;
    iKey = walHash(pgno);
    while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
      u32 iFrame = iH + sLoc.iZero;
      if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH]==pgno ){
        assert( iFrame>iRead || CORRUPT_DB );
        iRead = iFrame;
      }
      if( (nCollide--)==0 ){
        return SQLITE_CORRUPT_BKPT;
      }
      iKey = walNextHash(iKey);
    }
    if( iRead ) break;
  }
 
#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
  /* If expensive assert() statements are available, do a linear search
  ** of the wal-index file content. Make sure the results agree with the
  ** result obtained using the hash indexes above.  */
  {
    u32 iRead2 = 0;
    u32 iTest;
    assert( pWal->bShmUnreliable || pWal->minFrame>0 );
    for(iTest=iLast; iTest>=pWal->minFrame && iTest>0; iTest--){
      if( walFramePgno(pWal, iTest)==pgno ){
        iRead2 = iTest;
        break;
      }
    }
    assert( iRead==iRead2 );

References WalHashLoc::aHash, WalHashLoc::aPgno, AtomicLoad, Wal::bShmUnreliable, CORRUPT_DB, HASHTABLE_NSLOT, Wal::hdr, WalHashLoc::iZero, Wal::minFrame, WalIndexHdr::mxFrame, Wal::readLock, SQLITE_CORRUPT_BKPT, SQLITE_OK, walFramePage(), walFramePgno(), walHash(), walHashGet(), and walNextHash().

Referenced by readDbPage().

◆ sqlite3WalFrames()

SQLITE_PRIVATE int sqlite3WalFrames	(	Wal *	pWal,
		int	szPage,
		PgHdr *	pList,
		Pgno	nTruncate,
		int	isCommit,
		int	sync_flags )

Definition at line 62896 of file sqlite3.c.

 {
  int rc;                         /* Used to catch return codes */
  u32 iFrame;                     /* Next frame address */
  PgHdr *p;                       /* Iterator to run through pList with. */
  PgHdr *pLast = 0;               /* Last frame in list */
  int nExtra = 0;                 /* Number of extra copies of last page */
  int szFrame;                    /* The size of a single frame */
  i64 iOffset;                    /* Next byte to write in WAL file */
  WalWriter w;                    /* The writer */
  u32 iFirst = 0;                 /* First frame that may be overwritten */
  WalIndexHdr *pLive;             /* Pointer to shared header */
 
  assert( pList );
  assert( pWal->writeLock );
 
  /* If this frame set completes a transaction, then nTruncate>0.  If
  ** nTruncate==0 then this frame set does not complete the transaction. */
  assert( (isCommit!=0)==(nTruncate!=0) );
 
#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
  { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
    WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",
              pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
  }
#endif
 
  pLive = (WalIndexHdr*)walIndexHdr(pWal);
  if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){
    iFirst = pLive->mxFrame+1;
  }
 
  /* See if it is possible to write these frames into the start of the
  ** log file, instead of appending to it at pWal->hdr.mxFrame.
  */
  if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
    return rc;
  }
 
  /* If this is the first frame written into the log, write the WAL
  ** header to the start of the WAL file. See comments at the top of
  ** this source file for a description of the WAL header format.
  */
  iFrame = pWal->hdr.mxFrame;
  if( iFrame==0 ){
    u8 aWalHdr[WAL_HDRSIZE];      /* Buffer to assemble wal-header in */
    u32 aCksum[2];                /* Checksum for wal-header */
 
    sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN));
    sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION);
    sqlite3Put4byte(&aWalHdr[8], szPage);
    sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
    if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);
    memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
    walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);
    sqlite3Put4byte(&aWalHdr[24], aCksum[0]);
    sqlite3Put4byte(&aWalHdr[28], aCksum[1]);
 
    pWal->szPage = szPage;
    pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;
    pWal->hdr.aFrameCksum[0] = aCksum[0];
    pWal->hdr.aFrameCksum[1] = aCksum[1];
    pWal->truncateOnCommit = 1;
 
    rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
    WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
    if( rc!=SQLITE_OK ){
      return rc;
    }
 
    /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless
    ** all syncing is turned off by PRAGMA synchronous=OFF).  Otherwise
    ** an out-of-order write following a WAL restart could result in
    ** database corruption.  See the ticket:
    **
    **     https://sqlite.org/src/info/ff5be73dee
    */
    if( pWal->syncHeader ){
      rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
      if( rc ) return rc;
    }
  }
  assert( (int)pWal->szPage==szPage );
 
  /* Setup information needed to write frames into the WAL */
  w.pWal = pWal;
  w.pFd = pWal->pWalFd;
  w.iSyncPoint = 0;
  w.syncFlags = sync_flags;
  w.szPage = szPage;
  iOffset = walFrameOffset(iFrame+1, szPage);
  szFrame = szPage + WAL_FRAME_HDRSIZE;
 
  /* Write all frames into the log file exactly once */
  for(p=pList; p; p=p->pDirty){
    int nDbSize;   /* 0 normally.  Positive == commit flag */
 
    /* Check if this page has already been written into the wal file by
    ** the current transaction. If so, overwrite the existing frame and
    ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that
    ** checksums must be recomputed when the transaction is committed.  */
    if( iFirst && (p->pDirty || isCommit==0) ){
      u32 iWrite = 0;
      VVA_ONLY(rc =) sqlite3WalFindFrame(pWal, p->pgno, &iWrite);
      assert( rc==SQLITE_OK || iWrite==0 );
      if( iWrite>=iFirst ){
        i64 iOff = walFrameOffset(iWrite, szPage) + WAL_FRAME_HDRSIZE;
        void *pData;
        if( pWal->iReCksum==0 || iWrite<pWal->iReCksum ){
          pWal->iReCksum = iWrite;
        }
        pData = p->pData;
        rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
        if( rc ) return rc;
        p->flags &= ~PGHDR_WAL_APPEND;
        continue;
      }
    }
 
    iFrame++;
    assert( iOffset==walFrameOffset(iFrame, szPage) );
    nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
    rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
    if( rc ) return rc;
    pLast = p;
    iOffset += szFrame;
    p->flags |= PGHDR_WAL_APPEND;
  }
 
  /* Recalculate checksums within the wal file if required. */
  if( isCommit && pWal->iReCksum ){
    rc = walRewriteChecksums(pWal, iFrame);
    if( rc ) return rc;
  }
 
  /* If this is the end of a transaction, then we might need to pad
  ** the transaction and/or sync the WAL file.
  **
  ** Padding and syncing only occur if this set of frames complete a
  ** transaction and if PRAGMA synchronous=FULL.  If synchronous==NORMAL
  ** or synchronous==OFF, then no padding or syncing are needed.
  **
  ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
  ** needed and only the sync is done.  If padding is needed, then the
  ** final frame is repeated (with its commit mark) until the next sector
  ** boundary is crossed.  Only the part of the WAL prior to the last
  ** sector boundary is synced; the part of the last frame that extends
  ** past the sector boundary is written after the sync.
  */
  if( isCommit && WAL_SYNC_FLAGS(sync_flags)!=0 ){
    int bSync = 1;
    if( pWal->padToSectorBoundary ){
      int sectorSize = sqlite3SectorSize(pWal->pWalFd);
      w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
      bSync = (w.iSyncPoint==iOffset);
      testcase( bSync );
      while( iOffset<w.iSyncPoint ){
        rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
        if( rc ) return rc;
        iOffset += szFrame;
        nExtra++;
        assert( pLast!=0 );
      }
    }
    if( bSync ){
      assert( rc==SQLITE_OK );
      rc = sqlite3OsSync(w.pFd, WAL_SYNC_FLAGS(sync_flags));
    }
  }
 
  /* If this frame set completes the first transaction in the WAL and
  ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
  ** journal size limit, if possible.
  */
  if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){
    i64 sz = pWal->mxWalSize;
    if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){
      sz = walFrameOffset(iFrame+nExtra+1, szPage);
    }
    walLimitSize(pWal, sz);
    pWal->truncateOnCommit = 0;
  }
 
  /* Append data to the wal-index. It is not necessary to lock the
  ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index
  ** guarantees that there are no other writers, and no data that may
  ** be in use by existing readers is being overwritten.
  */
  iFrame = pWal->hdr.mxFrame;
  for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
    if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue;
    iFrame++;
    rc = walIndexAppend(pWal, iFrame, p->pgno);
  }
  assert( pLast!=0 || nExtra==0 );
  while( rc==SQLITE_OK && nExtra>0 ){
    iFrame++;
    nExtra--;
    rc = walIndexAppend(pWal, iFrame, pLast->pgno);
  }
 
  if( rc==SQLITE_OK ){
    /* Update the private copy of the header. */
    pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
    testcase( szPage<=32768 );
    testcase( szPage>=65536 );
    pWal->hdr.mxFrame = iFrame;
    if( isCommit ){
      pWal->hdr.iChange++;
      pWal->hdr.nPage = nTruncate;
    }
    /* If this is a commit, update the wal-index header too. */
    if( isCommit ){
      walIndexWriteHdr(pWal);
      pWal->iCallback = iFrame;

Referenced by pagerWalFrames().

◆ sqlite3WalHeapMemory()

SQLITE_PRIVATE int sqlite3WalHeapMemory ( Wal * pWal )

Definition at line 63334 of file sqlite3.c.

References Wal::exclusiveMode, and WAL_HEAPMEMORY_MODE.

Referenced by sqlite3PagerLockingMode().

◆ sqlite3WalkerDepthDecrease()

SQLITE_PRIVATE void sqlite3WalkerDepthDecrease	(	Walker *	pWalker,
		Select *	pSelect )

Definition at line 97719 of file sqlite3.c.

                                                                               {
  UNUSED_PARAMETER(pSelect);
  pWalker->walkerDepth++;

References UNUSED_PARAMETER, Walker::walkerDepth, and WRC_Continue.

Referenced by sqlite3ExprAnalyzeAggregates(), and sqlite3WindowRewrite().

◆ sqlite3WalkerDepthIncrease()

SQLITE_PRIVATE int sqlite3WalkerDepthIncrease	(	Walker *	pWalker,
		Select *	pSelect )

Definition at line 97714 of file sqlite3.c.

Referenced by sqlite3ExprAnalyzeAggregates(), and sqlite3WindowRewrite().

◆ sqlite3WalkExpr()

SQLITE_PRIVATE int sqlite3WalkExpr	(	Walker *	pWalker,
		Expr *	pExpr )

◆ sqlite3WalkExprList()

SQLITE_PRIVATE int sqlite3WalkExprList	(	Walker *	pWalker,
		ExprList *	p )

Definition at line 97608 of file sqlite3.c.

                                                                    {
  int i;
  struct ExprList_item *pItem;
  if( p ){

Referenced by renameColumnFunc(), renameTableFunc(), resolveExprStep(), selectWindowRewriteEList(), sqlite3FunctionUsesThisSrc(), sqlite3WalkSelectExpr(), sqlite3WalkSelectFrom(), walkExpr(), walkWindowList(), and whereIndexExprTrans().

◆ sqlite3WalkSelect()

SQLITE_PRIVATE int sqlite3WalkSelect	(	Walker *	pWalker,
		Select *	p )

Definition at line 97691 of file sqlite3.c.

                                                                {
  int rc;
  if( p==0 ) return WRC_Continue;
  if( pWalker->xSelectCallback==0 ) return WRC_Continue;
  do{
    rc = pWalker->xSelectCallback(pWalker, p);
    if( rc ) return rc & WRC_Abort;
    if( sqlite3WalkSelectExpr(pWalker, p)
     || sqlite3WalkSelectFrom(pWalker, p)
    ){
      return WRC_Abort;
    }
    if( pWalker->xSelectCallback2 ){

References Select::pPrior, sqlite3WalkSelectExpr(), sqlite3WalkSelectFrom(), WRC_Abort, WRC_Continue, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by flattenSubquery(), renameColumnFunc(), renameTableFunc(), resolveExprStep(), selectExpander(), sqlite3ResolveSelectNames(), sqlite3SelectAddTypeInfo(), sqlite3SelectExpand(), sqlite3WalkSelectFrom(), sqlite3WindowRewrite(), walkExpr(), and withExpand().

◆ sqlite3WalkSelectExpr()

SQLITE_PRIVATE int sqlite3WalkSelectExpr	(	Walker *	pWalker,
		Select *	p )

Definition at line 97625 of file sqlite3.c.

                                                                    {
  if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
  if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
  if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
  if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
  if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
  if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
#if !defined(SQLITE_OMIT_WINDOWFUNC) && !defined(SQLITE_OMIT_ALTERTABLE)
  {
    Parse *pParse = pWalker->pParse;
    if( pParse && IN_RENAME_OBJECT ){
      /* The following may return WRC_Abort if there are unresolvable
      ** symbols (e.g. a table that does not exist) in a window definition. */
      int rc = walkWindowList(pWalker, p->pWinDefn);

References IN_RENAME_OBJECT, Select::pEList, Select::pGroupBy, Select::pHaving, Select::pLimit, Select::pOrderBy, Walker::pParse, Select::pWhere, Select::pWinDefn, sqlite3WalkExpr(), sqlite3WalkExprList(), walkWindowList(), WRC_Abort, and WRC_Continue.

Referenced by sqlite3WalkSelect().

◆ sqlite3WalkSelectFrom()

SQLITE_PRIVATE int sqlite3WalkSelectFrom	(	Walker *	pWalker,
		Select *	p )

Definition at line 97653 of file sqlite3.c.

                                                                    {
  SrcList *pSrc;
  int i;
  struct SrcList_item *pItem;
 
  pSrc = p->pSrc;
  if( pSrc ){
    for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
      if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){
        return WRC_Abort;
      }
      if( pItem->fg.isTabFunc
       && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg)
      ){

References SrcList::a, SrcList::nSrc, Walker::pSelect, Select::pSrc, sqlite3WalkExprList(), sqlite3WalkSelect(), WRC_Abort, and WRC_Continue.

Referenced by sqlite3WalkSelect().

◆ sqlite3WalLimit()

SQLITE_PRIVATE void sqlite3WalLimit	(	Wal *	pWal,
		i64	iLimit )

Definition at line 60870 of file sqlite3.c.

Referenced by sqlite3PagerJournalSizeLimit().

◆ sqlite3WalOpen()

SQLITE_PRIVATE int sqlite3WalOpen	(	sqlite3_vfs *	pVfs,
		sqlite3_file *	pDbFd,
		const char *	zWalName,
		int	bNoShm,
		i64	mxWalSize,
		Wal **	ppWal )

Definition at line 60796 of file sqlite3.c.

 {
  int rc;                         /* Return Code */
  Wal *pRet;                      /* Object to allocate and return */
  int flags;                      /* Flags passed to OsOpen() */
 
  assert( zWalName && zWalName[0] );
  assert( pDbFd );
 
  /* In the amalgamation, the os_unix.c and os_win.c source files come before
  ** this source file.  Verify that the #defines of the locking byte offsets
  ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
  ** For that matter, if the lock offset ever changes from its initial design
  ** value of 120, we need to know that so there is an assert() to check it.
  */
  assert( 120==WALINDEX_LOCK_OFFSET );
  assert( 136==WALINDEX_HDR_SIZE );
#ifdef WIN_SHM_BASE
  assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
#endif
#ifdef UNIX_SHM_BASE
  assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
#endif
 
 
  /* Allocate an instance of struct Wal to return. */
  *ppWal = 0;
  pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);
  if( !pRet ){
    return SQLITE_NOMEM_BKPT;
  }
 
  pRet->pVfs = pVfs;
  pRet->pWalFd = (sqlite3_file *)&pRet[1];
  pRet->pDbFd = pDbFd;
  pRet->readLock = -1;
  pRet->mxWalSize = mxWalSize;
  pRet->zWalName = zWalName;
  pRet->syncHeader = 1;
  pRet->padToSectorBoundary = 1;
  pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
 
  /* Open file handle on the write-ahead log file. */
  flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
  rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
  if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
    pRet->readOnly = WAL_RDONLY;
  }
 
  if( rc!=SQLITE_OK ){
    walIndexClose(pRet, 0);
    sqlite3OsClose(pRet->pWalFd);
    sqlite3_free(pRet);
  }else{
    int iDC = sqlite3OsDeviceCharacteristics(pDbFd);
    if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }
    if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){
      pRet->padToSectorBoundary = 0;

References Wal::exclusiveMode, Wal::mxWalSize, Wal::padToSectorBoundary, Wal::pDbFd, Wal::pVfs, Wal::pWalFd, Wal::readLock, Wal::readOnly, sqlite3_free(), sqlite3MallocZero(), sqlite3OsClose(), sqlite3OsDeviceCharacteristics(), sqlite3OsOpen(), SQLITE_IOCAP_POWERSAFE_OVERWRITE, SQLITE_IOCAP_SEQUENTIAL, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_OPEN_WAL, Wal::syncHeader, sqlite3_vfs::szOsFile, UNIX_SHM_BASE, WAL_HEAPMEMORY_MODE, WAL_NORMAL_MODE, WAL_RDONLY, WALINDEX_HDR_SIZE, WALINDEX_LOCK_OFFSET, walIndexClose(), WALTRACE, and Wal::zWalName.

Referenced by pagerOpenWal().

◆ sqlite3WalReadFrame()

SQLITE_PRIVATE int sqlite3WalReadFrame	(	Wal *	pWal,
		u32	iRead,
		int	nOut,
		u8 *	pOut )

Definition at line 62531 of file sqlite3.c.

 {
  int sz;
  i64 iOffset;
  sz = pWal->hdr.szPage;
  sz = (sz&0xfe00) + ((sz&0x0001)<<16);

References Wal::hdr, WalIndexHdr::szPage, testcase, WAL_FRAME_HDRSIZE, and walFrameOffset.

Referenced by readDbPage().

◆ sqlite3WalSavepoint()

SQLITE_PRIVATE void sqlite3WalSavepoint	(	Wal *	pWal,
		u32 *	aWalData )

Definition at line 62682 of file sqlite3.c.

62688 {

References WalIndexHdr::aFrameCksum, Wal::hdr, WalIndexHdr::mxFrame, Wal::nCkpt, and Wal::writeLock.

Referenced by pagerOpenSavepoint().

◆ sqlite3WalSavepointUndo()

SQLITE_PRIVATE int sqlite3WalSavepointUndo	(	Wal *	pWal,
		u32 *	aWalData )

Definition at line 62696 of file sqlite3.c.

                                                                    {
  int rc = SQLITE_OK;
 
  assert( pWal->writeLock );
  assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
 
  if( aWalData[3]!=pWal->nCkpt ){
    /* This savepoint was opened immediately after the write-transaction
    ** was started. Right after that, the writer decided to wrap around
    ** to the start of the log. Update the savepoint values to match.
    */
    aWalData[0] = 0;
    aWalData[3] = pWal->nCkpt;
  }
 
  if( aWalData[0]<pWal->hdr.mxFrame ){
    pWal->hdr.mxFrame = aWalData[0];
    pWal->hdr.aFrameCksum[0] = aWalData[1];

References WalIndexHdr::aFrameCksum, Wal::hdr, WalIndexHdr::mxFrame, Wal::nCkpt, SQLITE_OK, walCleanupHash(), and Wal::writeLock.

Referenced by pagerPlaybackSavepoint().

◆ sqlite3WalUndo()

SQLITE_PRIVATE int sqlite3WalUndo	(	Wal *	pWal,
		int()(void , Pgno)	xUndo,
		void *	pUndoCtx )

Definition at line 62642 of file sqlite3.c.

                                                                                        {
  int rc = SQLITE_OK;
  if( ALWAYS(pWal->writeLock) ){
    Pgno iMax = pWal->hdr.mxFrame;
    Pgno iFrame;
 
    /* Restore the clients cache of the wal-index header to the state it
    ** was in before the client began writing to the database.
    */
    memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
 
    for(iFrame=pWal->hdr.mxFrame+1;
        ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
        iFrame++
    ){
      /* This call cannot fail. Unless the page for which the page number
      ** is passed as the second argument is (a) in the cache and
      ** (b) has an outstanding reference, then xUndo is either a no-op
      ** (if (a) is false) or simply expels the page from the cache (if (b)
      ** is false).
      **
      ** If the upper layer is doing a rollback, it is guaranteed that there
      ** are no outstanding references to any page other than page 1. And
      ** page 1 is never written to the log until the transaction is
      ** committed. As a result, the call to xUndo may not fail.
      */
      assert( walFramePgno(pWal, iFrame)!=1 );

References ALWAYS, Wal::hdr, WalIndexHdr::mxFrame, SQLITE_OK, walCleanupHash(), walFramePgno(), walIndexHdr(), and Wal::writeLock.

◆ sqlite3WhereBegin()

SQLITE_PRIVATE WhereInfo * sqlite3WhereBegin	(	Parse *	pParse,
		SrcList *	pTabList,
		Expr *	pWhere,
		ExprList *	pOrderBy,
		ExprList *	pResultSet,
		u16	wctrlFlags,
		int	iAuxArg )

Definition at line 150295 of file sqlite3.c.

 {
  int nByteWInfo;            /* Num. bytes allocated for WhereInfo struct */
  int nTabList;              /* Number of elements in pTabList */
  WhereInfo *pWInfo;         /* Will become the return value of this function */
  Vdbe *v = pParse->pVdbe;   /* The virtual database engine */
  Bitmask notReady;          /* Cursors that are not yet positioned */
  WhereLoopBuilder sWLB;     /* The WhereLoop builder */
  WhereMaskSet *pMaskSet;    /* The expression mask set */
  WhereLevel *pLevel;        /* A single level in pWInfo->a[] */
  WhereLoop *pLoop;          /* Pointer to a single WhereLoop object */
  int ii;                    /* Loop counter */
  sqlite3 *db;               /* Database connection */
  int rc;                    /* Return code */
  u8 bFordelete = 0;         /* OPFLAG_FORDELETE or zero, as appropriate */
 
  assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || (
        (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0
     && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0
  ));
 
  /* Only one of WHERE_OR_SUBCLAUSE or WHERE_USE_LIMIT */
  assert( (wctrlFlags & WHERE_OR_SUBCLAUSE)==0
            || (wctrlFlags & WHERE_USE_LIMIT)==0 );
 
  /* Variable initialization */
  db = pParse->db;
  memset(&sWLB, 0, sizeof(sWLB));
 
  /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */
  testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
  if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0;
  sWLB.pOrderBy = pOrderBy;
 
  /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via
  ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */
  if( OptimizationDisabled(db, SQLITE_DistinctOpt) ){
    wctrlFlags &= ~WHERE_WANT_DISTINCT;
  }
 
  /* The number of tables in the FROM clause is limited by the number of
  ** bits in a Bitmask
  */
  testcase( pTabList->nSrc==BMS );
  if( pTabList->nSrc>BMS ){
    sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
    return 0;
  }
 
  /* This function normally generates a nested loop for all tables in
  ** pTabList.  But if the WHERE_OR_SUBCLAUSE flag is set, then we should
  ** only generate code for the first table in pTabList and assume that
  ** any cursors associated with subsequent tables are uninitialized.
  */
  nTabList = (wctrlFlags & WHERE_OR_SUBCLAUSE) ? 1 : pTabList->nSrc;
 
  /* Allocate and initialize the WhereInfo structure that will become the
  ** return value. A single allocation is used to store the WhereInfo
  ** struct, the contents of WhereInfo.a[], the WhereClause structure
  ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
  ** field (type Bitmask) it must be aligned on an 8-byte boundary on
  ** some architectures. Hence the ROUND8() below.
  */
  nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
  pWInfo = sqlite3DbMallocRawNN(db, nByteWInfo + sizeof(WhereLoop));
  if( db->mallocFailed ){
    sqlite3DbFree(db, pWInfo);
    pWInfo = 0;
    goto whereBeginError;
  }
  pWInfo->pParse = pParse;
  pWInfo->pTabList = pTabList;
  pWInfo->pOrderBy = pOrderBy;
  pWInfo->pWhere = pWhere;
  pWInfo->pResultSet = pResultSet;
  pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
  pWInfo->nLevel = nTabList;
  pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse);
  pWInfo->wctrlFlags = wctrlFlags;
  pWInfo->iLimit = iAuxArg;
  pWInfo->savedNQueryLoop = pParse->nQueryLoop;
  memset(&pWInfo->nOBSat, 0,
         offsetof(WhereInfo,sWC) - offsetof(WhereInfo,nOBSat));
  memset(&pWInfo->a[0], 0, sizeof(WhereLoop)+nTabList*sizeof(WhereLevel));
  assert( pWInfo->eOnePass==ONEPASS_OFF );  /* ONEPASS defaults to OFF */
  pMaskSet = &pWInfo->sMaskSet;
  sWLB.pWInfo = pWInfo;
  sWLB.pWC = &pWInfo->sWC;
  sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo);
  assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) );
  whereLoopInit(sWLB.pNew);
#ifdef SQLITE_DEBUG
  sWLB.pNew->cId = '*';
#endif
 
  /* Split the WHERE clause into separate subexpressions where each
  ** subexpression is separated by an AND operator.
  */
  initMaskSet(pMaskSet);
  sqlite3WhereClauseInit(&pWInfo->sWC, pWInfo);
  sqlite3WhereSplit(&pWInfo->sWC, pWhere, TK_AND);
 
  /* Special case: No FROM clause
  */
  if( nTabList==0 ){
    if( pOrderBy ) pWInfo->nOBSat = pOrderBy->nExpr;
    if( wctrlFlags & WHERE_WANT_DISTINCT ){
      pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
    }
    ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
  }else{
    /* Assign a bit from the bitmask to every term in the FROM clause.
    **
    ** The N-th term of the FROM clause is assigned a bitmask of 1<<N.
    **
    ** The rule of the previous sentence ensures thta if X is the bitmask for
    ** a table T, then X-1 is the bitmask for all other tables to the left of T.
    ** Knowing the bitmask for all tables to the left of a left join is
    ** important.  Ticket #3015.
    **
    ** Note that bitmasks are created for all pTabList->nSrc tables in
    ** pTabList, not just the first nTabList tables.  nTabList is normally
    ** equal to pTabList->nSrc but might be shortened to 1 if the
    ** WHERE_OR_SUBCLAUSE flag is set.
    */
    ii = 0;
    do{
      createMask(pMaskSet, pTabList->a[ii].iCursor);
      sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC);
    }while( (++ii)<pTabList->nSrc );
  #ifdef SQLITE_DEBUG
    {
      Bitmask mx = 0;
      for(ii=0; ii<pTabList->nSrc; ii++){
        Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor);
        assert( m>=mx );
        mx = m;
      }
    }
  #endif
  }
 
  /* Analyze all of the subexpressions. */
  sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
  if( db->mallocFailed ) goto whereBeginError;
 
  /* Special case: WHERE terms that do not refer to any tables in the join
  ** (constant expressions). Evaluate each such term, and jump over all the
  ** generated code if the result is not true.
  **
  ** Do not do this if the expression contains non-deterministic functions
  ** that are not within a sub-select. This is not strictly required, but
  ** preserves SQLite's legacy behaviour in the following two cases:
  **
  **   FROM ... WHERE random()>0;           -- eval random() once per row
  **   FROM ... WHERE (SELECT random())>0;  -- eval random() once overall
  */
  for(ii=0; ii<sWLB.pWC->nTerm; ii++){
    WhereTerm *pT = &sWLB.pWC->a[ii];
    if( pT->wtFlags & TERM_VIRTUAL ) continue;
    if( pT->prereqAll==0 && (nTabList==0 || exprIsDeterministic(pT->pExpr)) ){
      sqlite3ExprIfFalse(pParse, pT->pExpr, pWInfo->iBreak, SQLITE_JUMPIFNULL);
      pT->wtFlags |= TERM_CODED;
    }
  }
 
  if( wctrlFlags & WHERE_WANT_DISTINCT ){
    if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
      /* The DISTINCT marking is pointless.  Ignore it. */
      pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
    }else if( pOrderBy==0 ){
      /* Try to ORDER BY the result set to make distinct processing easier */
      pWInfo->wctrlFlags |= WHERE_DISTINCTBY;
      pWInfo->pOrderBy = pResultSet;
    }
  }
 
  /* Construct the WhereLoop objects */
#if defined(WHERETRACE_ENABLED)
  if( sqlite3WhereTrace & 0xffff ){
    sqlite3DebugPrintf("*** Optimizer Start *** (wctrlFlags: 0x%x",wctrlFlags);
    if( wctrlFlags & WHERE_USE_LIMIT ){
      sqlite3DebugPrintf(", limit: %d", iAuxArg);
    }
    sqlite3DebugPrintf(")\n");
    if( sqlite3WhereTrace & 0x100 ){
      Select sSelect;
      memset(&sSelect, 0, sizeof(sSelect));
      sSelect.selFlags = SF_WhereBegin;
      sSelect.pSrc = pTabList;
      sSelect.pWhere = pWhere;
      sSelect.pOrderBy = pOrderBy;
      sSelect.pEList = pResultSet;
      sqlite3TreeViewSelect(0, &sSelect, 0);
    }
  }
  if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */
    sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n");
    sqlite3WhereClausePrint(sWLB.pWC);
  }
#endif
 
  if( nTabList!=1 || whereShortCut(&sWLB)==0 ){
    rc = whereLoopAddAll(&sWLB);
    if( rc ) goto whereBeginError;
 
#ifdef SQLITE_ENABLE_STAT4
    /* If one or more WhereTerm.truthProb values were used in estimating
    ** loop parameters, but then those truthProb values were subsequently
    ** changed based on STAT4 information while computing subsequent loops,
    ** then we need to rerun the whole loop building process so that all
    ** loops will be built using the revised truthProb values. */
    if( sWLB.bldFlags2 & SQLITE_BLDF2_2NDPASS ){
      WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC);
      WHERETRACE(0xffff,
           ("**** Redo all loop computations due to"
            " TERM_HIGHTRUTH changes ****\n"));
      while( pWInfo->pLoops ){
        WhereLoop *p = pWInfo->pLoops;
        pWInfo->pLoops = p->pNextLoop;
        whereLoopDelete(db, p);
      }
      rc = whereLoopAddAll(&sWLB);
      if( rc ) goto whereBeginError;
    }
#endif
    WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC);
 
    wherePathSolver(pWInfo, 0);
    if( db->mallocFailed ) goto whereBeginError;
    if( pWInfo->pOrderBy ){
       wherePathSolver(pWInfo, pWInfo->nRowOut+1);
       if( db->mallocFailed ) goto whereBeginError;
    }
  }
  if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
     pWInfo->revMask = ALLBITS;
  }
  if( pParse->nErr || NEVER(db->mallocFailed) ){
    goto whereBeginError;
  }
#ifdef WHERETRACE_ENABLED
  if( sqlite3WhereTrace ){
    sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut);
    if( pWInfo->nOBSat>0 ){
      sqlite3DebugPrintf(" ORDERBY=%d,0x%llx", pWInfo->nOBSat, pWInfo->revMask);
    }
    switch( pWInfo->eDistinct ){
      case WHERE_DISTINCT_UNIQUE: {
        sqlite3DebugPrintf("  DISTINCT=unique");
        break;
      }
      case WHERE_DISTINCT_ORDERED: {
        sqlite3DebugPrintf("  DISTINCT=ordered");
        break;
      }
      case WHERE_DISTINCT_UNORDERED: {
        sqlite3DebugPrintf("  DISTINCT=unordered");
        break;
      }
    }
    sqlite3DebugPrintf("\n");
    for(ii=0; ii<pWInfo->nLevel; ii++){
      sqlite3WhereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC);
    }
  }
#endif
 
  /* Attempt to omit tables from the join that do not affect the result.
  ** For a table to not affect the result, the following must be true:
  **
  **   1) The query must not be an aggregate.
  **   2) The table must be the RHS of a LEFT JOIN.
  **   3) Either the query must be DISTINCT, or else the ON or USING clause
  **      must contain a constraint that limits the scan of the table to
  **      at most a single row.
  **   4) The table must not be referenced by any part of the query apart
  **      from its own USING or ON clause.
  **
  ** For example, given:
  **
  **     CREATE TABLE t1(ipk INTEGER PRIMARY KEY, v1);
  **     CREATE TABLE t2(ipk INTEGER PRIMARY KEY, v2);
  **     CREATE TABLE t3(ipk INTEGER PRIMARY KEY, v3);
  **
  ** then table t2 can be omitted from the following:
  **
  **     SELECT v1, v3 FROM t1
  **       LEFT JOIN t2 ON (t1.ipk=t2.ipk)
  **       LEFT JOIN t3 ON (t1.ipk=t3.ipk)
  **
  ** or from:
  **
  **     SELECT DISTINCT v1, v3 FROM t1
  **       LEFT JOIN t2
  **       LEFT JOIN t3 ON (t1.ipk=t3.ipk)
  */
  notReady = ~(Bitmask)0;
  if( pWInfo->nLevel>=2
   && pResultSet!=0               /* guarantees condition (1) above */
   && OptimizationEnabled(db, SQLITE_OmitNoopJoin)
  ){
    int i;
    Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet);
    if( sWLB.pOrderBy ){
      tabUsed |= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy);
    }
    for(i=pWInfo->nLevel-1; i>=1; i--){
      WhereTerm *pTerm, *pEnd;
      struct SrcList_item *pItem;
      pLoop = pWInfo->a[i].pWLoop;
      pItem = &pWInfo->pTabList->a[pLoop->iTab];
      if( (pItem->fg.jointype & JT_LEFT)==0 ) continue;
      if( (wctrlFlags & WHERE_WANT_DISTINCT)==0
       && (pLoop->wsFlags & WHERE_ONEROW)==0
      ){
        continue;
      }
      if( (tabUsed & pLoop->maskSelf)!=0 ) continue;
      pEnd = sWLB.pWC->a + sWLB.pWC->nTerm;
      for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
        if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
          if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
           || pTerm->pExpr->iRightJoinTable!=pItem->iCursor
          ){
            break;
          }
        }
      }
      if( pTerm<pEnd ) continue;
      WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));
      notReady &= ~pLoop->maskSelf;
      for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
        if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
          pTerm->wtFlags |= TERM_CODED;
        }
      }
      if( i!=pWInfo->nLevel-1 ){
        int nByte = (pWInfo->nLevel-1-i) * sizeof(WhereLevel);
        memmove(&pWInfo->a[i], &pWInfo->a[i+1], nByte);
      }
      pWInfo->nLevel--;
      nTabList--;
    }
  }
#if defined(WHERETRACE_ENABLED)
  if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */
    sqlite3DebugPrintf("---- WHERE clause at end of analysis:\n");
    sqlite3WhereClausePrint(sWLB.pWC);
  }
  WHERETRACE(0xffff,("*** Optimizer Finished ***\n"));
#endif
  pWInfo->pParse->nQueryLoop += pWInfo->nRowOut;
 
  /* If the caller is an UPDATE or DELETE statement that is requesting
  ** to use a one-pass algorithm, determine if this is appropriate.
  **
  ** A one-pass approach can be used if the caller has requested one
  ** and either (a) the scan visits at most one row or (b) each
  ** of the following are true:
  **
  **   * the caller has indicated that a one-pass approach can be used
  **     with multiple rows (by setting WHERE_ONEPASS_MULTIROW), and
  **   * the table is not a virtual table, and
  **   * either the scan does not use the OR optimization or the caller
  **     is a DELETE operation (WHERE_DUPLICATES_OK is only specified
  **     for DELETE).
  **
  ** The last qualification is because an UPDATE statement uses
  ** WhereInfo.aiCurOnePass[1] to determine whether or not it really can
  ** use a one-pass approach, and this is not set accurately for scans
  ** that use the OR optimization.
  */
  assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
  if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){
    int wsFlags = pWInfo->a[0].pWLoop->wsFlags;
    int bOnerow = (wsFlags & WHERE_ONEROW)!=0;
    assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
    if( bOnerow || (
        0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW)
     && !IsVirtual(pTabList->a[0].pTab)
     && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK))
    )){
      pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
      if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
        if( wctrlFlags & WHERE_ONEPASS_MULTIROW ){
          bFordelete = OPFLAG_FORDELETE;
        }
        pWInfo->a[0].pWLoop->wsFlags = (wsFlags & ~WHERE_IDX_ONLY);
      }
    }
  }
 
  /* Open all tables in the pTabList and any indices selected for
  ** searching those tables.
  */
  for(ii=0, pLevel=pWInfo->a; ii<nTabList; ii++, pLevel++){
    Table *pTab;     /* Table to open */
    int iDb;         /* Index of database containing table/index */
    struct SrcList_item *pTabItem;
 
    pTabItem = &pTabList->a[pLevel->iFrom];
    pTab = pTabItem->pTab;
    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
    pLoop = pLevel->pWLoop;
    if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
      /* Do nothing */
    }else
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){
      const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
      int iCur = pTabItem->iCursor;
      sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
    }else if( IsVirtual(pTab) ){
      /* noop */
    }else
#endif
    if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
         && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){
      int op = OP_OpenRead;
      if( pWInfo->eOnePass!=ONEPASS_OFF ){
        op = OP_OpenWrite;
        pWInfo->aiCurOnePass[0] = pTabItem->iCursor;
      };
      sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
      assert( pTabItem->iCursor==pLevel->iTabCur );
      testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
      testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
      if( pWInfo->eOnePass==ONEPASS_OFF
       && pTab->nCol<BMS
       && (pTab->tabFlags & (TF_HasGenerated|TF_WithoutRowid))==0
      ){
        /* If we know that only a prefix of the record will be used,
        ** it is advantageous to reduce the "column count" field in
        ** the P4 operand of the OP_OpenRead/Write opcode. */
        Bitmask b = pTabItem->colUsed;
        int n = 0;
        for(; b; b=b>>1, n++){}
        sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32);
        assert( n<=pTab->nCol );
      }
#ifdef SQLITE_ENABLE_CURSOR_HINTS
      if( pLoop->u.btree.pIndex!=0 ){
        sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ|bFordelete);
      }else
#endif
      {
        sqlite3VdbeChangeP5(v, bFordelete);
      }
#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
      sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0,
                            (const u8*)&pTabItem->colUsed, P4_INT64);
#endif
    }else{
      sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
    }
    if( pLoop->wsFlags & WHERE_INDEXED ){
      Index *pIx = pLoop->u.btree.pIndex;
      int iIndexCur;
      int op = OP_OpenRead;
      /* iAuxArg is always set to a positive value if ONEPASS is possible */
      assert( iAuxArg!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 );
      if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx)
       && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0
      ){
        /* This is one term of an OR-optimization using the PRIMARY KEY of a
        ** WITHOUT ROWID table.  No need for a separate index */
        iIndexCur = pLevel->iTabCur;
        op = 0;
      }else if( pWInfo->eOnePass!=ONEPASS_OFF ){
        Index *pJ = pTabItem->pTab->pIndex;
        iIndexCur = iAuxArg;
        assert( wctrlFlags & WHERE_ONEPASS_DESIRED );
        while( ALWAYS(pJ) && pJ!=pIx ){
          iIndexCur++;
          pJ = pJ->pNext;
        }
        op = OP_OpenWrite;
        pWInfo->aiCurOnePass[1] = iIndexCur;
      }else if( iAuxArg && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 ){
        iIndexCur = iAuxArg;
        op = OP_ReopenIdx;
      }else{
        iIndexCur = pParse->nTab++;
      }
      pLevel->iIdxCur = iIndexCur;
      assert( pIx->pSchema==pTab->pSchema );
      assert( iIndexCur>=0 );
      if( op ){
        sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
        sqlite3VdbeSetP4KeyInfo(pParse, pIx);
        if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0
         && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0
         && (pLoop->wsFlags & WHERE_BIGNULL_SORT)==0
         && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0
         && pWInfo->eDistinct!=WHERE_DISTINCT_ORDERED
        ){
          sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ);
        }
        VdbeComment((v, "%s", pIx->zName));
#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
        {
          u64 colUsed = 0;
          int ii, jj;
          for(ii=0; ii<pIx->nColumn; ii++){
            jj = pIx->aiColumn[ii];
            if( jj<0 ) continue;
            if( jj>63 ) jj = 63;
            if( (pTabItem->colUsed & MASKBIT(jj))==0 ) continue;
            colUsed |= ((u64)1)<<(ii<63 ? ii : 63);
          }
          sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0,
                                (u8*)&colUsed, P4_INT64);
        }
#endif /* SQLITE_ENABLE_COLUMN_USED_MASK */
      }
    }
    if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
  }
  pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
  if( db->mallocFailed ) goto whereBeginError;
 
  /* Generate the code to do the search.  Each iteration of the for
  ** loop below generates code for a single nested loop of the VM
  ** program.
  */
  for(ii=0; ii<nTabList; ii++){
    int addrExplain;
    int wsFlags;
    pLevel = &pWInfo->a[ii];
    wsFlags = pLevel->pWLoop->wsFlags;
#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
    if( (pLevel->pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 ){
      constructAutomaticIndex(pParse, &pWInfo->sWC,
                &pTabList->a[pLevel->iFrom], notReady, pLevel);
      if( db->mallocFailed ) goto whereBeginError;
    }
#endif
    addrExplain = sqlite3WhereExplainOneScan(
        pParse, pTabList, pLevel, wctrlFlags
    );
    pLevel->addrBody = sqlite3VdbeCurrentAddr(v);
    notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady);
    pWInfo->iContinue = pLevel->addrCont;
    if( (wsFlags&WHERE_MULTI_OR)==0 && (wctrlFlags&WHERE_OR_SUBCLAUSE)==0 ){
      sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain);
    }
  }
 
  /* Done. */
  VdbeModuleComment((v, "Begin WHERE-core"));
  return pWInfo;
 
  /* Jump here if malloc fails */
whereBeginError:

References SrcList::a, WhereClause::a, WhereInfo::a, WhereLevel::addrBody, WhereLevel::addrCont, Index::aiColumn, WhereInfo::aiCurOnePass, ALLBITS, ALWAYS, WhereLoopBuilder::bldFlags2, BMS, WhereLoop::btree, constructAutomaticIndex(), createMask(), Parse::db, WhereInfo::eDistinct, EIGHT_BYTE_ALIGNMENT, WhereInfo::eOnePass, EP_FromJoin, ExplainQueryPlan, ExprHasProperty, exprIsDeterministic(), sqlite3::flags, HasRowid, WhereInfo::iBreak, WhereInfo::iContinue, SrcList::SrcList_item::iCursor, WhereLevel::iFrom, WhereLevel::iIdxCur, WhereInfo::iLimit, initMaskSet, Expr::iRightJoinTable, isDistinctRedundant(), IsPrimaryKeyIndex, IsVirtual, WhereLoop::iTab, WhereLevel::iTabCur, WhereInfo::iTop, JT_LEFT, sqlite3::mallocFailed, MASKBIT, WhereLoop::maskSelf, Table::nCol, Index::nColumn, Parse::nErr, NEVER, ExprList::nExpr, WhereInfo::nLevel, WhereInfo::nOBSat, Parse::nQueryLoop, WhereInfo::nRowOut, SrcList::nSrc, Parse::nTab, WhereClause::nTerm, offsetof, ONEPASS_MULTI, ONEPASS_OFF, ONEPASS_SINGLE, OP_ColumnsUsed, OP_OpenRead, OP_OpenWrite, OP_ReopenIdx, OP_VOpen, OPFLAG_FORDELETE, OPFLAG_SEEKEQ, OptimizationDisabled, OptimizationEnabled, P4_INT32, P4_INT64, P4_VTAB, Select::pEList, WhereTerm::pExpr, WhereLoop::pIndex, WhereInfo::pLoops, WhereLoopBuilder::pNew, Index::pNext, WhereLoop::pNextLoop, Select::pOrderBy, WhereLoopBuilder::pOrderBy, WhereInfo::pOrderBy, WhereInfo::pParse, WhereTerm::prereqAll, WhereInfo::pResultSet, Table::pSchema, Index::pSchema, Table::pSelect, Select::pSrc, SrcList::SrcList_item::pTab, WhereInfo::pTabList, Parse::pVdbe, WhereLoopBuilder::pWC, Select::pWhere, WhereInfo::pWhere, WhereLoopBuilder::pWInfo, WhereLevel::pWLoop, WhereInfo::revMask, ROUND8, WhereInfo::savedNQueryLoop, Select::selFlags, SF_WhereBegin, WhereInfo::sMaskSet, sqlite3CodeVerifySchema(), sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3ErrorMsg(), sqlite3ExprIfFalse(), sqlite3GetVTable(), sqlite3OpenTable(), sqlite3SchemaToIndex(), sqlite3TableLock(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Dup8(), sqlite3VdbeChangeP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeMakeLabel(), sqlite3VdbeSetP4KeyInfo(), sqlite3WhereAddScanStatus, sqlite3WhereClauseInit(), sqlite3WhereCodeOneLoopStart(), sqlite3WhereExplainOneScan(), sqlite3WhereExprAnalyze(), sqlite3WhereExprListUsage(), sqlite3WhereGetMask(), sqlite3WhereSplit(), sqlite3WhereTabFuncArgs(), SQLITE_BLDF2_2NDPASS, SQLITE_DistinctOpt, SQLITE_INT_TO_PTR, SQLITE_JUMPIFNULL, SQLITE_OmitNoopJoin, SQLITE_ReverseOrder, WhereInfo::sWC, Table::tabFlags, TERM_CODED, TERM_VIRTUAL, testcase, TF_Ephemeral, TF_HasGenerated, TF_WithoutRowid, TK_AND, Table::tnum, Index::tnum, WhereLoop::u, VdbeComment, VdbeModuleComment, WhereInfo::wctrlFlags, WHERE_AUTO_INDEX, WHERE_BIGNULL_SORT, WHERE_COLUMN_RANGE, WHERE_CONSTRAINT, WHERE_DISTINCT_ORDERED, WHERE_DISTINCT_UNIQUE, WHERE_DISTINCT_UNORDERED, WHERE_DISTINCTBY, WHERE_DUPLICATES_OK, WHERE_IDX_ONLY, WHERE_INDEXED, WHERE_MULTI_OR, WHERE_ONEPASS_DESIRED, WHERE_ONEPASS_MULTIROW, WHERE_ONEROW, WHERE_OR_SUBCLAUSE, WHERE_ORDERBY_MIN, WHERE_SKIPSCAN, WHERE_USE_LIMIT, WHERE_VIRTUALTABLE, WHERE_WANT_DISTINCT, whereInfoFree(), whereLoopAddAll(), whereLoopDelete(), whereLoopInit(), wherePathSolver(), whereShortCut(), WHERETRACE, WHERETRACE_ALL_LOOPS, WhereLoop::wsFlags, WhereTerm::wtFlags, Table::zName, and Index::zName.

Referenced by fkScanChildren(), sqlite3DeleteFrom(), sqlite3Select(), sqlite3Update(), and updateVirtualTable().

◆ sqlite3WhereBreakLabel()

SQLITE_PRIVATE int sqlite3WhereBreakLabel ( WhereInfo * pWInfo )

Definition at line 145726 of file sqlite3.c.

Referenced by sqlite3Select().

◆ sqlite3WhereClauseClear()

SQLITE_PRIVATE void sqlite3WhereClauseClear ( WhereClause * pWC )

Definition at line 145473 of file sqlite3.c.

                                                             {
  int i;
  WhereTerm *a;
  sqlite3 *db = pWC->pWInfo->pParse->db;
  for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){
    if( a->wtFlags & TERM_DYNAMIC ){
      sqlite3ExprDelete(db, a->pExpr);
    }
    if( a->wtFlags & TERM_ORINFO ){
      whereOrInfoDelete(db, a->u.pOrInfo);
    }else if( a->wtFlags & TERM_ANDINFO ){
      whereAndInfoDelete(db, a->u.pAndInfo);

References WhereClause::a, WhereClause::aStatic, Parse::db, WhereClause::nTerm, WhereInfo::pParse, WhereClause::pWInfo, sqlite3DbFree(), sqlite3ExprDelete(), TERM_ANDINFO, TERM_DYNAMIC, TERM_ORINFO, whereAndInfoDelete(), and whereOrInfoDelete().

◆ sqlite3WhereClauseInit()

SQLITE_PRIVATE void sqlite3WhereClauseInit	(	WhereClause *	pWC,
		WhereInfo *	pWInfo )

Definition at line 145456 of file sqlite3.c.

145465 {

145466 pWC->pWInfo = pWInfo;

Referenced by exprAnalyzeOrTerm(), and sqlite3WhereBegin().

◆ sqlite3WhereCodeOneLoopStart()

SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart	(	Parse *	pParse,
		Vdbe *	v,
		WhereInfo *	pWInfo,
		int	iLevel,
		WhereLevel *	pLevel,
		Bitmask	notReady )

Definition at line 142790 of file sqlite3.c.

 {
  int j, k;            /* Loop counters */
  int iCur;            /* The VDBE cursor for the table */
  int addrNxt;         /* Where to jump to continue with the next IN case */
  int bRev;            /* True if we need to scan in reverse order */
  WhereLoop *pLoop;    /* The WhereLoop object being coded */
  WhereClause *pWC;    /* Decomposition of the entire WHERE clause */
  WhereTerm *pTerm;               /* A WHERE clause term */
  sqlite3 *db;                    /* Database connection */
  struct SrcList_item *pTabItem;  /* FROM clause term being coded */
  int addrBrk;                    /* Jump here to break out of the loop */
  int addrHalt;                   /* addrBrk for the outermost loop */
  int addrCont;                   /* Jump here to continue with next cycle */
  int iRowidReg = 0;        /* Rowid is stored in this register, if not zero */
  int iReleaseReg = 0;      /* Temp register to free before returning */
  Index *pIdx = 0;          /* Index used by loop (if any) */
  int iLoop;                /* Iteration of constraint generator loop */
 
  pWC = &pWInfo->sWC;
  db = pParse->db;
  pLoop = pLevel->pWLoop;
  pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
  iCur = pTabItem->iCursor;
  pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur);
  bRev = (pWInfo->revMask>>iLevel)&1;
  VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
#if WHERETRACE_ENABLED /* 0x20800 */
  if( sqlite3WhereTrace & 0x800 ){
    sqlite3DebugPrintf("Coding level %d of %d:  notReady=%llx  iFrom=%d\n",
       iLevel, pWInfo->nLevel, (u64)notReady, pLevel->iFrom);
    sqlite3WhereLoopPrint(pLoop, pWC);
  }
  if( sqlite3WhereTrace & 0x20000 ){
    if( iLevel==0 ){
      sqlite3DebugPrintf("WHERE clause being coded:\n");
      sqlite3TreeViewExpr(0, pWInfo->pWhere, 0);
    }
    sqlite3DebugPrintf("All WHERE-clause terms before coding:\n");
    sqlite3WhereClausePrint(pWC);
  }
#endif
 
  /* Create labels for the "break" and "continue" instructions
  ** for the current loop.  Jump to addrBrk to break out of a loop.
  ** Jump to cont to go immediately to the next iteration of the
  ** loop.
  **
  ** When there is an IN operator, we also have a "addrNxt" label that
  ** means to continue with the next IN value combination.  When
  ** there are no IN operators in the constraints, the "addrNxt" label
  ** is the same as "addrBrk".
  */
  addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
  addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse);
 
  /* If this is the right table of a LEFT OUTER JOIN, allocate and
  ** initialize a memory cell that records if this table matches any
  ** row of the left table of the join.
  */
  assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
       || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0
  );
  if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
    pLevel->iLeftJoin = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
    VdbeComment((v, "init LEFT JOIN no-match flag"));
  }
 
  /* Compute a safe address to jump to if we discover that the table for
  ** this loop is empty and can never contribute content. */
  for(j=iLevel; j>0 && pWInfo->a[j].iLeftJoin==0; j--){}
  addrHalt = pWInfo->a[j].addrBrk;
 
  /* Special case of a FROM clause subquery implemented as a co-routine */
  if( pTabItem->fg.viaCoroutine ){
    int regYield = pTabItem->regReturn;
    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
    pLevel->p2 =  sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
    VdbeCoverage(v);
    VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
    pLevel->op = OP_Goto;
  }else
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if(  (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){
    /* Case 1:  The table is a virtual-table.  Use the VFilter and VNext
    **          to access the data.
    */
    int iReg;   /* P3 Value for OP_VFilter */
    int addrNotFound;
    int nConstraint = pLoop->nLTerm;
    int iIn;    /* Counter for IN constraints */
 
    iReg = sqlite3GetTempRange(pParse, nConstraint+2);
    addrNotFound = pLevel->addrBrk;
    for(j=0; j<nConstraint; j++){
      int iTarget = iReg+j+2;
      pTerm = pLoop->aLTerm[j];
      if( NEVER(pTerm==0) ) continue;
      if( pTerm->eOperator & WO_IN ){
        codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
        addrNotFound = pLevel->addrNxt;
      }else{
        Expr *pRight = pTerm->pExpr->pRight;
        codeExprOrVector(pParse, pRight, iTarget, 1);
      }
    }
    sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
    sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1);
    sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
                      pLoop->u.vtab.idxStr,
                      pLoop->u.vtab.needFree ? P4_DYNAMIC : P4_STATIC);
    VdbeCoverage(v);
    pLoop->u.vtab.needFree = 0;
    pLevel->p1 = iCur;
    pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext;
    pLevel->p2 = sqlite3VdbeCurrentAddr(v);
    iIn = pLevel->u.in.nIn;
    for(j=nConstraint-1; j>=0; j--){
      pTerm = pLoop->aLTerm[j];
      if( (pTerm->eOperator & WO_IN)!=0 ) iIn--;
      if( j<16 && (pLoop->u.vtab.omitMask>>j)&1 ){
        disableTerm(pLevel, pTerm);
      }else if( (pTerm->eOperator & WO_IN)!=0
        && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1
      ){
        Expr *pCompare;  /* The comparison operator */
        Expr *pRight;    /* RHS of the comparison */
        VdbeOp *pOp;     /* Opcode to access the value of the IN constraint */
 
        /* Reload the constraint value into reg[iReg+j+2].  The same value
        ** was loaded into the same register prior to the OP_VFilter, but
        ** the xFilter implementation might have changed the datatype or
        ** encoding of the value in the register, so it *must* be reloaded. */
        assert( pLevel->u.in.aInLoop!=0 || db->mallocFailed );
        if( !db->mallocFailed ){
          assert( iIn>=0 && iIn<pLevel->u.in.nIn );
          pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop);
          assert( pOp->opcode==OP_Column || pOp->opcode==OP_Rowid );
          assert( pOp->opcode!=OP_Column || pOp->p3==iReg+j+2 );
          assert( pOp->opcode!=OP_Rowid || pOp->p2==iReg+j+2 );
          testcase( pOp->opcode==OP_Rowid );
          sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
        }
 
        /* Generate code that will continue to the next row if
        ** the IN constraint is not satisfied */
        pCompare = sqlite3PExpr(pParse, TK_EQ, 0, 0);
        assert( pCompare!=0 || db->mallocFailed );
        if( pCompare ){
          pCompare->pLeft = pTerm->pExpr->pLeft;
          pCompare->pRight = pRight = sqlite3Expr(db, TK_REGISTER, 0);
          if( pRight ){
            pRight->iTable = iReg+j+2;
            sqlite3ExprIfFalse(
                pParse, pCompare, pLevel->addrCont, SQLITE_JUMPIFNULL
            );
          }
          pCompare->pLeft = 0;
          sqlite3ExprDelete(db, pCompare);
        }
      }
    }
    assert( iIn==0 || db->mallocFailed );
    /* These registers need to be preserved in case there is an IN operator
    ** loop.  So we could deallocate the registers here (and potentially
    ** reuse them later) if (pLoop->wsFlags & WHERE_IN_ABLE)==0.  But it seems
    ** simpler and safer to simply not reuse the registers.
    **
    **    sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
    */
  }else
#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
  if( (pLoop->wsFlags & WHERE_IPK)!=0
   && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0
  ){
    /* Case 2:  We can directly reference a single row using an
    **          equality comparison against the ROWID field.  Or
    **          we reference multiple rows using a "rowid IN (...)"
    **          construct.
    */
    assert( pLoop->u.btree.nEq==1 );
    pTerm = pLoop->aLTerm[0];
    assert( pTerm!=0 );
    assert( pTerm->pExpr!=0 );
    testcase( pTerm->wtFlags & TERM_VIRTUAL );
    iReleaseReg = ++pParse->nMem;
    iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
    if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg);
    addrNxt = pLevel->addrNxt;
    sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg);
    VdbeCoverage(v);
    pLevel->op = OP_Noop;
    if( (pTerm->prereqAll & pLevel->notReady)==0 ){
      pTerm->wtFlags |= TERM_CODED;
    }
  }else if( (pLoop->wsFlags & WHERE_IPK)!=0
         && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0
  ){
    /* Case 3:  We have an inequality comparison against the ROWID field.
    */
    int testOp = OP_Noop;
    int start;
    int memEndValue = 0;
    WhereTerm *pStart, *pEnd;
 
    j = 0;
    pStart = pEnd = 0;
    if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++];
    if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++];
    assert( pStart!=0 || pEnd!=0 );
    if( bRev ){
      pTerm = pStart;
      pStart = pEnd;
      pEnd = pTerm;
    }
    codeCursorHint(pTabItem, pWInfo, pLevel, pEnd);
    if( pStart ){
      Expr *pX;             /* The expression that defines the start bound */
      int r1, rTemp;        /* Registers for holding the start boundary */
      int op;               /* Cursor seek operation */
 
      /* The following constant maps TK_xx codes into corresponding
      ** seek opcodes.  It depends on a particular ordering of TK_xx
      */
      const u8 aMoveOp[] = {
           /* TK_GT */  OP_SeekGT,
           /* TK_LE */  OP_SeekLE,
           /* TK_LT */  OP_SeekLT,
           /* TK_GE */  OP_SeekGE
      };
      assert( TK_LE==TK_GT+1 );      /* Make sure the ordering.. */
      assert( TK_LT==TK_GT+2 );      /*  ... of the TK_xx values... */
      assert( TK_GE==TK_GT+3 );      /*  ... is correcct. */
 
      assert( (pStart->wtFlags & TERM_VNULL)==0 );
      testcase( pStart->wtFlags & TERM_VIRTUAL );
      pX = pStart->pExpr;
      assert( pX!=0 );
      testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
      if( sqlite3ExprIsVector(pX->pRight) ){
        r1 = rTemp = sqlite3GetTempReg(pParse);
        codeExprOrVector(pParse, pX->pRight, r1, 1);
        testcase( pX->op==TK_GT );
        testcase( pX->op==TK_GE );
        testcase( pX->op==TK_LT );
        testcase( pX->op==TK_LE );
        op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1];
        assert( pX->op!=TK_GT || op==OP_SeekGE );
        assert( pX->op!=TK_GE || op==OP_SeekGE );
        assert( pX->op!=TK_LT || op==OP_SeekLE );
        assert( pX->op!=TK_LE || op==OP_SeekLE );
      }else{
        r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
        disableTerm(pLevel, pStart);
        op = aMoveOp[(pX->op - TK_GT)];
      }
      sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1);
      VdbeComment((v, "pk"));
      VdbeCoverageIf(v, pX->op==TK_GT);
      VdbeCoverageIf(v, pX->op==TK_LE);
      VdbeCoverageIf(v, pX->op==TK_LT);
      VdbeCoverageIf(v, pX->op==TK_GE);
      sqlite3ReleaseTempReg(pParse, rTemp);
    }else{
      sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
      VdbeCoverageIf(v, bRev==0);
      VdbeCoverageIf(v, bRev!=0);
    }
    if( pEnd ){
      Expr *pX;
      pX = pEnd->pExpr;
      assert( pX!=0 );
      assert( (pEnd->wtFlags & TERM_VNULL)==0 );
      testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
      testcase( pEnd->wtFlags & TERM_VIRTUAL );
      memEndValue = ++pParse->nMem;
      codeExprOrVector(pParse, pX->pRight, memEndValue, 1);
      if( 0==sqlite3ExprIsVector(pX->pRight)
       && (pX->op==TK_LT || pX->op==TK_GT)
      ){
        testOp = bRev ? OP_Le : OP_Ge;
      }else{
        testOp = bRev ? OP_Lt : OP_Gt;
      }
      if( 0==sqlite3ExprIsVector(pX->pRight) ){
        disableTerm(pLevel, pEnd);
      }
    }
    start = sqlite3VdbeCurrentAddr(v);
    pLevel->op = bRev ? OP_Prev : OP_Next;
    pLevel->p1 = iCur;
    pLevel->p2 = start;
    assert( pLevel->p5==0 );
    if( testOp!=OP_Noop ){
      iRowidReg = ++pParse->nMem;
      sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
      sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
      VdbeCoverageIf(v, testOp==OP_Le);
      VdbeCoverageIf(v, testOp==OP_Lt);
      VdbeCoverageIf(v, testOp==OP_Ge);
      VdbeCoverageIf(v, testOp==OP_Gt);
      sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
    }
  }else if( pLoop->wsFlags & WHERE_INDEXED ){
    /* Case 4: A scan using an index.
    **
    **         The WHERE clause may contain zero or more equality
    **         terms ("==" or "IN" operators) that refer to the N
    **         left-most columns of the index. It may also contain
    **         inequality constraints (>, <, >= or <=) on the indexed
    **         column that immediately follows the N equalities. Only
    **         the right-most column can be an inequality - the rest must
    **         use the "==" and "IN" operators. For example, if the
    **         index is on (x,y,z), then the following clauses are all
    **         optimized:
    **
    **            x=5
    **            x=5 AND y=10
    **            x=5 AND y<10
    **            x=5 AND y>5 AND y<10
    **            x=5 AND y=5 AND z<=10
    **
    **         The z<10 term of the following cannot be used, only
    **         the x=5 term:
    **
    **            x=5 AND z<10
    **
    **         N may be zero if there are inequality constraints.
    **         If there are no inequality constraints, then N is at
    **         least one.
    **
    **         This case is also used when there are no WHERE clause
    **         constraints but an index is selected anyway, in order
    **         to force the output order to conform to an ORDER BY.
    */
    static const u8 aStartOp[] = {
      0,
      0,
      OP_Rewind,           /* 2: (!start_constraints && startEq &&  !bRev) */
      OP_Last,             /* 3: (!start_constraints && startEq &&   bRev) */
      OP_SeekGT,           /* 4: (start_constraints  && !startEq && !bRev) */
      OP_SeekLT,           /* 5: (start_constraints  && !startEq &&  bRev) */
      OP_SeekGE,           /* 6: (start_constraints  &&  startEq && !bRev) */
      OP_SeekLE            /* 7: (start_constraints  &&  startEq &&  bRev) */
    };
    static const u8 aEndOp[] = {
      OP_IdxGE,            /* 0: (end_constraints && !bRev && !endEq) */
      OP_IdxGT,            /* 1: (end_constraints && !bRev &&  endEq) */
      OP_IdxLE,            /* 2: (end_constraints &&  bRev && !endEq) */
      OP_IdxLT,            /* 3: (end_constraints &&  bRev &&  endEq) */
    };
    u16 nEq = pLoop->u.btree.nEq;     /* Number of == or IN terms */
    u16 nBtm = pLoop->u.btree.nBtm;   /* Length of BTM vector */
    u16 nTop = pLoop->u.btree.nTop;   /* Length of TOP vector */
    int regBase;                 /* Base register holding constraint values */
    WhereTerm *pRangeStart = 0;  /* Inequality constraint at range start */
    WhereTerm *pRangeEnd = 0;    /* Inequality constraint at range end */
    int startEq;                 /* True if range start uses ==, >= or <= */
    int endEq;                   /* True if range end uses ==, >= or <= */
    int start_constraints;       /* Start of range is constrained */
    int nConstraint;             /* Number of constraint terms */
    int iIdxCur;                 /* The VDBE cursor for the index */
    int nExtraReg = 0;           /* Number of extra registers needed */
    int op;                      /* Instruction opcode */
    char *zStartAff;             /* Affinity for start of range constraint */
    char *zEndAff = 0;           /* Affinity for end of range constraint */
    u8 bSeekPastNull = 0;        /* True to seek past initial nulls */
    u8 bStopAtNull = 0;          /* Add condition to terminate at NULLs */
    int omitTable;               /* True if we use the index only */
    int regBignull = 0;          /* big-null flag register */
 
    pIdx = pLoop->u.btree.pIndex;
    iIdxCur = pLevel->iIdxCur;
    assert( nEq>=pLoop->nSkip );
 
    /* Find any inequality constraint terms for the start and end
    ** of the range.
    */
    j = nEq;
    if( pLoop->wsFlags & WHERE_BTM_LIMIT ){
      pRangeStart = pLoop->aLTerm[j++];
      nExtraReg = MAX(nExtraReg, pLoop->u.btree.nBtm);
      /* Like optimization range constraints always occur in pairs */
      assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
              (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 );
    }
    if( pLoop->wsFlags & WHERE_TOP_LIMIT ){
      pRangeEnd = pLoop->aLTerm[j++];
      nExtraReg = MAX(nExtraReg, pLoop->u.btree.nTop);
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
      if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){
        assert( pRangeStart!=0 );                     /* LIKE opt constraints */
        assert( pRangeStart->wtFlags & TERM_LIKEOPT );   /* occur in pairs */
        pLevel->iLikeRepCntr = (u32)++pParse->nMem;
        sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr);
        VdbeComment((v, "LIKE loop counter"));
        pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v);
        /* iLikeRepCntr actually stores 2x the counter register number.  The
        ** bottom bit indicates whether the search order is ASC or DESC. */
        testcase( bRev );
        testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
        assert( (bRev & ~1)==0 );
        pLevel->iLikeRepCntr <<=1;
        pLevel->iLikeRepCntr |= bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC);
      }
#endif
      if( pRangeStart==0 ){
        j = pIdx->aiColumn[nEq];
        if( (j>=0 && pIdx->pTable->aCol[j].notNull==0) || j==XN_EXPR ){
          bSeekPastNull = 1;
        }
      }
    }
    assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 );
 
    /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses
    ** a non-default "big-null" sort (either ASC NULLS LAST or DESC NULLS
    ** FIRST). In both cases separate ordered scans are made of those
    ** index entries for which the column is null and for those for which
    ** it is not. For an ASC sort, the non-NULL entries are scanned first.
    ** For DESC, NULL entries are scanned first.
    */
    if( (pLoop->wsFlags & (WHERE_TOP_LIMIT|WHERE_BTM_LIMIT))==0
     && (pLoop->wsFlags & WHERE_BIGNULL_SORT)!=0
    ){
      assert( bSeekPastNull==0 && nExtraReg==0 && nBtm==0 && nTop==0 );
      assert( pRangeEnd==0 && pRangeStart==0 );
      testcase( pLoop->nSkip>0 );
      nExtraReg = 1;
      bSeekPastNull = 1;
      pLevel->regBignull = regBignull = ++pParse->nMem;
      if( pLevel->iLeftJoin ){
        sqlite3VdbeAddOp2(v, OP_Integer, 0, regBignull);
      }
      pLevel->addrBignull = sqlite3VdbeMakeLabel(pParse);
    }
 
    /* If we are doing a reverse order scan on an ascending index, or
    ** a forward order scan on a descending index, interchange the
    ** start and end terms (pRangeStart and pRangeEnd).
    */
    if( (nEq<pIdx->nKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC))
     || (bRev && pIdx->nKeyCol==nEq)
    ){
      SWAP(WhereTerm *, pRangeEnd, pRangeStart);
      SWAP(u8, bSeekPastNull, bStopAtNull);
      SWAP(u8, nBtm, nTop);
    }
 
    /* Generate code to evaluate all constraint terms using == or IN
    ** and store the values of those terms in an array of registers
    ** starting at regBase.
    */
    codeCursorHint(pTabItem, pWInfo, pLevel, pRangeEnd);
    regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff);
    assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq );
    if( zStartAff && nTop ){
      zEndAff = sqlite3DbStrDup(db, &zStartAff[nEq]);
    }
    addrNxt = (regBignull ? pLevel->addrBignull : pLevel->addrNxt);
 
    testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );
    testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 );
    testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 );
    testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 );
    startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE);
    endEq =   !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE);
    start_constraints = pRangeStart || nEq>0;
 
    /* Seek the index cursor to the start of the range. */
    nConstraint = nEq;
    if( pRangeStart ){
      Expr *pRight = pRangeStart->pExpr->pRight;
      codeExprOrVector(pParse, pRight, regBase+nEq, nBtm);
      whereLikeOptimizationStringFixup(v, pLevel, pRangeStart);
      if( (pRangeStart->wtFlags & TERM_VNULL)==0
       && sqlite3ExprCanBeNull(pRight)
      ){
        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
        VdbeCoverage(v);
      }
      if( zStartAff ){
        updateRangeAffinityStr(pRight, nBtm, &zStartAff[nEq]);
      }
      nConstraint += nBtm;
      testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
      if( sqlite3ExprIsVector(pRight)==0 ){
        disableTerm(pLevel, pRangeStart);
      }else{
        startEq = 1;
      }
      bSeekPastNull = 0;
    }else if( bSeekPastNull ){
      startEq = 0;
      sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
      start_constraints = 1;
      nConstraint++;
    }else if( regBignull ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
      start_constraints = 1;
      nConstraint++;
    }
    codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff);
    if( pLoop->nSkip>0 && nConstraint==pLoop->nSkip ){
      /* The skip-scan logic inside the call to codeAllEqualityConstraints()
      ** above has already left the cursor sitting on the correct row,
      ** so no further seeking is needed */
    }else{
      if( pLoop->wsFlags & WHERE_IN_EARLYOUT ){
        sqlite3VdbeAddOp1(v, OP_SeekHit, iIdxCur);
      }
      if( regBignull ){
        sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull);
        VdbeComment((v, "NULL-scan pass ctr"));
      }
 
      op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
      assert( op!=0 );
      sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
      VdbeCoverage(v);
      VdbeCoverageIf(v, op==OP_Rewind);  testcase( op==OP_Rewind );
      VdbeCoverageIf(v, op==OP_Last);    testcase( op==OP_Last );
      VdbeCoverageIf(v, op==OP_SeekGT);  testcase( op==OP_SeekGT );
      VdbeCoverageIf(v, op==OP_SeekGE);  testcase( op==OP_SeekGE );
      VdbeCoverageIf(v, op==OP_SeekLE);  testcase( op==OP_SeekLE );
      VdbeCoverageIf(v, op==OP_SeekLT);  testcase( op==OP_SeekLT );
 
      assert( bSeekPastNull==0 || bStopAtNull==0 );
      if( regBignull ){
        assert( bSeekPastNull==1 || bStopAtNull==1 );
        assert( bSeekPastNull==!bStopAtNull );
        assert( bStopAtNull==startEq );
        sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
        op = aStartOp[(nConstraint>1)*4 + 2 + bRev];
        sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
                             nConstraint-startEq);
        VdbeCoverage(v);
        VdbeCoverageIf(v, op==OP_Rewind);  testcase( op==OP_Rewind );
        VdbeCoverageIf(v, op==OP_Last);    testcase( op==OP_Last );
        VdbeCoverageIf(v, op==OP_SeekGE);  testcase( op==OP_SeekGE );
        VdbeCoverageIf(v, op==OP_SeekLE);  testcase( op==OP_SeekLE );
        assert( op==OP_Rewind || op==OP_Last || op==OP_SeekGE || op==OP_SeekLE);
      }
    }
 
    /* Load the value for the inequality constraint at the end of the
    ** range (if any).
    */
    nConstraint = nEq;
    if( pRangeEnd ){
      Expr *pRight = pRangeEnd->pExpr->pRight;
      codeExprOrVector(pParse, pRight, regBase+nEq, nTop);
      whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
      if( (pRangeEnd->wtFlags & TERM_VNULL)==0
       && sqlite3ExprCanBeNull(pRight)
      ){
        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
        VdbeCoverage(v);
      }
      if( zEndAff ){
        updateRangeAffinityStr(pRight, nTop, zEndAff);
        codeApplyAffinity(pParse, regBase+nEq, nTop, zEndAff);
      }else{
        assert( pParse->db->mallocFailed );
      }
      nConstraint += nTop;
      testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
 
      if( sqlite3ExprIsVector(pRight)==0 ){
        disableTerm(pLevel, pRangeEnd);
      }else{
        endEq = 1;
      }
    }else if( bStopAtNull ){
      if( regBignull==0 ){
        sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
        endEq = 0;
      }
      nConstraint++;
    }
    sqlite3DbFree(db, zStartAff);
    sqlite3DbFree(db, zEndAff);
 
    /* Top of the loop body */
    pLevel->p2 = sqlite3VdbeCurrentAddr(v);
 
    /* Check if the index cursor is past the end of the range. */
    if( nConstraint ){
      if( regBignull ){
        /* Except, skip the end-of-range check while doing the NULL-scan */
        sqlite3VdbeAddOp2(v, OP_IfNot, regBignull, sqlite3VdbeCurrentAddr(v)+3);
        VdbeComment((v, "If NULL-scan 2nd pass"));
        VdbeCoverage(v);
      }
      op = aEndOp[bRev*2 + endEq];
      sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
      testcase( op==OP_IdxGT );  VdbeCoverageIf(v, op==OP_IdxGT );
      testcase( op==OP_IdxGE );  VdbeCoverageIf(v, op==OP_IdxGE );
      testcase( op==OP_IdxLT );  VdbeCoverageIf(v, op==OP_IdxLT );
      testcase( op==OP_IdxLE );  VdbeCoverageIf(v, op==OP_IdxLE );
    }
    if( regBignull ){
      /* During a NULL-scan, check to see if we have reached the end of
      ** the NULLs */
      assert( bSeekPastNull==!bStopAtNull );
      assert( bSeekPastNull+bStopAtNull==1 );
      assert( nConstraint+bSeekPastNull>0 );
      sqlite3VdbeAddOp2(v, OP_If, regBignull, sqlite3VdbeCurrentAddr(v)+2);
      VdbeComment((v, "If NULL-scan 1st pass"));
      VdbeCoverage(v);
      op = aEndOp[bRev*2 + bSeekPastNull];
      sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
                           nConstraint+bSeekPastNull);
      testcase( op==OP_IdxGT );  VdbeCoverageIf(v, op==OP_IdxGT );
      testcase( op==OP_IdxGE );  VdbeCoverageIf(v, op==OP_IdxGE );
      testcase( op==OP_IdxLT );  VdbeCoverageIf(v, op==OP_IdxLT );
      testcase( op==OP_IdxLE );  VdbeCoverageIf(v, op==OP_IdxLE );
    }
 
    if( pLoop->wsFlags & WHERE_IN_EARLYOUT ){
      sqlite3VdbeAddOp2(v, OP_SeekHit, iIdxCur, 1);
    }
 
    /* Seek the table cursor, if required */
    omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0
           && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0;
    if( omitTable ){
      /* pIdx is a covering index.  No need to access the main table. */
    }else if( HasRowid(pIdx->pTable) ){
      if( (pWInfo->wctrlFlags & WHERE_SEEK_TABLE)
       || ( (pWInfo->wctrlFlags & WHERE_SEEK_UNIQ_TABLE)!=0
           && (pWInfo->eOnePass==ONEPASS_SINGLE || pLoop->nLTerm==0) )
      ){
        iRowidReg = ++pParse->nMem;
        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
        sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowidReg);
        VdbeCoverage(v);
      }else{
        codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
      }
    }else if( iCur!=iIdxCur ){
      Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
      iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
      for(j=0; j<pPk->nKeyCol; j++){
        k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j);
      }
      sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont,
                           iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
    }
 
    if( pLevel->iLeftJoin==0 ){
      /* If pIdx is an index on one or more expressions, then look through
      ** all the expressions in pWInfo and try to transform matching expressions
      ** into reference to index columns.  Also attempt to translate references
      ** to virtual columns in the table into references to (stored) columns
      ** of the index.
      **
      ** Do not do this for the RHS of a LEFT JOIN. This is because the
      ** expression may be evaluated after OP_NullRow has been executed on
      ** the cursor. In this case it is important to do the full evaluation,
      ** as the result of the expression may not be NULL, even if all table
      ** column values are.  https://www.sqlite.org/src/info/7fa8049685b50b5a
      **
      ** Also, do not do this when processing one index an a multi-index
      ** OR clause, since the transformation will become invalid once we
      ** move forward to the next index.
      ** https://sqlite.org/src/info/4e8e4857d32d401f
      */
      if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){
        whereIndexExprTrans(pIdx, iCur, iIdxCur, pWInfo);
      }
 
      /* If a partial index is driving the loop, try to eliminate WHERE clause
      ** terms from the query that must be true due to the WHERE clause of
      ** the partial index.
      **
      ** 2019-11-02 ticket 623eff57e76d45f6: This optimization does not work
      ** for a LEFT JOIN.
      */
      if( pIdx->pPartIdxWhere ){
        whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC);
      }
    }else{
      testcase( pIdx->pPartIdxWhere );
      /* The following assert() is not a requirement, merely an observation:
      ** The OR-optimization doesn't work for the right hand table of
      ** a LEFT JOIN: */
      assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 );
    }
 
    /* Record the instruction used to terminate the loop. */
    if( pLoop->wsFlags & WHERE_ONEROW ){
      pLevel->op = OP_Noop;
    }else if( bRev ){
      pLevel->op = OP_Prev;
    }else{
      pLevel->op = OP_Next;
    }
    pLevel->p1 = iIdxCur;
    pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0;
    if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){
      pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
    }else{
      assert( pLevel->p5==0 );
    }
    if( omitTable ) pIdx = 0;
  }else
 
#ifndef SQLITE_OMIT_OR_OPTIMIZATION
  if( pLoop->wsFlags & WHERE_MULTI_OR ){
    /* Case 5:  Two or more separately indexed terms connected by OR
    **
    ** Example:
    **
    **   CREATE TABLE t1(a,b,c,d);
    **   CREATE INDEX i1 ON t1(a);
    **   CREATE INDEX i2 ON t1(b);
    **   CREATE INDEX i3 ON t1(c);
    **
    **   SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13)
    **
    ** In the example, there are three indexed terms connected by OR.
    ** The top of the loop looks like this:
    **
    **          Null       1                # Zero the rowset in reg 1
    **
    ** Then, for each indexed term, the following. The arguments to
    ** RowSetTest are such that the rowid of the current row is inserted
    ** into the RowSet. If it is already present, control skips the
    ** Gosub opcode and jumps straight to the code generated by WhereEnd().
    **
    **        sqlite3WhereBegin(<term>)
    **          RowSetTest                  # Insert rowid into rowset
    **          Gosub      2 A
    **        sqlite3WhereEnd()
    **
    ** Following the above, code to terminate the loop. Label A, the target
    ** of the Gosub above, jumps to the instruction right after the Goto.
    **
    **          Null       1                # Zero the rowset in reg 1
    **          Goto       B                # The loop is finished.
    **
    **       A: <loop body>                 # Return data, whatever.
    **
    **          Return     2                # Jump back to the Gosub
    **
    **       B: <after the loop>
    **
    ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then
    ** use an ephemeral index instead of a RowSet to record the primary
    ** keys of the rows we have already seen.
    **
    */
    WhereClause *pOrWc;    /* The OR-clause broken out into subterms */
    SrcList *pOrTab;       /* Shortened table list or OR-clause generation */
    Index *pCov = 0;             /* Potential covering index (or NULL) */
    int iCovCur = pParse->nTab++;  /* Cursor used for index scans (if any) */
 
    int regReturn = ++pParse->nMem;           /* Register used with OP_Gosub */
    int regRowset = 0;                        /* Register for RowSet object */
    int regRowid = 0;                         /* Register holding rowid */
    int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */
    int iRetInit;                             /* Address of regReturn init */
    int untestedTerms = 0;             /* Some terms not completely tested */
    int ii;                            /* Loop counter */
    u16 wctrlFlags;                    /* Flags for sub-WHERE clause */
    Expr *pAndExpr = 0;                /* An ".. AND (...)" expression */
    Table *pTab = pTabItem->pTab;
 
    pTerm = pLoop->aLTerm[0];
    assert( pTerm!=0 );
    assert( pTerm->eOperator & WO_OR );
    assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
    pOrWc = &pTerm->u.pOrInfo->wc;
    pLevel->op = OP_Return;
    pLevel->p1 = regReturn;
 
    /* Set up a new SrcList in pOrTab containing the table being scanned
    ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
    ** This becomes the SrcList in the recursive call to sqlite3WhereBegin().
    */
    if( pWInfo->nLevel>1 ){
      int nNotReady;                 /* The number of notReady tables */
      struct SrcList_item *origSrc;     /* Original list of tables */
      nNotReady = pWInfo->nLevel - iLevel - 1;
      pOrTab = sqlite3StackAllocRaw(db,
                            sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
      if( pOrTab==0 ) return notReady;
      pOrTab->nAlloc = (u8)(nNotReady + 1);
      pOrTab->nSrc = pOrTab->nAlloc;
      memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
      origSrc = pWInfo->pTabList->a;
      for(k=1; k<=nNotReady; k++){
        memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
      }
    }else{
      pOrTab = pWInfo->pTabList;
    }
 
    /* Initialize the rowset register to contain NULL. An SQL NULL is
    ** equivalent to an empty rowset.  Or, create an ephemeral index
    ** capable of holding primary keys in the case of a WITHOUT ROWID.
    **
    ** Also initialize regReturn to contain the address of the instruction
    ** immediately following the OP_Return at the bottom of the loop. This
    ** is required in a few obscure LEFT JOIN cases where control jumps
    ** over the top of the loop into the body of it. In this case the
    ** correct response for the end-of-loop code (the OP_Return) is to
    ** fall through to the next instruction, just as an OP_Next does if
    ** called on an uninitialized cursor.
    */
    if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
      if( HasRowid(pTab) ){
        regRowset = ++pParse->nMem;
        sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset);
      }else{
        Index *pPk = sqlite3PrimaryKeyIndex(pTab);
        regRowset = pParse->nTab++;
        sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol);
        sqlite3VdbeSetP4KeyInfo(pParse, pPk);
      }
      regRowid = ++pParse->nMem;
    }
    iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn);
 
    /* If the original WHERE clause is z of the form:  (x1 OR x2 OR ...) AND y
    ** Then for every term xN, evaluate as the subexpression: xN AND z
    ** That way, terms in y that are factored into the disjunction will
    ** be picked up by the recursive calls to sqlite3WhereBegin() below.
    **
    ** Actually, each subexpression is converted to "xN AND w" where w is
    ** the "interesting" terms of z - terms that did not originate in the
    ** ON or USING clause of a LEFT JOIN, and terms that are usable as
    ** indices.
    **
    ** This optimization also only applies if the (x1 OR x2 OR ...) term
    ** is not contained in the ON clause of a LEFT JOIN.
    ** See ticket http://www.sqlite.org/src/info/f2369304e4
    */
    if( pWC->nTerm>1 ){
      int iTerm;
      for(iTerm=0; iTerm<pWC->nTerm; iTerm++){
        Expr *pExpr = pWC->a[iTerm].pExpr;
        if( &pWC->a[iTerm] == pTerm ) continue;
        testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
        testcase( pWC->a[iTerm].wtFlags & TERM_CODED );
        if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED))!=0 ) continue;
        if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
        testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
        pExpr = sqlite3ExprDup(db, pExpr, 0);
        pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
      }
      if( pAndExpr ){
        /* The extra 0x10000 bit on the opcode is masked off and does not
        ** become part of the new Expr.op.  However, it does make the
        ** op==TK_AND comparison inside of sqlite3PExpr() false, and this
        ** prevents sqlite3PExpr() from implementing AND short-circuit
        ** optimization, which we do not want here. */
        pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr);
      }
    }
 
    /* Run a separate WHERE clause for each term of the OR clause.  After
    ** eliminating duplicates from other WHERE clauses, the action for each
    ** sub-WHERE clause is to to invoke the main loop body as a subroutine.
    */
    wctrlFlags =  WHERE_OR_SUBCLAUSE | (pWInfo->wctrlFlags & WHERE_SEEK_TABLE);
    ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR"));
    for(ii=0; ii<pOrWc->nTerm; ii++){
      WhereTerm *pOrTerm = &pOrWc->a[ii];
      if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){
        WhereInfo *pSubWInfo;           /* Info for single OR-term scan */
        Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
        int jmp1 = 0;                   /* Address of jump operation */
        testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
               && !ExprHasProperty(pOrExpr, EP_FromJoin)
        ); /* See TH3 vtab25.400 and ticket 614b25314c766238 */
        if( pAndExpr ){
          pAndExpr->pLeft = pOrExpr;
          pOrExpr = pAndExpr;
        }
        /* Loop through table entries that match term pOrTerm. */
        ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));
        WHERETRACE(0xffff, ("Subplan for OR-clause:\n"));
        pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
                                      wctrlFlags, iCovCur);
        assert( pSubWInfo || pParse->nErr || db->mallocFailed );
        if( pSubWInfo ){
          WhereLoop *pSubLoop;
          int addrExplain = sqlite3WhereExplainOneScan(
              pParse, pOrTab, &pSubWInfo->a[0], 0
          );
          sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain);
 
          /* This is the sub-WHERE clause body.  First skip over
          ** duplicate rows from prior sub-WHERE clauses, and record the
          ** rowid (or PRIMARY KEY) for the current row so that the same
          ** row will be skipped in subsequent sub-WHERE clauses.
          */
          if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
            int iSet = ((ii==pOrWc->nTerm-1)?-1:ii);
            if( HasRowid(pTab) ){
              sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
              jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0,
                                          regRowid, iSet);
              VdbeCoverage(v);
            }else{
              Index *pPk = sqlite3PrimaryKeyIndex(pTab);
              int nPk = pPk->nKeyCol;
              int iPk;
              int r;
 
              /* Read the PK into an array of temp registers. */
              r = sqlite3GetTempRange(pParse, nPk);
              for(iPk=0; iPk<nPk; iPk++){
                int iCol = pPk->aiColumn[iPk];
                sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
              }
 
              /* Check if the temp table already contains this key. If so,
              ** the row has already been included in the result set and
              ** can be ignored (by jumping past the Gosub below). Otherwise,
              ** insert the key into the temp table and proceed with processing
              ** the row.
              **
              ** Use some of the same optimizations as OP_RowSetTest: If iSet
              ** is zero, assume that the key cannot already be present in
              ** the temp table. And if iSet is -1, assume that there is no
              ** need to insert the key into the temp table, as it will never
              ** be tested for.  */
              if( iSet ){
                jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk);
                VdbeCoverage(v);
              }
              if( iSet>=0 ){
                sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid);
                sqlite3VdbeAddOp4Int(v, OP_IdxInsert, regRowset, regRowid,
                                     r, nPk);
                if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
              }
 
              /* Release the array of temp registers */
              sqlite3ReleaseTempRange(pParse, r, nPk);
            }
          }
 
          /* Invoke the main loop body as a subroutine */
          sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);
 
          /* Jump here (skipping the main loop body subroutine) if the
          ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */
          if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1);
 
          /* The pSubWInfo->untestedTerms flag means that this OR term
          ** contained one or more AND term from a notReady table.  The
          ** terms from the notReady table could not be tested and will
          ** need to be tested later.
          */
          if( pSubWInfo->untestedTerms ) untestedTerms = 1;
 
          /* If all of the OR-connected terms are optimized using the same
          ** index, and the index is opened using the same cursor number
          ** by each call to sqlite3WhereBegin() made by this loop, it may
          ** be possible to use that index as a covering index.
          **
          ** If the call to sqlite3WhereBegin() above resulted in a scan that
          ** uses an index, and this is either the first OR-connected term
          ** processed or the index is the same as that used by all previous
          ** terms, set pCov to the candidate covering index. Otherwise, set
          ** pCov to NULL to indicate that no candidate covering index will
          ** be available.
          */
          pSubLoop = pSubWInfo->a[0].pWLoop;
          assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
          if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0
           && (ii==0 || pSubLoop->u.btree.pIndex==pCov)
           && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
          ){
            assert( pSubWInfo->a[0].iIdxCur==iCovCur );
            pCov = pSubLoop->u.btree.pIndex;
          }else{
            pCov = 0;
          }
 
          /* Finish the loop through table entries that match term pOrTerm. */
          sqlite3WhereEnd(pSubWInfo);
          ExplainQueryPlanPop(pParse);
        }
      }
    }
    ExplainQueryPlanPop(pParse);
    pLevel->u.pCovidx = pCov;
    if( pCov ) pLevel->iIdxCur = iCovCur;
    if( pAndExpr ){
      pAndExpr->pLeft = 0;
      sqlite3ExprDelete(db, pAndExpr);
    }
    sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v));
    sqlite3VdbeGoto(v, pLevel->addrBrk);
    sqlite3VdbeResolveLabel(v, iLoopBody);
 
    if( pWInfo->nLevel>1 ){ sqlite3StackFree(db, pOrTab); }
    if( !untestedTerms ) disableTerm(pLevel, pTerm);
  }else
#endif /* SQLITE_OMIT_OR_OPTIMIZATION */
 
  {
    /* Case 6:  There is no usable index.  We must do a complete
    **          scan of the entire table.
    */
    static const u8 aStep[] = { OP_Next, OP_Prev };
    static const u8 aStart[] = { OP_Rewind, OP_Last };
    assert( bRev==0 || bRev==1 );
    if( pTabItem->fg.isRecursive ){
      /* Tables marked isRecursive have only a single row that is stored in
      ** a pseudo-cursor.  No need to Rewind or Next such cursors. */
      pLevel->op = OP_Noop;
    }else{
      codeCursorHint(pTabItem, pWInfo, pLevel, 0);
      pLevel->op = aStep[bRev];
      pLevel->p1 = iCur;
      pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
      VdbeCoverageIf(v, bRev==0);
      VdbeCoverageIf(v, bRev!=0);
      pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
    }
  }
 
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  pLevel->addrVisit = sqlite3VdbeCurrentAddr(v);
#endif
 
  /* Insert code to test every subexpression that can be completely
  ** computed using the current set of tables.
  **
  ** This loop may run between one and three times, depending on the
  ** constraints to be generated. The value of stack variable iLoop
  ** determines the constraints coded by each iteration, as follows:
  **
  ** iLoop==1: Code only expressions that are entirely covered by pIdx.
  ** iLoop==2: Code remaining expressions that do not contain correlated
  **           sub-queries.
  ** iLoop==3: Code all remaining expressions.
  **
  ** An effort is made to skip unnecessary iterations of the loop.
  */
  iLoop = (pIdx ? 1 : 2);
  do{
    int iNext = 0;                /* Next value for iLoop */
    for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
      Expr *pE;
      int skipLikeAddr = 0;
      testcase( pTerm->wtFlags & TERM_VIRTUAL );
      testcase( pTerm->wtFlags & TERM_CODED );
      if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
      if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
        testcase( pWInfo->untestedTerms==0
            && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 );
        pWInfo->untestedTerms = 1;
        continue;
      }
      pE = pTerm->pExpr;
      assert( pE!=0 );
      if( (pTabItem->fg.jointype&JT_LEFT) && !ExprHasProperty(pE,EP_FromJoin) ){
        continue;
      }
 
      if( iLoop==1 && !sqlite3ExprCoveredByIndex(pE, pLevel->iTabCur, pIdx) ){
        iNext = 2;
        continue;
      }
      if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){
        if( iNext==0 ) iNext = 3;
        continue;
      }
 
      if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){
        /* If the TERM_LIKECOND flag is set, that means that the range search
        ** is sufficient to guarantee that the LIKE operator is true, so we
        ** can skip the call to the like(A,B) function.  But this only works
        ** for strings.  So do not skip the call to the function on the pass
        ** that compares BLOBs. */
#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
        continue;
#else
        u32 x = pLevel->iLikeRepCntr;
        if( x>0 ){
          skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1));
          VdbeCoverageIf(v, (x&1)==1);
          VdbeCoverageIf(v, (x&1)==0);
        }
#endif
      }
#ifdef WHERETRACE_ENABLED /* 0xffff */
      if( sqlite3WhereTrace ){
        VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d",
                         pWC->nTerm-j, pTerm, iLoop));
      }
      if( sqlite3WhereTrace & 0x800 ){
        sqlite3DebugPrintf("Coding auxiliary constraint:\n");
        sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
      }
#endif
      sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
      if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr);
      pTerm->wtFlags |= TERM_CODED;
    }
    iLoop = iNext;
  }while( iLoop>0 );
 
  /* Insert code to test for implied constraints based on transitivity
  ** of the "==" operator.
  **
  ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123"
  ** and we are coding the t1 loop and the t2 loop has not yet coded,
  ** then we cannot use the "t1.a=t2.b" constraint, but we can code
  ** the implied "t1.a=123" constraint.
  */
  for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
    Expr *pE, sEAlt;
    WhereTerm *pAlt;
    if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
    if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue;
    if( (pTerm->eOperator & WO_EQUIV)==0 ) continue;
    if( pTerm->leftCursor!=iCur ) continue;
    if( pTabItem->fg.jointype & JT_LEFT ) continue;
    pE = pTerm->pExpr;
#ifdef WHERETRACE_ENABLED /* 0x800 */
    if( sqlite3WhereTrace & 0x800 ){
      sqlite3DebugPrintf("Coding transitive constraint:\n");
      sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
    }
#endif
    assert( !ExprHasProperty(pE, EP_FromJoin) );
    assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
    pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.leftColumn, notReady,
                    WO_EQ|WO_IN|WO_IS, 0);
    if( pAlt==0 ) continue;
    if( pAlt->wtFlags & (TERM_CODED) ) continue;
    if( (pAlt->eOperator & WO_IN)
     && (pAlt->pExpr->flags & EP_xIsSelect)
     && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
    ){
      continue;
    }
    testcase( pAlt->eOperator & WO_EQ );
    testcase( pAlt->eOperator & WO_IS );
    testcase( pAlt->eOperator & WO_IN );
    VdbeModuleComment((v, "begin transitive constraint"));
    sEAlt = *pAlt->pExpr;
    sEAlt.pLeft = pE->pLeft;
    sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL);
  }
 
  /* For a LEFT OUTER JOIN, generate code that will record the fact that
  ** at least one row of the right table has matched the left table.
  */
  if( pLevel->iLeftJoin ){
    pLevel->addrFirst = sqlite3VdbeCurrentAddr(v);
    sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
    VdbeComment((v, "record LEFT JOIN hit"));
    for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){
      testcase( pTerm->wtFlags & TERM_VIRTUAL );
      testcase( pTerm->wtFlags & TERM_CODED );
      if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
      if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
        assert( pWInfo->untestedTerms );
        continue;
      }
      assert( pTerm->pExpr );
      sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
      pTerm->wtFlags |= TERM_CODED;
    }
  }
 
#if WHERETRACE_ENABLED /* 0x20800 */
  if( sqlite3WhereTrace & 0x20000 ){
    sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n",
                       iLevel);
    sqlite3WhereClausePrint(pWC);
  }
  if( sqlite3WhereTrace & 0x800 ){

Referenced by sqlite3WhereBegin().

◆ sqlite3WhereContinueLabel()

SQLITE_PRIVATE int sqlite3WhereContinueLabel ( WhereInfo * pWInfo )

Definition at line 145717 of file sqlite3.c.

Referenced by sqlite3Select().

◆ sqlite3WhereEnd()

SQLITE_PRIVATE void sqlite3WhereEnd ( WhereInfo * pWInfo )

Definition at line 150889 of file sqlite3.c.

                                                      {
  Parse *pParse = pWInfo->pParse;
  Vdbe *v = pParse->pVdbe;
  int i;
  WhereLevel *pLevel;
  WhereLoop *pLoop;
  SrcList *pTabList = pWInfo->pTabList;
  sqlite3 *db = pParse->db;
 
  /* Generate loop termination code.
  */
  VdbeModuleComment((v, "End WHERE-core"));
  for(i=pWInfo->nLevel-1; i>=0; i--){
    int addr;
    pLevel = &pWInfo->a[i];
    pLoop = pLevel->pWLoop;
    if( pLevel->op!=OP_Noop ){
#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
      int addrSeek = 0;
      Index *pIdx;
      int n;
      if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED
       && i==pWInfo->nLevel-1  /* Ticket [ef9318757b152e3] 2017-10-21 */
       && (pLoop->wsFlags & WHERE_INDEXED)!=0
       && (pIdx = pLoop->u.btree.pIndex)->hasStat1
       && (n = pLoop->u.btree.nDistinctCol)>0
       && pIdx->aiRowLogEst[n]>=36
      ){
        int r1 = pParse->nMem+1;
        int j, op;
        for(j=0; j<n; j++){
          sqlite3VdbeAddOp3(v, OP_Column, pLevel->iIdxCur, j, r1+j);
        }
        pParse->nMem += n+1;
        op = pLevel->op==OP_Prev ? OP_SeekLT : OP_SeekGT;
        addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n);
        VdbeCoverageIf(v, op==OP_SeekLT);
        VdbeCoverageIf(v, op==OP_SeekGT);
        sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2);
      }
#endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */
      /* The common case: Advance to the next row */
      sqlite3VdbeResolveLabel(v, pLevel->addrCont);
      sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
      sqlite3VdbeChangeP5(v, pLevel->p5);
      VdbeCoverage(v);
      VdbeCoverageIf(v, pLevel->op==OP_Next);
      VdbeCoverageIf(v, pLevel->op==OP_Prev);
      VdbeCoverageIf(v, pLevel->op==OP_VNext);
      if( pLevel->regBignull ){
        sqlite3VdbeResolveLabel(v, pLevel->addrBignull);
        sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1);
        VdbeCoverage(v);
      }
#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
      if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek);
#endif
    }else{
      sqlite3VdbeResolveLabel(v, pLevel->addrCont);
    }
    if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
      struct InLoop *pIn;
      int j;
      sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
      for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
        sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
        if( pIn->eEndLoopOp!=OP_Noop ){
          if( pIn->nPrefix ){
            assert( pLoop->wsFlags & WHERE_IN_EARLYOUT );
            if( pLevel->iLeftJoin ){
              /* For LEFT JOIN queries, cursor pIn->iCur may not have been
              ** opened yet. This occurs for WHERE clauses such as
              ** "a = ? AND b IN (...)", where the index is on (a, b). If
              ** the RHS of the (a=?) is NULL, then the "b IN (...)" may
              ** never have been coded, but the body of the loop run to
              ** return the null-row. So, if the cursor is not open yet,
              ** jump over the OP_Next or OP_Prev instruction about to
              ** be coded.  */
              sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur,
                  sqlite3VdbeCurrentAddr(v) + 2 +
                     ((pLoop->wsFlags & WHERE_VIRTUALTABLE)==0)
              );
              VdbeCoverage(v);
            }
            if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ){
              sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur,
                  sqlite3VdbeCurrentAddr(v)+2,
                  pIn->iBase, pIn->nPrefix);
              VdbeCoverage(v);
            }
          }
          sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
          VdbeCoverage(v);
          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev);
          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next);
        }
        sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
      }
    }
    sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
    if( pLevel->addrSkip ){
      sqlite3VdbeGoto(v, pLevel->addrSkip);
      VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
      sqlite3VdbeJumpHere(v, pLevel->addrSkip);
      sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
    }
#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
    if( pLevel->addrLikeRep ){
      sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1),
                        pLevel->addrLikeRep);
      VdbeCoverage(v);
    }
#endif
    if( pLevel->iLeftJoin ){
      int ws = pLoop->wsFlags;
      addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
      assert( (ws & WHERE_IDX_ONLY)==0 || (ws & WHERE_INDEXED)!=0 );
      if( (ws & WHERE_IDX_ONLY)==0 ){
        assert( pLevel->iTabCur==pTabList->a[pLevel->iFrom].iCursor );
        sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
      }
      if( (ws & WHERE_INDEXED)
       || ((ws & WHERE_MULTI_OR) && pLevel->u.pCovidx)
      ){
        sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
      }
      if( pLevel->op==OP_Return ){
        sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
      }else{
        sqlite3VdbeGoto(v, pLevel->addrFirst);
      }
      sqlite3VdbeJumpHere(v, addr);
    }
    VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
                     pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
  }
 
  /* The "break" point is here, just past the end of the outer loop.
  ** Set it.
  */
  sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
 
  assert( pWInfo->nLevel<=pTabList->nSrc );
  for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
    int k, last;
    VdbeOp *pOp;
    Index *pIdx = 0;
    struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
    Table *pTab = pTabItem->pTab;
    assert( pTab!=0 );
    pLoop = pLevel->pWLoop;
 
    /* For a co-routine, change all OP_Column references to the table of
    ** the co-routine into OP_Copy of result contained in a register.
    ** OP_Rowid becomes OP_Null.
    */
    if( pTabItem->fg.viaCoroutine ){
      testcase( pParse->db->mallocFailed );
      translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
                            pTabItem->regResult, 0);
      continue;
    }
 
#ifdef SQLITE_ENABLE_EARLY_CURSOR_CLOSE
    /* Close all of the cursors that were opened by sqlite3WhereBegin.
    ** Except, do not close cursors that will be reused by the OR optimization
    ** (WHERE_OR_SUBCLAUSE).  And do not close the OP_OpenWrite cursors
    ** created for the ONEPASS optimization.
    */
    if( (pTab->tabFlags & TF_Ephemeral)==0
     && pTab->pSelect==0
     && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
    ){
      int ws = pLoop->wsFlags;
      if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){
        sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
      }
      if( (ws & WHERE_INDEXED)!=0
       && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0
       && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1]
      ){
        sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
      }
    }
#endif
 
    /* If this scan uses an index, make VDBE code substitutions to read data
    ** from the index instead of from the table where possible.  In some cases
    ** this optimization prevents the table from ever being read, which can
    ** yield a significant performance boost.
    **
    ** Calls to the code generator in between sqlite3WhereBegin and
    ** sqlite3WhereEnd will have created code that references the table
    ** directly.  This loop scans all that code looking for opcodes
    ** that reference the table and converts them into opcodes that
    ** reference the index.
    */
    if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){
      pIdx = pLoop->u.btree.pIndex;
    }else if( pLoop->wsFlags & WHERE_MULTI_OR ){
      pIdx = pLevel->u.pCovidx;
    }
    if( pIdx
     && (pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable))
     && !db->mallocFailed
    ){
      last = sqlite3VdbeCurrentAddr(v);
      k = pLevel->addrBody;
#ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeAddopTrace ){
        printf("TRANSLATE opcodes in range %d..%d\n", k, last-1);
      }
#endif
      pOp = sqlite3VdbeGetOp(v, k);
      for(; k<last; k++, pOp++){
        if( pOp->p1!=pLevel->iTabCur ) continue;
        if( pOp->opcode==OP_Column
#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
         || pOp->opcode==OP_Offset
#endif
        ){
          int x = pOp->p2;
          assert( pIdx->pTable==pTab );
          if( !HasRowid(pTab) ){
            Index *pPk = sqlite3PrimaryKeyIndex(pTab);
            x = pPk->aiColumn[x];
            assert( x>=0 );
          }else{
            testcase( x!=sqlite3StorageColumnToTable(pTab,x) );
            x = sqlite3StorageColumnToTable(pTab,x);
          }
          x = sqlite3TableColumnToIndex(pIdx, x);
          if( x>=0 ){
            pOp->p2 = x;
            pOp->p1 = pLevel->iIdxCur;
            OpcodeRewriteTrace(db, k, pOp);
          }
          assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0
              || pWInfo->eOnePass );
        }else if( pOp->opcode==OP_Rowid ){
          pOp->p1 = pLevel->iIdxCur;
          pOp->opcode = OP_IdxRowid;
          OpcodeRewriteTrace(db, k, pOp);
        }else if( pOp->opcode==OP_IfNullRow ){
          pOp->p1 = pLevel->iIdxCur;
          OpcodeRewriteTrace(db, k, pOp);
        }
      }
#ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n");
#endif
    }
  }
 
  /* Undo all Expr node modifications */
  while( pWInfo->pExprMods ){
    WhereExprMod *p = pWInfo->pExprMods;
    pWInfo->pExprMods = p->pNext;
    memcpy(p->pExpr, &p->orig, sizeof(p->orig));
    sqlite3DbFree(db, p);
  }
 

References SrcList::a, WhereInfo::a, WhereLevel::addrBignull, WhereLevel::addrBody, WhereLevel::addrBrk, WhereLevel::addrCont, WhereLevel::addrFirst, WhereLevel::addrLikeRep, WhereLevel::addrNxt, WhereLevel::addrSkip, Index::aiColumn, WhereInfo::aiCurOnePass, WhereLevel::aInLoop, Index::aiRowLogEst, WhereLoop::btree, Parse::db, WhereInfo::eDistinct, WhereInfo::eOnePass, sqlite3::flags, HasRowid, WhereInfo::iBreak, SrcList::SrcList_item::iCursor, WhereLevel::iFrom, WhereLevel::iIdxCur, WhereLevel::iLeftJoin, WhereLevel::iLikeRepCntr, WhereLevel::in, WhereLevel::iTabCur, sqlite3::mallocFailed, WhereLoop::nDistinctCol, WhereLevel::nIn, WhereInfo::nLevel, Parse::nMem, Parse::nQueryLoop, SrcList::nSrc, ONEPASS_OFF, WhereLevel::op, OP_Close, OP_Column, OP_DecrJumpZero, OP_Gosub, OP_Goto, OP_IdxRowid, OP_IfNoHope, OP_IfNotOpen, OP_IfNullRow, OP_IfPos, OP_Next, OP_Noop, OP_NullRow, OP_Offset, OP_Prev, OP_Return, OP_Rowid, OP_SeekGT, OP_SeekLT, OP_VNext, VdbeOp::opcode, OpcodeRewriteTrace, WhereExprMod::orig, VdbeOp::p1, WhereLevel::p1, VdbeOp::p2, WhereLevel::p2, WhereLevel::p3, WhereLevel::p5, WhereLevel::pCovidx, WhereExprMod::pExpr, WhereInfo::pExprMods, WhereLoop::pIndex, WhereExprMod::pNext, WhereInfo::pParse, printf, Table::pSelect, SrcList::SrcList_item::pTab, Index::pTable, WhereInfo::pTabList, Parse::pVdbe, WhereLevel::pWLoop, WhereLevel::regBignull, WhereInfo::savedNQueryLoop, sqlite3DbFree(), sqlite3PrimaryKeyIndex(), sqlite3StorageColumnToTable(), sqlite3TableColumnToIndex(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4Int(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), sqlite3VdbeGoto(), sqlite3VdbeJumpHere(), sqlite3VdbeResolveLabel(), Table::tabFlags, testcase, TF_Ephemeral, translateColumnToCopy(), WhereLevel::u, WhereLoop::u, VdbeComment, VdbeCoverage, VdbeCoverageIf, VdbeModuleComment, WhereInfo::wctrlFlags, WHERE_AUTO_INDEX, WHERE_DISTINCT_ORDERED, WHERE_IDX_ONLY, WHERE_IN_ABLE, WHERE_IN_EARLYOUT, WHERE_INDEXED, WHERE_IPK, WHERE_MULTI_OR, WHERE_OR_SUBCLAUSE, WHERE_VIRTUALTABLE, whereInfoFree(), WhereLoop::wsFlags, Table::zName, and Index::zName.

Referenced by fkScanChildren(), sqlite3DeleteFrom(), sqlite3Select(), sqlite3Update(), sqlite3WindowCodeStep(), and updateVirtualTable().

◆ sqlite3WhereExplainOneScan()

SQLITE_PRIVATE int sqlite3WhereExplainOneScan	(	Parse *	pParse,
		SrcList *	pTabList,
		WhereLevel *	pLevel,
		u16	wctrlFlags )

Definition at line 141637 of file sqlite3.c.

 {
  int ret = 0;
#if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
  if( sqlite3ParseToplevel(pParse)->explain==2 )
#endif
  {
    struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
    Vdbe *v = pParse->pVdbe;      /* VM being constructed */
    sqlite3 *db = pParse->db;     /* Database handle */
    int isSearch;                 /* True for a SEARCH. False for SCAN. */
    WhereLoop *pLoop;             /* The controlling WhereLoop object */
    u32 flags;                    /* Flags that describe this loop */
    char *zMsg;                   /* Text to add to EQP output */
    StrAccum str;                 /* EQP output string */
    char zBuf[100];               /* Initial space for EQP output string */
 
    pLoop = pLevel->pWLoop;
    flags = pLoop->wsFlags;
    if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_OR_SUBCLAUSE) ) return 0;
 
    isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0
            || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0))
            || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX));
 
    sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH);
    sqlite3_str_appendall(&str, isSearch ? "SEARCH" : "SCAN");
    if( pItem->pSelect ){
      sqlite3_str_appendf(&str, " SUBQUERY %u", pItem->pSelect->selId);
    }else{
      sqlite3_str_appendf(&str, " TABLE %s", pItem->zName);
    }
 
    if( pItem->zAlias ){
      sqlite3_str_appendf(&str, " AS %s", pItem->zAlias);
    }
    if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){
      const char *zFmt = 0;
      Index *pIdx;
 
      assert( pLoop->u.btree.pIndex!=0 );
      pIdx = pLoop->u.btree.pIndex;
      assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
      if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
        if( isSearch ){
          zFmt = "PRIMARY KEY";
        }
      }else if( flags & WHERE_PARTIALIDX ){
        zFmt = "AUTOMATIC PARTIAL COVERING INDEX";
      }else if( flags & WHERE_AUTO_INDEX ){
        zFmt = "AUTOMATIC COVERING INDEX";
      }else if( flags & WHERE_IDX_ONLY ){
        zFmt = "COVERING INDEX %s";
      }else{
        zFmt = "INDEX %s";
      }
      if( zFmt ){
        sqlite3_str_append(&str, " USING ", 7);
        sqlite3_str_appendf(&str, zFmt, pIdx->zName);
        explainIndexRange(&str, pLoop);
      }
    }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
      const char *zRangeOp;
      if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){
        zRangeOp = "=";
      }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){
        zRangeOp = ">? AND rowid<";
      }else if( flags&WHERE_BTM_LIMIT ){
        zRangeOp = ">";
      }else{
        assert( flags&WHERE_TOP_LIMIT);
        zRangeOp = "<";
      }
      sqlite3_str_appendf(&str,
          " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp);
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
      sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s",
                  pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
    }
#endif
#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS
    if( pLoop->nOut>=10 ){
      sqlite3_str_appendf(&str, " (~%llu rows)",
             sqlite3LogEstToInt(pLoop->nOut));
    }else{
      sqlite3_str_append(&str, " (~1 row)", 9);
    }
#endif
    zMsg = sqlite3StrAccumFinish(&str);

References SrcList::a, Parse::addrExplain, WhereLoop::btree, Parse::db, explainIndexRange(), HasRowid, WhereLoop::idxNum, WhereLoop::idxStr, WhereLevel::iFrom, IsPrimaryKeyIndex, WhereLoop::nEq, WhereLoop::nOut, OP_Explain, P4_DYNAMIC, WhereLoop::pIndex, Parse::pVdbe, WhereLevel::pWLoop, sqlite3_str_append(), sqlite3_str_appendall(), sqlite3_str_appendf(), sqlite3ExplainBreakpoint, sqlite3ParseToplevel, sqlite3StrAccumFinish(), sqlite3StrAccumInit(), sqlite3VdbeAddOp4(), sqlite3VdbeCurrentAddr(), SQLITE_MAX_LENGTH, WhereLoop::u, WhereLoop::vtab, WHERE_AUTO_INDEX, WHERE_BOTH_LIMIT, WHERE_BTM_LIMIT, WHERE_COLUMN_EQ, WHERE_COLUMN_IN, WHERE_CONSTRAINT, WHERE_IDX_ONLY, WHERE_IPK, WHERE_MULTI_OR, WHERE_OR_SUBCLAUSE, WHERE_ORDERBY_MAX, WHERE_ORDERBY_MIN, WHERE_PARTIALIDX, WHERE_TOP_LIMIT, WHERE_VIRTUALTABLE, WhereLoop::wsFlags, and Index::zName.

Referenced by sqlite3WhereBegin().

◆ sqlite3WhereExprAnalyze()

SQLITE_PRIVATE void sqlite3WhereExprAnalyze	(	SrcList *	pTabList,
		WhereClause *	pWC )

Definition at line 145549 of file sqlite3.c.

References exprAnalyze(), and WhereClause::nTerm.

Referenced by exprAnalyzeOrTerm(), and sqlite3WhereBegin().

◆ sqlite3WhereExprListUsage()

SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage	(	WhereMaskSet *	pMaskSet,
		ExprList *	pList )

Definition at line 145529 of file sqlite3.c.

                                                                             {
  return p ? sqlite3WhereExprUsageNN(pMaskSet,p) : 0;
}
SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){
  int i;
  Bitmask mask = 0;
  if( pList ){

Referenced by exprAnalyze(), exprSelectUsage(), sqlite3WhereBegin(), and sqlite3WhereExprUsageNN().

◆ sqlite3WhereExprUsage()

SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage	(	WhereMaskSet *	pMaskSet,
		Expr *	p )

Definition at line 145526 of file sqlite3.c.

Referenced by exprAnalyze(), exprSelectUsage(), and wherePathSatisfiesOrderBy().

◆ sqlite3WhereExprUsageNN()

SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN	(	WhereMaskSet *	pMaskSet,
		Expr *	p )

Definition at line 145498 of file sqlite3.c.

                                                                               {
  Bitmask mask;
  if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
    return sqlite3WhereGetMask(pMaskSet, p->iTable);
  }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
    assert( p->op!=TK_IF_NULL_ROW );
    return 0;
  }
  mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0;
  if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft);
  if( p->pRight ){
    mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
    assert( p->x.pList==0 );
  }else if( ExprHasProperty(p, EP_xIsSelect) ){
    if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1;
    mask |= exprSelectUsage(pMaskSet, p->x.pSelect);
  }else if( p->x.pList ){
    mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
  }
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && p->y.pWin ){
    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);

References WhereMaskSet::bVarSelect, EP_FixedCol, EP_Leaf, EP_TokenOnly, EP_VarSelect, EP_xIsSelect, ExprHasProperty, exprSelectUsage(), Expr::iTable, mask, Expr::op, Expr::pLeft, Expr::pList, Window::pPartition, Expr::pRight, Expr::pSelect, Expr::pWin, sqlite3WhereExprListUsage(), sqlite3WhereExprUsageNN(), sqlite3WhereGetMask(), TK_AGG_FUNCTION, TK_COLUMN, TK_FUNCTION, TK_IF_NULL_ROW, Expr::x, and Expr::y.

Referenced by exprAnalyze(), and sqlite3WhereExprUsageNN().

◆ sqlite3WhereFindTerm()

SQLITE_PRIVATE WhereTerm * sqlite3WhereFindTerm	(	WhereClause *	pWC,
		int	iCur,
		int	iColumn,
		Bitmask	notReady,
		u32	op,
		Index *	pIdx )

Definition at line 146024 of file sqlite3.c.

 {
  WhereTerm *pResult = 0;
  WhereTerm *p;
  WhereScan scan;
 
  p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
  op &= WO_EQ|WO_IS;
  while( p ){
    if( (p->prereqRight & notReady)==0 ){
      if( p->prereqRight==0 && (p->eOperator&op)!=0 ){
        testcase( p->eOperator & WO_IS );
        return p;
      }

References WhereTerm::eOperator, WhereTerm::prereqRight, testcase, whereScanInit(), whereScanNext(), WO_EQ, and WO_IS.

Referenced by isDistinctRedundant(), wherePathSatisfiesOrderBy(), and whereShortCut().

◆ sqlite3WhereGetMask()

SQLITE_PRIVATE Bitmask sqlite3WhereGetMask	(	WhereMaskSet *	pMaskSet,
		int	iCursor )

Definition at line 145819 of file sqlite3.c.

                                                                               {
  int i;
  assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
  for(i=0; i<pMaskSet->n; i++){

Referenced by exprAnalyze(), exprAnalyzeOrTerm(), sqlite3WhereBegin(), and sqlite3WhereExprUsageNN().

◆ sqlite3WhereIsDistinct()

SQLITE_PRIVATE int sqlite3WhereIsDistinct ( WhereInfo * pWInfo )

Definition at line 145662 of file sqlite3.c.

Referenced by sqlite3Select().

◆ sqlite3WhereIsOrdered()

SQLITE_PRIVATE int sqlite3WhereIsOrdered ( WhereInfo * pWInfo )

Definition at line 145674 of file sqlite3.c.

References WhereInfo::nOBSat.

Referenced by sqlite3Select().

◆ sqlite3WhereIsSorted()

SQLITE_PRIVATE int sqlite3WhereIsSorted ( WhereInfo * pWInfo )

Definition at line 149620 of file sqlite3.c.

References WhereInfo::sorted, WhereInfo::wctrlFlags, WHERE_GROUPBY, and WHERE_SORTBYGROUP.

Referenced by sqlite3Select().

◆ sqlite3WhereOkOnePass()

SQLITE_PRIVATE int sqlite3WhereOkOnePass	(	WhereInfo *	pWInfo,
		int *	aiCur )

Definition at line 145747 of file sqlite3.c.

                                                                       {
  memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);
#ifdef WHERETRACE_ENABLED
  if( sqlite3WhereTrace && pWInfo->eOnePass!=ONEPASS_OFF ){
    sqlite3DebugPrintf("%s cursors: %d %d\n",

References WhereInfo::aiCurOnePass, WhereInfo::eOnePass, ONEPASS_OFF, and ONEPASS_SINGLE.

Referenced by sqlite3DeleteFrom(), sqlite3Update(), and updateVirtualTable().

◆ sqlite3WhereOrderByLimitOptLabel()

SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel ( WhereInfo * pWInfo )

Definition at line 145701 of file sqlite3.c.

                                                                      {
  WhereLevel *pInner;
  if( !pWInfo->bOrderedInnerLoop ){
    /* The ORDER BY LIMIT optimization does not apply.  Jump to the
    ** continuation of the inner-most loop. */

References WhereInfo::a, WhereLevel::addrNxt, WhereInfo::bOrderedInnerLoop, WhereInfo::iContinue, and WhereInfo::nLevel.

Referenced by sqlite3Select().

◆ sqlite3WhereOutputRowCount()

SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount ( WhereInfo * pWInfo )

Definition at line 145654 of file sqlite3.c.

References WhereInfo::nRowOut.

Referenced by sqlite3Select().

◆ sqlite3WhereSplit()

SQLITE_PRIVATE void sqlite3WhereSplit	(	WhereClause *	pWC,
		Expr *	pExpr,
		u8	op )

Definition at line 145441 of file sqlite3.c.

                                                                           {
  Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
  pWC->op = op;
  if( pE2==0 ) return;
  if( pE2->op!=op ){

References Expr::op, WhereClause::op, Expr::pLeft, Expr::pRight, sqlite3ExprSkipCollateAndLikely(), sqlite3WhereSplit(), and whereClauseInsert().

Referenced by exprAnalyzeOrTerm(), sqlite3WhereBegin(), and sqlite3WhereSplit().

◆ sqlite3WhereTabFuncArgs()

SQLITE_PRIVATE void sqlite3WhereTabFuncArgs	(	Parse *	pParse,
		struct SrcList_item *	pItem,
		WhereClause *	pWC )

Definition at line 145566 of file sqlite3.c.

 {
  Table *pTab;
  int j, k;
  ExprList *pArgs;
  Expr *pColRef;
  Expr *pTerm;
  if( pItem->fg.isTabFunc==0 ) return;
  pTab = pItem->pTab;
  assert( pTab!=0 );
  pArgs = pItem->u1.pFuncArg;
  if( pArgs==0 ) return;
  for(j=k=0; j<pArgs->nExpr; j++){
    Expr *pRhs;
    while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
    if( k>=pTab->nCol ){
      sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d",
                      pTab->zName, j);
      return;
    }
    pColRef = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
    if( pColRef==0 ) return;
    pColRef->iTable = pItem->iCursor;
    pColRef->iColumn = k++;
    pColRef->y.pTab = pTab;
    pRhs = sqlite3PExpr(pParse, TK_UPLUS,
        sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
    pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);

References ExprList::a, Table::aCol, COLFLAG_HIDDEN, Column::colFlags, Parse::db, Expr::iColumn, Expr::iTable, JT_LEFT, Table::nCol, ExprList::nExpr, ExprList::ExprList_item::pExpr, Expr::pTab, sqlite3ErrorMsg(), sqlite3ExprAlloc(), sqlite3ExprDup(), sqlite3PExpr(), sqlite3SetJoinExpr(), TERM_DYNAMIC, TK_COLUMN, TK_EQ, TK_UPLUS, whereClauseInsert(), Expr::y, and Table::zName.

Referenced by sqlite3WhereBegin().

◆ sqlite3WhereUsesDeferredSeek()

SQLITE_PRIVATE int sqlite3WhereUsesDeferredSeek ( WhereInfo * pWInfo )

Definition at line 145763 of file sqlite3.c.

Referenced by sqlite3Update().

◆ sqlite3WindowAlloc()

SQLITE_PRIVATE Window * sqlite3WindowAlloc	(	Parse *	pParse,
		int	eType,
		int	eStart,
		Expr *	pStart,
		int	eEnd,
		Expr *	pEnd,
		u8	eExclude )

Definition at line 152309 of file sqlite3.c.

 {
  Window *pWin = 0;
  int bImplicitFrame = 0;
 
  /* Parser assures the following: */
  assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS );
  assert( eStart==TK_CURRENT || eStart==TK_PRECEDING
           || eStart==TK_UNBOUNDED || eStart==TK_FOLLOWING );
  assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING
           || eEnd==TK_UNBOUNDED || eEnd==TK_PRECEDING );
  assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) );
  assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) );
 
  if( eType==0 ){
    bImplicitFrame = 1;
    eType = TK_RANGE;
  }
 
  /* Additionally, the
  ** starting boundary type may not occur earlier in the following list than
  ** the ending boundary type:
  **
  **   UNBOUNDED PRECEDING
  **   <expr> PRECEDING
  **   CURRENT ROW
  **   <expr> FOLLOWING
  **   UNBOUNDED FOLLOWING
  **
  ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending
  ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting
  ** frame boundary.
  */
  if( (eStart==TK_CURRENT && eEnd==TK_PRECEDING)
   || (eStart==TK_FOLLOWING && (eEnd==TK_PRECEDING || eEnd==TK_CURRENT))
  ){
    sqlite3ErrorMsg(pParse, "unsupported frame specification");
    goto windowAllocErr;
  }
 
  pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( pWin==0 ) goto windowAllocErr;
  pWin->eFrmType = eType;
  pWin->eStart = eStart;
  pWin->eEnd = eEnd;
  if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){
    eExclude = TK_NO;
  }
  pWin->eExclude = eExclude;
  pWin->bImplicitFrame = bImplicitFrame;
  pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd);
  pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart);
  return pWin;

Referenced by yy_reduce().

◆ sqlite3WindowAssemble()

SQLITE_PRIVATE Window * sqlite3WindowAssemble	(	Parse *	pParse,
		Window *	pWin,
		ExprList *	pPartition,
		ExprList *	pOrderBy,
		Token *	pBase )

Definition at line 152381 of file sqlite3.c.

 {
  if( pWin ){
    pWin->pPartition = pPartition;
    pWin->pOrderBy = pOrderBy;
    if( pBase ){
      pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
    }

References Parse::db, Token::n, Window::pOrderBy, Window::pPartition, WindowRewrite::pWin, sqlite3DbStrNDup(), sqlite3ExprListDelete(), Token::z, and Window::zBase.

Referenced by yy_reduce().

◆ sqlite3WindowAttach()

SQLITE_PRIVATE void sqlite3WindowAttach	(	Parse *	pParse,
		Expr *	p,
		Window *	pWin )

Definition at line 152442 of file sqlite3.c.

                                                                             {
  if( p ){
    assert( p->op==TK_FUNCTION );
    assert( pWin );
    p->y.pWin = pWin;
    ExprSetProperty(p, EP_WinFunc);
    pWin->pOwner = p;
    if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){
      sqlite3ErrorMsg(pParse,
          "DISTINCT is not supported for window functions"

Referenced by yy_reduce().

◆ sqlite3WindowChain()

SQLITE_PRIVATE void sqlite3WindowChain	(	Parse *	pParse,
		Window *	pWin,
		Window *	pList )

Definition at line 152408 of file sqlite3.c.

                                                                                  {
  if( pWin->zBase ){
    sqlite3 *db = pParse->db;
    Window *pExist = windowFind(pParse, pList, pWin->zBase);
    if( pExist ){
      const char *zErr = 0;
      /* Check for errors */
      if( pWin->pPartition ){
        zErr = "PARTITION clause";
      }else if( pExist->pOrderBy && pWin->pOrderBy ){
        zErr = "ORDER BY clause";
      }else if( pExist->bImplicitFrame==0 ){
        zErr = "frame specification";
      }
      if( zErr ){
        sqlite3ErrorMsg(pParse,
            "cannot override %s of window: %s", zErr, pWin->zBase
        );
      }else{
        pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0);
        if( pExist->pOrderBy ){
          assert( pWin->pOrderBy==0 );
          pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0);
        }

References Window::bImplicitFrame, Parse::db, Window::pOrderBy, Window::pPartition, WindowRewrite::pWin, sqlite3DbFree(), sqlite3ErrorMsg(), sqlite3ExprListDup(), windowFind(), and Window::zBase.

Referenced by sqlite3WindowUpdate(), and yy_reduce().

◆ sqlite3WindowCodeInit()

SQLITE_PRIVATE void sqlite3WindowCodeInit	(	Parse *	pParse,
		Select *	pSelect )

Definition at line 152512 of file sqlite3.c.

                                                                         {
  int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr;
  Window *pMWin = pSelect->pWin;
  Window *pWin;
  Vdbe *v = sqlite3GetVdbe(pParse);
 
  sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
  sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
  sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr);
  sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr);
 
  /* Allocate registers to use for PARTITION BY values, if any. Initialize
  ** said registers to NULL.  */
  if( pMWin->pPartition ){
    int nExpr = pMWin->pPartition->nExpr;
    pMWin->regPart = pParse->nMem+1;
    pParse->nMem += nExpr;
    sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1);
  }
 
  pMWin->regOne = ++pParse->nMem;
  sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne);
 
  if( pMWin->eExclude ){
    pMWin->regStartRowid = ++pParse->nMem;
    pMWin->regEndRowid = ++pParse->nMem;
    pMWin->csrApp = pParse->nTab++;
    sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
    sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
    sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr);
    return;
  }
 
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *p = pWin->pFunc;
    if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){
      /* The inline versions of min() and max() require a single ephemeral
      ** table and 3 registers. The registers are used as follows:
      **
      **   regApp+0: slot to copy min()/max() argument to for MakeRecord
      **   regApp+1: integer value used to ensure keys are unique
      **   regApp+2: output of MakeRecord
      */
      ExprList *pList = pWin->pOwner->x.pList;
      KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
      pWin->csrApp = pParse->nTab++;
      pWin->regApp = pParse->nMem+1;
      pParse->nMem += 3;
      if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){
        assert( pKeyInfo->aSortFlags[0]==0 );
        pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC;
      }
      sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2);
      sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
    }
    else if( p->zName==nth_valueName || p->zName==first_valueName ){
      /* Allocate two registers at pWin->regApp. These will be used to
      ** store the start and end index of the current frame.  */
      pWin->regApp = pParse->nMem+1;
      pWin->csrApp = pParse->nTab++;
      pParse->nMem += 2;
      sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
    }

References SrcList::a, KeyInfo::aSortFlags, Window::csrApp, Window::eExclude, Window::eStart, first_valueName, FuncDef::funcFlags, Window::iEphCsr, KEYINFO_ORDER_DESC, lagName, leadName, ExprList::nExpr, Parse::nMem, Parse::nTab, nth_valueName, OP_Integer, OP_Null, OP_OpenDup, OP_OpenEphemeral, P4_KEYINFO, Select::pEList, Window::pFunc, Expr::pList, Window::pNextWin, Window::pOwner, Window::pPartition, SrcList::SrcList_item::pSelect, Select::pSrc, Select::pWin, WindowRewrite::pWin, Window::regApp, Window::regEndRowid, Window::regOne, Window::regPart, Window::regStartRowid, sqlite3GetVdbe(), sqlite3KeyInfoFromExprList(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAppendP4(), SQLITE_FUNC_MINMAX, TK_UNBOUNDED, Expr::x, and FuncDef::zName.

Referenced by sqlite3Select().

◆ sqlite3WindowCodeStep()

SQLITE_PRIVATE void sqlite3WindowCodeStep	(	Parse *	pParse,
		Select *	p,
		WhereInfo *	pWInfo,
		int	regGosub,
		int	addrGosub )

Definition at line 153875 of file sqlite3.c.

 {
  Window *pMWin = p->pWin;
  ExprList *pOrderBy = pMWin->pOrderBy;
  Vdbe *v = sqlite3GetVdbe(pParse);
  int csrWrite;                   /* Cursor used to write to eph. table */
  int csrInput = p->pSrc->a[0].iCursor;     /* Cursor of sub-select */
  int nInput = p->pSrc->a[0].pTab->nCol;    /* Number of cols returned by sub */
  int iInput;                               /* To iterate through sub cols */
  int addrNe;                     /* Address of OP_Ne */
  int addrGosubFlush = 0;         /* Address of OP_Gosub to flush: */
  int addrInteger = 0;            /* Address of OP_Integer */
  int addrEmpty;                  /* Address of OP_Rewind in flush: */
  int regNew;                     /* Array of registers holding new input row */
  int regRecord;                  /* regNew array in record form */
  int regRowid;                   /* Rowid for regRecord in eph table */
  int regNewPeer = 0;             /* Peer values for new row (part of regNew) */
  int regPeer = 0;                /* Peer values for current row */
  int regFlushPart = 0;           /* Register for "Gosub flush_partition" */
  WindowCodeArg s;                /* Context object for sub-routines */
  int lblWhereEnd;                /* Label just before sqlite3WhereEnd() code */
  int regStart = 0;               /* Value of <expr> PRECEDING */
  int regEnd = 0;                 /* Value of <expr> FOLLOWING */
 
  assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT
       || pMWin->eStart==TK_FOLLOWING || pMWin->eStart==TK_UNBOUNDED
  );
  assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT
       || pMWin->eEnd==TK_UNBOUNDED || pMWin->eEnd==TK_PRECEDING
  );
  assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT
       || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES
       || pMWin->eExclude==TK_NO
  );
 
  lblWhereEnd = sqlite3VdbeMakeLabel(pParse);
 
  /* Fill in the context object */
  memset(&s, 0, sizeof(WindowCodeArg));
  s.pParse = pParse;
  s.pMWin = pMWin;
  s.pVdbe = v;
  s.regGosub = regGosub;
  s.addrGosub = addrGosub;
  s.current.csr = pMWin->iEphCsr;
  csrWrite = s.current.csr+1;
  s.start.csr = s.current.csr+2;
  s.end.csr = s.current.csr+3;
 
  /* Figure out when rows may be deleted from the ephemeral table. There
  ** are four options - they may never be deleted (eDelete==0), they may
  ** be deleted as soon as they are no longer part of the window frame
  ** (eDelete==WINDOW_AGGINVERSE), they may be deleted as after the row
  ** has been returned to the caller (WINDOW_RETURN_ROW), or they may
  ** be deleted after they enter the frame (WINDOW_AGGSTEP). */
  switch( pMWin->eStart ){
    case TK_FOLLOWING:
      if( pMWin->eFrmType!=TK_RANGE
       && windowExprGtZero(pParse, pMWin->pStart)
      ){
        s.eDelete = WINDOW_RETURN_ROW;
      }
      break;
    case TK_UNBOUNDED:
      if( windowCacheFrame(pMWin)==0 ){
        if( pMWin->eEnd==TK_PRECEDING ){
          if( pMWin->eFrmType!=TK_RANGE
           && windowExprGtZero(pParse, pMWin->pEnd)
          ){
            s.eDelete = WINDOW_AGGSTEP;
          }
        }else{
          s.eDelete = WINDOW_RETURN_ROW;
        }
      }
      break;
    default:
      s.eDelete = WINDOW_AGGINVERSE;
      break;
  }
 
  /* Allocate registers for the array of values from the sub-query, the
  ** samve values in record form, and the rowid used to insert said record
  ** into the ephemeral table.  */
  regNew = pParse->nMem+1;
  pParse->nMem += nInput;
  regRecord = ++pParse->nMem;
  regRowid = ++pParse->nMem;
 
  /* If the window frame contains an "<expr> PRECEDING" or "<expr> FOLLOWING"
  ** clause, allocate registers to store the results of evaluating each
  ** <expr>.  */
  if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){
    regStart = ++pParse->nMem;
  }
  if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){
    regEnd = ++pParse->nMem;
  }
 
  /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of
  ** registers to store copies of the ORDER BY expressions (peer values)
  ** for the main loop, and for each cursor (start, current and end). */
  if( pMWin->eFrmType!=TK_ROWS ){
    int nPeer = (pOrderBy ? pOrderBy->nExpr : 0);
    regNewPeer = regNew + pMWin->nBufferCol;
    if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr;
    regPeer = pParse->nMem+1;       pParse->nMem += nPeer;
    s.start.reg = pParse->nMem+1;   pParse->nMem += nPeer;
    s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
    s.end.reg = pParse->nMem+1;     pParse->nMem += nPeer;
  }
 
  /* Load the column values for the row returned by the sub-select
  ** into an array of registers starting at regNew. Assemble them into
  ** a record in register regRecord. */
  for(iInput=0; iInput<nInput; iInput++){
    sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
  }
  sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);
 
  /* An input row has just been read into an array of registers starting
  ** at regNew. If the window has a PARTITION clause, this block generates
  ** VM code to check if the input row is the start of a new partition.
  ** If so, it does an OP_Gosub to an address to be filled in later. The
  ** address of the OP_Gosub is stored in local variable addrGosubFlush. */
  if( pMWin->pPartition ){
    int addr;
    ExprList *pPart = pMWin->pPartition;
    int nPart = pPart->nExpr;
    int regNewPart = regNew + pMWin->nBufferCol;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);
 
    regFlushPart = ++pParse->nMem;
    addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
    VdbeCoverageEqNe(v);
    addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
    VdbeComment((v, "call flush_partition"));
    sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
  }
 
  /* Insert the new row into the ephemeral table */
  sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid);
  sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid);
  addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, regRowid);
  VdbeCoverageNeverNull(v);
 
  /* This block is run for the first row of each partition */
  s.regArg = windowInitAccum(pParse, pMWin);
 
  if( regStart ){
    sqlite3ExprCode(pParse, pMWin->pStart, regStart);
    windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0));
  }
  if( regEnd ){
    sqlite3ExprCode(pParse, pMWin->pEnd, regEnd);
    windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0));
  }
 
  if( pMWin->eFrmType!=TK_RANGE && pMWin->eStart==pMWin->eEnd && regStart ){
    int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le);
    int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
    VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */
    VdbeCoverageNeverNullIf(v, op==OP_Le); /*   values previously checked */
    windowAggFinal(&s, 0);
    sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
    VdbeCoverageNeverTaken(v);
    windowReturnOneRow(&s);
    sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
    sqlite3VdbeJumpHere(v, addrGe);
  }
  if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){
    assert( pMWin->eEnd==TK_FOLLOWING );
    sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
  }
 
  if( pMWin->eStart!=TK_UNBOUNDED ){
    sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1);
    VdbeCoverageNeverTaken(v);
  }
  sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
  VdbeCoverageNeverTaken(v);
  sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1);
  VdbeCoverageNeverTaken(v);
  if( regPeer && pOrderBy ){
    sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1);
  }
 
  sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
 
  sqlite3VdbeJumpHere(v, addrNe);
 
  /* Beginning of the block executed for the second and subsequent rows. */
  if( regPeer ){
    windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd);
  }
  if( pMWin->eStart==TK_FOLLOWING ){
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eEnd!=TK_UNBOUNDED ){
      if( pMWin->eFrmType==TK_RANGE ){
        int lbl = sqlite3VdbeMakeLabel(pParse);
        int addrNext = sqlite3VdbeCurrentAddr(v);
        windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
        sqlite3VdbeResolveLabel(v, lbl);
      }else{
        windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
      }
    }
  }else
  if( pMWin->eEnd==TK_PRECEDING ){
    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
    if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
  }else{
    int addr = 0;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eEnd!=TK_UNBOUNDED ){
      if( pMWin->eFrmType==TK_RANGE ){
        int lbl = 0;
        addr = sqlite3VdbeCurrentAddr(v);
        if( regEnd ){
          lbl = sqlite3VdbeMakeLabel(pParse);
          windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
        }
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        if( regEnd ){
          sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
          sqlite3VdbeResolveLabel(v, lbl);
        }
      }else{
        if( regEnd ){
          addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
          VdbeCoverage(v);
        }
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        if( regEnd ) sqlite3VdbeJumpHere(v, addr);
      }
    }
  }
 
  /* End of the main input loop */
  sqlite3VdbeResolveLabel(v, lblWhereEnd);
  sqlite3WhereEnd(pWInfo);
 
  /* Fall through */
  if( pMWin->pPartition ){
    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
    sqlite3VdbeJumpHere(v, addrGosubFlush);
  }
 
  addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
  VdbeCoverage(v);
  if( pMWin->eEnd==TK_PRECEDING ){
    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
  }else if( pMWin->eStart==TK_FOLLOWING ){
    int addrStart;
    int addrBreak1;
    int addrBreak2;
    int addrBreak3;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eFrmType==TK_RANGE ){
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    }else
    if( pMWin->eEnd==TK_UNBOUNDED ){
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1);
    }else{
      assert( pMWin->eEnd==TK_FOLLOWING );
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
    }
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak2);
    addrStart = sqlite3VdbeCurrentAddr(v);
    addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak1);
    sqlite3VdbeJumpHere(v, addrBreak3);
  }else{
    int addrBreak;
    int addrStart;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    addrStart = sqlite3VdbeCurrentAddr(v);
    addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak);
  }
  sqlite3VdbeJumpHere(v, addrEmpty);
 
  sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
  if( pMWin->pPartition ){
    if( pMWin->regStartRowid ){
      sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);

References SrcList::a, Window::eEnd, Window::eExclude, Window::eFrmType, Window::eStart, SrcList::SrcList_item::iCursor, Window::iEphCsr, Window::nBufferCol, Table::nCol, ExprList::nExpr, Parse::nMem, OP_Column, OP_Compare, OP_Copy, OP_Ge, OP_Gosub, OP_Goto, OP_IfPos, OP_Insert, OP_Integer, OP_Jump, OP_Le, OP_MakeRecord, OP_Ne, OP_NewRowid, OP_ResetSorter, OP_Return, OP_Rewind, OP_Subtract, P4_KEYINFO, Window::pEnd, Window::pOrderBy, Window::pPartition, Select::pSrc, Window::pStart, SrcList::SrcList_item::pTab, Select::pWin, Window::regEndRowid, Window::regOne, Window::regPart, Window::regStartRowid, s, sqlite3ExprCode(), sqlite3GetVdbe(), sqlite3KeyInfoFromExprList(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP1(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), sqlite3WhereEnd(), TK_CURRENT, TK_FOLLOWING, TK_GROUP, TK_NO, TK_PRECEDING, TK_RANGE, TK_ROWS, TK_TIES, TK_UNBOUNDED, VdbeComment, VdbeCoverage, VdbeCoverageEqNe, VdbeCoverageNeverNull, VdbeCoverageNeverNullIf, VdbeCoverageNeverTaken, WINDOW_AGGINVERSE, WINDOW_AGGSTEP, WINDOW_RETURN_ROW, windowAggFinal(), windowCacheFrame(), windowCheckValue(), windowCodeOp(), windowCodeRangeTest(), windowExprGtZero(), windowIfNewPeer(), windowInitAccum(), and windowReturnOneRow().

Referenced by sqlite3Select().

◆ sqlite3WindowCompare()

SQLITE_PRIVATE int sqlite3WindowCompare	(	Parse *	pParse,
		Window *	p1,
		Window *	p2,
		int	bFilter )

Definition at line 152483 of file sqlite3.c.

                                                                                           {
  int res;
  if( NEVER(p1==0) || NEVER(p2==0) ) return 1;
  if( p1->eFrmType!=p2->eFrmType ) return 1;
  if( p1->eStart!=p2->eStart ) return 1;
  if( p1->eEnd!=p2->eEnd ) return 1;
  if( p1->eExclude!=p2->eExclude ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
  if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){
    return res;
  }
  if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){
    return res;
  }
  if( bFilter ){

References Window::eEnd, Window::eExclude, Window::eFrmType, Window::eStart, NEVER, Window::pEnd, Window::pFilter, Window::pOrderBy, Window::pPartition, Window::pStart, sqlite3ExprCompare(), and sqlite3ExprListCompare().

Referenced by sqlite3ExprCompare(), sqlite3WindowLink(), and windowAggStep().

◆ sqlite3WindowDelete()

SQLITE_PRIVATE void sqlite3WindowDelete	(	sqlite3 *	db,
		Window *	p )

Definition at line 152265 of file sqlite3.c.

                                                               {
  if( p ){
    sqlite3WindowUnlinkFromSelect(p);
    sqlite3ExprDelete(db, p->pFilter);
    sqlite3ExprListDelete(db, p->pPartition);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pEnd);

Referenced by yy_destructor().

◆ sqlite3WindowDup()

SQLITE_PRIVATE Window * sqlite3WindowDup	(	sqlite3 *	db,
		Expr *	pOwner,
		Window *	p )

Definition at line 153473 of file sqlite3.c.

                                                                             {
  Window *pNew = 0;
  if( ALWAYS(p) ){
    pNew = sqlite3DbMallocZero(db, sizeof(Window));
    if( pNew ){
      pNew->zName = sqlite3DbStrDup(db, p->zName);
      pNew->zBase = sqlite3DbStrDup(db, p->zBase);
      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
      pNew->pFunc = p->pFunc;
      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
      pNew->eFrmType = p->eFrmType;
      pNew->eEnd = p->eEnd;
      pNew->eStart = p->eStart;
      pNew->eExclude = p->eExclude;
      pNew->regResult = p->regResult;
      pNew->regAccum = p->regAccum;
      pNew->iArgCol = p->iArgCol;
      pNew->iEphCsr = p->iEphCsr;
      pNew->bExprArgs = p->bExprArgs;
      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);

References ALWAYS, Window::bExprArgs, Window::bImplicitFrame, Window::eEnd, Window::eExclude, Window::eFrmType, Window::eStart, Window::iArgCol, Window::iEphCsr, Window::pEnd, Window::pFilter, Window::pFunc, Window::pOrderBy, Window::pOwner, Window::pPartition, Window::pStart, Window::regAccum, Window::regResult, sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ExprDup(), sqlite3ExprListDup(), Window::zBase, and Window::zName.

Referenced by exprDup().

◆ sqlite3WindowExtraAggFuncDepth()

static int sqlite3WindowExtraAggFuncDepth	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 152088 of file sqlite3.c.

152094 {

152095 if( pExpr->op==TK_AGG_FUNCTION

References Expr::op, Expr::op2, TK_AGG_FUNCTION, Walker::walkerDepth, and WRC_Continue.

Referenced by sqlite3WindowRewrite().

◆ sqlite3WindowFunctions()

SQLITE_PRIVATE void sqlite3WindowFunctions ( void )

Definition at line 151769 of file sqlite3.c.

                                                {
  static FuncDef aWindowFuncs[] = {
    WINDOWFUNCX(row_number, 0, 0),
    WINDOWFUNCX(dense_rank, 0, 0),
    WINDOWFUNCX(rank, 0, 0),
    WINDOWFUNCALL(percent_rank, 0, 0),
    WINDOWFUNCALL(cume_dist, 0, 0),
    WINDOWFUNCALL(ntile, 1, 0),
    WINDOWFUNCALL(last_value, 1, 0),
    WINDOWFUNCALL(nth_value, 2, 0),
    WINDOWFUNCALL(first_value, 1, 0),
    WINDOWFUNCNOOP(lead, 1, 0),
    WINDOWFUNCNOOP(lead, 2, 0),
    WINDOWFUNCNOOP(lead, 3, 0),

References WINDOWFUNCALL, WINDOWFUNCNOOP, and WINDOWFUNCX.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sqlite3WindowLink()

SQLITE_PRIVATE void sqlite3WindowLink	(	Select *	pSel,
		Window *	pWin )

Definition at line 152465 of file sqlite3.c.

                                                                 {
  if( pSel!=0
   && (0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0))
  ){
    pWin->pNextWin = pSel->pWin;
    if( pSel->pWin ){

References Window::pNextWin, Window::ppThis, Select::pWin, WindowRewrite::pWin, and sqlite3WindowCompare().

Referenced by resolveExprStep().

◆ sqlite3WindowListDelete()

SQLITE_PRIVATE void sqlite3WindowListDelete	(	sqlite3 *	db,
		Window *	p )

Definition at line 152282 of file sqlite3.c.

152288 {

Referenced by clearSelect(), yy_destructor(), and yy_reduce().

◆ sqlite3WindowListDup()

SQLITE_PRIVATE Window * sqlite3WindowListDup	(	sqlite3 *	db,
		Window *	p )

Definition at line 153506 of file sqlite3.c.

                                                                   {
  Window *pWin;
  Window *pRet = 0;
  Window **pp = &pRet;
 
  for(pWin=p; pWin; pWin=pWin->pNextWin){
    *pp = sqlite3WindowDup(db, 0, pWin);

◆ sqlite3WindowOffsetExpr()

static Expr * sqlite3WindowOffsetExpr	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 152297 of file sqlite3.c.

152303 {

152304 if( 0==sqlite3ExprIsConstant(pExpr) ){

References Parse::db, IN_RENAME_OBJECT, sqlite3ExprAlloc(), sqlite3ExprDelete(), sqlite3ExprIsConstant(), sqlite3RenameExprUnmap(), and TK_NULL.

◆ sqlite3WindowRewrite()

SQLITE_PRIVATE int sqlite3WindowRewrite	(	Parse *	pParse,
		Select *	p )

Definition at line 152104 of file sqlite3.c.

                                                                 {
  int rc = SQLITE_OK;
  if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){
    Vdbe *v = sqlite3GetVdbe(pParse);
    sqlite3 *db = pParse->db;
    Select *pSub = 0;             /* The subquery */
    SrcList *pSrc = p->pSrc;
    Expr *pWhere = p->pWhere;
    ExprList *pGroupBy = p->pGroupBy;
    Expr *pHaving = p->pHaving;
    ExprList *pSort = 0;
 
    ExprList *pSublist = 0;       /* Expression list for sub-query */
    Window *pMWin = p->pWin;      /* Main window object */
    Window *pWin;                 /* Window object iterator */
    Table *pTab;
    Walker w;
 
    u32 selFlags = p->selFlags;
 
    pTab = sqlite3DbMallocZero(db, sizeof(Table));
    if( pTab==0 ){
      return sqlite3ErrorToParser(db, SQLITE_NOMEM);
    }
    sqlite3AggInfoPersistWalkerInit(&w, pParse);
    sqlite3WalkSelect(&w, p);
 
    p->pSrc = 0;
    p->pWhere = 0;
    p->pGroupBy = 0;
    p->pHaving = 0;
    p->selFlags &= ~SF_Aggregate;
    p->selFlags |= SF_WinRewrite;
 
    /* Create the ORDER BY clause for the sub-select. This is the concatenation
    ** of the window PARTITION and ORDER BY clauses. Then, if this makes it
    ** redundant, remove the ORDER BY from the parent SELECT.  */
    pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1);
    pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1);
    if( pSort && p->pOrderBy && p->pOrderBy->nExpr<=pSort->nExpr ){
      int nSave = pSort->nExpr;
      pSort->nExpr = p->pOrderBy->nExpr;
      if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){
        sqlite3ExprListDelete(db, p->pOrderBy);
        p->pOrderBy = 0;
      }
      pSort->nExpr = nSave;
    }
 
    /* Assign a cursor number for the ephemeral table used to buffer rows.
    ** The OpenEphemeral instruction is coded later, after it is known how
    ** many columns the table will have.  */
    pMWin->iEphCsr = pParse->nTab++;
    pParse->nTab += 3;
 
    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
    pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0);
 
    /* Append the PARTITION BY and ORDER BY expressions to the to the
    ** sub-select expression list. They are required to figure out where
    ** boundaries for partitions and sets of peer rows lie.  */
    pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0);
    pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0);
 
    /* Append the arguments passed to each window function to the
    ** sub-select expression list. Also allocate two registers for each
    ** window function - one for the accumulator, another for interim
    ** results.  */
    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
      ExprList *pArgs = pWin->pOwner->x.pList;
      if( pWin->pFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){
        selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
        pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
        pWin->bExprArgs = 1;
      }else{
        pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
        pSublist = exprListAppendList(pParse, pSublist, pArgs, 0);
      }
      if( pWin->pFilter ){
        Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0);
        pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter);
      }
      pWin->regAccum = ++pParse->nMem;
      pWin->regResult = ++pParse->nMem;
      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
    }
 
    /* If there is no ORDER BY or PARTITION BY clause, and the window
    ** function accepts zero arguments, and there are no other columns
    ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible
    ** that pSublist is still NULL here. Add a constant expression here to
    ** keep everything legal in this case.
    */
    if( pSublist==0 ){
      pSublist = sqlite3ExprListAppend(pParse, 0,
        sqlite3Expr(db, TK_INTEGER, "0")
      );
    }
 
    pSub = sqlite3SelectNew(
        pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0
    );
    SELECTTRACE(1,pParse,pSub,
       ("New window-function subquery in FROM clause of (%u/%p)\n",
       p->selId, p));
    p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
    if( p->pSrc ){
      Table *pTab2;
      p->pSrc->a[0].pSelect = pSub;
      sqlite3SrcListAssignCursors(pParse, p->pSrc);
      pSub->selFlags |= SF_Expanded;
      pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);
      pSub->selFlags |= (selFlags & SF_Aggregate);
      if( pTab2==0 ){
        /* Might actually be some other kind of error, but in that case
        ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get
        ** the correct error message regardless. */
        rc = SQLITE_NOMEM;
      }else{
        memcpy(pTab, pTab2, sizeof(Table));
        pTab->tabFlags |= TF_Ephemeral;
        p->pSrc->a[0].pTab = pTab;
        pTab = pTab2;
        memset(&w, 0, sizeof(w));
        w.xExprCallback = sqlite3WindowExtraAggFuncDepth;
        w.xSelectCallback = sqlite3WalkerDepthIncrease;
        w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
        sqlite3WalkSelect(&w, pSub);
      }
    }else{
      sqlite3SelectDelete(db, pSub);
    }
    if( db->mallocFailed ) rc = SQLITE_NOMEM;
    sqlite3DbFree(db, pTab);
  }
 
  if( rc ){
    if( pParse->nErr==0 ){

References SrcList::a, Window::bExprArgs, Parse::db, exprListAppendList(), FuncDef::funcFlags, Window::iArgCol, Window::iEphCsr, sqlite3::mallocFailed, Window::nBufferCol, Parse::nErr, ExprList::nExpr, Parse::nMem, Parse::nTab, OP_Null, Select::pEList, Window::pFilter, Window::pFunc, Select::pGroupBy, Select::pHaving, Expr::pList, Window::pNextWin, Select::pOrderBy, Window::pOrderBy, Window::pOwner, Window::pPartition, Select::pPrior, SrcList::SrcList_item::pSelect, Select::pSrc, WindowRewrite::pSrc, WindowRewrite::pSub, SrcList::SrcList_item::pTab, WindowRewrite::pTab, Select::pWhere, Select::pWin, WindowRewrite::pWin, Window::regAccum, Window::regResult, SELECTTRACE, selectWindowRewriteEList(), Select::selFlags, Select::selId, SF_Aggregate, SF_Expanded, SF_WinRewrite, sqlite3AggInfoPersistWalkerInit(), sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3ErrorToParser(), sqlite3Expr(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListCompare(), sqlite3ExprListDelete(), sqlite3GetVdbe(), sqlite3ResultSetOfSelect(), sqlite3SelectDelete(), sqlite3SelectNew(), sqlite3SrcListAppend(), sqlite3SrcListAssignCursors(), sqlite3VdbeAddOp2(), sqlite3WalkerDepthDecrease(), sqlite3WalkerDepthIncrease(), sqlite3WalkSelect(), sqlite3WindowExtraAggFuncDepth(), SQLITE_AFF_NONE, SQLITE_FUNC_SUBTYPE, SQLITE_NOMEM, SQLITE_OK, Table::tabFlags, TF_Ephemeral, TK_INTEGER, Expr::x, Walker::xExprCallback, Walker::xSelectCallback, and Walker::xSelectCallback2.

Referenced by sqlite3Select().

◆ sqlite3WindowUnlinkFromSelect()

SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect ( Window * p )

Definition at line 152254 of file sqlite3.c.

152260 {

◆ sqlite3WindowUpdate()

SQLITE_PRIVATE void sqlite3WindowUpdate	(	Parse *	pParse,
		Window *	pList,
		Window *	pWin,
		FuncDef *	pFunc )

Definition at line 151818 of file sqlite3.c.

 {
  if( pWin->zName && pWin->eFrmType==0 ){
    Window *p = windowFind(pParse, pList, pWin->zName);
    if( p==0 ) return;
    pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0);
    pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0);
    pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0);
    pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0);
    pWin->eStart = p->eStart;
    pWin->eEnd = p->eEnd;
    pWin->eFrmType = p->eFrmType;
    pWin->eExclude = p->eExclude;
  }else{
    sqlite3WindowChain(pParse, pWin, pList);
  }
  if( (pWin->eFrmType==TK_RANGE)
   && (pWin->pStart || pWin->pEnd)
   && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1)
  ){
    sqlite3ErrorMsg(pParse,
      "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression"
    );
  }else
  if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){
    sqlite3 *db = pParse->db;
    if( pWin->pFilter ){
      sqlite3ErrorMsg(pParse,
          "FILTER clause may only be used with aggregate window functions"
      );
    }else{
      struct WindowUpdate {
        const char *zFunc;
        int eFrmType;
        int eStart;
        int eEnd;
      } aUp[] = {
        { row_numberName,   TK_ROWS,   TK_UNBOUNDED, TK_CURRENT },
        { dense_rankName,   TK_RANGE,  TK_UNBOUNDED, TK_CURRENT },
        { rankName,         TK_RANGE,  TK_UNBOUNDED, TK_CURRENT },
        { percent_rankName, TK_GROUPS, TK_CURRENT,   TK_UNBOUNDED },
        { cume_distName,    TK_GROUPS, TK_FOLLOWING, TK_UNBOUNDED },
        { ntileName,        TK_ROWS,   TK_CURRENT,   TK_UNBOUNDED },
        { leadName,         TK_ROWS,   TK_UNBOUNDED, TK_UNBOUNDED },
        { lagName,          TK_ROWS,   TK_UNBOUNDED, TK_CURRENT },
      };
      int i;
      for(i=0; i<ArraySize(aUp); i++){
        if( pFunc->zName==aUp[i].zFunc ){
          sqlite3ExprDelete(db, pWin->pStart);
          sqlite3ExprDelete(db, pWin->pEnd);
          pWin->pEnd = pWin->pStart = 0;
          pWin->eFrmType = aUp[i].eFrmType;
          pWin->eStart = aUp[i].eStart;
          pWin->eEnd = aUp[i].eEnd;
          pWin->eExclude = 0;
          if( pWin->eStart==TK_FOLLOWING ){
            pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1");
          }
          break;

References ArraySize, cume_distName, Parse::db, dense_rankName, Window::eEnd, Window::eExclude, Window::eFrmType, Window::eStart, FuncDef::funcFlags, lagName, leadName, ExprList::nExpr, ntileName, Window::pEnd, percent_rankName, Window::pFilter, Window::pFunc, Window::pOrderBy, Window::pPartition, Window::pStart, rankName, row_numberName, sqlite3ErrorMsg(), sqlite3Expr(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprListDup(), sqlite3WindowChain(), SQLITE_FUNC_WINDOW, TK_CURRENT, TK_FOLLOWING, TK_GROUPS, TK_INTEGER, TK_RANGE, TK_ROWS, TK_UNBOUNDED, windowFind(), FuncDef::zName, and Window::zName.

Referenced by resolveExprStep().

◆ sqlite3WithAdd()

SQLITE_PRIVATE With * sqlite3WithAdd	(	Parse *	pParse,
		With *	pWith,
		Token *	pName,
		ExprList *	pArglist,
		Select *	pQuery )

Definition at line 115471 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  With *pNew;
  char *zName;
 
  /* Check that the CTE name is unique within this WITH clause. If
  ** not, store an error in the Parse structure. */
  zName = sqlite3NameFromToken(pParse->db, pName);
  if( zName && pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
        sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
      }
    }
  }
 
  if( pWith ){
    sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
    pNew = sqlite3DbRealloc(db, pWith, nByte);
  }else{
    pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
  }
  assert( (pNew!=0 && zName!=0) || db->mallocFailed );
 
  if( db->mallocFailed ){
    sqlite3ExprListDelete(db, pArglist);
    sqlite3SelectDelete(db, pQuery);
    sqlite3DbFree(db, zName);
    pNew = pWith;
  }else{
    pNew->a[pNew->nCte].pSelect = pQuery;
    pNew->a[pNew->nCte].pCols = pArglist;
    pNew->a[pNew->nCte].zName = zName;

References With::a, Parse::db, sqlite3::mallocFailed, With::nCte, With::Cte::pCols, With::Cte::pSelect, sqlite3DbFree(), sqlite3DbMallocZero(), sqlite3DbRealloc(), sqlite3ErrorMsg(), sqlite3ExprListDelete(), sqlite3NameFromToken(), sqlite3SelectDelete(), sqlite3StrICmp(), With::Cte::zCteErr, With::Cte::zName, and zName.

Referenced by yy_reduce().

◆ sqlite3WithDelete()

SQLITE_PRIVATE void sqlite3WithDelete	(	sqlite3 *	db,
		With *	pWith )

Definition at line 115521 of file sqlite3.c.

                                                               {
  if( pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      struct Cte *pCte = &pWith->a[i];
      sqlite3ExprListDelete(db, pCte->pCols);

Referenced by clearSelect(), sqlite3RunParser(), yy_destructor(), and yy_reduce().

◆ sqlite3WithPush()

SQLITE_PRIVATE void sqlite3WithPush	(	Parse *	pParse,
		With *	pWith,
		u8	bFree )

Definition at line 134046 of file sqlite3.c.

                                                                         {
  assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) );
  if( pWith ){

References With::pOuter, Parse::pWith, and Parse::pWithToFree.

Referenced by selectExpander(), and yy_reduce().

◆ sqlite3WritableSchema()

SQLITE_PRIVATE int sqlite3WritableSchema ( sqlite3 * db )

Definition at line 111250 of file sqlite3.c.

                                                     {
  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
               SQLITE_WriteSchema );

Referenced by lockBtree(), sqlite3CheckObjectName(), and tabIsReadOnly().

◆ sqliteAuthBadReturnCode()

static void sqliteAuthBadReturnCode ( Parse * pParse )

static

Definition at line 110202 of file sqlite3.c.

Referenced by sqlite3AuthCheck(), and sqlite3AuthReadCol().

◆ sqliteDefaultBusyCallback()

static int sqliteDefaultBusyCallback	(	void *	ptr,
		int	count )

static

Definition at line 162609 of file sqlite3.c.

 {
#if SQLITE_OS_WIN || HAVE_USLEEP
  /* This case is for systems that have support for sleeping for fractions of
  ** a second.  Examples:  All windows systems, unix systems with usleep() */
  static const u8 delays[] =
     { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
  static const u8 totals[] =
     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
# define NDELAY ArraySize(delays)
  sqlite3 *db = (sqlite3 *)ptr;
  int tmout = db->busyTimeout;
  int delay, prior;
 
  assert( count>=0 );
  if( count < NDELAY ){
    delay = delays[count];
    prior = totals[count];
  }else{
    delay = delays[NDELAY-1];
    prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
  }
  if( prior + delay > tmout ){
    delay = tmout - prior;
    if( delay<=0 ) return 0;
  }
  sqlite3OsSleep(db->pVfs, delay*1000);
  return 1;
#else
  /* This case for unix systems that lack usleep() support.  Sleeping
  ** must be done in increments of whole seconds */
  sqlite3 *db = (sqlite3 *)ptr;
  int tmout = ((sqlite3 *)ptr)->busyTimeout;
  if( (count+1)*1000 > tmout ){

References sqlite3::busyTimeout, sqlite3::pVfs, and sqlite3OsSleep().

Referenced by sqlite3_busy_timeout().

◆ sqliteErrorFromPosixError()

static int sqliteErrorFromPosixError	(	int	posixError,
		int	sqliteIOErr )

static

Definition at line 34404 of file sqlite3.c.

                                                                      {
  assert( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
          (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
          (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
          (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) );
  switch (posixError) {
  case EACCES:
  case EAGAIN:
  case ETIMEDOUT:
  case EBUSY:
  case EINTR:
  case ENOLCK:
    /* random NFS retry error, unless during file system support
     * introspection, in which it actually means what it says */
    return SQLITE_BUSY;
 
  case EPERM:

References SQLITE_BUSY, SQLITE_IOERR_CHECKRESERVEDLOCK, SQLITE_IOERR_LOCK, SQLITE_IOERR_RDLOCK, SQLITE_IOERR_UNLOCK, and SQLITE_PERM.

Referenced by dotlockLock(), posixUnlock(), and unixLock().

◆ sqliteProcessJoin()

static int sqliteProcessJoin	(	Parse *	pParse,
		Select *	p )

static

Definition at line 129728 of file sqlite3.c.

                                                      {
  SrcList *pSrc;                  /* All tables in the FROM clause */
  int i, j;                       /* Loop counters */
  struct SrcList_item *pLeft;     /* Left table being joined */
  struct SrcList_item *pRight;    /* Right table being joined */
 
  pSrc = p->pSrc;
  pLeft = &pSrc->a[0];
  pRight = &pLeft[1];
  for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
    Table *pRightTab = pRight->pTab;
    int isOuter;
 
    if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
    isOuter = (pRight->fg.jointype & JT_OUTER)!=0;
 
    /* When the NATURAL keyword is present, add WHERE clause terms for
    ** every column that the two tables have in common.
    */
    if( pRight->fg.jointype & JT_NATURAL ){
      if( pRight->pOn || pRight->pUsing ){
        sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
           "an ON or USING clause", 0);
        return 1;
      }
      for(j=0; j<pRightTab->nCol; j++){
        char *zName;   /* Name of column in the right table */
        int iLeft;     /* Matching left table */
        int iLeftCol;  /* Matching column in the left table */
 
        if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue;
        zName = pRightTab->aCol[j].zName;
        if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
          addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
                isOuter, &p->pWhere);
        }
      }
    }
 
    /* Disallow both ON and USING clauses in the same join
    */
    if( pRight->pOn && pRight->pUsing ){
      sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
        "clauses in the same join");
      return 1;
    }
 
    /* Add the ON clause to the end of the WHERE clause, connected by
    ** an AND operator.
    */
    if( pRight->pOn ){
      if( isOuter ) sqlite3SetJoinExpr(pRight->pOn, pRight->iCursor);
      p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn);
      pRight->pOn = 0;
    }
 
    /* Create extra terms on the WHERE clause for each column named
    ** in the USING clause.  Example: If the two tables to be joined are
    ** A and B and the USING clause names X, Y, and Z, then add this
    ** to the WHERE clause:    A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
    ** Report an error if any column mentioned in the USING clause is
    ** not contained in both tables to be joined.
    */
    if( pRight->pUsing ){
      IdList *pList = pRight->pUsing;
      for(j=0; j<pList->nId; j++){
        char *zName;     /* Name of the term in the USING clause */
        int iLeft;       /* Table on the left with matching column name */
        int iLeftCol;    /* Column number of matching column on the left */
        int iRightCol;   /* Column number of matching column on the right */
 
        zName = pList->a[j].zName;
        iRightCol = columnIndex(pRightTab, zName);
        if( iRightCol<0
         || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
        ){
          sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
            "not present in both tables", zName);
          return 1;
        }
        addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,

References IdList::a, SrcList::a, Table::aCol, addWhereTerm(), columnIndex(), IsHiddenColumn, JT_NATURAL, JT_OUTER, Table::nCol, NEVER, IdList::nId, SrcList::nSrc, Select::pSrc, Select::pWhere, sqlite3ErrorMsg(), sqlite3ExprAnd(), sqlite3SetJoinExpr(), tableAndColumnIndex(), Column::zName, IdList::IdList_item::zName, and zName.

Referenced by selectExpander().

◆ sqliteVdbePopStack()

void sqliteVdbePopStack	(	Vdbe *	,
		int	)

◆ sqliteViewResetAll()

static void sqliteViewResetAll	(	sqlite3 *	db,
		int	idx )

static

Definition at line 113162 of file sqlite3.c.

                                                    {
  HashElem *i;
  assert( sqlite3SchemaMutexHeld(db, idx, 0) );
  if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
  for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
    Table *pTab = sqliteHashData(i);
    if( pTab->pSelect ){
      sqlite3DeleteColumnNames(db, pTab);

References Table::aCol, sqlite3::aDb, DB_UnresetViews, DbClearProperty, DbHasProperty, Table::nCol, Db::pSchema, Table::pSelect, sqlite3DeleteColumnNames(), sqliteHashData, sqliteHashFirst, sqliteHashNext, and Schema::tblHash.

◆ sqliteViewTriggers()

void sqliteViewTriggers	(	Parse *	,
		Table *	,
		Expr *	,
		int	,
		ExprList *	)

◆ statAccumDestructor()

static void statAccumDestructor ( void * pOld )

static

Definition at line 107908 of file sqlite3.c.

                                           {
  StatAccum *p = (StatAccum*)pOld;
#ifdef SQLITE_ENABLE_STAT4
  if( p->mxSample ){
    int i;
    for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);

◆ statGet()

static void statGet	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 108357 of file sqlite3.c.

 {
  StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]);
#ifdef SQLITE_ENABLE_STAT4
  /* STAT4 has a parameter on this routine. */
  int eCall = sqlite3_value_int(argv[1]);
  assert( argc==2 );
  assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ
       || eCall==STAT_GET_ROWID || eCall==STAT_GET_NLT
       || eCall==STAT_GET_NDLT
  );
  assert( eCall==STAT_GET_STAT1 || p->mxSample );
  if( eCall==STAT_GET_STAT1 )
#else
  assert( argc==1 );
#endif
  {
    /* Return the value to store in the "stat" column of the sqlite_stat1
    ** table for this index.
    **
    ** The value is a string composed of a list of integers describing
    ** the index. The first integer in the list is the total number of
    ** entries in the index. There is one additional integer in the list
    ** for each indexed column. This additional integer is an estimate of
    ** the number of rows matched by a equality query on the index using
    ** a key with the corresponding number of fields. In other words,
    ** if the index is on columns (a,b) and the sqlite_stat1 value is
    ** "100 10 2", then SQLite estimates that:
    **
    **   * the index contains 100 rows,
    **   * "WHERE a=?" matches 10 rows, and
    **   * "WHERE a=? AND b=?" matches 2 rows.
    **
    ** If D is the count of distinct values and K is the total number of
    ** rows, then each estimate is computed as:
    **
    **        I = (K+D-1)/D
    */
    char *z;
    int i;
 
    char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 );
    if( zRet==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
 
    sqlite3_snprintf(24, zRet, "%llu",
        p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow);
    z = zRet + sqlite3Strlen30(zRet);
    for(i=0; i<p->nKeyCol; i++){
      u64 nDistinct = p->current.anDLt[i] + 1;
      u64 iVal = (p->nRow + nDistinct - 1) / nDistinct;
      sqlite3_snprintf(24, z, " %llu", iVal);
      z += sqlite3Strlen30(z);
      assert( p->current.anEq[i] );
    }
    assert( z[0]=='\0' && z>zRet );
 
    sqlite3_result_text(context, zRet, -1, sqlite3_free);
  }
#ifdef SQLITE_ENABLE_STAT4
  else if( eCall==STAT_GET_ROWID ){
    if( p->iGet<0 ){
      samplePushPrevious(p, 0);
      p->iGet = 0;
    }
    if( p->iGet<p->nSample ){
      StatSample *pS = p->a + p->iGet;
      if( pS->nRowid==0 ){
        sqlite3_result_int64(context, pS->u.iRowid);
      }else{
        sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid,
                            SQLITE_TRANSIENT);
      }
    }
  }else{
    tRowcnt *aCnt = 0;
 
    assert( p->iGet<p->nSample );
    switch( eCall ){
      case STAT_GET_NEQ:  aCnt = p->a[p->iGet].anEq; break;
      case STAT_GET_NLT:  aCnt = p->a[p->iGet].anLt; break;
      default: {
        aCnt = p->a[p->iGet].anDLt;
        p->iGet++;
        break;
      }
    }
 
    {
      char *zRet = sqlite3MallocZero(p->nCol * 25);
      if( zRet==0 ){
        sqlite3_result_error_nomem(context);
      }else{
        int i;
        char *z = zRet;
        for(i=0; i<p->nCol; i++){
          sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]);
          z += sqlite3Strlen30(z);
        }
        assert( z[0]=='\0' && z>zRet );
        z[-1] = '\0';
        sqlite3_result_text(context, zRet, -1, sqlite3_free);
      }
    }

References StatSample::anDLt, StatSample::anEq, StatAccum::current, StatAccum::nCol, StatAccum::nEst, StatAccum::nKeyCol, StatAccum::nRow, StatAccum::nSkipAhead, sqlite3_free(), sqlite3_result_blob(), sqlite3_result_error_nomem(), sqlite3_result_int64(), sqlite3_result_text(), sqlite3_snprintf(), sqlite3_value_blob(), sqlite3_value_int(), sqlite3MallocZero(), sqlite3Strlen30(), SQLITE_TRANSIENT, STAT_GET_NDLT, STAT_GET_NEQ, STAT_GET_NLT, STAT_GET_ROWID, and STAT_GET_STAT1.

◆ statInit()

static void statInit	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 107943 of file sqlite3.c.

 {
  StatAccum *p;
  int nCol;                       /* Number of columns in index being sampled */
  int nKeyCol;                    /* Number of key columns */
  int nColUp;                     /* nCol rounded up for alignment */
  int n;                          /* Bytes of space to allocate */
  sqlite3 *db = sqlite3_context_db_handle(context);   /* Database connection */
#ifdef SQLITE_ENABLE_STAT4
  /* Maximum number of samples.  0 if STAT4 data is not collected */
  int mxSample = OptimizationEnabled(db,SQLITE_Stat4) ?SQLITE_STAT4_SAMPLES :0;
#endif
 
  /* Decode the three function arguments */
  UNUSED_PARAMETER(argc);
  nCol = sqlite3_value_int(argv[0]);
  assert( nCol>0 );
  nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
  nKeyCol = sqlite3_value_int(argv[1]);
  assert( nKeyCol<=nCol );
  assert( nKeyCol>0 );
 
  /* Allocate the space required for the StatAccum object */
  n = sizeof(*p)
    + sizeof(tRowcnt)*nColUp                  /* StatAccum.anEq */
    + sizeof(tRowcnt)*nColUp;                 /* StatAccum.anDLt */
#ifdef SQLITE_ENABLE_STAT4
  if( mxSample ){
    n += sizeof(tRowcnt)*nColUp                  /* StatAccum.anLt */
      + sizeof(StatSample)*(nCol+mxSample)       /* StatAccum.aBest[], a[] */
      + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
  }
#endif
  db = sqlite3_context_db_handle(context);
  p = sqlite3DbMallocZero(db, n);
  if( p==0 ){
    sqlite3_result_error_nomem(context);
    return;
  }
 
  p->db = db;
  p->nEst = sqlite3_value_int64(argv[2]);
  p->nRow = 0;
  p->nLimit = sqlite3_value_int64(argv[3]);
  p->nCol = nCol;
  p->nKeyCol = nKeyCol;
  p->nSkipAhead = 0;
  p->current.anDLt = (tRowcnt*)&p[1];
  p->current.anEq = &p->current.anDLt[nColUp];
 
#ifdef SQLITE_ENABLE_STAT4
  p->mxSample = p->nLimit==0 ? mxSample : 0;
  if( mxSample ){
    u8 *pSpace;                     /* Allocated space not yet assigned */
    int i;                          /* Used to iterate through p->aSample[] */
 
    p->iGet = -1;
    p->nPSample = (tRowcnt)(p->nEst/(mxSample/3+1) + 1);
    p->current.anLt = &p->current.anEq[nColUp];
    p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
 
    /* Set up the StatAccum.a[] and aBest[] arrays */
    p->a = (struct StatSample*)&p->current.anLt[nColUp];
    p->aBest = &p->a[mxSample];
    pSpace = (u8*)(&p->a[mxSample+nCol]);
    for(i=0; i<(mxSample+nCol); i++){
      p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
      p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
      p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
    }
    assert( (pSpace - (u8*)p)==n );
 
    for(i=0; i<nCol; i++){
      p->aBest[i].iCol = i;
    }
  }
#endif
 

References StatSample::anDLt, StatSample::anEq, StatAccum::current, StatAccum::db, StatAccum::nCol, StatAccum::nEst, StatAccum::nKeyCol, StatAccum::nLimit, StatAccum::nRow, StatAccum::nSkipAhead, OptimizationEnabled, sqlite3_context_db_handle(), sqlite3_result_error_nomem(), sqlite3_value_int(), sqlite3_value_int64(), sqlite3DbMallocZero(), SQLITE_Stat4, SQLITE_STAT4_SAMPLES, and UNUSED_PARAMETER.

◆ statPush()

static void statPush	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 108245 of file sqlite3.c.

 {
  int i;
 
  /* The three function arguments */
  StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]);
  int iChng = sqlite3_value_int(argv[1]);
 
  UNUSED_PARAMETER( argc );
  UNUSED_PARAMETER( context );
  assert( p->nCol>0 );
  assert( iChng<p->nCol );
 
  if( p->nRow==0 ){
    /* This is the first call to this function. Do initialization. */
    for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
  }else{
    /* Second and subsequent calls get processed here */
#ifdef SQLITE_ENABLE_STAT4
    if( p->mxSample ) samplePushPrevious(p, iChng);
#endif
 
    /* Update anDLt[], anLt[] and anEq[] to reflect the values that apply
    ** to the current row of the index. */
    for(i=0; i<iChng; i++){
      p->current.anEq[i]++;
    }
    for(i=iChng; i<p->nCol; i++){
      p->current.anDLt[i]++;
#ifdef SQLITE_ENABLE_STAT4
      if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i];
#endif
      p->current.anEq[i] = 1;
    }
  }
 
  p->nRow++;
#ifdef SQLITE_ENABLE_STAT4
  if( p->mxSample ){
    tRowcnt nLt;
    if( sqlite3_value_type(argv[2])==SQLITE_INTEGER ){
      sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
    }else{
      sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
                                         sqlite3_value_blob(argv[2]));
    }
    p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
 
    nLt = p->current.anLt[p->nCol-1];
    /* Check if this is to be a periodic sample. If so, add it. */
    if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){
      p->current.isPSample = 1;
      p->current.iCol = 0;
      sampleInsert(p, &p->current, p->nCol-1);
      p->current.isPSample = 0;
    }
 
    /* Update the aBest[] array. */
    for(i=0; i<(p->nCol-1); i++){
      p->current.iCol = i;
      if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){
        sampleCopy(p, &p->aBest[i], &p->current);
      }
    }
  }else

References StatSample::anDLt, StatSample::anEq, StatAccum::current, StatAccum::db, StatAccum::nCol, StatAccum::nRow, sqlite3_value_blob(), sqlite3_value_bytes(), sqlite3_value_int(), sqlite3_value_int64(), sqlite3_value_type(), SQLITE_INTEGER, and UNUSED_PARAMETER.

◆ storeLastErrno()

static void storeLastErrno	(	unixFile *	pFile,
		int	error )

static

Definition at line 34839 of file sqlite3.c.

Referenced by dotlockLock(), dotlockUnlock(), fcntlSizeHint(), findInodeInfo(), posixUnlock(), seekAndRead(), unixCheckReservedLock(), unixLock(), unixOpen(), unixRead(), unixSync(), and unixWrite().

◆ strAccumFinishRealloc()

static SQLITE_NOINLINE char * strAccumFinishRealloc ( StrAccum * p )

static

Definition at line 29150 of file sqlite3.c.

                                                               {
  char *zText;
  assert( p->mxAlloc>0 && !isMalloced(p) );
  zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
  if( zText ){
    memcpy(zText, p->zText, p->nChar+1);
    p->printfFlags |= SQLITE_PRINTF_MALLOCED;

References sqlite3_str::db, isMalloced, sqlite3_str::mxAlloc, sqlite3_str::nChar, sqlite3_str::printfFlags, sqlite3DbMallocRaw(), SQLITE_PRINTF_MALLOCED, and sqlite3_str::zText.

◆ strftimeFunc()

static void strftimeFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 22714 of file sqlite3.c.

 {
  DateTime x;
  u64 n;
  size_t i,j;
  char *z;
  sqlite3 *db;
  const char *zFmt;
  char zBuf[100];
  if( argc==0 ) return;
  zFmt = (const char*)sqlite3_value_text(argv[0]);
  if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
  db = sqlite3_context_db_handle(context);
  for(i=0, n=1; zFmt[i]; i++, n++){
    if( zFmt[i]=='%' ){
      switch( zFmt[i+1] ){
        case 'd':
        case 'H':
        case 'm':
        case 'M':
        case 'S':
        case 'W':
          n++;
          /* fall thru */
        case 'w':
        case '%':
          break;
        case 'f':
          n += 8;
          break;
        case 'j':
          n += 3;
          break;
        case 'Y':
          n += 8;
          break;
        case 's':
        case 'J':
          n += 50;
          break;
        default:
          return;  /* ERROR.  return a NULL */
      }
      i++;
    }
  }
  testcase( n==sizeof(zBuf)-1 );
  testcase( n==sizeof(zBuf) );
  testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
  testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
  if( n<sizeof(zBuf) ){
    z = zBuf;
  }else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
    sqlite3_result_error_toobig(context);
    return;
  }else{
    z = sqlite3DbMallocRawNN(db, (int)n);
    if( z==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
  }
  computeJD(&x);
  computeYMD_HMS(&x);
  for(i=j=0; zFmt[i]; i++){
    if( zFmt[i]!='%' ){
      z[j++] = zFmt[i];
    }else{
      i++;
      switch( zFmt[i] ){
        case 'd':  sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
        case 'f': {
          double s = x.s;
          if( s>59.999 ) s = 59.999;
          sqlite3_snprintf(7, &z[j],"%06.3f", s);
          j += sqlite3Strlen30(&z[j]);
          break;
        }
        case 'H':  sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
        case 'W': /* Fall thru */
        case 'j': {
          int nDay;             /* Number of days since 1st day of year */
          DateTime y = x;
          y.validJD = 0;
          y.M = 1;
          y.D = 1;
          computeJD(&y);
          nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
          if( zFmt[i]=='W' ){
            int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
            wd = (int)(((x.iJD+43200000)/86400000)%7);
            sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
            j += 2;
          }else{
            sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
            j += 3;
          }
          break;
        }
        case 'J': {
          sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
          j+=sqlite3Strlen30(&z[j]);
          break;
        }
        case 'm':  sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
        case 'M':  sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
        case 's': {
          i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000);
          sqlite3Int64ToText(iS, &z[j]);
          j += sqlite3Strlen30(&z[j]);
          break;
        }
        case 'S':  sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
        case 'w': {
          z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
          break;
        }
        case 'Y': {
          sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
          break;
        }
        default:   z[j++] = '%'; break;
      }
    }

References sqlite3::aLimit, computeJD(), computeYMD_HMS(), DateTime::D, DateTime::h, DateTime::iJD, isDate(), DateTime::M, DateTime::m, DateTime::s, s, sqlite3_context_db_handle(), sqlite3_result_error_nomem(), sqlite3_result_error_toobig(), sqlite3_result_text(), sqlite3_snprintf(), sqlite3_value_text(), sqlite3DbMallocRawNN(), sqlite3Int64ToText(), sqlite3Strlen30(), SQLITE_DYNAMIC, SQLITE_LIMIT_LENGTH, SQLITE_TRANSIENT, testcase, DateTime::validJD, and DateTime::Y.

Referenced by sqlite3RegisterDateTimeFunctions().

◆ strHash()

static unsigned int strHash ( const char * z )

static

Definition at line 32932 of file sqlite3.c.

                                          {
  unsigned int h = 0;
  unsigned char c;
  while( (c = (unsigned char)*z++)!=0 ){     /*OPTIMIZATION-IF-TRUE*/
    /* Knuth multiplicative hashing.  (Sorting & Searching, p. 510).
    ** 0x9e3779b1 is 2654435761 which is the closest prime number to

Referenced by findElementWithHash(), rehash(), and sqlite3HashInsert().

◆ subjournalPage()

static int subjournalPage ( PgHdr * pPg )

static

Definition at line 56153 of file sqlite3.c.

                                     {
  int rc = SQLITE_OK;
  Pager *pPager = pPg->pPager;
  if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
 
    /* Open the sub-journal, if it has not already been opened */
    assert( pPager->useJournal );
    assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
    assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
    assert( pagerUseWal(pPager)
         || pageInJournal(pPager, pPg)
         || pPg->pgno>pPager->dbOrigSize
    );
    rc = openSubJournal(pPager);
 
    /* If the sub-journal was opened successfully (or was already open),
    ** write the journal record into the file.  */
    if( rc==SQLITE_OK ){
      void *pData = pPg->pData;
      i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
      char *pData2;
      pData2 = pData;
      PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
      rc = write32bits(pPager->sjfd, offset, pPg->pgno);
      if( rc==SQLITE_OK ){
        rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
      }
    }
  }
  if( rc==SQLITE_OK ){

References Pager::dbOrigSize, isOpen, Pager::jfd, Pager::journalMode, Pager::nSubRec, openSubJournal(), PAGER_JOURNALMODE_OFF, PAGERID, PAGERTRACE, pagerUseWal, Pager::pageSize, PgHdr::pData, PgHdr::pgno, PgHdr::pPager, Pager::sjfd, sqlite3OsWrite(), SQLITE_OK, Pager::useJournal, and write32bits().

◆ subjournalPageIfRequired()

static int subjournalPageIfRequired ( PgHdr * pPg )

static

Definition at line 56189 of file sqlite3.c.

56195 {

Referenced by pager_write(), pagerStress(), sqlite3PagerMovepage(), and sqlite3PagerWrite().

◆ subjRequiresPage()

static int subjRequiresPage ( PgHdr * pPg )

static

Definition at line 52767 of file sqlite3.c.

                                    :
**
**   * The page-number is less than or equal to PagerSavepoint.nOrig, and
**   * The bit corresponding to the page-number is not set in
**     PagerSavepoint.pInSavepoint.
*/
static int subjRequiresPage(PgHdr *pPg){
  Pager *pPager = pPg->pPager;
  PagerSavepoint *p;
  Pgno pgno = pPg->pgno;
  int i;
  for(i=0; i<pPager->nSavepoint; i++){
    p = &pPager->aSavepoint[i];

References Pager::aSavepoint, PagerSavepoint::nOrig, Pager::nSavepoint, PgHdr::pgno, PagerSavepoint::pInSavepoint, PgHdr::pPager, and sqlite3BitvecTestNotNull().

◆ substExpr()

static Expr * substExpr	(	SubstContext *	pSubst,
		Expr *	pExpr )

static

Definition at line 132771 of file sqlite3.c.

 {
  if( pExpr==0 ) return 0;
  if( ExprHasProperty(pExpr, EP_FromJoin)
   && pExpr->iRightJoinTable==pSubst->iTable
  ){
    pExpr->iRightJoinTable = pSubst->iNewTable;
  }
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pSubst->iTable
   && !ExprHasProperty(pExpr, EP_FixedCol)
  ){
    if( pExpr->iColumn<0 ){
      pExpr->op = TK_NULL;
    }else{
      Expr *pNew;
      Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
      Expr ifNullRow;
      assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
      assert( pExpr->pRight==0 );
      if( sqlite3ExprIsVector(pCopy) ){
        sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
      }else{
        sqlite3 *db = pSubst->pParse->db;
        if( pSubst->isLeftJoin && pCopy->op!=TK_COLUMN ){
          memset(&ifNullRow, 0, sizeof(ifNullRow));
          ifNullRow.op = TK_IF_NULL_ROW;
          ifNullRow.pLeft = pCopy;
          ifNullRow.iTable = pSubst->iNewTable;
          ifNullRow.flags = EP_Skip;
          pCopy = &ifNullRow;
        }
        testcase( ExprHasProperty(pCopy, EP_Subquery) );
        pNew = sqlite3ExprDup(db, pCopy, 0);
        if( pNew && pSubst->isLeftJoin ){
          ExprSetProperty(pNew, EP_CanBeNull);
        }
        if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
          pNew->iRightJoinTable = pExpr->iRightJoinTable;
          ExprSetProperty(pNew, EP_FromJoin);
        }
        sqlite3ExprDelete(db, pExpr);
        pExpr = pNew;
 
        /* Ensure that the expression now has an implicit collation sequence,
        ** just as it did when it was a column of a view or sub-query. */
        if( pExpr ){
          if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
            CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
            pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
                (pColl ? pColl->zName : "BINARY")
            );
          }
          ExprClearProperty(pExpr, EP_Collate);
        }
      }
    }
  }else{
    if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
      pExpr->iTable = pSubst->iNewTable;
    }
    pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
    pExpr->pRight = substExpr(pSubst, pExpr->pRight);
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      substSelect(pSubst, pExpr->x.pSelect, 1);
    }else{
      substExprList(pSubst, pExpr->x.pList);
    }
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( ExprHasProperty(pExpr, EP_WinFunc) ){
      Window *pWin = pExpr->y.pWin;
      pWin->pFilter = substExpr(pSubst, pWin->pFilter);
      substExprList(pSubst, pWin->pPartition);

References ExprList::a, Parse::db, EP_CanBeNull, EP_Collate, EP_FixedCol, EP_FromJoin, EP_Skip, EP_Subquery, EP_WinFunc, EP_xIsSelect, ExprClearProperty, ExprHasProperty, ExprSetProperty, Expr::flags, Expr::iColumn, SubstContext::iNewTable, Expr::iRightJoinTable, SubstContext::isLeftJoin, Expr::iTable, SubstContext::iTable, ExprList::nExpr, Expr::op, SubstContext::pEList, ExprList::ExprList_item::pExpr, Window::pFilter, Expr::pLeft, Expr::pList, SubstContext::pParse, Window::pPartition, Expr::pRight, Expr::pSelect, Expr::pWin, sqlite3ExprAddCollateString(), sqlite3ExprCollSeq(), sqlite3ExprDelete(), sqlite3ExprDup(), sqlite3ExprIsVector(), sqlite3VectorErrorMsg(), substExpr(), substExprList(), substSelect(), testcase, TK_COLLATE, TK_COLUMN, TK_IF_NULL_ROW, TK_NULL, Expr::x, Expr::y, and CollSeq::zName.

Referenced by pushDownWhereTerms(), substExpr(), and substSelect().

◆ substExprList()

static void substExprList	(	SubstContext *	pSubst,
		ExprList *	pList )

static

Definition at line 132852 of file sqlite3.c.

132861 {

Referenced by substExpr().

◆ substrFunc()

static void substrFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117343 of file sqlite3.c.

 {
  const unsigned char *z;
  const unsigned char *z2;
  int len;
  int p0type;
  i64 p1, p2;
  int negP2 = 0;
 
  assert( argc==3 || argc==2 );
  if( sqlite3_value_type(argv[1])==SQLITE_NULL
   || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
  ){
    return;
  }
  p0type = sqlite3_value_type(argv[0]);
  p1 = sqlite3_value_int(argv[1]);
  if( p0type==SQLITE_BLOB ){
    len = sqlite3_value_bytes(argv[0]);
    z = sqlite3_value_blob(argv[0]);
    if( z==0 ) return;
    assert( len==sqlite3_value_bytes(argv[0]) );
  }else{
    z = sqlite3_value_text(argv[0]);
    if( z==0 ) return;
    len = 0;
    if( p1<0 ){
      for(z2=z; *z2; len++){
        SQLITE_SKIP_UTF8(z2);
      }
    }
  }
#ifdef SQLITE_SUBSTR_COMPATIBILITY
  /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
  ** as substr(X,1,N) - it returns the first N characters of X.  This
  ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
  ** from 2009-02-02 for compatibility of applications that exploited the
  ** old buggy behavior. */
  if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */
#endif
  if( argc==3 ){
    p2 = sqlite3_value_int(argv[2]);
    if( p2<0 ){
      p2 = -p2;
      negP2 = 1;
    }
  }else{
    p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
  }
  if( p1<0 ){
    p1 += len;
    if( p1<0 ){
      p2 += p1;
      if( p2<0 ) p2 = 0;
      p1 = 0;
    }
  }else if( p1>0 ){
    p1--;
  }else if( p2>0 ){
    p2--;
  }
  if( negP2 ){
    p1 -= p2;
    if( p1<0 ){
      p2 += p1;
      p1 = 0;
    }
  }
  assert( p1>=0 && p2>=0 );
  if( p0type!=SQLITE_BLOB ){
    while( *z && p1 ){
      SQLITE_SKIP_UTF8(z);
      p1--;
    }
    for(z2=z; *z2 && p2; p2--){
      SQLITE_SKIP_UTF8(z2);
    }
    sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
                          SQLITE_UTF8);
  }else{
    if( p1+p2>len ){

References sqlite3::aLimit, sqlite3_context_db_handle(), sqlite3_result_blob64(), sqlite3_result_text64(), sqlite3_value_blob(), sqlite3_value_bytes(), sqlite3_value_int(), sqlite3_value_text(), sqlite3_value_type(), SQLITE_BLOB, SQLITE_LIMIT_LENGTH, SQLITE_NULL, SQLITE_SKIP_UTF8, SQLITE_TRANSIENT, and SQLITE_UTF8.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ substSelect()

static void substSelect	(	SubstContext *	pSubst,
		Select *	p,
		int	doPrior )

static

Definition at line 132862 of file sqlite3.c.

                               {
    pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
  }
}
static void substSelect(
  SubstContext *pSubst, /* Description of the substitution */
  Select *p,            /* SELECT statement in which to make substitutions */
  int doPrior           /* Do substitutes on p->pPrior too */
){
  SrcList *pSrc;
  struct SrcList_item *pItem;
  int i;
  if( !p ) return;
  do{
    substExprList(pSubst, p->pEList);
    substExprList(pSubst, p->pGroupBy);
    substExprList(pSubst, p->pOrderBy);
    p->pHaving = substExpr(pSubst, p->pHaving);
    p->pWhere = substExpr(pSubst, p->pWhere);
    pSrc = p->pSrc;
    assert( pSrc!=0 );
    for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
      substSelect(pSubst, pItem->pSelect, 1);

References ExprList::a, ExprList::ExprList_item::pExpr, and substExpr().

Referenced by flattenSubquery(), and substExpr().

◆ sumFinalize()

static void sumFinalize ( sqlite3_context * context )

static

Definition at line 118617 of file sqlite3.c.

                                                 {
  SumCtx *p;
  p = sqlite3_aggregate_context(context, 0);
  if( p && p->cnt>0 ){
    if( p->overflow ){
      sqlite3_result_error(context,"integer overflow",-1);
    }else if( p->approx ){

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sumInverse()

static void sumInverse	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118592 of file sqlite3.c.

                                                                               {
  SumCtx *p;
  int type;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  type = sqlite3_value_numeric_type(argv[0]);
  /* p is always non-NULL because sumStep() will have been called first
  ** to initialize it */
  if( ALWAYS(p) && type!=SQLITE_NULL ){
    assert( p->cnt>0 );
    p->cnt--;
    assert( type==SQLITE_INTEGER || p->approx );
    if( type==SQLITE_INTEGER && p->approx==0 ){
      i64 v = sqlite3_value_int64(argv[0]);
      p->rSum -= v;

Referenced by sqlite3RegisterBuiltinFunctions().

◆ sumStep()

static void sumStep	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118570 of file sqlite3.c.

                                                                             {
  SumCtx *p;
  int type;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  type = sqlite3_value_numeric_type(argv[0]);
  if( p && type!=SQLITE_NULL ){
    p->cnt++;
    if( type==SQLITE_INTEGER ){
      i64 v = sqlite3_value_int64(argv[0]);
      p->rSum += v;
      if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
        p->approx = p->overflow = 1;
      }

References SumCtx::approx, SumCtx::cnt, SumCtx::iSum, SumCtx::overflow, SumCtx::rSum, sqlite3_aggregate_context(), sqlite3_value_int64(), sqlite3_value_numeric_type(), sqlite3AddInt64(), SQLITE_INTEGER, SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ syncJournal()

static int syncJournal	(	Pager *	pPager,
		int	newHdr )

static

Definition at line 55893 of file sqlite3.c.

                                                 {
  int rc;                         /* Return code */
 
  assert( pPager->eState==PAGER_WRITER_CACHEMOD
       || pPager->eState==PAGER_WRITER_DBMOD
  );
  assert( assert_pager_state(pPager) );
  assert( !pagerUseWal(pPager) );
 
  rc = sqlite3PagerExclusiveLock(pPager);
  if( rc!=SQLITE_OK ) return rc;
 
  if( !pPager->noSync ){
    assert( !pPager->tempFile );
    if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
      const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
      assert( isOpen(pPager->jfd) );
 
      if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
        /* This block deals with an obscure problem. If the last connection
        ** that wrote to this database was operating in persistent-journal
        ** mode, then the journal file may at this point actually be larger
        ** than Pager.journalOff bytes. If the next thing in the journal
        ** file happens to be a journal-header (written as part of the
        ** previous connection's transaction), and a crash or power-failure
        ** occurs after nRec is updated but before this connection writes
        ** anything else to the journal file (or commits/rolls back its
        ** transaction), then SQLite may become confused when doing the
        ** hot-journal rollback following recovery. It may roll back all
        ** of this connections data, then proceed to rolling back the old,
        ** out-of-date data that follows it. Database corruption.
        **
        ** To work around this, if the journal file does appear to contain
        ** a valid header following Pager.journalOff, then write a 0x00
        ** byte to the start of it to prevent it from being recognized.
        **
        ** Variable iNextHdrOffset is set to the offset at which this
        ** problematic header will occur, if it exists. aMagic is used
        ** as a temporary buffer to inspect the first couple of bytes of
        ** the potential journal header.
        */
        i64 iNextHdrOffset;
        u8 aMagic[8];
        u8 zHeader[sizeof(aJournalMagic)+4];
 
        memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
        put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
 
        iNextHdrOffset = journalHdrOffset(pPager);
        rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
        if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
          static const u8 zerobyte = 0;
          rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
        }
        if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
          return rc;
        }
 
        /* Write the nRec value into the journal file header. If in
        ** full-synchronous mode, sync the journal first. This ensures that
        ** all data has really hit the disk before nRec is updated to mark
        ** it as a candidate for rollback.
        **
        ** This is not required if the persistent media supports the
        ** SAFE_APPEND property. Because in this case it is not possible
        ** for garbage data to be appended to the file, the nRec field
        ** is populated with 0xFFFFFFFF when the journal header is written
        ** and never needs to be updated.
        */
        if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
          PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
          IOTRACE(("JSYNC %p\n", pPager))
          rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
          if( rc!=SQLITE_OK ) return rc;
        }
        IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
        rc = sqlite3OsWrite(
            pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
        );
        if( rc!=SQLITE_OK ) return rc;
      }
      if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
        PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
        IOTRACE(("JSYNC %p\n", pPager))
        rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
          (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
        );
        if( rc!=SQLITE_OK ) return rc;
      }
 
      pPager->journalHdr = pPager->journalOff;
      if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
        pPager->nRec = 0;
        rc = writeJournalHdr(pPager);
        if( rc!=SQLITE_OK ) return rc;
      }
    }else{
      pPager->journalHdr = pPager->journalOff;
    }
  }
 
  /* Unless the pager is in noSync mode, the journal file was just
  ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
  ** all pages.

References aJournalMagic, Pager::eState, Pager::fd, Pager::fullSync, IOTRACE, isOpen, Pager::jfd, Pager::journalHdr, journalHdrOffset(), Pager::journalMode, Pager::journalOff, Pager::noSync, Pager::nRec, PAGER_JOURNALMODE_MEMORY, PAGER_WRITER_CACHEMOD, PAGER_WRITER_DBMOD, PAGERID, PAGERTRACE, pagerUseWal, Pager::pPCache, put32bits, sqlite3OsDeviceCharacteristics(), sqlite3OsRead(), sqlite3OsSync(), sqlite3OsWrite(), sqlite3PagerExclusiveLock(), sqlite3PcacheClearSyncFlags(), SQLITE_IOCAP_SAFE_APPEND, SQLITE_IOCAP_SEQUENTIAL, SQLITE_IOERR_SHORT_READ, SQLITE_OK, SQLITE_SYNC_DATAONLY, SQLITE_SYNC_FULL, Pager::syncFlags, Pager::tempFile, and writeJournalHdr().

Referenced by pagerStress(), and sqlite3PagerCommitPhaseOne().

◆ synthCollSeq()

static int synthCollSeq	(	sqlite3 *	db,
		CollSeq *	pColl )

static

Definition at line 115588 of file sqlite3.c.

                                                    {
  CollSeq *pColl2;
  char *z = pColl->zName;
  int i;
  static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 };
  for(i=0; i<3; i++){
    pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0);
    if( pColl2->xCmp!=0 ){
      memcpy(pColl, pColl2, sizeof(CollSeq));

References sqlite3FindCollSeq(), SQLITE_ERROR, SQLITE_OK, SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8, CollSeq::xCmp, CollSeq::xDel, and CollSeq::zName.

Referenced by sqlite3GetCollSeq().

◆ tabIsReadOnly()

static int tabIsReadOnly	(	Parse *	pParse,
		Table *	pTab )

static

Definition at line 116137 of file sqlite3.c.

                                                    {
  sqlite3 *db;
  if( IsVirtual(pTab) ){
    return sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0;
  }
  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
  db = pParse->db;

References Parse::db, IsVirtual, Parse::nested, VTable::pMod, Module::pModule, sqlite3GetVTable(), sqlite3ReadOnlyShadowTables(), sqlite3WritableSchema(), Table::tabFlags, TF_Readonly, TF_Shadow, and sqlite3_module::xUpdate.

Referenced by sqlite3IsReadOnly().

◆ tableAndColumnIndex()

static int tableAndColumnIndex	(	SrcList *	pSrc,
		int	N,
		const char *	zCol,
		int *	piTab,
		int *	piCol,
		int	bIgnoreHidden )

static

Definition at line 129577 of file sqlite3.c.

 {
  int i;               /* For looping over tables in pSrc */
  int iCol;            /* Index of column matching zCol */
 
  assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
  for(i=0; i<N; i++){
    iCol = columnIndex(pSrc->a[i].pTab, zCol);
    if( iCol>=0
     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
    ){
      if( piTab ){
        *piTab = i;
        *piCol = iCol;

References SrcList::a, Table::aCol, columnIndex(), IsHiddenColumn, and SrcList::SrcList_item::pTab.

Referenced by selectExpander(), and sqliteProcessJoin().

◆ tableMayNotBeDropped()

static int tableMayNotBeDropped	(	sqlite3 *	db,
		Table *	pTab )

static

Definition at line 113418 of file sqlite3.c.

                                                         {
  if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
    if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
    if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
    return 1;

◆ tableOfTrigger()

static Table * tableOfTrigger ( Trigger * pTrigger )

static

Definition at line 136998 of file sqlite3.c.

Referenced by getRowTrigger().

◆ termCanDriveIndex()

static int termCanDriveIndex	(	WhereTerm *	pTerm,
		struct SrcList_item *	pSrc,
		Bitmask	notReady )

static

Definition at line 146269 of file sqlite3.c.

 {
  char aff;
  if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
  if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
  if( (pSrc->fg.jointype & JT_LEFT)
   && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
   && (pTerm->eOperator & WO_IS)
  ){
    /* Cannot use an IS term from the WHERE clause as an index driver for
    ** the RHS of a LEFT JOIN. Such a term can only be used if it is from
    ** the ON clause.  */
    return 0;
  }
  if( (pTerm->prereqRight & notReady)!=0 ) return 0;

References WhereTerm::eOperator, EP_FromJoin, ExprHasProperty, JT_LEFT, WhereTerm::leftColumn, WhereTerm::leftCursor, Expr::op, WhereTerm::pExpr, WhereTerm::prereqRight, sqlite3IndexAffinityOk(), testcase, TK_IS, WhereTerm::u, WO_EQ, and WO_IS.

Referenced by constructAutomaticIndex(), and whereLoopAddBtree().

◆ termIsEquivalence()

static int termIsEquivalence	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 144889 of file sqlite3.c.

                                                        {
  char aff1, aff2;
  CollSeq *pColl;
  if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;
  if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
  if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;
  aff1 = sqlite3ExprAffinity(pExpr->pLeft);
  aff2 = sqlite3ExprAffinity(pExpr->pRight);
  if( aff1!=aff2
   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))
  ){

References Parse::db, EP_FromJoin, ExprHasProperty, Expr::op, OptimizationEnabled, Expr::pLeft, Expr::pRight, sqlite3ExprAffinity(), sqlite3ExprCollSeqMatch(), sqlite3ExprCompareCollSeq(), sqlite3IsBinary(), sqlite3IsNumericAffinity, SQLITE_Transitive, TK_EQ, and TK_IS.

Referenced by exprAnalyze().

◆ timeFunc()

static void timeFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 22662 of file sqlite3.c.

 {
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];

References computeHMS(), DateTime::h, isDate(), DateTime::m, DateTime::s, sqlite3_result_text(), sqlite3_snprintf(), and SQLITE_TRANSIENT.

Referenced by ctimeFunc(), and sqlite3RegisterDateTimeFunctions().

◆ tokenExpr()

static Expr * tokenExpr	(	Parse *	pParse,
		int	op,
		Token	t )

static

Definition at line 154344 of file sqlite3.c.

                                                        {
    Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
    if( p ){
      /* memset(p, 0, sizeof(Expr)); */
      p->op = (u8)op;
      p->affExpr = 0;
      p->flags = EP_Leaf;
      ExprClearVVAProperties(p);
      p->iAgg = -1;
      p->pLeft = p->pRight = 0;
      p->x.pList = 0;
      p->pAggInfo = 0;
      p->y.pTab = 0;
      p->op2 = 0;
      p->iTable = 0;
      p->iColumn = 0;
      p->u.zToken = (char*)&p[1];
      memcpy(p->u.zToken, t.z, t.n);
      p->u.zToken[t.n] = 0;
      if( sqlite3Isquote(p->u.zToken[0]) ){
        sqlite3DequoteExpr(p);
      }
#if SQLITE_MAX_EXPR_DEPTH>0
      p->nHeight = 1;
#endif

References Expr::affExpr, Parse::db, EP_Leaf, ExprClearVVAProperties, Expr::flags, Expr::iAgg, Expr::iColumn, IN_RENAME_OBJECT, Expr::iTable, Token::n, Expr::nHeight, Expr::op, Expr::op2, Expr::pAggInfo, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pTab, sqlite3DbMallocRawNN(), sqlite3DequoteExpr(), sqlite3Isquote, sqlite3RenameTokenMap(), Expr::u, Expr::x, Expr::y, Token::z, and Expr::zToken.

Referenced by yy_reduce().

◆ total_changes()

static void total_changes	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117636 of file sqlite3.c.

117646 {

Referenced by sqlite3RegisterBuiltinFunctions().

◆ totalFinalize()

static void totalFinalize ( sqlite3_context * context )

static

Definition at line 118637 of file sqlite3.c.

                     {
    sqlite3_result_double(context, p->rSum/(double)p->cnt);
  }
}

Referenced by sqlite3RegisterBuiltinFunctions().

◆ transferJoinMarkings()

static void transferJoinMarkings	(	Expr *	pDerived,
		Expr *	pBase )

static

Definition at line 144441 of file sqlite3.c.

References EP_FromJoin, Expr::flags, and Expr::iRightJoinTable.

Referenced by exprAnalyze(), and exprAnalyzeOrTerm().

◆ transferParseError()

static void transferParseError	(	Parse *	pTo,
		Parse *	pFrom )

static

Definition at line 137263 of file sqlite3.c.

                                                        {
  assert( pFrom->zErrMsg==0 || pFrom->nErr );
  assert( pTo->zErrMsg==0 || pTo->nErr );
  if( pTo->nErr==0 ){
    pTo->zErrMsg = pFrom->zErrMsg;

References Parse::db, Parse::nErr, Parse::rc, sqlite3DbFree(), and Parse::zErrMsg.

◆ translateColumnToCopy()

static void translateColumnToCopy	(	Parse *	pParse,
		int	iStart,
		int	iTabCur,
		int	iRegister,
		int	iAutoidxCur )

static

Definition at line 146187 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  if( pParse->db->mallocFailed ) return;
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
      pOp->opcode = OP_Copy;
      pOp->p1 = pOp->p2 + iRegister;
      pOp->p2 = pOp->p3;
      pOp->p3 = 0;
    }else if( pOp->opcode==OP_Rowid ){
      if( iAutoidxCur ){
        pOp->opcode = OP_Sequence;
        pOp->p1 = iAutoidxCur;
      }else{
        pOp->opcode = OP_Null;

References Parse::db, sqlite3::mallocFailed, OP_Column, OP_Copy, OP_Null, OP_Rowid, OP_Sequence, VdbeOp::opcode, VdbeOp::p1, VdbeOp::p2, VdbeOp::p3, Parse::pVdbe, sqlite3VdbeCurrentAddr(), and sqlite3VdbeGetOp().

Referenced by constructAutomaticIndex(), and sqlite3WhereEnd().

◆ triggerSpanDup()

static char * triggerSpanDup	(	sqlite3 *	db,
		const char *	zStart,
		const char *	zEnd )

static

Definition at line 136756 of file sqlite3.c.

Referenced by sqlite3TriggerSelectStep(), and triggerStepAllocate().

◆ triggerStepAllocate()

static TriggerStep * triggerStepAllocate	(	Parse *	pParse,
		u8	op,
		Token *	pName,
		const char *	zStart,
		const char *	zEnd )

static

Definition at line 136794 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;
 
  pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
  if( pTriggerStep ){
    char *z = (char*)&pTriggerStep[1];
    memcpy(z, pName->z, pName->n);
    sqlite3Dequote(z);
    pTriggerStep->zTarget = z;
    pTriggerStep->op = op;
    pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);

References Parse::db, IN_RENAME_OBJECT, Token::n, TriggerStep::op, sqlite3DbMallocZero(), sqlite3Dequote(), sqlite3RenameTokenMap(), triggerSpanDup(), Token::z, TriggerStep::zSpan, and TriggerStep::zTarget.

Referenced by sqlite3TriggerDeleteStep(), sqlite3TriggerInsertStep(), and sqlite3TriggerUpdateStep().

◆ trimFunc()

static void trimFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118355 of file sqlite3.c.

 {
  const unsigned char *zIn;         /* Input string */
  const unsigned char *zCharSet;    /* Set of characters to trim */
  int nIn;                          /* Number of bytes in input */
  int flags;                        /* 1: trimleft  2: trimright  3: trim */
  int i;                            /* Loop counter */
  unsigned char *aLen = 0;          /* Length of each character in zCharSet */
  unsigned char **azChar = 0;       /* Individual characters in zCharSet */
  int nChar;                        /* Number of characters in zCharSet */
 
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
    return;
  }
  zIn = sqlite3_value_text(argv[0]);
  if( zIn==0 ) return;
  nIn = sqlite3_value_bytes(argv[0]);
  assert( zIn==sqlite3_value_text(argv[0]) );
  if( argc==1 ){
    static const unsigned char lenOne[] = { 1 };
    static unsigned char * const azOne[] = { (u8*)" " };
    nChar = 1;
    aLen = (u8*)lenOne;
    azChar = (unsigned char **)azOne;
    zCharSet = 0;
  }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
    return;
  }else{
    const unsigned char *z;
    for(z=zCharSet, nChar=0; *z; nChar++){
      SQLITE_SKIP_UTF8(z);
    }
    if( nChar>0 ){
      azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
      if( azChar==0 ){
        return;
      }
      aLen = (unsigned char*)&azChar[nChar];
      for(z=zCharSet, nChar=0; *z; nChar++){
        azChar[nChar] = (unsigned char *)z;
        SQLITE_SKIP_UTF8(z);
        aLen[nChar] = (u8)(z - azChar[nChar]);
      }
    }
  }
  if( nChar>0 ){
    flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
    if( flags & 1 ){
      while( nIn>0 ){
        int len = 0;
        for(i=0; i<nChar; i++){
          len = aLen[i];
          if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
        }
        if( i>=nChar ) break;
        zIn += len;
        nIn -= len;
      }
    }
    if( flags & 2 ){
      while( nIn>0 ){
        int len = 0;
        for(i=0; i<nChar; i++){
          len = aLen[i];
          if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
        }
        if( i>=nChar ) break;
        nIn -= len;
      }
    }

Referenced by sqlite3RegisterBuiltinFunctions().

◆ typeofFunc()

static void typeofFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	argv )

static

Definition at line 117123 of file sqlite3.c.

 {
  static const char *azType[] = { "integer", "real", "text", "blob", "null" };
  int i = sqlite3_value_type(argv[0]) - 1;
  UNUSED_PARAMETER(NotUsed);
  assert( i>=0 && i<ArraySize(azType) );
  assert( SQLITE_INTEGER==1 );
  assert( SQLITE_FLOAT==2 );
  assert( SQLITE_TEXT==3 );
  assert( SQLITE_BLOB==4 );
  assert( SQLITE_NULL==5 );

Referenced by sqlite3RegisterBuiltinFunctions().

◆ unicodeFunc()

static void unicodeFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118155 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ unixAccess()

static int unixAccess	(	sqlite3_vfs *	NotUsed,
		const char *	zPath,
		int	flags,
		int *	pResOut )

static

Definition at line 39820 of file sqlite3.c.

                           : Return 1 if the file exists
**     SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
**     SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
**
** Otherwise return 0.
*/
static int unixAccess(
  sqlite3_vfs *NotUsed,   /* The VFS containing this xAccess method */
  const char *zPath,      /* Path of the file to examine */
  int flags,              /* What do we want to learn about the zPath file? */
  int *pResOut            /* Write result boolean here */
){
  UNUSED_PARAMETER(NotUsed);
  SimulateIOError( return SQLITE_IOERR_ACCESS; );
  assert( pResOut!=0 );
 
  /* The spec says there are three possible values for flags.  But only
  ** two of them are actually used */
  assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE );
 
  if( flags==SQLITE_ACCESS_EXISTS ){
    struct stat buf;
    *pResOut = 0==osStat(zPath, &buf) &&

References osAccess, osStat, SimulateIOError, SQLITE_ACCESS_EXISTS, SQLITE_ACCESS_READWRITE, SQLITE_IOERR_ACCESS, and UNUSED_PARAMETER.

◆ unixCheckReservedLock()

static int unixCheckReservedLock	(	sqlite3_file *	id,
		int *	pResOut )

static

Definition at line 35048 of file sqlite3.c.

                                                                {
  int rc = SQLITE_OK;
  int reserved = 0;
  unixFile *pFile = (unixFile*)id;
 
  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
 
  assert( pFile );
  assert( pFile->eFileLock<=SHARED_LOCK );
  sqlite3_mutex_enter(pFile->pInode->pLockMutex);
 
  /* Check if a thread in this process holds such a lock */
  if( pFile->pInode->eFileLock>SHARED_LOCK ){
    reserved = 1;
  }
 
  /* Otherwise see if some other process holds it.
  */
#ifndef __DJGPP__
  if( !reserved && !pFile->pInode->bProcessLock ){
    struct flock lock;
    lock.l_whence = SEEK_SET;
    lock.l_start = RESERVED_BYTE;
    lock.l_len = 1;
    lock.l_type = F_WRLCK;
    if( osFcntl(pFile->h, F_GETLK, &lock) ){
      rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
      storeLastErrno(pFile, errno);
    } else if( lock.l_type!=F_UNLCK ){
      reserved = 1;
    }
  }
#endif
 

References unixInodeInfo::bProcessLock, unixFile::eFileLock, unixInodeInfo::eFileLock, unixFile::h, osFcntl, OSTRACE, unixFile::pInode, unixInodeInfo::pLockMutex, RESERVED_BYTE, SHARED_LOCK, SimulateIOError, sqlite3_mutex_enter(), sqlite3_mutex_leave(), SQLITE_IOERR_CHECKRESERVEDLOCK, SQLITE_OK, and storeLastErrno().

◆ unixClose()

static int unixClose ( sqlite3_file * id )

static

Definition at line 35663 of file sqlite3.c.

                                      {
  int rc = SQLITE_OK;
  unixFile *pFile = (unixFile *)id;
  unixInodeInfo *pInode = pFile->pInode;
 
  assert( pInode!=0 );
  verifyDbFile(pFile);
  unixUnlock(id, NO_LOCK);
  assert( unixFileMutexNotheld(pFile) );
  unixEnterMutex();
 
  /* unixFile.pInode is always valid here. Otherwise, a different close
  ** routine (e.g. nolockClose()) would be called instead.
  */
  assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
  sqlite3_mutex_enter(pInode->pLockMutex);
  if( pInode->nLock ){
    /* If there are outstanding locks, do not actually close the file just
    ** yet because that would clear those locks.  Instead, add the file
    ** descriptor to pInode->pUnused list.  It will be automatically closed
    ** when the last lock is cleared.
    */
    setPendingFd(pFile);
  }

Referenced by unixOpen().

◆ unixCurrentTime()

static int unixCurrentTime	(	sqlite3_vfs *	NotUsed,
		double *	prNow )

static

Definition at line 40150 of file sqlite3.c.

40156 {

40157 sqlite3_int64 i = 0;

References unixCurrentTimeInt64(), and UNUSED_PARAMETER.

◆ unixCurrentTimeInt64()

static int unixCurrentTimeInt64	(	sqlite3_vfs *	NotUsed,
		sqlite3_int64 *	piNow )

static

Definition at line 40118 of file sqlite3.c.

                                                                           {
  static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
  int rc = SQLITE_OK;
#if defined(NO_GETTOD)
  time_t t;
  time(&t);
  *piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
#elif OS_VXWORKS
  struct timespec sNow;
  clock_gettime(CLOCK_REALTIME, &sNow);
  *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
#else
  struct timeval sNow;
  (void)gettimeofday(&sNow, 0);  /* Cannot fail given valid arguments */
  *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000;
#endif
 
#ifdef SQLITE_TEST
  if( sqlite3_current_time ){

References SQLITE_OK, and UNUSED_PARAMETER.

Referenced by unixCurrentTime().

◆ unixDelete()

static int unixDelete	(	sqlite3_vfs *	NotUsed,
		const char *	zPath,
		int	dirSync )

static

Definition at line 39772 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  UNUSED_PARAMETER(NotUsed);
  SimulateIOError(return SQLITE_IOERR_DELETE);
  if( osUnlink(zPath)==(-1) ){
    if( errno==ENOENT
#if OS_VXWORKS
        || osAccess(zPath,0)!=0
#endif
    ){
      rc = SQLITE_IOERR_DELETE_NOENT;
    }else{
      rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
    }
    return rc;
  }
#ifndef SQLITE_DISABLE_DIRSYNC
  if( (dirSync & 1)!=0 ){
    int fd;
    rc = osOpenDirectory(zPath, &fd);
    if( rc==SQLITE_OK ){
      if( full_fsync(fd,0,0) ){
        rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
      }
      robust_close(0, fd, __LINE__);
    }else{
      assert( rc==SQLITE_CANTOPEN );

References full_fsync(), OS_VXWORKS, osAccess, osOpenDirectory, osUnlink, robust_close(), SimulateIOError, SQLITE_CANTOPEN, SQLITE_IOERR_DELETE, SQLITE_IOERR_DELETE_NOENT, SQLITE_IOERR_DIR_FSYNC, SQLITE_OK, unixLogError, and UNUSED_PARAMETER.

◆ unixDeviceCharacteristics()

static int unixDeviceCharacteristics ( sqlite3_file * id )

static

Definition at line 37730 of file sqlite3.c.

References unixFile::deviceCharacteristics, and setDeviceCharacteristics().

◆ unixDlClose()

static void unixDlClose	(	sqlite3_vfs *	NotUsed,
		void *	pHandle )

static

Definition at line 40017 of file sqlite3.c.

◆ unixDlError()

static void unixDlError	(	sqlite3_vfs *	NotUsed,
		int	nBuf,
		char *	zBufOut )

static

Definition at line 39984 of file sqlite3.c.

                                                                      {
  const char *zErr;
  UNUSED_PARAMETER(NotUsed);
  unixEnterMutex();

References unixEnterMutex(), and UNUSED_PARAMETER.

◆ unixDlOpen()

static void * unixDlOpen	(	sqlite3_vfs *	NotUsed,
		const char *	zFilename )

static

Definition at line 39972 of file sqlite3.c.

References UNUSED_PARAMETER.

◆ unixEnterMutex()

static void unixEnterMutex ( void )

static

Definition at line 34279 of file sqlite3.c.

          :     enter(unixBigLock),  enter(pLockInfo)
**      OK:     enter(unixBigLock)
**      OK:     enter(pLockInfo)
**   ERROR:     enter(pLockInfo), enter(unixBigLock)

Referenced by findReusableFd(), unixDlError(), unixOpenSharedMemory(), unixShmBarrier(), and unixShmUnmap().

◆ unixFetch()

static int unixFetch	(	sqlite3_file *	fd,
		i64	iOff,
		int	nAmt,
		void **	pp )

static

Definition at line 38711 of file sqlite3.c.

                                                                     {
#if SQLITE_MAX_MMAP_SIZE>0
  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */
#endif
  *pp = 0;
 
#if SQLITE_MAX_MMAP_SIZE>0
  if( pFd->mmapSizeMax>0 ){
    if( pFd->pMapRegion==0 ){
      int rc = unixMapfile(pFd, -1);
      if( rc!=SQLITE_OK ) return rc;
    }
    if( pFd->mmapSize >= iOff+nAmt ){
      *pp = &((u8 *)pFd->pMapRegion)[iOff];

References SQLITE_OK.

◆ unixFileControl()

static int unixFileControl	(	sqlite3_file *	id,
		int	op,
		void *	pArg )

static

Definition at line 37478 of file sqlite3.c.

                                                                {
  unixFile *pFile = (unixFile*)id;
  switch( op ){
#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
    case SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: {
      int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
      return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK;
    }
    case SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: {
      int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
      return rc ? SQLITE_IOERR_COMMIT_ATOMIC : SQLITE_OK;
    }
    case SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: {
      int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
      return rc ? SQLITE_IOERR_ROLLBACK_ATOMIC : SQLITE_OK;
    }
#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
 
    case SQLITE_FCNTL_LOCKSTATE: {
      *(int*)pArg = pFile->eFileLock;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_LAST_ERRNO: {
      *(int*)pArg = pFile->lastErrno;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_CHUNK_SIZE: {
      pFile->szChunk = *(int *)pArg;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_SIZE_HINT: {
      int rc;
      SimulateIOErrorBenign(1);
      rc = fcntlSizeHint(pFile, *(i64 *)pArg);
      SimulateIOErrorBenign(0);
      return rc;
    }
    case SQLITE_FCNTL_PERSIST_WAL: {
      unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
      unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_VFSNAME: {
      *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_TEMPFILENAME: {
      char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
      if( zTFile ){
        unixGetTempname(pFile->pVfs->mxPathname, zTFile);
        *(char**)pArg = zTFile;
      }
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_HAS_MOVED: {
      *(int*)pArg = fileHasMoved(pFile);
      return SQLITE_OK;
    }
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
    case SQLITE_FCNTL_LOCK_TIMEOUT: {
      int iOld = pFile->iBusyTimeout;
      pFile->iBusyTimeout = *(int*)pArg;
      *(int*)pArg = iOld;
      return SQLITE_OK;
    }
#endif
#if SQLITE_MAX_MMAP_SIZE>0
    case SQLITE_FCNTL_MMAP_SIZE: {
      i64 newLimit = *(i64*)pArg;
      int rc = SQLITE_OK;
      if( newLimit>sqlite3GlobalConfig.mxMmap ){
        newLimit = sqlite3GlobalConfig.mxMmap;
      }
 
      /* The value of newLimit may be eventually cast to (size_t) and passed
      ** to mmap(). Restrict its value to 2GB if (size_t) is not at least a
      ** 64-bit type. */
      if( newLimit>0 && sizeof(size_t)<8 ){
        newLimit = (newLimit & 0x7FFFFFFF);
      }
 
      *(i64*)pArg = pFile->mmapSizeMax;
      if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
        pFile->mmapSizeMax = newLimit;
        if( pFile->mmapSize>0 ){
          unixUnmapfile(pFile);
          rc = unixMapfile(pFile, -1);
        }
      }
      return rc;
    }
#endif
#ifdef SQLITE_DEBUG
    /* The pager calls this method to signal that it has done
    ** a rollback and that the database is therefore unchanged and
    ** it hence it is OK for the transaction change counter to be
    ** unchanged.
    */
    case SQLITE_FCNTL_DB_UNCHANGED: {
      ((unixFile*)id)->dbUpdate = 0;
      return SQLITE_OK;
    }
#endif
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    case SQLITE_FCNTL_SET_LOCKPROXYFILE:
    case SQLITE_FCNTL_GET_LOCKPROXYFILE: {

◆ unixFileLock()

static int unixFileLock	(	unixFile *	pFile,
		struct flock *	pLock )

static

Definition at line 35146 of file sqlite3.c.

                                                             {
  int rc;
  unixInodeInfo *pInode = pFile->pInode;
  assert( pInode!=0 );
  assert( sqlite3_mutex_held(pInode->pLockMutex) );
  if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
    if( pInode->bProcessLock==0 ){
      struct flock lock;
      assert( pInode->nLock==0 );
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      lock.l_type = F_WRLCK;
      rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
      if( rc<0 ) return rc;
      pInode->bProcessLock = 1;
      pInode->nLock++;
    }else{
      rc = 0;

References unixInodeInfo::bProcessLock, unixFile::ctrlFlags, unixFile::h, unixInodeInfo::nLock, osSetPosixAdvisoryLock, unixFile::pInode, unixInodeInfo::pLockMutex, SHARED_FIRST, SHARED_SIZE, sqlite3_mutex_held(), UNIXFILE_EXCL, and UNIXFILE_RDONLY.

Referenced by posixUnlock(), and unixLock().

◆ unixFileSize()

static int unixFileSize	(	sqlite3_file *	id,
		i64 *	pSize )

static

Definition at line 37355 of file sqlite3.c.

                                                     {
  int rc;
  struct stat buf;
  assert( id );
  rc = osFstat(((unixFile*)id)->h, &buf);
  SimulateIOError( rc=1 );
  if( rc!=0 ){
    storeLastErrno((unixFile*)id, errno);
    return SQLITE_IOERR_FSTAT;
  }
  *pSize = buf.st_size;
 
  /* When opening a zero-size database, the findInodeInfo() procedure
  ** writes a single byte into that file in order to work around a bug
  ** in the OS-X msdos filesystem.  In order to avoid problems with upper
  ** layers, we need to report this file size as zero even though it is
  ** really 1.   Ticket #3260.

◆ unixFullPathname()

static int unixFullPathname	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		int	nOut,
		char *	zOut )

static

Definition at line 39880 of file sqlite3.c.

 {
#if !defined(HAVE_READLINK) || !defined(HAVE_LSTAT)
  return mkFullPathname(zPath, zOut, nOut);
#else
  int rc = SQLITE_OK;
  int nByte;
  int nLink = 0;                /* Number of symbolic links followed so far */
  const char *zIn = zPath;      /* Input path for each iteration of loop */
  char *zDel = 0;
 
  assert( pVfs->mxPathname==MAX_PATHNAME );
  UNUSED_PARAMETER(pVfs);
 
  /* It's odd to simulate an io-error here, but really this is just
  ** using the io-error infrastructure to test that SQLite handles this
  ** function failing. This function could fail if, for example, the
  ** current working directory has been unlinked.
  */
  SimulateIOError( return SQLITE_ERROR );
 
  do {
 
    /* Call stat() on path zIn. Set bLink to true if the path is a symbolic
    ** link, or false otherwise.  */
    int bLink = 0;
    struct stat buf;
    if( osLstat(zIn, &buf)!=0 ){
      if( errno!=ENOENT ){
        rc = unixLogError(SQLITE_CANTOPEN_BKPT, "lstat", zIn);
      }
    }else{
      bLink = S_ISLNK(buf.st_mode);
    }
 
    if( bLink ){
      nLink++;
      if( zDel==0 ){
        zDel = sqlite3_malloc(nOut);
        if( zDel==0 ) rc = SQLITE_NOMEM_BKPT;
      }else if( nLink>=SQLITE_MAX_SYMLINKS ){
        rc = SQLITE_CANTOPEN_BKPT;
      }
 
      if( rc==SQLITE_OK ){
        nByte = osReadlink(zIn, zDel, nOut-1);
        if( nByte<0 ){
          rc = unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zIn);
        }else{
          if( zDel[0]!='/' ){
            int n;
            for(n = sqlite3Strlen30(zIn); n>0 && zIn[n-1]!='/'; n--);
            if( nByte+n+1>nOut ){
              rc = SQLITE_CANTOPEN_BKPT;
            }else{
              memmove(&zDel[n], zDel, nByte+1);
              memcpy(zDel, zIn, n);
              nByte += n;
            }
          }
          zDel[nByte] = '\0';
        }
      }
 
      zIn = zDel;
    }
 
    assert( rc!=SQLITE_OK || zIn!=zOut || zIn[0]=='/' );
    if( rc==SQLITE_OK && zIn!=zOut ){
      rc = mkFullPathname(zIn, zOut, nOut);
    }
    if( bLink==0 ) break;
    zIn = zOut;
  }while( rc==SQLITE_OK );

References MAX_PATHNAME, mkFullPathname(), sqlite3_vfs::mxPathname, osLstat, osReadlink, SimulateIOError, sqlite3_free(), sqlite3_malloc(), sqlite3Strlen30(), SQLITE_CANTOPEN_BKPT, SQLITE_ERROR, SQLITE_MAX_SYMLINKS, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OK_SYMLINK, unixLogError, and UNUSED_PARAMETER.

◆ unixGetLastError()

static int unixGetLastError	(	sqlite3_vfs *	NotUsed,
		int	NotUsed2,
		char *	NotUsed3 )

static

Definition at line 40168 of file sqlite3.c.

References UNUSED_PARAMETER.

◆ unixGetpagesize()

static int unixGetpagesize ( void )

static

Definition at line 37744 of file sqlite3.c.

                                {
#if OS_VXWORKS
  return 1024;

◆ unixGetSystemCall()

static sqlite3_syscall_ptr unixGetSystemCall	(	sqlite3_vfs *	pNotUsed,
		const char *	zName )

static

Definition at line 34156 of file sqlite3.c.

 {
  unsigned int i;
 

References aSyscall, UNUSED_PARAMETER, and zName.

◆ unixGetTempname()

static int unixGetTempname	(	int	nBuf,
		char *	zBuf )

static

Definition at line 39282 of file sqlite3.c.

                                                {
  const char *zDir;
  int iLimit = 0;
 
  /* It's odd to simulate an io-error here, but really this is just
  ** using the io-error infrastructure to test that SQLite handles this
  ** function failing.
  */
  zBuf[0] = 0;
  SimulateIOError( return SQLITE_IOERR );
 
  zDir = unixTempFileDir();
  if( zDir==0 ) return SQLITE_IOERR_GETTEMPPATH;
  do{
    u64 r;
    sqlite3_randomness(sizeof(r), &r);
    assert( nBuf>2 );
    zBuf[nBuf-2] = 0;

References osAccess, SimulateIOError, sqlite3_randomness(), sqlite3_snprintf(), SQLITE_ERROR, SQLITE_IOERR, SQLITE_IOERR_GETTEMPPATH, SQLITE_OK, SQLITE_TEMP_FILE_PREFIX, and unixTempFileDir().

Referenced by unixOpen().

◆ unixLeaveMutex()

static void unixLeaveMutex ( void )

static

Definition at line 34283 of file sqlite3.c.

34285 {

34286 assert( sqlite3_mutex_notheld(unixBigLock) ); /* Not a recursive mutex */

References sqlite3_mutex_enter(), sqlite3_mutex_notheld(), and unixBigLock.

Referenced by findReusableFd(), unixOpenSharedMemory(), unixShmBarrier(), and unixShmUnmap().

◆ unixLock()

static int unixLock	(	sqlite3_file *	id,
		int	eFileLock )

static

Definition at line 35196 of file sqlite3.c.

                                                    {
  /* The following describes the implementation of the various locks and
  ** lock transitions in terms of the POSIX advisory shared and exclusive
  ** lock primitives (called read-locks and write-locks below, to avoid
  ** confusion with SQLite lock names). The algorithms are complicated
  ** slightly in order to be compatible with Windows95 systems simultaneously
  ** accessing the same database file, in case that is ever required.
  **
  ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
  ** byte', each single bytes at well known offsets, and the 'shared byte
  ** range', a range of 510 bytes at a well known offset.
  **
  ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
  ** byte'.  If this is successful, 'shared byte range' is read-locked
  ** and the lock on the 'pending byte' released.  (Legacy note:  When
  ** SQLite was first developed, Windows95 systems were still very common,
  ** and Widnows95 lacks a shared-lock capability.  So on Windows95, a
  ** single randomly selected by from the 'shared byte range' is locked.
  ** Windows95 is now pretty much extinct, but this work-around for the
  ** lack of shared-locks on Windows95 lives on, for backwards
  ** compatibility.)
  **
  ** A process may only obtain a RESERVED lock after it has a SHARED lock.
  ** A RESERVED lock is implemented by grabbing a write-lock on the
  ** 'reserved byte'.
  **
  ** A process may only obtain a PENDING lock after it has obtained a
  ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
  ** on the 'pending byte'. This ensures that no new SHARED locks can be
  ** obtained, but existing SHARED locks are allowed to persist. A process
  ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
  ** This property is used by the algorithm for rolling back a journal file
  ** after a crash.
  **
  ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
  ** implemented by obtaining a write-lock on the entire 'shared byte
  ** range'. Since all other locks require a read-lock on one of the bytes
  ** within this range, this ensures that no other locks are held on the
  ** database.
  */
  int rc = SQLITE_OK;
  unixFile *pFile = (unixFile*)id;
  unixInodeInfo *pInode;
  struct flock lock;
  int tErrno = 0;
 
  assert( pFile );
  OSTRACE(("LOCK    %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
      azFileLock(eFileLock), azFileLock(pFile->eFileLock),
      azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
      osGetpid(0)));
 
  /* If there is already a lock of this type or more restrictive on the
  ** unixFile, do nothing. Don't use the end_lock: exit path, as
  ** unixEnterMutex() hasn't been called yet.
  */
  if( pFile->eFileLock>=eFileLock ){
    OSTRACE(("LOCK    %d %s ok (already held) (unix)\n", pFile->h,
            azFileLock(eFileLock)));
    return SQLITE_OK;
  }
 
  /* Make sure the locking sequence is correct.
  **  (1) We never move from unlocked to anything higher than shared lock.
  **  (2) SQLite never explicitly requests a pending lock.
  **  (3) A shared lock is always held when a reserve lock is requested.
  */
  assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
  assert( eFileLock!=PENDING_LOCK );
  assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
 
  /* This mutex is needed because pFile->pInode is shared across threads
  */
  pInode = pFile->pInode;
  sqlite3_mutex_enter(pInode->pLockMutex);
 
  /* If some thread using this PID has a lock via a different unixFile*
  ** handle that precludes the requested lock, return BUSY.
  */
  if( (pFile->eFileLock!=pInode->eFileLock &&
          (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
  ){
    rc = SQLITE_BUSY;
    goto end_lock;
  }
 
  /* If a SHARED lock is requested, and some thread using this PID already
  ** has a SHARED or RESERVED lock, then increment reference counts and
  ** return SQLITE_OK.
  */
  if( eFileLock==SHARED_LOCK &&
      (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
    assert( eFileLock==SHARED_LOCK );
    assert( pFile->eFileLock==0 );
    assert( pInode->nShared>0 );
    pFile->eFileLock = SHARED_LOCK;
    pInode->nShared++;
    pInode->nLock++;
    goto end_lock;
  }
 
 
  /* A PENDING lock is needed before acquiring a SHARED lock and before
  ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
  ** be released.
  */
  lock.l_len = 1L;
  lock.l_whence = SEEK_SET;
  if( eFileLock==SHARED_LOCK
      || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
  ){
    lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
    lock.l_start = PENDING_BYTE;
    if( unixFileLock(pFile, &lock) ){
      tErrno = errno;
      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
      if( rc!=SQLITE_BUSY ){
        storeLastErrno(pFile, tErrno);
      }
      goto end_lock;
    }
  }
 
 
  /* If control gets to this point, then actually go ahead and make
  ** operating system calls for the specified lock.
  */
  if( eFileLock==SHARED_LOCK ){
    assert( pInode->nShared==0 );
    assert( pInode->eFileLock==0 );
    assert( rc==SQLITE_OK );
 
    /* Now get the read-lock */
    lock.l_start = SHARED_FIRST;
    lock.l_len = SHARED_SIZE;
    if( unixFileLock(pFile, &lock) ){
      tErrno = errno;
      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
    }
 
    /* Drop the temporary PENDING lock */
    lock.l_start = PENDING_BYTE;
    lock.l_len = 1L;
    lock.l_type = F_UNLCK;
    if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
      /* This could happen with a network mount */
      tErrno = errno;
      rc = SQLITE_IOERR_UNLOCK;
    }
 
    if( rc ){
      if( rc!=SQLITE_BUSY ){
        storeLastErrno(pFile, tErrno);
      }
      goto end_lock;
    }else{
      pFile->eFileLock = SHARED_LOCK;
      pInode->nLock++;
      pInode->nShared = 1;
    }
  }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
    /* We are trying for an exclusive lock but another thread in this
    ** same process is still holding a shared lock. */
    rc = SQLITE_BUSY;
  }else{
    /* The request was for a RESERVED or EXCLUSIVE lock.  It is
    ** assumed that there is a SHARED or greater lock on the file
    ** already.
    */
    assert( 0!=pFile->eFileLock );
    lock.l_type = F_WRLCK;
 
    assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
    if( eFileLock==RESERVED_LOCK ){
      lock.l_start = RESERVED_BYTE;
      lock.l_len = 1L;
    }else{
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
    }
 
    if( unixFileLock(pFile, &lock) ){
      tErrno = errno;
      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
      if( rc!=SQLITE_BUSY ){
        storeLastErrno(pFile, tErrno);
      }
    }
  }
 
 
#ifdef SQLITE_DEBUG
  /* Set up the transaction-counter change checking flags when
  ** transitioning from a SHARED to a RESERVED lock.  The change
  ** from SHARED to RESERVED marks the beginning of a normal
  ** write operation (not a hot journal rollback).
  */
  if( rc==SQLITE_OK
   && pFile->eFileLock<=SHARED_LOCK
   && eFileLock==RESERVED_LOCK
  ){
    pFile->transCntrChng = 0;
    pFile->dbUpdate = 0;
    pFile->inNormalWrite = 1;
  }
#endif
 
 
  if( rc==SQLITE_OK ){
    pFile->eFileLock = eFileLock;
    pInode->eFileLock = eFileLock;
  }else if( eFileLock==EXCLUSIVE_LOCK ){
    pFile->eFileLock = PENDING_LOCK;
    pInode->eFileLock = PENDING_LOCK;
  }
 

References unixFile::eFileLock, unixInodeInfo::eFileLock, EXCLUSIVE_LOCK, unixFile::h, unixInodeInfo::nLock, NO_LOCK, unixInodeInfo::nShared, osGetpid, OSTRACE, PENDING_BYTE, PENDING_LOCK, unixFile::pInode, unixInodeInfo::pLockMutex, RESERVED_BYTE, RESERVED_LOCK, SHARED_FIRST, SHARED_LOCK, SHARED_SIZE, sqlite3_mutex_enter(), sqlite3_mutex_leave(), SQLITE_BUSY, SQLITE_IOERR_LOCK, SQLITE_IOERR_UNLOCK, SQLITE_OK, sqliteErrorFromPosixError(), storeLastErrno(), and unixFileLock().

◆ unixLockSharedMemory()

static int unixLockSharedMemory	(	unixFile *	pDbFd,
		unixShmNode *	pShmNode )

static

Definition at line 37973 of file sqlite3.c.

                                                                       {
  struct flock lock;
  int rc = SQLITE_OK;
 
  /* Use F_GETLK to determine the locks other processes are holding
  ** on the DMS byte. If it indicates that another process is holding
  ** a SHARED lock, then this process may also take a SHARED lock
  ** and proceed with opening the *-shm file.
  **
  ** Or, if no other process is holding any lock, then this process
  ** is the first to open it. In this case take an EXCLUSIVE lock on the
  ** DMS byte and truncate the *-shm file to zero bytes in size. Then
  ** downgrade to a SHARED lock on the DMS byte.
  **
  ** If another process is holding an EXCLUSIVE lock on the DMS byte,
  ** return SQLITE_BUSY to the caller (it will try again). An earlier
  ** version of this code attempted the SHARED lock at this point. But
  ** this introduced a subtle race condition: if the process holding
  ** EXCLUSIVE failed just before truncating the *-shm file, then this
  ** process might open and use the *-shm file without truncating it.
  ** And if the *-shm file has been corrupted by a power failure or
  ** system crash, the database itself may also become corrupt.  */
  lock.l_whence = SEEK_SET;
  lock.l_start = UNIX_SHM_DMS;
  lock.l_len = 1;
  lock.l_type = F_WRLCK;
  if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) {
    rc = SQLITE_IOERR_LOCK;
  }else if( lock.l_type==F_UNLCK ){
    if( pShmNode->isReadonly ){
      pShmNode->isUnlocked = 1;
      rc = SQLITE_READONLY_CANTINIT;
    }else{
      rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1);
      /* The first connection to attach must truncate the -shm file.  We
      ** truncate to 3 bytes (an arbitrary small number, less than the
      ** -shm header size) rather than 0 as a system debugging aid, to
      ** help detect if a -shm file truncation is legitimate or is the work
      ** or a rogue process. */
      if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){
        rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename);
      }
    }
  }else if( lock.l_type==F_WRLCK ){
    rc = SQLITE_BUSY;
  }
 

References unixShmNode::hShm, unixShmNode::isReadonly, unixShmNode::isUnlocked, osFcntl, robust_ftruncate(), SQLITE_BUSY, SQLITE_IOERR_LOCK, SQLITE_IOERR_SHMOPEN, SQLITE_OK, SQLITE_READONLY_CANTINIT, UNIX_SHM_DMS, unixLogError, unixShmSystemLock(), and unixShmNode::zFilename.

Referenced by unixOpenSharedMemory(), and unixShmMap().

◆ unixLogErrorAtLine()

static int unixLogErrorAtLine	(	int	errcode,
		const char *	zFunc,
		const char *	zPath,
		int	iLine )

static

Definition at line 34763 of file sqlite3.c.

 {
  char *zErr;                     /* Message from strerror() or equivalent */
  int iErrno = errno;             /* Saved syscall error number */
 
  /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
  ** the strerror() function to obtain the human-readable error message
  ** equivalent to errno. Otherwise, use strerror_r().
  */
#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
  char aErr[80];
  memset(aErr, 0, sizeof(aErr));
  zErr = aErr;
 
  /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
  ** assume that the system provides the GNU version of strerror_r() that
  ** returns a pointer to a buffer containing the error message. That pointer
  ** may point to aErr[], or it may point to some static storage somewhere.
  ** Otherwise, assume that the system provides the POSIX version of
  ** strerror_r(), which always writes an error message into aErr[].
  **
  ** If the code incorrectly assumes that it is the POSIX version that is
  ** available, the error message will often be an empty string. Not a
  ** huge problem. Incorrectly concluding that the GNU version is available
  ** could lead to a segfault though.
  */
#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
  zErr =
# endif
  strerror_r(iErrno, aErr, sizeof(aErr)-1);
 
#elif SQLITE_THREADSAFE
  /* This is a threadsafe build, but strerror_r() is not available. */
  zErr = "";
#else
  /* Non-threadsafe build, use strerror(). */
  zErr = strerror(iErrno);
#endif
 
  if( zPath==0 ) zPath = "";
  sqlite3_log(errcode,

References sqlite3_log().

Referenced by robust_close().

◆ unixModeBit()

static void unixModeBit	(	unixFile *	pFile,
		unsigned char	mask,
		int *	pArg )

static

Definition at line 37462 of file sqlite3.c.

                                                                       {
  if( *pArg<0 ){
    *pArg = (pFile->ctrlFlags & mask)!=0;

References unixFile::ctrlFlags, and mask.

◆ unixNextSystemCall()

static const char * unixNextSystemCall	(	sqlite3_vfs *	p,
		const char *	zName )

static

Definition at line 34175 of file sqlite3.c.

                                                                        {
  int i = -1;
 
  UNUSED_PARAMETER(p);
  if( zName ){
    for(i=0; i<ArraySize(aSyscall)-1; i++){
      if( strcmp(zName, aSyscall[i].zName)==0 ) break;
    }

References ArraySize, aSyscall, UNUSED_PARAMETER, zName, and unix_syscall::zName.

◆ unixOpen()

static int unixOpen	(	sqlite3_vfs *	pVfs,
		const char *	zPath,
		sqlite3_file *	pFile,
		int	flags,
		int *	pOutFlags )

static

Definition at line 39498 of file sqlite3.c.

 {
  unixFile *p = (unixFile *)pFile;
  int fd = -1;                   /* File descriptor returned by open() */
  int openFlags = 0;             /* Flags to pass to open() */
  int eType = flags&0x0FFF00;  /* Type of file to open */
  int noLock;                    /* True to omit locking primitives */
  int rc = SQLITE_OK;            /* Function Return Code */
  int ctrlFlags = 0;             /* UNIXFILE_* flags */
 
  int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
  int isDelete     = (flags & SQLITE_OPEN_DELETEONCLOSE);
  int isCreate     = (flags & SQLITE_OPEN_CREATE);
  int isReadonly   = (flags & SQLITE_OPEN_READONLY);
  int isReadWrite  = (flags & SQLITE_OPEN_READWRITE);
#if SQLITE_ENABLE_LOCKING_STYLE
  int isAutoProxy  = (flags & SQLITE_OPEN_AUTOPROXY);
#endif
#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
  struct statfs fsInfo;
#endif
 
  /* If creating a super- or main-file journal, this function will open
  ** a file-descriptor on the directory too. The first time unixSync()
  ** is called the directory file descriptor will be fsync()ed and close()d.
  */
  int isNewJrnl = (isCreate && (
        eType==SQLITE_OPEN_SUPER_JOURNAL
     || eType==SQLITE_OPEN_MAIN_JOURNAL
     || eType==SQLITE_OPEN_WAL
  ));
 
  /* If argument zPath is a NULL pointer, this function is required to open
  ** a temporary file. Use this buffer to store the file name in.
  */
  char zTmpname[MAX_PATHNAME+2];
  const char *zName = zPath;
 
  /* Check the following statements are true:
  **
  **   (a) Exactly one of the READWRITE and READONLY flags must be set, and
  **   (b) if CREATE is set, then READWRITE must also be set, and
  **   (c) if EXCLUSIVE is set, then CREATE must also be set.
  **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
  */
  assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
  assert(isCreate==0 || isReadWrite);
  assert(isExclusive==0 || isCreate);
  assert(isDelete==0 || isCreate);
 
  /* The main DB, main journal, WAL file and super-journal are never
  ** automatically deleted. Nor are they ever temporary files.  */
  assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
  assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
  assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
  assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
 
  /* Assert that the upper layer has set one of the "file-type" flags. */
  assert( eType==SQLITE_OPEN_MAIN_DB      || eType==SQLITE_OPEN_TEMP_DB
       || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
       || eType==SQLITE_OPEN_SUBJOURNAL   || eType==SQLITE_OPEN_SUPER_JOURNAL
       || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
  );
 
  /* Detect a pid change and reset the PRNG.  There is a race condition
  ** here such that two or more threads all trying to open databases at
  ** the same instant might all reset the PRNG.  But multiple resets
  ** are harmless.
  */
  if( randomnessPid!=osGetpid(0) ){
    randomnessPid = osGetpid(0);
    sqlite3_randomness(0,0);
  }
  memset(p, 0, sizeof(unixFile));
 
  if( eType==SQLITE_OPEN_MAIN_DB ){
    UnixUnusedFd *pUnused;
    pUnused = findReusableFd(zName, flags);
    if( pUnused ){
      fd = pUnused->fd;
    }else{
      pUnused = sqlite3_malloc64(sizeof(*pUnused));
      if( !pUnused ){
        return SQLITE_NOMEM_BKPT;
      }
    }
    p->pPreallocatedUnused = pUnused;
 
    /* Database filenames are double-zero terminated if they are not
    ** URIs with parameters.  Hence, they can always be passed into
    ** sqlite3_uri_parameter(). */
    assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
 
  }else if( !zName ){
    /* If zName is NULL, the upper layer is requesting a temp file. */
    assert(isDelete && !isNewJrnl);
    rc = unixGetTempname(pVfs->mxPathname, zTmpname);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    zName = zTmpname;
 
    /* Generated temporary filenames are always double-zero terminated
    ** for use by sqlite3_uri_parameter(). */
    assert( zName[strlen(zName)+1]==0 );
  }
 
  /* Determine the value of the flags parameter passed to POSIX function
  ** open(). These must be calculated even if open() is not called, as
  ** they may be stored as part of the file handle and used by the
  ** 'conch file' locking functions later on.  */
  if( isReadonly )  openFlags |= O_RDONLY;
  if( isReadWrite ) openFlags |= O_RDWR;
  if( isCreate )    openFlags |= O_CREAT;
  if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
  openFlags |= (O_LARGEFILE|O_BINARY|O_NOFOLLOW);
 
  if( fd<0 ){
    mode_t openMode;              /* Permissions to create file with */
    uid_t uid;                    /* Userid for the file */
    gid_t gid;                    /* Groupid for the file */
    rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
    if( rc!=SQLITE_OK ){
      assert( !p->pPreallocatedUnused );
      assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
      return rc;
    }
    fd = robust_open(zName, openFlags, openMode);
    OSTRACE(("OPENX   %-3d %s 0%o\n", fd, zName, openFlags));
    assert( !isExclusive || (openFlags & O_CREAT)!=0 );
    if( fd<0 ){
      if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){
        /* If unable to create a journal because the directory is not
        ** writable, change the error code to indicate that. */
        rc = SQLITE_READONLY_DIRECTORY;
      }else if( errno!=EISDIR && isReadWrite ){
        /* Failed to open the file for read/write access. Try read-only. */
        flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
        openFlags &= ~(O_RDWR|O_CREAT);
        flags |= SQLITE_OPEN_READONLY;
        openFlags |= O_RDONLY;
        isReadonly = 1;
        fd = robust_open(zName, openFlags, openMode);
      }
    }
    if( fd<0 ){
      int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      if( rc==SQLITE_OK ) rc = rc2;
      goto open_finished;
    }
 
    /* The owner of the rollback journal or WAL file should always be the
    ** same as the owner of the database file.  Try to ensure that this is
    ** the case.  The chown() system call will be a no-op if the current
    ** process lacks root privileges, be we should at least try.  Without
    ** this step, if a root process opens a database file, it can leave
    ** behinds a journal/WAL that is owned by root and hence make the
    ** database inaccessible to unprivileged processes.
    **
    ** If openMode==0, then that means uid and gid are not set correctly
    ** (probably because SQLite is configured to use 8+3 filename mode) and
    ** in that case we do not want to attempt the chown().
    */
    if( openMode && (flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL))!=0 ){
      robustFchown(fd, uid, gid);
    }
  }
  assert( fd>=0 );
  if( pOutFlags ){
    *pOutFlags = flags;
  }
 
  if( p->pPreallocatedUnused ){
    p->pPreallocatedUnused->fd = fd;
    p->pPreallocatedUnused->flags =
                          flags & (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE);
  }
 
  if( isDelete ){
#if OS_VXWORKS
    zPath = zName;
#elif defined(SQLITE_UNLINK_AFTER_CLOSE)
    zPath = sqlite3_mprintf("%s", zName);
    if( zPath==0 ){
      robust_close(p, fd, __LINE__);
      return SQLITE_NOMEM_BKPT;
    }
#else
    osUnlink(zName);
#endif
  }
#if SQLITE_ENABLE_LOCKING_STYLE
  else{
    p->openFlags = openFlags;
  }
#endif
 
#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
  if( fstatfs(fd, &fsInfo) == -1 ){
    storeLastErrno(p, errno);
    robust_close(p, fd, __LINE__);
    return SQLITE_IOERR_ACCESS;
  }
  if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
    ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
  }
  if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) {
    ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
  }
#endif
 
  /* Set up appropriate ctrlFlags */
  if( isDelete )                ctrlFlags |= UNIXFILE_DELETE;
  if( isReadonly )              ctrlFlags |= UNIXFILE_RDONLY;
  noLock = eType!=SQLITE_OPEN_MAIN_DB;
  if( noLock )                  ctrlFlags |= UNIXFILE_NOLOCK;
  if( isNewJrnl )               ctrlFlags |= UNIXFILE_DIRSYNC;
  if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI;
 
#if SQLITE_ENABLE_LOCKING_STYLE
#if SQLITE_PREFER_PROXY_LOCKING
  isAutoProxy = 1;
#endif
  if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
    char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING");
    int useProxy = 0;
 
    /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means
    ** never use proxy, NULL means use proxy for non-local files only.  */
    if( envforce!=NULL ){
      useProxy = atoi(envforce)>0;
    }else{
      useProxy = !(fsInfo.f_flags&MNT_LOCAL);
    }
    if( useProxy ){
      rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
      if( rc==SQLITE_OK ){
        rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
        if( rc!=SQLITE_OK ){
          /* Use unixClose to clean up the resources added in fillInUnixFile
          ** and clear all the structure's references.  Specifically,
          ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
          */
          unixClose(pFile);
          return rc;
        }
      }
      goto open_finished;
    }
  }
#endif
 
  assert( zPath==0 || zPath[0]=='/'
      || eType==SQLITE_OPEN_SUPER_JOURNAL || eType==SQLITE_OPEN_MAIN_JOURNAL
  );
  rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
 

References eType, UnixUnusedFd::fd, findCreateFileMode(), findReusableFd(), UnixUnusedFd::flags, MAX_PATHNAME, sqlite3_vfs::mxPathname, NULL, O_BINARY, O_LARGEFILE, O_NOFOLLOW, osAccess, osGetpid, OSTRACE, osUnlink, unixFile::pPreallocatedUnused, randomnessPid, robust_close(), robust_open(), robustFchown(), sqlite3_free(), sqlite3_malloc64(), sqlite3_mprintf(), sqlite3_randomness(), SQLITE_CANTOPEN_BKPT, SQLITE_FSFLAGS_IS_MSDOS, SQLITE_IOERR_ACCESS, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_AUTOPROXY, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_MAIN_DB, SQLITE_OPEN_MAIN_JOURNAL, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_OPEN_SUBJOURNAL, SQLITE_OPEN_SUPER_JOURNAL, SQLITE_OPEN_TEMP_DB, SQLITE_OPEN_TEMP_JOURNAL, SQLITE_OPEN_TRANSIENT_DB, SQLITE_OPEN_URI, SQLITE_OPEN_WAL, SQLITE_READONLY_DIRECTORY, storeLastErrno(), unixClose(), UNIXFILE_DELETE, UNIXFILE_DIRSYNC, UNIXFILE_NOLOCK, UNIXFILE_RDONLY, UNIXFILE_URI, unixGetTempname(), unixLogError, sqlite3_vfs::xOpen, and zName.

◆ unixOpenSharedMemory()

static int unixOpenSharedMemory ( unixFile * pDbFd )

static

Definition at line 38062 of file sqlite3.c.

                                                {
  struct unixShm *p = 0;          /* The connection to be opened */
  struct unixShmNode *pShmNode;   /* The underlying mmapped file */
  int rc = SQLITE_OK;             /* Result code */
  unixInodeInfo *pInode;          /* The inode of fd */
  char *zShm;             /* Name of the file used for SHM */
  int nShmFilename;               /* Size of the SHM filename in bytes */
 
  /* Allocate space for the new unixShm object. */
  p = sqlite3_malloc64( sizeof(*p) );
  if( p==0 ) return SQLITE_NOMEM_BKPT;
  memset(p, 0, sizeof(*p));
  assert( pDbFd->pShm==0 );
 
  /* Check to see if a unixShmNode object already exists. Reuse an existing
  ** one if present. Create a new one if necessary.
  */
  assert( unixFileMutexNotheld(pDbFd) );
  unixEnterMutex();
  pInode = pDbFd->pInode;
  pShmNode = pInode->pShmNode;
  if( pShmNode==0 ){
    struct stat sStat;                 /* fstat() info for database file */
#ifndef SQLITE_SHM_DIRECTORY
    const char *zBasePath = pDbFd->zPath;
#endif
 
    /* Call fstat() to figure out the permissions on the database file. If
    ** a new *-shm file is created, an attempt will be made to create it
    ** with the same permissions.
    */
    if( osFstat(pDbFd->h, &sStat) ){
      rc = SQLITE_IOERR_FSTAT;
      goto shm_open_err;
    }
 
#ifdef SQLITE_SHM_DIRECTORY
    nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31;
#else
    nShmFilename = 6 + (int)strlen(zBasePath);
#endif
    pShmNode = sqlite3_malloc64( sizeof(*pShmNode) + nShmFilename );
    if( pShmNode==0 ){
      rc = SQLITE_NOMEM_BKPT;
      goto shm_open_err;
    }
    memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename);
    zShm = pShmNode->zFilename = (char*)&pShmNode[1];
#ifdef SQLITE_SHM_DIRECTORY
    sqlite3_snprintf(nShmFilename, zShm,
                     SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
                     (u32)sStat.st_ino, (u32)sStat.st_dev);
#else
    sqlite3_snprintf(nShmFilename, zShm, "%s-shm", zBasePath);
    sqlite3FileSuffix3(pDbFd->zPath, zShm);
#endif
    pShmNode->hShm = -1;
    pDbFd->pInode->pShmNode = pShmNode;
    pShmNode->pInode = pDbFd->pInode;
    if( sqlite3GlobalConfig.bCoreMutex ){
      pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
      if( pShmNode->pShmMutex==0 ){
        rc = SQLITE_NOMEM_BKPT;
        goto shm_open_err;
      }
    }
 
    if( pInode->bProcessLock==0 ){
      if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
        pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW,
                                     (sStat.st_mode&0777));
      }
      if( pShmNode->hShm<0 ){
        pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW,
                                     (sStat.st_mode&0777));
        if( pShmNode->hShm<0 ){
          rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm);
          goto shm_open_err;
        }
        pShmNode->isReadonly = 1;
      }
 
      /* If this process is running as root, make sure that the SHM file
      ** is owned by the same user that owns the original database.  Otherwise,
      ** the original owner will not be able to connect.
      */
      robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid);
 
      rc = unixLockSharedMemory(pDbFd, pShmNode);
      if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
    }
  }
 
  /* Make the new connection a child of the unixShmNode */
  p->pShmNode = pShmNode;
#ifdef SQLITE_DEBUG
  p->id = pShmNode->nextShmId++;
#endif
  pShmNode->nRef++;
  pDbFd->pShm = p;
  unixLeaveMutex();
 
  /* The reference count on pShmNode has already been incremented under
  ** the cover of the unixEnterMutex() mutex and the pointer from the
  ** new (struct unixShm) object to the pShmNode has been set. All that is
  ** left to do is to link the new object into the linked list starting
  ** at pShmNode->pFirst. This must be done while holding the
  ** pShmNode->pShmMutex.
  */
  sqlite3_mutex_enter(pShmNode->pShmMutex);
  p->pNext = pShmNode->pFirst;
  pShmNode->pFirst = p;
  sqlite3_mutex_leave(pShmNode->pShmMutex);
  return rc;
 
  /* Jump here on any error */

References unixInodeInfo::bProcessLock, unixFile::h, unixShmNode::hShm, unixShm::id, unixShmNode::isReadonly, unixShmNode::nRef, O_NOFOLLOW, osFstat, unixShmNode::pFirst, unixFile::pInode, unixShmNode::pInode, unixShm::pNext, unixFile::pShm, unixShmNode::pShmMutex, unixInodeInfo::pShmNode, unixShm::pShmNode, robust_open(), robustFchown(), sqlite3_free(), sqlite3_malloc64(), sqlite3_mutex_alloc(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_snprintf(), sqlite3_uri_boolean(), sqlite3FileSuffix3, sqlite3GlobalConfig, SQLITE_CANTOPEN_BKPT, SQLITE_IOERR_FSTAT, SQLITE_MUTEX_FAST, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_READONLY_CANTINIT, unixEnterMutex(), unixLeaveMutex(), unixLockSharedMemory(), unixLogError, unixShmPurge(), unixShmNode::zFilename, and unixFile::zPath.

Referenced by unixShmMap().

◆ unixRandomness()

static int unixRandomness	(	sqlite3_vfs *	NotUsed,
		int	nBuf,
		char *	zBuf )

static

Definition at line 40031 of file sqlite3.c.

                                                                     {
  UNUSED_PARAMETER(NotUsed);
  assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
 
  /* We have to initialize zBuf to prevent valgrind from reporting
  ** errors.  The reports issued by valgrind are incorrect - we would
  ** prefer that the randomness be increased by making use of the
  ** uninitialized space in zBuf - but valgrind errors tend to worry
  ** some users.  Rather than argue, it seems easier just to initialize
  ** the whole array and silence valgrind, even if that means less randomness
  ** in the random seed.
  **
  ** When testing, initializing zBuf[] to zero is all we do.  That means
  ** that we always use the same random number sequence.  This makes the
  ** tests repeatable.
  */
  memset(zBuf, 0, nBuf);
  randomnessPid = osGetpid(0);
#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS)
  {
    int fd, got;
    fd = robust_open("/dev/urandom", O_RDONLY, 0);
    if( fd<0 ){
      time_t t;
      time(&t);
      memcpy(zBuf, &t, sizeof(t));
      memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid));
      assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
      nBuf = sizeof(t) + sizeof(randomnessPid);
    }else{
      do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR );

References osGetpid, osRead, randomnessPid, robust_close(), robust_open(), and UNUSED_PARAMETER.

◆ unixRead()

static int unixRead	(	sqlite3_file *	id,
		void *	pBuf,
		int	amt,
		sqlite3_int64	offset )

static

Definition at line 36873 of file sqlite3.c.

 {
  unixFile *pFile = (unixFile *)id;
  int got;
  assert( id );
  assert( offset>=0 );
  assert( amt>0 );
 
  /* If this is a database file (not a journal, super-journal or temp
  ** file), the bytes in the locking range should never be read or written. */
#if 0
  assert( pFile->pPreallocatedUnused==0
       || offset>=PENDING_BYTE+512
       || offset+amt<=PENDING_BYTE
  );
#endif
 
#if SQLITE_MAX_MMAP_SIZE>0
  /* Deal with as much of this read request as possible by transfering
  ** data from the memory mapping using memcpy().  */
  if( offset<pFile->mmapSize ){
    if( offset+amt <= pFile->mmapSize ){
      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
      return SQLITE_OK;
    }else{
      int nCopy = pFile->mmapSize - offset;
      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
      pBuf = &((u8 *)pBuf)[nCopy];
      amt -= nCopy;
      offset += nCopy;
    }
  }
#endif
 
  got = seekAndRead(pFile, offset, pBuf, amt);
  if( got==amt ){
    return SQLITE_OK;
  }else if( got<0 ){
    /* lastErrno set by seekAndRead */
    return SQLITE_IOERR_READ;
  }else{

References PENDING_BYTE, unixFile::pPreallocatedUnused, seekAndRead(), SQLITE_IOERR_READ, SQLITE_IOERR_SHORT_READ, SQLITE_OK, and storeLastErrno().

◆ unixSectorSize()

static int unixSectorSize ( sqlite3_file * id )

static

Definition at line 37711 of file sqlite3.c.

References unixFile::sectorSize, and setDeviceCharacteristics().

◆ unixSetSystemCall()

static int unixSetSystemCall	(	sqlite3_vfs *	pNotUsed,
		const char *	zName,
		sqlite3_syscall_ptr	pNewFunc )

static

Definition at line 34113 of file sqlite3.c.

 {
  unsigned int i;
  int rc = SQLITE_NOTFOUND;
 
  UNUSED_PARAMETER(pNotUsed);
  if( zName==0 ){
    /* If no zName is given, restore all system calls to their default
    ** settings and return NULL
    */
    rc = SQLITE_OK;
    for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
      if( aSyscall[i].pDefault ){
        aSyscall[i].pCurrent = aSyscall[i].pDefault;
      }
    }
  }else{
    /* If zName is specified, operate on only the one system call
    ** specified.
    */
    for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
      if( strcmp(zName, aSyscall[i].zName)==0 ){
        if( aSyscall[i].pDefault==0 ){
          aSyscall[i].pDefault = aSyscall[i].pCurrent;
        }
        rc = SQLITE_OK;
        if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
        aSyscall[i].pCurrent = pNewFunc;

References aSyscall, unix_syscall::pCurrent, unix_syscall::pDefault, SQLITE_NOTFOUND, SQLITE_OK, UNUSED_PARAMETER, and zName.

◆ unixShmBarrier()

static void unixShmBarrier ( sqlite3_file * fd )

static

Definition at line 38481 of file sqlite3.c.

 {
  UNUSED_PARAMETER(fd);
  sqlite3MemoryBarrier();         /* compiler-defined memory barrier */

References nolockLock(), sqlite3_file::pMethods, sqlite3MemoryBarrier(), unixEnterMutex(), unixLeaveMutex(), UNUSED_PARAMETER, and sqlite3_io_methods::xLock.

◆ unixShmLock()

static int unixShmLock	(	sqlite3_file *	fd,
		int	ofst,
		int	n,
		int	flags )

static

Definition at line 38347 of file sqlite3.c.

 {
  unixFile *pDbFd = (unixFile*)fd;      /* Connection holding shared memory */
  unixShm *p = pDbFd->pShm;             /* The shared memory being locked */
  unixShm *pX;                          /* For looping over all siblings */
  unixShmNode *pShmNode = p->pShmNode;  /* The underlying file iNode */
  int rc = SQLITE_OK;                   /* Result code */
  u16 mask;                             /* Mask of locks to take or release */
 
  assert( pShmNode==pDbFd->pInode->pShmNode );
  assert( pShmNode->pInode==pDbFd->pInode );
  assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
  assert( n>=1 );
  assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
       || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
       || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
       || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
  assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
 
  /* Check that, if this to be a blocking lock, no locks that occur later
  ** in the following list than the lock being obtained are already held:
  **
  **   1. Checkpointer lock (ofst==1).
  **   2. Write lock (ofst==0).
  **   3. Read locks (ofst>=3 && ofst<SQLITE_SHM_NLOCK).
  **
  ** In other words, if this is a blocking lock, none of the locks that
  ** occur later in the above list than the lock being obtained may be
  ** held.
  **
  ** It is not permitted to block on the RECOVER lock.
  */
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  assert( (flags & SQLITE_SHM_UNLOCK) || pDbFd->iBusyTimeout==0 || (
         (ofst!=2)                                   /* not RECOVER */
      && (ofst!=1 || (p->exclMask|p->sharedMask)==0)
      && (ofst!=0 || (p->exclMask|p->sharedMask)<3)
      && (ofst<3  || (p->exclMask|p->sharedMask)<(1<<ofst))
  ));
#endif
 
  mask = (1<<(ofst+n)) - (1<<ofst);
  assert( n>1 || mask==(1<<ofst) );
  sqlite3_mutex_enter(pShmNode->pShmMutex);
  if( flags & SQLITE_SHM_UNLOCK ){
    u16 allMask = 0; /* Mask of locks held by siblings */
 
    /* See if any siblings hold this same lock */
    for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
      if( pX==p ) continue;
      assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
      allMask |= pX->sharedMask;
    }
 
    /* Unlock the system-level locks */
    if( (mask & allMask)==0 ){
      rc = unixShmSystemLock(pDbFd, F_UNLCK, ofst+UNIX_SHM_BASE, n);
    }else{
      rc = SQLITE_OK;
    }
 
    /* Undo the local locks */
    if( rc==SQLITE_OK ){
      p->exclMask &= ~mask;
      p->sharedMask &= ~mask;
    }
  }else if( flags & SQLITE_SHM_SHARED ){
    u16 allShared = 0;  /* Union of locks held by connections other than "p" */
 
    /* Find out which shared locks are already held by sibling connections.
    ** If any sibling already holds an exclusive lock, go ahead and return
    ** SQLITE_BUSY.
    */
    for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
      if( (pX->exclMask & mask)!=0 ){
        rc = SQLITE_BUSY;
        break;
      }
      allShared |= pX->sharedMask;
    }
 
    /* Get shared locks at the system level, if necessary */
    if( rc==SQLITE_OK ){
      if( (allShared & mask)==0 ){
        rc = unixShmSystemLock(pDbFd, F_RDLCK, ofst+UNIX_SHM_BASE, n);
      }else{
        rc = SQLITE_OK;
      }
    }
 
    /* Get the local shared locks */
    if( rc==SQLITE_OK ){
      p->sharedMask |= mask;
    }
  }else{
    /* Make sure no sibling connections hold locks that will block this
    ** lock.  If any do, return SQLITE_BUSY right away.
    */
    for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
      if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
        rc = SQLITE_BUSY;
        break;
      }
    }
 
    /* Get the exclusive locks at the system level.  Then if successful
    ** also mark the local connection as being locked.
    */
    if( rc==SQLITE_OK ){
      rc = unixShmSystemLock(pDbFd, F_WRLCK, ofst+UNIX_SHM_BASE, n);
      if( rc==SQLITE_OK ){
        assert( (p->sharedMask & mask)==0 );
        p->exclMask |= mask;
      }
    }

References unixInodeInfo::bProcessLock, unixShm::exclMask, unixShmNode::hShm, unixShm::id, mask, osGetpid, OSTRACE, unixShmNode::pFirst, unixFile::pInode, unixShmNode::pInode, unixShm::pNext, unixFile::pShm, unixShmNode::pShmMutex, unixInodeInfo::pShmNode, unixShm::pShmNode, unixShm::sharedMask, sqlite3_mutex_enter(), sqlite3_mutex_leave(), SQLITE_BUSY, SQLITE_OK, SQLITE_SHM_EXCLUSIVE, SQLITE_SHM_LOCK, SQLITE_SHM_NLOCK, SQLITE_SHM_SHARED, SQLITE_SHM_UNLOCK, UNIX_SHM_BASE, and unixShmSystemLock().

◆ unixShmMap()

static int unixShmMap	(	sqlite3_file *	fd,
		int	iRegion,
		int	szRegion,
		int	bExtend,
		void volatile **	pp )

static

Definition at line 38204 of file sqlite3.c.

 {
  unixFile *pDbFd = (unixFile*)fd;
  unixShm *p;
  unixShmNode *pShmNode;
  int rc = SQLITE_OK;
  int nShmPerMap = unixShmRegionPerMap();
  int nReqRegion;
 
  /* If the shared-memory file has not yet been opened, open it now. */
  if( pDbFd->pShm==0 ){
    rc = unixOpenSharedMemory(pDbFd);
    if( rc!=SQLITE_OK ) return rc;
  }
 
  p = pDbFd->pShm;
  pShmNode = p->pShmNode;
  sqlite3_mutex_enter(pShmNode->pShmMutex);
  if( pShmNode->isUnlocked ){
    rc = unixLockSharedMemory(pDbFd, pShmNode);
    if( rc!=SQLITE_OK ) goto shmpage_out;
    pShmNode->isUnlocked = 0;
  }
  assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
  assert( pShmNode->pInode==pDbFd->pInode );
  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
 
  /* Minimum number of regions required to be mapped. */
  nReqRegion = ((iRegion+nShmPerMap) / nShmPerMap) * nShmPerMap;
 
  if( pShmNode->nRegion<nReqRegion ){
    char **apNew;                      /* New apRegion[] array */
    int nByte = nReqRegion*szRegion;   /* Minimum required file size */
    struct stat sStat;                 /* Used by fstat() */
 
    pShmNode->szRegion = szRegion;
 
    if( pShmNode->hShm>=0 ){
      /* The requested region is not mapped into this processes address space.
      ** Check to see if it has been allocated (i.e. if the wal-index file is
      ** large enough to contain the requested region).
      */
      if( osFstat(pShmNode->hShm, &sStat) ){
        rc = SQLITE_IOERR_SHMSIZE;
        goto shmpage_out;
      }
 
      if( sStat.st_size<nByte ){
        /* The requested memory region does not exist. If bExtend is set to
        ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
        */
        if( !bExtend ){
          goto shmpage_out;
        }
 
        /* Alternatively, if bExtend is true, extend the file. Do this by
        ** writing a single byte to the end of each (OS) page being
        ** allocated or extended. Technically, we need only write to the
        ** last page in order to extend the file. But writing to all new
        ** pages forces the OS to allocate them immediately, which reduces
        ** the chances of SIGBUS while accessing the mapped region later on.
        */
        else{
          static const int pgsz = 4096;
          int iPg;
 
          /* Write to the last byte of each newly allocated or extended page */
          assert( (nByte % pgsz)==0 );
          for(iPg=(sStat.st_size/pgsz); iPg<(nByte/pgsz); iPg++){
            int x = 0;
            if( seekAndWriteFd(pShmNode->hShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){
              const char *zFile = pShmNode->zFilename;
              rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile);
              goto shmpage_out;
            }
          }
        }
      }
    }
 
    /* Map the requested memory region into this processes address space. */
    apNew = (char **)sqlite3_realloc(
        pShmNode->apRegion, nReqRegion*sizeof(char *)
    );
    if( !apNew ){
      rc = SQLITE_IOERR_NOMEM_BKPT;
      goto shmpage_out;
    }
    pShmNode->apRegion = apNew;
    while( pShmNode->nRegion<nReqRegion ){
      int nMap = szRegion*nShmPerMap;
      int i;
      void *pMem;
      if( pShmNode->hShm>=0 ){
        pMem = osMmap(0, nMap,
            pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
            MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion
        );
        if( pMem==MAP_FAILED ){
          rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
          goto shmpage_out;
        }
      }else{
        pMem = sqlite3_malloc64(nMap);
        if( pMem==0 ){
          rc = SQLITE_NOMEM_BKPT;
          goto shmpage_out;
        }
        memset(pMem, 0, nMap);
      }
 
      for(i=0; i<nShmPerMap; i++){
        pShmNode->apRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i];
      }
      pShmNode->nRegion += nShmPerMap;
    }
  }
 
shmpage_out:
  if( pShmNode->nRegion>iRegion ){
    *pp = pShmNode->apRegion[iRegion];
  }else{

References unixShmNode::apRegion, unixInodeInfo::bProcessLock, unixShmNode::hShm, unixShmNode::isReadonly, unixShmNode::isUnlocked, unixShmNode::nRegion, osFstat, osMmap, unixFile::pInode, unixShmNode::pInode, unixFile::pShm, unixShmNode::pShmMutex, unixShm::pShmNode, seekAndWriteFd(), sqlite3_malloc64(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_realloc(), SQLITE_IOERR_NOMEM_BKPT, SQLITE_IOERR_SHMMAP, SQLITE_IOERR_SHMSIZE, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_READONLY, unixShmNode::szRegion, unixLockSharedMemory(), unixLogError, unixOpenSharedMemory(), unixShmRegionPerMap(), and unixShmNode::zFilename.

◆ unixShmPurge()

static void unixShmPurge ( unixFile * pFd )

static

Definition at line 37939 of file sqlite3.c.

                                       {
  unixShmNode *p = pFd->pInode->pShmNode;
  assert( unixMutexHeld() );
  if( p && ALWAYS(p->nRef==0) ){
    int nShmPerMap = unixShmRegionPerMap();
    int i;
    assert( p->pInode==pFd->pInode );
    sqlite3_mutex_free(p->pShmMutex);
    for(i=0; i<p->nRegion; i+=nShmPerMap){
      if( p->hShm>=0 ){
        osMunmap(p->apRegion[i], p->szRegion);
      }else{
        sqlite3_free(p->apRegion[i]);
      }
    }
    sqlite3_free(p->apRegion);
    if( p->hShm>=0 ){
      robust_close(pFd, p->hShm, __LINE__);

References ALWAYS, unixShmNode::apRegion, unixShmNode::hShm, unixShmNode::nRef, unixShmNode::nRegion, osMunmap, unixFile::pInode, unixShmNode::pInode, unixShmNode::pShmMutex, unixInodeInfo::pShmNode, robust_close(), sqlite3_free(), sqlite3_mutex_free(), unixShmNode::szRegion, and unixShmRegionPerMap().

Referenced by unixOpenSharedMemory(), and unixShmUnmap().

◆ unixShmRegionPerMap()

static int unixShmRegionPerMap ( void )

static

Definition at line 37925 of file sqlite3.c.

37931 {

References osGetpagesize.

Referenced by unixShmMap(), and unixShmPurge().

◆ unixShmSystemLock()

static int unixShmSystemLock	(	unixFile *	pFile,
		int	lockType,
		int	ofst,
		int	n )

static

Definition at line 37840 of file sqlite3.c.

 {
  unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */
  struct flock f;        /* The posix advisory locking structure */
  int rc = SQLITE_OK;    /* Result code form fcntl() */
 
  /* Access to the unixShmNode object is serialized by the caller */
  pShmNode = pFile->pInode->pShmNode;
  assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) );
  assert( pShmNode->nRef>0 || unixMutexHeld() );
 
  /* Shared locks never span more than one byte */
  assert( n==1 || lockType!=F_RDLCK );
 
  /* Locks are within range */
  assert( n>=1 && n<=SQLITE_SHM_NLOCK );
 
  if( pShmNode->hShm>=0 ){
    int res;
    /* Initialize the locking parameters */
    f.l_type = lockType;
    f.l_whence = SEEK_SET;
    f.l_start = ofst;
    f.l_len = n;
    res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile);
    if( res==-1 ){
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
      rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
#else
      rc = SQLITE_BUSY;
#endif
    }
  }
 
  /* Update the global lock state and do debug tracing */
#ifdef SQLITE_DEBUG
  { u16 mask;
  OSTRACE(("SHM-LOCK "));
  mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<<ofst);
  if( rc==SQLITE_OK ){
    if( lockType==F_UNLCK ){
      OSTRACE(("unlock %d ok", ofst));
      pShmNode->exclMask &= ~mask;
      pShmNode->sharedMask &= ~mask;
    }else if( lockType==F_RDLCK ){
      OSTRACE(("read-lock %d ok", ofst));
      pShmNode->exclMask &= ~mask;
      pShmNode->sharedMask |= mask;
    }else{
      assert( lockType==F_WRLCK );
      OSTRACE(("write-lock %d ok", ofst));
      pShmNode->exclMask |= mask;
      pShmNode->sharedMask &= ~mask;
    }
  }else{
    if( lockType==F_UNLCK ){
      OSTRACE(("unlock %d failed", ofst));
    }else if( lockType==F_RDLCK ){
      OSTRACE(("read-lock failed"));
    }else{
      assert( lockType==F_WRLCK );
      OSTRACE(("write-lock %d failed", ofst));
    }
  }
  OSTRACE((" - afterwards %03x,%03x\n",

References unixShmNode::hShm, mask, unixShmNode::nRef, osSetPosixAdvisoryLock, OSTRACE, unixFile::pInode, unixShmNode::pShmMutex, unixInodeInfo::pShmNode, sqlite3_mutex_held(), SQLITE_BUSY, SQLITE_BUSY_TIMEOUT, SQLITE_OK, and SQLITE_SHM_NLOCK.

Referenced by unixLockSharedMemory(), and unixShmLock().

◆ unixShmUnmap()

static int unixShmUnmap	(	sqlite3_file *	fd,
		int	deleteFlag )

static

Definition at line 38500 of file sqlite3.c.

 {
  unixShm *p;                     /* The connection to be closed */
  unixShmNode *pShmNode;          /* The underlying shared-memory file */
  unixShm **pp;                   /* For looping over sibling connections */
  unixFile *pDbFd;                /* The underlying database file */
 
  pDbFd = (unixFile*)fd;
  p = pDbFd->pShm;
  if( p==0 ) return SQLITE_OK;
  pShmNode = p->pShmNode;
 
  assert( pShmNode==pDbFd->pInode->pShmNode );
  assert( pShmNode->pInode==pDbFd->pInode );
 
  /* Remove connection p from the set of connections associated
  ** with pShmNode */
  sqlite3_mutex_enter(pShmNode->pShmMutex);
  for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
  *pp = p->pNext;
 
  /* Free the connection p */
  sqlite3_free(p);
  pDbFd->pShm = 0;
  sqlite3_mutex_leave(pShmNode->pShmMutex);
 
  /* If pShmNode->nRef has reached 0, then close the underlying
  ** shared-memory file, too */
  assert( unixFileMutexNotheld(pDbFd) );
  unixEnterMutex();
  assert( pShmNode->nRef>0 );
  pShmNode->nRef--;
  if( pShmNode->nRef==0 ){
    if( deleteFlag && pShmNode->hShm>=0 ){
      osUnlink(pShmNode->zFilename);
    }

References unixShmNode::hShm, unixShmNode::nRef, osUnlink, unixShmNode::pFirst, unixFile::pInode, unixShmNode::pInode, unixShm::pNext, unixFile::pShm, unixShmNode::pShmMutex, unixInodeInfo::pShmNode, unixShm::pShmNode, sqlite3_free(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), SQLITE_OK, unixEnterMutex(), unixLeaveMutex(), unixShmPurge(), and unixShmNode::zFilename.

◆ unixSleep()

static int unixSleep	(	sqlite3_vfs *	NotUsed,
		int	microseconds )

static

Definition at line 40078 of file sqlite3.c.

                                                            {
#if OS_VXWORKS
  struct timespec sp;
 
  sp.tv_sec = microseconds / 1000000;
  sp.tv_nsec = (microseconds % 1000000) * 1000;
  nanosleep(&sp, NULL);
  UNUSED_PARAMETER(NotUsed);
  return microseconds;
#elif defined(HAVE_USLEEP) && HAVE_USLEEP
  usleep(microseconds);
  UNUSED_PARAMETER(NotUsed);
  return microseconds;
#else

References NULL, and UNUSED_PARAMETER.

◆ unixSync()

static int unixSync	(	sqlite3_file *	id,
		int	flags )

static

Definition at line 37255 of file sqlite3.c.

                                                {
  int rc;
  unixFile *pFile = (unixFile*)id;
 
  int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
  int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
 
  /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
  assert((flags&0x0F)==SQLITE_SYNC_NORMAL
      || (flags&0x0F)==SQLITE_SYNC_FULL
  );
 
  /* Unix cannot, but some systems may return SQLITE_FULL from here. This
  ** line is to test that doing so does not cause any problems.
  */
  SimulateDiskfullError( return SQLITE_FULL );
 
  assert( pFile );
  OSTRACE(("SYNC    %-3d\n", pFile->h));
  rc = full_fsync(pFile->h, isFullsync, isDataOnly);
  SimulateIOError( rc=1 );
  if( rc ){
    storeLastErrno(pFile, errno);
    return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
  }
 
  /* Also fsync the directory containing the file if the DIRSYNC flag
  ** is set.  This is a one-time occurrence.  Many systems (examples: AIX)
  ** are unable to fsync a directory, so ignore errors on the fsync.
  */
  if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
    int dirfd;
    OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
            HAVE_FULLFSYNC, isFullsync));
    rc = osOpenDirectory(pFile->zPath, &dirfd);
    if( rc==SQLITE_OK ){
      full_fsync(dirfd, 0, 0);
      robust_close(pFile, dirfd, __LINE__);
    }else{
      assert( rc==SQLITE_CANTOPEN );

References unixFile::ctrlFlags, full_fsync(), unixFile::h, HAVE_FULLFSYNC, osOpenDirectory, OSTRACE, robust_close(), SimulateDiskfullError, SimulateIOError, SQLITE_CANTOPEN, SQLITE_FULL, SQLITE_IOERR_FSYNC, SQLITE_OK, SQLITE_SYNC_DATAONLY, SQLITE_SYNC_FULL, SQLITE_SYNC_NORMAL, storeLastErrno(), UNIXFILE_DIRSYNC, unixLogError, and unixFile::zPath.

◆ unixTempFileDir()

static const char * unixTempFileDir ( void )

static

Definition at line 39248 of file sqlite3.c.

                                        {
  static const char *azDirs[] = {
     0,
     0,
     "/var/tmp",
     "/usr/tmp",
     "/tmp",
     "."
  };
  unsigned int i = 0;
  struct stat buf;
  const char *zDir = sqlite3_temp_directory;
 
  if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR");
  if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
  while(1){
    if( zDir!=0
     && osStat(zDir, &buf)==0
     && S_ISDIR(buf.st_mode)
     && osAccess(zDir, 03)==0
    ){
      return zDir;

Referenced by unixGetTempname().

◆ unixTruncate()

static int unixTruncate	(	sqlite3_file *	id,
		i64	nByte )

static

Definition at line 37305 of file sqlite3.c.

                                                    {
  unixFile *pFile = (unixFile *)id;
  int rc;
  assert( pFile );
  SimulateIOError( return SQLITE_IOERR_TRUNCATE );
 
  /* If the user has configured a chunk-size for this file, truncate the
  ** file so that it consists of an integer number of chunks (i.e. the
  ** actual file size after the operation may be larger than the requested
  ** size).
  */
  if( pFile->szChunk>0 ){
    nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
  }
 
  rc = robust_ftruncate(pFile->h, nByte);
  if( rc ){
    storeLastErrno(pFile, errno);
    return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
  }else{
#ifdef SQLITE_DEBUG
    /* If we are doing a normal write to a database file (as opposed to
    ** doing a hot-journal rollback or a write to some file other than a
    ** normal database file) and we truncate the file to zero length,
    ** that effectively updates the change counter.  This might happen
    ** when restoring a database using the backup API from a zero-length
    ** source.
    */
    if( pFile->inNormalWrite && nByte==0 ){
      pFile->transCntrChng = 1;
    }
#endif
 
#if SQLITE_MAX_MMAP_SIZE>0
    /* If the file was just truncated to a size smaller than the currently
    ** mapped region, reduce the effective mapping size as well. SQLite will
    ** use read() and write() to access data beyond this point from now on.
    */
    if( nByte<pFile->mmapSize ){
      pFile->mmapSize = nByte;

◆ unixUnfetch()

static int unixUnfetch	(	sqlite3_file *	fd,
		i64	iOff,
		void *	p )

static

Definition at line 38742 of file sqlite3.c.

                                                           {
#if SQLITE_MAX_MMAP_SIZE>0
  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */
  UNUSED_PARAMETER(iOff);
 
  /* If p==0 (unmap the entire file) then there must be no outstanding
  ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference),
  ** then there must be at least one outstanding.  */
  assert( (p==0)==(pFd->nFetchOut==0) );
 
  /* If p!=0, it must match the iOff value. */
  assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
 
  if( p ){
    pFd->nFetchOut--;
  }else{
    unixUnmapfile(pFd);
  }
 
  assert( pFd->nFetchOut>=0 );
#else

References SQLITE_OK, and UNUSED_PARAMETER.

◆ unixUnlock()

static int unixUnlock	(	sqlite3_file *	id,
		int	eFileLock )

static

Definition at line 35606 of file sqlite3.c.

References posixUnlock(), and SHARED_LOCK.

◆ unixWrite()

static int unixWrite	(	sqlite3_file *	id,
		const void *	pBuf,
		int	amt,
		sqlite3_int64	offset )

static

Definition at line 36987 of file sqlite3.c.

 {
  unixFile *pFile = (unixFile*)id;
  int wrote = 0;
  assert( id );
  assert( amt>0 );
 
  /* If this is a database file (not a journal, super-journal or temp
  ** file), the bytes in the locking range should never be read or written. */
#if 0
  assert( pFile->pPreallocatedUnused==0
       || offset>=PENDING_BYTE+512
       || offset+amt<=PENDING_BYTE
  );
#endif
 
#ifdef SQLITE_DEBUG
  /* If we are doing a normal write to a database file (as opposed to
  ** doing a hot-journal rollback or a write to some file other than a
  ** normal database file) then record the fact that the database
  ** has changed.  If the transaction counter is modified, record that
  ** fact too.
  */
  if( pFile->inNormalWrite ){
    pFile->dbUpdate = 1;  /* The database has been modified */
    if( offset<=24 && offset+amt>=27 ){
      int rc;
      char oldCntr[4];
      SimulateIOErrorBenign(1);
      rc = seekAndRead(pFile, 24, oldCntr, 4);
      SimulateIOErrorBenign(0);
      if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
        pFile->transCntrChng = 1;  /* The transaction counter has changed */
      }
    }
  }
#endif
 
#if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0
  /* Deal with as much of this write request as possible by transfering
  ** data from the memory mapping using memcpy().  */
  if( offset<pFile->mmapSize ){
    if( offset+amt <= pFile->mmapSize ){
      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
      return SQLITE_OK;
    }else{
      int nCopy = pFile->mmapSize - offset;
      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
      pBuf = &((u8 *)pBuf)[nCopy];
      amt -= nCopy;
      offset += nCopy;
    }
  }
#endif
 
  while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
    amt -= wrote;
    offset += wrote;
    pBuf = &((char*)pBuf)[wrote];
  }
  SimulateIOError(( wrote=(-1), amt=1 ));
  SimulateDiskfullError(( wrote=0, amt=1 ));
 
  if( amt>wrote ){
    if( wrote<0 && pFile->lastErrno!=ENOSPC ){
      /* lastErrno set by seekAndWrite */
      return SQLITE_IOERR_WRITE;
    }else{
      storeLastErrno(pFile, 0); /* not a system error */

References PENDING_BYTE, unixFile::pPreallocatedUnused, seekAndRead(), seekAndWrite(), SimulateDiskfullError, SimulateIOError, SimulateIOErrorBenign, SQLITE_FULL, SQLITE_IOERR_WRITE, SQLITE_OK, and storeLastErrno().

◆ unlockBtreeIfUnused()

static void unlockBtreeIfUnused ( BtShared * pBt )

static

Definition at line 67745 of file sqlite3.c.

                                              {
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
  if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
    MemPage *pPage1 = pBt->pPage1;

References MemPage::aData, BtShared::inTransaction, BtShared::mutex, BtShared::pPage1, BtShared::pPager, releasePageOne(), sqlite3_mutex_held(), and TRANS_NONE.

Referenced by sqlite3BtreeBeginTrans().

◆ unlockBtreeMutex()

static void SQLITE_NOINLINE unlockBtreeMutex ( Btree * p )

static

Definition at line 64207 of file sqlite3.c.

                                                      {
  BtShared *pBt = p->pBt;
  assert( p->locked==1 );
  assert( sqlite3_mutex_held(pBt->mutex) );

Referenced by btreeLockCarefully().

◆ unmapColumnIdlistNames()

static void unmapColumnIdlistNames	(	Parse *	pParse,
		IdList *	pIdList )

static

Definition at line 106572 of file sqlite3.c.

106581 {

106582 if( pIdList ){

◆ unsetJoinExpr()

static void unsetJoinExpr	(	Expr *	p,
		int	iTable )

static

Definition at line 129697 of file sqlite3.c.

                                              {
  while( p ){
    if( ExprHasProperty(p, EP_FromJoin)
     && (iTable<0 || p->iRightJoinTable==iTable) ){
      ExprClearProperty(p, EP_FromJoin);
    }
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);

References ExprList::a, EP_FromJoin, ExprClearProperty, ExprHasProperty, ExprList::nExpr, Expr::op, ExprList::ExprList_item::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, TK_FUNCTION, unsetJoinExpr(), and Expr::x.

Referenced by pushDownWhereTerms(), sqlite3Select(), and unsetJoinExpr().

◆ updateAccumulator()

static void updateAccumulator	(	Parse *	pParse,
		int	regAcc,
		AggInfo *	pAggInfo )

static

Definition at line 134752 of file sqlite3.c.

                                                                           {
  Vdbe *v = pParse->pVdbe;
  int i;
  int regHit = 0;
  int addrHitTest = 0;
  struct AggInfo_func *pF;
  struct AggInfo_col *pC;
 
  pAggInfo->directMode = 1;
  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
    int nArg;
    int addrNext = 0;
    int regAgg;
    ExprList *pList = pF->pFExpr->x.pList;
    assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
    assert( !IsWindowFunc(pF->pFExpr) );
    if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){
      Expr *pFilter = pF->pFExpr->y.pWin->pFilter;
      if( pAggInfo->nAccumulator
       && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
       && regAcc
      ){
        /* If regAcc==0, there there exists some min() or max() function
        ** without a FILTER clause that will ensure the magnet registers
        ** are populated. */
        if( regHit==0 ) regHit = ++pParse->nMem;
        /* If this is the first row of the group (regAcc contains 0), clear the
        ** "magnet" register regHit so that the accumulator registers
        ** are populated if the FILTER clause jumps over the the
        ** invocation of min() or max() altogether. Or, if this is not
        ** the first row (regAcc contains 1), set the magnet register so that
        ** the accumulators are not populated unless the min()/max() is invoked
        ** and indicates that they should be.  */
        sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit);
      }
      addrNext = sqlite3VdbeMakeLabel(pParse);
      sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL);
    }
    if( pList ){
      nArg = pList->nExpr;
      regAgg = sqlite3GetTempRange(pParse, nArg);
      sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
    }else{
      nArg = 0;
      regAgg = 0;
    }
    if( pF->iDistinct>=0 ){
      if( addrNext==0 ){
        addrNext = sqlite3VdbeMakeLabel(pParse);
      }
      testcase( nArg==0 );  /* Error condition */
      testcase( nArg>1 );   /* Also an error */
      codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
    }
    if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
      CollSeq *pColl = 0;
      struct ExprList_item *pItem;
      int j;
      assert( pList!=0 );  /* pList!=0 if pF->pFunc has NEEDCOLL */
      for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
        pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
      }
      if( !pColl ){
        pColl = pParse->db->pDfltColl;
      }
      if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
      sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
    }
    sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);
    sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
    sqlite3VdbeChangeP5(v, (u8)nArg);
    sqlite3ReleaseTempRange(pParse, regAgg, nArg);
    if( addrNext ){
      sqlite3VdbeResolveLabel(v, addrNext);
    }
  }
  if( regHit==0 && pAggInfo->nAccumulator ){
    regHit = regAcc;
  }
  if( regHit ){
    addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
  }
  for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
    sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem);
  }

References ExprList::a, AggInfo::aCol, AggInfo::aFunc, codeDistinct(), Parse::db, AggInfo::directMode, EP_WinFunc, EP_xIsSelect, ExprHasProperty, IsWindowFunc, AggInfo::nAccumulator, ExprList::nExpr, AggInfo::nFunc, Parse::nMem, OP_AggStep, OP_CollSeq, OP_Copy, OP_If, P4_COLLSEQ, P4_FUNCDEF, sqlite3::pDfltColl, Window::pFilter, Parse::pVdbe, Expr::pWin, sqlite3ExprCode(), sqlite3ExprCodeExprList(), sqlite3ExprCollSeq(), sqlite3ExprIfFalse(), sqlite3GetTempRange(), sqlite3ReleaseTempRange(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeJumpHereOrPopInst(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), SQLITE_ECEL_DUP, SQLITE_FUNC_NEEDCOLL, SQLITE_JUMPIFNULL, testcase, VdbeCoverage, and Expr::y.

Referenced by sqlite3Select().

◆ updateFromSelect()

static void updateFromSelect	(	Parse *	pParse,
		int	iEph,
		Index *	pPk,
		ExprList *	pChanges,
		SrcList *	pTabList,
		Expr *	pWhere,
		ExprList *	pOrderBy,
		Expr *	pLimit )

static

Definition at line 137778 of file sqlite3.c.

 {
  int i;
  SelectDest dest;
  Select *pSelect = 0;
  ExprList *pList = 0;
  ExprList *pGrp = 0;
  Expr *pLimit2 = 0;
  ExprList *pOrderBy2 = 0;
  sqlite3 *db = pParse->db;
  Table *pTab = pTabList->a[0].pTab;
  SrcList *pSrc;
  Expr *pWhere2;
  int eDest;
 
#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
  if( pOrderBy && pLimit==0 ) {
    sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE");
    return;
  }
  pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0);
  pLimit2 = sqlite3ExprDup(db, pLimit, 0);
#else
  UNUSED_PARAMETER(pOrderBy);
  UNUSED_PARAMETER(pLimit);
#endif
 
  pSrc = sqlite3SrcListDup(db, pTabList, 0);
  pWhere2 = sqlite3ExprDup(db, pWhere, 0);
 
  assert( pTabList->nSrc>1 );
  if( pSrc ){
    pSrc->a[0].iCursor = -1;
    pSrc->a[0].pTab->nTabRef--;
    pSrc->a[0].pTab = 0;
  }
  if( pPk ){
    for(i=0; i<pPk->nKeyCol; i++){
      Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
      if( pLimit ){
        pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
      }
#endif
      pList = sqlite3ExprListAppend(pParse, pList, pNew);
    }
    eDest = SRT_Upfrom;
  }else if( pTab->pSelect ){
    for(i=0; i<pTab->nCol; i++){
      pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
    }
    eDest = SRT_Table;
  }else{
    eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
    pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
    if( pLimit ){
      pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
    }
#endif
  }
  if( ALWAYS(pChanges) ){
    for(i=0; i<pChanges->nExpr; i++){
      pList = sqlite3ExprListAppend(pParse, pList,
          sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
      );
    }
  }
  pSelect = sqlite3SelectNew(pParse, pList,
      pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UpdateFrom|SF_IncludeHidden, pLimit2

References ExprList::a, SrcList::a, Index::aiColumn, ALWAYS, Parse::db, exprRowColumn(), SrcList::SrcList_item::iCursor, SelectDest::iSDParm2, IsVirtual, Table::nCol, ExprList::nExpr, Index::nKeyCol, SrcList::nSrc, Table::nTabRef, ExprList::ExprList_item::pExpr, Table::pSelect, SrcList::SrcList_item::pTab, SF_IncludeHidden, SF_UpdateFrom, sqlite3ErrorMsg(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListDup(), sqlite3PExpr(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectDestInit(), sqlite3SelectNew(), sqlite3SrcListDup(), SRT_Table, SRT_Upfrom, TK_ROW, and UNUSED_PARAMETER.

Referenced by sqlite3Update(), and updateVirtualTable().

◆ updateRangeAffinityStr()

static void updateRangeAffinityStr	(	Expr *	pRight,
		int	n,
		char *	zAff )

static

Definition at line 141881 of file sqlite3.c.

                                               :
**
**   * the comparison will be performed with no affinity, or
**   * the affinity change in zAff is guaranteed not to change the value.
*/
static void updateRangeAffinityStr(
  Expr *pRight,                   /* RHS of comparison */
  int n,                          /* Number of vector elements in comparison */
  char *zAff                      /* Affinity string to modify */
){
  int i;
  for(i=0; i<n; i++){
    Expr *p = sqlite3VectorFieldSubexpr(pRight, i);
    if( sqlite3CompareAffinity(p, zAff[i])==SQLITE_AFF_BLOB

References sqlite3CompareAffinity(), sqlite3ExprNeedsNoAffinityChange(), sqlite3VectorFieldSubexpr(), and SQLITE_AFF_BLOB.

◆ updateVirtualTable()

static void updateVirtualTable	(	Parse *	pParse,
		SrcList *	pSrc,
		Table *	pTab,
		ExprList *	pChanges,
		Expr *	pRowidExpr,
		int *	aXRef,
		Expr *	pWhere,
		int	onError )

static

Definition at line 138751 of file sqlite3.c.

 {
  Vdbe *v = pParse->pVdbe;  /* Virtual machine under construction */
  int ephemTab;             /* Table holding the result of the SELECT */
  int i;                    /* Loop counter */
  sqlite3 *db = pParse->db; /* Database connection */
  const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
  WhereInfo *pWInfo = 0;
  int nArg = 2 + pTab->nCol;      /* Number of arguments to VUpdate */
  int regArg;                     /* First register in VUpdate arg array */
  int regRec;                     /* Register in which to assemble record */
  int regRowid;                   /* Register for ephem table rowid */
  int iCsr = pSrc->a[0].iCursor;  /* Cursor used for virtual table scan */
  int aDummy[2];                  /* Unused arg for sqlite3WhereOkOnePass() */
  int eOnePass;                   /* True to use onepass strategy */
  int addr;                       /* Address of OP_OpenEphemeral */
 
  /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
  ** create and open the ephemeral table in which the records created from
  ** these arguments will be temporarily stored. */
  assert( v );
  ephemTab = pParse->nTab++;
  addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
  regArg = pParse->nMem + 1;
  pParse->nMem += nArg;
  if( pSrc->nSrc>1 ){
    Expr *pRow;
    ExprList *pList;
    if( pRowid ){
      pRow = sqlite3ExprDup(db, pRowid, 0);
    }else{
      pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0);
    }
    pList = sqlite3ExprListAppend(pParse, 0, pRow);
 
    for(i=0; i<pTab->nCol; i++){
      if( aXRef[i]>=0 ){
        pList = sqlite3ExprListAppend(pParse, pList,
          sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
        );
      }else{
        pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
      }
    }
 
    updateFromSelect(pParse, ephemTab, 0, pList, pSrc, pWhere, 0, 0);
    sqlite3ExprListDelete(db, pList);
    eOnePass = ONEPASS_OFF;
  }else{
    regRec = ++pParse->nMem;
    regRowid = ++pParse->nMem;
 
    /* Start scanning the virtual table */
    pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0);
    if( pWInfo==0 ) return;
 
    /* Populate the argument registers. */
    for(i=0; i<pTab->nCol; i++){
      assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
      if( aXRef[i]>=0 ){
        sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
      }else{
        sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
        sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */
      }
    }
    if( HasRowid(pTab) ){
      sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
      if( pRowid ){
        sqlite3ExprCode(pParse, pRowid, regArg+1);
      }else{
        sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
      }
    }else{
      Index *pPk;   /* PRIMARY KEY index */
      i16 iPk;      /* PRIMARY KEY column */
      pPk = sqlite3PrimaryKeyIndex(pTab);
      assert( pPk!=0 );
      assert( pPk->nKeyCol==1 );
      iPk = pPk->aiColumn[0];
      sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
      sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
    }
 
    eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
 
    /* There is no ONEPASS_MULTI on virtual tables */
    assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
 
    if( eOnePass ){
      /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
      ** above. */
      sqlite3VdbeChangeToNoop(v, addr);
      sqlite3VdbeAddOp1(v, OP_Close, iCsr);
    }else{
      /* Create a record from the argument register contents and insert it into
      ** the ephemeral table. */
      sqlite3MultiWrite(pParse);
      sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
#if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM)
      /* Signal an assert() within OP_MakeRecord that it is allowed to
      ** accept no-change records with serial_type 10 */
      sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
#endif
      sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
    }
  }
 
 
  if( eOnePass==ONEPASS_OFF ){
    /* End the virtual table scan */
    if( pSrc->nSrc==1 ){
      sqlite3WhereEnd(pWInfo);
    }
 
    /* Begin scannning through the ephemeral table. */
    addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
 
    /* Extract arguments from the current row of the ephemeral table and
    ** invoke the VUpdate method.  */
    for(i=0; i<nArg; i++){
      sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
    }
  }
  sqlite3VtabMakeWritable(pParse, pTab);
  sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
  sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
  sqlite3MayAbort(pParse);
 
  /* End of the ephemeral table scan. Or, if using the onepass strategy,
  ** jump to here if the scan visited zero rows. */
  if( eOnePass==ONEPASS_OFF ){
    sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);

References ExprList::a, SrcList::a, Table::aCol, Index::aiColumn, COLFLAG_GENERATED, Column::colFlags, Parse::db, exprRowColumn(), HasRowid, SrcList::SrcList_item::iCursor, Table::nCol, Index::nKeyCol, Parse::nMem, SrcList::nSrc, Parse::nTab, OE_Abort, OE_Default, ONEPASS_OFF, ONEPASS_SINGLE, OP_Close, OP_Column, OP_Insert, OP_MakeRecord, OP_NewRowid, OP_Next, OP_OpenEphemeral, OP_Rewind, OP_Rowid, OP_SCopy, OP_VColumn, OP_VUpdate, OPFLAG_NOCHNG, OPFLAG_NOCHNG_MAGIC, P4_VTAB, ExprList::ExprList_item::pExpr, Parse::pVdbe, sqlite3ExprCode(), sqlite3ExprDup(), sqlite3ExprListAppend(), sqlite3ExprListDelete(), sqlite3GetVTable(), sqlite3MayAbort(), sqlite3MultiWrite(), sqlite3PExpr(), sqlite3PrimaryKeyIndex(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeChangeToNoop(), sqlite3VdbeJumpHere(), sqlite3VtabMakeWritable(), sqlite3WhereBegin(), sqlite3WhereEnd(), sqlite3WhereOkOnePass(), TK_ROW, updateFromSelect(), VdbeCoverage, and WHERE_ONEPASS_DESIRED.

Referenced by sqlite3Update().

◆ upperFunc()

static void upperFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 117500 of file sqlite3.c.

                                                                               {
  char *z1;
  const char *z2;
  int i, n;
  UNUSED_PARAMETER(argc);
  z2 = (char*)sqlite3_value_text(argv[0]);
  n = sqlite3_value_bytes(argv[0]);
  /* Verify that the call to _bytes() does not invalidate the _text() pointer */
  assert( z2==(char*)sqlite3_value_text(argv[0]) );
  if( z2 ){
    z1 = contextMalloc(context, ((i64)n)+1);
    if( z1 ){
      for(i=0; i<n; i++){

Referenced by sqlite3RegisterBuiltinFunctions().

◆ uriParameter()

static const char * uriParameter	(	const char *	zFilename,
		const char *	zParam )

static

Definition at line 164035 of file sqlite3.c.

                                                                          {
  zFilename += sqlite3Strlen30(zFilename) + 1;
  while( zFilename[0] ){
    int x = strcmp(zFilename, zParam);

◆ validJulianDay()

static int validJulianDay ( sqlite3_int64 iJD )

static

Definition at line 22121 of file sqlite3.c.

References INT_464269060799999.

Referenced by isDate().

◆ valueBytes()

static SQLITE_NOINLINE int valueBytes	(	sqlite3_value *	pVal,
		u8	enc )

static

Definition at line 77711 of file sqlite3.c.

◆ valueFromExpr()

static int valueFromExpr	(	sqlite3 *	db,
		Expr *	pExpr,
		u8	enc,
		u8	affinity,
		sqlite3_value **	ppVal,
		struct ValueNewStat4Ctx *	pCtx )

static

Definition at line 77303 of file sqlite3.c.

 {
  int op;
  char *zVal = 0;
  sqlite3_value *pVal = 0;
  int negInt = 1;
  const char *zNeg = "";
  int rc = SQLITE_OK;
 
  assert( pExpr!=0 );
  while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
#if defined(SQLITE_ENABLE_STAT4)
  if( op==TK_REGISTER ) op = pExpr->op2;
#else
  if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
#endif
 
  /* Compressed expressions only appear when parsing the DEFAULT clause
  ** on a table column definition, and hence only when pCtx==0.  This
  ** check ensures that an EP_TokenOnly expression is never passed down
  ** into valueFromFunction(). */
  assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
 
  if( op==TK_CAST ){
    u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
    rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
    testcase( rc!=SQLITE_OK );
    if( *ppVal ){
      sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8);
      sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8);
    }
    return rc;
  }
 
  /* Handle negative integers in a single step.  This is needed in the
  ** case when the value is -9223372036854775808.
  */
  if( op==TK_UMINUS
   && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
    pExpr = pExpr->pLeft;
    op = pExpr->op;
    negInt = -1;
    zNeg = "-";
  }
 
  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
    pVal = valueNew(db, pCtx);
    if( pVal==0 ) goto no_mem;
    if( ExprHasProperty(pExpr, EP_IntValue) ){
      sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
    }else{
      zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
      if( zVal==0 ) goto no_mem;
      sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
    }
    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){
      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
    }else{
      sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
    }
    assert( (pVal->flags & MEM_IntReal)==0 );
    if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
      testcase( pVal->flags & MEM_Int );
      testcase( pVal->flags & MEM_Real );
      pVal->flags &= ~MEM_Str;
    }
    if( enc!=SQLITE_UTF8 ){
      rc = sqlite3VdbeChangeEncoding(pVal, enc);
    }
  }else if( op==TK_UMINUS ) {
    /* This branch happens for multiple negative signs.  Ex: -(-5) */
    if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
     && pVal!=0
    ){
      sqlite3VdbeMemNumerify(pVal);
      if( pVal->flags & MEM_Real ){
        pVal->u.r = -pVal->u.r;
      }else if( pVal->u.i==SMALLEST_INT64 ){
#ifndef SQLITE_OMIT_FLOATING_POINT
        pVal->u.r = -(double)SMALLEST_INT64;
#else
        pVal->u.r = LARGEST_INT64;
#endif
        MemSetTypeFlag(pVal, MEM_Real);
      }else{
        pVal->u.i = -pVal->u.i;
      }
      sqlite3ValueApplyAffinity(pVal, affinity, enc);
    }
  }else if( op==TK_NULL ){
    pVal = valueNew(db, pCtx);
    if( pVal==0 ) goto no_mem;
    sqlite3VdbeMemSetNull(pVal);
  }
#ifndef SQLITE_OMIT_BLOB_LITERAL
  else if( op==TK_BLOB ){
    int nVal;
    assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
    assert( pExpr->u.zToken[1]=='\'' );
    pVal = valueNew(db, pCtx);
    if( !pVal ) goto no_mem;
    zVal = &pExpr->u.zToken[2];
    nVal = sqlite3Strlen30(zVal)-1;
    assert( zVal[nVal]=='\'' );
    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
                         0, SQLITE_DYNAMIC);
  }
#endif
#ifdef SQLITE_ENABLE_STAT4
  else if( op==TK_FUNCTION && pCtx!=0 ){
    rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
  }
#endif
  else if( op==TK_TRUEFALSE ){
    pVal = valueNew(db, pCtx);
    if( pVal ){
      pVal->flags = MEM_Int;
      pVal->u.i = pExpr->u.zToken[4]==0;
    }
  }
 
  *ppVal = pVal;
  return rc;
 
no_mem:
#ifdef SQLITE_ENABLE_STAT4
  if( pCtx==0 || pCtx->pParse->nErr==0 )
#endif
    sqlite3OomFault(db);
  sqlite3DbFree(db, zVal);
  assert( *ppVal==0 );
#ifdef SQLITE_ENABLE_STAT4

References EP_IntValue, EP_TokenOnly, ExprHasProperty, Expr::flags, sqlite3_value::flags, sqlite3_value::MemValue::i, Expr::iValue, LARGEST_INT64, MEM_Int, MEM_IntReal, MEM_Real, MemSetTypeFlag, Parse::nErr, NEVER, Expr::op, Expr::op2, Expr::pLeft, ValueNewStat4Ctx::pParse, sqlite3_value::MemValue::r, SMALLEST_INT64, sqlite3AffinityType(), sqlite3DbFree(), sqlite3HexToBlob(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3Strlen30(), sqlite3ValueApplyAffinity(), sqlite3ValueFree(), sqlite3ValueSetStr(), sqlite3VdbeChangeEncoding(), sqlite3VdbeMemCast(), sqlite3VdbeMemNumerify(), sqlite3VdbeMemSetInt64(), sqlite3VdbeMemSetNull(), sqlite3VdbeMemSetStr(), SQLITE_AFF_BLOB, SQLITE_AFF_NUMERIC, SQLITE_DYNAMIC, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_UTF8, testcase, TK_BLOB, TK_CAST, TK_FLOAT, TK_FUNCTION, TK_INTEGER, TK_NULL, TK_REGISTER, TK_SPAN, TK_STRING, TK_TRUEFALSE, TK_UMINUS, TK_UPLUS, Expr::u, sqlite3_value::u, valueFromExpr(), valueFromFunction, valueNew(), and Expr::zToken.

Referenced by sqlite3ValueFromExpr(), and valueFromExpr().

◆ valueNew()

static sqlite3_value * valueNew	(	sqlite3 *	db,
		struct ValueNewStat4Ctx *	p )

static

Definition at line 77147 of file sqlite3.c.

                                                                       {
#ifdef SQLITE_ENABLE_STAT4
  if( p ){
    UnpackedRecord *pRec = p->ppRec[0];
 
    if( pRec==0 ){
      Index *pIdx = p->pIdx;      /* Index being probed */
      int nByte;                  /* Bytes of space to allocate */
      int i;                      /* Counter variable */
      int nCol = pIdx->nColumn;   /* Number of index columns including rowid */
 
      nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
      pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
      if( pRec ){
        pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
        if( pRec->pKeyInfo ){
          assert( pRec->pKeyInfo->nAllField==nCol );
          assert( pRec->pKeyInfo->enc==ENC(db) );
          pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
          for(i=0; i<nCol; i++){
            pRec->aMem[i].flags = MEM_Null;
            pRec->aMem[i].db = db;
          }
        }else{
          sqlite3DbFreeNN(db, pRec);
          pRec = 0;
        }
      }
      if( pRec==0 ) return 0;
      p->ppRec[0] = pRec;
    }
 
    pRec->nField = p->iVal+1;
    return &pRec->aMem[p->iVal];

References UnpackedRecord::aMem, sqlite3_value::db, ENC, KeyInfo::enc, sqlite3_value::flags, ValueNewStat4Ctx::iVal, MEM_Null, KeyInfo::nAllField, Index::nColumn, UnpackedRecord::nField, ValueNewStat4Ctx::pIdx, UnpackedRecord::pKeyInfo, ValueNewStat4Ctx::pParse, ValueNewStat4Ctx::ppRec, ROUND8, sqlite3DbFreeNN(), sqlite3DbMallocZero(), sqlite3KeyInfoOfIndex(), sqlite3ValueNew(), and UNUSED_PARAMETER.

Referenced by valueFromExpr().

◆ valueToText()

static SQLITE_NOINLINE const void * valueToText	(	sqlite3_value *	pVal,
		u8	enc )

static

Definition at line 77055 of file sqlite3.c.

                                                                           {
  assert( pVal!=0 );
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  assert( (pVal->flags & (MEM_Null))==0 );
  if( pVal->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(pVal) ) return 0;
    pVal->flags |= MEM_Str;
    if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
      sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
    }
    if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
      assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
      if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
        return 0;
      }
    }
    sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
  }else{
    sqlite3VdbeMemStringify(pVal, enc, 0);
    assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
  }
  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
              || pVal->db->mallocFailed );
  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){

References sqlite3_value::db, sqlite3_value::enc, ExpandBlob, sqlite3_value::flags, sqlite3::mallocFailed, MEM_Blob, MEM_Ephem, MEM_Null, MEM_Static, MEM_Str, sqlite3::mutex, sqlite3_mutex_held(), sqlite3VdbeChangeEncoding(), sqlite3VdbeMemMakeWriteable(), sqlite3VdbeMemNulTerminate(), sqlite3VdbeMemStringify(), SQLITE_OK, SQLITE_PTR_TO_INT, SQLITE_UTF16_ALIGNED, and sqlite3_value::z.

Referenced by sqlite3ValueBytes().

◆ vdbeChangeP4Full()

static void SQLITE_NOINLINE vdbeChangeP4Full	(	Vdbe *	p,
		Op *	pOp,
		const char *	zP4,
		int	n )

static

Definition at line 79009 of file sqlite3.c.

 {
  if( pOp->p4type ){
    freeP4(p->db, pOp->p4type, pOp->p4.p);
    pOp->p4type = 0;
    pOp->p4.p = 0;
  }
  if( n<0 ){
    sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);

References Vdbe::aOp, Vdbe::db, freeP4(), VdbeOp::p4union::p, VdbeOp::p4, VdbeOp::p4type, and sqlite3VdbeChangeP4().

◆ vdbeCloseStatement()

static SQLITE_NOINLINE int vdbeCloseStatement	(	Vdbe *	p,
		int	eOp )

static

Definition at line 80663 of file sqlite3.c.

                                                               {
  sqlite3 *const db = p->db;
  int rc = SQLITE_OK;
  int i;
  const int iSavepoint = p->iStatement-1;
 
  assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
  assert( db->nStatement>0 );
  assert( p->iStatement==(db->nStatement+db->nSavepoint) );
 
  for(i=0; i<db->nDb; i++){
    int rc2 = SQLITE_OK;
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      if( eOp==SAVEPOINT_ROLLBACK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
      }
      if( rc2==SQLITE_OK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
      }
      if( rc==SQLITE_OK ){
        rc = rc2;
      }
    }
  }
  db->nStatement--;
  p->iStatement = 0;
 
  if( rc==SQLITE_OK ){
    if( eOp==SAVEPOINT_ROLLBACK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
    }
  }
 
  /* If the statement transaction is being rolled back, also restore the
  ** database handles deferred constraint counter to the value it had when
  ** the statement transaction was opened.  */

References sqlite3::aDb, Vdbe::db, Vdbe::iStatement, sqlite3::nDb, sqlite3::nSavepoint, sqlite3::nStatement, Db::pBt, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, sqlite3BtreeSavepoint(), sqlite3VtabSavepoint(), and SQLITE_OK.

◆ vdbeClrCopy()

static SQLITE_NOINLINE void vdbeClrCopy	(	Mem *	pTo,
		const Mem *	pFrom,
		int	eType )

static

Definition at line 76822 of file sqlite3.c.

◆ vdbeCommit()

static int vdbeCommit	(	sqlite3 *	db,
		Vdbe *	p )

static

Definition at line 80367 of file sqlite3.c.

                                           {
  int i;
  int nTrans = 0;  /* Number of databases with an active write-transaction
                   ** that are candidates for a two-phase commit using a
                   ** super-journal */
  int rc = SQLITE_OK;
  int needXcommit = 0;
 
#ifdef SQLITE_OMIT_VIRTUALTABLE
  /* With this option, sqlite3VtabSync() is defined to be simply
  ** SQLITE_OK so p is not used.
  */
  UNUSED_PARAMETER(p);
#endif
 
  /* Before doing anything else, call the xSync() callback for any
  ** virtual module tables written in this transaction. This has to
  ** be done before determining whether a super-journal file is
  ** required, as an xSync() callback may add an attached database
  ** to the transaction.
  */
  rc = sqlite3VtabSync(db, p);
 
  /* This loop determines (a) if the commit hook should be invoked and
  ** (b) how many database files have open write transactions, not
  ** including the temp database. (b) is important because if more than
  ** one database file has an open write transaction, a super-journal
  ** file is required for an atomic commit.
  */
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( sqlite3BtreeIsInTrans(pBt) ){
      /* Whether or not a database might need a super-journal depends upon
      ** its journal mode (among other things).  This matrix determines which
      ** journal modes use a super-journal and which do not */
      static const u8 aMJNeeded[] = {
        /* DELETE   */  1,
        /* PERSIST   */ 1,
        /* OFF       */ 0,
        /* TRUNCATE  */ 1,
        /* MEMORY    */ 0,
        /* WAL       */ 0
      };
      Pager *pPager;   /* Pager associated with pBt */
      needXcommit = 1;
      sqlite3BtreeEnter(pBt);
      pPager = sqlite3BtreePager(pBt);
      if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF
       && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
       && sqlite3PagerIsMemdb(pPager)==0
      ){
        assert( i!=1 );
        nTrans++;
      }
      rc = sqlite3PagerExclusiveLock(pPager);
      sqlite3BtreeLeave(pBt);
    }
  }
  if( rc!=SQLITE_OK ){
    return rc;
  }
 
  /* If there are any write-transactions at all, invoke the commit hook */
  if( needXcommit && db->xCommitCallback ){
    rc = db->xCommitCallback(db->pCommitArg);
    if( rc ){
      return SQLITE_CONSTRAINT_COMMITHOOK;
    }
  }
 
  /* The simple case - no more than one database file (not counting the
  ** TEMP database) has a transaction active.   There is no need for the
  ** super-journal.
  **
  ** If the return value of sqlite3BtreeGetFilename() is a zero length
  ** string, it means the main database is :memory: or a temp file.  In
  ** that case we do not support atomic multi-file commits, so use the
  ** simple case then too.
  */
  if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
   || nTrans<=1
  ){
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
      }
    }
 
    /* Do the commit only if all databases successfully complete phase 1.
    ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
    ** IO error while deleting or truncating a journal file. It is unlikely,
    ** but could happen. In this case abandon processing and return the error.
    */
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
      }
    }
    if( rc==SQLITE_OK ){
      sqlite3VtabCommit(db);
    }
  }
 
  /* The complex case - There is a multi-file write-transaction active.
  ** This requires a super-journal file to ensure the transaction is
  ** committed atomically.
  */
#ifndef SQLITE_OMIT_DISKIO
  else{
    sqlite3_vfs *pVfs = db->pVfs;
    char *zSuper = 0;   /* File-name for the super-journal */
    char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
    sqlite3_file *pSuperJrnl = 0;
    i64 offset = 0;
    int res;
    int retryCount = 0;
    int nMainFile;
 
    /* Select a super-journal file name */
    nMainFile = sqlite3Strlen30(zMainFile);
    zSuper = sqlite3MPrintf(db, "%.4c%s%.16c", 0,zMainFile,0);
    if( zSuper==0 ) return SQLITE_NOMEM_BKPT;
    zSuper += 4;
    do {
      u32 iRandom;
      if( retryCount ){
        if( retryCount>100 ){
          sqlite3_log(SQLITE_FULL, "MJ delete: %s", zSuper);
          sqlite3OsDelete(pVfs, zSuper, 0);
          break;
        }else if( retryCount==1 ){
          sqlite3_log(SQLITE_FULL, "MJ collide: %s", zSuper);
        }
      }
      retryCount++;
      sqlite3_randomness(sizeof(iRandom), &iRandom);
      sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X",
                               (iRandom>>8)&0xffffff, iRandom&0xff);
      /* The antipenultimate character of the super-journal name must
      ** be "9" to avoid name collisions when using 8+3 filenames. */
      assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' );
      sqlite3FileSuffix3(zMainFile, zSuper);
      rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
    }while( rc==SQLITE_OK && res );
    if( rc==SQLITE_OK ){
      /* Open the super-journal. */
      rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl,
          SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
          SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_SUPER_JOURNAL, 0
      );
    }
    if( rc!=SQLITE_OK ){
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }
 
    /* Write the name of each database file in the transaction into the new
    ** super-journal file. If an error occurs at this point close
    ** and delete the super-journal file. All the individual journal files
    ** still have 'null' as the super-journal pointer, so they will roll
    ** back independently if a failure occurs.
    */
    for(i=0; i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( sqlite3BtreeIsInTrans(pBt) ){
        char const *zFile = sqlite3BtreeGetJournalname(pBt);
        if( zFile==0 ){
          continue;  /* Ignore TEMP and :memory: databases */
        }
        assert( zFile[0]!=0 );
        rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset);
        offset += sqlite3Strlen30(zFile)+1;
        if( rc!=SQLITE_OK ){
          sqlite3OsCloseFree(pSuperJrnl);
          sqlite3OsDelete(pVfs, zSuper, 0);
          sqlite3DbFree(db, zSuper-4);
          return rc;
        }
      }
    }
 
    /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device
    ** flag is set this is not required.
    */
    if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl)&SQLITE_IOCAP_SEQUENTIAL)
     && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL))
    ){
      sqlite3OsCloseFree(pSuperJrnl);
      sqlite3OsDelete(pVfs, zSuper, 0);
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }
 
    /* Sync all the db files involved in the transaction. The same call
    ** sets the super-journal pointer in each individual journal. If
    ** an error occurs here, do not delete the super-journal file.
    **
    ** If the error occurs during the first call to
    ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
    ** super-journal file will be orphaned. But we cannot delete it,
    ** in case the super-journal file name was written into the journal
    ** file before the failure occurred.
    */
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseOne(pBt, zSuper);
      }
    }
    sqlite3OsCloseFree(pSuperJrnl);
    assert( rc!=SQLITE_BUSY );
    if( rc!=SQLITE_OK ){
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }
 
    /* Delete the super-journal file. This commits the transaction. After
    ** doing this the directory is synced again before any individual
    ** transaction files are deleted.
    */
    rc = sqlite3OsDelete(pVfs, zSuper, 1);
    sqlite3DbFree(db, zSuper-4);
    zSuper = 0;
    if( rc ){
      return rc;
    }
 
    /* All files and directories have already been synced, so the following
    ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
    ** deleting or truncating journals. If something goes wrong while
    ** this is happening we don't really care. The integrity of the
    ** transaction is already guaranteed, but some stray 'cold' journals
    ** may be lying around. Returning an error code won't help matters.
    */
    disable_simulated_io_errors();
    sqlite3BeginBenignMalloc();
    for(i=0; i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        sqlite3BtreeCommitPhaseTwo(pBt, 1);
      }
    }
    sqlite3EndBenignMalloc();
    enable_simulated_io_errors();
 

References sqlite3::aDb, disable_simulated_io_errors, enable_simulated_io_errors, sqlite3::nDb, PAGER_SYNCHRONOUS_OFF, Db::pBt, sqlite3::pCommitArg, sqlite3::pVfs, Db::safety_level, sqlite3_log(), sqlite3_randomness(), sqlite3_snprintf(), sqlite3BeginBenignMalloc(), sqlite3BtreeCommitPhaseOne(), sqlite3BtreeCommitPhaseTwo(), sqlite3BtreeEnter(), sqlite3BtreeGetFilename(), sqlite3BtreeGetJournalname(), sqlite3BtreeIsInTrans(), sqlite3BtreeLeave(), sqlite3BtreePager(), sqlite3DbFree(), sqlite3EndBenignMalloc(), sqlite3FileSuffix3, sqlite3MPrintf(), sqlite3OsAccess(), sqlite3OsCloseFree(), sqlite3OsDelete(), sqlite3OsDeviceCharacteristics(), sqlite3OsOpenMalloc(), sqlite3OsSync(), sqlite3OsWrite(), sqlite3PagerExclusiveLock(), sqlite3PagerGetJournalMode(), sqlite3PagerIsMemdb(), sqlite3Strlen30(), sqlite3VtabCommit(), sqlite3VtabSync(), SQLITE_ACCESS_EXISTS, SQLITE_BUSY, SQLITE_CONSTRAINT_COMMITHOOK, SQLITE_FULL, SQLITE_IOCAP_SEQUENTIAL, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_SUPER_JOURNAL, SQLITE_SYNC_NORMAL, UNUSED_PARAMETER, and sqlite3::xCommitCallback.

Referenced by sqlite3VdbeHalt().

◆ vdbeCompareMemString()

static int vdbeCompareMemString	(	const Mem *	pMem1,
		const Mem *	pMem2,
		const CollSeq *	pColl,
		u8 *	prcErr )

static

Definition at line 81943 of file sqlite3.c.

 {
  if( pMem1->enc==pColl->enc ){
    /* The strings are already in the correct encoding.  Call the
     ** comparison function directly */
    return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
  }else{
    int rc;
    const void *v1, *v2;
    Mem c1;
    Mem c2;
    sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
    sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
    sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
    sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
    v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
    v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
    if( (v1==0 || v2==0) ){
      if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT;
      rc = 0;
    }else{
      rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2);

References sqlite3_value::db, CollSeq::enc, sqlite3_value::enc, MEM_Ephem, MEM_Null, sqlite3_value::n, CollSeq::pUser, sqlite3ValueText(), sqlite3VdbeMemInit(), sqlite3VdbeMemRelease(), sqlite3VdbeMemShallowCopy(), SQLITE_NOMEM_BKPT, CollSeq::xCmp, and sqlite3_value::z.

Referenced by sqlite3MemCompare(), and sqlite3VdbeRecordCompareWithSkip().

◆ vdbeFreeOpArray()

static void vdbeFreeOpArray	(	sqlite3 *	db,
		Op *	aOp,
		int	nOp )

static

Definition at line 78900 of file sqlite3.c.

                                                          {
  if( aOp ){
    Op *pOp;
    for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
      if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS

References freeP4(), VdbeOp::p4union::p, VdbeOp::p4, P4_FREE_IF_LE, VdbeOp::p4type, sqlite3DbFree(), and sqlite3DbFreeNN().

Referenced by sqlite3VdbeClearObject().

◆ vdbeIncrBgPopulate()

static int vdbeIncrBgPopulate ( IncrMerger * pIncr )

static

Definition at line 95804 of file sqlite3.c.

Referenced by vdbeIncrSwap().

◆ vdbeIncrFree()

static void vdbeIncrFree ( IncrMerger * pIncr )

static

Definition at line 95087 of file sqlite3.c.

                                           {
  if( pIncr ){
#if SQLITE_MAX_WORKER_THREADS>0
    if( pIncr->bUseThread ){
      vdbeSorterJoinThread(pIncr->pTask);
      if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd);
      if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd);

Referenced by vdbeSorterAddToTree().

◆ vdbeIncrMergerNew()

static int vdbeIncrMergerNew	(	SortSubtask *	pTask,
		MergeEngine *	pMerger,
		IncrMerger **	ppOut )

static

Definition at line 95867 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  IncrMerger *pIncr = *ppOut = (IncrMerger*)
       (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr)));
  if( pIncr ){
    pIncr->pMerger = pMerger;
    pIncr->pTask = pTask;
    pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2);
    pTask->file2.iEof += pIncr->mxSz;

References SortSubtask::file2, SorterFile::iEof, MAX, VdbeSorter::mxKeysize, VdbeSorter::mxPmaSize, IncrMerger::mxSz, IncrMerger::pMerger, SortSubtask::pSorter, IncrMerger::pTask, sqlite3FaultSim(), sqlite3MallocZero(), SQLITE_NOMEM_BKPT, SQLITE_OK, and vdbeMergeEngineFree().

Referenced by vdbeSorterAddToTree(), vdbeSorterMergeTreeBuild(), and vdbeSorterSetupMerge().

◆ vdbeIncrMergerSetThreads()

static void vdbeIncrMergerSetThreads ( IncrMerger * pIncr )

static

Definition at line 95891 of file sqlite3.c.

Referenced by vdbeSorterSetupMerge().

◆ vdbeIncrPopulate()

static int vdbeIncrPopulate ( IncrMerger * pIncr )

static

Definition at line 95752 of file sqlite3.c.

                                              {
  int rc = SQLITE_OK;
  int rc2;
  i64 iStart = pIncr->iStartOff;
  SorterFile *pOut = &pIncr->aFile[1];
  SortSubtask *pTask = pIncr->pTask;
  MergeEngine *pMerger = pIncr->pMerger;
  PmaWriter writer;
  assert( pIncr->bEof==0 );
 
  vdbeSorterPopulateDebug(pTask, "enter");
 
  vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
  while( rc==SQLITE_OK ){
    int dummy;
    PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ];
    int nKey = pReader->nKey;
    i64 iEof = writer.iWriteOff + writer.iBufEnd;
 
    /* Check if the output file is full or if the input has been exhausted.
    ** In either case exit the loop. */
    if( pReader->pFd==0 ) break;
    if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break;
 
    /* Write the next key to the output. */
    vdbePmaWriteVarint(&writer, nKey);
    vdbePmaWriteBlob(&writer, pReader->aKey, nKey);
    assert( pIncr->pMerger->pTask==pTask );
    rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy);
  }

References IncrMerger::aFile, PmaReader::aKey, MergeEngine::aReadr, MergeEngine::aTree, IncrMerger::bEof, dummy, SorterFile::iEof, IncrMerger::iStartOff, IncrMerger::mxSz, PmaReader::nKey, SorterFile::pFd, PmaReader::pFd, VdbeSorter::pgsz, IncrMerger::pMerger, SortSubtask::pSorter, MergeEngine::pTask, IncrMerger::pTask, sqlite3VarintLen(), SQLITE_OK, vdbeMergeEngineStep(), vdbePmaWriteBlob(), vdbePmaWriterFinish(), vdbePmaWriterInit(), vdbePmaWriteVarint(), vdbeSorterPopulateDebug, and writer().

Referenced by vdbeIncrPopulateThread(), vdbeIncrSwap(), and vdbePmaReaderIncrMergeInit().

◆ vdbeIncrPopulateThread()

static void * vdbeIncrPopulateThread ( void * pCtx )

static

Definition at line 95794 of file sqlite3.c.

References SortSubtask::bDone, IncrMerger::pTask, SQLITE_INT_TO_PTR, and vdbeIncrPopulate().

◆ vdbeIncrSwap()

static int vdbeIncrSwap ( IncrMerger * pIncr )

static

Definition at line 95828 of file sqlite3.c.

                                          {
  int rc = SQLITE_OK;
 
#if SQLITE_MAX_WORKER_THREADS>0
  if( pIncr->bUseThread ){
    rc = vdbeSorterJoinThread(pIncr->pTask);
 
    if( rc==SQLITE_OK ){
      SorterFile f0 = pIncr->aFile[0];
      pIncr->aFile[0] = pIncr->aFile[1];
      pIncr->aFile[1] = f0;
    }
 
    if( rc==SQLITE_OK ){
      if( pIncr->aFile[0].iEof==pIncr->iStartOff ){
        pIncr->bEof = 1;
      }else{
        rc = vdbeIncrBgPopulate(pIncr);
      }
    }
  }else
#endif
  {
    rc = vdbeIncrPopulate(pIncr);
    pIncr->aFile[0] = pIncr->aFile[1];
    if( pIncr->aFile[0].iEof==pIncr->iStartOff ){

References IncrMerger::aFile, IncrMerger::bEof, IncrMerger::bUseThread, SorterFile::iEof, IncrMerger::iStartOff, IncrMerger::pTask, SQLITE_OK, vdbeIncrBgPopulate(), vdbeIncrPopulate(), and vdbeSorterJoinThread().

◆ vdbeLeave()

static SQLITE_NOINLINE void vdbeLeave ( Vdbe * p )

static

Definition at line 79542 of file sqlite3.c.

                                              {
  int i;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;

References sqlite3::aDb, Vdbe::db, and sqlite3::nDb.

◆ vdbeMemAddTerminator()

static SQLITE_NOINLINE int vdbeMemAddTerminator ( Mem * pMem )

static

Definition at line 76137 of file sqlite3.c.

                                                          {
  if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
    return SQLITE_NOMEM_BKPT;
  }

References sqlite3_value::flags, MEM_Term, sqlite3_value::n, sqlite3VdbeMemGrow(), SQLITE_NOMEM_BKPT, SQLITE_OK, and sqlite3_value::z.

Referenced by sqlite3VdbeMemMakeWriteable().

◆ vdbeMemClear()

static SQLITE_NOINLINE void vdbeMemClear ( Mem * p )

static

Definition at line 76342 of file sqlite3.c.

                                                {
  if( VdbeMemDynamic(p) ){
    vdbeMemClearExternAndSetNull(p);
  }

References sqlite3_value::db, sqlite3DbFreeNN(), sqlite3_value::szMalloc, vdbeMemClearExternAndSetNull(), VdbeMemDynamic, sqlite3_value::z, and sqlite3_value::zMalloc.

Referenced by sqlite3VdbeMemRelease().

◆ vdbeMemClearExternAndSetNull()

static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull ( Mem * p )

static

Definition at line 76319 of file sqlite3.c.

                                                                {
  assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
  assert( VdbeMemDynamic(p) );
  if( p->flags&MEM_Agg ){
    sqlite3VdbeMemFinalize(p, p->u.pDef);
    assert( (p->flags & MEM_Agg)==0 );
    testcase( p->flags & MEM_Dyn );
  }

References sqlite3_value::db, sqlite3_value::flags, MEM_Agg, MEM_Dyn, MEM_Null, sqlite3::mutex, sqlite3_value::MemValue::pDef, sqlite3_mutex_held(), sqlite3VdbeMemFinalize(), SQLITE_DYNAMIC, testcase, sqlite3_value::u, VdbeMemDynamic, sqlite3_value::xDel, and sqlite3_value::z.

Referenced by sqlite3ValueSetNull(), sqlite3VdbeMemShallowCopy(), and vdbeMemClear().

◆ vdbeMemRenderNum()

static void vdbeMemRenderNum	(	int	sz,
		char *	zBuf,
		Mem *	p )

static

Definition at line 75928 of file sqlite3.c.

                                                        {
  StrAccum acc;
  assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
  assert( sz>22 );
  if( p->flags & MEM_Int ){
#if GCC_VERSION>=7000000
    /* Work-around for GCC bug
    ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96270 */
    i64 x;
    assert( (p->flags&MEM_Int)*2==sizeof(x) );
    memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2);
    sqlite3Int64ToText(x, zBuf);
#else
    sqlite3Int64ToText(p->u.i, zBuf);
#endif
  }else{
    sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);

References sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Int, MEM_IntReal, MEM_Real, sqlite3_str::mxAlloc, sqlite3_str::nChar, sqlite3_value::MemValue::r, sqlite3_str_appendf(), sqlite3Int64ToText(), sqlite3StrAccumInit(), sqlite3_value::u, and sqlite3_str::zText.

Referenced by sqlite3VdbeMemStringify().

◆ vdbeMergeEngineCompare()

static void vdbeMergeEngineCompare	(	MergeEngine *	pMerger,
		int	iOut )

static

Definition at line 95904 of file sqlite3.c.

 {
  int i1;
  int i2;
  int iRes;
  PmaReader *p1;
  PmaReader *p2;
 
  assert( iOut<pMerger->nTree && iOut>0 );
 
  if( iOut>=(pMerger->nTree/2) ){
    i1 = (iOut - pMerger->nTree/2) * 2;
    i2 = i1 + 1;
  }else{
    i1 = pMerger->aTree[iOut*2];
    i2 = pMerger->aTree[iOut*2+1];
  }
 
  p1 = &pMerger->aReadr[i1];
  p2 = &pMerger->aReadr[i2];
 
  if( p1->pFd==0 ){
    iRes = i2;
  }else if( p2->pFd==0 ){
    iRes = i1;
  }else{
    SortSubtask *pTask = pMerger->pTask;
    int bCached = 0;
    int res;
    assert( pTask->pUnpacked!=0 );  /* from vdbeSortSubtaskMain() */
    res = pTask->xCompare(
        pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey
    );
    if( res<=0 ){
      iRes = i1;
    }else{

References PmaReader::aKey, MergeEngine::aReadr, MergeEngine::aTree, PmaReader::nKey, MergeEngine::nTree, PmaReader::pFd, MergeEngine::pTask, SortSubtask::pUnpacked, and SortSubtask::xCompare.

Referenced by vdbeMergeEngineInit().

◆ vdbeMergeEngineFree()

static void vdbeMergeEngineFree ( MergeEngine * pMerger )

static

Definition at line 95073 of file sqlite3.c.

                                                     {
  int i;
  if( pMerger ){

Referenced by vdbeIncrMergerNew(), vdbeMergeEngineLevel0(), vdbeSorterMergeTreeBuild(), and vdbeSorterSetupMerge().

◆ vdbeMergeEngineInit()

static int vdbeMergeEngineInit	(	SortSubtask *	pTask,
		MergeEngine *	pMerger,
		int	eMode )

static

Definition at line 95986 of file sqlite3.c.

 {
  int rc = SQLITE_OK;             /* Return code */
  int i;                          /* For looping over PmaReader objects */
  int nTree;                      /* Number of subtrees to merge */
 
  /* Failure to allocate the merge would have been detected prior to
  ** invoking this routine */
  assert( pMerger!=0 );
 
  /* eMode is always INCRINIT_NORMAL in single-threaded mode */
  assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
 
  /* Verify that the MergeEngine is assigned to a single thread */
  assert( pMerger->pTask==0 );
  pMerger->pTask = pTask;
 
  nTree = pMerger->nTree;
  for(i=0; i<nTree; i++){
    if( SQLITE_MAX_WORKER_THREADS>0 && eMode==INCRINIT_ROOT ){
      /* PmaReaders should be normally initialized in order, as if they are
      ** reading from the same temp file this makes for more linear file IO.
      ** However, in the INCRINIT_ROOT case, if PmaReader aReadr[nTask-1] is
      ** in use it will block the vdbePmaReaderNext() call while it uses
      ** the main thread to fill its buffer. So calling PmaReaderNext()
      ** on this PmaReader before any of the multi-threaded PmaReaders takes
      ** better advantage of multi-processor hardware. */
      rc = vdbePmaReaderNext(&pMerger->aReadr[nTree-i-1]);
    }else{
      rc = vdbePmaReaderIncrInit(&pMerger->aReadr[i], INCRINIT_NORMAL);
    }
    if( rc!=SQLITE_OK ) return rc;
  }

References MergeEngine::aReadr, UnpackedRecord::errCode, INCRINIT_NORMAL, INCRINIT_ROOT, MergeEngine::nTree, MergeEngine::pTask, SortSubtask::pUnpacked, SQLITE_MAX_WORKER_THREADS, SQLITE_OK, vdbeMergeEngineCompare(), vdbePmaReaderIncrInit(), and vdbePmaReaderNext().

Referenced by vdbePmaReaderIncrMergeInit(), and vdbeSorterSetupMerge().

◆ vdbeMergeEngineLevel0()

static int vdbeMergeEngineLevel0	(	SortSubtask *	pTask,
		int	nPMA,
		i64 *	piOffset,
		MergeEngine **	ppOut )

static

Definition at line 96180 of file sqlite3.c.

 {
  MergeEngine *pNew;              /* Merge engine to return */
  i64 iOff = *piOffset;
  int i;
  int rc = SQLITE_OK;
 
  *ppOut = pNew = vdbeMergeEngineNew(nPMA);
  if( pNew==0 ) rc = SQLITE_NOMEM_BKPT;
 
  for(i=0; i<nPMA && rc==SQLITE_OK; i++){
    i64 nDummy = 0;
    PmaReader *pReadr = &pNew->aReadr[i];
    rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy);
    iOff = pReadr->iEof;
  }
 
  if( rc!=SQLITE_OK ){

References MergeEngine::aReadr, SortSubtask::file, PmaReader::iEof, SQLITE_NOMEM_BKPT, SQLITE_OK, vdbeMergeEngineFree(), vdbeMergeEngineNew(), and vdbePmaReaderInit().

Referenced by vdbeSorterMergeTreeBuild().

◆ vdbeMergeEngineNew()

static MergeEngine * vdbeMergeEngineNew ( int nReader )

static

Definition at line 95050 of file sqlite3.c.

                                                   {
  int N = 2;                      /* Smallest power of two >= nReader */
  int nByte;                      /* Total bytes of space to allocate */
  MergeEngine *pNew;              /* Pointer to allocated object to return */
 
  assert( nReader<=SORTER_MAX_MERGE_COUNT );
 
  while( N<nReader ) N += N;
  nByte = sizeof(MergeEngine) + N * (sizeof(int) + sizeof(PmaReader));
 
  pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
  if( pNew ){
    pNew->nTree = N;

References MergeEngine::aReadr, MergeEngine::aTree, MergeEngine::nTree, MergeEngine::pTask, SORTER_MAX_MERGE_COUNT, sqlite3FaultSim(), and sqlite3MallocZero().

Referenced by vdbeMergeEngineLevel0(), vdbeSorterAddToTree(), and vdbeSorterMergeTreeBuild().

◆ vdbeMergeEngineStep()

static int vdbeMergeEngineStep	(	MergeEngine *	pMerger,
		int *	pbEof )

static

Definition at line 95485 of file sqlite3.c.

 {
  int rc;
  int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */
  SortSubtask *pTask = pMerger->pTask;
 
  /* Advance the current PmaReader */
  rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]);
 
  /* Update contents of aTree[] */
  if( rc==SQLITE_OK ){
    int i;                      /* Index of aTree[] to recalculate */
    PmaReader *pReadr1;         /* First PmaReader to compare */
    PmaReader *pReadr2;         /* Second PmaReader to compare */
    int bCached = 0;
 
    /* Find the first two PmaReaders to compare. The one that was just
    ** advanced (iPrev) and the one next to it in the array.  */
    pReadr1 = &pMerger->aReadr[(iPrev & 0xFFFE)];
    pReadr2 = &pMerger->aReadr[(iPrev | 0x0001)];
 
    for(i=(pMerger->nTree+iPrev)/2; i>0; i=i/2){
      /* Compare pReadr1 and pReadr2. Store the result in variable iRes. */
      int iRes;
      if( pReadr1->pFd==0 ){
        iRes = +1;
      }else if( pReadr2->pFd==0 ){
        iRes = -1;
      }else{
        iRes = pTask->xCompare(pTask, &bCached,
            pReadr1->aKey, pReadr1->nKey, pReadr2->aKey, pReadr2->nKey
        );
      }
 
      /* If pReadr1 contained the smaller value, set aTree[i] to its index.
      ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
      ** case there is no cache of pReadr2 in pTask->pUnpacked, so set
      ** pKey2 to point to the record belonging to pReadr2.
      **
      ** Alternatively, if pReadr2 contains the smaller of the two values,
      ** set aTree[i] to its index and update pReadr1. If vdbeSorterCompare()
      ** was actually called above, then pTask->pUnpacked now contains
      ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent
      ** vdbeSorterCompare() from decoding pReadr2 again.
      **
      ** If the two values were equal, then the value from the oldest
      ** PMA should be considered smaller. The VdbeSorter.aReadr[] array
      ** is sorted from oldest to newest, so pReadr1 contains older values
      ** than pReadr2 iff (pReadr1<pReadr2).  */
      if( iRes<0 || (iRes==0 && pReadr1<pReadr2) ){
        pMerger->aTree[i] = (int)(pReadr1 - pMerger->aReadr);
        pReadr2 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ];
        bCached = 0;
      }else{
        if( pReadr1->pFd ) bCached = 0;
        pMerger->aTree[i] = (int)(pReadr2 - pMerger->aReadr);
        pReadr1 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ];
      }

References PmaReader::aKey, MergeEngine::aReadr, MergeEngine::aTree, UnpackedRecord::errCode, PmaReader::nKey, MergeEngine::nTree, PmaReader::pFd, MergeEngine::pTask, SortSubtask::pUnpacked, SQLITE_OK, vdbePmaReaderNext(), and SortSubtask::xCompare.

Referenced by sqlite3VdbeSorterNext(), and vdbeIncrPopulate().

◆ vdbePmaReadBlob()

static int vdbePmaReadBlob	(	PmaReader *	p,
		int	nByte,
		u8 **	ppOut )

static

Definition at line 94364 of file sqlite3.c.

 {
  int iBuf;                       /* Offset within buffer to read from */
  int nAvail;                     /* Bytes of data available in buffer */
 
  if( p->aMap ){
    *ppOut = &p->aMap[p->iReadOff];
    p->iReadOff += nByte;
    return SQLITE_OK;
  }
 
  assert( p->aBuffer );
 
  /* If there is no more data to be read from the buffer, read the next
  ** p->nBuffer bytes of data from the file into it. Or, if there are less
  ** than p->nBuffer bytes remaining in the PMA, read all remaining data.  */
  iBuf = p->iReadOff % p->nBuffer;
  if( iBuf==0 ){
    int nRead;                    /* Bytes to read from disk */
    int rc;                       /* sqlite3OsRead() return code */
 
    /* Determine how many bytes of data to read. */
    if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){
      nRead = p->nBuffer;
    }else{
      nRead = (int)(p->iEof - p->iReadOff);
    }
    assert( nRead>0 );
 
    /* Readr data from the file. Return early if an error occurs. */
    rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff);
    assert( rc!=SQLITE_IOERR_SHORT_READ );
    if( rc!=SQLITE_OK ) return rc;
  }
  nAvail = p->nBuffer - iBuf;
 
  if( nByte<=nAvail ){
    /* The requested data is available in the in-memory buffer. In this
    ** case there is no need to make a copy of the data, just return a
    ** pointer into the buffer to the caller.  */
    *ppOut = &p->aBuffer[iBuf];
    p->iReadOff += nByte;
  }else{
    /* The requested data is not all available in the in-memory buffer.
    ** In this case, allocate space at p->aAlloc[] to copy the requested
    ** range into. Then return a copy of pointer p->aAlloc to the caller.  */
    int nRem;                     /* Bytes remaining to copy */
 
    /* Extend the p->aAlloc[] allocation if required. */
    if( p->nAlloc<nByte ){
      u8 *aNew;
      sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
      while( nByte>nNew ) nNew = nNew*2;
      aNew = sqlite3Realloc(p->aAlloc, nNew);
      if( !aNew ) return SQLITE_NOMEM_BKPT;
      p->nAlloc = nNew;
      p->aAlloc = aNew;
    }
 
    /* Copy as much data as is available in the buffer into the start of
    ** p->aAlloc[].  */
    memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail);
    p->iReadOff += nAvail;
    nRem = nByte - nAvail;
 
    /* The following loop copies up to p->nBuffer bytes per iteration into
    ** the p->aAlloc[] buffer.  */
    while( nRem>0 ){
      int rc;                     /* vdbePmaReadBlob() return code */
      int nCopy;                  /* Number of bytes to copy */
      u8 *aNext;                  /* Pointer to buffer to copy data from */
 
      nCopy = nRem;
      if( nRem>p->nBuffer ) nCopy = p->nBuffer;
      rc = vdbePmaReadBlob(p, nCopy, &aNext);
      if( rc!=SQLITE_OK ) return rc;
      assert( aNext!=p->aAlloc );
      memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
      nRem -= nCopy;
    }

References PmaReader::aAlloc, PmaReader::aBuffer, PmaReader::aMap, PmaReader::iEof, PmaReader::iReadOff, MAX, PmaReader::nAlloc, PmaReader::nBuffer, PmaReader::pFd, sqlite3OsRead(), sqlite3Realloc(), SQLITE_IOERR_SHORT_READ, SQLITE_NOMEM_BKPT, SQLITE_OK, and vdbePmaReadBlob().

Referenced by vdbePmaReadBlob().

◆ vdbePmaReaderBgIncrInit()

static void * vdbePmaReaderBgIncrInit ( void * pCtx )

static

Definition at line 96129 of file sqlite3.c.

96135 {

96136 PmaReader *pReader = (PmaReader*)pCtx;

References SortSubtask::bDone, INCRINIT_TASK, PmaReader::pIncr, IncrMerger::pTask, SQLITE_INT_TO_PTR, and vdbePmaReaderIncrMergeInit().

Referenced by vdbePmaReaderIncrInit().

◆ vdbePmaReaderClear()

static void vdbePmaReaderClear ( PmaReader * pReadr )

static

Definition at line 94347 of file sqlite3.c.

94353 {

◆ vdbePmaReaderIncrInit()

static int vdbePmaReaderIncrInit	(	PmaReader *	pReadr,
		int	eMode )

static

Definition at line 96150 of file sqlite3.c.

                                                              {
  IncrMerger *pIncr = pReadr->pIncr;   /* Incremental merger */
  int rc = SQLITE_OK;                  /* Return code */
  if( pIncr ){
#if SQLITE_MAX_WORKER_THREADS>0
    assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK );
    if( pIncr->bUseThread ){
      void *pCtx = (void*)pReadr;
      rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
    }else
#endif

References IncrMerger::bUseThread, INCRINIT_TASK, PmaReader::pIncr, IncrMerger::pTask, SQLITE_OK, vdbePmaReaderBgIncrInit(), vdbePmaReaderIncrMergeInit(), and vdbeSorterCreateThread().

Referenced by vdbeMergeEngineInit(), and vdbeSorterSetupMerge().

◆ vdbePmaReaderIncrMergeInit()

static int vdbePmaReaderIncrMergeInit	(	PmaReader *	pReadr,
		int	eMode )

static

Definition at line 96062 of file sqlite3.c.

                                                                   {
  int rc = SQLITE_OK;
  IncrMerger *pIncr = pReadr->pIncr;
  SortSubtask *pTask = pIncr->pTask;
  sqlite3 *db = pTask->pSorter->db;
 
  /* eMode is always INCRINIT_NORMAL in single-threaded mode */
  assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
 
  rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode);
 
  /* Set up the required files for pIncr. A multi-theaded IncrMerge object
  ** requires two temp files to itself, whereas a single-threaded object
  ** only requires a region of pTask->file2. */
  if( rc==SQLITE_OK ){
    int mxSz = pIncr->mxSz;
#if SQLITE_MAX_WORKER_THREADS>0
    if( pIncr->bUseThread ){
      rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd);
      if( rc==SQLITE_OK ){
        rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd);
      }
    }else
#endif
    /*if( !pIncr->bUseThread )*/{
      if( pTask->file2.pFd==0 ){
        assert( pTask->file2.iEof>0 );
        rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd);
        pTask->file2.iEof = 0;
      }
      if( rc==SQLITE_OK ){
        pIncr->aFile[1].pFd = pTask->file2.pFd;
        pIncr->iStartOff = pTask->file2.iEof;
        pTask->file2.iEof += mxSz;
      }
    }
  }
 
#if SQLITE_MAX_WORKER_THREADS>0
  if( rc==SQLITE_OK && pIncr->bUseThread ){
    /* Use the current thread to populate aFile[1], even though this
    ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object,
    ** then this function is already running in background thread
    ** pIncr->pTask->thread.
    **
    ** If this is the INCRINIT_ROOT object, then it is running in the
    ** main VDBE thread. But that is Ok, as that thread cannot return
    ** control to the VDBE or proceed with anything useful until the
    ** first results are ready from this merger object anyway.
    */
    assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK );
    rc = vdbeIncrPopulate(pIncr);
  }
#endif
 

References IncrMerger::aFile, IncrMerger::bUseThread, VdbeSorter::db, SortSubtask::file2, SorterFile::iEof, INCRINIT_NORMAL, INCRINIT_ROOT, INCRINIT_TASK, IncrMerger::iStartOff, IncrMerger::mxSz, SorterFile::pFd, PmaReader::pIncr, IncrMerger::pMerger, SortSubtask::pSorter, IncrMerger::pTask, SQLITE_MAX_WORKER_THREADS, SQLITE_OK, vdbeIncrPopulate(), vdbeMergeEngineInit(), vdbePmaReaderNext(), and vdbeSorterOpenTempFile().

Referenced by vdbePmaReaderBgIncrInit(), vdbePmaReaderIncrInit(), and vdbeSorterSetupMerge().

◆ vdbePmaReaderInit()

static int vdbePmaReaderInit	(	SortSubtask *	pTask,
		SorterFile *	pFile,
		i64	iStart,
		PmaReader *	pReadr,
		i64 *	pnByte )

static

Definition at line 94602 of file sqlite3.c.

 {
  int rc;
 
  assert( pFile->iEof>iStart );
  assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 );
  assert( pReadr->aBuffer==0 );
  assert( pReadr->aMap==0 );
 
  rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
  if( rc==SQLITE_OK ){
    u64 nByte = 0;                 /* Size of PMA in bytes */
    rc = vdbePmaReadVarint(pReadr, &nByte);
    pReadr->iEof = pReadr->iReadOff + nByte;
    *pnByte += nByte;
  }

References PmaReader::aAlloc, PmaReader::aBuffer, PmaReader::aMap, SorterFile::iEof, PmaReader::iEof, PmaReader::iReadOff, PmaReader::nAlloc, SQLITE_OK, vdbePmaReaderNext(), vdbePmaReaderSeek(), and vdbePmaReadVarint().

Referenced by vdbeMergeEngineLevel0().

◆ vdbePmaReaderNext()

static int vdbePmaReaderNext ( PmaReader * pReadr )

static

Definition at line 94555 of file sqlite3.c.

                                               {
  int rc = SQLITE_OK;             /* Return Code */
  u64 nRec = 0;                   /* Size of record in bytes */
 
 
  if( pReadr->iReadOff>=pReadr->iEof ){
    IncrMerger *pIncr = pReadr->pIncr;
    int bEof = 1;
    if( pIncr ){
      rc = vdbeIncrSwap(pIncr);
      if( rc==SQLITE_OK && pIncr->bEof==0 ){
        rc = vdbePmaReaderSeek(
            pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff
        );
        bEof = 0;
      }
    }
 
    if( bEof ){
      /* This is an EOF condition */
      vdbePmaReaderClear(pReadr);
      testcase( rc!=SQLITE_OK );
      return rc;
    }
  }
 
  if( rc==SQLITE_OK ){
    rc = vdbePmaReadVarint(pReadr, &nRec);
  }
  if( rc==SQLITE_OK ){
    pReadr->nKey = (int)nRec;

Referenced by sqlite3VdbeSorterNext(), vdbeMergeEngineInit(), vdbeMergeEngineStep(), vdbePmaReaderIncrMergeInit(), and vdbePmaReaderInit().

◆ vdbePmaReaderSeek()

static int vdbePmaReaderSeek	(	SortSubtask *	pTask,
		PmaReader *	pReadr,
		SorterFile *	pFile,
		i64	iOff )

static

Definition at line 94508 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
 
  assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 );
 
  if( sqlite3FaultSim(201) ) return SQLITE_IOERR_READ;
  if( pReadr->aMap ){
    sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
    pReadr->aMap = 0;
  }
  pReadr->iReadOff = iOff;
  pReadr->iEof = pFile->iEof;
  pReadr->pFd = pFile->pFd;
 
  rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
  if( rc==SQLITE_OK && pReadr->aMap==0 ){
    int pgsz = pTask->pSorter->pgsz;
    int iBuf = pReadr->iReadOff % pgsz;
    if( pReadr->aBuffer==0 ){
      pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz);
      if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM_BKPT;
      pReadr->nBuffer = pgsz;
    }
    if( rc==SQLITE_OK && iBuf ){
      int nRead = pgsz - iBuf;
      if( (pReadr->iReadOff + nRead) > pReadr->iEof ){
        nRead = (int)(pReadr->iEof - pReadr->iReadOff);
      }
      rc = sqlite3OsRead(
          pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff
      );

References PmaReader::aBuffer, PmaReader::aMap, IncrMerger::bEof, SorterFile::iEof, PmaReader::iEof, PmaReader::iReadOff, PmaReader::nBuffer, SorterFile::pFd, PmaReader::pFd, VdbeSorter::pgsz, PmaReader::pIncr, SortSubtask::pSorter, sqlite3FaultSim(), sqlite3Malloc(), sqlite3OsRead(), sqlite3OsUnfetch(), SQLITE_IOERR_READ, SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, and vdbeSorterMapFile().

Referenced by vdbePmaReaderInit().

◆ vdbePmaReadVarint()

static int vdbePmaReadVarint	(	PmaReader *	p,
		u64 *	pnOut )

static

Definition at line 94458 of file sqlite3.c.

                                                      {
  int iBuf;
 
  if( p->aMap ){
    p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut);
  }else{
    iBuf = p->iReadOff % p->nBuffer;
    if( iBuf && (p->nBuffer-iBuf)>=9 ){
      p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut);
    }else{
      u8 aVarint[16], *a;
      int i = 0, rc;
      do{
        rc = vdbePmaReadBlob(p, 1, &a);
        if( rc ) return rc;
        aVarint[(i++)&0xf] = a[0];
      }while( (a[0]&0x80)!=0 );

Referenced by vdbePmaReaderInit().

◆ vdbePmaWriteBlob()

static void vdbePmaWriteBlob	(	PmaWriter *	p,
		u8 *	pData,
		int	nData )

static

Definition at line 95348 of file sqlite3.c.

                                                                {
  int nRem = nData;
  while( nRem>0 && p->eFWErr==0 ){
    int nCopy = nRem;
    if( nCopy>(p->nBuffer - p->iBufEnd) ){
      nCopy = p->nBuffer - p->iBufEnd;
    }
 
    memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
    p->iBufEnd += nCopy;
    if( p->iBufEnd==p->nBuffer ){
      p->eFWErr = sqlite3OsWrite(p->pFd,
          &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
          p->iWriteOff + p->iBufStart
      );
      p->iBufStart = p->iBufEnd = 0;
      p->iWriteOff += p->nBuffer;

Referenced by vdbeIncrPopulate(), and vdbeSorterListToPMA().

◆ vdbePmaWriterFinish()

static int vdbePmaWriterFinish	(	PmaWriter *	p,
		i64 *	piEof )

static

Definition at line 95381 of file sqlite3.c.

                                                        {
  int rc;
  if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){
    p->eFWErr = sqlite3OsWrite(p->pFd,
        &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
        p->iWriteOff + p->iBufStart
    );
  }

References PmaWriter::aBuffer, ALWAYS, PmaWriter::eFWErr, PmaWriter::iBufEnd, PmaWriter::iBufStart, PmaWriter::iWriteOff, PmaWriter::pFd, sqlite3_free(), and sqlite3OsWrite().

Referenced by vdbeIncrPopulate(), and vdbeSorterListToPMA().

◆ vdbePmaWriterInit()

static void vdbePmaWriterInit	(	sqlite3_file *	pFd,
		PmaWriter *	p,
		int	nBuf,
		i64	iStart )

static

Definition at line 95326 of file sqlite3.c.

 {
  memset(p, 0, sizeof(PmaWriter));
  p->aBuffer = (u8*)sqlite3Malloc(nBuf);
  if( !p->aBuffer ){
    p->eFWErr = SQLITE_NOMEM_BKPT;
  }else{

Referenced by vdbeIncrPopulate(), and vdbeSorterListToPMA().

◆ vdbePmaWriteVarint()

static void vdbePmaWriteVarint	(	PmaWriter *	p,
		u64	iVal )

static

Definition at line 95400 of file sqlite3.c.

Referenced by vdbeIncrPopulate(), and vdbeSorterListToPMA().

◆ vdbeRecordCompareInt()

static int vdbeRecordCompareInt	(	int	nKey1,
		const void *	pKey1,
		UnpackedRecord *	pPKey2 )

static

Definition at line 82424 of file sqlite3.c.

 {
  const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F];
  int serial_type = ((const u8*)pKey1)[1];
  int res;
  u32 y;
  u64 x;
  i64 v;
  i64 lhs;
 
  vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
  assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB );
  switch( serial_type ){
    case 1: { /* 1-byte signed integer */
      lhs = ONE_BYTE_INT(aKey);
      testcase( lhs<0 );
      break;
    }
    case 2: { /* 2-byte signed integer */
      lhs = TWO_BYTE_INT(aKey);
      testcase( lhs<0 );
      break;
    }
    case 3: { /* 3-byte signed integer */
      lhs = THREE_BYTE_INT(aKey);
      testcase( lhs<0 );
      break;
    }
    case 4: { /* 4-byte signed integer */
      y = FOUR_BYTE_UINT(aKey);
      lhs = (i64)*(int*)&y;
      testcase( lhs<0 );
      break;
    }
    case 5: { /* 6-byte signed integer */
      lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
      testcase( lhs<0 );
      break;
    }
    case 6: { /* 8-byte signed integer */
      x = FOUR_BYTE_UINT(aKey);
      x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
      lhs = *(i64*)&x;
      testcase( lhs<0 );
      break;
    }
    case 8:
      lhs = 0;
      break;
    case 9:
      lhs = 1;
      break;
 
    /* This case could be removed without changing the results of running
    ** this code. Including it causes gcc to generate a faster switch
    ** statement (since the range of switch targets now starts at zero and
    ** is contiguous) but does not cause any duplicate code to be generated
    ** (as gcc is clever enough to combine the two like cases). Other
    ** compilers might be similar.  */
    case 0: case 7:
      return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
 
    default:
      return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
  }
 
  v = pPKey2->aMem[0].u.i;
  if( v>lhs ){
    res = pPKey2->r1;
  }else if( v<lhs ){
    res = pPKey2->r2;
  }else if( pPKey2->nField>1 ){
    /* The first fields of the two keys are equal. Compare the trailing
    ** fields.  */
    res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
  }else{
    /* The first fields of the two keys are equal and there are no trailing
    ** fields. Return pPKey2->default_rc in this case. */
    res = pPKey2->default_rc;

References UnpackedRecord::aMem, CORRUPT_DB, UnpackedRecord::default_rc, UnpackedRecord::eqSeen, FOUR_BYTE_UINT, sqlite3_value::MemValue::i, UnpackedRecord::nField, ONE_BYTE_INT, UnpackedRecord::pKeyInfo, UnpackedRecord::r1, UnpackedRecord::r2, sqlite3VdbeRecordCompare(), sqlite3VdbeRecordCompareWithSkip(), testcase, THREE_BYTE_INT, TWO_BYTE_INT, sqlite3_value::u, and vdbeAssertFieldCountWithinLimits.

Referenced by sqlite3VdbeFindCompare().

◆ vdbeRecordCompareString()

static int vdbeRecordCompareString	(	int	nKey1,
		const void *	pKey1,
		UnpackedRecord *	pPKey2 )

static

Definition at line 82518 of file sqlite3.c.

 {
  const u8 *aKey1 = (const u8*)pKey1;
  int serial_type;
  int res;
 
  assert( pPKey2->aMem[0].flags & MEM_Str );
  vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
  serial_type = (u8)(aKey1[1]);
  if( serial_type >= 0x80 ){
    sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type);
  }
  if( serial_type<12 ){
    res = pPKey2->r1;      /* (pKey1/nKey1) is a number or a null */
  }else if( !(serial_type & 0x01) ){
    res = pPKey2->r2;      /* (pKey1/nKey1) is a blob */
  }else{
    int nCmp;
    int nStr;
    int szHdr = aKey1[0];
 
    nStr = (serial_type-12) / 2;
    if( (szHdr + nStr) > nKey1 ){
      pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
      return 0;    /* Corruption */
    }
    nCmp = MIN( pPKey2->aMem[0].n, nStr );
    res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);
 
    if( res>0 ){
      res = pPKey2->r2;
    }else if( res<0 ){
      res = pPKey2->r1;
    }else{
      res = nStr - pPKey2->aMem[0].n;
      if( res==0 ){
        if( pPKey2->nField>1 ){
          res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
        }else{
          res = pPKey2->default_rc;
          pPKey2->eqSeen = 1;
        }
      }else if( res>0 ){
        res = pPKey2->r2;
      }else{
        res = pPKey2->r1;
      }
    }
  }
 

References UnpackedRecord::aMem, CORRUPT_DB, KeyInfo::db, UnpackedRecord::default_rc, UnpackedRecord::eqSeen, UnpackedRecord::errCode, sqlite3_value::flags, sqlite3::mallocFailed, MEM_Str, MIN, sqlite3_value::n, UnpackedRecord::nField, UnpackedRecord::pKeyInfo, UnpackedRecord::r1, UnpackedRecord::r2, sqlite3GetVarint32(), sqlite3VdbeRecordCompareWithSkip(), SQLITE_CORRUPT_BKPT, vdbeAssertFieldCountWithinLimits, and sqlite3_value::z.

Referenced by sqlite3VdbeFindCompare().

◆ vdbeRecordDecodeInt()

static i64 vdbeRecordDecodeInt	(	u32	serial_type,
		const u8 *	aKey )

static

Definition at line 82155 of file sqlite3.c.

                                                               {
  u32 y;
  assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
  switch( serial_type ){
    case 0:
    case 1:
      testcase( aKey[0]&0x80 );
      return ONE_BYTE_INT(aKey);
    case 2:
      testcase( aKey[0]&0x80 );
      return TWO_BYTE_INT(aKey);
    case 3:
      testcase( aKey[0]&0x80 );
      return THREE_BYTE_INT(aKey);
    case 4: {
      testcase( aKey[0]&0x80 );
      y = FOUR_BYTE_UINT(aKey);
      return (i64)*(int*)&y;
    }
    case 5: {
      testcase( aKey[0]&0x80 );
      return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
    }
    case 6: {
      u64 x = FOUR_BYTE_UINT(aKey);
      testcase( aKey[0]&0x80 );
      x = (x<<32) | FOUR_BYTE_UINT(aKey+4);

References CORRUPT_DB, FOUR_BYTE_UINT, ONE_BYTE_INT, testcase, THREE_BYTE_INT, and TWO_BYTE_INT.

Referenced by sqlite3VdbeRecordCompareWithSkip().

◆ vdbeReleaseAndSetInt64()

static SQLITE_NOINLINE void vdbeReleaseAndSetInt64	(	Mem *	pMem,
		i64	val )

static

Definition at line 76676 of file sqlite3.c.

References sqlite3_value::flags, sqlite3_value::MemValue::i, MEM_Int, sqlite3VdbeMemSetNull(), and sqlite3_value::u.

◆ vdbeSafety()

static int vdbeSafety ( Vdbe * p )

static

Definition at line 83020 of file sqlite3.c.

83026 {

83027 if( p->db==0 ){

References Vdbe::db.

Referenced by sqlite3_finalize().

◆ vdbeSafetyNotNull()

static int vdbeSafetyNotNull ( Vdbe * p )

static

Definition at line 83028 of file sqlite3.c.

       {
    return 0;
  }
}
static int vdbeSafetyNotNull(Vdbe *p){
  if( p==0 ){

Referenced by sqlite3_step(), and vdbeUnbind().

◆ vdbeSortAllocUnpacked()

static int vdbeSortAllocUnpacked ( SortSubtask * pTask )

static

Definition at line 95205 of file sqlite3.c.

                                                    {
  if( pTask->pUnpacked==0 ){
    pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);

References UnpackedRecord::errCode, UnpackedRecord::nField, KeyInfo::nKeyField, VdbeSorter::pKeyInfo, SortSubtask::pSorter, SortSubtask::pUnpacked, sqlite3VdbeAllocUnpackedRecord(), SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by vdbeSorterSetupMerge(), and vdbeSorterSort().

◆ vdbeSorterAddToTree()

static int vdbeSorterAddToTree	(	SortSubtask *	pTask,
		int	nDepth,
		int	iSeq,
		MergeEngine *	pRoot,
		MergeEngine *	pLeaf )

static

Definition at line 96237 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  int nDiv = 1;
  int i;
  MergeEngine *p = pRoot;
  IncrMerger *pIncr;
 
  rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr);
 
  for(i=1; i<nDepth; i++){
    nDiv = nDiv * SORTER_MAX_MERGE_COUNT;
  }
 
  for(i=1; i<nDepth && rc==SQLITE_OK; i++){
    int iIter = (iSeq / nDiv) % SORTER_MAX_MERGE_COUNT;
    PmaReader *pReadr = &p->aReadr[iIter];
 
    if( pReadr->pIncr==0 ){
      MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT);
      if( pNew==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
      }
    }
    if( rc==SQLITE_OK ){
      p = pReadr->pIncr->pMerger;
      nDiv = nDiv / SORTER_MAX_MERGE_COUNT;
    }
  }
 
  if( rc==SQLITE_OK ){

References MergeEngine::aReadr, PmaReader::pIncr, IncrMerger::pMerger, SORTER_MAX_MERGE_COUNT, SQLITE_NOMEM_BKPT, SQLITE_OK, vdbeIncrFree(), vdbeIncrMergerNew(), and vdbeMergeEngineNew().

Referenced by vdbeSorterMergeTreeBuild().

◆ vdbeSorterCompare()

static int vdbeSorterCompare	(	SortSubtask *	pTask,
		int *	pbKey2Cached,
		const void *	pKey1,
		int	nKey1,
		const void *	pKey2,
		int	nKey2 )

static

Definition at line 94662 of file sqlite3.c.

94673 {

94674 UnpackedRecord *r2 = pTask->pUnpacked;

References VdbeSorter::pKeyInfo, SortSubtask::pSorter, SortSubtask::pUnpacked, sqlite3VdbeRecordCompare(), and sqlite3VdbeRecordUnpack().

◆ vdbeSorterCompareInt()

static int vdbeSorterCompareInt	(	SortSubtask *	pTask,
		int *	pbKey2Cached,
		const void *	pKey1,
		int	nKey1,
		const void *	pKey2,
		int	nKey2 )

static

Definition at line 94723 of file sqlite3.c.

 {
  const u8 * const p1 = (const u8 * const)pKey1;
  const u8 * const p2 = (const u8 * const)pKey2;
  const int s1 = p1[1];                 /* Left hand serial type */
  const int s2 = p2[1];                 /* Right hand serial type */
  const u8 * const v1 = &p1[ p1[0] ];   /* Pointer to value 1 */
  const u8 * const v2 = &p2[ p2[0] ];   /* Pointer to value 2 */
  int res;                              /* Return value */
 
  assert( (s1>0 && s1<7) || s1==8 || s1==9 );
  assert( (s2>0 && s2<7) || s2==8 || s2==9 );
 
  if( s1==s2 ){
    /* The two values have the same sign. Compare using memcmp(). */
    static const u8 aLen[] = {0, 1, 2, 3, 4, 6, 8, 0, 0, 0 };
    const u8 n = aLen[s1];
    int i;
    res = 0;
    for(i=0; i<n; i++){
      if( (res = v1[i] - v2[i])!=0 ){
        if( ((v1[0] ^ v2[0]) & 0x80)!=0 ){
          res = v1[0] & 0x80 ? -1 : +1;
        }
        break;
      }
    }
  }else if( s1>7 && s2>7 ){
    res = s1 - s2;
  }else{
    if( s2>7 ){
      res = +1;
    }else if( s1>7 ){
      res = -1;
    }else{
      res = s1 - s2;
    }
    assert( res!=0 );
 
    if( res>0 ){
      if( *v1 & 0x80 ) res = -1;
    }else{
      if( *v2 & 0x80 ) res = +1;
    }
  }
 
  if( res==0 ){
    if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
      res = vdbeSorterCompareTail(
          pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
      );
    }
  }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){

◆ vdbeSorterCompareTail()

static int vdbeSorterCompareTail	(	SortSubtask *	pTask,
		int *	pbKey2Cached,
		const void *	pKey1,
		int	nKey1,
		const void *	pKey2,
		int	nKey2 )

static

Definition at line 94635 of file sqlite3.c.

94646 {

94647 UnpackedRecord *r2 = pTask->pUnpacked;

References VdbeSorter::pKeyInfo, SortSubtask::pSorter, SortSubtask::pUnpacked, sqlite3VdbeRecordCompareWithSkip(), and sqlite3VdbeRecordUnpack().

Referenced by vdbeSorterCompareText().

◆ vdbeSorterCompareText()

static int vdbeSorterCompareText	(	SortSubtask *	pTask,
		int *	pbKey2Cached,
		const void *	pKey1,
		int	nKey1,
		const void *	pKey2,
		int	nKey2 )

static

Definition at line 94681 of file sqlite3.c.

 {
  const u8 * const p1 = (const u8 * const)pKey1;
  const u8 * const p2 = (const u8 * const)pKey2;
  const u8 * const v1 = &p1[ p1[0] ];   /* Pointer to value 1 */
  const u8 * const v2 = &p2[ p2[0] ];   /* Pointer to value 2 */
 
  int n1;
  int n2;
  int res;
 
  getVarint32NR(&p1[1], n1);
  getVarint32NR(&p2[1], n2);
  res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2);
  if( res==0 ){
    res = n1 - n2;
  }
 
  if( res==0 ){
    if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
      res = vdbeSorterCompareTail(
          pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
      );
    }
  }else{
    assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
    if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){

References KeyInfo::aSortFlags, getVarint32NR, KEYINFO_ORDER_BIGNULL, MIN, KeyInfo::nKeyField, VdbeSorter::pKeyInfo, SortSubtask::pSorter, and vdbeSorterCompareTail().

◆ vdbeSorterCreateThread()

static int vdbeSorterCreateThread	(	SortSubtask *	pTask,
		void ()(void *)	xTask,
		void *	pIn )

static

Definition at line 95007 of file sqlite3.c.

Referenced by vdbePmaReaderIncrInit(), and vdbeSorterFlushPMA().

◆ vdbeSorterFlushPMA()

static int vdbeSorterFlushPMA ( VdbeSorter * pSorter )

static

Definition at line 95570 of file sqlite3.c.

                                                  {
#if SQLITE_MAX_WORKER_THREADS==0
  pSorter->bUsePMA = 1;
  return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list);
#else
  int rc = SQLITE_OK;
  int i;
  SortSubtask *pTask = 0;    /* Thread context used to create new PMA */
  int nWorker = (pSorter->nTask-1);
 
  /* Set the flag to indicate that at least one PMA has been written.
  ** Or will be, anyhow.  */
  pSorter->bUsePMA = 1;
 
  /* Select a sub-task to sort and flush the current list of in-memory
  ** records to disk. If the sorter is running in multi-threaded mode,
  ** round-robin between the first (pSorter->nTask-1) tasks. Except, if
  ** the background thread from a sub-tasks previous turn is still running,
  ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
  ** fall back to using the final sub-task. The first (pSorter->nTask-1)
  ** sub-tasks are prefered as they use background threads - the final
  ** sub-task uses the main thread. */
  for(i=0; i<nWorker; i++){
    int iTest = (pSorter->iPrev + i + 1) % nWorker;
    pTask = &pSorter->aTask[iTest];
    if( pTask->bDone ){
      rc = vdbeSorterJoinThread(pTask);
    }
    if( rc!=SQLITE_OK || pTask->pThread==0 ) break;
  }
 
  if( rc==SQLITE_OK ){
    if( i==nWorker ){
      /* Use the foreground thread for this operation */
      rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list);
    }else{
      /* Launch a background thread for this operation */
      u8 *aMem;
      void *pCtx;
 
      assert( pTask!=0 );
      assert( pTask->pThread==0 && pTask->bDone==0 );
      assert( pTask->list.pList==0 );
      assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
 
      aMem = pTask->list.aMemory;
      pCtx = (void*)pTask;
      pSorter->iPrev = (u8)(pTask - pSorter->aTask);
      pTask->list = pSorter->list;
      pSorter->list.pList = 0;
      pSorter->list.szPMA = 0;
      if( aMem ){
        pSorter->list.aMemory = aMem;
        pSorter->nMemory = sqlite3MallocSize(aMem);
      }else if( pSorter->list.aMemory ){
        pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory);
        if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT;
      }
 
      rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx);

References SorterList::aMemory, VdbeSorter::aTask, SortSubtask::bDone, VdbeSorter::bUsePMA, VdbeSorter::iPrev, SortSubtask::list, VdbeSorter::list, VdbeSorter::nMemory, VdbeSorter::nTask, SorterList::pList, SortSubtask::pThread, sqlite3Malloc(), sqlite3MallocSize(), SQLITE_NOMEM_BKPT, SQLITE_OK, SorterList::szPMA, vdbeSorterCreateThread(), vdbeSorterFlushThread(), vdbeSorterJoinThread(), and vdbeSorterListToPMA().

Referenced by sqlite3VdbeSorterRewind().

◆ vdbeSorterFlushThread()

static void * vdbeSorterFlushThread ( void * pCtx )

static

Definition at line 95556 of file sqlite3.c.

95562 {

95563 SortSubtask *pTask = (SortSubtask*)pCtx;

Referenced by vdbeSorterFlushPMA().

◆ vdbeSorterGetCompare()

static SorterCompare vdbeSorterGetCompare ( VdbeSorter * p )

static

Definition at line 95261 of file sqlite3.c.

95267 {

95268 if( p->typeMask==SORTER_TYPE_INTEGER ){

Referenced by vdbeSorterSetupMerge(), and vdbeSorterSort().

◆ vdbeSorterJoinAll()

static int vdbeSorterJoinAll	(	VdbeSorter *	pSorter,
		int	rcin )

static

Definition at line 95020 of file sqlite3.c.

                                                           {
  int rc = rcin;
  int i;
 
  /* This function is always called by the main user thread.
  **
  ** If this function is being called after SorterRewind() has been called,
  ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread
  ** is currently attempt to join one of the other threads. To avoid a race
  ** condition where this thread also attempts to join the same object, join
  ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */
  for(i=pSorter->nTask-1; i>=0; i--){

Referenced by sqlite3VdbeSorterRewind().

◆ vdbeSorterJoinThread()

static int vdbeSorterJoinThread ( SortSubtask * pTask )

static

Definition at line 94986 of file sqlite3.c.

                                                   {
  int rc = SQLITE_OK;
  if( pTask->pThread ){
#ifdef SQLITE_DEBUG_SORTER_THREADS
    int bDone = pTask->bDone;
#endif
    void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR);
    vdbeSorterBlockDebug(pTask, !bDone, "enter");
    (void)sqlite3ThreadJoin(pTask->pThread, &pRet);
    vdbeSorterBlockDebug(pTask, !bDone, "exit");
    rc = SQLITE_PTR_TO_INT(pRet);

References SortSubtask::bDone, SortSubtask::pThread, sqlite3ThreadJoin(), SQLITE_ERROR, SQLITE_INT_TO_PTR, SQLITE_OK, SQLITE_PTR_TO_INT, and vdbeSorterBlockDebug.

Referenced by vdbeIncrSwap(), and vdbeSorterFlushPMA().

◆ vdbeSorterListToPMA()

static int vdbeSorterListToPMA	(	SortSubtask *	pTask,
		SorterList *	pList )

static

Definition at line 95421 of file sqlite3.c.

                                                                     {
  sqlite3 *db = pTask->pSorter->db;
  int rc = SQLITE_OK;             /* Return code */
  PmaWriter writer;               /* Object used to write to the file */
 
#ifdef SQLITE_DEBUG
  /* Set iSz to the expected size of file pTask->file after writing the PMA.
  ** This is used by an assert() statement at the end of this function.  */
  i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof;
#endif
 
  vdbeSorterWorkDebug(pTask, "enter");
  memset(&writer, 0, sizeof(PmaWriter));
  assert( pList->szPMA>0 );
 
  /* If the first temporary PMA file has not been opened, open it now. */
  if( pTask->file.pFd==0 ){
    rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd);
    assert( rc!=SQLITE_OK || pTask->file.pFd );
    assert( pTask->file.iEof==0 );
    assert( pTask->nPMA==0 );
  }
 
  /* Try to get the file to memory map */
  if( rc==SQLITE_OK ){
    vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9);
  }
 
  /* Sort the list */
  if( rc==SQLITE_OK ){
    rc = vdbeSorterSort(pTask, pList);
  }
 
  if( rc==SQLITE_OK ){
    SorterRecord *p;
    SorterRecord *pNext = 0;
 
    vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz,
                      pTask->file.iEof);
    pTask->nPMA++;
    vdbePmaWriteVarint(&writer, pList->szPMA);
    for(p=pList->pList; p; p=pNext){
      pNext = p->u.pNext;
      vdbePmaWriteVarint(&writer, p->nVal);
      vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal);
      if( pList->aMemory==0 ) sqlite3_free(p);
    }
    pList->pList = p;
    rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof);
  }

References SorterList::aMemory, VdbeSorter::db, SortSubtask::file, SorterFile::iEof, SortSubtask::nPMA, SorterRecord::nVal, SorterFile::pFd, VdbeSorter::pgsz, SorterList::pList, SorterRecord::pNext, SortSubtask::pSorter, sqlite3_free(), sqlite3VarintLen(), SQLITE_OK, SRVAL, SorterList::szPMA, SorterRecord::u, vdbePmaWriteBlob(), vdbePmaWriterFinish(), vdbePmaWriterInit(), vdbePmaWriteVarint(), vdbeSorterExtendFile, vdbeSorterOpenTempFile(), vdbeSorterSort(), vdbeSorterWorkDebug, and writer().

Referenced by vdbeSorterFlushPMA().

◆ vdbeSorterMapFile()

static int vdbeSorterMapFile	(	SortSubtask *	pTask,
		SorterFile *	pFile,
		u8 **	pp )

static

Definition at line 94491 of file sqlite3.c.

                                                                            {
  int rc = SQLITE_OK;
  if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
    sqlite3_file *pFd = pFile->pFd;
    if( pFd->pMethods->iVersion>=3 ){

References VdbeSorter::db, SorterFile::iEof, sqlite3_io_methods::iVersion, sqlite3::nMaxSorterMmap, SorterFile::pFd, sqlite3_file::pMethods, SortSubtask::pSorter, sqlite3OsFetch(), SQLITE_OK, and testcase.

Referenced by vdbePmaReaderSeek().

◆ vdbeSorterMerge()

static SorterRecord * vdbeSorterMerge	(	SortSubtask *	pTask,
		SorterRecord *	p1,
		SorterRecord *	p2 )

static

Definition at line 95219 of file sqlite3.c.

 {
  SorterRecord *pFinal = 0;
  SorterRecord **pp = &pFinal;
  int bCached = 0;
 
  assert( p1!=0 && p2!=0 );
  for(;;){
    int res;
    res = pTask->xCompare(
        pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
    );
 
    if( res<=0 ){
      *pp = p1;
      pp = &p1->u.pNext;
      p1 = p1->u.pNext;
      if( p1==0 ){
        *pp = p2;
        break;
      }
    }else{
      *pp = p2;
      pp = &p2->u.pNext;
      p2 = p2->u.pNext;
      bCached = 0;
      if( p2==0 ){
        *pp = p1;

Referenced by vdbeSorterSort().

◆ vdbeSorterMergeTreeBuild()

static int vdbeSorterMergeTreeBuild	(	VdbeSorter *	pSorter,
		MergeEngine **	ppOut )

static

Definition at line 96293 of file sqlite3.c.

 {
  MergeEngine *pMain = 0;
  int rc = SQLITE_OK;
  int iTask;
 
#if SQLITE_MAX_WORKER_THREADS>0
  /* If the sorter uses more than one task, then create the top-level
  ** MergeEngine here. This MergeEngine will read data from exactly
  ** one PmaReader per sub-task.  */
  assert( pSorter->bUseThreads || pSorter->nTask==1 );
  if( pSorter->nTask>1 ){
    pMain = vdbeMergeEngineNew(pSorter->nTask);
    if( pMain==0 ) rc = SQLITE_NOMEM_BKPT;
  }
#endif
 
  for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
    SortSubtask *pTask = &pSorter->aTask[iTask];
    assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 );
    if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){
      MergeEngine *pRoot = 0;     /* Root node of tree for this task */
      int nDepth = vdbeSorterTreeDepth(pTask->nPMA);
      i64 iReadOff = 0;
 
      if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){
        rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot);
      }else{
        int i;
        int iSeq = 0;
        pRoot = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT);
        if( pRoot==0 ) rc = SQLITE_NOMEM_BKPT;
        for(i=0; i<pTask->nPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){
          MergeEngine *pMerger = 0; /* New level-0 PMA merger */
          int nReader;              /* Number of level-0 PMAs to merge */
 
          nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT);
          rc = vdbeMergeEngineLevel0(pTask, nReader, &iReadOff, &pMerger);
          if( rc==SQLITE_OK ){
            rc = vdbeSorterAddToTree(pTask, nDepth, iSeq++, pRoot, pMerger);
          }
        }
      }
 
      if( rc==SQLITE_OK ){
#if SQLITE_MAX_WORKER_THREADS>0
        if( pMain!=0 ){
          rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr);
        }else
#endif
        {
          assert( pMain==0 );
          pMain = pRoot;
        }
      }else{
        vdbeMergeEngineFree(pRoot);
      }
    }
  }
 
  if( rc!=SQLITE_OK ){

References MergeEngine::aReadr, VdbeSorter::aTask, VdbeSorter::bUseThreads, MIN, SortSubtask::nPMA, VdbeSorter::nTask, PmaReader::pIncr, SORTER_MAX_MERGE_COUNT, SQLITE_MAX_WORKER_THREADS, SQLITE_NOMEM_BKPT, SQLITE_OK, vdbeIncrMergerNew(), vdbeMergeEngineFree(), vdbeMergeEngineLevel0(), vdbeMergeEngineNew(), vdbeSorterAddToTree(), and vdbeSorterTreeDepth().

Referenced by vdbeSorterSetupMerge().

◆ vdbeSorterOpenTempFile()

static int vdbeSorterOpenTempFile	(	sqlite3 *	db,
		i64	nExtend,
		sqlite3_file **	ppFd )

static

Definition at line 95178 of file sqlite3.c.

 {
  int rc;
  if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS;
  rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
      SQLITE_OPEN_TEMP_JOURNAL |
      SQLITE_OPEN_READWRITE    | SQLITE_OPEN_CREATE |
      SQLITE_OPEN_EXCLUSIVE    | SQLITE_OPEN_DELETEONCLOSE, &rc
  );
  if( rc==SQLITE_OK ){
    i64 max = SQLITE_MAX_MMAP_SIZE;
    sqlite3OsFileControlHint(*ppFd, SQLITE_FCNTL_MMAP_SIZE, (void*)&max);

References sqlite3::pVfs, sqlite3FaultSim(), sqlite3OsFileControlHint(), sqlite3OsOpenMalloc(), SQLITE_FCNTL_MMAP_SIZE, SQLITE_IOERR_ACCESS, SQLITE_MAX_MMAP_SIZE, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_DELETEONCLOSE, SQLITE_OPEN_EXCLUSIVE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_TEMP_JOURNAL, and vdbeSorterExtendFile.

Referenced by vdbePmaReaderIncrMergeInit(), and vdbeSorterListToPMA().

◆ vdbeSorterRecordFree()

static void vdbeSorterRecordFree	(	sqlite3 *	db,
		SorterRecord *	pRecord )

static

Definition at line 94908 of file sqlite3.c.

94914 {

94915 SorterRecord *p;

Referenced by sqlite3VdbeSorterNext().

◆ vdbeSorterRowkey()

static void * vdbeSorterRowkey	(	const VdbeSorter *	pSorter,
		int *	pnKey )

static

Definition at line 96544 of file sqlite3.c.

 {
  void *pKey;
  if( pSorter->bUsePMA ){
    PmaReader *pReader;
#if SQLITE_MAX_WORKER_THREADS>0
    if( pSorter->bUseThreads ){
      pReader = pSorter->pReader;
    }else
#endif
    /*if( !pSorter->bUseThreads )*/{
      pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]];
    }
    *pnKey = pReader->nKey;
    pKey = pReader->aKey;

Referenced by sqlite3VdbeSorterCompare().

◆ vdbeSorterSetupMerge()

static int vdbeSorterSetupMerge ( VdbeSorter * pSorter )

static

Definition at line 96372 of file sqlite3.c.

                                                    {
  int rc;                         /* Return code */
  SortSubtask *pTask0 = &pSorter->aTask[0];
  MergeEngine *pMain = 0;
#if SQLITE_MAX_WORKER_THREADS
  sqlite3 *db = pTask0->pSorter->db;
  int i;
  SorterCompare xCompare = vdbeSorterGetCompare(pSorter);
  for(i=0; i<pSorter->nTask; i++){
    pSorter->aTask[i].xCompare = xCompare;
  }
#endif
 
  rc = vdbeSorterMergeTreeBuild(pSorter, &pMain);
  if( rc==SQLITE_OK ){
#if SQLITE_MAX_WORKER_THREADS
    assert( pSorter->bUseThreads==0 || pSorter->nTask>1 );
    if( pSorter->bUseThreads ){
      int iTask;
      PmaReader *pReadr = 0;
      SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1];
      rc = vdbeSortAllocUnpacked(pLast);
      if( rc==SQLITE_OK ){
        pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader));
        pSorter->pReader = pReadr;
        if( pReadr==0 ) rc = SQLITE_NOMEM_BKPT;
      }
      if( rc==SQLITE_OK ){
        rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr);
        if( rc==SQLITE_OK ){
          vdbeIncrMergerSetThreads(pReadr->pIncr);
          for(iTask=0; iTask<(pSorter->nTask-1); iTask++){
            IncrMerger *pIncr;
            if( (pIncr = pMain->aReadr[iTask].pIncr) ){
              vdbeIncrMergerSetThreads(pIncr);
              assert( pIncr->pTask!=pLast );
            }
          }
          for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
            /* Check that:
            **
            **   a) The incremental merge object is configured to use the
            **      right task, and
            **   b) If it is using task (nTask-1), it is configured to run
            **      in single-threaded mode. This is important, as the
            **      root merge (INCRINIT_ROOT) will be using the same task
            **      object.
            */
            PmaReader *p = &pMain->aReadr[iTask];
            assert( p->pIncr==0 || (
                (p->pIncr->pTask==&pSorter->aTask[iTask])             /* a */
             && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0)  /* b */
            ));
            rc = vdbePmaReaderIncrInit(p, INCRINIT_TASK);
          }
        }
        pMain = 0;
      }
      if( rc==SQLITE_OK ){
        rc = vdbePmaReaderIncrMergeInit(pReadr, INCRINIT_ROOT);
      }
    }else
#endif
    {
      rc = vdbeMergeEngineInit(pTask0, pMain, INCRINIT_NORMAL);
      pSorter->pMerger = pMain;
      pMain = 0;
    }
  }

References MergeEngine::aReadr, VdbeSorter::aTask, IncrMerger::bUseThread, VdbeSorter::bUseThreads, VdbeSorter::db, INCRINIT_NORMAL, INCRINIT_ROOT, INCRINIT_TASK, VdbeSorter::nTask, PmaReader::pIncr, VdbeSorter::pMerger, VdbeSorter::pReader, SortSubtask::pSorter, IncrMerger::pTask, sqlite3DbMallocZero(), SQLITE_NOMEM_BKPT, SQLITE_OK, vdbeIncrMergerNew(), vdbeIncrMergerSetThreads(), vdbeMergeEngineFree(), vdbeMergeEngineInit(), vdbePmaReaderIncrInit(), vdbePmaReaderIncrMergeInit(), vdbeSortAllocUnpacked(), vdbeSorterGetCompare(), vdbeSorterMergeTreeBuild(), and SortSubtask::xCompare.

Referenced by sqlite3VdbeSorterRewind().

◆ vdbeSorterSort()

static int vdbeSorterSort	(	SortSubtask *	pTask,
		SorterList *	pList )

static

Definition at line 95275 of file sqlite3.c.

                                                                {
  int i;
  SorterRecord *p;
  int rc;
  SorterRecord *aSlot[64];
 
  rc = vdbeSortAllocUnpacked(pTask);
  if( rc!=SQLITE_OK ) return rc;
 
  p = pList->pList;
  pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);
  memset(aSlot, 0, sizeof(aSlot));
 
  while( p ){
    SorterRecord *pNext;
    if( pList->aMemory ){
      if( (u8*)p==pList->aMemory ){
        pNext = 0;
      }else{
        assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
        pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
      }
    }else{
      pNext = p->u.pNext;
    }
 
    p->u.pNext = 0;
    for(i=0; aSlot[i]; i++){
      p = vdbeSorterMerge(pTask, p, aSlot[i]);
      aSlot[i] = 0;
    }
    aSlot[i] = p;
    p = pNext;
  }
 
  p = 0;
  for(i=0; i<ArraySize(aSlot); i++){
    if( aSlot[i]==0 ) continue;
    p = p ? vdbeSorterMerge(pTask, p, aSlot[i]) : aSlot[i];
  }
  pList->pList = p;

References SorterList::aMemory, ArraySize, UnpackedRecord::errCode, SorterRecord::iNext, SorterList::pList, SorterRecord::pNext, SortSubtask::pSorter, SortSubtask::pUnpacked, sqlite3MallocSize(), SQLITE_NOMEM, SQLITE_OK, SorterRecord::u, vdbeSortAllocUnpacked(), vdbeSorterGetCompare(), vdbeSorterMerge(), and SortSubtask::xCompare.

Referenced by sqlite3VdbeSorterRewind(), and vdbeSorterListToPMA().

◆ vdbeSorterTreeDepth()

static int vdbeSorterTreeDepth ( int nPMA )

static

Definition at line 96219 of file sqlite3.c.

                                        {
  int nDepth = 0;
  i64 nDiv = SORTER_MAX_MERGE_COUNT;

References SORTER_MAX_MERGE_COUNT.

Referenced by vdbeSorterMergeTreeBuild().

◆ vdbeSortSubtaskCleanup()

static void vdbeSortSubtaskCleanup	(	sqlite3 *	db,
		SortSubtask *	pTask )

static

Definition at line 94921 of file sqlite3.c.

                                                                   {
  sqlite3DbFree(db, pTask->pUnpacked);
#if SQLITE_MAX_WORKER_THREADS>0
  /* pTask->list.aMemory can only be non-zero if it was handed memory
  ** from the main thread.  That only occurs SQLITE_MAX_WORKER_THREADS>0 */
  if( pTask->list.aMemory ){
    sqlite3_free(pTask->list.aMemory);
  }else
#endif
  {
    assert( pTask->list.aMemory==0 );
    vdbeSorterRecordFree(0, pTask->list.pList);
  }
  if( pTask->file.pFd ){
    sqlite3OsCloseFree(pTask->file.pFd);

◆ vdbeUnbind()

static int vdbeUnbind	(	Vdbe *	p,
		int	i )

static

Definition at line 84311 of file sqlite3.c.

                                     {
  Mem *pVar;
  if( vdbeSafetyNotNull(p) ){
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(p->db->mutex);
  if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
    sqlite3Error(p->db, SQLITE_MISUSE);
    sqlite3_mutex_leave(p->db->mutex);
    sqlite3_log(SQLITE_MISUSE,
        "bind on a busy prepared statement: [%s]", p->zSql);
    return SQLITE_MISUSE_BKPT;
  }
  if( i<1 || i>p->nVar ){
    sqlite3Error(p->db, SQLITE_RANGE);
    sqlite3_mutex_leave(p->db->mutex);
    return SQLITE_RANGE;
  }
  i--;
  pVar = &p->aVar[i];
  sqlite3VdbeMemRelease(pVar);
  pVar->flags = MEM_Null;
  p->db->errCode = SQLITE_OK;
 
  /* If the bit corresponding to this variable in Vdbe.expmask is set, then
  ** binding a new value to this variable invalidates the current query plan.
  **
  ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host
  ** parameter in the WHERE clause might influence the choice of query plan
  ** for a statement, then the statement will be automatically recompiled,
  ** as if there had been a schema change, on the first sqlite3_step() call
  ** following any change to the bindings of that parameter.
  */

References Vdbe::aVar, Vdbe::db, sqlite3::errCode, Vdbe::expired, Vdbe::expmask, sqlite3_value::flags, Vdbe::magic, MEM_Null, sqlite3::mutex, Vdbe::nVar, Vdbe::pc, Vdbe::prepFlags, sqlite3_log(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3Error(), sqlite3VdbeMemRelease(), SQLITE_MISUSE, SQLITE_MISUSE_BKPT, SQLITE_OK, SQLITE_PREPARE_SAVESQL, SQLITE_RANGE, VDBE_MAGIC_RUN, vdbeSafetyNotNull(), and Vdbe::zSql.

◆ verifyDbFile()

static void verifyDbFile ( unixFile * pFile )

static

Definition at line 35015 of file sqlite3.c.

                                         {
  struct stat buf;
  int rc;
 
  /* These verifications occurs for the main database only */
  if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;
 
  rc = osFstat(pFile->h, &buf);
  if( rc!=0 ){
    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink==0 ){
    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink>1 ){
    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
    return;

References unixFile::ctrlFlags, fileHasMoved(), unixFile::h, osFstat, sqlite3_log(), SQLITE_WARNING, UNIXFILE_NOLOCK, and unixFile::zPath.

◆ versionFunc()

static void versionFunc	(	sqlite3_context *	context,
		int	NotUsed,
		sqlite3_value **	NotUsed2 )

static

Definition at line 117977 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ vfsUnlink()

static void vfsUnlink ( sqlite3_vfs * pVfs )

static

Definition at line 23331 of file sqlite3.c.

                                        {
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) );
  if( pVfs==0 ){
    /* No-op */
  }else if( vfsList==pVfs ){
    vfsList = pVfs->pNext;
  }else if( vfsList ){
    sqlite3_vfs *p = vfsList;
    while( p->pNext && p->pNext!=pVfs ){
      p = p->pNext;
    }

Referenced by sqlite3_vfs_register().

◆ vtabBestIndex()

static int vtabBestIndex	(	Parse *	pParse,
		Table *	pTab,
		sqlite3_index_info *	p )

static

Definition at line 146664 of file sqlite3.c.

                                                                           {
  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
  int rc;
 
  whereTraceIndexInfoInputs(p);
  rc = pVtab->pModule->xBestIndex(pVtab, p);
  whereTraceIndexInfoOutputs(p);
 
  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
      sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);

References Parse::db, sqlite3_vtab::pModule, VTable::pVtab, sqlite3_free(), sqlite3ErrorMsg(), sqlite3ErrStr(), sqlite3GetVTable(), sqlite3OomFault(), SQLITE_CONSTRAINT, SQLITE_NOMEM, SQLITE_OK, whereTraceIndexInfoInputs, whereTraceIndexInfoOutputs, sqlite3_module::xBestIndex, and sqlite3_vtab::zErrMsg.

Referenced by whereLoopAddVirtualOne().

◆ vtabCallConstructor()

static int vtabCallConstructor	(	sqlite3 *	db,
		Table *	pTab,
		Module *	pMod,
		int()(sqlite3 , void , int, const char const , sqlite3_vtab , char *)	xConstruct,
		char **	pzErr )

static

Definition at line 140121 of file sqlite3.c.

 {
  VtabCtx sCtx;
  VTable *pVTable;
  int rc;
  const char *const*azArg = (const char *const*)pTab->azModuleArg;
  int nArg = pTab->nModuleArg;
  char *zErr = 0;
  char *zModuleName;
  int iDb;
  VtabCtx *pCtx;
 
  /* Check that the virtual-table is not already being initialized */
  for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
    if( pCtx->pTab==pTab ){
      *pzErr = sqlite3MPrintf(db,
          "vtable constructor called recursively: %s", pTab->zName
      );
      return SQLITE_LOCKED;
    }
  }
 
  zModuleName = sqlite3DbStrDup(db, pTab->zName);
  if( !zModuleName ){
    return SQLITE_NOMEM_BKPT;
  }
 
  pVTable = sqlite3MallocZero(sizeof(VTable));
  if( !pVTable ){
    sqlite3OomFault(db);
    sqlite3DbFree(db, zModuleName);
    return SQLITE_NOMEM_BKPT;
  }
  pVTable->db = db;
  pVTable->pMod = pMod;
  pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;
 
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  pTab->azModuleArg[1] = db->aDb[iDb].zDbSName;
 
  /* Invoke the virtual table constructor */
  assert( &db->pVtabCtx );
  assert( xConstruct );
  sCtx.pTab = pTab;
  sCtx.pVTable = pVTable;
  sCtx.pPrior = db->pVtabCtx;
  sCtx.bDeclared = 0;
  db->pVtabCtx = &sCtx;
  rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
  db->pVtabCtx = sCtx.pPrior;
  if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
  assert( sCtx.pTab==pTab );
 
  if( SQLITE_OK!=rc ){
    if( zErr==0 ){
      *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
    }else {
      *pzErr = sqlite3MPrintf(db, "%s", zErr);
      sqlite3_free(zErr);
    }
    sqlite3DbFree(db, pVTable);
  }else if( ALWAYS(pVTable->pVtab) ){
    /* Justification of ALWAYS():  A correct vtab constructor must allocate
    ** the sqlite3_vtab object if successful.  */
    memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0]));
    pVTable->pVtab->pModule = pMod->pModule;
    pMod->nRefModule++;
    pVTable->nRef = 1;
    if( sCtx.bDeclared==0 ){
      const char *zFormat = "vtable constructor did not declare schema: %s";
      *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
      sqlite3VtabUnlock(pVTable);
      rc = SQLITE_ERROR;
    }else{
      int iCol;
      u16 oooHidden = 0;
      /* If everything went according to plan, link the new VTable structure
      ** into the linked list headed by pTab->pVTable. Then loop through the
      ** columns of the table to see if any of them contain the token "hidden".
      ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
      ** the type string.  */
      pVTable->pNext = pTab->pVTable;
      pTab->pVTable = pVTable;
 
      for(iCol=0; iCol<pTab->nCol; iCol++){
        char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
        int nType;
        int i = 0;
        nType = sqlite3Strlen30(zType);
        for(i=0; i<nType; i++){
          if( 0==sqlite3StrNICmp("hidden", &zType[i], 6)
           && (i==0 || zType[i-1]==' ')
           && (zType[i+6]=='\0' || zType[i+6]==' ')
          ){
            break;
          }
        }
        if( i<nType ){
          int j;
          int nDel = 6 + (zType[i+6] ? 1 : 0);
          for(j=i; (j+nDel)<=nType; j++){
            zType[j] = zType[j+nDel];
          }
          if( zType[i]=='\0' && i>0 ){
            assert(zType[i-1]==' ');
            zType[i-1] = '\0';
          }
          pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
          oooHidden = TF_OOOHidden;
        }else{
          pTab->tabFlags |= oooHidden;
        }
      }

References Table::aCol, sqlite3::aDb, ALWAYS, Table::azModuleArg, VtabCtx::bDeclared, COLFLAG_HIDDEN, Column::colFlags, VTable::db, VTable::eVtabRisk, Table::nCol, Table::nModuleArg, VTable::nRef, Module::nRefModule, Module::pAux, VTable::pMod, sqlite3_vtab::pModule, Module::pModule, VTable::pNext, VtabCtx::pPrior, Table::pSchema, VtabCtx::pTab, VTable::pVtab, sqlite3::pVtabCtx, Table::pVTable, VtabCtx::pVTable, sqlite3_free(), sqlite3ColumnType(), sqlite3DbFree(), sqlite3DbStrDup(), sqlite3MallocZero(), sqlite3MPrintf(), sqlite3OomFault(), sqlite3SchemaToIndex(), sqlite3Strlen30(), sqlite3StrNICmp, sqlite3VtabUnlock(), SQLITE_ERROR, SQLITE_LOCKED, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_VTABRISK_Normal, Table::tabFlags, TF_OOOHidden, Db::zDbSName, and Table::zName.

Referenced by sqlite3VtabCallConnect(), sqlite3VtabCallCreate(), and sqlite3VtabEponymousTableInit().

◆ vtabDisconnectAll()

static VTable * vtabDisconnectAll	(	sqlite3 *	db,
		Table *	p )

static

Definition at line 139799 of file sqlite3.c.

                                                       {
  VTable *pRet = 0;
  VTable *pVTable = p->pVTable;
  p->pVTable = 0;
 
  /* Assert that the mutex (if any) associated with the BtShared database
  ** that contains table p is held by the caller. See header comments
  ** above function sqlite3VtabUnlockList() for an explanation of why
  ** this makes it safe to access the sqlite3.pDisconnect list of any
  ** database connection that may have an entry in the p->pVTable list.
  */
  assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
 
  while( pVTable ){
    sqlite3 *db2 = pVTable->db;
    VTable *pNext = pVTable->pNext;
    assert( db2 );
    if( db2==db ){
      pRet = pVTable;
      p->pVTable = pRet;
      pRet->pNext = 0;
    }else{
      pVTable->pNext = db2->pDisconnect;
      db2->pDisconnect = pVTable;
    }

References VTable::db, sqlite3::pDisconnect, VTable::pNext, Table::pSchema, and Table::pVTable.

Referenced by sqlite3VtabCallDestroy(), and sqlite3VtabClear().

◆ walBeginShmUnreliable()

static int walBeginShmUnreliable	(	Wal *	pWal,
		int *	pChanged )

static

Definition at line 61808 of file sqlite3.c.

                                                          {
  i64 szWal;                      /* Size of wal file on disk in bytes */
  i64 iOffset;                    /* Current offset when reading wal file */
  u8 aBuf[WAL_HDRSIZE];           /* Buffer to load WAL header into */
  u8 *aFrame = 0;                 /* Malloc'd buffer to load entire frame */
  int szFrame;                    /* Number of bytes in buffer aFrame[] */
  u8 *aData;                      /* Pointer to data part of aFrame buffer */
  volatile void *pDummy;          /* Dummy argument for xShmMap */
  int rc;                         /* Return code */
  u32 aSaveCksum[2];              /* Saved copy of pWal->hdr.aFrameCksum */
 
  assert( pWal->bShmUnreliable );
  assert( pWal->readOnly & WAL_SHM_RDONLY );
  assert( pWal->nWiData>0 && pWal->apWiData[0] );
 
  /* Take WAL_READ_LOCK(0). This has the effect of preventing any
  ** writers from running a checkpoint, but does not stop them
  ** from running recovery.  */
  rc = walLockShared(pWal, WAL_READ_LOCK(0));
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_BUSY ) rc = WAL_RETRY;
    goto begin_unreliable_shm_out;
  }
  pWal->readLock = 0;
 
  /* Check to see if a separate writer has attached to the shared-memory area,
  ** thus making the shared-memory "reliable" again.  Do this by invoking
  ** the xShmMap() routine of the VFS and looking to see if the return
  ** is SQLITE_READONLY instead of SQLITE_READONLY_CANTINIT.
  **
  ** If the shared-memory is now "reliable" return WAL_RETRY, which will
  ** cause the heap-memory WAL-index to be discarded and the actual
  ** shared memory to be used in its place.
  **
  ** This step is important because, even though this connection is holding
  ** the WAL_READ_LOCK(0) which prevents a checkpoint, a writer might
  ** have already checkpointed the WAL file and, while the current
  ** is active, wrap the WAL and start overwriting frames that this
  ** process wants to use.
  **
  ** Once sqlite3OsShmMap() has been called for an sqlite3_file and has
  ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY
  ** or SQLITE_READONLY_CANTINIT or some error for all subsequent invocations,
  ** even if some external agent does a "chmod" to make the shared-memory
  ** writable by us, until sqlite3OsShmUnmap() has been called.
  ** This is a requirement on the VFS implementation.
   */
  rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy);
  assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */
  if( rc!=SQLITE_READONLY_CANTINIT ){
    rc = (rc==SQLITE_READONLY ? WAL_RETRY : rc);
    goto begin_unreliable_shm_out;
  }
 
  /* We reach this point only if the real shared-memory is still unreliable.
  ** Assume the in-memory WAL-index substitute is correct and load it
  ** into pWal->hdr.
  */
  memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr));
 
  /* Make sure some writer hasn't come in and changed the WAL file out
  ** from under us, then disconnected, while we were not looking.
  */
  rc = sqlite3OsFileSize(pWal->pWalFd, &szWal);
  if( rc!=SQLITE_OK ){
    goto begin_unreliable_shm_out;
  }
  if( szWal<WAL_HDRSIZE ){
    /* If the wal file is too small to contain a wal-header and the
    ** wal-index header has mxFrame==0, then it must be safe to proceed
    ** reading the database file only. However, the page cache cannot
    ** be trusted, as a read/write connection may have connected, written
    ** the db, run a checkpoint, truncated the wal file and disconnected
    ** since this client's last read transaction.  */
    *pChanged = 1;
    rc = (pWal->hdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY);
    goto begin_unreliable_shm_out;
  }
 
  /* Check the salt keys at the start of the wal file still match. */
  rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
  if( rc!=SQLITE_OK ){
    goto begin_unreliable_shm_out;
  }
  if( memcmp(&pWal->hdr.aSalt, &aBuf[16], 8) ){
    /* Some writer has wrapped the WAL file while we were not looking.
    ** Return WAL_RETRY which will cause the in-memory WAL-index to be
    ** rebuilt. */
    rc = WAL_RETRY;
    goto begin_unreliable_shm_out;
  }
 
  /* Allocate a buffer to read frames into */
  szFrame = pWal->hdr.szPage + WAL_FRAME_HDRSIZE;
  aFrame = (u8 *)sqlite3_malloc64(szFrame);
  if( aFrame==0 ){
    rc = SQLITE_NOMEM_BKPT;
    goto begin_unreliable_shm_out;
  }
  aData = &aFrame[WAL_FRAME_HDRSIZE];
 
  /* Check to see if a complete transaction has been appended to the
  ** wal file since the heap-memory wal-index was created. If so, the
  ** heap-memory wal-index is discarded and WAL_RETRY returned to
  ** the caller.  */
  aSaveCksum[0] = pWal->hdr.aFrameCksum[0];
  aSaveCksum[1] = pWal->hdr.aFrameCksum[1];
  for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->hdr.szPage);
      iOffset+szFrame<=szWal;
      iOffset+=szFrame
  ){
    u32 pgno;                   /* Database page number for frame */
    u32 nTruncate;              /* dbsize field from frame header */
 
    /* Read and decode the next log frame. */
    rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
    if( rc!=SQLITE_OK ) break;
    if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
 
    /* If nTruncate is non-zero, then a complete transaction has been
    ** appended to this wal file. Set rc to WAL_RETRY and break out of
    ** the loop.  */
    if( nTruncate ){
      rc = WAL_RETRY;
      break;
    }
  }
  pWal->hdr.aFrameCksum[0] = aSaveCksum[0];
  pWal->hdr.aFrameCksum[1] = aSaveCksum[1];
 
 begin_unreliable_shm_out:
  sqlite3_free(aFrame);
  if( rc!=SQLITE_OK ){
    int i;
    for(i=0; i<pWal->nWiData; i++){
      sqlite3_free((void*)pWal->apWiData[i]);
      pWal->apWiData[i] = 0;
    }

References WalIndexHdr::aFrameCksum, Wal::apWiData, WalIndexHdr::aSalt, Wal::bShmUnreliable, Wal::hdr, WalIndexHdr::mxFrame, Wal::nWiData, Wal::pDbFd, Wal::pWalFd, Wal::readLock, Wal::readOnly, sqlite3_free(), sqlite3_malloc64(), sqlite3OsFileSize(), sqlite3OsRead(), sqlite3OsShmMap(), sqlite3WalEndReadTransaction(), SQLITE_BUSY, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_READONLY, SQLITE_READONLY_CANTINIT, WalIndexHdr::szPage, WAL_FRAME_HDRSIZE, WAL_HDRSIZE, WAL_READ_LOCK, WAL_RETRY, WAL_SHM_RDONLY, walDecodeFrame(), walFrameOffset, WALINDEX_PGSZ, walIndexHdr(), and walLockShared().

Referenced by walTryBeginRead().

◆ walBusyLock()

static int walBusyLock	(	Wal *	pWal,
		int()(void )	xBusy,
		void *	pBusyArg,
		int	lockIdx,
		int	n )

static

Definition at line 61238 of file sqlite3.c.

 {
  int rc;
  do {
    rc = walLockExclusive(pWal, lockIdx, n);
  }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  if( rc==SQLITE_BUSY_TIMEOUT ){

References SQLITE_BUSY, SQLITE_BUSY_TIMEOUT, walDisableBlocking, and walLockExclusive().

Referenced by sqlite3WalCheckpoint(), and walCheckpoint().

◆ walCheckpoint()

static int walCheckpoint	(	Wal *	pWal,
		sqlite3 *	db,
		int	eMode,
		int()(void )	xBusy,
		void *	pBusyArg,
		int	sync_flags,
		u8 *	zBuf )

static

Definition at line 61330 of file sqlite3.c.

 {
  int rc = SQLITE_OK;             /* Return code */
  int szPage;                     /* Database page-size */
  WalIterator *pIter = 0;         /* Wal iterator context */
  u32 iDbpage = 0;                /* Next database page to write */
  u32 iFrame = 0;                 /* Wal frame containing data for iDbpage */
  u32 mxSafeFrame;                /* Max frame that can be backfilled */
  u32 mxPage;                     /* Max database page to write */
  int i;                          /* Loop counter */
  volatile WalCkptInfo *pInfo;    /* The checkpoint status information */
 
  szPage = walPagesize(pWal);
  testcase( szPage<=32768 );
  testcase( szPage>=65536 );
  pInfo = walCkptInfo(pWal);
  if( pInfo->nBackfill<pWal->hdr.mxFrame ){
 
    /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
    ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
    assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
 
    /* Compute in mxSafeFrame the index of the last frame of the WAL that is
    ** safe to write into the database.  Frames beyond mxSafeFrame might
    ** overwrite database pages that are in use by active readers and thus
    ** cannot be backfilled from the WAL.
    */
    mxSafeFrame = pWal->hdr.mxFrame;
    mxPage = pWal->hdr.nPage;
    for(i=1; i<WAL_NREADER; i++){
      u32 y = AtomicLoad(pInfo->aReadMark+i);
      if( mxSafeFrame>y ){
        assert( y<=pWal->hdr.mxFrame );
        rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
        if( rc==SQLITE_OK ){
          u32 iMark = (i==1 ? mxSafeFrame : READMARK_NOT_USED);
          AtomicStore(pInfo->aReadMark+i, iMark);
          walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
        }else if( rc==SQLITE_BUSY ){
          mxSafeFrame = y;
          xBusy = 0;
        }else{
          goto walcheckpoint_out;
        }
      }
    }
 
    /* Allocate the iterator */
    if( pInfo->nBackfill<mxSafeFrame ){
      rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
      assert( rc==SQLITE_OK || pIter==0 );
    }
 
    if( pIter
     && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
    ){
      u32 nBackfill = pInfo->nBackfill;
 
      pInfo->nBackfillAttempted = mxSafeFrame;
 
      /* Sync the WAL to disk */
      rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
 
      /* If the database may grow as a result of this checkpoint, hint
      ** about the eventual size of the db file to the VFS layer.
      */
      if( rc==SQLITE_OK ){
        i64 nReq = ((i64)mxPage * szPage);
        i64 nSize;                    /* Current size of database file */
        sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0);
        rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
        if( rc==SQLITE_OK && nSize<nReq ){
          if( (nSize+65536+(i64)pWal->hdr.mxFrame*szPage)<nReq ){
            /* If the size of the final database is larger than the current
            ** database plus the amount of data in the wal file, plus the
            ** maximum size of the pending-byte page (65536 bytes), then
            ** must be corruption somewhere.  */
            rc = SQLITE_CORRUPT_BKPT;
          }else{
            sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT,&nReq);
          }
        }
 
      }
 
      /* Iterate through the contents of the WAL, copying data to the db file */
      while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
        i64 iOffset;
        assert( walFramePgno(pWal, iFrame)==iDbpage );
        if( AtomicLoad(&db->u1.isInterrupted) ){
          rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
          break;
        }
        if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ){
          continue;
        }
        iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
        /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
        rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
        if( rc!=SQLITE_OK ) break;
        iOffset = (iDbpage-1)*(i64)szPage;
        testcase( IS_BIG_INT(iOffset) );
        rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
        if( rc!=SQLITE_OK ) break;
      }
      sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0);
 
      /* If work was actually accomplished... */
      if( rc==SQLITE_OK ){
        if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
          i64 szDb = pWal->hdr.nPage*(i64)szPage;
          testcase( IS_BIG_INT(szDb) );
          rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
          if( rc==SQLITE_OK ){
            rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));
          }
        }
        if( rc==SQLITE_OK ){
          AtomicStore(&pInfo->nBackfill, mxSafeFrame);
        }
      }
 
      /* Release the reader lock held while backfilling */
      walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
    }
 
    if( rc==SQLITE_BUSY ){
      /* Reset the return code so as not to report a checkpoint failure
      ** just because there are active readers.  */
      rc = SQLITE_OK;
    }
  }
 
  /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the
  ** entire wal file has been copied into the database file, then block
  ** until all readers have finished using the wal file. This ensures that
  ** the next process to write to the database restarts the wal file.
  */
  if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
    assert( pWal->writeLock );
    if( pInfo->nBackfill<pWal->hdr.mxFrame ){
      rc = SQLITE_BUSY;
    }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){
      u32 salt1;
      sqlite3_randomness(4, &salt1);
      assert( pInfo->nBackfill==pWal->hdr.mxFrame );
      rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
      if( rc==SQLITE_OK ){
        if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){
          /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as
          ** SQLITE_CHECKPOINT_RESTART with the addition that it also
          ** truncates the log file to zero bytes just prior to a
          ** successful return.
          **
          ** In theory, it might be safe to do this without updating the
          ** wal-index header in shared memory, as all subsequent reader or
          ** writer clients should see that the entire log file has been
          ** checkpointed and behave accordingly. This seems unsafe though,
          ** as it would leave the system in a state where the contents of
          ** the wal-index header do not match the contents of the
          ** file-system. To avoid this, update the wal-index header to
          ** indicate that the log file contains zero valid frames.  */
          walRestartHdr(pWal, salt1);
          rc = sqlite3OsTruncate(pWal->pWalFd, 0);
        }
        walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
      }
    }

References WalCkptInfo::aReadMark, AtomicLoad, AtomicStore, CKPT_SYNC_FLAGS, Wal::hdr, IS_BIG_INT, sqlite3::isInterrupted, sqlite3::mallocFailed, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, WalCkptInfo::nBackfillAttempted, WalIndexHdr::nPage, Wal::pDbFd, Wal::pWalFd, READMARK_NOT_USED, sqlite3_randomness(), sqlite3OsFileControl(), sqlite3OsFileControlHint(), sqlite3OsFileSize(), sqlite3OsRead(), sqlite3OsSync(), sqlite3OsTruncate(), sqlite3OsWrite(), SQLITE_BUSY, SQLITE_CHECKPOINT_PASSIVE, SQLITE_CHECKPOINT_RESTART, SQLITE_CHECKPOINT_TRUNCATE, SQLITE_CORRUPT_BKPT, SQLITE_FCNTL_CKPT_DONE, SQLITE_FCNTL_CKPT_START, SQLITE_FCNTL_SIZE_HINT, SQLITE_INTERRUPT, SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, sqlite3::u1, WAL_FRAME_HDRSIZE, WAL_NREADER, WAL_READ_LOCK, walBusyLock(), walCkptInfo(), walFrameOffset, walFramePgno(), walIndexHdr(), walIteratorFree(), walIteratorInit(), walIteratorNext(), walPagesize(), walRestartHdr(), walUnlockExclusive(), and Wal::writeLock.

Referenced by sqlite3WalCheckpoint().

◆ walChecksumBytes()

static void walChecksumBytes	(	int	nativeCksum,
		u8 *	a,
		int	nByte,
		const u32 *	aIn,
		u32 *	aOut )

static

Definition at line 60052 of file sqlite3.c.

 {
  u32 s1, s2;
  u32 *aData = (u32 *)a;
  u32 *aEnd = (u32 *)&a[nByte];
 
  if( aIn ){
    s1 = aIn[0];
    s2 = aIn[1];
  }else{
    s1 = s2 = 0;
  }
 
  assert( nByte>=8 );
  assert( (nByte&0x00000007)==0 );
  assert( nByte<=65536 );
 
  if( nativeCksum ){
    do {
      s1 += *aData++ + s2;
      s2 += *aData++ + s1;
    }while( aData<aEnd );
  }else{
    do {
      s1 += BYTESWAP32(aData[0]) + s2;
      s2 += BYTESWAP32(aData[1]) + s1;
      aData += 2;

References BYTESWAP32.

Referenced by walDecodeFrame(), walEncodeFrame(), walIndexRecover(), walIndexTryHdr(), and walIndexWriteHdr().

◆ walCkptInfo()

static volatile WalCkptInfo * walCkptInfo ( Wal * pWal )

static

Definition at line 60018 of file sqlite3.c.

Referenced by sqlite3WalBeginReadTransaction(), sqlite3WalCheckpoint(), walCheckpoint(), walIndexRecover(), walRestartHdr(), walRestartLog(), and walTryBeginRead().

◆ walCleanupHash()

static void walCleanupHash ( Wal * pWal )

static

Definition at line 60394 of file sqlite3.c.

                                     {
  WalHashLoc sLoc;                /* Hash table location */
  int iLimit = 0;                 /* Zero values greater than this */
  int nByte;                      /* Number of bytes to zero in aPgno[] */
  int i;                          /* Used to iterate through aHash[] */
  int rc;                         /* Return code form walHashGet() */
 
  assert( pWal->writeLock );
  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
 
  if( pWal->hdr.mxFrame==0 ) return;
 
  /* Obtain pointers to the hash-table and page-number array containing
  ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
  ** that the page said hash-table and array reside on is already mapped.(1)
  */
  assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
  assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
  rc = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
  if( NEVER(rc) ) return; /* Defense-in-depth, in case (1) above is wrong */
 
  /* Zero all hash-table entries that correspond to frame numbers greater
  ** than pWal->hdr.mxFrame.
  */
  iLimit = pWal->hdr.mxFrame - sLoc.iZero;
  assert( iLimit>0 );
  for(i=0; i<HASHTABLE_NSLOT; i++){
    if( sLoc.aHash[i]>iLimit ){
      sLoc.aHash[i] = 0;
    }
  }
 
  /* Zero the entries in the aPgno array that correspond to frames with
  ** frame numbers greater than pWal->hdr.mxFrame.
  */
  nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]);
  memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte);
 
#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
  /* Verify that the every entry in the mapping region is still reachable
  ** via the hash table even after the cleanup.
  */
  if( iLimit ){
    int j;           /* Loop counter */
    int iKey;        /* Hash key */
    for(j=1; j<=iLimit; j++){
      for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){
        if( sLoc.aHash[iKey]==j ) break;

References WalHashLoc::aHash, WalHashLoc::aPgno, Wal::apWiData, HASHTABLE_NPAGE_ONE, HASHTABLE_NSLOT, Wal::hdr, WalHashLoc::iZero, WalIndexHdr::mxFrame, NEVER, Wal::nWiData, testcase, walFramePage(), walHash(), walHashGet(), walNextHash(), and Wal::writeLock.

Referenced by sqlite3WalSavepointUndo(), sqlite3WalUndo(), and walIndexAppend().

◆ walDecodeFrame()

static int walDecodeFrame	(	Wal *	pWal,
		u32 *	piPage,
		u32 *	pnTruncate,
		u8 *	aData,
		u8 *	aFrame )

static

Definition at line 60177 of file sqlite3.c.

 {
  int nativeCksum;                /* True for native byte-order checksums */
  u32 *aCksum = pWal->hdr.aFrameCksum;
  u32 pgno;                       /* Page number of the frame */
  assert( WAL_FRAME_HDRSIZE==24 );
 
  /* A frame is only valid if the salt values in the frame-header
  ** match the salt values in the wal-header.
  */
  if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
    return 0;
  }
 
  /* A frame is only valid if the page number is creater than zero.
  */
  pgno = sqlite3Get4byte(&aFrame[0]);
  if( pgno==0 ){
    return 0;
  }
 
  /* A frame is only valid if a checksum of the WAL header,
  ** all prior frams, the first 16 bytes of this frame-header,
  ** and the frame-data matches the checksum in the last 8
  ** bytes of this frame-header.
  */
  nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
  walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
  walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
  if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
   || aCksum[1]!=sqlite3Get4byte(&aFrame[20])
  ){
    /* Checksum failed. */
    return 0;
  }
 
  /* If we reach this point, the frame is valid.  Return the page number

References WalIndexHdr::aFrameCksum, WalIndexHdr::aSalt, WalIndexHdr::bigEndCksum, Wal::hdr, sqlite3Get4byte(), SQLITE_BIGENDIAN, Wal::szPage, WAL_FRAME_HDRSIZE, and walChecksumBytes().

Referenced by walBeginShmUnreliable(), and walIndexRecover().

◆ walEncodeFrame()

static void walEncodeFrame	(	Wal *	pWal,
		u32	iPage,
		u32	nTruncate,
		u8 *	aData,
		u8 *	aFrame )

static

Definition at line 60146 of file sqlite3.c.

        : Salt-1 (copied from the wal-header)
**    12: Salt-2 (copied from the wal-header)
**    16: Checksum-1.
**    20: Checksum-2.
*/
static void walEncodeFrame(
  Wal *pWal,                      /* The write-ahead log */
  u32 iPage,                      /* Database page number for frame */
  u32 nTruncate,                  /* New db size (or 0 for non-commit frames) */
  u8 *aData,                      /* Pointer to page data */
  u8 *aFrame                      /* OUT: Write encoded frame here */
){
  int nativeCksum;                /* True for native byte-order checksums */
  u32 *aCksum = pWal->hdr.aFrameCksum;
  assert( WAL_FRAME_HDRSIZE==24 );
  sqlite3Put4byte(&aFrame[0], iPage);
  sqlite3Put4byte(&aFrame[4], nTruncate);
  if( pWal->iReCksum==0 ){
    memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
 
    nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
    walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
    walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
 

References WalIndexHdr::aFrameCksum, WalIndexHdr::aSalt, WalIndexHdr::bigEndCksum, Wal::hdr, Wal::iReCksum, sqlite3Put4byte(), SQLITE_BIGENDIAN, Wal::szPage, WAL_FRAME_HDRSIZE, and walChecksumBytes().

Referenced by walRewriteChecksums().

◆ walFramePage()

static int walFramePage ( u32 iFrame )

static

Definition at line 60359 of file sqlite3.c.

                                   {
  int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;
  assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
       && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE)
       && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE))

References HASHTABLE_NPAGE, and HASHTABLE_NPAGE_ONE.

Referenced by sqlite3WalFindFrame(), walCleanupHash(), walIndexAppend(), walIndexRecover(), and walIteratorInit().

◆ walFramePgno()

static u32 walFramePgno	(	Wal *	pWal,
		u32	iFrame )

static

Definition at line 60374 of file sqlite3.c.

60380 {

Referenced by sqlite3WalFindFrame(), sqlite3WalUndo(), and walCheckpoint().

◆ walHash()

static int walHash ( u32 iPage )

static

Definition at line 60295 of file sqlite3.c.

Referenced by sqlite3WalFindFrame(), walCleanupHash(), and walIndexAppend().

◆ walHashGet()

static int walHashGet	(	Wal *	pWal,
		int	iHash,
		WalHashLoc *	pLoc )

static

Definition at line 60330 of file sqlite3.c.

 {
  int rc;                         /* Return code */
 
  rc = walIndexPage(pWal, iHash, &pLoc->aPgno);
  assert( rc==SQLITE_OK || iHash>0 );
 
  if( rc==SQLITE_OK ){
    pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE];
    if( iHash==0 ){
      pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
      pLoc->iZero = 0;
    }else{

References WalHashLoc::aHash, WalHashLoc::aPgno, HASHTABLE_NPAGE, HASHTABLE_NPAGE_ONE, WalHashLoc::iZero, SQLITE_OK, WALINDEX_HDR_SIZE, and walIndexPage().

Referenced by sqlite3WalFindFrame(), walCleanupHash(), walIndexAppend(), and walIteratorInit().

◆ walIndexAppend()

static int walIndexAppend	(	Wal *	pWal,
		u32	iFrame,
		u32	iPage )

static

Definition at line 60456 of file sqlite3.c.

                                                           {
  int rc;                         /* Return code */
  WalHashLoc sLoc;                /* Wal-index hash table location */
 
  rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);
 
  /* Assuming the wal-index file was successfully mapped, populate the
  ** page number array and hash table entry.
  */
  if( rc==SQLITE_OK ){
    int iKey;                     /* Hash table key */
    int idx;                      /* Value to write to hash-table slot */
    int nCollide;                 /* Number of hash collisions */
 
    idx = iFrame - sLoc.iZero;
    assert( idx <= HASHTABLE_NSLOT/2 + 1 );
 
    /* If this is the first entry to be added to this hash-table, zero the
    ** entire hash table and aPgno[] array before proceeding.
    */
    if( idx==1 ){
      int nByte = (int)((u8 *)&sLoc.aHash[HASHTABLE_NSLOT]
                               - (u8 *)&sLoc.aPgno[1]);
      memset((void*)&sLoc.aPgno[1], 0, nByte);
    }
 
    /* If the entry in aPgno[] is already set, then the previous writer
    ** must have exited unexpectedly in the middle of a transaction (after
    ** writing one or more dirty pages to the WAL to free up memory).
    ** Remove the remnants of that writers uncommitted transaction from
    ** the hash-table before writing any new entries.
    */
    if( sLoc.aPgno[idx] ){
      walCleanupHash(pWal);
      assert( !sLoc.aPgno[idx] );
    }
 
    /* Write the aPgno[] array entry and the hash-table slot. */
    nCollide = idx;
    for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){
      if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
    }
    sLoc.aPgno[idx] = iPage;
    AtomicStore(&sLoc.aHash[iKey], (ht_slot)idx);
 
#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
    /* Verify that the number of entries in the hash table exactly equals
    ** the number of entries in the mapping region.
    */
    {
      int i;           /* Loop counter */
      int nEntry = 0;  /* Number of entries in the hash table */
      for(i=0; i<HASHTABLE_NSLOT; i++){ if( sLoc.aHash[i] ) nEntry++; }
      assert( nEntry==idx );
    }
 
    /* Verify that the every entry in the mapping region is reachable
    ** via the hash table.  This turns out to be a really, really expensive
    ** thing to check, so only do this occasionally - not on every
    ** iteration.
    */
    if( (idx&0x3ff)==0 ){
      int i;           /* Loop counter */
      for(i=1; i<=idx; i++){
        for(iKey=walHash(sLoc.aPgno[i]);
            sLoc.aHash[iKey];
            iKey=walNextHash(iKey)){
          if( sLoc.aHash[iKey]==i ) break;
        }
        assert( sLoc.aHash[iKey]==i );
      }
    }

References WalHashLoc::aHash, WalHashLoc::aPgno, AtomicStore, HASHTABLE_NSLOT, WalHashLoc::iZero, SQLITE_CORRUPT_BKPT, SQLITE_OK, walCleanupHash(), walFramePage(), walHash(), walHashGet(), and walNextHash().

Referenced by walIndexRecover().

◆ walIndexClose()

static void walIndexClose	(	Wal *	pWal,
		int	isDelete )

static

Definition at line 60768 of file sqlite3.c.

                                                  {
  if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){
    int i;
    for(i=0; i<pWal->nWiData; i++){
      sqlite3_free((void *)pWal->apWiData[i]);
      pWal->apWiData[i] = 0;

Referenced by sqlite3WalOpen(), and walIndexReadHdr().

◆ walIndexHdr()

static volatile WalIndexHdr * walIndexHdr ( Wal * pWal )

static

Definition at line 60026 of file sqlite3.c.

Referenced by sqlite3WalBeginWriteTransaction(), sqlite3WalUndo(), walBeginShmUnreliable(), walCheckpoint(), walIndexTryHdr(), walIndexWriteHdr(), and walTryBeginRead().

◆ walIndexPage()

static int walIndexPage	(	Wal *	pWal,
		int	iPage,
		volatile u32 **	ppPage )

static

Definition at line 60004 of file sqlite3.c.

Referenced by walHashGet(), walIndexReadHdr(), and walIndexRecover().

◆ walIndexPageRealloc()

static SQLITE_NOINLINE int walIndexPageRealloc	(	Wal *	pWal,
		int	iPage,
		volatile u32 **	ppPage )

static

Definition at line 59957 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
 
  /* Enlarge the pWal->apWiData[] array if required */
  if( pWal->nWiData<=iPage ){
    sqlite3_int64 nByte = sizeof(u32*)*(iPage+1);
    volatile u32 **apNew;
    apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte);
    if( !apNew ){
      *ppPage = 0;
      return SQLITE_NOMEM_BKPT;
    }
    memset((void*)&apNew[pWal->nWiData], 0,
           sizeof(u32*)*(iPage+1-pWal->nWiData));
    pWal->apWiData = apNew;
    pWal->nWiData = iPage+1;
  }
 
  /* Request a pointer to the required page from the VFS */
  assert( pWal->apWiData[iPage]==0 );
  if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
    pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
    if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
  }else{
    rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
        pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
    );
    assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 );
    testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
    if( rc==SQLITE_OK ){
      if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM;
    }else if( (rc&0xff)==SQLITE_READONLY ){
      pWal->readOnly |= WAL_SHM_RDONLY;
      if( rc==SQLITE_READONLY ){
        rc = SQLITE_OK;
      }
    }

References Wal::apWiData, Wal::exclusiveMode, Wal::nWiData, Wal::pDbFd, Wal::readOnly, sqlite3FaultSim(), sqlite3MallocZero(), sqlite3OsShmMap(), sqlite3Realloc(), SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_READONLY, testcase, WAL_HEAPMEMORY_MODE, WAL_SHM_RDONLY, WALINDEX_PGSZ, and Wal::writeLock.

◆ walIndexReadHdr()

static int walIndexReadHdr	(	Wal *	pWal,
		int *	pChanged )

static

Definition at line 61684 of file sqlite3.c.

                                                    {
  int rc;                         /* Return code */
  int badHdr;                     /* True if a header read failed */
  volatile u32 *page0;            /* Chunk of wal-index containing header */
 
  /* Ensure that page 0 of the wal-index (the page that contains the
  ** wal-index header) is mapped. Return early if an error occurs here.
  */
  assert( pChanged );
  rc = walIndexPage(pWal, 0, &page0);
  if( rc!=SQLITE_OK ){
    assert( rc!=SQLITE_READONLY ); /* READONLY changed to OK in walIndexPage */
    if( rc==SQLITE_READONLY_CANTINIT ){
      /* The SQLITE_READONLY_CANTINIT return means that the shared-memory
      ** was openable but is not writable, and this thread is unable to
      ** confirm that another write-capable connection has the shared-memory
      ** open, and hence the content of the shared-memory is unreliable,
      ** since the shared-memory might be inconsistent with the WAL file
      ** and there is no writer on hand to fix it. */
      assert( page0==0 );
      assert( pWal->writeLock==0 );
      assert( pWal->readOnly & WAL_SHM_RDONLY );
      pWal->bShmUnreliable = 1;
      pWal->exclusiveMode = WAL_HEAPMEMORY_MODE;
      *pChanged = 1;
    }else{
      return rc; /* Any other non-OK return is just an error */
    }
  }else{
    /* page0 can be NULL if the SHM is zero bytes in size and pWal->writeLock
    ** is zero, which prevents the SHM from growing */
    testcase( page0!=0 );
  }
  assert( page0!=0 || pWal->writeLock==0 );
 
  /* If the first page of the wal-index has been mapped, try to read the
  ** wal-index header immediately, without holding any lock. This usually
  ** works, but may fail if the wal-index header is corrupt or currently
  ** being modified by another thread or process.
  */
  badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);
 
  /* If the first attempt failed, it might have been due to a race
  ** with a writer.  So get a WRITE lock and try again.
  */
  if( badHdr ){
    if( pWal->bShmUnreliable==0 && (pWal->readOnly & WAL_SHM_RDONLY) ){
      if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
        walUnlockShared(pWal, WAL_WRITE_LOCK);
        rc = SQLITE_READONLY_RECOVERY;
      }
    }else{
      int bWriteLock = pWal->writeLock;
      if( bWriteLock || SQLITE_OK==(rc = walLockWriter(pWal)) ){
        pWal->writeLock = 1;
        if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
          badHdr = walIndexTryHdr(pWal, pChanged);
          if( badHdr ){
            /* If the wal-index header is still malformed even while holding
            ** a WRITE lock, it can only mean that the header is corrupted and
            ** needs to be reconstructed.  So run recovery to do exactly that.
            */
            rc = walIndexRecover(pWal);
            *pChanged = 1;
          }
        }
        if( bWriteLock==0 ){
          pWal->writeLock = 0;
          walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
        }
      }
    }
  }
 
  /* If the header is read successfully, check the version number to make
  ** sure the wal-index was not constructed with some future format that
  ** this version of SQLite cannot understand.
  */
  if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
    rc = SQLITE_CANTOPEN_BKPT;
  }
  if( pWal->bShmUnreliable ){
    if( rc!=SQLITE_OK ){
      walIndexClose(pWal, 0);
      pWal->bShmUnreliable = 0;
      assert( pWal->nWiData>0 && pWal->apWiData[0]==0 );
      /* walIndexRecover() might have returned SHORT_READ if a concurrent
      ** writer truncated the WAL out from under it.  If that happens, it
      ** indicates that a writer has fixed the SHM file for us, so retry */
      if( rc==SQLITE_IOERR_SHORT_READ ) rc = WAL_RETRY;

References Wal::apWiData, Wal::bShmUnreliable, Wal::exclusiveMode, Wal::hdr, WalIndexHdr::iVersion, Wal::nWiData, Wal::readOnly, SQLITE_CANTOPEN_BKPT, SQLITE_IOERR_SHORT_READ, SQLITE_OK, SQLITE_READONLY, SQLITE_READONLY_CANTINIT, SQLITE_READONLY_RECOVERY, testcase, WAL_HEAPMEMORY_MODE, WAL_NORMAL_MODE, WAL_RETRY, WAL_SHM_RDONLY, WAL_WRITE_LOCK, WALINDEX_MAX_VERSION, walIndexClose(), walIndexPage(), walIndexRecover(), walIndexTryHdr(), walLockShared(), walLockWriter, walUnlockExclusive(), walUnlockShared(), and Wal::writeLock.

Referenced by sqlite3WalCheckpoint(), and walTryBeginRead().

◆ walIndexRecover()

static int walIndexRecover ( Wal * pWal )

static

Definition at line 60546 of file sqlite3.c.

                                     {
  int rc;                         /* Return Code */
  i64 nSize;                      /* Size of log file */
  u32 aFrameCksum[2] = {0, 0};
  int iLock;                      /* Lock offset to lock for checkpoint */
 
  /* Obtain an exclusive lock on all byte in the locking range not already
  ** locked by the caller. The caller is guaranteed to have locked the
  ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
  ** If successful, the same bytes that are locked here are unlocked before
  ** this function returns.
  */
  assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
  assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
  assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
  assert( pWal->writeLock );
  iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
  rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
  if( rc ){
    return rc;
  }
 
  WALTRACE(("WAL%p: recovery begin...\n", pWal));
 
  memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
 
  rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
  if( rc!=SQLITE_OK ){
    goto recovery_error;
  }
 
  if( nSize>WAL_HDRSIZE ){
    u8 aBuf[WAL_HDRSIZE];         /* Buffer to load WAL header into */
    u32 *aPrivate = 0;            /* Heap copy of *-shm hash being populated */
    u8 *aFrame = 0;               /* Malloc'd buffer to load entire frame */
    int szFrame;                  /* Number of bytes in buffer aFrame[] */
    u8 *aData;                    /* Pointer to data part of aFrame buffer */
    int szPage;                   /* Page size according to the log */
    u32 magic;                    /* Magic value read from WAL header */
    u32 version;                  /* Magic value read from WAL header */
    int isValid;                  /* True if this frame is valid */
    u32 iPg;                      /* Current 32KB wal-index page */
    u32 iLastFrame;               /* Last frame in wal, based on nSize alone */
 
    /* Read in the WAL header. */
    rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
    if( rc!=SQLITE_OK ){
      goto recovery_error;
    }
 
    /* If the database page size is not a power of two, or is greater than
    ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
    ** data. Similarly, if the 'magic' value is invalid, ignore the whole
    ** WAL file.
    */
    magic = sqlite3Get4byte(&aBuf[0]);
    szPage = sqlite3Get4byte(&aBuf[8]);
    if( (magic&0xFFFFFFFE)!=WAL_MAGIC
     || szPage&(szPage-1)
     || szPage>SQLITE_MAX_PAGE_SIZE
     || szPage<512
    ){
      goto finished;
    }
    pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
    pWal->szPage = szPage;
    pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
    memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
 
    /* Verify that the WAL header checksum is correct */
    walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
        aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
    );
    if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
     || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
    ){
      goto finished;
    }
 
    /* Verify that the version number on the WAL format is one that
    ** are able to understand */
    version = sqlite3Get4byte(&aBuf[4]);
    if( version!=WAL_MAX_VERSION ){
      rc = SQLITE_CANTOPEN_BKPT;
      goto finished;
    }
 
    /* Malloc a buffer to read frames into. */
    szFrame = szPage + WAL_FRAME_HDRSIZE;
    aFrame = (u8 *)sqlite3_malloc64(szFrame + WALINDEX_PGSZ);
    if( !aFrame ){
      rc = SQLITE_NOMEM_BKPT;
      goto recovery_error;
    }
    aData = &aFrame[WAL_FRAME_HDRSIZE];
    aPrivate = (u32*)&aData[szPage];
 
    /* Read all frames from the log file. */
    iLastFrame = (nSize - WAL_HDRSIZE) / szFrame;
    for(iPg=0; iPg<=(u32)walFramePage(iLastFrame); iPg++){
      u32 *aShare;
      u32 iFrame;                 /* Index of last frame read */
      u32 iLast = MIN(iLastFrame, HASHTABLE_NPAGE_ONE+iPg*HASHTABLE_NPAGE);
      u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE);
      u32 nHdr, nHdr32;
      rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare);
      if( rc ) break;
      pWal->apWiData[iPg] = aPrivate;
 
      for(iFrame=iFirst; iFrame<=iLast; iFrame++){
        i64 iOffset = walFrameOffset(iFrame, szPage);
        u32 pgno;                 /* Database page number for frame */
        u32 nTruncate;            /* dbsize field from frame header */
 
        /* Read and decode the next log frame. */
        rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
        if( rc!=SQLITE_OK ) break;
        isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
        if( !isValid ) break;
        rc = walIndexAppend(pWal, iFrame, pgno);
        if( NEVER(rc!=SQLITE_OK) ) break;
 
        /* If nTruncate is non-zero, this is a commit record. */
        if( nTruncate ){
          pWal->hdr.mxFrame = iFrame;
          pWal->hdr.nPage = nTruncate;
          pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
          testcase( szPage<=32768 );
          testcase( szPage>=65536 );
          aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
          aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
        }
      }
      pWal->apWiData[iPg] = aShare;
      nHdr = (iPg==0 ? WALINDEX_HDR_SIZE : 0);
      nHdr32 = nHdr / sizeof(u32);
#ifndef SQLITE_SAFER_WALINDEX_RECOVERY
      /* Memcpy() should work fine here, on all reasonable implementations.
      ** Technically, memcpy() might change the destination to some
      ** intermediate value before setting to the final value, and that might
      ** cause a concurrent reader to malfunction.  Memcpy() is allowed to
      ** do that, according to the spec, but no memcpy() implementation that
      ** we know of actually does that, which is why we say that memcpy()
      ** is safe for this.  Memcpy() is certainly a lot faster.
      */
      memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr);
#else
      /* In the event that some platform is found for which memcpy()
      ** changes the destination to some intermediate value before
      ** setting the final value, this alternative copy routine is
      ** provided.
      */
      {
        int i;
        for(i=nHdr32; i<WALINDEX_PGSZ/sizeof(u32); i++){
          if( aShare[i]!=aPrivate[i] ){
            /* Atomic memory operations are not required here because if
            ** the value needs to be changed, that means it is not being
            ** accessed concurrently. */
            aShare[i] = aPrivate[i];
          }
        }
      }
#endif
      if( iFrame<=iLast ) break;
    }
 
    sqlite3_free(aFrame);
  }
 
finished:
  if( rc==SQLITE_OK ){
    volatile WalCkptInfo *pInfo;
    int i;
    pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
    pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
    walIndexWriteHdr(pWal);
 
    /* Reset the checkpoint-header. This is safe because this thread is
    ** currently holding locks that exclude all other writers and
    ** checkpointers. Then set the values of read-mark slots 1 through N.
    */
    pInfo = walCkptInfo(pWal);
    pInfo->nBackfill = 0;
    pInfo->nBackfillAttempted = pWal->hdr.mxFrame;
    pInfo->aReadMark[0] = 0;
    for(i=1; i<WAL_NREADER; i++){
      rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
      if( rc==SQLITE_OK ){
        if( i==1 && pWal->hdr.mxFrame ){
          pInfo->aReadMark[i] = pWal->hdr.mxFrame;
        }else{
          pInfo->aReadMark[i] = READMARK_NOT_USED;
        }
        walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
      }else if( rc!=SQLITE_BUSY ){
        goto recovery_error;
      }
    }
 
    /* If more than one frame was recovered from the log file, report an
    ** event via sqlite3_log(). This is to help with identifying performance
    ** problems caused by applications routinely shutting down without
    ** checkpointing the log file.
    */
    if( pWal->hdr.nPage ){
      sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,
          "recovered %d frames from WAL file %s",
          pWal->hdr.mxFrame, pWal->zWalName
      );
    }
  }

References WalIndexHdr::aFrameCksum, Wal::apWiData, WalCkptInfo::aReadMark, WalIndexHdr::aSalt, WalIndexHdr::bigEndCksum, Wal::ckptLock, HASHTABLE_NPAGE, HASHTABLE_NPAGE_ONE, Wal::hdr, MIN, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, WalCkptInfo::nBackfillAttempted, Wal::nCkpt, NEVER, WalIndexHdr::nPage, Wal::pWalFd, READMARK_NOT_USED, sqlite3_free(), sqlite3_log(), sqlite3_malloc64(), sqlite3Get4byte(), sqlite3OsFileSize(), sqlite3OsRead(), SQLITE_BIGENDIAN, SQLITE_BUSY, SQLITE_CANTOPEN_BKPT, SQLITE_MAX_PAGE_SIZE, SQLITE_NOMEM_BKPT, SQLITE_NOTICE_RECOVER_WAL, SQLITE_OK, WalIndexHdr::szPage, Wal::szPage, testcase, WAL_ALL_BUT_WRITE, WAL_CKPT_LOCK, WAL_FRAME_HDRSIZE, WAL_HDRSIZE, WAL_MAGIC, WAL_MAX_VERSION, WAL_NREADER, WAL_READ_LOCK, WAL_WRITE_LOCK, walChecksumBytes(), walCkptInfo(), walDecodeFrame(), walFrameOffset, walFramePage(), WALINDEX_HDR_SIZE, WALINDEX_PGSZ, walIndexAppend(), walIndexPage(), walIndexWriteHdr(), walLockExclusive(), WALTRACE, walUnlockExclusive(), Wal::writeLock, and Wal::zWalName.

Referenced by walIndexReadHdr().

◆ walIndexTryHdr()

static SQLITE_NO_TSAN int walIndexTryHdr	(	Wal *	pWal,
		int *	pChanged )

static

Definition at line 61614 of file sqlite3.c.

                                                                  {
  u32 aCksum[2];                  /* Checksum on the header content */
  WalIndexHdr h1, h2;             /* Two copies of the header content */
  WalIndexHdr volatile *aHdr;     /* Header in shared memory */
 
  /* The first page of the wal-index must be mapped at this point. */
  assert( pWal->nWiData>0 && pWal->apWiData[0] );
 
  /* Read the header. This might happen concurrently with a write to the
  ** same area of shared memory on a different CPU in a SMP,
  ** meaning it is possible that an inconsistent snapshot is read
  ** from the file. If this happens, return non-zero.
  **
  ** tag-20200519-1:
  ** There are two copies of the header at the beginning of the wal-index.
  ** When reading, read [0] first then [1].  Writes are in the reverse order.
  ** Memory barriers are used to prevent the compiler or the hardware from
  ** reordering the reads and writes.  TSAN and similar tools can sometimes
  ** give false-positive warnings about these accesses because the tools do not
  ** account for the double-read and the memory barrier. The use of mutexes
  ** here would be problematic as the memory being accessed is potentially
  ** shared among multiple processes and not all mutex implementions work
  ** reliably in that environment.
  */
  aHdr = walIndexHdr(pWal);
  memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); /* Possible TSAN false-positive */
  walShmBarrier(pWal);
  memcpy(&h2, (void *)&aHdr[1], sizeof(h2));
 
  if( memcmp(&h1, &h2, sizeof(h1))!=0 ){
    return 1;   /* Dirty read */
  }
  if( h1.isInit==0 ){
    return 1;   /* Malformed header - probably all zeros */
  }
  walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);
  if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){
    return 1;   /* Checksum does not match */
  }
 
  if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
    *pChanged = 1;
    memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
    pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
    testcase( pWal->szPage<=32768 );

References WalIndexHdr::aCksum, Wal::apWiData, Wal::hdr, WalIndexHdr::isInit, Wal::nWiData, WalIndexHdr::szPage, Wal::szPage, testcase, walChecksumBytes(), walIndexHdr(), and walShmBarrier().

Referenced by walIndexReadHdr().

◆ walIndexWriteHdr()

static SQLITE_NO_TSAN void walIndexWriteHdr ( Wal * pWal )

static

Definition at line 60119 of file sqlite3.c.

                                                      {
  volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
  const int nCksum = offsetof(WalIndexHdr, aCksum);
 
  assert( pWal->writeLock );
  pWal->hdr.isInit = 1;
  pWal->hdr.iVersion = WALINDEX_MAX_VERSION;

References WalIndexHdr::aCksum, Wal::hdr, WalIndexHdr::isInit, WalIndexHdr::iVersion, offsetof, walChecksumBytes(), WALINDEX_MAX_VERSION, walIndexHdr(), walShmBarrier(), and Wal::writeLock.

Referenced by walIndexRecover(), and walRestartHdr().

◆ walIteratorFree()

static void walIteratorFree ( WalIterator * p )

static

Definition at line 61057 of file sqlite3.c.

Referenced by walCheckpoint(), and walIteratorInit().

◆ walIteratorInit()

static int walIteratorInit	(	Wal *	pWal,
		u32	nBackfill,
		WalIterator **	pp )

static

Definition at line 61074 of file sqlite3.c.

                                                                      {
  WalIterator *p;                 /* Return value */
  int nSegment;                   /* Number of segments to merge */
  u32 iLast;                      /* Last frame in log */
  sqlite3_int64 nByte;            /* Number of bytes to allocate */
  int i;                          /* Iterator variable */
  ht_slot *aTmp;                  /* Temp space used by merge-sort */
  int rc = SQLITE_OK;             /* Return Code */
 
  /* This routine only runs while holding the checkpoint lock. And
  ** it only runs if there is actually content in the log (mxFrame>0).
  */
  assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
  iLast = pWal->hdr.mxFrame;
 
  /* Allocate space for the WalIterator object. */
  nSegment = walFramePage(iLast) + 1;
  nByte = sizeof(WalIterator)
        + (nSegment-1)*sizeof(struct WalSegment)
        + iLast*sizeof(ht_slot);
  p = (WalIterator *)sqlite3_malloc64(nByte);
  if( !p ){
    return SQLITE_NOMEM_BKPT;
  }
  memset(p, 0, nByte);
  p->nSegment = nSegment;
 
  /* Allocate temporary space used by the merge-sort routine. This block
  ** of memory will be freed before this function returns.
  */
  aTmp = (ht_slot *)sqlite3_malloc64(
      sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)
  );
  if( !aTmp ){
    rc = SQLITE_NOMEM_BKPT;
  }
 
  for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
    WalHashLoc sLoc;
 
    rc = walHashGet(pWal, i, &sLoc);
    if( rc==SQLITE_OK ){
      int j;                      /* Counter variable */
      int nEntry;                 /* Number of entries in this segment */
      ht_slot *aIndex;            /* Sorted index for this segment */
 
      sLoc.aPgno++;
      if( (i+1)==nSegment ){
        nEntry = (int)(iLast - sLoc.iZero);
      }else{
        nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);
      }
      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];
      sLoc.iZero++;
 
      for(j=0; j<nEntry; j++){
        aIndex[j] = (ht_slot)j;
      }
      walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry);
      p->aSegment[i].iZero = sLoc.iZero;
      p->aSegment[i].nEntry = nEntry;
      p->aSegment[i].aIndex = aIndex;
      p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;
    }
  }
  sqlite3_free(aTmp);
 
  if( rc!=SQLITE_OK ){

References WalHashLoc::aHash, WalIterator::WalSegment::aIndex, WalIterator::WalSegment::aPgno, WalHashLoc::aPgno, WalIterator::aSegment, Wal::ckptLock, HASHTABLE_NPAGE, Wal::hdr, WalIterator::WalSegment::iZero, WalHashLoc::iZero, WalIndexHdr::mxFrame, WalIterator::WalSegment::nEntry, WalIterator::nSegment, sqlite3_free(), sqlite3_malloc64(), SQLITE_NOMEM_BKPT, SQLITE_OK, walFramePage(), walHashGet(), walIteratorFree(), and walMergesort().

Referenced by walCheckpoint().

◆ walIteratorNext()

static int walIteratorNext	(	WalIterator *	p,
		u32 *	piPage,
		u32 *	piFrame )

static

Definition at line 60884 of file sqlite3.c.

 {
  u32 iMin;                     /* Result pgno must be greater than iMin */
  u32 iRet = 0xFFFFFFFF;        /* 0xffffffff is never a valid page number */
  int i;                        /* For looping through segments */
 
  iMin = p->iPrior;
  assert( iMin<0xffffffff );
  for(i=p->nSegment-1; i>=0; i--){
    struct WalSegment *pSegment = &p->aSegment[i];
    while( pSegment->iNext<pSegment->nEntry ){
      u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
      if( iPg>iMin ){
        if( iPg<iRet ){
          iRet = iPg;
          *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];
        }
        break;
      }
      pSegment->iNext++;

References WalIterator::WalSegment::aPgno, WalIterator::aSegment, WalIterator::iPrior, and WalIterator::nSegment.

Referenced by walCheckpoint().

◆ walkExpr()

static SQLITE_NOINLINE int walkExpr	(	Walker *	pWalker,
		Expr *	pExpr )

static

Definition at line 97568 of file sqlite3.c.

                                                                 {
  int rc;
  testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
  testcase( ExprHasProperty(pExpr, EP_Reduced) );
  while(1){
    rc = pWalker->xExprCallback(pWalker, pExpr);
    if( rc ) return rc & WRC_Abort;
    if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
      assert( pExpr->x.pList==0 || pExpr->pRight==0 );
      if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
      if( pExpr->pRight ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        pExpr = pExpr->pRight;
        continue;
      }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
      }else{
        if( pExpr->x.pList ){
          if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
        }
#ifndef SQLITE_OMIT_WINDOWFUNC
        if( ExprHasProperty(pExpr, EP_WinFunc) ){
          if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort;
        }
#endif

References EP_Leaf, EP_Reduced, EP_TokenOnly, EP_WinFunc, EP_xIsSelect, ExprHasProperty, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pSelect, Expr::pWin, sqlite3WalkExprList(), sqlite3WalkSelect(), testcase, walkExpr(), walkWindowList(), WRC_Abort, Expr::x, Walker::xExprCallback, and Expr::y.

Referenced by walkExpr().

◆ walkWindowList()

static int walkWindowList	(	Walker *	pWalker,
		Window *	pList )

static

Definition at line 97525 of file sqlite3.c.

                                                         {
  Window *pWin;
  for(pWin=pList; pWin; pWin=pWin->pNextWin){
    int rc;
    rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy);
    if( rc ) return WRC_Abort;
    rc = sqlite3WalkExprList(pWalker, pWin->pPartition);
    if( rc ) return WRC_Abort;
    rc = sqlite3WalkExpr(pWalker, pWin->pFilter);
    if( rc ) return WRC_Abort;
 
    /* The next two are purely for calls to sqlite3RenameExprUnmap()
    ** within sqlite3WindowOffsetExpr().  Because of constraints imposed
    ** by sqlite3WindowOffsetExpr(), they can never fail.  The results do
    ** not matter anyhow. */
    rc = sqlite3WalkExpr(pWalker, pWin->pStart);

References NEVER, Window::pEnd, Window::pFilter, Window::pNextWin, Window::pOrderBy, Window::pPartition, Window::pStart, sqlite3WalkExpr(), sqlite3WalkExprList(), WRC_Abort, and WRC_Continue.

Referenced by sqlite3WalkSelectExpr(), and walkExpr().

◆ walLimitSize()

static void walLimitSize	(	Wal *	pWal,
		i64	nMax )

static

Definition at line 61516 of file sqlite3.c.

                                             {
  i64 sz;
  int rx;
  sqlite3BeginBenignMalloc();
  rx = sqlite3OsFileSize(pWal->pWalFd, &sz);
  if( rx==SQLITE_OK && (sz > nMax ) ){
    rx = sqlite3OsTruncate(pWal->pWalFd, nMax);

◆ walLockExclusive()

static int walLockExclusive	(	Wal *	pWal,
		int	lockIdx,
		int	n )

static

Definition at line 60272 of file sqlite3.c.

                                                   {
  if( pWal->exclusiveMode ) return;
  (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
                         SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED);
  WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
}
static int walLockExclusive(Wal *pWal, int lockIdx, int n){
  int rc;
  if( pWal->exclusiveMode ) return SQLITE_OK;
  rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,

References Wal::exclusiveMode, Wal::pDbFd, sqlite3OsShmLock(), SQLITE_SHM_SHARED, SQLITE_SHM_UNLOCK, and WALTRACE.

Referenced by sqlite3WalBeginWriteTransaction(), sqlite3WalCheckpoint(), walBusyLock(), walIndexRecover(), walRestartLog(), and walTryBeginRead().

◆ walLockShared()

static int walLockShared	(	Wal *	pWal,
		int	lockIdx )

static

Definition at line 60256 of file sqlite3.c.

                                                {
  int rc;
  if( pWal->exclusiveMode ) return SQLITE_OK;
  rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,

References Wal::exclusiveMode, Wal::pDbFd, sqlite3OsShmLock(), and SQLITE_OK.

Referenced by sqlite3WalBeginReadTransaction(), sqlite3WalExclusiveMode(), walBeginShmUnreliable(), walIndexReadHdr(), and walTryBeginRead().

◆ walMerge()

static void walMerge	(	const u32 *	aContent,
		ht_slot *	aLeft,
		int	nLeft,
		ht_slot **	paRight,
		int *	pnRight,
		ht_slot *	aTmp )

static

Definition at line 60937 of file sqlite3.c.

 {
  int iLeft = 0;                  /* Current index in aLeft */
  int iRight = 0;                 /* Current index in aRight */
  int iOut = 0;                   /* Current index in output buffer */
  int nRight = *pnRight;
  ht_slot *aRight = *paRight;
 
  assert( nLeft>0 && nRight>0 );
  while( iRight<nRight || iLeft<nLeft ){
    ht_slot logpage;
    Pgno dbpage;
 
    if( (iLeft<nLeft)
     && (iRight>=nRight || aContent[aLeft[iLeft]]<aContent[aRight[iRight]])
    ){
      logpage = aLeft[iLeft++];
    }else{
      logpage = aRight[iRight++];
    }
    dbpage = aContent[logpage];
 
    aTmp[iOut++] = logpage;
    if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;
 
    assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
    assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );

Referenced by walMergesort().

◆ walMergesort()

static void walMergesort	(	const u32 *	aContent,
		ht_slot *	aBuffer,
		ht_slot *	aList,
		int *	pnList )

static

Definition at line 60994 of file sqlite3.c.

 {
  struct Sublist {
    int nList;                    /* Number of elements in aList */
    ht_slot *aList;               /* Pointer to sub-list content */
  };
 
  const int nList = *pnList;      /* Size of input list */
  int nMerge = 0;                 /* Number of elements in list aMerge */
  ht_slot *aMerge = 0;            /* List to be merged */
  int iList;                      /* Index into input list */
  u32 iSub = 0;                   /* Index into aSub array */
  struct Sublist aSub[13];        /* Array of sub-lists */
 
  memset(aSub, 0, sizeof(aSub));
  assert( nList<=HASHTABLE_NPAGE && nList>0 );
  assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
 
  for(iList=0; iList<nList; iList++){
    nMerge = 1;
    aMerge = &aList[iList];
    for(iSub=0; iList & (1<<iSub); iSub++){
      struct Sublist *p;
      assert( iSub<ArraySize(aSub) );
      p = &aSub[iSub];
      assert( p->aList && p->nList<=(1<<iSub) );
      assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
      walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
    }
    aSub[iSub].aList = aMerge;
    aSub[iSub].nList = nMerge;
  }
 
  for(iSub++; iSub<ArraySize(aSub); iSub++){
    if( nList & (1<<iSub) ){
      struct Sublist *p;
      assert( iSub<ArraySize(aSub) );
      p = &aSub[iSub];
      assert( p->nList<=(1<<iSub) );
      assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
      walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
    }
  }
  assert( aMerge==aList );
  *pnList = nMerge;
 
#ifdef SQLITE_DEBUG
  {
    int i;

References ArraySize, HASHTABLE_NPAGE, and walMerge().

Referenced by walIteratorInit().

◆ walNextHash()

static int walNextHash ( int iPriorHash )

static

Definition at line 60300 of file sqlite3.c.

60301 {

60302 assert( iPage>0 );

References HASHTABLE_HASH_1, and HASHTABLE_NSLOT.

Referenced by sqlite3WalFindFrame(), walCleanupHash(), and walIndexAppend().

◆ walPagesize()

static int walPagesize ( Wal * pWal )

static

Definition at line 61262 of file sqlite3.c.

Referenced by sqlite3WalCheckpoint(), and walCheckpoint().

◆ walRestartHdr()

static void walRestartHdr	(	Wal *	pWal,
		u32	salt1 )

static

Definition at line 61283 of file sqlite3.c.

                                               {
  volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
  int i;                          /* Loop counter */
  u32 *aSalt = pWal->hdr.aSalt;   /* Big-endian salt values */
  pWal->nCkpt++;
  pWal->hdr.mxFrame = 0;
  sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0]));
  memcpy(&pWal->hdr.aSalt[1], &salt1, 4);
  walIndexWriteHdr(pWal);

References WalCkptInfo::aReadMark, WalIndexHdr::aSalt, AtomicStore, Wal::hdr, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, WalCkptInfo::nBackfillAttempted, Wal::nCkpt, READMARK_NOT_USED, sqlite3Get4byte(), sqlite3Put4byte(), WAL_NREADER, walCkptInfo(), and walIndexWriteHdr().

Referenced by walCheckpoint(), and walRestartLog().

◆ walRestartLog()

static int walRestartLog ( Wal * pWal )

static

Definition at line 62733 of file sqlite3.c.

                                   {
  int rc = SQLITE_OK;
  int cnt;
 
  if( pWal->readLock==0 ){
    volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
    assert( pInfo->nBackfill==pWal->hdr.mxFrame );
    if( pInfo->nBackfill>0 ){
      u32 salt1;
      sqlite3_randomness(4, &salt1);
      rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
      if( rc==SQLITE_OK ){
        /* If all readers are using WAL_READ_LOCK(0) (in other words if no
        ** readers are currently using the WAL), then the transactions
        ** frames will overwrite the start of the existing log. Update the
        ** wal-index header to reflect this.
        **
        ** In theory it would be Ok to update the cache of the header only
        ** at this point. But updating the actual wal-index header is also
        ** safe and means there is no special case for sqlite3WalUndo()
        ** to handle if this transaction is rolled back.  */
        walRestartHdr(pWal, salt1);
        walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
      }else if( rc!=SQLITE_BUSY ){
        return rc;
      }
    }
    walUnlockShared(pWal, WAL_READ_LOCK(0));
    pWal->readLock = -1;
    cnt = 0;
    do{
      int notUsed;
      rc = walTryBeginRead(pWal, &notUsed, 1, ++cnt);
    }while( rc==WAL_RETRY );
    assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */

References Wal::hdr, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, Wal::readLock, sqlite3_randomness(), SQLITE_BUSY, SQLITE_IOERR, SQLITE_OK, SQLITE_PROTOCOL, testcase, WAL_NREADER, WAL_READ_LOCK, WAL_RETRY, walCkptInfo(), walLockExclusive(), walRestartHdr(), walTryBeginRead(), walUnlockExclusive(), and walUnlockShared().

◆ walRewriteChecksums()

static int walRewriteChecksums	(	Wal *	pWal,
		u32	iLast )

static

Definition at line 62847 of file sqlite3.c.

                                                    {
  const int szPage = pWal->szPage;/* Database page size */
  int rc = SQLITE_OK;             /* Return code */
  u8 *aBuf;                       /* Buffer to load data from wal file into */
  u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-headers in */
  u32 iRead;                      /* Next frame to read from wal file */
  i64 iCksumOff;
 
  aBuf = sqlite3_malloc(szPage + WAL_FRAME_HDRSIZE);
  if( aBuf==0 ) return SQLITE_NOMEM_BKPT;
 
  /* Find the checksum values to use as input for the recalculating the
  ** first checksum. If the first frame is frame 1 (implying that the current
  ** transaction restarted the wal file), these values must be read from the
  ** wal-file header. Otherwise, read them from the frame header of the
  ** previous frame.  */
  assert( pWal->iReCksum>0 );
  if( pWal->iReCksum==1 ){
    iCksumOff = 24;
  }else{
    iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16;
  }
  rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
  pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf);
  pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]);
 
  iRead = pWal->iReCksum;
  pWal->iReCksum = 0;
  for(; rc==SQLITE_OK && iRead<=iLast; iRead++){
    i64 iOff = walFrameOffset(iRead, szPage);
    rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
    if( rc==SQLITE_OK ){
      u32 iPgno, nDbSize;
      iPgno = sqlite3Get4byte(aBuf);
      nDbSize = sqlite3Get4byte(&aBuf[4]);
 
      walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame);
      rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff);

References WalIndexHdr::aFrameCksum, Wal::hdr, Wal::iReCksum, Wal::pWalFd, sqlite3_free(), sqlite3_malloc(), sqlite3Get4byte(), sqlite3OsRead(), sqlite3OsWrite(), SQLITE_NOMEM_BKPT, SQLITE_OK, Wal::szPage, WAL_FRAME_HDRSIZE, walEncodeFrame(), and walFrameOffset.

◆ walShmBarrier()

static void walShmBarrier ( Wal * pWal )

static

Definition at line 60095 of file sqlite3.c.

Referenced by walIndexTryHdr(), walIndexWriteHdr(), and walTryBeginRead().

◆ walTryBeginRead()

static int walTryBeginRead	(	Wal *	pWal,
		int *	pChanged,
		int	useWal,
		int	cnt )

static

Definition at line 62003 of file sqlite3.c.

                                                                         {
  volatile WalCkptInfo *pInfo;    /* Checkpoint information in wal-index */
  u32 mxReadMark;                 /* Largest aReadMark[] value */
  int mxI;                        /* Index of largest aReadMark[] value */
  int i;                          /* Loop counter */
  int rc = SQLITE_OK;             /* Return code  */
  u32 mxFrame;                    /* Wal frame to lock to */
 
  assert( pWal->readLock<0 );     /* Not currently locked */
 
  /* useWal may only be set for read/write connections */
  assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 );
 
  /* Take steps to avoid spinning forever if there is a protocol error.
  **
  ** Circumstances that cause a RETRY should only last for the briefest
  ** instances of time.  No I/O or other system calls are done while the
  ** locks are held, so the locks should not be held for very long. But
  ** if we are unlucky, another process that is holding a lock might get
  ** paged out or take a page-fault that is time-consuming to resolve,
  ** during the few nanoseconds that it is holding the lock.  In that case,
  ** it might take longer than normal for the lock to free.
  **
  ** After 5 RETRYs, we begin calling sqlite3OsSleep().  The first few
  ** calls to sqlite3OsSleep() have a delay of 1 microsecond.  Really this
  ** is more of a scheduler yield than an actual delay.  But on the 10th
  ** an subsequent retries, the delays start becoming longer and longer,
  ** so that on the 100th (and last) RETRY we delay for 323 milliseconds.
  ** The total delay time before giving up is less than 10 seconds.
  */
  if( cnt>5 ){
    int nDelay = 1;                      /* Pause time in microseconds */
    if( cnt>100 ){
      VVA_ONLY( pWal->lockError = 1; )
      return SQLITE_PROTOCOL;
    }
    if( cnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39;
    sqlite3OsSleep(pWal->pVfs, nDelay);
  }
 
  if( !useWal ){
    assert( rc==SQLITE_OK );
    if( pWal->bShmUnreliable==0 ){
      rc = walIndexReadHdr(pWal, pChanged);
    }
    if( rc==SQLITE_BUSY ){
      /* If there is not a recovery running in another thread or process
      ** then convert BUSY errors to WAL_RETRY.  If recovery is known to
      ** be running, convert BUSY to BUSY_RECOVERY.  There is a race here
      ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
      ** would be technically correct.  But the race is benign since with
      ** WAL_RETRY this routine will be called again and will probably be
      ** right on the second iteration.
      */
      if( pWal->apWiData[0]==0 ){
        /* This branch is taken when the xShmMap() method returns SQLITE_BUSY.
        ** We assume this is a transient condition, so return WAL_RETRY. The
        ** xShmMap() implementation used by the default unix and win32 VFS
        ** modules may return SQLITE_BUSY due to a race condition in the
        ** code that determines whether or not the shared-memory region
        ** must be zeroed before the requested page is returned.
        */
        rc = WAL_RETRY;
      }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
        walUnlockShared(pWal, WAL_RECOVER_LOCK);
        rc = WAL_RETRY;
      }else if( rc==SQLITE_BUSY ){
        rc = SQLITE_BUSY_RECOVERY;
      }
    }
    if( rc!=SQLITE_OK ){
      return rc;
    }
    else if( pWal->bShmUnreliable ){
      return walBeginShmUnreliable(pWal, pChanged);
    }
  }
 
  assert( pWal->nWiData>0 );
  assert( pWal->apWiData[0]!=0 );
  pInfo = walCkptInfo(pWal);
  if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
#ifdef SQLITE_ENABLE_SNAPSHOT
   && (pWal->pSnapshot==0 || pWal->hdr.mxFrame==0)
#endif
  ){
    /* The WAL has been completely backfilled (or it is empty).
    ** and can be safely ignored.
    */
    rc = walLockShared(pWal, WAL_READ_LOCK(0));
    walShmBarrier(pWal);
    if( rc==SQLITE_OK ){
      if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
        /* It is not safe to allow the reader to continue here if frames
        ** may have been appended to the log before READ_LOCK(0) was obtained.
        ** When holding READ_LOCK(0), the reader ignores the entire log file,
        ** which implies that the database file contains a trustworthy
        ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from
        ** happening, this is usually correct.
        **
        ** However, if frames have been appended to the log (or if the log
        ** is wrapped and written for that matter) before the READ_LOCK(0)
        ** is obtained, that is not necessarily true. A checkpointer may
        ** have started to backfill the appended frames but crashed before
        ** it finished. Leaving a corrupt image in the database file.
        */
        walUnlockShared(pWal, WAL_READ_LOCK(0));
        return WAL_RETRY;
      }
      pWal->readLock = 0;
      return SQLITE_OK;
    }else if( rc!=SQLITE_BUSY ){
      return rc;
    }
  }
 
  /* If we get this far, it means that the reader will want to use
  ** the WAL to get at content from recent commits.  The job now is
  ** to select one of the aReadMark[] entries that is closest to
  ** but not exceeding pWal->hdr.mxFrame and lock that entry.
  */
  mxReadMark = 0;
  mxI = 0;
  mxFrame = pWal->hdr.mxFrame;
#ifdef SQLITE_ENABLE_SNAPSHOT
  if( pWal->pSnapshot && pWal->pSnapshot->mxFrame<mxFrame ){
    mxFrame = pWal->pSnapshot->mxFrame;
  }
#endif
  for(i=1; i<WAL_NREADER; i++){
    u32 thisMark = AtomicLoad(pInfo->aReadMark+i);
    if( mxReadMark<=thisMark && thisMark<=mxFrame ){
      assert( thisMark!=READMARK_NOT_USED );
      mxReadMark = thisMark;
      mxI = i;
    }
  }
  if( (pWal->readOnly & WAL_SHM_RDONLY)==0
   && (mxReadMark<mxFrame || mxI==0)
  ){
    for(i=1; i<WAL_NREADER; i++){
      rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
      if( rc==SQLITE_OK ){
        AtomicStore(pInfo->aReadMark+i,mxFrame);
        mxReadMark = mxFrame;
        mxI = i;
        walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
        break;
      }else if( rc!=SQLITE_BUSY ){
        return rc;
      }
    }
  }
  if( mxI==0 ){
    assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
    return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTINIT;
  }
 
  rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
  if( rc ){
    return rc==SQLITE_BUSY ? WAL_RETRY : rc;
  }
  /* Now that the read-lock has been obtained, check that neither the
  ** value in the aReadMark[] array or the contents of the wal-index
  ** header have changed.
  **
  ** It is necessary to check that the wal-index header did not change
  ** between the time it was read and when the shared-lock was obtained
  ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility
  ** that the log file may have been wrapped by a writer, or that frames
  ** that occur later in the log than pWal->hdr.mxFrame may have been
  ** copied into the database by a checkpointer. If either of these things
  ** happened, then reading the database with the current value of
  ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
  ** instead.
  **
  ** Before checking that the live wal-index header has not changed
  ** since it was read, set Wal.minFrame to the first frame in the wal
  ** file that has not yet been checkpointed. This client will not need
  ** to read any frames earlier than minFrame from the wal file - they
  ** can be safely read directly from the database file.
  **
  ** Because a ShmBarrier() call is made between taking the copy of
  ** nBackfill and checking that the wal-header in shared-memory still
  ** matches the one cached in pWal->hdr, it is guaranteed that the
  ** checkpointer that set nBackfill was not working with a wal-index
  ** header newer than that cached in pWal->hdr. If it were, that could
  ** cause a problem. The checkpointer could omit to checkpoint
  ** a version of page X that lies before pWal->minFrame (call that version
  ** A) on the basis that there is a newer version (version B) of the same
  ** page later in the wal file. But if version B happens to like past
  ** frame pWal->hdr.mxFrame - then the client would incorrectly assume
  ** that it can read version A from the database file. However, since
  ** we can guarantee that the checkpointer that set nBackfill could not
  ** see any pages past pWal->hdr.mxFrame, this problem does not come up.
  */
  pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1;
  walShmBarrier(pWal);
  if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark
   || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
  ){
    walUnlockShared(pWal, WAL_READ_LOCK(mxI));
    return WAL_RETRY;

References Wal::apWiData, WalCkptInfo::aReadMark, AtomicLoad, AtomicStore, Wal::bShmUnreliable, Wal::hdr, Wal::minFrame, WalIndexHdr::mxFrame, WalCkptInfo::nBackfill, Wal::nWiData, Wal::pVfs, Wal::readLock, READMARK_NOT_USED, Wal::readOnly, sqlite3OsSleep(), SQLITE_BUSY, SQLITE_BUSY_RECOVERY, SQLITE_OK, SQLITE_PROTOCOL, SQLITE_READONLY_CANTINIT, VVA_ONLY, WAL_NREADER, WAL_READ_LOCK, WAL_RECOVER_LOCK, WAL_RETRY, WAL_SHM_RDONLY, walBeginShmUnreliable(), walCkptInfo(), walIndexHdr(), walIndexReadHdr(), walLockExclusive(), walLockShared(), walShmBarrier(), walUnlockExclusive(), and walUnlockShared().

Referenced by sqlite3WalBeginReadTransaction(), and walRestartLog().

◆ walUnlockExclusive()

static void walUnlockExclusive	(	Wal *	pWal,
		int	lockIdx,
		int	n )

static

Definition at line 60282 of file sqlite3.c.

                  : acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
            walLockName(lockIdx), n, rc ? "failed" : "ok"));
  VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
  return rc;
}
static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){

Referenced by sqlite3WalBeginWriteTransaction(), sqlite3WalCheckpoint(), walCheckpoint(), walIndexReadHdr(), walIndexRecover(), walRestartLog(), and walTryBeginRead().

◆ walUnlockShared()

static void walUnlockShared	(	Wal *	pWal,
		int	lockIdx )

static

Definition at line 60266 of file sqlite3.c.

                  : acquire SHARED-%s %s\n", pWal,
            walLockName(lockIdx), rc ? "failed" : "ok"));
  VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
  return rc;
}

Referenced by sqlite3WalBeginReadTransaction(), sqlite3WalExclusiveMode(), walIndexReadHdr(), walRestartLog(), and walTryBeginRead().

◆ walWriteOneFrame()

static int walWriteOneFrame	(	WalWriter *	p,
		PgHdr *	pPage,
		int	nTruncate,
		sqlite3_int64	iOffset )

static

Definition at line 62821 of file sqlite3.c.

 {
  int rc;                         /* Result code from subfunctions */
  void *pData;                    /* Data actually written */
  u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-header in */
  pData = pPage->pData;
  walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);

◆ walWriteToLog()

static int walWriteToLog	(	WalWriter *	p,
		void *	pContent,
		int	iAmt,
		sqlite3_int64	iOffset )

static

Definition at line 62796 of file sqlite3.c.

 {
  int rc;
  if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
    int iFirstAmt = (int)(p->iSyncPoint - iOffset);
    rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
    if( rc ) return rc;
    iOffset += iFirstAmt;
    iAmt -= iFirstAmt;
    pContent = (void*)(iFirstAmt + (char*)pContent);
    assert( WAL_SYNC_FLAGS(p->syncFlags)!=0 );

References WalWriter::iSyncPoint, WalWriter::pFd, sqlite3OsSync(), sqlite3OsWrite(), WalWriter::syncFlags, and WAL_SYNC_FLAGS.

◆ whereAndInfoDelete()

static void whereAndInfoDelete	(	sqlite3 *	db,
		WhereAndInfo *	p )

static

Definition at line 144026 of file sqlite3.c.

Referenced by sqlite3WhereClauseClear().

◆ whereApplyPartialIndexConstraints()

static void whereApplyPartialIndexConstraints	(	Expr *	pTruth,
		int	iTabCur,
		WhereClause *	pWC )

static

Definition at line 142765 of file sqlite3.c.

 {
  int i;
  WhereTerm *pTerm;
  while( pTruth->op==TK_AND ){
    whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC);
    pTruth = pTruth->pRight;
  }
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    if( pTerm->wtFlags & TERM_CODED ) continue;

References WhereClause::a, WhereClause::nTerm, Expr::op, WhereTerm::pExpr, Expr::pLeft, Expr::pRight, sqlite3ExprCompare(), TERM_CODED, TK_AND, whereApplyPartialIndexConstraints(), and WhereTerm::wtFlags.

Referenced by whereApplyPartialIndexConstraints().

◆ whereClauseInsert()

static int whereClauseInsert	(	WhereClause *	pWC,
		Expr *	p,
		u16	wtFlags )

static

Definition at line 144050 of file sqlite3.c.

          :  This routine might reallocate the space used to store
** WhereTerms.  All pointers to WhereTerms should be invalidated after
** calling this routine.  Such pointers may be reinitialized by referencing
** the pWC->a[] array.
*/
static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
  WhereTerm *pTerm;
  int idx;
  testcase( wtFlags & TERM_VIRTUAL );
  if( pWC->nTerm>=pWC->nSlot ){
    WhereTerm *pOld = pWC->a;
    sqlite3 *db = pWC->pWInfo->pParse->db;
    pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
    if( pWC->a==0 ){
      if( wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, p);
      }
      pWC->a = pOld;
      return 0;
    }
    memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
    if( pOld!=pWC->aStatic ){
      sqlite3DbFree(db, pOld);
    }
    pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
  }
  pTerm = &pWC->a[idx = pWC->nTerm++];
  if( p && ExprHasProperty(p, EP_Unlikely) ){
    pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
  }else{
    pTerm->truthProb = 1;
  }
  pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
  pTerm->wtFlags = wtFlags;

References WhereClause::a, WhereClause::aStatic, Parse::db, WhereTerm::eOperator, EP_Unlikely, ExprHasProperty, WhereTerm::iParent, Expr::iTable, WhereClause::nSlot, WhereClause::nTerm, offsetof, WhereTerm::pExpr, WhereInfo::pParse, WhereTerm::pWC, WhereClause::pWInfo, sqlite3DbFree(), sqlite3DbMallocRawNN(), sqlite3DbMallocSize(), sqlite3ExprDelete(), sqlite3ExprSkipCollateAndLikely(), sqlite3LogEst(), TERM_DYNAMIC, TERM_VIRTUAL, testcase, WhereTerm::truthProb, and WhereTerm::wtFlags.

Referenced by exprAnalyze(), exprAnalyzeOrTerm(), sqlite3WhereSplit(), sqlite3WhereTabFuncArgs(), and whereCombineDisjuncts().

◆ whereCombineDisjuncts()

static void whereCombineDisjuncts	(	SrcList *	pSrc,
		WhereClause *	pWC,
		WhereTerm *	pOne,
		WhereTerm *	pTwo )

static

Definition at line 144492 of file sqlite3.c.

                                 :
**
**    x<y OR x>y    -->     x!=y
*/
static void whereCombineDisjuncts(
  SrcList *pSrc,         /* the FROM clause */
  WhereClause *pWC,      /* The complete WHERE clause */
  WhereTerm *pOne,       /* First disjunct */
  WhereTerm *pTwo        /* Second disjunct */
){
  u16 eOp = pOne->eOperator | pTwo->eOperator;
  sqlite3 *db;           /* Database connection (for malloc) */
  Expr *pNew;            /* New virtual expression */
  int op;                /* Operator for the combined expression */
  int idxNew;            /* Index in pWC of the next virtual term */
 
  if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
  if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
  if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp
   && (eOp & (WO_EQ|WO_GT|WO_GE))!=eOp ) return;
  assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
  assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
  if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
  if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
  /* If we reach this point, it means the two subterms can be combined */
  if( (eOp & (eOp-1))!=0 ){
    if( eOp & (WO_LT|WO_LE) ){
      eOp = WO_LE;
    }else{
      assert( eOp & (WO_GT|WO_GE) );
      eOp = WO_GE;
    }
  }
  db = pWC->pWInfo->pParse->db;
  pNew = sqlite3ExprDup(db, pOne->pExpr, 0);

References Parse::db, WhereTerm::eOperator, exprAnalyze(), Expr::op, WhereTerm::pExpr, Expr::pLeft, WhereInfo::pParse, Expr::pRight, WhereClause::pWInfo, sqlite3ExprCompare(), sqlite3ExprDup(), TERM_DYNAMIC, TERM_VIRTUAL, TK_EQ, TK_GE, whereClauseInsert(), WO_EQ, WO_GE, WO_GT, WO_LE, and WO_LT.

Referenced by exprAnalyzeOrTerm().

◆ whereIndexExprTrans()

static void whereIndexExprTrans	(	Index *	pIdx,
		int	iTabCur,
		int	iIdxCur,
		WhereInfo *	pWInfo )

static

Definition at line 142702 of file sqlite3.c.

             : Updated to also translate references to a VIRTUAL column in
** the table into references to the corresponding (stored) column of the
** index.
*/
static void whereIndexExprTrans(
  Index *pIdx,      /* The Index */
  int iTabCur,      /* Cursor of the table that is being indexed */
  int iIdxCur,      /* Cursor of the index itself */
  WhereInfo *pWInfo /* Transform expressions in this WHERE clause */
){
  int iIdxCol;               /* Column number of the index */
  ExprList *aColExpr;        /* Expressions that are indexed */
  Table *pTab;
  Walker w;
  IdxExprTrans x;
  aColExpr = pIdx->aColExpr;
  if( aColExpr==0 && !pIdx->bHasVCol ){
    /* The index does not reference any expressions or virtual columns
    ** so no translations are needed. */
    return;
  }
  pTab = pIdx->pTable;
  memset(&w, 0, sizeof(w));
  w.u.pIdxTrans = &x;
  x.iTabCur = iTabCur;
  x.iIdxCur = iIdxCur;
  x.pWInfo = pWInfo;
  x.db = pWInfo->pParse->db;
  for(iIdxCol=0; iIdxCol<pIdx->nColumn; iIdxCol++){
    i16 iRef = pIdx->aiColumn[iIdxCol];
    if( iRef==XN_EXPR ){
      assert( aColExpr->a[iIdxCol].pExpr!=0 );
      x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
      if( sqlite3ExprIsConstant(x.pIdxExpr) ) continue;
      w.xExprCallback = whereIndexExprTransNode;
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    }else if( iRef>=0
       && (pTab->aCol[iRef].colFlags & COLFLAG_VIRTUAL)!=0
       && (pTab->aCol[iRef].zColl==0
           || sqlite3StrICmp(pTab->aCol[iRef].zColl, sqlite3StrBINARY)==0)
    ){
      /* Check to see if there are direct references to generated columns
      ** that are contained in the index.  Pulling the generated column
      ** out of the index is an optimization only - the main table is always
      ** available if the index cannot be used.  To avoid unnecessary
      ** complication, omit this optimization if the collating sequence for
      ** the column is non-standard */
      x.iTabCol = iRef;
      w.xExprCallback = whereIndexExprTransColumn;
#endif /* SQLITE_OMIT_GENERATED_COLUMNS */
    }else{
      continue;
    }

References ExprList::a, Table::aCol, Index::aColExpr, Index::aiColumn, Index::bHasVCol, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, IdxExprTrans::db, IdxExprTrans::iIdxCol, IdxExprTrans::iIdxCur, IdxExprTrans::iTabCol, IdxExprTrans::iTabCur, Index::nColumn, ExprList::ExprList_item::pExpr, IdxExprTrans::pIdxExpr, Walker::pIdxTrans, WhereInfo::pOrderBy, WhereInfo::pParse, WhereInfo::pResultSet, Index::pTable, WhereInfo::pWhere, IdxExprTrans::pWInfo, sqlite3ExprIsConstant(), sqlite3StrBINARY, sqlite3StrICmp(), sqlite3WalkExpr(), sqlite3WalkExprList(), Walker::u, whereIndexExprTransColumn(), whereIndexExprTransNode(), Walker::xExprCallback, XN_EXPR, and Column::zColl.

◆ whereIndexExprTransColumn()

static int whereIndexExprTransColumn	(	Walker *	p,
		Expr *	pExpr )

static

Definition at line 142677 of file sqlite3.c.

                                                            {
  if( pExpr->op==TK_COLUMN ){
    IdxExprTrans *pX = p->u.pIdxTrans;
    if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
      assert( pExpr->y.pTab!=0 );
      preserveExpr(pX, pExpr);
      pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
      pExpr->iTable = pX->iIdxCur;

Referenced by whereIndexExprTrans().

◆ whereIndexExprTransNode()

static int whereIndexExprTransNode	(	Walker *	p,
		Expr *	pExpr )

static

Definition at line 142655 of file sqlite3.c.

                                                          {
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    preserveExpr(pX, pExpr);
    pExpr->affExpr = sqlite3ExprAffinity(pExpr);
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->y.pTab = 0;
    testcase( ExprHasProperty(pExpr, EP_Skip) );
    testcase( ExprHasProperty(pExpr, EP_Unlikely) );

References Expr::affExpr, EP_Skip, EP_Unlikely, ExprClearProperty, ExprHasProperty, Expr::iColumn, IdxExprTrans::iIdxCol, IdxExprTrans::iIdxCur, IdxExprTrans::iTabCur, Expr::iTable, Expr::op, IdxExprTrans::pIdxExpr, Walker::pIdxTrans, preserveExpr(), Expr::pTab, sqlite3ExprAffinity(), sqlite3ExprCompare(), testcase, TK_COLUMN, Walker::u, WRC_Continue, WRC_Prune, and Expr::y.

Referenced by whereIndexExprTrans().

◆ whereInfoFree()

static void whereInfoFree	(	sqlite3 *	db,
		WhereInfo *	pWInfo )

static

Definition at line 147539 of file sqlite3.c.

                                                         {
  int i;
  assert( pWInfo!=0 );
  for(i=0; i<pWInfo->nLevel; i++){
    WhereLevel *pLevel = &pWInfo->a[i];
    if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){
      sqlite3DbFree(db, pLevel->u.in.aInLoop);
    }
  }
  sqlite3WhereClauseClear(&pWInfo->sWC);
  while( pWInfo->pLoops ){
    WhereLoop *p = pWInfo->pLoops;

Referenced by sqlite3WhereBegin(), and sqlite3WhereEnd().

◆ whereLikeOptimizationStringFixup()

static void whereLikeOptimizationStringFixup	(	Vdbe *	v,
		WhereLevel *	pLevel,
		WhereTerm *	pTerm )

static

Definition at line 142300 of file sqlite3.c.

 {
  if( pTerm->wtFlags & TERM_LIKEOPT ){
    VdbeOp *pOp;
    assert( pLevel->iLikeRepCntr>0 );
    pOp = sqlite3VdbeGetOp(v, -1);
    assert( pOp!=0 );

References Parse::db, WhereLevel::iLikeRepCntr, sqlite3::mallocFailed, OP_String8, VdbeOp::opcode, VdbeOp::p3, VdbeOp::p5, WhereInfo::pParse, WhereTerm::pWC, WhereClause::pWInfo, sqlite3VdbeGetOp(), TERM_LIKEOPT, and WhereTerm::wtFlags.

◆ whereLoopAddAll()

static int whereLoopAddAll ( WhereLoopBuilder * pBuilder )

static

Definition at line 149207 of file sqlite3.c.

                                                      {
  WhereInfo *pWInfo = pBuilder->pWInfo;
  Bitmask mPrereq = 0;
  Bitmask mPrior = 0;
  int iTab;
  SrcList *pTabList = pWInfo->pTabList;
  struct SrcList_item *pItem;
  struct SrcList_item *pEnd = &pTabList->a[pWInfo->nLevel];
  sqlite3 *db = pWInfo->pParse->db;
  int rc = SQLITE_OK;
  WhereLoop *pNew;
 
  /* Loop over the tables in the join, from left to right */
  pNew = pBuilder->pNew;
  whereLoopInit(pNew);
  pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT;
  for(iTab=0, pItem=pTabList->a; pItem<pEnd; iTab++, pItem++){
    Bitmask mUnusable = 0;
    pNew->iTab = iTab;
    pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR;
    pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
    if( (pItem->fg.jointype & (JT_LEFT|JT_CROSS))!=0 ){
      /* This condition is true when pItem is the FROM clause term on the
      ** right-hand-side of a LEFT or CROSS JOIN.  */
      mPrereq = mPrior;
    }else{
      mPrereq = 0;
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    if( IsVirtual(pItem->pTab) ){
      struct SrcList_item *p;
      for(p=&pItem[1]; p<pEnd; p++){
        if( mUnusable || (p->fg.jointype & (JT_LEFT|JT_CROSS)) ){
          mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor);
        }
      }
      rc = whereLoopAddVirtual(pBuilder, mPrereq, mUnusable);
    }else
#endif /* SQLITE_OMIT_VIRTUALTABLE */
    {
      rc = whereLoopAddBtree(pBuilder, mPrereq);
    }
    if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){
      rc = whereLoopAddOr(pBuilder, mPrereq, mUnusable);
    }
    mPrior |= pNew->maskSelf;
    if( rc || db->mallocFailed ){
      if( rc==SQLITE_DONE ){
        /* We hit the query planner search limit set by iPlanLimit */
        sqlite3_log(SQLITE_WARNING, "abbreviated query algorithm search");
        rc = SQLITE_OK;
      }else{
        break;
      }

Referenced by sqlite3WhereBegin().

◆ whereLoopAddBtree()

static int whereLoopAddBtree	(	WhereLoopBuilder *	pBuilder,
		Bitmask	mPrereq )

static

Definition at line 148501 of file sqlite3.c.

 {
  WhereInfo *pWInfo;          /* WHERE analysis context */
  Index *pProbe;              /* An index we are evaluating */
  Index sPk;                  /* A fake index object for the primary key */
  LogEst aiRowEstPk[2];       /* The aiRowLogEst[] value for the sPk index */
  i16 aiColumnPk = -1;        /* The aColumn[] value for the sPk index */
  SrcList *pTabList;          /* The FROM clause */
  struct SrcList_item *pSrc;  /* The FROM clause btree term to add */
  WhereLoop *pNew;            /* Template WhereLoop object */
  int rc = SQLITE_OK;         /* Return code */
  int iSortIdx = 1;           /* Index number */
  int b;                      /* A boolean value */
  LogEst rSize;               /* number of rows in the table */
  LogEst rLogSize;            /* Logarithm of the number of rows in the table */
  WhereClause *pWC;           /* The parsed WHERE clause */
  Table *pTab;                /* Table being queried */
 
  pNew = pBuilder->pNew;
  pWInfo = pBuilder->pWInfo;
  pTabList = pWInfo->pTabList;
  pSrc = pTabList->a + pNew->iTab;
  pTab = pSrc->pTab;
  pWC = pBuilder->pWC;
  assert( !IsVirtual(pSrc->pTab) );
 
  if( pSrc->pIBIndex ){
    /* An INDEXED BY clause specifies a particular index to use */
    pProbe = pSrc->pIBIndex;
  }else if( !HasRowid(pTab) ){
    pProbe = pTab->pIndex;
  }else{
    /* There is no INDEXED BY clause.  Create a fake Index object in local
    ** variable sPk to represent the rowid primary key index.  Make this
    ** fake index the first in a chain of Index objects with all of the real
    ** indices to follow */
    Index *pFirst;                  /* First of real indices on the table */
    memset(&sPk, 0, sizeof(Index));
    sPk.nKeyCol = 1;
    sPk.nColumn = 1;
    sPk.aiColumn = &aiColumnPk;
    sPk.aiRowLogEst = aiRowEstPk;
    sPk.onError = OE_Replace;
    sPk.pTable = pTab;
    sPk.szIdxRow = pTab->szTabRow;
    sPk.idxType = SQLITE_IDXTYPE_IPK;
    aiRowEstPk[0] = pTab->nRowLogEst;
    aiRowEstPk[1] = 0;
    pFirst = pSrc->pTab->pIndex;
    if( pSrc->fg.notIndexed==0 ){
      /* The real indices of the table are only considered if the
      ** NOT INDEXED qualifier is omitted from the FROM clause */
      sPk.pNext = pFirst;
    }
    pProbe = &sPk;
  }
  rSize = pTab->nRowLogEst;
  rLogSize = estLog(rSize);
 
#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
  /* Automatic indexes */
  if( !pBuilder->pOrSet      /* Not part of an OR optimization */
   && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
   && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
   && pSrc->pIBIndex==0      /* Has no INDEXED BY clause */
   && !pSrc->fg.notIndexed   /* Has no NOT INDEXED clause */
   && HasRowid(pTab)         /* Not WITHOUT ROWID table. (FIXME: Why not?) */
   && !pSrc->fg.isCorrelated /* Not a correlated subquery */
   && !pSrc->fg.isRecursive  /* Not a recursive common table expression. */
  ){
    /* Generate auto-index WhereLoops */
    WhereTerm *pTerm;
    WhereTerm *pWCEnd = pWC->a + pWC->nTerm;
    for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
      if( pTerm->prereqRight & pNew->maskSelf ) continue;
      if( termCanDriveIndex(pTerm, pSrc, 0) ){
        pNew->u.btree.nEq = 1;
        pNew->nSkip = 0;
        pNew->u.btree.pIndex = 0;
        pNew->nLTerm = 1;
        pNew->aLTerm[0] = pTerm;
        /* TUNING: One-time cost for computing the automatic index is
        ** estimated to be X*N*log2(N) where N is the number of rows in
        ** the table being indexed and where X is 7 (LogEst=28) for normal
        ** tables or 0.5 (LogEst=-10) for views and subqueries.  The value
        ** of X is smaller for views and subqueries so that the query planner
        ** will be more aggressive about generating automatic indexes for
        ** those objects, since there is no opportunity to add schema
        ** indexes on subqueries and views. */
        pNew->rSetup = rLogSize + rSize;
        if( pTab->pSelect==0 && (pTab->tabFlags & TF_Ephemeral)==0 ){
          pNew->rSetup += 28;
        }else{
          pNew->rSetup -= 10;
        }
        ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
        if( pNew->rSetup<0 ) pNew->rSetup = 0;
        /* TUNING: Each index lookup yields 20 rows in the table.  This
        ** is more than the usual guess of 10 rows, since we have no way
        ** of knowing how selective the index will ultimately be.  It would
        ** not be unreasonable to make this value much larger. */
        pNew->nOut = 43;  assert( 43==sqlite3LogEst(20) );
        pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut);
        pNew->wsFlags = WHERE_AUTO_INDEX;
        pNew->prereq = mPrereq | pTerm->prereqRight;
        rc = whereLoopInsert(pBuilder, pNew);
      }
    }
  }
#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */
 
  /* Loop over all indices. If there was an INDEXED BY clause, then only
  ** consider index pProbe.  */
  for(; rc==SQLITE_OK && pProbe;
      pProbe=(pSrc->pIBIndex ? 0 : pProbe->pNext), iSortIdx++
  ){
    int isLeft = (pSrc->fg.jointype & JT_OUTER)!=0;
    if( pProbe->pPartIdxWhere!=0
     && !whereUsablePartialIndex(pSrc->iCursor, isLeft, pWC,
                                 pProbe->pPartIdxWhere)
    ){
      testcase( pNew->iTab!=pSrc->iCursor );  /* See ticket [98d973b8f5] */
      continue;  /* Partial index inappropriate for this query */
    }
    if( pProbe->bNoQuery ) continue;
    rSize = pProbe->aiRowLogEst[0];
    pNew->u.btree.nEq = 0;
    pNew->u.btree.nBtm = 0;
    pNew->u.btree.nTop = 0;
    pNew->nSkip = 0;
    pNew->nLTerm = 0;
    pNew->iSortIdx = 0;
    pNew->rSetup = 0;
    pNew->prereq = mPrereq;
    pNew->nOut = rSize;
    pNew->u.btree.pIndex = pProbe;
    b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor);
 
    /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */
    assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 );
    if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
      /* Integer primary key index */
      pNew->wsFlags = WHERE_IPK;
 
      /* Full table scan */
      pNew->iSortIdx = b ? iSortIdx : 0;
      /* TUNING: Cost of full table scan is (N*3.0). */
      pNew->rRun = rSize + 16;
      ApplyCostMultiplier(pNew->rRun, pTab->costMult);
      whereLoopOutputAdjust(pWC, pNew, rSize);
      rc = whereLoopInsert(pBuilder, pNew);
      pNew->nOut = rSize;
      if( rc ) break;
    }else{
      Bitmask m;
      if( pProbe->isCovering ){
        pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
        m = 0;
      }else{
        m = pSrc->colUsed & pProbe->colNotIdxed;
        pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;
      }
 
      /* Full scan via index */
      if( b
       || !HasRowid(pTab)
       || pProbe->pPartIdxWhere!=0
       || pSrc->fg.isIndexedBy
       || ( m==0
         && pProbe->bUnordered==0
         && (pProbe->szIdxRow<pTab->szTabRow)
         && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0
         && sqlite3GlobalConfig.bUseCis
         && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)
          )
      ){
        pNew->iSortIdx = b ? iSortIdx : 0;
 
        /* The cost of visiting the index rows is N*K, where K is
        ** between 1.1 and 3.0, depending on the relative sizes of the
        ** index and table rows. */
        pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
        if( m!=0 ){
          /* If this is a non-covering index scan, add in the cost of
          ** doing table lookups.  The cost will be 3x the number of
          ** lookups.  Take into account WHERE clause terms that can be
          ** satisfied using just the index, and that do not require a
          ** table lookup. */
          LogEst nLookup = rSize + 16;  /* Base cost:  N*3 */
          int ii;
          int iCur = pSrc->iCursor;
          WhereClause *pWC2 = &pWInfo->sWC;
          for(ii=0; ii<pWC2->nTerm; ii++){
            WhereTerm *pTerm = &pWC2->a[ii];
            if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
              break;
            }
            /* pTerm can be evaluated using just the index.  So reduce
            ** the expected number of table lookups accordingly */
            if( pTerm->truthProb<=0 ){
              nLookup += pTerm->truthProb;
            }else{
              nLookup--;
              if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19;
            }
          }
 
          pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup);
        }
        ApplyCostMultiplier(pNew->rRun, pTab->costMult);
        whereLoopOutputAdjust(pWC, pNew, rSize);
        rc = whereLoopInsert(pBuilder, pNew);
        pNew->nOut = rSize;
        if( rc ) break;
      }
    }
 
    pBuilder->bldFlags1 = 0;
    rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0);
    if( pBuilder->bldFlags1==SQLITE_BLDF1_INDEXED ){
      /* If a non-unique index is used, or if a prefix of the key for
      ** unique index is used (making the index functionally non-unique)
      ** then the sqlite_stat1 data becomes important for scoring the
      ** plan */
      pTab->tabFlags |= TF_StatsUsed;
    }
#ifdef SQLITE_ENABLE_STAT4
    sqlite3Stat4ProbeFree(pBuilder->pRec);

References SrcList::a, WhereClause::a, Index::aiColumn, Index::aiRowLogEst, WhereLoop::aLTerm, ApplyCostMultiplier, WhereLoopBuilder::bldFlags1, Index::bNoQuery, WhereLoop::btree, Index::bUnordered, Index::colNotIdxed, Parse::db, WhereTerm::eOperator, estLog(), sqlite3::flags, HasRowid, Index::idxType, indexMightHelpWithOrderBy(), Index::isCovering, WhereLoop::iSortIdx, IsVirtual, WhereLoop::iTab, JT_OUTER, WhereLoop::maskSelf, WhereLoop::nBtm, Index::nColumn, WhereLoop::nEq, Index::nKeyCol, WhereLoop::nLTerm, WhereLoop::nOut, Table::nRowLogEst, WhereLoop::nSkip, WhereClause::nTerm, WhereLoop::nTop, OE_Replace, Index::onError, OptimizationEnabled, WhereTerm::pExpr, Table::pIndex, WhereLoop::pIndex, WhereLoopBuilder::pNew, Index::pNext, WhereLoopBuilder::pOrSet, WhereInfo::pParse, Index::pPartIdxWhere, WhereLoop::prereq, WhereTerm::prereqRight, Table::pSelect, Index::pTable, WhereInfo::pTabList, WhereLoopBuilder::pWC, WhereLoopBuilder::pWInfo, WhereLoop::rRun, WhereLoop::rSetup, sqlite3ExprCoveredByIndex(), sqlite3GlobalConfig, sqlite3LogEst(), sqlite3LogEstAdd(), SQLITE_AutoIndex, SQLITE_BLDF1_INDEXED, SQLITE_CoverIdxScan, SQLITE_IDXTYPE_IPK, SQLITE_OK, WhereInfo::sWC, Index::szIdxRow, Table::szTabRow, Table::tabFlags, termCanDriveIndex(), testcase, TF_Ephemeral, TF_StatsUsed, WhereTerm::truthProb, WhereLoop::u, WhereInfo::wctrlFlags, WHERE_AUTO_INDEX, WHERE_IDX_ONLY, WHERE_INDEXED, WHERE_IPK, WHERE_ONEPASS_DESIRED, WHERE_OR_SUBCLAUSE, whereLoopAddBtreeIndex(), whereLoopInsert(), whereLoopOutputAdjust(), whereUsablePartialIndex(), WO_EQ, WO_IS, and WhereLoop::wsFlags.

Referenced by whereLoopAddOr().

◆ whereLoopAddBtreeIndex()

static int whereLoopAddBtreeIndex	(	WhereLoopBuilder *	pBuilder,
		struct SrcList_item *	pSrc,
		Index *	pProbe,
		LogEst	nInMul )

static

Definition at line 148020 of file sqlite3.c.

 {
  WhereInfo *pWInfo = pBuilder->pWInfo;  /* WHERE analyse context */
  Parse *pParse = pWInfo->pParse;        /* Parsing context */
  sqlite3 *db = pParse->db;       /* Database connection malloc context */
  WhereLoop *pNew;                /* Template WhereLoop under construction */
  WhereTerm *pTerm;               /* A WhereTerm under consideration */
  int opMask;                     /* Valid operators for constraints */
  WhereScan scan;                 /* Iterator for WHERE terms */
  Bitmask saved_prereq;           /* Original value of pNew->prereq */
  u16 saved_nLTerm;               /* Original value of pNew->nLTerm */
  u16 saved_nEq;                  /* Original value of pNew->u.btree.nEq */
  u16 saved_nBtm;                 /* Original value of pNew->u.btree.nBtm */
  u16 saved_nTop;                 /* Original value of pNew->u.btree.nTop */
  u16 saved_nSkip;                /* Original value of pNew->nSkip */
  u32 saved_wsFlags;              /* Original value of pNew->wsFlags */
  LogEst saved_nOut;              /* Original value of pNew->nOut */
  int rc = SQLITE_OK;             /* Return code */
  LogEst rSize;                   /* Number of rows in the table */
  LogEst rLogSize;                /* Logarithm of table size */
  WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */
 
  pNew = pBuilder->pNew;
  if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;
  WHERETRACE(0x800, ("BEGIN %s.addBtreeIdx(%s), nEq=%d, nSkip=%d\n",
                     pProbe->pTable->zName,pProbe->zName,
                     pNew->u.btree.nEq, pNew->nSkip));
 
  assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
  assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
  if( pNew->wsFlags & WHERE_BTM_LIMIT ){
    opMask = WO_LT|WO_LE;
  }else{
    assert( pNew->u.btree.nBtm==0 );
    opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS;
  }
  if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
 
  assert( pNew->u.btree.nEq<pProbe->nColumn );
 
  saved_nEq = pNew->u.btree.nEq;
  saved_nBtm = pNew->u.btree.nBtm;
  saved_nTop = pNew->u.btree.nTop;
  saved_nSkip = pNew->nSkip;
  saved_nLTerm = pNew->nLTerm;
  saved_wsFlags = pNew->wsFlags;
  saved_prereq = pNew->prereq;
  saved_nOut = pNew->nOut;
  pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq,
                        opMask, pProbe);
  pNew->rSetup = 0;
  rSize = pProbe->aiRowLogEst[0];
  rLogSize = estLog(rSize);
  for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
    u16 eOp = pTerm->eOperator;   /* Shorthand for pTerm->eOperator */
    LogEst rCostIdx;
    LogEst nOutUnadjusted;        /* nOut before IN() and WHERE adjustments */
    int nIn = 0;
#ifdef SQLITE_ENABLE_STAT4
    int nRecValid = pBuilder->nRecValid;
#endif
    if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0)
     && indexColumnNotNull(pProbe, saved_nEq)
    ){
      continue; /* ignore IS [NOT] NULL constraints on NOT NULL columns */
    }
    if( pTerm->prereqRight & pNew->maskSelf ) continue;
 
    /* Do not allow the upper bound of a LIKE optimization range constraint
    ** to mix with a lower range bound from some other source */
    if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
 
    /* tag-20191211-001:  Do not allow constraints from the WHERE clause to
    ** be used by the right table of a LEFT JOIN.  Only constraints in the
    ** ON clause are allowed.  See tag-20191211-002 for the vtab equivalent. */
    if( (pSrc->fg.jointype & JT_LEFT)!=0
     && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
    ){
      continue;
    }
 
    if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){
      pBuilder->bldFlags1 |= SQLITE_BLDF1_UNIQUE;
    }else{
      pBuilder->bldFlags1 |= SQLITE_BLDF1_INDEXED;
    }
    pNew->wsFlags = saved_wsFlags;
    pNew->u.btree.nEq = saved_nEq;
    pNew->u.btree.nBtm = saved_nBtm;
    pNew->u.btree.nTop = saved_nTop;
    pNew->nLTerm = saved_nLTerm;
    if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
    pNew->aLTerm[pNew->nLTerm++] = pTerm;
    pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
 
    assert( nInMul==0
        || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0
        || (pNew->wsFlags & WHERE_COLUMN_IN)!=0
        || (pNew->wsFlags & WHERE_SKIPSCAN)!=0
    );
 
    if( eOp & WO_IN ){
      Expr *pExpr = pTerm->pExpr;
      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        /* "x IN (SELECT ...)":  TUNING: the SELECT returns 25 rows */
        int i;
        nIn = 46;  assert( 46==sqlite3LogEst(25) );
 
        /* The expression may actually be of the form (x, y) IN (SELECT...).
        ** In this case there is a separate term for each of (x) and (y).
        ** However, the nIn multiplier should only be applied once, not once
        ** for each such term. The following loop checks that pTerm is the
        ** first such term in use, and sets nIn back to 0 if it is not. */
        for(i=0; i<pNew->nLTerm-1; i++){
          if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
        }
      }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
        /* "x IN (value, value, ...)" */
        nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
      }
      if( pProbe->hasStat1 ){
        LogEst M, logK, safetyMargin;
        /* Let:
        **   N = the total number of rows in the table
        **   K = the number of entries on the RHS of the IN operator
        **   M = the number of rows in the table that match terms to the
        **       to the left in the same index.  If the IN operator is on
        **       the left-most index column, M==N.
        **
        ** Given the definitions above, it is better to omit the IN operator
        ** from the index lookup and instead do a scan of the M elements,
        ** testing each scanned row against the IN operator separately, if:
        **
        **        M*log(K) < K*log(N)
        **
        ** Our estimates for M, K, and N might be inaccurate, so we build in
        ** a safety margin of 2 (LogEst: 10) that favors using the IN operator
        ** with the index, as using an index has better worst-case behavior.
        ** If we do not have real sqlite_stat1 data, always prefer to use
        ** the index.
        */
        M = pProbe->aiRowLogEst[saved_nEq];
        logK = estLog(nIn);
        safetyMargin = 10;  /* TUNING: extra weight for indexed IN */
        if( M + logK + safetyMargin < nIn + rLogSize ){
          WHERETRACE(0x40,
            ("Scan preferred over IN operator on column %d of \"%s\" (%d<%d)\n",
             saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
          continue;
        }else{
          WHERETRACE(0x40,
            ("IN operator preferred on column %d of \"%s\" (%d>=%d)\n",
             saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
        }
      }
      pNew->wsFlags |= WHERE_COLUMN_IN;
    }else if( eOp & (WO_EQ|WO_IS) ){
      int iCol = pProbe->aiColumn[saved_nEq];
      pNew->wsFlags |= WHERE_COLUMN_EQ;
      assert( saved_nEq==pNew->u.btree.nEq );
      if( iCol==XN_ROWID
       || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
      ){
        if( iCol==XN_ROWID || pProbe->uniqNotNull
         || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ)
        ){
          pNew->wsFlags |= WHERE_ONEROW;
        }else{
          pNew->wsFlags |= WHERE_UNQ_WANTED;
        }
      }
    }else if( eOp & WO_ISNULL ){
      pNew->wsFlags |= WHERE_COLUMN_NULL;
    }else if( eOp & (WO_GT|WO_GE) ){
      testcase( eOp & WO_GT );
      testcase( eOp & WO_GE );
      pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
      pNew->u.btree.nBtm = whereRangeVectorLen(
          pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
      );
      pBtm = pTerm;
      pTop = 0;
      if( pTerm->wtFlags & TERM_LIKEOPT ){
        /* Range contraints that come from the LIKE optimization are
        ** always used in pairs. */
        pTop = &pTerm[1];
        assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
        assert( pTop->wtFlags & TERM_LIKEOPT );
        assert( pTop->eOperator==WO_LT );
        if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
        pNew->aLTerm[pNew->nLTerm++] = pTop;
        pNew->wsFlags |= WHERE_TOP_LIMIT;
        pNew->u.btree.nTop = 1;
      }
    }else{
      assert( eOp & (WO_LT|WO_LE) );
      testcase( eOp & WO_LT );
      testcase( eOp & WO_LE );
      pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT;
      pNew->u.btree.nTop = whereRangeVectorLen(
          pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
      );
      pTop = pTerm;
      pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ?
                     pNew->aLTerm[pNew->nLTerm-2] : 0;
    }
 
    /* At this point pNew->nOut is set to the number of rows expected to
    ** be visited by the index scan before considering term pTerm, or the
    ** values of nIn and nInMul. In other words, assuming that all
    ** "x IN(...)" terms are replaced with "x = ?". This block updates
    ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul).  */
    assert( pNew->nOut==saved_nOut );
    if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
      /* Adjust nOut using stat4 data. Or, if there is no stat4
      ** data, using some other estimate.  */
      whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew);
    }else{
      int nEq = ++pNew->u.btree.nEq;
      assert( eOp & (WO_ISNULL|WO_EQ|WO_IN|WO_IS) );
 
      assert( pNew->nOut==saved_nOut );
      if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){
        assert( (eOp & WO_IN) || nIn==0 );
        testcase( eOp & WO_IN );
        pNew->nOut += pTerm->truthProb;
        pNew->nOut -= nIn;
      }else{
#ifdef SQLITE_ENABLE_STAT4
        tRowcnt nOut = 0;
        if( nInMul==0
         && pProbe->nSample
         && pNew->u.btree.nEq<=pProbe->nSampleCol
         && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
         && OptimizationEnabled(db, SQLITE_Stat4)
        ){
          Expr *pExpr = pTerm->pExpr;
          if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){
            testcase( eOp & WO_EQ );
            testcase( eOp & WO_IS );
            testcase( eOp & WO_ISNULL );
            rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
          }else{
            rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
          }
          if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
          if( rc!=SQLITE_OK ) break;          /* Jump out of the pTerm loop */
          if( nOut ){
            pNew->nOut = sqlite3LogEst(nOut);
            if( nEq==1
             /* TUNING: Mark terms as "low selectivity" if they seem likely
             ** to be true for half or more of the rows in the table.
             ** See tag-202002240-1 */
             && pNew->nOut+10 > pProbe->aiRowLogEst[0]
            ){
#if WHERETRACE_ENABLED /* 0x01 */
              if( sqlite3WhereTrace & 0x01 ){
                sqlite3DebugPrintf(
                   "STAT4 determines term has low selectivity:\n");
                sqlite3WhereTermPrint(pTerm, 999);
              }
#endif
              pTerm->wtFlags |= TERM_HIGHTRUTH;
              if( pTerm->wtFlags & TERM_HEURTRUTH ){
                /* If the term has previously been used with an assumption of
                ** higher selectivity, then set the flag to rerun the
                ** loop computations. */
                pBuilder->bldFlags2 |= SQLITE_BLDF2_2NDPASS;
              }
            }
            if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut;
            pNew->nOut -= nIn;
          }
        }
        if( nOut==0 )
#endif
        {
          pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]);
          if( eOp & WO_ISNULL ){
            /* TUNING: If there is no likelihood() value, assume that a
            ** "col IS NULL" expression matches twice as many rows
            ** as (col=?). */
            pNew->nOut += 10;
          }
        }
      }
    }
 
    /* Set rCostIdx to the cost of visiting selected rows in index. Add
    ** it to pNew->rRun, which is currently set to the cost of the index
    ** seek only. Then, if this is a non-covering index, add the cost of
    ** visiting the rows in the main table.  */
    assert( pSrc->pTab->szTabRow>0 );
    rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
    pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx);
    if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){
      pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
    }
    ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult);
 
    nOutUnadjusted = pNew->nOut;
    pNew->rRun += nInMul + nIn;
    pNew->nOut += nInMul + nIn;
    whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize);
    rc = whereLoopInsert(pBuilder, pNew);
 
    if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
      pNew->nOut = saved_nOut;
    }else{
      pNew->nOut = nOutUnadjusted;
    }
 
    if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
     && pNew->u.btree.nEq<pProbe->nColumn
    ){
      whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn);
    }
    pNew->nOut = saved_nOut;
#ifdef SQLITE_ENABLE_STAT4
    pBuilder->nRecValid = nRecValid;
#endif
  }
  pNew->prereq = saved_prereq;
  pNew->u.btree.nEq = saved_nEq;
  pNew->u.btree.nBtm = saved_nBtm;
  pNew->u.btree.nTop = saved_nTop;
  pNew->nSkip = saved_nSkip;
  pNew->wsFlags = saved_wsFlags;
  pNew->nOut = saved_nOut;
  pNew->nLTerm = saved_nLTerm;
 
  /* Consider using a skip-scan if there are no WHERE clause constraints
  ** available for the left-most terms of the index, and if the average
  ** number of repeats in the left-most terms is at least 18.
  **
  ** The magic number 18 is selected on the basis that scanning 17 rows
  ** is almost always quicker than an index seek (even though if the index
  ** contains fewer than 2^17 rows we assume otherwise in other parts of
  ** the code). And, even if it is not, it should not be too much slower.
  ** On the other hand, the extra seeks could end up being significantly
  ** more expensive.  */
  assert( 42==sqlite3LogEst(18) );
  if( saved_nEq==saved_nSkip
   && saved_nEq+1<pProbe->nKeyCol
   && saved_nEq==pNew->nLTerm
   && pProbe->noSkipScan==0
   && pProbe->hasStat1!=0
   && OptimizationEnabled(db, SQLITE_SkipScan)
   && pProbe->aiRowLogEst[saved_nEq+1]>=42  /* TUNING: Minimum for skip-scan */
   && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
  ){
    LogEst nIter;
    pNew->u.btree.nEq++;
    pNew->nSkip++;
    pNew->aLTerm[pNew->nLTerm++] = 0;
    pNew->wsFlags |= WHERE_SKIPSCAN;
    nIter = pProbe->aiRowLogEst[saved_nEq] - pProbe->aiRowLogEst[saved_nEq+1];
    pNew->nOut -= nIter;
    /* TUNING:  Because uncertainties in the estimates for skip-scan queries,
    ** add a 1.375 fudge factor to make skip-scan slightly less likely. */
    nIter += 5;
    whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nIter + nInMul);
    pNew->nOut = saved_nOut;
    pNew->u.btree.nEq = saved_nEq;
    pNew->nSkip = saved_nSkip;
    pNew->wsFlags = saved_wsFlags;

References WhereClause::a, Index::aiColumn, Index::aiRowLogEst, WhereLoop::aLTerm, ALWAYS, ApplyCostMultiplier, WhereLoopBuilder::bldFlags1, WhereLoopBuilder::bldFlags2, WhereLoop::btree, Index::bUnordered, Parse::db, WhereTerm::eOperator, EP_FromJoin, EP_xIsSelect, estLog(), ExprHasProperty, Index::hasStat1, indexColumnNotNull(), IsUniqueIndex, JT_LEFT, sqlite3::mallocFailed, WhereLoop::maskSelf, WhereLoop::nBtm, Index::nColumn, WhereLoop::nEq, ExprList::nExpr, Index::nKeyCol, WhereLoop::nLTerm, Index::noSkipScan, WhereLoop::nOut, WhereLoop::nSkip, WhereClause::nTerm, WhereLoop::nTop, Index::onError, OptimizationEnabled, WhereTerm::pExpr, Expr::pList, WhereLoopBuilder::pNew, WhereInfo::pParse, WhereLoop::prereq, WhereTerm::prereqRight, Expr::pRight, Index::pTable, WhereTerm::pWC, WhereLoopBuilder::pWC, WhereLoopBuilder::pWInfo, WhereLoop::rRun, WhereLoop::rSetup, sqlite3LogEst(), sqlite3LogEstAdd(), SQLITE_BLDF1_INDEXED, SQLITE_BLDF1_UNIQUE, SQLITE_BLDF2_2NDPASS, SQLITE_NOMEM_BKPT, SQLITE_NOTFOUND, SQLITE_OK, SQLITE_SkipScan, SQLITE_Stat4, Index::szIdxRow, TERM_HEURTRUTH, TERM_HIGHTRUTH, TERM_LIKEOPT, TERM_VNULL, testcase, WhereTerm::truthProb, WhereLoop::u, Index::uniqNotNull, WHERE_BTM_LIMIT, WHERE_COLUMN_EQ, WHERE_COLUMN_IN, WHERE_COLUMN_NULL, WHERE_COLUMN_RANGE, WHERE_IDX_ONLY, WHERE_IPK, WHERE_ONEROW, WHERE_SKIPSCAN, WHERE_TOP_LIMIT, WHERE_UNQ_WANTED, WHERE_VIRTUALTABLE, whereLoopAddBtreeIndex(), whereLoopInsert(), whereLoopOutputAdjust(), whereLoopResize(), whereRangeScanEst(), whereRangeVectorLen(), whereScanInit(), whereScanNext(), WHERETRACE, WO_EQ, WO_GE, WO_GT, WO_IN, WO_IS, WO_ISNULL, WO_LE, WO_LT, WhereLoop::wsFlags, WhereTerm::wtFlags, Expr::x, XN_ROWID, Table::zName, and Index::zName.

Referenced by whereLoopAddBtree(), and whereLoopAddBtreeIndex().

◆ whereLoopAddOr()

static int whereLoopAddOr	(	WhereLoopBuilder *	pBuilder,
		Bitmask	mPrereq,
		Bitmask	mUnusable )

static

Definition at line 149083 of file sqlite3.c.

 {
  WhereInfo *pWInfo = pBuilder->pWInfo;
  WhereClause *pWC;
  WhereLoop *pNew;
  WhereTerm *pTerm, *pWCEnd;
  int rc = SQLITE_OK;
  int iCur;
  WhereClause tempWC;
  WhereLoopBuilder sSubBuild;
  WhereOrSet sSum, sCur;
  struct SrcList_item *pItem;
 
  pWC = pBuilder->pWC;
  pWCEnd = pWC->a + pWC->nTerm;
  pNew = pBuilder->pNew;
  memset(&sSum, 0, sizeof(sSum));
  pItem = pWInfo->pTabList->a + pNew->iTab;
  iCur = pItem->iCursor;
 
  for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
    if( (pTerm->eOperator & WO_OR)!=0
     && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
    ){
      WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
      WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm];
      WhereTerm *pOrTerm;
      int once = 1;
      int i, j;
 
      sSubBuild = *pBuilder;
      sSubBuild.pOrderBy = 0;
      sSubBuild.pOrSet = &sCur;
 
      WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm));
      for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){
        if( (pOrTerm->eOperator & WO_AND)!=0 ){
          sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc;
        }else if( pOrTerm->leftCursor==iCur ){
          tempWC.pWInfo = pWC->pWInfo;
          tempWC.pOuter = pWC;
          tempWC.op = TK_AND;
          tempWC.nTerm = 1;
          tempWC.a = pOrTerm;
          sSubBuild.pWC = &tempWC;
        }else{
          continue;
        }
        sCur.n = 0;
#ifdef WHERETRACE_ENABLED
        WHERETRACE(0x200, ("OR-term %d of %p has %d subterms:\n",
                   (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm));
        if( sqlite3WhereTrace & 0x400 ){
          sqlite3WhereClausePrint(sSubBuild.pWC);
        }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
        if( IsVirtual(pItem->pTab) ){
          rc = whereLoopAddVirtual(&sSubBuild, mPrereq, mUnusable);
        }else
#endif
        {
          rc = whereLoopAddBtree(&sSubBuild, mPrereq);
        }
        if( rc==SQLITE_OK ){
          rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable);
        }
        assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0 );
        testcase( rc==SQLITE_DONE );
        if( sCur.n==0 ){
          sSum.n = 0;
          break;
        }else if( once ){
          whereOrMove(&sSum, &sCur);
          once = 0;
        }else{
          WhereOrSet sPrev;
          whereOrMove(&sPrev, &sSum);
          sSum.n = 0;
          for(i=0; i<sPrev.n; i++){
            for(j=0; j<sCur.n; j++){
              whereOrInsert(&sSum, sPrev.a[i].prereq | sCur.a[j].prereq,
                            sqlite3LogEstAdd(sPrev.a[i].rRun, sCur.a[j].rRun),
                            sqlite3LogEstAdd(sPrev.a[i].nOut, sCur.a[j].nOut));
            }
          }
        }
      }
      pNew->nLTerm = 1;
      pNew->aLTerm[0] = pTerm;
      pNew->wsFlags = WHERE_MULTI_OR;
      pNew->rSetup = 0;
      pNew->iSortIdx = 0;
      memset(&pNew->u, 0, sizeof(pNew->u));
      for(i=0; rc==SQLITE_OK && i<sSum.n; i++){
        /* TUNING: Currently sSum.a[i].rRun is set to the sum of the costs
        ** of all sub-scans required by the OR-scan. However, due to rounding
        ** errors, it may be that the cost of the OR-scan is equal to its
        ** most expensive sub-scan. Add the smallest possible penalty
        ** (equivalent to multiplying the cost by 1.07) to ensure that
        ** this does not happen. Otherwise, for WHERE clauses such as the
        ** following where there is an index on "y":
        **
        **     WHERE likelihood(x=?, 0.99) OR y=?
        **
        ** the planner may elect to "OR" together a full-table scan and an
        ** index lookup. And other similarly odd results.  */
        pNew->rRun = sSum.a[i].rRun + 1;
        pNew->nOut = sSum.a[i].nOut;
        pNew->prereq = sSum.a[i].prereq;
        rc = whereLoopInsert(pBuilder, pNew);

References SrcList::a, WhereOrSet::a, WhereClause::a, WhereLoop::aLTerm, WhereTerm::eOperator, WhereOrInfo::indexable, WhereLoop::iSortIdx, IsVirtual, WhereLoop::iTab, WhereTerm::leftCursor, WhereLoop::maskSelf, WhereOrSet::n, WhereLoop::nLTerm, WhereLoop::nOut, WhereOrCost::nOut, WhereClause::nTerm, WhereClause::op, WhereTerm::pAndInfo, WhereLoopBuilder::pNew, WhereLoopBuilder::pOrderBy, WhereTerm::pOrInfo, WhereLoopBuilder::pOrSet, WhereClause::pOuter, WhereLoop::prereq, WhereOrCost::prereq, WhereInfo::pTabList, WhereLoopBuilder::pWC, WhereClause::pWInfo, WhereLoopBuilder::pWInfo, WhereLoop::rRun, WhereOrCost::rRun, WhereLoop::rSetup, sqlite3LogEstAdd(), SQLITE_DONE, SQLITE_OK, testcase, TK_AND, WhereLoop::u, WhereTerm::u, WhereOrInfo::wc, WhereAndInfo::wc, WHERE_MULTI_OR, whereLoopAddBtree(), whereLoopAddOr(), whereLoopAddVirtual(), whereLoopInsert(), whereOrInsert(), whereOrMove(), WHERETRACE, WO_AND, WO_OR, and WhereLoop::wsFlags.

Referenced by whereLoopAddOr().

◆ whereLoopAddVirtual()

static int whereLoopAddVirtual	(	WhereLoopBuilder *	pBuilder,
		Bitmask	mPrereq,
		Bitmask	mUnusable )

static

Definition at line 148960 of file sqlite3.c.

 {
  int rc = SQLITE_OK;          /* Return code */
  WhereInfo *pWInfo;           /* WHERE analysis context */
  Parse *pParse;               /* The parsing context */
  WhereClause *pWC;            /* The WHERE clause */
  struct SrcList_item *pSrc;   /* The FROM clause term to search */
  sqlite3_index_info *p;       /* Object to pass to xBestIndex() */
  int nConstraint;             /* Number of constraints in p */
  int bIn;                     /* True if plan uses IN(...) operator */
  WhereLoop *pNew;
  Bitmask mBest;               /* Tables used by best possible plan */
  u16 mNoOmit;
 
  assert( (mPrereq & mUnusable)==0 );
  pWInfo = pBuilder->pWInfo;
  pParse = pWInfo->pParse;
  pWC = pBuilder->pWC;
  pNew = pBuilder->pNew;
  pSrc = &pWInfo->pTabList->a[pNew->iTab];
  assert( IsVirtual(pSrc->pTab) );
  p = allocateIndexInfo(pParse, pWC, mUnusable, pSrc, pBuilder->pOrderBy,
      &mNoOmit);
  if( p==0 ) return SQLITE_NOMEM_BKPT;
  pNew->rSetup = 0;
  pNew->wsFlags = WHERE_VIRTUALTABLE;
  pNew->nLTerm = 0;
  pNew->u.vtab.needFree = 0;
  nConstraint = p->nConstraint;
  if( whereLoopResize(pParse->db, pNew, nConstraint) ){
    sqlite3DbFree(pParse->db, p);
    return SQLITE_NOMEM_BKPT;
  }
 
  /* First call xBestIndex() with all constraints usable. */
  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
  WHERETRACE(0x40, ("  VirtualOne: all usable\n"));
  rc = whereLoopAddVirtualOne(pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn);
 
  /* If the call to xBestIndex() with all terms enabled produced a plan
  ** that does not require any source tables (IOW: a plan with mBest==0)
  ** and does not use an IN(...) operator, then there is no point in making
  ** any further calls to xBestIndex() since they will all return the same
  ** result (if the xBestIndex() implementation is sane). */
  if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
    int seenZero = 0;             /* True if a plan with no prereqs seen */
    int seenZeroNoIN = 0;         /* Plan with no prereqs and no IN(...) seen */
    Bitmask mPrev = 0;
    Bitmask mBestNoIn = 0;
 
    /* If the plan produced by the earlier call uses an IN(...) term, call
    ** xBestIndex again, this time with IN(...) terms disabled. */
    if( bIn ){
      WHERETRACE(0x40, ("  VirtualOne: all usable w/o IN\n"));
      rc = whereLoopAddVirtualOne(
          pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn);
      assert( bIn==0 );
      mBestNoIn = pNew->prereq & ~mPrereq;
      if( mBestNoIn==0 ){
        seenZero = 1;
        seenZeroNoIN = 1;
      }
    }
 
    /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq)
    ** in the set of terms that apply to the current virtual table.  */
    while( rc==SQLITE_OK ){
      int i;
      Bitmask mNext = ALLBITS;
      assert( mNext>0 );
      for(i=0; i<nConstraint; i++){
        Bitmask mThis = (
            pWC->a[p->aConstraint[i].iTermOffset].prereqRight & ~mPrereq
        );
        if( mThis>mPrev && mThis<mNext ) mNext = mThis;
      }
      mPrev = mNext;
      if( mNext==ALLBITS ) break;
      if( mNext==mBest || mNext==mBestNoIn ) continue;
      WHERETRACE(0x40, ("  VirtualOne: mPrev=%04llx mNext=%04llx\n",
                       (sqlite3_uint64)mPrev, (sqlite3_uint64)mNext));
      rc = whereLoopAddVirtualOne(
          pBuilder, mPrereq, mNext|mPrereq, 0, p, mNoOmit, &bIn);
      if( pNew->prereq==mPrereq ){
        seenZero = 1;
        if( bIn==0 ) seenZeroNoIN = 1;
      }
    }
 
    /* If the calls to xBestIndex() in the above loop did not find a plan
    ** that requires no source tables at all (i.e. one guaranteed to be
    ** usable), make a call here with all source tables disabled */
    if( rc==SQLITE_OK && seenZero==0 ){
      WHERETRACE(0x40, ("  VirtualOne: all disabled\n"));
      rc = whereLoopAddVirtualOne(
          pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn);
      if( bIn==0 ) seenZeroNoIN = 1;
    }
 
    /* If the calls to xBestIndex() have so far failed to find a plan
    ** that requires no source tables at all and does not use an IN(...)
    ** operator, make a final call to obtain one here.  */
    if( rc==SQLITE_OK && seenZeroNoIN==0 ){
      WHERETRACE(0x40, ("  VirtualOne: all disabled and w/o IN\n"));
      rc = whereLoopAddVirtualOne(
          pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn);
    }
  }

References SrcList::a, WhereClause::a, sqlite3_index_info::aConstraint, ALLBITS, allocateIndexInfo(), Parse::db, sqlite3_index_info::idxStr, IsVirtual, WhereLoop::iTab, sqlite3_index_info::sqlite3_index_constraint::iTermOffset, sqlite3_index_info::nConstraint, WhereLoop::needFree, sqlite3_index_info::needToFreeIdxStr, WhereLoop::nLTerm, WhereLoopBuilder::pNew, WhereLoopBuilder::pOrderBy, WhereInfo::pParse, WhereLoop::prereq, WhereTerm::prereqRight, WhereInfo::pTabList, WhereLoopBuilder::pWC, WhereLoopBuilder::pWInfo, WhereLoop::rSetup, sqlite3_free(), sqlite3DbFree(), sqlite3DbFreeNN(), SQLITE_NOMEM_BKPT, SQLITE_OK, WhereLoop::u, WhereLoop::vtab, WHERE_VIRTUALTABLE, whereLoopAddVirtualOne(), whereLoopResize(), WHERETRACE, WO_IN, and WhereLoop::wsFlags.

Referenced by whereLoopAddOr().

◆ whereLoopAddVirtualOne()

static int whereLoopAddVirtualOne	(	WhereLoopBuilder *	pBuilder,
		Bitmask	mPrereq,
		Bitmask	mUsable,
		u16	mExclude,
		sqlite3_index_info *	pIdxInfo,
		u16	mNoOmit,
		int *	pbIn )

static

Definition at line 148760 of file sqlite3.c.

 {
  WhereClause *pWC = pBuilder->pWC;
  struct sqlite3_index_constraint *pIdxCons;
  struct sqlite3_index_constraint_usage *pUsage = pIdxInfo->aConstraintUsage;
  int i;
  int mxTerm;
  int rc = SQLITE_OK;
  WhereLoop *pNew = pBuilder->pNew;
  Parse *pParse = pBuilder->pWInfo->pParse;
  struct SrcList_item *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
  int nConstraint = pIdxInfo->nConstraint;
 
  assert( (mUsable & mPrereq)==mPrereq );
  *pbIn = 0;
  pNew->prereq = mPrereq;
 
  /* Set the usable flag on the subset of constraints identified by
  ** arguments mUsable and mExclude. */
  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
  for(i=0; i<nConstraint; i++, pIdxCons++){
    WhereTerm *pTerm = &pWC->a[pIdxCons->iTermOffset];
    pIdxCons->usable = 0;
    if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight
     && (pTerm->eOperator & mExclude)==0
    ){
      pIdxCons->usable = 1;
    }
  }
 
  /* Initialize the output fields of the sqlite3_index_info structure */
  memset(pUsage, 0, sizeof(pUsage[0])*nConstraint);
  assert( pIdxInfo->needToFreeIdxStr==0 );
  pIdxInfo->idxStr = 0;
  pIdxInfo->idxNum = 0;
  pIdxInfo->orderByConsumed = 0;
  pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
  pIdxInfo->estimatedRows = 25;
  pIdxInfo->idxFlags = 0;
  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
 
  /* Invoke the virtual table xBestIndex() method */
  rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
  if( rc ){
    if( rc==SQLITE_CONSTRAINT ){
      /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means
      ** that the particular combination of parameters provided is unusable.
      ** Make no entries in the loop table.
      */
      WHERETRACE(0xffff, ("  ^^^^--- non-viable plan rejected!\n"));
      return SQLITE_OK;
    }
    return rc;
  }
 
  mxTerm = -1;
  assert( pNew->nLSlot>=nConstraint );
  for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0;
  pNew->u.vtab.omitMask = 0;
  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
  for(i=0; i<nConstraint; i++, pIdxCons++){
    int iTerm;
    if( (iTerm = pUsage[i].argvIndex - 1)>=0 ){
      WhereTerm *pTerm;
      int j = pIdxCons->iTermOffset;
      if( iTerm>=nConstraint
       || j<0
       || j>=pWC->nTerm
       || pNew->aLTerm[iTerm]!=0
       || pIdxCons->usable==0
      ){
        sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
        testcase( pIdxInfo->needToFreeIdxStr );
        return SQLITE_ERROR;
      }
      testcase( iTerm==nConstraint-1 );
      testcase( j==0 );
      testcase( j==pWC->nTerm-1 );
      pTerm = &pWC->a[j];
      pNew->prereq |= pTerm->prereqRight;
      assert( iTerm<pNew->nLSlot );
      pNew->aLTerm[iTerm] = pTerm;
      if( iTerm>mxTerm ) mxTerm = iTerm;
      testcase( iTerm==15 );
      testcase( iTerm==16 );
      if( pUsage[i].omit ){
        if( i<16 && ((1<<i)&mNoOmit)==0 ){
          testcase( i!=iTerm );
          pNew->u.vtab.omitMask |= 1<<iTerm;
        }else{
          testcase( i!=iTerm );
        }
      }
      if( (pTerm->eOperator & WO_IN)!=0 ){
        /* A virtual table that is constrained by an IN clause may not
        ** consume the ORDER BY clause because (1) the order of IN terms
        ** is not necessarily related to the order of output terms and
        ** (2) Multiple outputs from a single IN value will not merge
        ** together.  */
        pIdxInfo->orderByConsumed = 0;
        pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE;
        *pbIn = 1; assert( (mExclude & WO_IN)==0 );
      }
    }
  }
 
  pNew->nLTerm = mxTerm+1;
  for(i=0; i<=mxTerm; i++){
    if( pNew->aLTerm[i]==0 ){
      /* The non-zero argvIdx values must be contiguous.  Raise an
      ** error if they are not */
      sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
      testcase( pIdxInfo->needToFreeIdxStr );
      return SQLITE_ERROR;
    }
  }
  assert( pNew->nLTerm<=pNew->nLSlot );
  pNew->u.vtab.idxNum = pIdxInfo->idxNum;
  pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
  pIdxInfo->needToFreeIdxStr = 0;
  pNew->u.vtab.idxStr = pIdxInfo->idxStr;
  pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
      pIdxInfo->nOrderBy : 0);
  pNew->rSetup = 0;
  pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
  pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
 
  /* Set the WHERE_ONEROW flag if the xBestIndex() method indicated
  ** that the scan will visit at most one row. Clear it otherwise. */
  if( pIdxInfo->idxFlags & SQLITE_INDEX_SCAN_UNIQUE ){
    pNew->wsFlags |= WHERE_ONEROW;
  }else{
    pNew->wsFlags &= ~WHERE_ONEROW;
  }
  rc = whereLoopInsert(pBuilder, pNew);
  if( pNew->u.vtab.needFree ){
    sqlite3_free(pNew->u.vtab.idxStr);
    pNew->u.vtab.needFree = 0;
  }

Referenced by whereLoopAddVirtual().

◆ whereLoopAdjustCost()

static void whereLoopAdjustCost	(	const WhereLoop *	p,
		WhereLoop *	pTemplate )

static

Definition at line 147617 of file sqlite3.c.

                                                                         {
  if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return;
  for(; p; p=p->pNextLoop){
    if( p->iTab!=pTemplate->iTab ) continue;
    if( (p->wsFlags & WHERE_INDEXED)==0 ) continue;
    if( whereLoopCheaperProperSubset(p, pTemplate) ){
      /* Adjust pTemplate cost downward so that it is cheaper than its
      ** subset p. */
      WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",
                       pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1));
      pTemplate->rRun = p->rRun;
      pTemplate->nOut = p->nOut - 1;
    }else if( whereLoopCheaperProperSubset(pTemplate, p) ){
      /* Adjust pTemplate cost upward so that it is costlier than p since
      ** pTemplate is a proper subset of p */
      WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",

References WhereLoop::iTab, WhereLoop::nOut, WhereLoop::pNextLoop, WhereLoop::rRun, WHERE_INDEXED, whereLoopCheaperProperSubset(), WHERETRACE, and WhereLoop::wsFlags.

Referenced by whereLoopInsert().

◆ whereLoopCheaperProperSubset()

static int whereLoopCheaperProperSubset	(	const WhereLoop *	pX,
		const WhereLoop *	pY )

static

Definition at line 147576 of file sqlite3.c.

 {
  int i, j;
  if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
    return 0; /* X is not a subset of Y */
  }
  if( pY->nSkip > pX->nSkip ) return 0;
  if( pX->rRun >= pY->rRun ){
    if( pX->rRun > pY->rRun ) return 0;    /* X costs more than Y */
    if( pX->nOut > pY->nOut ) return 0;    /* X costs more than Y */
  }
  for(i=pX->nLTerm-1; i>=0; i--){
    if( pX->aLTerm[i]==0 ) continue;
    for(j=pY->nLTerm-1; j>=0; j--){
      if( pY->aLTerm[j]==pX->aLTerm[i] ) break;
    }
    if( j<0 ) return 0;  /* X not a subset of Y since term X[i] not used by Y */
  }

References WhereLoop::aLTerm, WhereLoop::nLTerm, WhereLoop::nOut, WhereLoop::nSkip, WhereLoop::rRun, WHERE_IDX_ONLY, and WhereLoop::wsFlags.

Referenced by whereLoopAdjustCost().

◆ whereLoopClear()

static void whereLoopClear	(	sqlite3 *	db,
		WhereLoop *	p )

static

Definition at line 147487 of file sqlite3.c.

◆ whereLoopClearUnion()

static void whereLoopClearUnion	(	sqlite3 *	db,
		WhereLoop *	p )

static

Definition at line 147470 of file sqlite3.c.

                                                          {
  if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){
    if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
      sqlite3_free(p->u.vtab.idxStr);
      p->u.vtab.needFree = 0;
      p->u.vtab.idxStr = 0;
    }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){

◆ whereLoopDelete()

static void whereLoopDelete	(	sqlite3 *	db,
		WhereLoop *	p )

static

Definition at line 147531 of file sqlite3.c.

Referenced by sqlite3WhereBegin(), and whereLoopInsert().

◆ whereLoopFindLesser()

static WhereLoop ** whereLoopFindLesser	(	WhereLoop **	ppPrev,
		const WhereLoop *	pTemplate )

static

Definition at line 147654 of file sqlite3.c.

 {
  WhereLoop *p;
  for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){
    if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){
      /* If either the iTab or iSortIdx values for two WhereLoop are different
      ** then those WhereLoops need to be considered separately.  Neither is
      ** a candidate to replace the other. */
      continue;
    }
    /* In the current implementation, the rSetup value is either zero
    ** or the cost of building an automatic index (NlogN) and the NlogN
    ** is the same for compatible WhereLoops. */
    assert( p->rSetup==0 || pTemplate->rSetup==0
                 || p->rSetup==pTemplate->rSetup );
 
    /* whereLoopAddBtree() always generates and inserts the automatic index
    ** case first.  Hence compatible candidate WhereLoops never have a larger
    ** rSetup. Call this SETUP-INVARIANT */
    assert( p->rSetup>=pTemplate->rSetup );
 
    /* Any loop using an appliation-defined index (or PRIMARY KEY or
    ** UNIQUE constraint) with one or more == constraints is better
    ** than an automatic index. Unless it is a skip-scan. */
    if( (p->wsFlags & WHERE_AUTO_INDEX)!=0
     && (pTemplate->nSkip)==0
     && (pTemplate->wsFlags & WHERE_INDEXED)!=0
     && (pTemplate->wsFlags & WHERE_COLUMN_EQ)!=0
     && (p->prereq & pTemplate->prereq)==pTemplate->prereq
    ){
      break;
    }
 
    /* If existing WhereLoop p is better than pTemplate, pTemplate can be
    ** discarded.  WhereLoop p is better if:
    **   (1)  p has no more dependencies than pTemplate, and
    **   (2)  p has an equal or lower cost than pTemplate
    */
    if( (p->prereq & pTemplate->prereq)==p->prereq    /* (1)  */
     && p->rSetup<=pTemplate->rSetup                  /* (2a) */
     && p->rRun<=pTemplate->rRun                      /* (2b) */
     && p->nOut<=pTemplate->nOut                      /* (2c) */
    ){
      return 0;  /* Discard pTemplate */
    }
 
    /* If pTemplate is always better than p, then cause p to be overwritten
    ** with pTemplate.  pTemplate is better than p if:
    **   (1)  pTemplate has no more dependences than p, and
    **   (2)  pTemplate has an equal or lower cost than p.
    */
    if( (p->prereq & pTemplate->prereq)==pTemplate->prereq   /* (1)  */
     && p->rRun>=pTemplate->rRun                             /* (2a) */
     && p->nOut>=pTemplate->nOut                             /* (2b) */
    ){

References WhereLoop::iSortIdx, WhereLoop::iTab, WhereLoop::nOut, WhereLoop::nSkip, WhereLoop::pNextLoop, WhereLoop::prereq, WhereLoop::rRun, WhereLoop::rSetup, WHERE_AUTO_INDEX, WHERE_COLUMN_EQ, WHERE_INDEXED, and WhereLoop::wsFlags.

Referenced by whereLoopInsert().

◆ whereLoopInit()

static void whereLoopInit ( WhereLoop * p )

static

Definition at line 147460 of file sqlite3.c.

References WhereLoop::aLTerm, WhereLoop::aLTermSpace, ArraySize, WhereLoop::nLSlot, and WhereLoop::nLTerm.

Referenced by sqlite3WhereBegin(), and whereLoopInsert().

◆ whereLoopInsert()

static int whereLoopInsert	(	WhereLoopBuilder *	pBuilder,
		WhereLoop *	pTemplate )

static

Definition at line 147742 of file sqlite3.c.

                                                                            {
  WhereLoop **ppPrev, *p;
  WhereInfo *pWInfo = pBuilder->pWInfo;
  sqlite3 *db = pWInfo->pParse->db;
  int rc;
 
  /* Stop the search once we hit the query planner search limit */
  if( pBuilder->iPlanLimit==0 ){
    WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n"));
    if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0;
    return SQLITE_DONE;
  }
  pBuilder->iPlanLimit--;
 
  whereLoopAdjustCost(pWInfo->pLoops, pTemplate);
 
  /* If pBuilder->pOrSet is defined, then only keep track of the costs
  ** and prereqs.
  */
  if( pBuilder->pOrSet!=0 ){
    if( pTemplate->nLTerm ){
#if WHERETRACE_ENABLED
      u16 n = pBuilder->pOrSet->n;
      int x =
#endif
      whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun,
                                    pTemplate->nOut);
#if WHERETRACE_ENABLED /* 0x8 */
      if( sqlite3WhereTrace & 0x8 ){
        sqlite3DebugPrintf(x?"   or-%d:  ":"   or-X:  ", n);
        sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
      }
#endif
    }
    return SQLITE_OK;
  }
 
  /* Look for an existing WhereLoop to replace with pTemplate
  */
  ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate);
 
  if( ppPrev==0 ){
    /* There already exists a WhereLoop on the list that is better
    ** than pTemplate, so just ignore pTemplate */
#if WHERETRACE_ENABLED /* 0x8 */
    if( sqlite3WhereTrace & 0x8 ){
      sqlite3DebugPrintf("   skip: ");
      sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
    }
#endif
    return SQLITE_OK;
  }else{
    p = *ppPrev;
  }
 
  /* If we reach this point it means that either p[] should be overwritten
  ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new
  ** WhereLoop and insert it.
  */
#if WHERETRACE_ENABLED /* 0x8 */
  if( sqlite3WhereTrace & 0x8 ){
    if( p!=0 ){
      sqlite3DebugPrintf("replace: ");
      sqlite3WhereLoopPrint(p, pBuilder->pWC);
      sqlite3DebugPrintf("   with: ");
    }else{
      sqlite3DebugPrintf("    add: ");
    }
    sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
  }
#endif
  if( p==0 ){
    /* Allocate a new WhereLoop to add to the end of the list */
    *ppPrev = p = sqlite3DbMallocRawNN(db, sizeof(WhereLoop));
    if( p==0 ) return SQLITE_NOMEM_BKPT;
    whereLoopInit(p);
    p->pNextLoop = 0;
  }else{
    /* We will be overwriting WhereLoop p[].  But before we do, first
    ** go through the rest of the list and delete any other entries besides
    ** p[] that are also supplated by pTemplate */
    WhereLoop **ppTail = &p->pNextLoop;
    WhereLoop *pToDel;
    while( *ppTail ){
      ppTail = whereLoopFindLesser(ppTail, pTemplate);
      if( ppTail==0 ) break;
      pToDel = *ppTail;
      if( pToDel==0 ) break;
      *ppTail = pToDel->pNextLoop;
#if WHERETRACE_ENABLED /* 0x8 */
      if( sqlite3WhereTrace & 0x8 ){
        sqlite3DebugPrintf(" delete: ");
        sqlite3WhereLoopPrint(pToDel, pBuilder->pWC);
      }
#endif
      whereLoopDelete(db, pToDel);
    }
  }
  rc = whereLoopXfer(db, p, pTemplate);
  if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
    Index *pIndex = p->u.btree.pIndex;

References WhereLoop::btree, Parse::db, Index::idxType, WhereLoopBuilder::iPlanLimit, WhereOrSet::n, WhereLoop::nLTerm, WhereLoop::nOut, WhereLoop::pIndex, WhereInfo::pLoops, WhereLoop::pNextLoop, WhereLoopBuilder::pOrSet, WhereInfo::pParse, WhereLoop::prereq, WhereLoopBuilder::pWC, WhereLoopBuilder::pWInfo, WhereLoop::rRun, sqlite3DbMallocRawNN(), SQLITE_DONE, SQLITE_IDXTYPE_IPK, SQLITE_NOMEM_BKPT, SQLITE_OK, WhereLoop::u, WHERE_VIRTUALTABLE, whereLoopAdjustCost(), whereLoopDelete(), whereLoopFindLesser(), whereLoopInit(), whereLoopXfer(), whereOrInsert(), WHERETRACE, and WhereLoop::wsFlags.

Referenced by whereLoopAddBtree(), whereLoopAddBtreeIndex(), whereLoopAddOr(), and whereLoopAddVirtualOne().

◆ whereLoopOutputAdjust()

static void whereLoopOutputAdjust	(	WhereClause *	pWC,
		WhereLoop *	pLoop,
		LogEst	nRow )

static

Definition at line 147879 of file sqlite3.c.

 {
  WhereTerm *pTerm, *pX;
  Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf);
  int i, j;
  LogEst iReduce = 0;    /* pLoop->nOut should not exceed nRow-iReduce */
 
  assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
  for(i=pWC->nTerm, pTerm=pWC->a; i>0; i--, pTerm++){
    assert( pTerm!=0 );
    if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) break;
    if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue;
    if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
    for(j=pLoop->nLTerm-1; j>=0; j--){
      pX = pLoop->aLTerm[j];
      if( pX==0 ) continue;
      if( pX==pTerm ) break;
      if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
    }
    if( j<0 ){
      if( pTerm->truthProb<=0 ){
        /* If a truth probability is specified using the likelihood() hints,
        ** then use the probability provided by the application. */
        pLoop->nOut += pTerm->truthProb;
      }else{
        /* In the absence of explicit truth probabilities, use heuristics to
        ** guess a reasonable truth probability. */
        pLoop->nOut--;
        if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0
         && (pTerm->wtFlags & TERM_HIGHTRUTH)==0  /* tag-20200224-1 */
        ){
          Expr *pRight = pTerm->pExpr->pRight;
          int k = 0;
          testcase( pTerm->pExpr->op==TK_IS );
          if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){
            k = 10;
          }else{
            k = 20;
          }
          if( iReduce<k ){
            pTerm->wtFlags |= TERM_HEURTRUTH;
            iReduce = k;
          }

References WhereClause::a, WhereLoop::aLTerm, WhereTerm::eOperator, WhereTerm::iParent, WhereLoop::maskSelf, WhereLoop::nLTerm, WhereLoop::nOut, WhereClause::nTerm, Expr::op, WhereTerm::pExpr, WhereLoop::prereq, WhereTerm::prereqAll, Expr::pRight, sqlite3ExprIsInteger(), TERM_HEURTRUTH, TERM_HIGHTRUTH, TERM_VIRTUAL, testcase, TK_IS, WhereTerm::truthProb, WHERE_AUTO_INDEX, WO_EQ, WO_IS, WhereLoop::wsFlags, and WhereTerm::wtFlags.

Referenced by whereLoopAddBtree(), and whereLoopAddBtreeIndex().

◆ whereLoopResize()

static int whereLoopResize	(	sqlite3 *	db,
		WhereLoop *	p,
		int	n )

static

Definition at line 147496 of file sqlite3.c.

                                                            {
  WhereTerm **paNew;
  if( p->nLSlot>=n ) return SQLITE_OK;
  n = (n+7)&~7;
  paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n);
  if( paNew==0 ) return SQLITE_NOMEM_BKPT;

Referenced by constructAutomaticIndex(), whereLoopAddBtreeIndex(), and whereLoopAddVirtual().

◆ whereLoopXfer()

static int whereLoopXfer	(	sqlite3 *	db,
		WhereLoop *	pTo,
		WhereLoop *	pFrom )

static

Definition at line 147512 of file sqlite3.c.

                                                                       {
  whereLoopClearUnion(db, pTo);
  if( whereLoopResize(db, pTo, pFrom->nLTerm) ){
    memset(&pTo->u, 0, sizeof(pTo->u));
    return SQLITE_NOMEM_BKPT;
  }
  memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
  memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
  if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){

Referenced by whereLoopInsert().

◆ whereNthSubterm()

static WhereTerm * whereNthSubterm	(	WhereTerm *	pTerm,
		int	N )

static

Definition at line 144462 of file sqlite3.c.

                                                          {
  if( pTerm->eOperator!=WO_AND ){
    return N==0 ? pTerm : 0;

References WhereClause::a, WhereTerm::eOperator, WhereTerm::pAndInfo, WhereTerm::u, WhereAndInfo::wc, and WO_AND.

Referenced by exprAnalyzeOrTerm().

◆ whereOrInfoDelete()

static void whereOrInfoDelete	(	sqlite3 *	db,
		WhereOrInfo *	p )

static

Definition at line 144018 of file sqlite3.c.

Referenced by sqlite3WhereClauseClear().

◆ whereOrInsert()

static int whereOrInsert	(	WhereOrSet *	pSet,
		Bitmask	prereq,
		LogEst	rRun,
		LogEst	nOut )

static

Definition at line 145782 of file sqlite3.c.

 {
  u16 i;
  WhereOrCost *p;
  for(i=pSet->n, p=pSet->a; i>0; i--, p++){
    if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){
      goto whereOrInsert_done;
    }
    if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){
      return 0;
    }
  }
  if( pSet->n<N_OR_COST ){
    p = &pSet->a[pSet->n++];
    p->nOut = nOut;
  }else{
    p = pSet->a;
    for(i=1; i<pSet->n; i++){
      if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i;
    }
    if( p->rRun<=rRun ) return 0;
  }

References WhereOrSet::a, WhereOrSet::n, N_OR_COST, WhereOrCost::nOut, WhereOrCost::prereq, and WhereOrCost::rRun.

Referenced by whereLoopAddOr(), and whereLoopInsert().

◆ whereOrMove()

static void whereOrMove	(	WhereOrSet *	pDest,
		WhereOrSet *	pSrc )

static

Definition at line 145770 of file sqlite3.c.

Referenced by whereLoopAddOr().

◆ wherePathSatisfiesOrderBy()

static i8 wherePathSatisfiesOrderBy	(	WhereInfo *	pWInfo,
		ExprList *	pOrderBy,
		WherePath *	pPath,
		u16	wctrlFlags,
		u16	nLoop,
		WhereLoop *	pLast,
		Bitmask *	pRevMask )

static

Definition at line 149285 of file sqlite3.c.

 {
  u8 revSet;            /* True if rev is known */
  u8 rev;               /* Composite sort order */
  u8 revIdx;            /* Index sort order */
  u8 isOrderDistinct;   /* All prior WhereLoops are order-distinct */
  u8 distinctColumns;   /* True if the loop has UNIQUE NOT NULL columns */
  u8 isMatch;           /* iColumn matches a term of the ORDER BY clause */
  u16 eqOpMask;         /* Allowed equality operators */
  u16 nKeyCol;          /* Number of key columns in pIndex */
  u16 nColumn;          /* Total number of ordered columns in the index */
  u16 nOrderBy;         /* Number terms in the ORDER BY clause */
  int iLoop;            /* Index of WhereLoop in pPath being processed */
  int i, j;             /* Loop counters */
  int iCur;             /* Cursor number for current WhereLoop */
  int iColumn;          /* A column number within table iCur */
  WhereLoop *pLoop = 0; /* Current WhereLoop being processed. */
  WhereTerm *pTerm;     /* A single term of the WHERE clause */
  Expr *pOBExpr;        /* An expression from the ORDER BY clause */
  CollSeq *pColl;       /* COLLATE function from an ORDER BY clause term */
  Index *pIndex;        /* The index associated with pLoop */
  sqlite3 *db = pWInfo->pParse->db;  /* Database connection */
  Bitmask obSat = 0;    /* Mask of ORDER BY terms satisfied so far */
  Bitmask obDone;       /* Mask of all ORDER BY terms */
  Bitmask orderDistinctMask;  /* Mask of all well-ordered loops */
  Bitmask ready;              /* Mask of inner loops */
 
  /*
  ** We say the WhereLoop is "one-row" if it generates no more than one
  ** row of output.  A WhereLoop is one-row if all of the following are true:
  **  (a) All index columns match with WHERE_COLUMN_EQ.
  **  (b) The index is unique
  ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row.
  ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags.
  **
  ** We say the WhereLoop is "order-distinct" if the set of columns from
  ** that WhereLoop that are in the ORDER BY clause are different for every
  ** row of the WhereLoop.  Every one-row WhereLoop is automatically
  ** order-distinct.   A WhereLoop that has no columns in the ORDER BY clause
  ** is not order-distinct. To be order-distinct is not quite the same as being
  ** UNIQUE since a UNIQUE column or index can have multiple rows that
  ** are NULL and NULL values are equivalent for the purpose of order-distinct.
  ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
  **
  ** The rowid for a table is always UNIQUE and NOT NULL so whenever the
  ** rowid appears in the ORDER BY clause, the corresponding WhereLoop is
  ** automatically order-distinct.
  */
 
  assert( pOrderBy!=0 );
  if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0;
 
  nOrderBy = pOrderBy->nExpr;
  testcase( nOrderBy==BMS-1 );
  if( nOrderBy>BMS-1 ) return 0;  /* Cannot optimize overly large ORDER BYs */
  isOrderDistinct = 1;
  obDone = MASKBIT(nOrderBy)-1;
  orderDistinctMask = 0;
  ready = 0;
  eqOpMask = WO_EQ | WO_IS | WO_ISNULL;
  if( wctrlFlags & (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MAX|WHERE_ORDERBY_MIN) ){
    eqOpMask |= WO_IN;
  }
  for(iLoop=0; isOrderDistinct && obSat<obDone && iLoop<=nLoop; iLoop++){
    if( iLoop>0 ) ready |= pLoop->maskSelf;
    if( iLoop<nLoop ){
      pLoop = pPath->aLoop[iLoop];
      if( wctrlFlags & WHERE_ORDERBY_LIMIT ) continue;
    }else{
      pLoop = pLast;
    }
    if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){
      if( pLoop->u.vtab.isOrdered && (wctrlFlags & WHERE_DISTINCTBY)==0 ){
        obSat = obDone;
      }
      break;
    }else if( wctrlFlags & WHERE_DISTINCTBY ){
      pLoop->u.btree.nDistinctCol = 0;
    }
    iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor;
 
    /* Mark off any ORDER BY term X that is a column in the table of
    ** the current loop for which there is term in the WHERE
    ** clause of the form X IS NULL or X=? that reference only outer
    ** loops.
    */
    for(i=0; i<nOrderBy; i++){
      if( MASKBIT(i) & obSat ) continue;
      pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
      if( pOBExpr->op!=TK_COLUMN ) continue;
      if( pOBExpr->iTable!=iCur ) continue;
      pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
                       ~ready, eqOpMask, 0);
      if( pTerm==0 ) continue;
      if( pTerm->eOperator==WO_IN ){
        /* IN terms are only valid for sorting in the ORDER BY LIMIT
        ** optimization, and then only if they are actually used
        ** by the query plan */
        assert( wctrlFlags &
               (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) );
        for(j=0; j<pLoop->nLTerm && pTerm!=pLoop->aLTerm[j]; j++){}
        if( j>=pLoop->nLTerm ) continue;
      }
      if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){
        Parse *pParse = pWInfo->pParse;
        CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
        CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
        assert( pColl1 );
        if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
          continue;
        }
        testcase( pTerm->pExpr->op==TK_IS );
      }
      obSat |= MASKBIT(i);
    }
 
    if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){
      if( pLoop->wsFlags & WHERE_IPK ){
        pIndex = 0;
        nKeyCol = 0;
        nColumn = 1;
      }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){
        return 0;
      }else{
        nKeyCol = pIndex->nKeyCol;
        nColumn = pIndex->nColumn;
        assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
        assert( pIndex->aiColumn[nColumn-1]==XN_ROWID
                          || !HasRowid(pIndex->pTable));
        isOrderDistinct = IsUniqueIndex(pIndex)
                          && (pLoop->wsFlags & WHERE_SKIPSCAN)==0;
      }
 
      /* Loop through all columns of the index and deal with the ones
      ** that are not constrained by == or IN.
      */
      rev = revSet = 0;
      distinctColumns = 0;
      for(j=0; j<nColumn; j++){
        u8 bOnce = 1; /* True to run the ORDER BY search loop */
 
        assert( j>=pLoop->u.btree.nEq
            || (pLoop->aLTerm[j]==0)==(j<pLoop->nSkip)
        );
        if( j<pLoop->u.btree.nEq && j>=pLoop->nSkip ){
          u16 eOp = pLoop->aLTerm[j]->eOperator;
 
          /* Skip over == and IS and ISNULL terms.  (Also skip IN terms when
          ** doing WHERE_ORDERBY_LIMIT processing).  Except, IS and ISNULL
          ** terms imply that the index is not UNIQUE NOT NULL in which case
          ** the loop need to be marked as not order-distinct because it can
          ** have repeated NULL rows.
          **
          ** If the current term is a column of an ((?,?) IN (SELECT...))
          ** expression for which the SELECT returns more than one column,
          ** check that it is the only column used by this loop. Otherwise,
          ** if it is one of two or more, none of the columns can be
          ** considered to match an ORDER BY term.
          */
          if( (eOp & eqOpMask)!=0 ){
            if( eOp & (WO_ISNULL|WO_IS) ){
              testcase( eOp & WO_ISNULL );
              testcase( eOp & WO_IS );
              testcase( isOrderDistinct );
              isOrderDistinct = 0;
            }
            continue;
          }else if( ALWAYS(eOp & WO_IN) ){
            /* ALWAYS() justification: eOp is an equality operator due to the
            ** j<pLoop->u.btree.nEq constraint above.  Any equality other
            ** than WO_IN is captured by the previous "if".  So this one
            ** always has to be WO_IN. */
            Expr *pX = pLoop->aLTerm[j]->pExpr;
            for(i=j+1; i<pLoop->u.btree.nEq; i++){
              if( pLoop->aLTerm[i]->pExpr==pX ){
                assert( (pLoop->aLTerm[i]->eOperator & WO_IN) );
                bOnce = 0;
                break;
              }
            }
          }
        }
 
        /* Get the column number in the table (iColumn) and sort order
        ** (revIdx) for the j-th column of the index.
        */
        if( pIndex ){
          iColumn = pIndex->aiColumn[j];
          revIdx = pIndex->aSortOrder[j] & KEYINFO_ORDER_DESC;
          if( iColumn==pIndex->pTable->iPKey ) iColumn = XN_ROWID;
        }else{
          iColumn = XN_ROWID;
          revIdx = 0;
        }
 
        /* An unconstrained column that might be NULL means that this
        ** WhereLoop is not well-ordered
        */
        if( isOrderDistinct
         && iColumn>=0
         && j>=pLoop->u.btree.nEq
         && pIndex->pTable->aCol[iColumn].notNull==0
        ){
          isOrderDistinct = 0;
        }
 
        /* Find the ORDER BY term that corresponds to the j-th column
        ** of the index and mark that ORDER BY term off
        */
        isMatch = 0;
        for(i=0; bOnce && i<nOrderBy; i++){
          if( MASKBIT(i) & obSat ) continue;
          pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
          testcase( wctrlFlags & WHERE_GROUPBY );
          testcase( wctrlFlags & WHERE_DISTINCTBY );
          if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0;
          if( iColumn>=XN_ROWID ){
            if( pOBExpr->op!=TK_COLUMN ) continue;
            if( pOBExpr->iTable!=iCur ) continue;
            if( pOBExpr->iColumn!=iColumn ) continue;
          }else{
            Expr *pIdxExpr = pIndex->aColExpr->a[j].pExpr;
            if( sqlite3ExprCompareSkip(pOBExpr, pIdxExpr, iCur) ){
              continue;
            }
          }
          if( iColumn!=XN_ROWID ){
            pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
            if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
          }
          if( wctrlFlags & WHERE_DISTINCTBY ){
            pLoop->u.btree.nDistinctCol = j+1;
          }
          isMatch = 1;
          break;
        }
        if( isMatch && (wctrlFlags & WHERE_GROUPBY)==0 ){
          /* Make sure the sort order is compatible in an ORDER BY clause.
          ** Sort order is irrelevant for a GROUP BY clause. */
          if( revSet ){
            if( (rev ^ revIdx)!=(pOrderBy->a[i].sortFlags&KEYINFO_ORDER_DESC) ){
              isMatch = 0;
            }
          }else{
            rev = revIdx ^ (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC);
            if( rev ) *pRevMask |= MASKBIT(iLoop);
            revSet = 1;
          }
        }
        if( isMatch && (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL) ){
          if( j==pLoop->u.btree.nEq ){
            pLoop->wsFlags |= WHERE_BIGNULL_SORT;
          }else{
            isMatch = 0;
          }
        }
        if( isMatch ){
          if( iColumn==XN_ROWID ){
            testcase( distinctColumns==0 );
            distinctColumns = 1;
          }
          obSat |= MASKBIT(i);
        }else{
          /* No match found */
          if( j==0 || j<nKeyCol ){
            testcase( isOrderDistinct!=0 );
            isOrderDistinct = 0;
          }
          break;
        }
      } /* end Loop over all index columns */
      if( distinctColumns ){
        testcase( isOrderDistinct==0 );
        isOrderDistinct = 1;
      }
    } /* end-if not one-row */
 
    /* Mark off any other ORDER BY terms that reference pLoop */
    if( isOrderDistinct ){
      orderDistinctMask |= pLoop->maskSelf;
      for(i=0; i<nOrderBy; i++){
        Expr *p;
        Bitmask mTerm;
        if( MASKBIT(i) & obSat ) continue;
        p = pOrderBy->a[i].pExpr;
        mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
        if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
        if( (mTerm&~orderDistinctMask)==0 ){
          obSat |= MASKBIT(i);
        }
      }
    }
  } /* End the loop over all WhereLoops from outer-most down to inner-most */
  if( obSat==obDone ) return (i8)nOrderBy;
  if( !isOrderDistinct ){
    for(i=nOrderBy-1; i>0; i--){
      Bitmask m = MASKBIT(i) - 1;

References ExprList::a, SrcList::a, Table::aCol, Index::aColExpr, Index::aiColumn, WherePath::aLoop, WhereLoop::aLTerm, ALWAYS, Index::aSortOrder, Index::azColl, BMS, WhereLoop::btree, Index::bUnordered, Parse::db, WhereTerm::eOperator, HasRowid, Expr::iColumn, SrcList::SrcList_item::iCursor, Table::iPKey, WhereLoop::isOrdered, IsUniqueIndex, WhereLoop::iTab, Expr::iTable, KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, MASKBIT, WhereLoop::maskSelf, Index::nColumn, WhereLoop::nDistinctCol, WhereLoop::nEq, ExprList::nExpr, Index::nKeyCol, WhereLoop::nLTerm, Column::notNull, WhereLoop::nSkip, Expr::op, OptimizationDisabled, ExprList::ExprList_item::pExpr, WhereTerm::pExpr, WhereLoop::pIndex, WhereInfo::pParse, Index::pTable, WhereInfo::pTabList, WhereInfo::sMaskSet, ExprList::ExprList_item::sortFlags, sqlite3ExprCompareCollSeq(), sqlite3ExprCompareSkip(), sqlite3ExprIsConstant(), sqlite3ExprNNCollSeq(), sqlite3ExprSkipCollateAndLikely(), sqlite3StrICmp(), sqlite3WhereExprUsage(), sqlite3WhereFindTerm(), SQLITE_OrderByIdxJoin, WhereInfo::sWC, testcase, TK_COLUMN, TK_IS, WhereLoop::u, WhereLoop::vtab, WHERE_BIGNULL_SORT, WHERE_DISTINCTBY, WHERE_GROUPBY, WHERE_IPK, WHERE_ONEROW, WHERE_ORDERBY_LIMIT, WHERE_ORDERBY_MAX, WHERE_ORDERBY_MIN, WHERE_SKIPSCAN, WHERE_VIRTUALTABLE, WO_EQ, WO_IN, WO_IS, WO_ISNULL, WhereLoop::wsFlags, XN_ROWID, and CollSeq::zName.

Referenced by wherePathSolver().

◆ wherePathSolver()

static int wherePathSolver	(	WhereInfo *	pWInfo,
		LogEst	nRowEst )

static

Definition at line 149688 of file sqlite3.c.

                                                             {
  int mxChoice;             /* Maximum number of simultaneous paths tracked */
  int nLoop;                /* Number of terms in the join */
  Parse *pParse;            /* Parsing context */
  sqlite3 *db;              /* The database connection */
  int iLoop;                /* Loop counter over the terms of the join */
  int ii, jj;               /* Loop counters */
  int mxI = 0;              /* Index of next entry to replace */
  int nOrderBy;             /* Number of ORDER BY clause terms */
  LogEst mxCost = 0;        /* Maximum cost of a set of paths */
  LogEst mxUnsorted = 0;    /* Maximum unsorted cost of a set of path */
  int nTo, nFrom;           /* Number of valid entries in aTo[] and aFrom[] */
  WherePath *aFrom;         /* All nFrom paths at the previous level */
  WherePath *aTo;           /* The nTo best paths at the current level */
  WherePath *pFrom;         /* An element of aFrom[] that we are working on */
  WherePath *pTo;           /* An element of aTo[] that we are working on */
  WhereLoop *pWLoop;        /* One of the WhereLoop objects */
  WhereLoop **pX;           /* Used to divy up the pSpace memory */
  LogEst *aSortCost = 0;    /* Sorting and partial sorting costs */
  char *pSpace;             /* Temporary memory used by this routine */
  int nSpace;               /* Bytes of space allocated at pSpace */
 
  pParse = pWInfo->pParse;
  db = pParse->db;
  nLoop = pWInfo->nLevel;
  /* TUNING: For simple queries, only the best path is tracked.
  ** For 2-way joins, the 5 best paths are followed.
  ** For joins of 3 or more tables, track the 10 best paths */
  mxChoice = (nLoop<=1) ? 1 : (nLoop==2 ? 5 : 10);
  assert( nLoop<=pWInfo->pTabList->nSrc );
  WHERETRACE(0x002, ("---- begin solver.  (nRowEst=%d)\n", nRowEst));
 
  /* If nRowEst is zero and there is an ORDER BY clause, ignore it. In this
  ** case the purpose of this call is to estimate the number of rows returned
  ** by the overall query. Once this estimate has been obtained, the caller
  ** will invoke this function a second time, passing the estimate as the
  ** nRowEst parameter.  */
  if( pWInfo->pOrderBy==0 || nRowEst==0 ){
    nOrderBy = 0;
  }else{
    nOrderBy = pWInfo->pOrderBy->nExpr;
  }
 
  /* Allocate and initialize space for aTo, aFrom and aSortCost[] */
  nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2;
  nSpace += sizeof(LogEst) * nOrderBy;
  pSpace = sqlite3DbMallocRawNN(db, nSpace);
  if( pSpace==0 ) return SQLITE_NOMEM_BKPT;
  aTo = (WherePath*)pSpace;
  aFrom = aTo+mxChoice;
  memset(aFrom, 0, sizeof(aFrom[0]));
  pX = (WhereLoop**)(aFrom+mxChoice);
  for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){
    pFrom->aLoop = pX;
  }
  if( nOrderBy ){
    /* If there is an ORDER BY clause and it is not being ignored, set up
    ** space for the aSortCost[] array. Each element of the aSortCost array
    ** is either zero - meaning it has not yet been initialized - or the
    ** cost of sorting nRowEst rows of data where the first X terms of
    ** the ORDER BY clause are already in order, where X is the array
    ** index.  */
    aSortCost = (LogEst*)pX;
    memset(aSortCost, 0, sizeof(LogEst) * nOrderBy);
  }
  assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] );
  assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX );
 
  /* Seed the search with a single WherePath containing zero WhereLoops.
  **
  ** TUNING: Do not let the number of iterations go above 28.  If the cost
  ** of computing an automatic index is not paid back within the first 28
  ** rows, then do not use the automatic index. */
  aFrom[0].nRow = MIN(pParse->nQueryLoop, 48);  assert( 48==sqlite3LogEst(28) );
  nFrom = 1;
  assert( aFrom[0].isOrdered==0 );
  if( nOrderBy ){
    /* If nLoop is zero, then there are no FROM terms in the query. Since
    ** in this case the query may return a maximum of one row, the results
    ** are already in the requested order. Set isOrdered to nOrderBy to
    ** indicate this. Or, if nLoop is greater than zero, set isOrdered to
    ** -1, indicating that the result set may or may not be ordered,
    ** depending on the loops added to the current plan.  */
    aFrom[0].isOrdered = nLoop>0 ? -1 : nOrderBy;
  }
 
  /* Compute successively longer WherePaths using the previous generation
  ** of WherePaths as the basis for the next.  Keep track of the mxChoice
  ** best paths at each generation */
  for(iLoop=0; iLoop<nLoop; iLoop++){
    nTo = 0;
    for(ii=0, pFrom=aFrom; ii<nFrom; ii++, pFrom++){
      for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
        LogEst nOut;                      /* Rows visited by (pFrom+pWLoop) */
        LogEst rCost;                     /* Cost of path (pFrom+pWLoop) */
        LogEst rUnsorted;                 /* Unsorted cost of (pFrom+pWLoop) */
        i8 isOrdered = pFrom->isOrdered;  /* isOrdered for (pFrom+pWLoop) */
        Bitmask maskNew;                  /* Mask of src visited by (..) */
        Bitmask revMask = 0;              /* Mask of rev-order loops for (..) */
 
        if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue;
        if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue;
        if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){
          /* Do not use an automatic index if the this loop is expected
          ** to run less than 1.25 times.  It is tempting to also exclude
          ** automatic index usage on an outer loop, but sometimes an automatic
          ** index is useful in the outer loop of a correlated subquery. */
          assert( 10==sqlite3LogEst(2) );
          continue;
        }
 
        /* At this point, pWLoop is a candidate to be the next loop.
        ** Compute its cost */
        rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
        rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted);
        nOut = pFrom->nRow + pWLoop->nOut;
        maskNew = pFrom->maskLoop | pWLoop->maskSelf;
        if( isOrdered<0 ){
          isOrdered = wherePathSatisfiesOrderBy(pWInfo,
                       pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags,
                       iLoop, pWLoop, &revMask);
        }else{
          revMask = pFrom->revLoop;
        }
        if( isOrdered>=0 && isOrdered<nOrderBy ){
          if( aSortCost[isOrdered]==0 ){
            aSortCost[isOrdered] = whereSortingCost(
                pWInfo, nRowEst, nOrderBy, isOrdered
            );
          }
          /* TUNING:  Add a small extra penalty (5) to sorting as an
          ** extra encouragment to the query planner to select a plan
          ** where the rows emerge in the correct order without any sorting
          ** required. */
          rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 5;
 
          WHERETRACE(0x002,
              ("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",
               aSortCost[isOrdered], (nOrderBy-isOrdered), nOrderBy,
               rUnsorted, rCost));
        }else{
          rCost = rUnsorted;
          rUnsorted -= 2;  /* TUNING:  Slight bias in favor of no-sort plans */
        }
 
        /* Check to see if pWLoop should be added to the set of
        ** mxChoice best-so-far paths.
        **
        ** First look for an existing path among best-so-far paths
        ** that covers the same set of loops and has the same isOrdered
        ** setting as the current path candidate.
        **
        ** The term "((pTo->isOrdered^isOrdered)&0x80)==0" is equivalent
        ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range
        ** of legal values for isOrdered, -1..64.
        */
        for(jj=0, pTo=aTo; jj<nTo; jj++, pTo++){
          if( pTo->maskLoop==maskNew
           && ((pTo->isOrdered^isOrdered)&0x80)==0
          ){
            testcase( jj==nTo-1 );
            break;
          }
        }
        if( jj>=nTo ){
          /* None of the existing best-so-far paths match the candidate. */
          if( nTo>=mxChoice
           && (rCost>mxCost || (rCost==mxCost && rUnsorted>=mxUnsorted))
          ){
            /* The current candidate is no better than any of the mxChoice
            ** paths currently in the best-so-far buffer.  So discard
            ** this candidate as not viable. */
#ifdef WHERETRACE_ENABLED /* 0x4 */
            if( sqlite3WhereTrace&0x4 ){
              sqlite3DebugPrintf("Skip   %s cost=%-3d,%3d,%3d order=%c\n",
                  wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
                  isOrdered>=0 ? isOrdered+'0' : '?');
            }
#endif
            continue;
          }
          /* If we reach this points it means that the new candidate path
          ** needs to be added to the set of best-so-far paths. */
          if( nTo<mxChoice ){
            /* Increase the size of the aTo set by one */
            jj = nTo++;
          }else{
            /* New path replaces the prior worst to keep count below mxChoice */
            jj = mxI;
          }
          pTo = &aTo[jj];
#ifdef WHERETRACE_ENABLED /* 0x4 */
          if( sqlite3WhereTrace&0x4 ){
            sqlite3DebugPrintf("New    %s cost=%-3d,%3d,%3d order=%c\n",
                wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
                isOrdered>=0 ? isOrdered+'0' : '?');
          }
#endif
        }else{
          /* Control reaches here if best-so-far path pTo=aTo[jj] covers the
          ** same set of loops and has the same isOrdered setting as the
          ** candidate path.  Check to see if the candidate should replace
          ** pTo or if the candidate should be skipped.
          **
          ** The conditional is an expanded vector comparison equivalent to:
          **   (pTo->rCost,pTo->nRow,pTo->rUnsorted) <= (rCost,nOut,rUnsorted)
          */
          if( pTo->rCost<rCost
           || (pTo->rCost==rCost
               && (pTo->nRow<nOut
                   || (pTo->nRow==nOut && pTo->rUnsorted<=rUnsorted)
                  )
              )
          ){
#ifdef WHERETRACE_ENABLED /* 0x4 */
            if( sqlite3WhereTrace&0x4 ){
              sqlite3DebugPrintf(
                  "Skip   %s cost=%-3d,%3d,%3d order=%c",
                  wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
                  isOrdered>=0 ? isOrdered+'0' : '?');
              sqlite3DebugPrintf("   vs %s cost=%-3d,%3d,%3d order=%c\n",
                  wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
                  pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
            }
#endif
            /* Discard the candidate path from further consideration */
            testcase( pTo->rCost==rCost );
            continue;
          }
          testcase( pTo->rCost==rCost+1 );
          /* Control reaches here if the candidate path is better than the
          ** pTo path.  Replace pTo with the candidate. */
#ifdef WHERETRACE_ENABLED /* 0x4 */
          if( sqlite3WhereTrace&0x4 ){
            sqlite3DebugPrintf(
                "Update %s cost=%-3d,%3d,%3d order=%c",
                wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
                isOrdered>=0 ? isOrdered+'0' : '?');
            sqlite3DebugPrintf("  was %s cost=%-3d,%3d,%3d order=%c\n",
                wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
                pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
          }
#endif
        }
        /* pWLoop is a winner.  Add it to the set of best so far */
        pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf;
        pTo->revLoop = revMask;
        pTo->nRow = nOut;
        pTo->rCost = rCost;
        pTo->rUnsorted = rUnsorted;
        pTo->isOrdered = isOrdered;
        memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
        pTo->aLoop[iLoop] = pWLoop;
        if( nTo>=mxChoice ){
          mxI = 0;
          mxCost = aTo[0].rCost;
          mxUnsorted = aTo[0].nRow;
          for(jj=1, pTo=&aTo[1]; jj<mxChoice; jj++, pTo++){
            if( pTo->rCost>mxCost
             || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted)
            ){
              mxCost = pTo->rCost;
              mxUnsorted = pTo->rUnsorted;
              mxI = jj;
            }
          }
        }
      }
    }
 
#ifdef WHERETRACE_ENABLED  /* >=2 */
    if( sqlite3WhereTrace & 0x02 ){
      sqlite3DebugPrintf("---- after round %d ----\n", iLoop);
      for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
        sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
           wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
           pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
        if( pTo->isOrdered>0 ){
          sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);
        }else{
          sqlite3DebugPrintf("\n");
        }
      }
    }
#endif
 
    /* Swap the roles of aFrom and aTo for the next generation */
    pFrom = aTo;
    aTo = aFrom;
    aFrom = pFrom;
    nFrom = nTo;
  }
 
  if( nFrom==0 ){
    sqlite3ErrorMsg(pParse, "no query solution");
    sqlite3DbFreeNN(db, pSpace);
    return SQLITE_ERROR;
  }
 
  /* Find the lowest cost path.  pFrom will be left pointing to that path */
  pFrom = aFrom;
  for(ii=1; ii<nFrom; ii++){
    if( pFrom->rCost>aFrom[ii].rCost ) pFrom = &aFrom[ii];
  }
  assert( pWInfo->nLevel==nLoop );
  /* Load the lowest cost path into pWInfo */
  for(iLoop=0; iLoop<nLoop; iLoop++){
    WhereLevel *pLevel = pWInfo->a + iLoop;
    pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop];
    pLevel->iFrom = pWLoop->iTab;
    pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor;
  }
  if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0
   && (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0
   && pWInfo->eDistinct==WHERE_DISTINCT_NOOP
   && nRowEst
  ){
    Bitmask notUsed;
    int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
                 WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], &notUsed);
    if( rc==pWInfo->pResultSet->nExpr ){
      pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
    }
  }
  pWInfo->bOrderedInnerLoop = 0;
  if( pWInfo->pOrderBy ){
    if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
      if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
        pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
      }
    }else{
      pWInfo->nOBSat = pFrom->isOrdered;
      pWInfo->revMask = pFrom->revLoop;
      if( pWInfo->nOBSat<=0 ){
        pWInfo->nOBSat = 0;
        if( nLoop>0 ){
          u32 wsFlags = pFrom->aLoop[nLoop-1]->wsFlags;
          if( (wsFlags & WHERE_ONEROW)==0
           && (wsFlags&(WHERE_IPK|WHERE_COLUMN_IN))!=(WHERE_IPK|WHERE_COLUMN_IN)
          ){
            Bitmask m = 0;
            int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, pFrom,
                      WHERE_ORDERBY_LIMIT, nLoop-1, pFrom->aLoop[nLoop-1], &m);
            testcase( wsFlags & WHERE_IPK );
            testcase( wsFlags & WHERE_COLUMN_IN );
            if( rc==pWInfo->pOrderBy->nExpr ){
              pWInfo->bOrderedInnerLoop = 1;
              pWInfo->revMask = m;
            }
          }
        }
      }else if( nLoop
            && pWInfo->nOBSat==1
            && (pWInfo->wctrlFlags & (WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX))!=0
            ){
        pWInfo->bOrderedInnerLoop = 1;
      }
    }
    if( (pWInfo->wctrlFlags & WHERE_SORTBYGROUP)
        && pWInfo->nOBSat==pWInfo->pOrderBy->nExpr && nLoop>0
    ){
      Bitmask revMask = 0;
      int nOrder = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy,
          pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask
      );
      assert( pWInfo->sorted==0 );
      if( nOrder==pWInfo->pOrderBy->nExpr ){
        pWInfo->sorted = 1;
        pWInfo->revMask = revMask;
      }
    }
  }
 
 

References SrcList::a, WhereInfo::a, WherePath::aLoop, WhereInfo::bOrderedInnerLoop, Parse::db, WhereInfo::eDistinct, SrcList::SrcList_item::iCursor, WhereLevel::iFrom, WherePath::isOrdered, WhereLoop::iTab, WhereLevel::iTabCur, WherePath::maskLoop, WhereLoop::maskSelf, MIN, ExprList::nExpr, WhereInfo::nLevel, WhereInfo::nOBSat, WhereLoop::nOut, Parse::nQueryLoop, WherePath::nRow, WhereInfo::nRowOut, WhereInfo::pLoops, WhereLoop::pNextLoop, WhereInfo::pOrderBy, WhereInfo::pParse, WhereLoop::prereq, WhereInfo::pResultSet, WhereInfo::pTabList, WhereLevel::pWLoop, WherePath::rCost, WherePath::revLoop, WhereInfo::revMask, WhereLoop::rRun, WhereLoop::rSetup, WherePath::rUnsorted, WhereInfo::sorted, sqlite3DbFreeNN(), sqlite3DbMallocRawNN(), sqlite3ErrorMsg(), sqlite3LogEst(), sqlite3LogEstAdd(), SQLITE_ERROR, SQLITE_NOMEM_BKPT, SQLITE_OK, testcase, WhereInfo::wctrlFlags, WHERE_AUTO_INDEX, WHERE_COLUMN_IN, WHERE_DISTINCT_NOOP, WHERE_DISTINCT_ORDERED, WHERE_DISTINCTBY, WHERE_IPK, WHERE_ONEROW, WHERE_ORDERBY_LIMIT, WHERE_ORDERBY_MAX, WHERE_ORDERBY_MIN, WHERE_SORTBYGROUP, WHERE_WANT_DISTINCT, wherePathSatisfiesOrderBy(), whereSortingCost(), WHERETRACE, and WhereLoop::wsFlags.

Referenced by sqlite3WhereBegin().

◆ whereRangeAdjust()

static LogEst whereRangeAdjust	(	WhereTerm *	pTerm,
		LogEst	nNew )

static

Definition at line 146893 of file sqlite3.c.

                                                             {
  LogEst nRet = nNew;
  if( pTerm ){
    if( pTerm->truthProb<=0 ){
      nRet += pTerm->truthProb;

References sqlite3LogEst(), TERM_VNULL, WhereTerm::truthProb, and WhereTerm::wtFlags.

Referenced by whereRangeScanEst().

◆ whereRangeScanEst()

static int whereRangeScanEst	(	Parse *	pParse,
		WhereLoopBuilder *	pBuilder,
		WhereTerm *	pLower,
		WhereTerm *	pUpper,
		WhereLoop *	pLoop )

static

Definition at line 147069 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
  int nOut = pLoop->nOut;
  LogEst nNew;
 
#ifdef SQLITE_ENABLE_STAT4
  Index *p = pLoop->u.btree.pIndex;
  int nEq = pLoop->u.btree.nEq;
 
  if( p->nSample>0 && ALWAYS(nEq<p->nSampleCol)
   && OptimizationEnabled(pParse->db, SQLITE_Stat4)
  ){
    if( nEq==pBuilder->nRecValid ){
      UnpackedRecord *pRec = pBuilder->pRec;
      tRowcnt a[2];
      int nBtm = pLoop->u.btree.nBtm;
      int nTop = pLoop->u.btree.nTop;
 
      /* Variable iLower will be set to the estimate of the number of rows in
      ** the index that are less than the lower bound of the range query. The
      ** lower bound being the concatenation of $P and $L, where $P is the
      ** key-prefix formed by the nEq values matched against the nEq left-most
      ** columns of the index, and $L is the value in pLower.
      **
      ** Or, if pLower is NULL or $L cannot be extracted from it (because it
      ** is not a simple variable or literal value), the lower bound of the
      ** range is $P. Due to a quirk in the way whereKeyStats() works, even
      ** if $L is available, whereKeyStats() is called for both ($P) and
      ** ($P:$L) and the larger of the two returned values is used.
      **
      ** Similarly, iUpper is to be set to the estimate of the number of rows
      ** less than the upper bound of the range query. Where the upper bound
      ** is either ($P) or ($P:$U). Again, even if $U is available, both values
      ** of iUpper are requested of whereKeyStats() and the smaller used.
      **
      ** The number of rows between the two bounds is then just iUpper-iLower.
      */
      tRowcnt iLower;     /* Rows less than the lower bound */
      tRowcnt iUpper;     /* Rows less than the upper bound */
      int iLwrIdx = -2;   /* aSample[] for the lower bound */
      int iUprIdx = -1;   /* aSample[] for the upper bound */
 
      if( pRec ){
        testcase( pRec->nField!=pBuilder->nRecValid );
        pRec->nField = pBuilder->nRecValid;
      }
      /* Determine iLower and iUpper using ($P) only. */
      if( nEq==0 ){
        iLower = 0;
        iUpper = p->nRowEst0;
      }else{
        /* Note: this call could be optimized away - since the same values must
        ** have been requested when testing key $P in whereEqualScanEst().  */
        whereKeyStats(pParse, p, pRec, 0, a);
        iLower = a[0];
        iUpper = a[0] + a[1];
      }
 
      assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 );
      assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 );
      assert( p->aSortOrder!=0 );
      if( p->aSortOrder[nEq] ){
        /* The roles of pLower and pUpper are swapped for a DESC index */
        SWAP(WhereTerm*, pLower, pUpper);
        SWAP(int, nBtm, nTop);
      }
 
      /* If possible, improve on the iLower estimate using ($P:$L). */
      if( pLower ){
        int n;                    /* Values extracted from pExpr */
        Expr *pExpr = pLower->pExpr->pRight;
        rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
        if( rc==SQLITE_OK && n ){
          tRowcnt iNew;
          u16 mask = WO_GT|WO_LE;
          if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
          iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a);
          iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0);
          if( iNew>iLower ) iLower = iNew;
          nOut--;
          pLower = 0;
        }
      }
 
      /* If possible, improve on the iUpper estimate using ($P:$U). */
      if( pUpper ){
        int n;                    /* Values extracted from pExpr */
        Expr *pExpr = pUpper->pExpr->pRight;
        rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
        if( rc==SQLITE_OK && n ){
          tRowcnt iNew;
          u16 mask = WO_GT|WO_LE;
          if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
          iUprIdx = whereKeyStats(pParse, p, pRec, 1, a);
          iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0);
          if( iNew<iUpper ) iUpper = iNew;
          nOut--;
          pUpper = 0;
        }
      }
 
      pBuilder->pRec = pRec;
      if( rc==SQLITE_OK ){
        if( iUpper>iLower ){
          nNew = sqlite3LogEst(iUpper - iLower);
          /* TUNING:  If both iUpper and iLower are derived from the same
          ** sample, then assume they are 4x more selective.  This brings
          ** the estimated selectivity more in line with what it would be
          ** if estimated without the use of STAT4 tables. */
          if( iLwrIdx==iUprIdx ) nNew -= 20;  assert( 20==sqlite3LogEst(4) );
        }else{
          nNew = 10;        assert( 10==sqlite3LogEst(2) );
        }
        if( nNew<nOut ){
          nOut = nNew;
        }
        WHERETRACE(0x10, ("STAT4 range scan: %u..%u  est=%d\n",
                           (u32)iLower, (u32)iUpper, nOut));
      }
    }else{
      int bDone = 0;
      rc = whereRangeSkipScanEst(pParse, pLower, pUpper, pLoop, &bDone);
      if( bDone ) return rc;
    }
  }
#else
  UNUSED_PARAMETER(pParse);
  UNUSED_PARAMETER(pBuilder);
  assert( pLower || pUpper );
#endif
  assert( pUpper==0 || (pUpper->wtFlags & TERM_VNULL)==0 );
  nNew = whereRangeAdjust(pLower, nOut);
  nNew = whereRangeAdjust(pUpper, nNew);
 
  /* TUNING: If there is both an upper and lower limit and neither limit
  ** has an application-defined likelihood(), assume the range is
  ** reduced by an additional 75%. This means that, by default, an open-ended
  ** range query (e.g. col > ?) is assumed to match 1/4 of the rows in the
  ** index. While a closed range (e.g. col BETWEEN ? AND ?) is estimated to
  ** match 1/64 of the index. */
  if( pLower && pLower->truthProb>0 && pUpper && pUpper->truthProb>0 ){
    nNew -= 20;
  }
 
  nOut -= (pLower!=0) + (pUpper!=0);
  if( nNew<10 ) nNew = 10;
  if( nNew<nOut ) nOut = nNew;
#if defined(WHERETRACE_ENABLED)
  if( pLoop->nOut>nOut ){
    WHERETRACE(0x10,("Range scan lowers nOut from %d to %d\n",

References ALWAYS, Index::aSortOrder, WhereLoop::btree, Parse::db, WhereTerm::eOperator, mask, WhereLoop::nBtm, WhereLoop::nEq, UnpackedRecord::nField, WhereLoop::nOut, WhereLoop::nTop, OptimizationEnabled, WhereTerm::pExpr, WhereLoop::pIndex, Expr::pRight, sqlite3ExprVectorSize(), sqlite3LogEst(), SQLITE_OK, SQLITE_Stat4, SWAP, TERM_VNULL, testcase, WhereTerm::truthProb, WhereLoop::u, UNUSED_PARAMETER, whereRangeAdjust(), WHERETRACE, WO_GE, WO_GT, WO_LE, WO_LT, and WhereTerm::wtFlags.

Referenced by whereLoopAddBtreeIndex().

◆ whereRangeVectorLen()

static int whereRangeVectorLen	(	Parse *	pParse,
		int	iCur,
		Index *	pIdx,
		int	nEq,
		WhereTerm *	pTerm )

static

Definition at line 147949 of file sqlite3.c.

 {
  int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
  int i;
 
  nCmp = MIN(nCmp, (pIdx->nColumn - nEq));
  for(i=1; i<nCmp; i++){
    /* Test if comparison i of pTerm is compatible with column (i+nEq)
    ** of the index. If not, exit the loop.  */
    char aff;                     /* Comparison affinity */
    char idxaff = 0;              /* Indexed columns affinity */
    CollSeq *pColl;               /* Comparison collation sequence */
    Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
    Expr *pRhs = pTerm->pExpr->pRight;
    if( pRhs->flags & EP_xIsSelect ){
      pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
    }else{
      pRhs = pRhs->x.pList->a[i].pExpr;
    }
 
    /* Check that the LHS of the comparison is a column reference to
    ** the right column of the right source table. And that the sort
    ** order of the index column is the same as the sort order of the
    ** leftmost index column.  */
    if( pLhs->op!=TK_COLUMN
     || pLhs->iTable!=iCur
     || pLhs->iColumn!=pIdx->aiColumn[i+nEq]
     || pIdx->aSortOrder[i+nEq]!=pIdx->aSortOrder[nEq]
    ){
      break;
    }
 
    testcase( pLhs->iColumn==XN_ROWID );
    aff = sqlite3CompareAffinity(pRhs, sqlite3ExprAffinity(pLhs));
    idxaff = sqlite3TableColumnAffinity(pIdx->pTable, pLhs->iColumn);
    if( aff!=idxaff ) break;
 

References ExprList::a, Index::aiColumn, Index::aSortOrder, Index::azColl, EP_xIsSelect, Expr::flags, Expr::iColumn, Expr::iTable, MIN, Index::nColumn, Expr::op, Select::pEList, ExprList::ExprList_item::pExpr, WhereTerm::pExpr, Expr::pLeft, Expr::pList, Expr::pRight, Expr::pSelect, Index::pTable, sqlite3BinaryCompareCollSeq(), sqlite3CompareAffinity(), sqlite3ExprAffinity(), sqlite3ExprVectorSize(), sqlite3StrICmp(), sqlite3TableColumnAffinity(), testcase, TK_COLUMN, Expr::x, XN_ROWID, and CollSeq::zName.

Referenced by whereLoopAddBtreeIndex().

◆ whereScanInit()

static WhereTerm * whereScanInit	(	WhereScan *	pScan,
		WhereClause *	pWC,
		int	iCur,
		int	iColumn,
		u32	opMask,
		Index *	pIdx )

static

Definition at line 145960 of file sqlite3.c.

 {
  pScan->pOrigWC = pWC;
  pScan->pWC = pWC;
  pScan->pIdxExpr = 0;
  pScan->idxaff = 0;
  pScan->zCollName = 0;
  pScan->opMask = opMask;
  pScan->k = 0;
  pScan->aiCur[0] = iCur;
  pScan->nEquiv = 1;
  pScan->iEquiv = 1;
  if( pIdx ){
    int j = iColumn;
    iColumn = pIdx->aiColumn[j];
    if( iColumn==XN_EXPR ){
      pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
      pScan->zCollName = pIdx->azColl[j];
      pScan->aiColumn[0] = XN_EXPR;
      return whereScanInitIndexExpr(pScan);
    }else if( iColumn==pIdx->pTable->iPKey ){
      iColumn = XN_ROWID;
    }else if( iColumn>=0 ){
      pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
      pScan->zCollName = pIdx->azColl[j];
    }

References ExprList::a, Table::aCol, Index::aColExpr, Column::affinity, Index::aiColumn, WhereScan::aiColumn, WhereScan::aiCur, Index::azColl, WhereScan::idxaff, WhereScan::iEquiv, Table::iPKey, WhereScan::k, WhereScan::nEquiv, WhereScan::opMask, ExprList::ExprList_item::pExpr, WhereScan::pIdxExpr, WhereScan::pOrigWC, Index::pTable, WhereScan::pWC, whereScanInitIndexExpr(), whereScanNext(), XN_EXPR, XN_ROWID, and WhereScan::zCollName.

Referenced by sqlite3WhereFindTerm(), and whereLoopAddBtreeIndex().

◆ whereScanInitIndexExpr()

static SQLITE_NOINLINE WhereTerm * whereScanInitIndexExpr ( WhereScan * pScan )

static

Definition at line 145936 of file sqlite3.c.

References WhereScan::idxaff, WhereScan::pIdxExpr, sqlite3ExprAffinity(), and whereScanNext().

Referenced by whereScanInit().

◆ whereScanNext()

static WhereTerm * whereScanNext ( WhereScan * pScan )

static

Definition at line 145848 of file sqlite3.c.

                                                 {
  int iCur;            /* The cursor on the LHS of the term */
  i16 iColumn;         /* The column on the LHS of the term.  -1 for IPK */
  Expr *pX;            /* An expression being tested */
  WhereClause *pWC;    /* Shorthand for pScan->pWC */
  WhereTerm *pTerm;    /* The term being tested */
  int k = pScan->k;    /* Where to start scanning */
 
  assert( pScan->iEquiv<=pScan->nEquiv );
  pWC = pScan->pWC;
  while(1){
    iColumn = pScan->aiColumn[pScan->iEquiv-1];
    iCur = pScan->aiCur[pScan->iEquiv-1];
    assert( pWC!=0 );
    do{
      for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
        if( pTerm->leftCursor==iCur
         && pTerm->u.leftColumn==iColumn
         && (iColumn!=XN_EXPR
             || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
                                       pScan->pIdxExpr,iCur)==0)
         && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
        ){
          if( (pTerm->eOperator & WO_EQUIV)!=0
           && pScan->nEquiv<ArraySize(pScan->aiCur)
           && (pX = sqlite3ExprSkipCollateAndLikely(pTerm->pExpr->pRight))->op
               ==TK_COLUMN
          ){
            int j;
            for(j=0; j<pScan->nEquiv; j++){
              if( pScan->aiCur[j]==pX->iTable
               && pScan->aiColumn[j]==pX->iColumn ){
                  break;
              }
            }
            if( j==pScan->nEquiv ){
              pScan->aiCur[j] = pX->iTable;
              pScan->aiColumn[j] = pX->iColumn;
              pScan->nEquiv++;
            }
          }
          if( (pTerm->eOperator & pScan->opMask)!=0 ){
            /* Verify the affinity and collating sequence match */
            if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){
              CollSeq *pColl;
              Parse *pParse = pWC->pWInfo->pParse;
              pX = pTerm->pExpr;
              if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
                continue;
              }
              assert(pX->pLeft);
              pColl = sqlite3ExprCompareCollSeq(pParse, pX);
              if( pColl==0 ) pColl = pParse->db->pDfltColl;
              if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
                continue;
              }
            }
            if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0
             && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN
             && pX->iTable==pScan->aiCur[0]
             && pX->iColumn==pScan->aiColumn[0]
            ){
              testcase( pTerm->eOperator & WO_IS );
              continue;
            }
            pScan->pWC = pWC;
            pScan->k = k+1;
            return pTerm;
          }
        }
      }
      pWC = pWC->pOuter;
      k = 0;
    }while( pWC!=0 );
    if( pScan->iEquiv>=pScan->nEquiv ) break;

References WhereClause::a, WhereScan::aiColumn, WhereScan::aiCur, ArraySize, Parse::db, WhereTerm::eOperator, EP_FromJoin, ExprHasProperty, Expr::iColumn, WhereScan::idxaff, WhereScan::iEquiv, Expr::iTable, WhereScan::k, WhereTerm::leftColumn, WhereTerm::leftCursor, WhereScan::nEquiv, WhereClause::nTerm, WhereScan::opMask, sqlite3::pDfltColl, WhereTerm::pExpr, WhereScan::pIdxExpr, Expr::pLeft, WhereScan::pOrigWC, WhereClause::pOuter, WhereInfo::pParse, Expr::pRight, WhereScan::pWC, WhereClause::pWInfo, sqlite3ExprCompareCollSeq(), sqlite3ExprCompareSkip(), sqlite3ExprSkipCollateAndLikely(), sqlite3IndexAffinityOk(), sqlite3StrICmp(), testcase, TK_COLUMN, WhereTerm::u, WO_EQ, WO_EQUIV, WO_IS, WO_ISNULL, XN_EXPR, WhereScan::zCollName, and CollSeq::zName.

Referenced by sqlite3WhereFindTerm(), whereLoopAddBtreeIndex(), whereScanInit(), and whereScanInitIndexExpr().

◆ whereShortCut()

static int whereShortCut ( WhereLoopBuilder * pBuilder )

static

Definition at line 150080 of file sqlite3.c.

                                                    {
  WhereInfo *pWInfo;
  struct SrcList_item *pItem;
  WhereClause *pWC;
  WhereTerm *pTerm;
  WhereLoop *pLoop;
  int iCur;
  int j;
  Table *pTab;
  Index *pIdx;
 
  pWInfo = pBuilder->pWInfo;
  if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0;
  assert( pWInfo->pTabList->nSrc>=1 );
  pItem = pWInfo->pTabList->a;
  pTab = pItem->pTab;
  if( IsVirtual(pTab) ) return 0;
  if( pItem->fg.isIndexedBy ) return 0;
  iCur = pItem->iCursor;
  pWC = &pWInfo->sWC;
  pLoop = pBuilder->pNew;
  pLoop->wsFlags = 0;
  pLoop->nSkip = 0;
  pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0);
  if( pTerm ){
    testcase( pTerm->eOperator & WO_IS );
    pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW;
    pLoop->aLTerm[0] = pTerm;
    pLoop->nLTerm = 1;
    pLoop->u.btree.nEq = 1;
    /* TUNING: Cost of a rowid lookup is 10 */
    pLoop->rRun = 33;  /* 33==sqlite3LogEst(10) */
  }else{
    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
      int opMask;
      assert( pLoop->aLTermSpace==pLoop->aLTerm );
      if( !IsUniqueIndex(pIdx)
       || pIdx->pPartIdxWhere!=0
       || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace)
      ) continue;
      opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ;
      for(j=0; j<pIdx->nKeyCol; j++){
        pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx);
        if( pTerm==0 ) break;
        testcase( pTerm->eOperator & WO_IS );
        pLoop->aLTerm[j] = pTerm;
      }
      if( j!=pIdx->nKeyCol ) continue;
      pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED;
      if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){
        pLoop->wsFlags |= WHERE_IDX_ONLY;
      }
      pLoop->nLTerm = j;
      pLoop->u.btree.nEq = j;
      pLoop->u.btree.pIndex = pIdx;
      /* TUNING: Cost of a unique index lookup is 15 */
      pLoop->rRun = 39;  /* 39==sqlite3LogEst(15) */
      break;
    }
  }
  if( pLoop->wsFlags ){
    pLoop->nOut = (LogEst)1;
    pWInfo->a[0].pWLoop = pLoop;
    assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] );
    pLoop->maskSelf = 1; /* sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); */
    pWInfo->a[0].iTabCur = iCur;
    pWInfo->nRowOut = 1;
    if( pWInfo->pOrderBy ) pWInfo->nOBSat =  pWInfo->pOrderBy->nExpr;
    if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){
      pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
    }
#ifdef SQLITE_DEBUG

References SrcList::a, WhereInfo::a, WhereLoop::aLTerm, WhereLoop::aLTermSpace, ArraySize, WhereLoop::btree, Index::colNotIdxed, WhereInfo::eDistinct, WhereTerm::eOperator, Index::isCovering, IsUniqueIndex, IsVirtual, WhereLevel::iTabCur, WhereMaskSet::ix, WhereLoop::maskSelf, WhereMaskSet::n, WhereLoop::nEq, ExprList::nExpr, Index::nKeyCol, WhereLoop::nLTerm, WhereInfo::nOBSat, WhereLoop::nOut, WhereInfo::nRowOut, WhereLoop::nSkip, SrcList::nSrc, Table::pIndex, WhereLoop::pIndex, WhereLoopBuilder::pNew, Index::pNext, WhereInfo::pOrderBy, Index::pPartIdxWhere, WhereInfo::pTabList, WhereLoopBuilder::pWInfo, WhereLevel::pWLoop, WhereLoop::rRun, WhereInfo::sMaskSet, sqlite3WhereFindTerm(), WhereInfo::sWC, testcase, WhereLoop::u, Index::uniqNotNull, WhereInfo::wctrlFlags, WHERE_COLUMN_EQ, WHERE_DISTINCT_UNIQUE, WHERE_IDX_ONLY, WHERE_INDEXED, WHERE_IPK, WHERE_ONEROW, WHERE_OR_SUBCLAUSE, WHERE_WANT_DISTINCT, WO_EQ, WO_IS, and WhereLoop::wsFlags.

Referenced by sqlite3WhereBegin().

◆ whereSortingCost()

static LogEst whereSortingCost	(	WhereInfo *	pWInfo,
		LogEst	nRow,
		int	nOrderBy,
		int	nSorted )

static

Definition at line 149643 of file sqlite3.c.

 {
  /* TUNING: Estimated cost of a full external sort, where N is
  ** the number of rows to sort is:
  **
  **   cost = (3.0 * N * log(N)).
  **
  ** Or, if the order-by clause has X terms but only the last Y
  ** terms are out of order, then block-sorting will reduce the
  ** sorting cost to:
  **
  **   cost = (3.0 * N * log(N)) * (Y/X)
  **
  ** The (Y/X) term is implemented using stack variable rScale
  ** below.  */
  LogEst rScale, rSortCost;
  assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
  rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
  rSortCost = nRow + rScale + 16;
 
  /* Multiple by log(M) where M is the number of output rows.
  ** Use the LIMIT for M if it is smaller */

References estLog(), WhereInfo::iLimit, sqlite3LogEst(), WhereInfo::wctrlFlags, and WHERE_USE_LIMIT.

Referenced by wherePathSolver().

◆ whereUsablePartialIndex()

static int whereUsablePartialIndex	(	int	iTab,
		int	isLeft,
		WhereClause *	pWC,
		Expr *	pWhere )

static

Definition at line 148438 of file sqlite3.c.

 {
  int i;
  WhereTerm *pTerm;
  Parse *pParse = pWC->pWInfo->pParse;
  while( pWhere->op==TK_AND ){
    if( !whereUsablePartialIndex(iTab,isLeft,pWC,pWhere->pLeft) ) return 0;
    pWhere = pWhere->pRight;
  }
  if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    pExpr = pTerm->pExpr;
    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
     && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)

Referenced by whereLoopAddBtree().

◆ windowAggFinal()

static void windowAggFinal	(	WindowCodeArg *	p,
		int	bFin )

static

Definition at line 152882 of file sqlite3.c.

                                                      {
  Parse *pParse = p->pParse;
  Window *pMWin = p->pMWin;
  Vdbe *v = sqlite3GetVdbe(pParse);
  Window *pWin;
 
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    if( pMWin->regStartRowid==0
     && (pWin->pFunc->funcFlags & SQLITE_FUNC_MINMAX)
     && (pWin->eStart!=TK_UNBOUNDED)
    ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
      sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
      VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
    }else if( pWin->regApp ){
      assert( pMWin->regStartRowid==0 );
    }else{
      int nArg = windowArgCount(pWin);
      if( bFin ){
        sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF);
        sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
      }else{

References Window::csrApp, Window::eStart, FuncDef::funcFlags, OP_AggFinal, OP_AggValue, OP_Column, OP_Copy, OP_Last, OP_Null, P4_FUNCDEF, Window::pFunc, WindowCodeArg::pMWin, Window::pNextWin, WindowCodeArg::pParse, Window::regAccum, Window::regApp, Window::regResult, Window::regStartRowid, sqlite3GetVdbe(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAppendP4(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), SQLITE_FUNC_MINMAX, TK_UNBOUNDED, VdbeCoverage, and windowArgCount().

Referenced by sqlite3WindowCodeStep(), windowCodeOp(), and windowFullScan().

◆ windowAggStep()

static void windowAggStep	(	WindowCodeArg *	p,
		Window *	pMWin,
		int	csr,
		int	bInverse,
		int	reg )

static

Definition at line 152768 of file sqlite3.c.

 {
  Parse *pParse = p->pParse;
  Vdbe *v = sqlite3GetVdbe(pParse);
  Window *pWin;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    int regArg;
    int nArg = pWin->bExprArgs ? 0 : windowArgCount(pWin);
    int i;
 
    assert( bInverse==0 || pWin->eStart!=TK_UNBOUNDED );
 
    /* All OVER clauses in the same window function aggregate step must
    ** be the same. */
    assert( pWin==pMWin || sqlite3WindowCompare(pParse,pWin,pMWin,0)!=1 );
 
    for(i=0; i<nArg; i++){
      if( i!=1 || pFunc->zName!=nth_valueName ){
        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i);
      }else{
        sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i);
      }
    }
    regArg = reg;
 
    if( pMWin->regStartRowid==0
     && (pFunc->funcFlags & SQLITE_FUNC_MINMAX)
     && (pWin->eStart!=TK_UNBOUNDED)
    ){
      int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg);
      VdbeCoverage(v);
      if( bInverse==0 ){
        sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1);
        sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp);
        sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2);
        sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2);
      }else{
        sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1);
        VdbeCoverageNeverTaken(v);
        sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp);
        sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
      }
      sqlite3VdbeJumpHere(v, addrIsNull);
    }else if( pWin->regApp ){
      assert( pFunc->zName==nth_valueName
           || pFunc->zName==first_valueName
      );
      assert( bInverse==0 || bInverse==1 );
      sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1);
    }else if( pFunc->xSFunc!=noopStepFunc ){
      int addrIf = 0;
      if( pWin->pFilter ){
        int regTmp;
        assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr );
        assert( pWin->bExprArgs || nArg  ||pWin->pOwner->x.pList==0 );
        regTmp = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp);
        addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1);
        VdbeCoverage(v);
        sqlite3ReleaseTempReg(pParse, regTmp);
      }
 
      if( pWin->bExprArgs ){
        int iStart = sqlite3VdbeCurrentAddr(v);
        VdbeOp *pOp, *pEnd;
 
        nArg = pWin->pOwner->x.pList->nExpr;
        regArg = sqlite3GetTempRange(pParse, nArg);
        sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0);
 
        pEnd = sqlite3VdbeGetOp(v, -1);
        for(pOp=sqlite3VdbeGetOp(v, iStart); pOp<=pEnd; pOp++){
          if( pOp->opcode==OP_Column && pOp->p1==pWin->iEphCsr ){
            pOp->p1 = csr;
          }
        }
      }
      if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
        CollSeq *pColl;
        assert( nArg>0 );
        pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
        sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ);
      }
      sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep,
                        bInverse, regArg, pWin->regAccum);
      sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF);
      sqlite3VdbeChangeP5(v, (u8)nArg);
      if( pWin->bExprArgs ){

References ExprList::a, Window::bExprArgs, Window::csrApp, Window::eStart, first_valueName, FuncDef::funcFlags, Window::iArgCol, Window::iEphCsr, ExprList::nExpr, noopStepFunc(), nth_valueName, OP_AddImm, OP_AggInverse, OP_AggStep, OP_CollSeq, OP_Column, OP_Delete, OP_IdxInsert, OP_IfNot, OP_IsNull, OP_MakeRecord, OP_SCopy, OP_SeekGE, VdbeOp::opcode, VdbeOp::p1, P4_COLLSEQ, P4_FUNCDEF, ExprList::ExprList_item::pExpr, Window::pFilter, Window::pFunc, Expr::pList, Window::pNextWin, Window::pOwner, WindowCodeArg::pParse, Window::regAccum, Window::regApp, Window::regStartRowid, sqlite3ExprCodeExprList(), sqlite3ExprNNCollSeq(), sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAddOp4Int(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeGetOp(), sqlite3VdbeJumpHere(), sqlite3WindowCompare(), SQLITE_FUNC_MINMAX, SQLITE_FUNC_NEEDCOLL, TK_UNBOUNDED, VdbeCoverage, VdbeCoverageNeverTaken, windowArgCount(), Expr::x, FuncDef::xSFunc, and FuncDef::zName.

Referenced by windowCodeOp(), and windowFullScan().

◆ windowArgCount()

static int windowArgCount ( Window * pWin )

static

Definition at line 152642 of file sqlite3.c.

Referenced by windowAggFinal(), windowAggStep(), and windowInitAccum().

◆ windowCacheFrame()

static int windowCacheFrame ( Window * pMWin )

static

Definition at line 153135 of file sqlite3.c.

                                          {
  Window *pWin;
  if( pMWin->regStartRowid ) return 1;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    if( (pFunc->zName==nth_valueName)
     || (pFunc->zName==first_valueName)
     || (pFunc->zName==leadName)
     || (pFunc->zName==lagName)

Referenced by sqlite3WindowCodeStep().

◆ windowCheckValue()

static void windowCheckValue	(	Parse *	pParse,
		int	reg,
		int	eCond )

static

Definition at line 152596 of file sqlite3.c.

                                                               {
  static const char *azErr[] = {
    "frame starting offset must be a non-negative integer",
    "frame ending offset must be a non-negative integer",
    "second argument to nth_value must be a positive integer",
    "frame starting offset must be a non-negative number",
    "frame ending offset must be a non-negative number",
  };
  static int aOp[] = { OP_Ge, OP_Ge, OP_Gt, OP_Ge, OP_Ge };
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regZero = sqlite3GetTempReg(pParse);
  assert( eCond>=0 && eCond<ArraySize(azErr) );
  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
  if( eCond>=WINDOW_STARTING_NUM ){
    int regString = sqlite3GetTempReg(pParse);
    sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
    sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg);
    sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL);
    VdbeCoverage(v);
    assert( eCond==3 || eCond==4 );
    VdbeCoverageIf(v, eCond==3);
    VdbeCoverageIf(v, eCond==4);
  }else{
    sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
    VdbeCoverage(v);
    assert( eCond==0 || eCond==1 || eCond==2 );
    VdbeCoverageIf(v, eCond==0);
    VdbeCoverageIf(v, eCond==1);
    VdbeCoverageIf(v, eCond==2);
  }
  sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
  VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */
  VdbeCoverageNeverNullIf(v, eCond==1); /*   the OP_MustBeInt */
  VdbeCoverageNeverNullIf(v, eCond==2);
  VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */

References ArraySize, OE_Abort, OP_Ge, OP_Gt, OP_Halt, OP_Integer, OP_MustBeInt, OP_String8, P4_STATIC, sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3MayAbort(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeAppendP4(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), SQLITE_AFF_NUMERIC, SQLITE_ERROR, SQLITE_JUMPIFNULL, VdbeCoverage, VdbeCoverageIf, VdbeCoverageNeverNullIf, and WINDOW_STARTING_NUM.

Referenced by sqlite3WindowCodeStep(), and windowReturnOneRow().

◆ windowCodeOp()

static int windowCodeOp	(	WindowCodeArg *	p,
		int	op,
		int	regCountdown,
		int	jumpOnEof )

static

Definition at line 153332 of file sqlite3.c.

 {
  int csr, reg;
  Parse *pParse = p->pParse;
  Window *pMWin = p->pMWin;
  int ret = 0;
  Vdbe *v = p->pVdbe;
  int addrContinue = 0;
  int bPeer = (pMWin->eFrmType!=TK_ROWS);
 
  int lblDone = sqlite3VdbeMakeLabel(pParse);
  int addrNextRange = 0;
 
  /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame
  ** starts with UNBOUNDED PRECEDING. */
  if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){
    assert( regCountdown==0 && jumpOnEof==0 );
    return 0;
  }
 
  if( regCountdown>0 ){
    if( pMWin->eFrmType==TK_RANGE ){
      addrNextRange = sqlite3VdbeCurrentAddr(v);
      assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP );
      if( op==WINDOW_AGGINVERSE ){
        if( pMWin->eStart==TK_FOLLOWING ){
          windowCodeRangeTest(
              p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
          );
        }else{
          windowCodeRangeTest(
              p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
          );
        }
      }else{
        windowCodeRangeTest(
            p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone
        );
      }
    }else{
      sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1);
      VdbeCoverage(v);
    }
  }
 
  if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){
    windowAggFinal(p, 0);
  }
  addrContinue = sqlite3VdbeCurrentAddr(v);
 
  /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or
  ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the
  ** start cursor does not advance past the end cursor within the
  ** temporary table. It otherwise might, if (a>b).  */
  if( pMWin->eStart==pMWin->eEnd && regCountdown
   && pMWin->eFrmType==TK_RANGE && op==WINDOW_AGGINVERSE
  ){
    int regRowid1 = sqlite3GetTempReg(pParse);
    int regRowid2 = sqlite3GetTempReg(pParse);
    sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
    sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
    sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1);
    VdbeCoverage(v);
    sqlite3ReleaseTempReg(pParse, regRowid1);
    sqlite3ReleaseTempReg(pParse, regRowid2);
    assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING );
  }
 
  switch( op ){
    case WINDOW_RETURN_ROW:
      csr = p->current.csr;
      reg = p->current.reg;
      windowReturnOneRow(p);
      break;
 
    case WINDOW_AGGINVERSE:
      csr = p->start.csr;
      reg = p->start.reg;
      if( pMWin->regStartRowid ){
        assert( pMWin->regEndRowid );
        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1);
      }else{
        windowAggStep(p, pMWin, csr, 1, p->regArg);
      }
      break;
 
    default:
      assert( op==WINDOW_AGGSTEP );
      csr = p->end.csr;
      reg = p->end.reg;
      if( pMWin->regStartRowid ){
        assert( pMWin->regEndRowid );
        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1);
      }else{
        windowAggStep(p, pMWin, csr, 0, p->regArg);
      }
      break;
  }
 
  if( op==p->eDelete ){
    sqlite3VdbeAddOp1(v, OP_Delete, csr);
    sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
  }
 
  if( jumpOnEof ){
    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2);
    VdbeCoverage(v);
    ret = sqlite3VdbeAddOp0(v, OP_Goto);
  }else{
    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer);
    VdbeCoverage(v);
    if( bPeer ){
      sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone);
    }
  }
 
  if( bPeer ){
    int nReg = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0);
    int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0);
    windowReadPeerValues(p, csr, regTmp);
    windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue);
    sqlite3ReleaseTempRange(pParse, regTmp, nReg);
  }
 

References WindowCsrAndReg::csr, WindowCodeArg::current, WindowCodeArg::eDelete, Window::eEnd, Window::eFrmType, WindowCodeArg::end, Window::eStart, ExprList::nExpr, OP_AddImm, OP_Delete, OP_Ge, OP_Goto, OP_Gt, OP_IfPos, OP_Le, OP_Next, OP_Rowid, OPFLAG_SAVEPOSITION, WindowCodeArg::pMWin, Window::pOrderBy, WindowCodeArg::pParse, WindowCodeArg::pVdbe, WindowCsrAndReg::reg, WindowCodeArg::regArg, Window::regEndRowid, Window::regStartRowid, sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), WindowCodeArg::start, TK_FOLLOWING, TK_PRECEDING, TK_RANGE, TK_ROWS, TK_UNBOUNDED, VdbeCoverage, WINDOW_AGGINVERSE, WINDOW_AGGSTEP, WINDOW_RETURN_ROW, windowAggFinal(), windowAggStep(), windowCodeRangeTest(), windowIfNewPeer(), windowReadPeerValues(), and windowReturnOneRow().

Referenced by sqlite3WindowCodeStep().

◆ windowCodeRangeTest()

static void windowCodeRangeTest	(	WindowCodeArg *	p,
		int	op,
		int	csr1,
		int	regVal,
		int	csr2,
		int	lbl )

static

Definition at line 153207 of file sqlite3.c.

 {
  Parse *pParse = p->pParse;
  Vdbe *v = sqlite3GetVdbe(pParse);
  ExprList *pOrderBy = p->pMWin->pOrderBy;  /* ORDER BY clause for window */
  int reg1 = sqlite3GetTempReg(pParse);     /* Reg. for csr1.peerVal+regVal */
  int reg2 = sqlite3GetTempReg(pParse);     /* Reg. for csr2.peerVal */
  int regString = ++pParse->nMem;           /* Reg. for constant value '' */
  int arith = OP_Add;                       /* OP_Add or OP_Subtract */
  int addrGe;                               /* Jump destination */
 
  assert( op==OP_Ge || op==OP_Gt || op==OP_Le );
  assert( pOrderBy && pOrderBy->nExpr==1 );
  if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_DESC ){
    switch( op ){
      case OP_Ge: op = OP_Le; break;
      case OP_Gt: op = OP_Lt; break;
      default: assert( op==OP_Le ); op = OP_Ge; break;
    }
    arith = OP_Subtract;
  }
 
  /* Read the peer-value from each cursor into a register */
  windowReadPeerValues(p, csr1, reg1);
  windowReadPeerValues(p, csr2, reg2);
 
  VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl",
      reg1, (arith==OP_Add ? "+" : "-"), regVal,
      ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2
  ));
 
  /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
  ** This block adds (or subtracts for DESC) the numeric value in regVal
  ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
  ** then leave reg1 as it is. In pseudo-code, this is implemented as:
  **
  **   if( reg1>='' ) goto addrGe;
  **   reg1 = reg1 +/- regVal
  **   addrGe:
  **
  ** Since all strings and blobs are greater-than-or-equal-to an empty string,
  ** the add/subtract is skipped for these, as required. If reg1 is a NULL,
  ** then the arithmetic is performed, but since adding or subtracting from
  ** NULL is always NULL anyway, this case is handled as required too.  */
  sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
  addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1);
  VdbeCoverage(v);
  sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1);
  sqlite3VdbeJumpHere(v, addrGe);
 
  /* If the BIGNULL flag is set for the ORDER BY, then it is required to
  ** consider NULL values to be larger than all other values, instead of
  ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this
  ** (and adding that capability causes a performance regression), so
  ** instead if the BIGNULL flag is set then cases where either reg1 or
  ** reg2 are NULL are handled separately in the following block. The code
  ** generated is equivalent to:
  **
  **   if( reg1 IS NULL ){
  **     if( op==OP_Ge ) goto lbl;
  **     if( op==OP_Gt && reg2 IS NOT NULL ) goto lbl;
  **     if( op==OP_Le && reg2 IS NULL ) goto lbl;
  **   }else if( reg2 IS NULL ){
  **     if( op==OP_Le ) goto lbl;
  **   }
  **
  ** Additionally, if either reg1 or reg2 are NULL but the jump to lbl is
  ** not taken, control jumps over the comparison operator coded below this
  ** block.  */
  if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_BIGNULL ){
    /* This block runs if reg1 contains a NULL. */
    int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v);
    switch( op ){
      case OP_Ge:
        sqlite3VdbeAddOp2(v, OP_Goto, 0, lbl);
        break;
      case OP_Gt:
        sqlite3VdbeAddOp2(v, OP_NotNull, reg2, lbl);
        VdbeCoverage(v);
        break;
      case OP_Le:
        sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl);
        VdbeCoverage(v);
        break;
      default: assert( op==OP_Lt ); /* no-op */ break;
    }
    sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3);
 
    /* This block runs if reg1 is not NULL, but reg2 is. */
    sqlite3VdbeJumpHere(v, addr);
    sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); VdbeCoverage(v);
    if( op==OP_Gt || op==OP_Ge ){
      sqlite3VdbeChangeP2(v, -1, sqlite3VdbeCurrentAddr(v)+1);
    }
  }
 
  /* Compare registers reg2 and reg1, taking the jump if required. Note that
  ** control skips over this test if the BIGNULL flag is set and either
  ** reg1 or reg2 contain a NULL value.  */
  sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
  sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
 
  assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le );
  testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
  testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt);
  testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le);

References ExprList::a, arith(), KEYINFO_ORDER_BIGNULL, KEYINFO_ORDER_DESC, ExprList::nExpr, Parse::nMem, OP_Add, OP_Ge, OP_Goto, OP_Gt, OP_IsNull, OP_Le, OP_Lt, OP_NotNull, OP_String8, OP_Subtract, P4_STATIC, WindowCodeArg::pMWin, Window::pOrderBy, WindowCodeArg::pParse, ExprList::ExprList_item::sortFlags, sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP2(), sqlite3VdbeChangeP5(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), SQLITE_NULLEQ, testcase, VdbeCoverage, VdbeCoverageIf, VdbeModuleComment, and windowReadPeerValues().

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ windowExprGtZero()

static int windowExprGtZero	(	Parse *	pParse,
		Expr *	pExpr )

static

Definition at line 153528 of file sqlite3.c.

                                                       {
  int ret = 0;
  sqlite3 *db = pParse->db;
  sqlite3_value *pVal = 0;
  sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);

References Parse::db, sqlite3::enc, sqlite3_value_int(), sqlite3ValueFree(), sqlite3ValueFromExpr(), and SQLITE_AFF_NUMERIC.

Referenced by sqlite3WindowCodeStep().

◆ windowFind()

static Window * windowFind	(	Parse *	pParse,
		Window *	pList,
		const char *	zName )

static

Definition at line 151790 of file sqlite3.c.

                                                                          {
  Window *p;
  for(p=pList; p; p=p->pNextWin){
    if( sqlite3StrICmp(p->zName, zName)==0 ) break;

Referenced by sqlite3WindowChain(), and sqlite3WindowUpdate().

◆ windowFullScan()

static void windowFullScan ( WindowCodeArg * p )

static

Definition at line 152921 of file sqlite3.c.

                                            {
  Window *pWin;
  Parse *pParse = p->pParse;
  Window *pMWin = p->pMWin;
  Vdbe *v = p->pVdbe;
 
  int regCRowid = 0;              /* Current rowid value */
  int regCPeer = 0;               /* Current peer values */
  int regRowid = 0;               /* AggStep rowid value */
  int regPeer = 0;                /* AggStep peer values */
 
  int nPeer;
  int lblNext;
  int lblBrk;
  int addrNext;
  int csr;
 
  VdbeModuleComment((v, "windowFullScan begin"));
 
  assert( pMWin!=0 );
  csr = pMWin->csrApp;
  nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0);
 
  lblNext = sqlite3VdbeMakeLabel(pParse);
  lblBrk = sqlite3VdbeMakeLabel(pParse);
 
  regCRowid = sqlite3GetTempReg(pParse);
  regRowid = sqlite3GetTempReg(pParse);
  if( nPeer ){
    regCPeer = sqlite3GetTempRange(pParse, nPeer);
    regPeer = sqlite3GetTempRange(pParse, nPeer);
  }
 
  sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid);
  windowReadPeerValues(p, pMWin->iEphCsr, regCPeer);
 
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
  }
 
  sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid);
  VdbeCoverage(v);
  addrNext = sqlite3VdbeCurrentAddr(v);
  sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid);
  sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid);
  VdbeCoverageNeverNull(v);
 
  if( pMWin->eExclude==TK_CURRENT ){
    sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid);
    VdbeCoverageNeverNull(v);
  }else if( pMWin->eExclude!=TK_NO ){
    int addr;
    int addrEq = 0;
    KeyInfo *pKeyInfo = 0;
 
    if( pMWin->pOrderBy ){
      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
    }
    if( pMWin->eExclude==TK_TIES ){
      addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid);
      VdbeCoverageNeverNull(v);
    }
    if( pKeyInfo ){
      windowReadPeerValues(p, csr, regPeer);
      sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer);
      sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
      addr = sqlite3VdbeCurrentAddr(v)+1;
      sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr);
      VdbeCoverageEqNe(v);
    }else{
      sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext);
    }
    if( addrEq ) sqlite3VdbeJumpHere(v, addrEq);
  }
 
  windowAggStep(p, pMWin, csr, 0, p->regArg);
 
  sqlite3VdbeResolveLabel(v, lblNext);
  sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext);
  VdbeCoverage(v);
  sqlite3VdbeJumpHere(v, addrNext-1);
  sqlite3VdbeJumpHere(v, addrNext+1);
  sqlite3ReleaseTempReg(pParse, regRowid);
  sqlite3ReleaseTempReg(pParse, regCRowid);
  if( nPeer ){
    sqlite3ReleaseTempRange(pParse, regPeer, nPeer);

References Window::csrApp, Window::eExclude, Window::iEphCsr, ExprList::nExpr, OP_Compare, OP_Eq, OP_Goto, OP_Gt, OP_Jump, OP_Next, OP_Null, OP_Rowid, OP_SeekGE, P4_KEYINFO, WindowCodeArg::pMWin, Window::pNextWin, Window::pOrderBy, WindowCodeArg::pParse, WindowCodeArg::pVdbe, Window::regAccum, WindowCodeArg::regArg, Window::regEndRowid, Window::regStartRowid, sqlite3GetTempRange(), sqlite3GetTempReg(), sqlite3KeyInfoFromExprList(), sqlite3ReleaseTempRange(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAppendP4(), sqlite3VdbeCurrentAddr(), sqlite3VdbeJumpHere(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), TK_CURRENT, TK_NO, TK_TIES, VdbeCoverage, VdbeCoverageEqNe, VdbeCoverageNeverNull, VdbeModuleComment, windowAggFinal(), windowAggStep(), and windowReadPeerValues().

Referenced by windowReturnOneRow().

◆ windowIfNewPeer()

static void windowIfNewPeer	(	Parse *	pParse,
		ExprList *	pOrderBy,
		int	regNew,
		int	regOld,
		int	addr )

static

Definition at line 153161 of file sqlite3.c.

 {
  Vdbe *v = sqlite3GetVdbe(pParse);
  if( pOrderBy ){
    int nVal = pOrderBy->nExpr;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
    sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump,
      sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
    );

References ExprList::nExpr, OP_Compare, OP_Copy, OP_Goto, OP_Jump, P4_KEYINFO, sqlite3GetVdbe(), sqlite3KeyInfoFromExprList(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAppendP4(), sqlite3VdbeCurrentAddr(), and VdbeCoverageEqNe.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ windowInitAccum()

static int windowInitAccum	(	Parse *	pParse,
		Window *	pMWin )

static

Definition at line 153103 of file sqlite3.c.

                                                        {
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regArg;
  int nArg = 0;
  Window *pWin;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    assert( pWin->regAccum );
    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
    nArg = MAX(nArg, windowArgCount(pWin));
    if( pMWin->regStartRowid==0 ){
      if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
      }
 
      if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){
        assert( pWin->eStart!=TK_UNBOUNDED );
        sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
      }

References Window::csrApp, Window::eStart, first_valueName, FuncDef::funcFlags, MAX, Parse::nMem, nth_valueName, OP_Integer, OP_Null, OP_ResetSorter, Window::pFunc, Window::pNextWin, Window::regAccum, Window::regApp, Window::regStartRowid, sqlite3GetVdbe(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), SQLITE_FUNC_MINMAX, TK_UNBOUNDED, windowArgCount(), and FuncDef::zName.

Referenced by sqlite3WindowCodeStep().

◆ windowReadPeerValues()

static void windowReadPeerValues	(	WindowCodeArg *	p,
		int	csr,
		int	reg )

static

Definition at line 152731 of file sqlite3.c.

 {
  Window *pMWin = p->pMWin;
  ExprList *pOrderBy = pMWin->pOrderBy;
  if( pOrderBy ){
    Vdbe *v = sqlite3GetVdbe(p->pParse);
    ExprList *pPart = pMWin->pPartition;
    int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0);

Referenced by windowCodeOp(), windowCodeRangeTest(), and windowFullScan().

◆ windowRemoveExprFromSelect()

static void windowRemoveExprFromSelect	(	Select *	pSelect,
		Expr *	pExpr )

static

Definition at line 99166 of file sqlite3.c.

                                                                    {
  if( pSelect->pWin ){
    Walker sWalker;

Referenced by resolveOrderGroupBy().

◆ windowReturnOneRow()

static void windowReturnOneRow ( WindowCodeArg * p )

static

Definition at line 153027 of file sqlite3.c.

                                                {
  Window *pMWin = p->pMWin;
  Vdbe *v = p->pVdbe;
 
  if( pMWin->regStartRowid ){
    windowFullScan(p);
  }else{
    Parse *pParse = p->pParse;
    Window *pWin;
 
    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
      FuncDef *pFunc = pWin->pFunc;
      if( pFunc->zName==nth_valueName
       || pFunc->zName==first_valueName
      ){
        int csr = pWin->csrApp;
        int lbl = sqlite3VdbeMakeLabel(pParse);
        int tmpReg = sqlite3GetTempReg(pParse);
        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
 
        if( pFunc->zName==nth_valueName ){
          sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg);
          windowCheckValue(pParse, tmpReg, 2);
        }else{
          sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg);
        }
        sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg);
        sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg);
        VdbeCoverageNeverNull(v);
        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg);
        VdbeCoverageNeverTaken(v);
        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
        sqlite3VdbeResolveLabel(v, lbl);
        sqlite3ReleaseTempReg(pParse, tmpReg);
      }
      else if( pFunc->zName==leadName || pFunc->zName==lagName ){
        int nArg = pWin->pOwner->x.pList->nExpr;
        int csr = pWin->csrApp;
        int lbl = sqlite3VdbeMakeLabel(pParse);
        int tmpReg = sqlite3GetTempReg(pParse);
        int iEph = pMWin->iEphCsr;
 
        if( nArg<3 ){
          sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
        }else{
          sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult);
        }
        sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg);
        if( nArg<2 ){
          int val = (pFunc->zName==leadName ? 1 : -1);
          sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val);
        }else{
          int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
          int tmpReg2 = sqlite3GetTempReg(pParse);
          sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2);
          sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg);
          sqlite3ReleaseTempReg(pParse, tmpReg2);
        }
 
        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg);
        VdbeCoverage(v);
        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
        sqlite3VdbeResolveLabel(v, lbl);

References WindowCodeArg::addrGosub, Window::csrApp, first_valueName, Window::iArgCol, Window::iEphCsr, lagName, leadName, ExprList::nExpr, nth_valueName, OP_Add, OP_AddImm, OP_Column, OP_Gosub, OP_Gt, OP_Integer, OP_Null, OP_Rowid, OP_SeekRowid, OP_Subtract, Window::pFunc, Expr::pList, WindowCodeArg::pMWin, Window::pNextWin, Window::pOwner, WindowCodeArg::pParse, WindowCodeArg::pVdbe, Window::regApp, WindowCodeArg::regGosub, Window::regResult, Window::regStartRowid, sqlite3GetTempReg(), sqlite3ReleaseTempReg(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeMakeLabel(), sqlite3VdbeResolveLabel(), VdbeCoverage, VdbeCoverageNeverNull, VdbeCoverageNeverTaken, windowCheckValue(), windowFullScan(), Expr::x, and FuncDef::zName.

Referenced by sqlite3WindowCodeStep(), and windowCodeOp().

◆ withDup()

static With * withDup	(	sqlite3 *	db,
		With *	p )

static

Definition at line 101090 of file sqlite3.c.

                                          {
  With *pRet = 0;
  if( p ){
    sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
    pRet = sqlite3DbMallocZero(db, nByte);
    if( pRet ){
      int i;
      pRet->nCte = p->nCte;
      for(i=0; i<p->nCte; i++){
        pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0);
        pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0);

References With::a, With::nCte, With::Cte::pCols, With::Cte::pSelect, sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ExprListDup(), sqlite3SelectDup(), and With::Cte::zName.

◆ withExpand()

static int withExpand	(	Walker *	pWalker,
		struct SrcList_item *	pFrom )

static

Definition at line 134071 of file sqlite3.c.

 {
  Parse *pParse = pWalker->pParse;
  sqlite3 *db = pParse->db;
  struct Cte *pCte;               /* Matched CTE (or NULL if no match) */
  With *pWith;                    /* WITH clause that pCte belongs to */
 
  assert( pFrom->pTab==0 );
  if( pParse->nErr ){
    return SQLITE_ERROR;
  }
 
  pCte = searchWith(pParse->pWith, pFrom, &pWith);
  if( pCte ){
    Table *pTab;
    ExprList *pEList;
    Select *pSel;
    Select *pLeft;                /* Left-most SELECT statement */
    int bMayRecursive;            /* True if compound joined by UNION [ALL] */
    With *pSavedWith;             /* Initial value of pParse->pWith */
 
    /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
    ** recursive reference to CTE pCte. Leave an error in pParse and return
    ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
    ** In this case, proceed.  */
    if( pCte->zCteErr ){
      sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
      return SQLITE_ERROR;
    }
    if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR;
 
    assert( pFrom->pTab==0 );
    pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
    if( pTab==0 ) return WRC_Abort;
    pTab->nTabRef = 1;
    pTab->zName = sqlite3DbStrDup(db, pCte->zName);
    pTab->iPKey = -1;
    pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
    pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
    pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
    if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;
    assert( pFrom->pSelect );
 
    /* Check if this is a recursive CTE. */
    pSel = pFrom->pSelect;
    bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
    if( bMayRecursive ){
      int i;
      SrcList *pSrc = pFrom->pSelect->pSrc;
      for(i=0; i<pSrc->nSrc; i++){
        struct SrcList_item *pItem = &pSrc->a[i];
        if( pItem->zDatabase==0
         && pItem->zName!=0
         && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
          ){
          pItem->pTab = pTab;
          pItem->fg.isRecursive = 1;
          pTab->nTabRef++;
          pSel->selFlags |= SF_Recursive;
        }
      }
    }
 
    /* Only one recursive reference is permitted. */
    if( pTab->nTabRef>2 ){
      sqlite3ErrorMsg(
          pParse, "multiple references to recursive table: %s", pCte->zName
      );
      return SQLITE_ERROR;
    }
    assert( pTab->nTabRef==1 ||
            ((pSel->selFlags&SF_Recursive) && pTab->nTabRef==2 ));
 
    pCte->zCteErr = "circular reference: %s";
    pSavedWith = pParse->pWith;
    pParse->pWith = pWith;
    if( bMayRecursive ){
      Select *pPrior = pSel->pPrior;
      assert( pPrior->pWith==0 );
      pPrior->pWith = pSel->pWith;
      sqlite3WalkSelect(pWalker, pPrior);
      pPrior->pWith = 0;
    }else{
      sqlite3WalkSelect(pWalker, pSel);
    }
    pParse->pWith = pWith;
 
    for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
    pEList = pLeft->pEList;
    if( pCte->pCols ){
      if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
        sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
            pCte->zName, pEList->nExpr, pCte->pCols->nExpr
        );
        pParse->pWith = pSavedWith;
        return SQLITE_ERROR;
      }
      pEList = pCte->pCols;
    }
 
    sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
    if( bMayRecursive ){
      if( pSel->selFlags & SF_Recursive ){
        pCte->zCteErr = "multiple recursive references: %s";
      }else{
        pCte->zCteErr = "recursive reference in a subquery: %s";
      }
      sqlite3WalkSelect(pWalker, pSel);
    }

References SrcList::a, Table::aCol, cannotBeFunction(), Parse::db, Table::iPKey, sqlite3::mallocFailed, Table::nCol, Parse::nErr, ExprList::nExpr, Table::nRowLogEst, SrcList::nSrc, Table::nTabRef, Select::op, Select::pEList, Walker::pParse, Select::pPrior, Select::pWith, Parse::pWith, searchWith(), Select::selFlags, SF_Recursive, sqlite3ColumnsFromExprList(), sqlite3DbMallocZero(), sqlite3DbStrDup(), sqlite3ErrorMsg(), sqlite3LogEst(), sqlite3SelectDup(), sqlite3StrICmp(), sqlite3WalkSelect(), SQLITE_ERROR, SQLITE_NOMEM_BKPT, SQLITE_OK, Table::tabFlags, TF_Ephemeral, TF_NoVisibleRowid, TK_ALL, TK_UNION, WRC_Abort, and Table::zName.

Referenced by selectExpander().

◆ write32bits()

static int write32bits	(	sqlite3_file *	fd,
		i64	offset,
		u32	val )

static

Definition at line 52816 of file sqlite3.c.

References put32bits, and sqlite3OsWrite().

Referenced by subjournalPage(), and writeSuperJournal().

◆ writeJournalHdr()

static int writeJournalHdr ( Pager * pPager )

static

Definition at line 53136 of file sqlite3.c.

            : Initial database page count.
** - 4 bytes: Sector size used by the process that wrote this journal.
** - 4 bytes: Database page size.
**
** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
*/
static int writeJournalHdr(Pager *pPager){
  int rc = SQLITE_OK;                 /* Return code */
  char *zHeader = pPager->pTmpSpace;  /* Temporary space used to build header */
  u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
  u32 nWrite;                         /* Bytes of header sector written */
  int ii;                             /* Loop counter */
 
  assert( isOpen(pPager->jfd) );      /* Journal file must be open. */
 
  if( nHeader>JOURNAL_HDR_SZ(pPager) ){
    nHeader = JOURNAL_HDR_SZ(pPager);
  }
 
  /* If there are active savepoints and any of them were created
  ** since the most recent journal header was written, update the
  ** PagerSavepoint.iHdrOffset fields now.
  */
  for(ii=0; ii<pPager->nSavepoint; ii++){
    if( pPager->aSavepoint[ii].iHdrOffset==0 ){
      pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
    }
  }
 
  pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
 
  /*
  ** Write the nRec Field - the number of page records that follow this
  ** journal header. Normally, zero is written to this value at this time.
  ** After the records are added to the journal (and the journal synced,
  ** if in full-sync mode), the zero is overwritten with the true number
  ** of records (see syncJournal()).
  **
  ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
  ** reading the journal this value tells SQLite to assume that the
  ** rest of the journal file contains valid page records. This assumption
  ** is dangerous, as if a failure occurred whilst writing to the journal
  ** file it may contain some garbage data. There are two scenarios
  ** where this risk can be ignored:
  **
  **   * When the pager is in no-sync mode. Corruption can follow a
  **     power failure in this case anyway.
  **
  **   * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
  **     that garbage data is never appended to the journal file.
  */
  assert( isOpen(pPager->fd) || pPager->noSync );
  if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
   || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
  ){
    memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
    put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
  }else{
    memset(zHeader, 0, sizeof(aJournalMagic)+4);
  }
 
  /* The random check-hash initializer */
  sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
  put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
  /* The initial database size */
  put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
  /* The assumed sector size for this process */
  put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
 
  /* The page size */
  put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
 
  /* Initializing the tail of the buffer is not necessary.  Everything
  ** works find if the following memset() is omitted.  But initializing
  ** the memory prevents valgrind from complaining, so we are willing to
  ** take the performance hit.
  */
  memset(&zHeader[sizeof(aJournalMagic)+20], 0,
         nHeader-(sizeof(aJournalMagic)+20));
 
  /* In theory, it is only necessary to write the 28 bytes that the
  ** journal header consumes to the journal file here. Then increment the
  ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
  ** record is written to the following sector (leaving a gap in the file
  ** that will be implicitly filled in by the OS).
  **
  ** However it has been discovered that on some systems this pattern can
  ** be significantly slower than contiguously writing data to the file,
  ** even if that means explicitly writing data to the block of
  ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
  ** is done.
  **
  ** The loop is required here in case the sector-size is larger than the
  ** database page size. Since the zHeader buffer is only Pager.pageSize
  ** bytes in size, more than one call to sqlite3OsWrite() may be required
  ** to populate the entire journal header sector.
  */
  for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
    IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
    rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);

References aJournalMagic, Pager::aSavepoint, Pager::cksumInit, Pager::dbOrigSize, Pager::fd, PagerSavepoint::iHdrOffset, IOTRACE, isOpen, Pager::jfd, JOURNAL_HDR_SZ, Pager::journalHdr, journalHdrOffset(), Pager::journalMode, Pager::journalOff, Pager::noSync, Pager::nSavepoint, PAGER_JOURNALMODE_MEMORY, Pager::pageSize, Pager::pTmpSpace, put32bits, Pager::sectorSize, sqlite3_randomness(), sqlite3OsDeviceCharacteristics(), sqlite3OsWrite(), SQLITE_IOCAP_SAFE_APPEND, and SQLITE_OK.

Referenced by pager_open_journal(), and syncJournal().

◆ writeSuperJournal()

static int writeSuperJournal	(	Pager *	pPager,
		const char *	zSuper )

static

Definition at line 53379 of file sqlite3.c.

                                                               {
  int rc;                          /* Return code */
  int nSuper;                      /* Length of string zSuper */
  i64 iHdrOff;                     /* Offset of header in journal file */
  i64 jrnlSize;                    /* Size of journal file on disk */
  u32 cksum = 0;                   /* Checksum of string zSuper */
 
  assert( pPager->setSuper==0 );
  assert( !pagerUseWal(pPager) );
 
  if( !zSuper
   || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
   || !isOpen(pPager->jfd)
  ){
    return SQLITE_OK;
  }
  pPager->setSuper = 1;
  assert( pPager->journalHdr <= pPager->journalOff );
 
  /* Calculate the length in bytes and the checksum of zSuper */
  for(nSuper=0; zSuper[nSuper]; nSuper++){
    cksum += zSuper[nSuper];
  }
 
  /* If in full-sync mode, advance to the next disk sector before writing
  ** the super-journal name. This is in case the previous page written to
  ** the journal has already been synced.
  */
  if( pPager->fullSync ){
    pPager->journalOff = journalHdrOffset(pPager);
  }
  iHdrOff = pPager->journalOff;
 
  /* Write the super-journal data to the end of the journal file. If
  ** an error occurs, return the error code to the caller.
  */
  if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
   || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
   || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
   || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
   || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
                                 iHdrOff+4+nSuper+8)))
  ){
    return rc;
  }
  pPager->journalOff += (nSuper+20);
 
  /* If the pager is in peristent-journal mode, then the physical
  ** journal-file may extend past the end of the super-journal name
  ** and 8 bytes of magic data just written to the file. This is
  ** dangerous because the code to rollback a hot-journal file
  ** will not be able to find the super-journal name to determine
  ** whether or not the journal is hot.
  **
  ** Easiest thing to do in this scenario is to truncate the journal
  ** file to the required size.
  */
  if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))

References aJournalMagic, Pager::fullSync, isOpen, Pager::jfd, Pager::journalHdr, journalHdrOffset(), Pager::journalMode, Pager::journalOff, PAGER_JOURNALMODE_MEMORY, PAGER_MJ_PGNO, pagerUseWal, Pager::setSuper, sqlite3OsFileSize(), sqlite3OsTruncate(), sqlite3OsWrite(), SQLITE_OK, and write32bits().

Referenced by sqlite3PagerCommitPhaseOne().

◆ xferCompatibleIndex()

static int xferCompatibleIndex	(	Index *	pDest,
		Index *	pSrc )

static

Definition at line 123008 of file sqlite3.c.

                                                         {
  int i;
  assert( pDest && pSrc );
  assert( pDest->pTable!=pSrc->pTable );
  if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){
    return 0;   /* Different number of columns */
  }
  if( pDest->onError!=pSrc->onError ){
    return 0;   /* Different conflict resolution strategies */
  }
  for(i=0; i<pSrc->nKeyCol; i++){
    if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
      return 0;   /* Different columns indexed */
    }
    if( pSrc->aiColumn[i]==XN_EXPR ){
      assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
      if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
                             pDest->aColExpr->a[i].pExpr, -1)!=0 ){
        return 0;   /* Different expressions in the index */
      }
    }
    if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
      return 0;   /* Different sort orders */
    }
    if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
      return 0;   /* Different collating sequences */
    }
  }
  if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){

References ExprList::a, Index::aColExpr, Index::aiColumn, Index::aSortOrder, Index::azColl, Index::nColumn, Index::nKeyCol, Index::onError, ExprList::ExprList_item::pExpr, Index::pPartIdxWhere, Index::pTable, sqlite3_stricmp(), sqlite3ExprCompare(), and XN_EXPR.

Referenced by xferOptimization().

◆ xferOptimization()

static int xferOptimization	(	Parse *	pParse,
		Table *	pDest,
		Select *	pSelect,
		int	onError,
		int	iDbDest )

static

Definition at line 123069 of file sqlite3.c.

 {
  sqlite3 *db = pParse->db;
  ExprList *pEList;                /* The result set of the SELECT */
  Table *pSrc;                     /* The table in the FROM clause of SELECT */
  Index *pSrcIdx, *pDestIdx;       /* Source and destination indices */
  struct SrcList_item *pItem;      /* An element of pSelect->pSrc */
  int i;                           /* Loop counter */
  int iDbSrc;                      /* The database of pSrc */
  int iSrc, iDest;                 /* Cursors from source and destination */
  int addr1, addr2;                /* Loop addresses */
  int emptyDestTest = 0;           /* Address of test for empty pDest */
  int emptySrcTest = 0;            /* Address of test for empty pSrc */
  Vdbe *v;                         /* The VDBE we are building */
  int regAutoinc;                  /* Memory register used by AUTOINC */
  int destHasUniqueIdx = 0;        /* True if pDest has a UNIQUE index */
  int regData, regRowid;           /* Registers holding data and rowid */
 
  if( pSelect==0 ){
    return 0;   /* Must be of the form  INSERT INTO ... SELECT ... */
  }
  if( pParse->pWith || pSelect->pWith ){
    /* Do not attempt to process this query if there are an WITH clauses
    ** attached to it. Proceeding may generate a false "no such table: xxx"
    ** error if pSelect reads from a CTE named "xxx".  */
    return 0;
  }
  if( sqlite3TriggerList(pParse, pDest) ){
    return 0;   /* tab1 must not have triggers */
  }
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pDest) ){
    return 0;   /* tab1 must not be a virtual table */
  }
#endif
  if( onError==OE_Default ){
    if( pDest->iPKey>=0 ) onError = pDest->keyConf;
    if( onError==OE_Default ) onError = OE_Abort;
  }
  assert(pSelect->pSrc);   /* allocated even if there is no FROM clause */
  if( pSelect->pSrc->nSrc!=1 ){
    return 0;   /* FROM clause must have exactly one term */
  }
  if( pSelect->pSrc->a[0].pSelect ){
    return 0;   /* FROM clause cannot contain a subquery */
  }
  if( pSelect->pWhere ){
    return 0;   /* SELECT may not have a WHERE clause */
  }
  if( pSelect->pOrderBy ){
    return 0;   /* SELECT may not have an ORDER BY clause */
  }
  /* Do not need to test for a HAVING clause.  If HAVING is present but
  ** there is no ORDER BY, we will get an error. */
  if( pSelect->pGroupBy ){
    return 0;   /* SELECT may not have a GROUP BY clause */
  }
  if( pSelect->pLimit ){
    return 0;   /* SELECT may not have a LIMIT clause */
  }
  if( pSelect->pPrior ){
    return 0;   /* SELECT may not be a compound query */
  }
  if( pSelect->selFlags & SF_Distinct ){
    return 0;   /* SELECT may not be DISTINCT */
  }
  pEList = pSelect->pEList;
  assert( pEList!=0 );
  if( pEList->nExpr!=1 ){
    return 0;   /* The result set must have exactly one column */
  }
  assert( pEList->a[0].pExpr );
  if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
    return 0;   /* The result set must be the special operator "*" */
  }
 
  /* At this point we have established that the statement is of the
  ** correct syntactic form to participate in this optimization.  Now
  ** we have to check the semantics.
  */
  pItem = pSelect->pSrc->a;
  pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
  if( pSrc==0 ){
    return 0;   /* FROM clause does not contain a real table */
  }
  if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){
    testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */
    return 0;   /* tab1 and tab2 may not be the same table */
  }
  if( HasRowid(pDest)!=HasRowid(pSrc) ){
    return 0;   /* source and destination must both be WITHOUT ROWID or not */
  }
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pSrc) ){
    return 0;   /* tab2 must not be a virtual table */
  }
#endif
  if( pSrc->pSelect ){
    return 0;   /* tab2 may not be a view */
  }
  if( pDest->nCol!=pSrc->nCol ){
    return 0;   /* Number of columns must be the same in tab1 and tab2 */
  }
  if( pDest->iPKey!=pSrc->iPKey ){
    return 0;   /* Both tables must have the same INTEGER PRIMARY KEY */
  }
  for(i=0; i<pDest->nCol; i++){
    Column *pDestCol = &pDest->aCol[i];
    Column *pSrcCol = &pSrc->aCol[i];
#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
    if( (db->mDbFlags & DBFLAG_Vacuum)==0
     && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN
    ){
      return 0;    /* Neither table may have __hidden__ columns */
    }
#endif
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    /* Even if tables t1 and t2 have identical schemas, if they contain
    ** generated columns, then this statement is semantically incorrect:
    **
    **     INSERT INTO t2 SELECT * FROM t1;
    **
    ** The reason is that generated column values are returned by the
    ** the SELECT statement on the right but the INSERT statement on the
    ** left wants them to be omitted.
    **
    ** Nevertheless, this is a useful notational shorthand to tell SQLite
    ** to do a bulk transfer all of the content from t1 over to t2.
    **
    ** We could, in theory, disable this (except for internal use by the
    ** VACUUM command where it is actually needed).  But why do that?  It
    ** seems harmless enough, and provides a useful service.
    */
    if( (pDestCol->colFlags & COLFLAG_GENERATED) !=
        (pSrcCol->colFlags & COLFLAG_GENERATED) ){
      return 0;    /* Both columns have the same generated-column type */
    }
    /* But the transfer is only allowed if both the source and destination
    ** tables have the exact same expressions for generated columns.
    ** This requirement could be relaxed for VIRTUAL columns, I suppose.
    */
    if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){
      if( sqlite3ExprCompare(0, pSrcCol->pDflt, pDestCol->pDflt, -1)!=0 ){
        testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
        testcase( pDestCol->colFlags & COLFLAG_STORED );
        return 0;  /* Different generator expressions */
      }
    }
#endif
    if( pDestCol->affinity!=pSrcCol->affinity ){
      return 0;    /* Affinity must be the same on all columns */
    }
    if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){
      return 0;    /* Collating sequence must be the same on all columns */
    }
    if( pDestCol->notNull && !pSrcCol->notNull ){
      return 0;    /* tab2 must be NOT NULL if tab1 is */
    }
    /* Default values for second and subsequent columns need to match. */
    if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){
      assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN );
      assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN );
      if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0)
       || (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken,
                                       pSrcCol->pDflt->u.zToken)!=0)
      ){
        return 0;    /* Default values must be the same for all columns */
      }
    }
  }
  for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
    if( IsUniqueIndex(pDestIdx) ){
      destHasUniqueIdx = 1;
    }
    for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
      if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
    }
    if( pSrcIdx==0 ){
      return 0;    /* pDestIdx has no corresponding index in pSrc */
    }
    if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema
         && sqlite3FaultSim(411)==SQLITE_OK ){
      /* The sqlite3FaultSim() call allows this corruption test to be
      ** bypassed during testing, in order to exercise other corruption tests
      ** further downstream. */
      return 0;   /* Corrupt schema - two indexes on the same btree */
    }
  }
#ifndef SQLITE_OMIT_CHECK
  if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
    return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
  }
#endif
#ifndef SQLITE_OMIT_FOREIGN_KEY
  /* Disallow the transfer optimization if the destination table constains
  ** any foreign key constraints.  This is more restrictive than necessary.
  ** But the main beneficiary of the transfer optimization is the VACUUM
  ** command, and the VACUUM command disables foreign key constraints.  So
  ** the extra complication to make this rule less restrictive is probably
  ** not worth the effort.  Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
  */
  if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
    return 0;
  }
#endif
  if( (db->flags & SQLITE_CountRows)!=0 ){
    return 0;  /* xfer opt does not play well with PRAGMA count_changes */
  }
 
  /* If we get this far, it means that the xfer optimization is at
  ** least a possibility, though it might only work if the destination
  ** table (tab1) is initially empty.
  */
#ifdef SQLITE_TEST
  sqlite3_xferopt_count++;
#endif
  iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
  v = sqlite3GetVdbe(pParse);
  sqlite3CodeVerifySchema(pParse, iDbSrc);
  iSrc = pParse->nTab++;
  iDest = pParse->nTab++;
  regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
  regData = sqlite3GetTempReg(pParse);
  regRowid = sqlite3GetTempReg(pParse);
  sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
  assert( HasRowid(pDest) || destHasUniqueIdx );
  if( (db->mDbFlags & DBFLAG_Vacuum)==0 && (
      (pDest->iPKey<0 && pDest->pIndex!=0)          /* (1) */
   || destHasUniqueIdx                              /* (2) */
   || (onError!=OE_Abort && onError!=OE_Rollback)   /* (3) */
  )){
    /* In some circumstances, we are able to run the xfer optimization
    ** only if the destination table is initially empty. Unless the
    ** DBFLAG_Vacuum flag is set, this block generates code to make
    ** that determination. If DBFLAG_Vacuum is set, then the destination
    ** table is always empty.
    **
    ** Conditions under which the destination must be empty:
    **
    ** (1) There is no INTEGER PRIMARY KEY but there are indices.
    **     (If the destination is not initially empty, the rowid fields
    **     of index entries might need to change.)
    **
    ** (2) The destination has a unique index.  (The xfer optimization
    **     is unable to test uniqueness.)
    **
    ** (3) onError is something other than OE_Abort and OE_Rollback.
    */
    addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
    emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
    sqlite3VdbeJumpHere(v, addr1);
  }
  if( HasRowid(pSrc) ){
    u8 insFlags;
    sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
    emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
    if( pDest->iPKey>=0 ){
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
      sqlite3VdbeVerifyAbortable(v, onError);
      addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
      VdbeCoverage(v);
      sqlite3RowidConstraint(pParse, onError, pDest);
      sqlite3VdbeJumpHere(v, addr2);
      autoIncStep(pParse, regAutoinc, regRowid);
    }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
      addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
    }else{
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
      assert( (pDest->tabFlags & TF_Autoincrement)==0 );
    }
    if( db->mDbFlags & DBFLAG_Vacuum ){
      sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
      insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT;
    }else{
      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND;
    }
    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
    sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
                      (char*)pDest, P4_TABLE);
    sqlite3VdbeChangeP5(v, insFlags);
    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
  }else{
    sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
    sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
  }
  for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
    u8 idxInsFlags = 0;
    for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
      if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
    }
    assert( pSrcIdx );
    sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
    sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
    VdbeComment((v, "%s", pSrcIdx->zName));
    sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
    sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
    sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
    VdbeComment((v, "%s", pDestIdx->zName));
    addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
    if( db->mDbFlags & DBFLAG_Vacuum ){
      /* This INSERT command is part of a VACUUM operation, which guarantees
      ** that the destination table is empty. If all indexed columns use
      ** collation sequence BINARY, then it can also be assumed that the
      ** index will be populated by inserting keys in strictly sorted
      ** order. In this case, instead of seeking within the b-tree as part
      ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the
      ** OP_IdxInsert to seek to the point within the b-tree where each key
      ** should be inserted. This is faster.
      **
      ** If any of the indexed columns use a collation sequence other than
      ** BINARY, this optimization is disabled. This is because the user
      ** might change the definition of a collation sequence and then run
      ** a VACUUM command. In that case keys may not be written in strictly
      ** sorted order.  */
      for(i=0; i<pSrcIdx->nColumn; i++){
        const char *zColl = pSrcIdx->azColl[i];
        if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
      }
      if( i==pSrcIdx->nColumn ){
        idxInsFlags = OPFLAG_USESEEKRESULT;
        sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
      }
    }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
      idxInsFlags |= OPFLAG_NCHANGE;
    }
    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
    sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
    sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr1);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
  }
  if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
  sqlite3ReleaseTempReg(pParse, regRowid);
  sqlite3ReleaseTempReg(pParse, regData);
  if( emptyDestTest ){
    sqlite3AutoincrementEnd(pParse);
    sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
    sqlite3VdbeJumpHere(v, emptyDestTest);

References ExprList::a, SrcList::a, Table::aCol, Column::affinity, ALWAYS, autoIncBegin(), autoIncStep(), Index::azColl, COLFLAG_GENERATED, COLFLAG_HIDDEN, COLFLAG_STORED, COLFLAG_VIRTUAL, Column::colFlags, Parse::db, DBFLAG_Vacuum, DBFLAG_VacuumInto, sqlite3::flags, HasRowid, Index::idxType, Table::iPKey, IsUniqueIndex, IsVirtual, Table::keyConf, sqlite3::mDbFlags, Table::nCol, Index::nColumn, ExprList::nExpr, Column::notNull, SrcList::nSrc, Parse::nTab, OE_Abort, OE_Default, OE_Rollback, Expr::op, OP_Close, OP_Goto, OP_Halt, OP_IdxInsert, OP_Insert, OP_NewRowid, OP_Next, OP_NotExists, OP_OpenRead, OP_OpenWrite, OP_Rewind, OP_RowData, OP_Rowid, OP_SeekEnd, OPFLAG_APPEND, OPFLAG_BULKCSR, OPFLAG_LASTROWID, OPFLAG_NCHANGE, OPFLAG_USESEEKRESULT, P4_TABLE, Table::pCheck, Column::pDflt, Select::pEList, ExprList::ExprList_item::pExpr, Table::pFKey, Select::pGroupBy, Table::pIndex, Select::pLimit, Index::pNext, Select::pOrderBy, Select::pPrior, Table::pSchema, Table::pSelect, SrcList::SrcList_item::pSelect, Select::pSrc, Select::pWhere, Select::pWith, Parse::pWith, Select::selFlags, SF_Distinct, sqlite3_stricmp(), sqlite3AutoincrementEnd(), sqlite3CodeVerifySchema(), sqlite3ExprCompare(), sqlite3ExprListCompare(), sqlite3FaultSim(), sqlite3GetTempReg(), sqlite3GetVdbe(), sqlite3LocateTableItem(), sqlite3OpenTable(), sqlite3ReleaseTempReg(), sqlite3RowidConstraint(), sqlite3SchemaToIndex(), sqlite3StrBINARY, sqlite3TableLock(), sqlite3TriggerList(), sqlite3VdbeAddOp0(), sqlite3VdbeAddOp1(), sqlite3VdbeAddOp2(), sqlite3VdbeAddOp3(), sqlite3VdbeAddOp4(), sqlite3VdbeChangeP5(), sqlite3VdbeJumpHere(), sqlite3VdbeSetP4KeyInfo(), sqlite3VdbeVerifyAbortable, SQLITE_CountRows, SQLITE_ForeignKeys, SQLITE_IDXTYPE_PRIMARYKEY, SQLITE_OK, Table::tabFlags, testcase, TF_Autoincrement, TK_ASTERISK, TK_SPAN, Table::tnum, Index::tnum, Expr::u, VdbeComment, VdbeCoverage, xferCompatibleIndex(), Column::zColl, Table::zName, Index::zName, and Expr::zToken.

Referenced by sqlite3Insert().

◆ yy_accept()

static void yy_accept ( yyParser * yypParser )

static

Definition at line 159030 of file sqlite3.c.

 {
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
  }
#endif
#ifndef YYNOERRORRECOVERY
  yypParser->yyerrcnt = -1;
#endif
  assert( yypParser->yytos==yypParser->yystack );
  /* Here code is inserted which will be executed whenever the

Referenced by sqlite3Parser().

◆ yy_destructor()

static void yy_destructor	(	yyParser *	yypParser,
		YYCODETYPE	yymajor,
		YYMINORTYPE *	yypminor )

static

Definition at line 156267 of file sqlite3.c.

 {
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
  switch( yymajor ){
    /* Here is inserted the actions which take place when a
    ** terminal or non-terminal is destroyed.  This can happen
    ** when the symbol is popped from the stack during a
    ** reduce or during error processing or when a parser is
    ** being destroyed before it is finished parsing.
    **
    ** Note: during a reduce, the only symbols destroyed are those
    ** which appear on the RHS of the rule, but which are *not* used
    ** inside the C code.
    */
/********* Begin destructor definitions ***************************************/
    case 200: /* select */
    case 234: /* selectnowith */
    case 235: /* oneselect */
    case 247: /* values */
{
sqlite3SelectDelete(pParse->db, (yypminor->yy539));
}
      break;
    case 211: /* term */
    case 212: /* expr */
    case 241: /* where_opt */
    case 243: /* having_opt */
    case 255: /* on_opt */
    case 271: /* case_operand */
    case 273: /* case_else */
    case 276: /* vinto */
    case 283: /* when_clause */
    case 288: /* key_opt */
    case 302: /* filter_clause */
{
sqlite3ExprDelete(pParse->db, (yypminor->yy202));
}
      break;
    case 216: /* eidlist_opt */
    case 226: /* sortlist */
    case 227: /* eidlist */
    case 239: /* selcollist */
    case 242: /* groupby_opt */
    case 244: /* orderby_opt */
    case 248: /* nexprlist */
    case 249: /* sclp */
    case 257: /* exprlist */
    case 262: /* setlist */
    case 270: /* paren_exprlist */
    case 272: /* case_exprlist */
    case 301: /* part_opt */
{
sqlite3ExprListDelete(pParse->db, (yypminor->yy242));
}
      break;
    case 233: /* fullname */
    case 240: /* from */
    case 251: /* seltablist */
    case 252: /* stl_prefix */
    case 258: /* xfullname */
{
sqlite3SrcListDelete(pParse->db, (yypminor->yy47));
}
      break;
    case 236: /* wqlist */
{
sqlite3WithDelete(pParse->db, (yypminor->yy131));
}
      break;
    case 246: /* window_clause */
    case 297: /* windowdefn_list */
{
sqlite3WindowListDelete(pParse->db, (yypminor->yy303));
}
      break;
    case 256: /* using_opt */
    case 259: /* idlist */
    case 264: /* idlist_opt */
{
sqlite3IdListDelete(pParse->db, (yypminor->yy600));
}
      break;
    case 266: /* filter_over */
    case 298: /* windowdefn */
    case 299: /* window */
    case 300: /* frame_opt */
    case 303: /* over_clause */
{
sqlite3WindowDelete(pParse->db, (yypminor->yy303));
}
      break;
    case 279: /* trigger_cmd_list */
    case 284: /* trigger_cmd */
{
sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy447));
}
      break;
    case 281: /* trigger_event */
{
sqlite3IdListDelete(pParse->db, (yypminor->yy230).b);
}
      break;
    case 305: /* frame_bound */
    case 306: /* frame_bound_s */
    case 307: /* frame_bound_e */
{
sqlite3ExprDelete(pParse->db, (yypminor->yy77).pExpr);

References Parse::db, sqlite3DeleteTriggerStep(), sqlite3ExprDelete(), sqlite3ExprListDelete(), sqlite3IdListDelete(), sqlite3ParserARG_FETCH, sqlite3ParserCTX_FETCH, sqlite3SelectDelete(), sqlite3SrcListDelete(), sqlite3WindowDelete(), sqlite3WindowListDelete(), sqlite3WithDelete(), YYMINORTYPE::yy131, YYMINORTYPE::yy202, YYMINORTYPE::yy230, YYMINORTYPE::yy242, YYMINORTYPE::yy303, YYMINORTYPE::yy447, YYMINORTYPE::yy47, YYMINORTYPE::yy539, YYMINORTYPE::yy600, and YYMINORTYPE::yy77.

Referenced by sqlite3Parser().

◆ yy_find_reduce_action()

static YYACTIONTYPE yy_find_reduce_action	(	YYACTIONTYPE	stateno,
		YYCODETYPE	iLookAhead )

static

Definition at line 156554 of file sqlite3.c.

 {
  int i;
#ifdef YYERRORSYMBOL
  if( stateno>YY_REDUCE_COUNT ){
    return yy_default[stateno];
  }
#else
  assert( stateno<=YY_REDUCE_COUNT );
#endif
  i = yy_reduce_ofst[stateno];
  assert( iLookAhead!=YYNOCODE );
  i += iLookAhead;
#ifdef YYERRORSYMBOL
  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
    return yy_default[stateno];
  }

Referenced by sqlite3Parser(), and yy_reduce().

◆ yy_find_shift_action()

static YYACTIONTYPE yy_find_shift_action	(	YYCODETYPE	iLookAhead,
		YYACTIONTYPE	stateno )

static

Definition at line 156489 of file sqlite3.c.

 {
  int i;
 
  if( stateno>YY_MAX_SHIFT ) return stateno;
  assert( stateno <= YY_SHIFT_COUNT );
#if defined(YYCOVERAGE)
  yycoverage[stateno][iLookAhead] = 1;
#endif
  do{
    i = yy_shift_ofst[stateno];
    assert( i>=0 );
    assert( i<=YY_ACTTAB_COUNT );
    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
    assert( iLookAhead!=YYNOCODE );
    assert( iLookAhead < YYNTOKEN );
    i += iLookAhead;
    assert( i<(int)YY_NLOOKAHEAD );
    if( yy_lookahead[i]!=iLookAhead ){
#ifdef YYFALLBACK
      YYCODETYPE iFallback;            /* Fallback token */
      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
      iFallback = yyFallback[iLookAhead];
      if( iFallback!=0 ){
#ifndef NDEBUG
        if( yyTraceFILE ){
          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
        }
#endif
        assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
        iLookAhead = iFallback;
        continue;
      }
#endif
#ifdef YYWILDCARD
      {
        int j = i - iLookAhead + YYWILDCARD;
        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
#ifndef NDEBUG
          if( yyTraceFILE ){
            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
               yyTracePrompt, yyTokenName[iLookAhead],
               yyTokenName[YYWILDCARD]);
          }
#endif /* NDEBUG */
          return yy_action[j];
        }
      }
#endif /* YYWILDCARD */
      return yy_default[stateno];

References yy_action, YY_ACTTAB_COUNT, yy_default, yy_lookahead, YY_MAX_SHIFT, YY_NLOOKAHEAD, YY_SHIFT_COUNT, yy_shift_ofst, YYCODETYPE, yyFallback, YYNOCODE, YYNTOKEN, and YYWILDCARD.

Referenced by sqlite3Parser().

◆ yy_pop_parser_stack()

static void yy_pop_parser_stack ( yyParser * pParser )

static

Definition at line 156391 of file sqlite3.c.

                                                  {
  yyStackEntry *yytos;
  assert( pParser->yytos!=0 );
  assert( pParser->yytos > pParser->yystack );
  yytos = pParser->yytos--;
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sPopping %s\n",

References yyStackEntry::major, yyParser::yystack, and yyParser::yytos.

Referenced by sqlite3Parser().

◆ yy_reduce()

static YYACTIONTYPE yy_reduce	(	yyParser *	yypParser,
		unsigned int	yyruleno,
		int	yyLookahead,
		sqlite3ParserTOKENTYPE yyLookaheadToken	sqlite3ParserCTX_PDECL )

static

Definition at line 157457 of file sqlite3.c.

 {
  int yygoto;                     /* The next state */
  YYACTIONTYPE yyact;             /* The next action */
  yyStackEntry *yymsp;            /* The top of the parser's stack */
  int yysize;                     /* Amount to pop the stack */
  sqlite3ParserARG_FETCH
  (void)yyLookahead;
  (void)yyLookaheadToken;
  yymsp = yypParser->yytos;
#ifndef NDEBUG
  if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
    yysize = yyRuleInfoNRhs[yyruleno];
    if( yysize ){
      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
        yyTracePrompt,
        yyruleno, yyRuleName[yyruleno],
        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
        yymsp[yysize].stateno);
    }else{
      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
    }
  }
#endif /* NDEBUG */
 
  /* Check that the stack is large enough to grow by a single entry
  ** if the RHS of the rule is empty.  This ensures that there is room
  ** enough on the stack to push the LHS value */
  if( yyRuleInfoNRhs[yyruleno]==0 ){
#ifdef YYTRACKMAXSTACKDEPTH
    if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
      yypParser->yyhwm++;
      assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
    }
#endif
#if YYSTACKDEPTH>0
    if( yypParser->yytos>=yypParser->yystackEnd ){
      yyStackOverflow(yypParser);
      /* The call to yyStackOverflow() above pops the stack until it is
      ** empty, causing the main parser loop to exit.  So the return value
      ** is never used and does not matter. */
      return 0;
    }
#else
    if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
      if( yyGrowStack(yypParser) ){
        yyStackOverflow(yypParser);
        /* The call to yyStackOverflow() above pops the stack until it is
        ** empty, causing the main parser loop to exit.  So the return value
        ** is never used and does not matter. */
        return 0;
      }
      yymsp = yypParser->yytos;
    }
#endif
  }
 
  switch( yyruleno ){
  /* Beginning here are the reduction cases.  A typical example
  ** follows:
  **   case 0:
  **  #line <lineno> <grammarfile>
  **     { ... }           // User supplied code
  **  #line <lineno> <thisfile>
  **     break;
  */
/********** Begin reduce actions **********************************************/
        YYMINORTYPE yylhsminor;
      case 0: /* explain ::= EXPLAIN */
{ pParse->explain = 1; }
        break;
      case 1: /* explain ::= EXPLAIN QUERY PLAN */
{ pParse->explain = 2; }
        break;
      case 2: /* cmdx ::= cmd */
{ sqlite3FinishCoding(pParse); }
        break;
      case 3: /* cmd ::= BEGIN transtype trans_opt */
{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy192);}
        break;
      case 4: /* transtype ::= */
{yymsp[1].minor.yy192 = TK_DEFERRED;}
        break;
      case 5: /* transtype ::= DEFERRED */
      case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
      case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
      case 306: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==306);
{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/}
        break;
      case 8: /* cmd ::= COMMIT|END trans_opt */
      case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
{sqlite3EndTransaction(pParse,yymsp[-1].major);}
        break;
      case 10: /* cmd ::= SAVEPOINT nm */
{
  sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
}
        break;
      case 11: /* cmd ::= RELEASE savepoint_opt nm */
{
  sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
}
        break;
      case 12: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
{
  sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
}
        break;
      case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
{
   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy192,0,0,yymsp[-2].minor.yy192);
}
        break;
      case 14: /* createkw ::= CREATE */
{disableLookaside(pParse);}
        break;
      case 15: /* ifnotexists ::= */
      case 18: /* temp ::= */ yytestcase(yyruleno==18);
      case 21: /* table_options ::= */ yytestcase(yyruleno==21);
      case 45: /* autoinc ::= */ yytestcase(yyruleno==45);
      case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60);
      case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70);
      case 79: /* ifexists ::= */ yytestcase(yyruleno==79);
      case 96: /* distinct ::= */ yytestcase(yyruleno==96);
      case 232: /* collate ::= */ yytestcase(yyruleno==232);
{yymsp[1].minor.yy192 = 0;}
        break;
      case 16: /* ifnotexists ::= IF NOT EXISTS */
{yymsp[-2].minor.yy192 = 1;}
        break;
      case 17: /* temp ::= TEMP */
      case 46: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==46);
{yymsp[0].minor.yy192 = 1;}
        break;
      case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
{
  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy192,0);
}
        break;
      case 20: /* create_table_args ::= AS select */
{
  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy539);
  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539);
}
        break;
      case 22: /* table_options ::= WITHOUT nm */
{
  if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
    yymsp[-1].minor.yy192 = TF_WithoutRowid | TF_NoVisibleRowid;
  }else{
    yymsp[-1].minor.yy192 = 0;
    sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
  }
}
        break;
      case 23: /* columnname ::= nm typetoken */
{sqlite3AddColumn(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
        break;
      case 24: /* typetoken ::= */
      case 63: /* conslist_opt ::= */ yytestcase(yyruleno==63);
      case 102: /* as ::= */ yytestcase(yyruleno==102);
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
        break;
      case 25: /* typetoken ::= typename LP signed RP */
{
  yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
}
        break;
      case 26: /* typetoken ::= typename LP signed COMMA signed RP */
{
  yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
}
        break;
      case 27: /* typename ::= typename ID|STRING */
{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
        break;
      case 28: /* scanpt ::= */
{
  assert( yyLookahead!=YYNOCODE );
  yymsp[1].minor.yy436 = yyLookaheadToken.z;
}
        break;
      case 29: /* scantok ::= */
{
  assert( yyLookahead!=YYNOCODE );
  yymsp[1].minor.yy0 = yyLookaheadToken;
}
        break;
      case 30: /* ccons ::= CONSTRAINT nm */
      case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65);
{pParse->constraintName = yymsp[0].minor.yy0;}
        break;
      case 31: /* ccons ::= DEFAULT scantok term */
{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
        break;
      case 32: /* ccons ::= DEFAULT LP expr RP */
{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
        break;
      case 33: /* ccons ::= DEFAULT PLUS scantok term */
{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
        break;
      case 34: /* ccons ::= DEFAULT MINUS scantok term */
{
  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy202, 0);
  sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
}
        break;
      case 35: /* ccons ::= DEFAULT scantok ID|INDEXED */
{
  Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0);
  if( p ){
    sqlite3ExprIdToTrueFalse(p);
    testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );
  }
    sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
}
        break;
      case 36: /* ccons ::= NOT NULL onconf */
{sqlite3AddNotNull(pParse, yymsp[0].minor.yy192);}
        break;
      case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy192,yymsp[0].minor.yy192,yymsp[-2].minor.yy192);}
        break;
      case 38: /* ccons ::= UNIQUE onconf */
{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy192,0,0,0,0,
                                   SQLITE_IDXTYPE_UNIQUE);}
        break;
      case 39: /* ccons ::= CHECK LP expr RP */
{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy202);}
        break;
      case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */
{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy242,yymsp[0].minor.yy192);}
        break;
      case 41: /* ccons ::= defer_subclause */
{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy192);}
        break;
      case 42: /* ccons ::= COLLATE ID|STRING */
{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
        break;
      case 43: /* generated ::= LP expr RP */
{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy202,0);}
        break;
      case 44: /* generated ::= LP expr RP ID */
{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy202,&yymsp[0].minor.yy0);}
        break;
      case 47: /* refargs ::= */
{ yymsp[1].minor.yy192 = OE_None*0x0101; /* EV: R-19803-45884 */}
        break;
      case 48: /* refargs ::= refargs refarg */
{ yymsp[-1].minor.yy192 = (yymsp[-1].minor.yy192 & ~yymsp[0].minor.yy207.mask) | yymsp[0].minor.yy207.value; }
        break;
      case 49: /* refarg ::= MATCH nm */
{ yymsp[-1].minor.yy207.value = 0;     yymsp[-1].minor.yy207.mask = 0x000000; }
        break;
      case 50: /* refarg ::= ON INSERT refact */
{ yymsp[-2].minor.yy207.value = 0;     yymsp[-2].minor.yy207.mask = 0x000000; }
        break;
      case 51: /* refarg ::= ON DELETE refact */
{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192;     yymsp[-2].minor.yy207.mask = 0x0000ff; }
        break;
      case 52: /* refarg ::= ON UPDATE refact */
{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192<<8;  yymsp[-2].minor.yy207.mask = 0x00ff00; }
        break;
      case 53: /* refact ::= SET NULL */
{ yymsp[-1].minor.yy192 = OE_SetNull;  /* EV: R-33326-45252 */}
        break;
      case 54: /* refact ::= SET DEFAULT */
{ yymsp[-1].minor.yy192 = OE_SetDflt;  /* EV: R-33326-45252 */}
        break;
      case 55: /* refact ::= CASCADE */
{ yymsp[0].minor.yy192 = OE_Cascade;  /* EV: R-33326-45252 */}
        break;
      case 56: /* refact ::= RESTRICT */
{ yymsp[0].minor.yy192 = OE_Restrict; /* EV: R-33326-45252 */}
        break;
      case 57: /* refact ::= NO ACTION */
{ yymsp[-1].minor.yy192 = OE_None;     /* EV: R-33326-45252 */}
        break;
      case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
{yymsp[-2].minor.yy192 = 0;}
        break;
      case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
      case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74);
      case 162: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==162);
{yymsp[-1].minor.yy192 = yymsp[0].minor.yy192;}
        break;
      case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
      case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78);
      case 204: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==204);
      case 207: /* in_op ::= NOT IN */ yytestcase(yyruleno==207);
      case 233: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==233);
{yymsp[-1].minor.yy192 = 1;}
        break;
      case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
{yymsp[-1].minor.yy192 = 0;}
        break;
      case 64: /* tconscomma ::= COMMA */
{pParse->constraintName.n = 0;}
        break;
      case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy242,yymsp[0].minor.yy192,yymsp[-2].minor.yy192,0);}
        break;
      case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */
{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy242,yymsp[0].minor.yy192,0,0,0,0,
                                       SQLITE_IDXTYPE_UNIQUE);}
        break;
      case 68: /* tcons ::= CHECK LP expr RP onconf */
{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy202);}
        break;
      case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
{
    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy242, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[-1].minor.yy192);
    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy192);
}
        break;
      case 71: /* onconf ::= */
      case 73: /* orconf ::= */ yytestcase(yyruleno==73);
{yymsp[1].minor.yy192 = OE_Default;}
        break;
      case 72: /* onconf ::= ON CONFLICT resolvetype */
{yymsp[-2].minor.yy192 = yymsp[0].minor.yy192;}
        break;
      case 75: /* resolvetype ::= IGNORE */
{yymsp[0].minor.yy192 = OE_Ignore;}
        break;
      case 76: /* resolvetype ::= REPLACE */
      case 163: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==163);
{yymsp[0].minor.yy192 = OE_Replace;}
        break;
      case 77: /* cmd ::= DROP TABLE ifexists fullname */
{
  sqlite3DropTable(pParse, yymsp[0].minor.yy47, 0, yymsp[-1].minor.yy192);
}
        break;
      case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
{
  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[0].minor.yy539, yymsp[-7].minor.yy192, yymsp[-5].minor.yy192);
}
        break;
      case 81: /* cmd ::= DROP VIEW ifexists fullname */
{
  sqlite3DropTable(pParse, yymsp[0].minor.yy47, 1, yymsp[-1].minor.yy192);
}
        break;
      case 82: /* cmd ::= select */
{
  SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
  sqlite3Select(pParse, yymsp[0].minor.yy539, &dest);
  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539);
}
        break;
      case 83: /* select ::= WITH wqlist selectnowith */
{
  Select *p = yymsp[0].minor.yy539;
  if( p ){
    p->pWith = yymsp[-1].minor.yy131;
    parserDoubleLinkSelect(pParse, p);
  }else{
    sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131);
  }
  yymsp[-2].minor.yy539 = p;
}
        break;
      case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */
{
  Select *p = yymsp[0].minor.yy539;
  if( p ){
    p->pWith = yymsp[-1].minor.yy131;
    parserDoubleLinkSelect(pParse, p);
  }else{
    sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131);
  }
  yymsp[-3].minor.yy539 = p;
}
        break;
      case 85: /* select ::= selectnowith */
{
  Select *p = yymsp[0].minor.yy539;
  if( p ){
    parserDoubleLinkSelect(pParse, p);
  }
  yymsp[0].minor.yy539 = p; /*A-overwrites-X*/
}
        break;
      case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */
{
  Select *pRhs = yymsp[0].minor.yy539;
  Select *pLhs = yymsp[-2].minor.yy539;
  if( pRhs && pRhs->pPrior ){
    SrcList *pFrom;
    Token x;
    x.n = 0;
    parserDoubleLinkSelect(pParse, pRhs);
    pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
    pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
  }
  if( pRhs ){
    pRhs->op = (u8)yymsp[-1].minor.yy192;
    pRhs->pPrior = pLhs;
    if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
    pRhs->selFlags &= ~SF_MultiValue;
    if( yymsp[-1].minor.yy192!=TK_ALL ) pParse->hasCompound = 1;
  }else{
    sqlite3SelectDelete(pParse->db, pLhs);
  }
  yymsp[-2].minor.yy539 = pRhs;
}
        break;
      case 87: /* multiselect_op ::= UNION */
      case 89: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==89);
{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-OP*/}
        break;
      case 88: /* multiselect_op ::= UNION ALL */
{yymsp[-1].minor.yy192 = TK_ALL;}
        break;
      case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
{
  yymsp[-8].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy242,yymsp[-5].minor.yy47,yymsp[-4].minor.yy202,yymsp[-3].minor.yy242,yymsp[-2].minor.yy202,yymsp[-1].minor.yy242,yymsp[-7].minor.yy192,yymsp[0].minor.yy202);
}
        break;
      case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
{
  yymsp[-9].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy242,yymsp[-6].minor.yy47,yymsp[-5].minor.yy202,yymsp[-4].minor.yy242,yymsp[-3].minor.yy202,yymsp[-1].minor.yy242,yymsp[-8].minor.yy192,yymsp[0].minor.yy202);
  if( yymsp[-9].minor.yy539 ){
    yymsp[-9].minor.yy539->pWinDefn = yymsp[-2].minor.yy303;
  }else{
    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy303);
  }
}
        break;
      case 92: /* values ::= VALUES LP nexprlist RP */
{
  yymsp[-3].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values,0);
}
        break;
      case 93: /* values ::= values COMMA LP nexprlist RP */
{
  Select *pRight, *pLeft = yymsp[-4].minor.yy539;
  pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values|SF_MultiValue,0);
  if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
  if( pRight ){
    pRight->op = TK_ALL;
    pRight->pPrior = pLeft;
    yymsp[-4].minor.yy539 = pRight;
  }else{
    yymsp[-4].minor.yy539 = pLeft;
  }
}
        break;
      case 94: /* distinct ::= DISTINCT */
{yymsp[0].minor.yy192 = SF_Distinct;}
        break;
      case 95: /* distinct ::= ALL */
{yymsp[0].minor.yy192 = SF_All;}
        break;
      case 97: /* sclp ::= */
      case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130);
      case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140);
      case 220: /* exprlist ::= */ yytestcase(yyruleno==220);
      case 223: /* paren_exprlist ::= */ yytestcase(yyruleno==223);
      case 228: /* eidlist_opt ::= */ yytestcase(yyruleno==228);
{yymsp[1].minor.yy242 = 0;}
        break;
      case 98: /* selcollist ::= sclp scanpt expr scanpt as */
{
   yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[-2].minor.yy202);
   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[0].minor.yy0, 1);
   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy242,yymsp[-3].minor.yy436,yymsp[-1].minor.yy436);
}
        break;
      case 99: /* selcollist ::= sclp scanpt STAR */
{
  Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
  yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy242, p);
}
        break;
      case 100: /* selcollist ::= sclp scanpt nm DOT STAR */
{
  Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
  Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
  Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, pDot);
}
        break;
      case 101: /* as ::= AS nm */
      case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112);
      case 244: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==244);
      case 245: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==245);
{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
        break;
      case 103: /* from ::= */
      case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106);
{yymsp[1].minor.yy47 = 0;}
        break;
      case 104: /* from ::= FROM seltablist */
{
  yymsp[-1].minor.yy47 = yymsp[0].minor.yy47;
  sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy47);
}
        break;
      case 105: /* stl_prefix ::= seltablist joinop */
{
   if( ALWAYS(yymsp[-1].minor.yy47 && yymsp[-1].minor.yy47->nSrc>0) ) yymsp[-1].minor.yy47->a[yymsp[-1].minor.yy47->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy192;
}
        break;
      case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
{
  yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
  sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy47, &yymsp[-2].minor.yy0);
}
        break;
      case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
{
  yymsp[-8].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy47,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
  sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy47, yymsp[-4].minor.yy242);
}
        break;
      case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
{
    yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy539,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
  }
        break;
      case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
{
    if( yymsp[-6].minor.yy47==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy202==0 && yymsp[0].minor.yy600==0 ){
      yymsp[-6].minor.yy47 = yymsp[-4].minor.yy47;
    }else if( yymsp[-4].minor.yy47->nSrc==1 ){
      yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
      if( yymsp[-6].minor.yy47 ){
        struct SrcList_item *pNew = &yymsp[-6].minor.yy47->a[yymsp[-6].minor.yy47->nSrc-1];
        struct SrcList_item *pOld = yymsp[-4].minor.yy47->a;
        pNew->zName = pOld->zName;
        pNew->zDatabase = pOld->zDatabase;
        pNew->pSelect = pOld->pSelect;
        if( pOld->fg.isTabFunc ){
          pNew->u1.pFuncArg = pOld->u1.pFuncArg;
          pOld->u1.pFuncArg = 0;
          pOld->fg.isTabFunc = 0;
          pNew->fg.isTabFunc = 1;
        }
        pOld->zName = pOld->zDatabase = 0;
        pOld->pSelect = 0;
      }
      sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy47);
    }else{
      Select *pSubquery;
      sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy47);
      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy47,0,0,0,0,SF_NestedFrom,0);
      yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
    }
  }
        break;
      case 111: /* dbnm ::= */
      case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125);
{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
        break;
      case 113: /* fullname ::= nm */
{
  yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
  if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0);
}
  yymsp[0].minor.yy47 = yylhsminor.yy47;
        break;
      case 114: /* fullname ::= nm DOT nm */
{
  yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
  if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0);
}
  yymsp[-2].minor.yy47 = yylhsminor.yy47;
        break;
      case 115: /* xfullname ::= nm */
{yymsp[0].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
        break;
      case 116: /* xfullname ::= nm DOT nm */
{yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
        break;
      case 117: /* xfullname ::= nm DOT nm AS nm */
{
   yymsp[-4].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
   if( yymsp[-4].minor.yy47 ) yymsp[-4].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
}
        break;
      case 118: /* xfullname ::= nm AS nm */
{
   yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
   if( yymsp[-2].minor.yy47 ) yymsp[-2].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
}
        break;
      case 119: /* joinop ::= COMMA|JOIN */
{ yymsp[0].minor.yy192 = JT_INNER; }
        break;
      case 120: /* joinop ::= JOIN_KW JOIN */
{yymsp[-1].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
        break;
      case 121: /* joinop ::= JOIN_KW nm JOIN */
{yymsp[-2].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
        break;
      case 122: /* joinop ::= JOIN_KW nm nm JOIN */
{yymsp[-3].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
        break;
      case 123: /* on_opt ::= ON expr */
      case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143);
      case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150);
      case 216: /* case_else ::= ELSE expr */ yytestcase(yyruleno==216);
      case 237: /* vinto ::= INTO expr */ yytestcase(yyruleno==237);
{yymsp[-1].minor.yy202 = yymsp[0].minor.yy202;}
        break;
      case 124: /* on_opt ::= */
      case 142: /* having_opt ::= */ yytestcase(yyruleno==142);
      case 144: /* limit_opt ::= */ yytestcase(yyruleno==144);
      case 149: /* where_opt ::= */ yytestcase(yyruleno==149);
      case 217: /* case_else ::= */ yytestcase(yyruleno==217);
      case 219: /* case_operand ::= */ yytestcase(yyruleno==219);
      case 238: /* vinto ::= */ yytestcase(yyruleno==238);
{yymsp[1].minor.yy202 = 0;}
        break;
      case 126: /* indexed_opt ::= INDEXED BY nm */
{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
        break;
      case 127: /* indexed_opt ::= NOT INDEXED */
{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
        break;
      case 128: /* using_opt ::= USING LP idlist RP */
{yymsp[-3].minor.yy600 = yymsp[-1].minor.yy600;}
        break;
      case 129: /* using_opt ::= */
      case 164: /* idlist_opt ::= */ yytestcase(yyruleno==164);
{yymsp[1].minor.yy600 = 0;}
        break;
      case 131: /* orderby_opt ::= ORDER BY sortlist */
      case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141);
{yymsp[-2].minor.yy242 = yymsp[0].minor.yy242;}
        break;
      case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */
{
  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202);
  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192);
}
        break;
      case 133: /* sortlist ::= expr sortorder nulls */
{
  yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy202); /*A-overwrites-Y*/
  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192);
}
        break;
      case 134: /* sortorder ::= ASC */
{yymsp[0].minor.yy192 = SQLITE_SO_ASC;}
        break;
      case 135: /* sortorder ::= DESC */
{yymsp[0].minor.yy192 = SQLITE_SO_DESC;}
        break;
      case 136: /* sortorder ::= */
      case 139: /* nulls ::= */ yytestcase(yyruleno==139);
{yymsp[1].minor.yy192 = SQLITE_SO_UNDEFINED;}
        break;
      case 137: /* nulls ::= NULLS FIRST */
{yymsp[-1].minor.yy192 = SQLITE_SO_ASC;}
        break;
      case 138: /* nulls ::= NULLS LAST */
{yymsp[-1].minor.yy192 = SQLITE_SO_DESC;}
        break;
      case 145: /* limit_opt ::= LIMIT expr */
{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,0);}
        break;
      case 146: /* limit_opt ::= LIMIT expr OFFSET expr */
{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
        break;
      case 147: /* limit_opt ::= LIMIT expr COMMA expr */
{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,yymsp[-2].minor.yy202);}
        break;
      case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy47, &yymsp[-1].minor.yy0);
  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy47,yymsp[0].minor.yy202,0,0);
}
        break;
      case 151: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy47, &yymsp[-4].minor.yy0);
  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy242,"set list");
  yymsp[-5].minor.yy47 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy47, yymsp[-1].minor.yy47);
  sqlite3Update(pParse,yymsp[-5].minor.yy47,yymsp[-2].minor.yy242,yymsp[0].minor.yy202,yymsp[-6].minor.yy192,0,0,0);
}
        break;
      case 152: /* setlist ::= setlist COMMA nm EQ expr */
{
  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[0].minor.yy202);
  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, 1);
}
        break;
      case 153: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
{
  yymsp[-6].minor.yy242 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy242, yymsp[-3].minor.yy600, yymsp[0].minor.yy202);
}
        break;
      case 154: /* setlist ::= nm EQ expr */
{
  yylhsminor.yy242 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy202);
  sqlite3ExprListSetName(pParse, yylhsminor.yy242, &yymsp[-2].minor.yy0, 1);
}
  yymsp[-2].minor.yy242 = yylhsminor.yy242;
        break;
      case 155: /* setlist ::= LP idlist RP EQ expr */
{
  yymsp[-4].minor.yy242 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy600, yymsp[0].minor.yy202);
}
        break;
      case 156: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
{
  sqlite3Insert(pParse, yymsp[-3].minor.yy47, yymsp[-1].minor.yy539, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, yymsp[0].minor.yy318);
}
        break;
      case 157: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
{
  sqlite3Insert(pParse, yymsp[-3].minor.yy47, 0, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, 0);
}
        break;
      case 158: /* upsert ::= */
{ yymsp[1].minor.yy318 = 0; }
        break;
      case 159: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
{ yymsp[-10].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-7].minor.yy242,yymsp[-5].minor.yy202,yymsp[-1].minor.yy242,yymsp[0].minor.yy202);}
        break;
      case 160: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
{ yymsp[-7].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202,0,0); }
        break;
      case 161: /* upsert ::= ON CONFLICT DO NOTHING */
{ yymsp[-3].minor.yy318 = sqlite3UpsertNew(pParse->db,0,0,0,0); }
        break;
      case 165: /* idlist_opt ::= LP idlist RP */
{yymsp[-2].minor.yy600 = yymsp[-1].minor.yy600;}
        break;
      case 166: /* idlist ::= idlist COMMA nm */
{yymsp[-2].minor.yy600 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy600,&yymsp[0].minor.yy0);}
        break;
      case 167: /* idlist ::= nm */
{yymsp[0].minor.yy600 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
        break;
      case 168: /* expr ::= LP expr RP */
{yymsp[-2].minor.yy202 = yymsp[-1].minor.yy202;}
        break;
      case 169: /* expr ::= ID|INDEXED */
      case 170: /* expr ::= JOIN_KW */ yytestcase(yyruleno==170);
{yymsp[0].minor.yy202=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
        break;
      case 171: /* expr ::= nm DOT nm */
{
  Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
  Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
  if( IN_RENAME_OBJECT ){
    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
    sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
  }
  yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
}
  yymsp[-2].minor.yy202 = yylhsminor.yy202;
        break;
      case 172: /* expr ::= nm DOT nm DOT nm */
{
  Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1);
  Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
  Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
  Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
  if( IN_RENAME_OBJECT ){
    sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
  }
  yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
}
  yymsp[-4].minor.yy202 = yylhsminor.yy202;
        break;
      case 173: /* term ::= NULL|FLOAT|BLOB */
      case 174: /* term ::= STRING */ yytestcase(yyruleno==174);
{yymsp[0].minor.yy202=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
        break;
      case 175: /* term ::= INTEGER */
{
  yylhsminor.yy202 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
}
  yymsp[0].minor.yy202 = yylhsminor.yy202;
        break;
      case 176: /* expr ::= VARIABLE */
{
  if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
    u32 n = yymsp[0].minor.yy0.n;
    yymsp[0].minor.yy202 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy202, n);
  }else{
    /* When doing a nested parse, one can include terms in an expression
    ** that look like this:   #1 #2 ...  These terms refer to registers
    ** in the virtual machine.  #N is the N-th register. */
    Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
    assert( t.n>=2 );
    if( pParse->nested==0 ){
      sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
      yymsp[0].minor.yy202 = 0;
    }else{
      yymsp[0].minor.yy202 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
      if( yymsp[0].minor.yy202 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy202->iTable);
    }
  }
}
        break;
      case 177: /* expr ::= expr COLLATE ID|STRING */
{
  yymsp[-2].minor.yy202 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy202, &yymsp[0].minor.yy0, 1);
}
        break;
      case 178: /* expr ::= CAST LP expr AS typetoken RP */
{
  yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy202, yymsp[-3].minor.yy202, 0);
}
        break;
      case 179: /* expr ::= ID|INDEXED LP distinct exprlist RP */
{
  yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy192);
}
  yymsp[-4].minor.yy202 = yylhsminor.yy202;
        break;
      case 180: /* expr ::= ID|INDEXED LP STAR RP */
{
  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
}
  yymsp[-3].minor.yy202 = yylhsminor.yy202;
        break;
      case 181: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
{
  yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy242, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy192);
  sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303);
}
  yymsp[-5].minor.yy202 = yylhsminor.yy202;
        break;
      case 182: /* expr ::= ID|INDEXED LP STAR RP filter_over */
{
  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
  sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303);
}
  yymsp[-4].minor.yy202 = yylhsminor.yy202;
        break;
      case 183: /* term ::= CTIME_KW */
{
  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
}
  yymsp[0].minor.yy202 = yylhsminor.yy202;
        break;
      case 184: /* expr ::= LP nexprlist COMMA expr RP */
{
  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202);
  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
  if( yymsp[-4].minor.yy202 ){
    yymsp[-4].minor.yy202->x.pList = pList;
    if( ALWAYS(pList->nExpr) ){
      yymsp[-4].minor.yy202->flags |= pList->a[0].pExpr->flags & EP_Propagate;
    }
  }else{
    sqlite3ExprListDelete(pParse->db, pList);
  }
}
        break;
      case 185: /* expr ::= expr AND expr */
{yymsp[-2].minor.yy202=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
        break;
      case 186: /* expr ::= expr OR expr */
      case 187: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==187);
      case 188: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==188);
      case 189: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==189);
      case 190: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==190);
      case 191: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==191);
      case 192: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==192);
{yymsp[-2].minor.yy202=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
        break;
      case 193: /* likeop ::= NOT LIKE_KW|MATCH */
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
        break;
      case 194: /* expr ::= expr likeop expr */
{
  ExprList *pList;
  int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
  yymsp[-1].minor.yy0.n &= 0x7fffffff;
  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy202);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy202);
  yymsp[-2].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
  if( bNot ) yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy202, 0);
  if( yymsp[-2].minor.yy202 ) yymsp[-2].minor.yy202->flags |= EP_InfixFunc;
}
        break;
      case 195: /* expr ::= expr likeop expr ESCAPE expr */
{
  ExprList *pList;
  int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
  yymsp[-3].minor.yy0.n &= 0x7fffffff;
  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy202);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202);
  yymsp[-4].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
  if( bNot ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
  if( yymsp[-4].minor.yy202 ) yymsp[-4].minor.yy202->flags |= EP_InfixFunc;
}
        break;
      case 196: /* expr ::= expr ISNULL|NOTNULL */
{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy202,0);}
        break;
      case 197: /* expr ::= expr NOT NULL */
{yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy202,0);}
        break;
      case 198: /* expr ::= expr IS expr */
{
  yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);
  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-2].minor.yy202, TK_ISNULL);
}
        break;
      case 199: /* expr ::= expr IS NOT expr */
{
  yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy202,yymsp[0].minor.yy202);
  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-3].minor.yy202, TK_NOTNULL);
}
        break;
      case 200: /* expr ::= NOT expr */
      case 201: /* expr ::= BITNOT expr */ yytestcase(yyruleno==201);
{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy202, 0);/*A-overwrites-B*/}
        break;
      case 202: /* expr ::= PLUS|MINUS expr */
{
  yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy202, 0);
  /*A-overwrites-B*/
}
        break;
      case 203: /* between_op ::= BETWEEN */
      case 206: /* in_op ::= IN */ yytestcase(yyruleno==206);
{yymsp[0].minor.yy192 = 0;}
        break;
      case 205: /* expr ::= expr between_op expr AND expr */
{
  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202);
  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy202, 0);
  if( yymsp[-4].minor.yy202 ){
    yymsp[-4].minor.yy202->x.pList = pList;
  }else{
    sqlite3ExprListDelete(pParse->db, pList);
  }
  if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
}
        break;
      case 208: /* expr ::= expr in_op LP exprlist RP */
{
    if( yymsp[-1].minor.yy242==0 ){
      /* Expressions of the form
      **
      **      expr1 IN ()
      **      expr1 NOT IN ()
      **
      ** simplify to constants 0 (false) and 1 (true), respectively,
      ** regardless of the value of expr1.
      */
      sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy202);
      yymsp[-4].minor.yy202 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy192 ? "1" : "0");
    }else if( yymsp[-1].minor.yy242->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy242->a[0].pExpr) ){
      Expr *pRHS = yymsp[-1].minor.yy242->a[0].pExpr;
      yymsp[-1].minor.yy242->a[0].pExpr = 0;
      sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242);
      pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
      yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy202, pRHS);
      if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
    }else{
      yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
      if( yymsp[-4].minor.yy202 ){
        yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy242;
        sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202);
      }else{
        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242);
      }
      if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
    }
  }
        break;
      case 209: /* expr ::= LP select RP */
{
    yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy202, yymsp[-1].minor.yy539);
  }
        break;
      case 210: /* expr ::= expr in_op LP select RP */
{
    yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, yymsp[-1].minor.yy539);
    if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
  }
        break;
      case 211: /* expr ::= expr in_op nm dbnm paren_exprlist */
{
    SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
    Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
    if( yymsp[0].minor.yy242 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy242);
    yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, pSelect);
    if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
  }
        break;
      case 212: /* expr ::= EXISTS LP select RP */
{
    Expr *p;
    p = yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy539);
  }
        break;
      case 213: /* expr ::= CASE case_operand case_exprlist case_else END */
{
  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy202, 0);
  if( yymsp[-4].minor.yy202 ){
    yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy202 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[-1].minor.yy202) : yymsp[-2].minor.yy242;
    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202);
  }else{
    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy242);
    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy202);
  }
}
        break;
      case 214: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
{
  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[-2].minor.yy202);
  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[0].minor.yy202);
}
        break;
      case 215: /* case_exprlist ::= WHEN expr THEN expr */
{
  yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
  yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy242, yymsp[0].minor.yy202);
}
        break;
      case 218: /* case_operand ::= expr */
{yymsp[0].minor.yy202 = yymsp[0].minor.yy202; /*A-overwrites-X*/}
        break;
      case 221: /* nexprlist ::= nexprlist COMMA expr */
{yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[0].minor.yy202);}
        break;
      case 222: /* nexprlist ::= expr */
{yymsp[0].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy202); /*A-overwrites-Y*/}
        break;
      case 224: /* paren_exprlist ::= LP exprlist RP */
      case 229: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==229);
{yymsp[-2].minor.yy242 = yymsp[-1].minor.yy242;}
        break;
      case 225: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
{
  sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy242, yymsp[-10].minor.yy192,
                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy202, SQLITE_SO_ASC, yymsp[-8].minor.yy192, SQLITE_IDXTYPE_APPDEF);
  if( IN_RENAME_OBJECT && pParse->pNewIndex ){
    sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
  }
}
        break;
      case 226: /* uniqueflag ::= UNIQUE */
      case 268: /* raisetype ::= ABORT */ yytestcase(yyruleno==268);
{yymsp[0].minor.yy192 = OE_Abort;}
        break;
      case 227: /* uniqueflag ::= */
{yymsp[1].minor.yy192 = OE_None;}
        break;
      case 230: /* eidlist ::= eidlist COMMA nm collate sortorder */
{
  yymsp[-4].minor.yy242 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192);
}
        break;
      case 231: /* eidlist ::= nm collate sortorder */
{
  yymsp[-2].minor.yy242 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); /*A-overwrites-Y*/
}
        break;
      case 234: /* cmd ::= DROP INDEX ifexists fullname */
{sqlite3DropIndex(pParse, yymsp[0].minor.yy47, yymsp[-1].minor.yy192);}
        break;
      case 235: /* cmd ::= VACUUM vinto */
{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy202);}
        break;
      case 236: /* cmd ::= VACUUM nm vinto */
{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy202);}
        break;
      case 239: /* cmd ::= PRAGMA nm dbnm */
{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
        break;
      case 240: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
        break;
      case 241: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
        break;
      case 242: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
        break;
      case 243: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
        break;
      case 246: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
{
  Token all;
  all.z = yymsp[-3].minor.yy0.z;
  all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy447, &all);
}
        break;
      case 247: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
{
  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy192, yymsp[-4].minor.yy230.a, yymsp[-4].minor.yy230.b, yymsp[-2].minor.yy47, yymsp[0].minor.yy202, yymsp[-10].minor.yy192, yymsp[-8].minor.yy192);
  yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
}
        break;
      case 248: /* trigger_time ::= BEFORE|AFTER */
{ yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/ }
        break;
      case 249: /* trigger_time ::= INSTEAD OF */
{ yymsp[-1].minor.yy192 = TK_INSTEAD;}
        break;
      case 250: /* trigger_time ::= */
{ yymsp[1].minor.yy192 = TK_BEFORE; }
        break;
      case 251: /* trigger_event ::= DELETE|INSERT */
      case 252: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==252);
{yymsp[0].minor.yy230.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy230.b = 0;}
        break;
      case 253: /* trigger_event ::= UPDATE OF idlist */
{yymsp[-2].minor.yy230.a = TK_UPDATE; yymsp[-2].minor.yy230.b = yymsp[0].minor.yy600;}
        break;
      case 254: /* when_clause ::= */
      case 273: /* key_opt ::= */ yytestcase(yyruleno==273);
{ yymsp[1].minor.yy202 = 0; }
        break;
      case 255: /* when_clause ::= WHEN expr */
      case 274: /* key_opt ::= KEY expr */ yytestcase(yyruleno==274);
{ yymsp[-1].minor.yy202 = yymsp[0].minor.yy202; }
        break;
      case 256: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
{
  assert( yymsp[-2].minor.yy447!=0 );
  yymsp[-2].minor.yy447->pLast->pNext = yymsp[-1].minor.yy447;
  yymsp[-2].minor.yy447->pLast = yymsp[-1].minor.yy447;
}
        break;
      case 257: /* trigger_cmd_list ::= trigger_cmd SEMI */
{
  assert( yymsp[-1].minor.yy447!=0 );
  yymsp[-1].minor.yy447->pLast = yymsp[-1].minor.yy447;
}
        break;
      case 258: /* trnm ::= nm DOT nm */
{
  yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
  sqlite3ErrorMsg(pParse,
        "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
        "statements within triggers");
}
        break;
      case 259: /* tridxby ::= INDEXED BY nm */
{
  sqlite3ErrorMsg(pParse,
        "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
        "within triggers");
}
        break;
      case 260: /* tridxby ::= NOT INDEXED */
{
  sqlite3ErrorMsg(pParse,
        "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
        "within triggers");
}
        break;
      case 261: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
{yylhsminor.yy447 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy47, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202, yymsp[-7].minor.yy192, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy436);}
  yymsp[-8].minor.yy447 = yylhsminor.yy447;
        break;
      case 262: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
{
   yylhsminor.yy447 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy600,yymsp[-2].minor.yy539,yymsp[-6].minor.yy192,yymsp[-1].minor.yy318,yymsp[-7].minor.yy436,yymsp[0].minor.yy436);/*yylhsminor.yy447-overwrites-yymsp[-6].minor.yy192*/
}
  yymsp[-7].minor.yy447 = yylhsminor.yy447;
        break;
      case 263: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
{yylhsminor.yy447 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy202, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy436);}
  yymsp[-5].minor.yy447 = yylhsminor.yy447;
        break;
      case 264: /* trigger_cmd ::= scanpt select scanpt */
{yylhsminor.yy447 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy539, yymsp[-2].minor.yy436, yymsp[0].minor.yy436); /*yylhsminor.yy447-overwrites-yymsp[-1].minor.yy539*/}
  yymsp[-2].minor.yy447 = yylhsminor.yy447;
        break;
      case 265: /* expr ::= RAISE LP IGNORE RP */
{
  yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
  if( yymsp[-3].minor.yy202 ){
    yymsp[-3].minor.yy202->affExpr = OE_Ignore;
  }
}
        break;
      case 266: /* expr ::= RAISE LP raisetype COMMA nm RP */
{
  yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
  if( yymsp[-5].minor.yy202 ) {
    yymsp[-5].minor.yy202->affExpr = (char)yymsp[-3].minor.yy192;
  }
}
        break;
      case 267: /* raisetype ::= ROLLBACK */
{yymsp[0].minor.yy192 = OE_Rollback;}
        break;
      case 269: /* raisetype ::= FAIL */
{yymsp[0].minor.yy192 = OE_Fail;}
        break;
      case 270: /* cmd ::= DROP TRIGGER ifexists fullname */
{
  sqlite3DropTrigger(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy192);
}
        break;
      case 271: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
{
  sqlite3Attach(pParse, yymsp[-3].minor.yy202, yymsp[-1].minor.yy202, yymsp[0].minor.yy202);
}
        break;
      case 272: /* cmd ::= DETACH database_kw_opt expr */
{
  sqlite3Detach(pParse, yymsp[0].minor.yy202);
}
        break;
      case 275: /* cmd ::= REINDEX */
{sqlite3Reindex(pParse, 0, 0);}
        break;
      case 276: /* cmd ::= REINDEX nm dbnm */
{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
        break;
      case 277: /* cmd ::= ANALYZE */
{sqlite3Analyze(pParse, 0, 0);}
        break;
      case 278: /* cmd ::= ANALYZE nm dbnm */
{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
        break;
      case 279: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
{
  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy47,&yymsp[0].minor.yy0);
}
        break;
      case 280: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
{
  yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
  sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
}
        break;
      case 281: /* add_column_fullname ::= fullname */
{
  disableLookaside(pParse);
  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy47);
}
        break;
      case 282: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
{
  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy47, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
        break;
      case 283: /* cmd ::= create_vtab */
{sqlite3VtabFinishParse(pParse,0);}
        break;
      case 284: /* cmd ::= create_vtab LP vtabarglist RP */
{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
        break;
      case 285: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
{
    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy192);
}
        break;
      case 286: /* vtabarg ::= */
{sqlite3VtabArgInit(pParse);}
        break;
      case 287: /* vtabargtoken ::= ANY */
      case 288: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==288);
      case 289: /* lp ::= LP */ yytestcase(yyruleno==289);
{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
        break;
      case 290: /* with ::= WITH wqlist */
      case 291: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==291);
{ sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); }
        break;
      case 292: /* wqlist ::= nm eidlist_opt AS LP select RP */
{
  yymsp[-5].minor.yy131 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); /*A-overwrites-X*/
}
        break;
      case 293: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
{
  yymsp[-7].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy131, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539);
}
        break;
      case 294: /* windowdefn_list ::= windowdefn */
{ yylhsminor.yy303 = yymsp[0].minor.yy303; }
  yymsp[0].minor.yy303 = yylhsminor.yy303;
        break;
      case 295: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
{
  assert( yymsp[0].minor.yy303!=0 );
  sqlite3WindowChain(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy303);
  yymsp[0].minor.yy303->pNextWin = yymsp[-2].minor.yy303;
  yylhsminor.yy303 = yymsp[0].minor.yy303;
}
  yymsp[-2].minor.yy303 = yylhsminor.yy303;
        break;
      case 296: /* windowdefn ::= nm AS LP window RP */
{
  if( ALWAYS(yymsp[-1].minor.yy303) ){
    yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
  }
  yylhsminor.yy303 = yymsp[-1].minor.yy303;
}
  yymsp[-4].minor.yy303 = yylhsminor.yy303;
        break;
      case 297: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
{
  yymsp[-4].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, 0);
}
        break;
      case 298: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
{
  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, &yymsp[-5].minor.yy0);
}
  yymsp[-5].minor.yy303 = yylhsminor.yy303;
        break;
      case 299: /* window ::= ORDER BY sortlist frame_opt */
{
  yymsp[-3].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, 0);
}
        break;
      case 300: /* window ::= nm ORDER BY sortlist frame_opt */
{
  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0);
}
  yymsp[-4].minor.yy303 = yylhsminor.yy303;
        break;
      case 301: /* window ::= frame_opt */
      case 320: /* filter_over ::= over_clause */ yytestcase(yyruleno==320);
{
  yylhsminor.yy303 = yymsp[0].minor.yy303;
}
  yymsp[0].minor.yy303 = yylhsminor.yy303;
        break;
      case 302: /* window ::= nm frame_opt */
{
  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, 0, &yymsp[-1].minor.yy0);
}
  yymsp[-1].minor.yy303 = yylhsminor.yy303;
        break;
      case 303: /* frame_opt ::= */
{
  yymsp[1].minor.yy303 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
}
        break;
      case 304: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
{
  yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy192, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy58);
}
  yymsp[-2].minor.yy303 = yylhsminor.yy303;
        break;
      case 305: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
{
  yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy192, yymsp[-3].minor.yy77.eType, yymsp[-3].minor.yy77.pExpr, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, yymsp[0].minor.yy58);
}
  yymsp[-5].minor.yy303 = yylhsminor.yy303;
        break;
      case 307: /* frame_bound_s ::= frame_bound */
      case 309: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==309);
{yylhsminor.yy77 = yymsp[0].minor.yy77;}
  yymsp[0].minor.yy77 = yylhsminor.yy77;
        break;
      case 308: /* frame_bound_s ::= UNBOUNDED PRECEDING */
      case 310: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==310);
      case 312: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==312);
{yylhsminor.yy77.eType = yymsp[-1].major; yylhsminor.yy77.pExpr = 0;}
  yymsp[-1].minor.yy77 = yylhsminor.yy77;
        break;
      case 311: /* frame_bound ::= expr PRECEDING|FOLLOWING */
{yylhsminor.yy77.eType = yymsp[0].major; yylhsminor.yy77.pExpr = yymsp[-1].minor.yy202;}
  yymsp[-1].minor.yy77 = yylhsminor.yy77;
        break;
      case 313: /* frame_exclude_opt ::= */
{yymsp[1].minor.yy58 = 0;}
        break;
      case 314: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
{yymsp[-1].minor.yy58 = yymsp[0].minor.yy58;}
        break;
      case 315: /* frame_exclude ::= NO OTHERS */
      case 316: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==316);
{yymsp[-1].minor.yy58 = yymsp[-1].major; /*A-overwrites-X*/}
        break;
      case 317: /* frame_exclude ::= GROUP|TIES */
{yymsp[0].minor.yy58 = yymsp[0].major; /*A-overwrites-X*/}
        break;
      case 318: /* window_clause ::= WINDOW windowdefn_list */
{ yymsp[-1].minor.yy303 = yymsp[0].minor.yy303; }
        break;
      case 319: /* filter_over ::= filter_clause over_clause */
{
  yymsp[0].minor.yy303->pFilter = yymsp[-1].minor.yy202;
  yylhsminor.yy303 = yymsp[0].minor.yy303;
}
  yymsp[-1].minor.yy303 = yylhsminor.yy303;
        break;
      case 321: /* filter_over ::= filter_clause */
{
  yylhsminor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yylhsminor.yy303 ){
    yylhsminor.yy303->eFrmType = TK_FILTER;
    yylhsminor.yy303->pFilter = yymsp[0].minor.yy202;
  }else{
    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy202);
  }
}
  yymsp[0].minor.yy303 = yylhsminor.yy303;
        break;
      case 322: /* over_clause ::= OVER LP window RP */
{
  yymsp[-3].minor.yy303 = yymsp[-1].minor.yy303;
  assert( yymsp[-3].minor.yy303!=0 );
}
        break;
      case 323: /* over_clause ::= OVER nm */
{
  yymsp[-1].minor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yymsp[-1].minor.yy303 ){
    yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
  }
}
        break;
      case 324: /* filter_clause ::= FILTER LP WHERE expr RP */
{ yymsp[-4].minor.yy202 = yymsp[-1].minor.yy202; }
        break;
      default:
      /* (325) input ::= cmdlist */ yytestcase(yyruleno==325);
      /* (326) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==326);
      /* (327) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=327);
      /* (328) ecmd ::= SEMI */ yytestcase(yyruleno==328);
      /* (329) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==329);
      /* (330) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=330);
      /* (331) trans_opt ::= */ yytestcase(yyruleno==331);
      /* (332) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==332);
      /* (333) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==333);
      /* (334) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==334);
      /* (335) savepoint_opt ::= */ yytestcase(yyruleno==335);
      /* (336) cmd ::= create_table create_table_args */ yytestcase(yyruleno==336);
      /* (337) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==337);
      /* (338) columnlist ::= columnname carglist */ yytestcase(yyruleno==338);
      /* (339) nm ::= ID|INDEXED */ yytestcase(yyruleno==339);
      /* (340) nm ::= STRING */ yytestcase(yyruleno==340);
      /* (341) nm ::= JOIN_KW */ yytestcase(yyruleno==341);
      /* (342) typetoken ::= typename */ yytestcase(yyruleno==342);
      /* (343) typename ::= ID|STRING */ yytestcase(yyruleno==343);
      /* (344) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=344);
      /* (345) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=345);
      /* (346) carglist ::= carglist ccons */ yytestcase(yyruleno==346);
      /* (347) carglist ::= */ yytestcase(yyruleno==347);
      /* (348) ccons ::= NULL onconf */ yytestcase(yyruleno==348);
      /* (349) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==349);
      /* (350) ccons ::= AS generated */ yytestcase(yyruleno==350);
      /* (351) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==351);
      /* (352) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==352);
      /* (353) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=353);
      /* (354) tconscomma ::= */ yytestcase(yyruleno==354);
      /* (355) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=355);
      /* (356) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=356);
      /* (357) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=357);
      /* (358) oneselect ::= values */ yytestcase(yyruleno==358);
      /* (359) sclp ::= selcollist COMMA */ yytestcase(yyruleno==359);
      /* (360) as ::= ID|STRING */ yytestcase(yyruleno==360);
      /* (361) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=361);
      /* (362) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==362);
      /* (363) exprlist ::= nexprlist */ yytestcase(yyruleno==363);
      /* (364) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=364);
      /* (365) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=365);
      /* (366) nmnum ::= ON */ yytestcase(yyruleno==366);
      /* (367) nmnum ::= DELETE */ yytestcase(yyruleno==367);
      /* (368) nmnum ::= DEFAULT */ yytestcase(yyruleno==368);
      /* (369) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==369);
      /* (370) foreach_clause ::= */ yytestcase(yyruleno==370);
      /* (371) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==371);
      /* (372) trnm ::= nm */ yytestcase(yyruleno==372);
      /* (373) tridxby ::= */ yytestcase(yyruleno==373);
      /* (374) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==374);
      /* (375) database_kw_opt ::= */ yytestcase(yyruleno==375);
      /* (376) kwcolumn_opt ::= */ yytestcase(yyruleno==376);
      /* (377) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==377);
      /* (378) vtabarglist ::= vtabarg */ yytestcase(yyruleno==378);
      /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==379);
      /* (380) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==380);
      /* (381) anylist ::= */ yytestcase(yyruleno==381);
      /* (382) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==382);
      /* (383) anylist ::= anylist ANY */ yytestcase(yyruleno==383);
      /* (384) with ::= */ yytestcase(yyruleno==384);
        break;
/********** End reduce actions ************************************************/
  };
  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
  yygoto = yyRuleInfoLhs[yyruleno];
  yysize = yyRuleInfoNRhs[yyruleno];
  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
  /* There are no SHIFTREDUCE actions on nonterminals because the table
  ** generator has simplified them to pure REDUCE actions. */
  assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );
 
  /* It is not possible for a REDUCE to be followed by an error */
  assert( yyact!=YY_ERROR_ACTION );
 
  yymsp += yysize+1;

References ExprList::a, SrcList::a, TrigEvent::a, Expr::affExpr, ALWAYS, TrigEvent::b, binaryToUnaryIfNull(), Parse::constraintName, Parse::db, disableLookaside(), Window::eFrmType, EP_InfixFunc, EP_Propagate, FrameBound::eType, Parse::explain, SrcList::SrcList_item::fg, Expr::flags, Parse::hasCompound, IN_RENAME_OBJECT, Expr::iTable, SrcList::SrcList_item::jointype, JT_INNER, yyStackEntry::major, YYMINORTYPE::mask, yyStackEntry::minor, Token::n, Parse::nested, ExprList::nExpr, SrcList::nSrc, OE_Abort, OE_Cascade, OE_Default, OE_Fail, OE_Ignore, OE_None, OE_Replace, OE_Restrict, OE_Rollback, OE_SetDflt, OE_SetNull, Expr::op, Select::op, parserAddExprIdListTerm(), parserDoubleLinkSelect(), ExprList::ExprList_item::pExpr, FrameBound::pExpr, Window::pFilter, TriggerStep::pLast, Expr::pList, Parse::pNewIndex, TriggerStep::pNext, Window::pNextWin, Select::pPrior, Select::pWinDefn, Select::pWith, SAVEPOINT_BEGIN, SAVEPOINT_RELEASE, SAVEPOINT_ROLLBACK, Select::selFlags, SF_All, SF_Distinct, SF_MultiValue, SF_NestedFrom, SF_Values, Parse::sLastToken, sqlite3_strnicmp(), sqlite3AddCheckConstraint(), sqlite3AddCollateType(), sqlite3AddColumn(), sqlite3AddDefaultValue(), sqlite3AddGenerated(), sqlite3AddNotNull(), sqlite3AddPrimaryKey(), sqlite3AlterBeginAddColumn(), sqlite3AlterFinishAddColumn(), sqlite3AlterRenameColumn(), sqlite3AlterRenameTable(), sqlite3Analyze(), sqlite3Attach(), sqlite3BeginTransaction(), sqlite3BeginTrigger(), sqlite3CreateForeignKey(), sqlite3CreateIndex(), sqlite3CreateView(), sqlite3DbMallocZero(), sqlite3DbStrNDup(), sqlite3DeferForeignKey(), sqlite3DeleteFrom(), sqlite3Detach(), sqlite3DropIndex(), sqlite3DropTable(), sqlite3DropTrigger(), sqlite3EndTable(), sqlite3EndTransaction(), sqlite3ErrorMsg(), sqlite3Expr(), sqlite3ExprAddCollateToken(), sqlite3ExprAlloc(), sqlite3ExprAnd(), sqlite3ExprAssignVarNumber(), sqlite3ExprAttachSubtrees(), sqlite3ExprDelete(), sqlite3ExprFunction(), sqlite3ExprIdToTrueFalse(), sqlite3ExprIsConstant(), sqlite3ExprListAppend(), sqlite3ExprListAppendVector(), sqlite3ExprListCheckLength(), sqlite3ExprListDelete(), sqlite3ExprListSetName(), sqlite3ExprListSetSortOrder(), sqlite3ExprListSetSpan(), sqlite3ExprSetHeightAndFlags(), sqlite3ExprTruthValue(), sqlite3ExprUnmapAndDelete(), sqlite3FinishCoding(), sqlite3FinishTrigger(), sqlite3GetInt32(), sqlite3IdListAppend(), sqlite3Insert(), sqlite3Isdigit, sqlite3JoinType(), sqlite3NameFromToken(), sqlite3ParserARG_FETCH, sqlite3PExpr(), sqlite3PExprAddSelect(), sqlite3Pragma(), sqlite3Reindex(), sqlite3RenameTokenMap(), sqlite3Savepoint(), sqlite3Select(), sqlite3SelectDelete(), sqlite3SelectNew(), sqlite3SrcListAppend(), sqlite3SrcListAppendFromTerm(), sqlite3SrcListAppendList(), sqlite3SrcListDelete(), sqlite3SrcListFuncArgs(), sqlite3SrcListIndexedBy(), sqlite3SrcListShiftJoinType(), sqlite3StartTable(), sqlite3TriggerDeleteStep(), sqlite3TriggerInsertStep(), sqlite3TriggerSelectStep(), sqlite3TriggerUpdateStep(), sqlite3Update(), sqlite3UpsertNew(), sqlite3Vacuum(), sqlite3VtabArgExtend(), sqlite3VtabArgInit(), sqlite3VtabBeginParse(), sqlite3VtabFinishParse(), sqlite3WindowAlloc(), sqlite3WindowAssemble(), sqlite3WindowAttach(), sqlite3WindowChain(), sqlite3WindowListDelete(), sqlite3WithAdd(), sqlite3WithDelete(), sqlite3WithPush(), SQLITE_IDXTYPE_APPDEF, SQLITE_IDXTYPE_UNIQUE, SQLITE_SO_ASC, SQLITE_SO_DESC, SQLITE_SO_UNDEFINED, SRT_Output, yyStackEntry::stateno, testcase, TF_NoVisibleRowid, TF_WithoutRowid, TK_ALL, TK_ASTERISK, TK_BEFORE, TK_BETWEEN, TK_CASE, TK_CAST, TK_CURRENT, TK_DEFERRED, TK_DOT, TK_EQ, TK_EXISTS, TK_FILTER, TK_ID, TK_IN, TK_INSTEAD, TK_INTEGER, TK_IS, TK_ISNOT, TK_ISNULL, TK_LIMIT, TK_NOT, TK_NOTNULL, TK_PLUS, TK_RAISE, TK_REGISTER, TK_SELECT, TK_STRING, TK_TRUEFALSE, TK_UMINUS, TK_UNBOUNDED, TK_UPDATE, TK_UPLUS, TK_VARIABLE, TK_VECTOR, tokenExpr(), YYMINORTYPE::value, Expr::x, YYMINORTYPE::yy0, YYMINORTYPE::yy131, YYMINORTYPE::yy192, YYMINORTYPE::yy202, YYMINORTYPE::yy207, YYMINORTYPE::yy230, YYMINORTYPE::yy242, YYMINORTYPE::yy303, YYMINORTYPE::yy318, YYMINORTYPE::yy436, YYMINORTYPE::yy447, YYMINORTYPE::yy47, YYMINORTYPE::yy539, YYMINORTYPE::yy58, YYMINORTYPE::yy600, YYMINORTYPE::yy77, YY_ERROR_ACTION, yy_find_reduce_action(), YY_MAX_SHIFT, YY_MAX_SHIFTREDUCE, YYACTIONTYPE, YYCODETYPE, YYNOCODE, YYNRULE_WITH_ACTION, yyRuleInfoLhs, yyRuleInfoNRhs, yyParser::yystack, yyParser::yystackEnd, yyStackOverflow(), yytestcase, yyParser::yytos, yyTraceShift, Token::z, SrcList::SrcList_item::zAlias, Index::zName, SrcList::SrcList_item::zName, and Window::zName.

Referenced by sqlite3Parser().

◆ yy_shift()

static void yy_shift	(	yyParser *	yypParser,
		YYACTIONTYPE	yyNewState,
		YYCODETYPE	yyMajor,
		sqlite3ParserTOKENTYPE	yyMinor )

static

Definition at line 156626 of file sqlite3.c.

 {
  yyStackEntry *yytos;
  yypParser->yytos++;
#ifdef YYTRACKMAXSTACKDEPTH
  if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
    yypParser->yyhwm++;
    assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
  }
#endif
#if YYSTACKDEPTH>0
  if( yypParser->yytos>yypParser->yystackEnd ){
    yypParser->yytos--;
    yyStackOverflow(yypParser);
    return;
  }
#else
  if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
    if( yyGrowStack(yypParser) ){
      yypParser->yytos--;
      yyStackOverflow(yypParser);
      return;
    }
  }
#endif
  if( yyNewState > YY_MAX_SHIFT ){
    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
  }

References yyStackEntry::major, yyStackEntry::stateno, YY_MAX_SHIFT, YY_MIN_REDUCE, YY_MIN_SHIFTREDUCE, yyParser::yystack, yyParser::yystackEnd, yyStackOverflow(), and yyParser::yytos.

Referenced by sqlite3Parser().

◆ yy_syntax_error()

static void yy_syntax_error	(	yyParser *	yypParser,
		int	yymajor,
		sqlite3ParserTOKENTYPE	yyminor )

static

Definition at line 159006 of file sqlite3.c.

 {
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
#define TOKEN yyminor
/************ Begin %syntax_error code ****************************************/
 
  UNUSED_PARAMETER(yymajor);  /* Silence some compiler warnings */
  if( TOKEN.z[0] ){
    sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
  }else{

Referenced by sqlite3Parser().

◆ yyStackOverflow()

static void yyStackOverflow ( yyParser * yypParser )

static

Definition at line 156583 of file sqlite3.c.

                                                {
   sqlite3ParserARG_FETCH
   sqlite3ParserCTX_FETCH
#ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
   }
#endif
   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
   /* Here code is inserted which will execute if the parser
   ** stack every overflows */
/******** Begin %stack_overflow code ******************************************/

Referenced by yy_reduce(), and yy_shift().

◆ zeroblobFunc()

static void zeroblobFunc	(	sqlite3_context *	context,
		int	argc,
		sqlite3_value **	argv )

static

Definition at line 118239 of file sqlite3.c.

 {
  i64 n;
  int rc;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  n = sqlite3_value_int64(argv[0]);

Referenced by sqlite3RegisterBuiltinFunctions().

◆ zeroJournalHdr()

static int zeroJournalHdr	(	Pager *	pPager,
		int	doTruncate )

static

Definition at line 53086 of file sqlite3.c.

                                                        {
  int rc = SQLITE_OK;                               /* Return code */
  assert( isOpen(pPager->jfd) );
  assert( !sqlite3JournalIsInMemory(pPager->jfd) );
  if( pPager->journalOff ){
    const i64 iLimit = pPager->journalSizeLimit;    /* Local cache of jsl */
 
    IOTRACE(("JZEROHDR %p\n", pPager))
    if( doTruncate || iLimit==0 ){
      rc = sqlite3OsTruncate(pPager->jfd, 0);
    }else{
      static const char zeroHdr[28] = {0};
      rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
    }
    if( rc==SQLITE_OK && !pPager->noSync ){
      rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
    }
 
    /* At this point the transaction is committed but the write lock
    ** is still held on the file. If there is a size limit configured for
    ** the persistent journal and the journal file currently consumes more
    ** space than that limit allows for, truncate it now. There is no need
    ** to sync the file following this operation.
    */
    if( rc==SQLITE_OK && iLimit>0 ){
      i64 sz;
      rc = sqlite3OsFileSize(pPager->jfd, &sz);
      if( rc==SQLITE_OK && sz>iLimit ){

References IOTRACE, isOpen, Pager::jfd, Pager::journalOff, Pager::journalSizeLimit, Pager::noSync, sqlite3JournalIsInMemory(), sqlite3OsFileSize(), sqlite3OsSync(), sqlite3OsTruncate(), sqlite3OsWrite(), SQLITE_OK, SQLITE_SYNC_DATAONLY, and Pager::syncFlags.

Referenced by pager_end_transaction().

◆ zeroPage()

static void zeroPage	(	MemPage *	pPage,
		int	flags )

static

Definition at line 66521 of file sqlite3.c.

                                               {
  unsigned char *data = pPage->aData;
  BtShared *pBt = pPage->pBt;
  u8 hdr = pPage->hdrOffset;
  u16 first;
 
  assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
  assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
  assert( sqlite3PagerGetData(pPage->pDbPage) == data );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( sqlite3_mutex_held(pBt->mutex) );
  if( pBt->btsFlags & BTS_FAST_SECURE ){
    memset(&data[hdr], 0, pBt->usableSize - hdr);
  }
  data[hdr] = (char)flags;
  first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8);
  memset(&data[hdr+1], 0, 4);
  data[hdr+7] = 0;
  put2byte(&data[hdr+5], pBt->usableSize);
  pPage->nFree = (u16)(pBt->usableSize - first);
  decodeFlags(pPage, flags);
  pPage->cellOffset = first;
  pPage->aDataEnd = &data[pBt->usableSize];
  pPage->aCellIdx = &data[first];
  pPage->aDataOfst = &data[pPage->childPtrSize];

Referenced by balance_deeper(), balance_nonroot(), balance_quick(), and newDatabase().

Variable Documentation

◆ aDigits

const char aDigits[] = "0123456789ABCDEF0123456789abcdef"

static

Definition at line 28204 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ aHardLimit

const int aHardLimit[]

static

Initial value:

= {
  SQLITE_MAX_LENGTH,
  SQLITE_MAX_SQL_LENGTH,
  SQLITE_MAX_COLUMN,
  SQLITE_MAX_EXPR_DEPTH,
  SQLITE_MAX_COMPOUND_SELECT,
  SQLITE_MAX_VDBE_OP,
  SQLITE_MAX_FUNCTION_ARG,
  SQLITE_MAX_ATTACHED,
  SQLITE_MAX_LIKE_PATTERN_LENGTH,
  SQLITE_MAX_VARIABLE_NUMBER,      
  SQLITE_MAX_TRIGGER_DEPTH,
  SQLITE_MAX_WORKER_THREADS,
}

Definition at line 163665 of file sqlite3.c.

                                {
  SQLITE_MAX_LENGTH,
  SQLITE_MAX_SQL_LENGTH,
  SQLITE_MAX_COLUMN,
  SQLITE_MAX_EXPR_DEPTH,
  SQLITE_MAX_COMPOUND_SELECT,
  SQLITE_MAX_VDBE_OP,
  SQLITE_MAX_FUNCTION_ARG,

Referenced by openDatabase(), and sqlite3_limit().

◆ aiClass

const unsigned char aiClass[]

static

Definition at line 159315 of file sqlite3.c.

                                       {
#ifdef SQLITE_ASCII
/*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
/* 0x */   28, 27, 27, 27, 27, 27, 27, 27, 27,  7,  7, 27,  7,  7, 27, 27,
/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
/* 2x */    7, 15,  8,  5,  4, 22, 24,  8, 17, 18, 21, 20, 23, 11, 26, 16,
/* 3x */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  5, 19, 12, 14, 13,  6,
/* 4x */    5,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
/* 5x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  9, 27, 27, 27,  1,
/* 6x */    8,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
/* 7x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1, 27, 10, 27, 25, 27,
/* 8x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* 9x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Ax */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Bx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Cx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Dx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Ex */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
/* Fx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2
#endif
#ifdef SQLITE_EBCDIC
/*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
/* 0x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27,  7,  7, 27, 27,
/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
/* 2x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
/* 3x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
/* 4x */    7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10,
/* 5x */   24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15,  4, 21, 18, 19, 27,
/* 6x */   11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22,  1, 13,  6,
/* 7x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  8,  5,  5,  5,  8, 14,  8,
/* 8x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
/* 9x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
/* Ax */   27, 25,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
/* Bx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27,  9, 27, 27, 27, 27, 27,

Referenced by sqlite3GetToken().

◆ aJournalMagic

const unsigned char aJournalMagic[]

static

Initial value:

= {
  0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
}

Definition at line 52453 of file sqlite3.c.

Referenced by readJournalHdr(), readSuperJournal(), syncJournal(), writeJournalHdr(), and writeSuperJournal().

◆ aKWCode

const unsigned char aKWCode[145]

static

Definition at line 159530 of file sqlite3.c.

                                          {
  TK_REINDEX,    TK_INDEXED,    TK_INDEX,      TK_DESC,       TK_ESCAPE,
  TK_EACH,       TK_CHECK,      TK_KEY,        TK_BEFORE,     TK_FOREIGN,
  TK_FOR,        TK_IGNORE,     TK_LIKE_KW,    TK_EXPLAIN,    TK_INSTEAD,
  TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     TK_TABLE,
  TK_JOIN_KW,    TK_THEN,       TK_END,        TK_DEFERRABLE, TK_ELSE,
  TK_EXCLUDE,    TK_DELETE,     TK_TEMP,       TK_TEMP,       TK_OR,
  TK_ISNULL,     TK_NULLS,      TK_SAVEPOINT,  TK_INTERSECT,  TK_TIES,
  TK_NOTNULL,    TK_NOT,        TK_NO,         TK_NULL,       TK_LIKE_KW,
  TK_EXCEPT,     TK_TRANSACTION,TK_ACTION,     TK_ON,         TK_JOIN_KW,
  TK_ALTER,      TK_RAISE,      TK_EXCLUSIVE,  TK_EXISTS,     TK_CONSTRAINT,
  TK_INTO,       TK_OFFSET,     TK_OF,         TK_SET,        TK_TRIGGER,
  TK_RANGE,      TK_GENERATED,  TK_DETACH,     TK_HAVING,     TK_LIKE_KW,
  TK_BEGIN,      TK_JOIN_KW,    TK_REFERENCES, TK_UNIQUE,     TK_QUERY,
  TK_WITHOUT,    TK_WITH,       TK_JOIN_KW,    TK_RELEASE,    TK_ATTACH,
  TK_BETWEEN,    TK_NOTHING,    TK_GROUPS,     TK_GROUP,      TK_CASCADE,
  TK_ASC,        TK_DEFAULT,    TK_CASE,       TK_COLLATE,    TK_CREATE,
  TK_CTIME_KW,   TK_IMMEDIATE,  TK_JOIN,       TK_INSERT,     TK_MATCH,
  TK_PLAN,       TK_ANALYZE,    TK_PRAGMA,     TK_ABORT,      TK_UPDATE,
  TK_VALUES,     TK_VIRTUAL,    TK_ALWAYS,     TK_WHEN,       TK_WHERE,
  TK_RECURSIVE,  TK_AFTER,      TK_RENAME,     TK_AND,        TK_DEFERRED,
  TK_DISTINCT,   TK_IS,         TK_AUTOINCR,   TK_TO,         TK_IN,
  TK_CAST,       TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,
  TK_CTIME_KW,   TK_CTIME_KW,   TK_CURRENT,    TK_PARTITION,  TK_DROP,
  TK_PRECEDING,  TK_FAIL,       TK_LAST,       TK_FILTER,     TK_REPLACE,

◆ aKWHash

const unsigned char aKWHash[127]

static

Initial value:

= {
    84, 102, 132,  82, 114,  29,   0,   0,  91,   0,  85,  72,   0,
    53,  35,  86,  15,   0,  42,  94,  54, 126, 133,  19,   0,   0,
   138,   0,  40, 128,   0,  22, 104,   0,   9,   0,   0, 122,  80,
     0,  78,   6,   0,  65,  99, 145,   0, 134, 112,   0,   0,  48,
     0, 100,  24,   0,  17,   0,  27,  70,  23,  26,   5,  60, 140,
   107, 121,   0,  73, 101,  71, 143,  61, 119,  74,   0,  49,   0,
    11,  41,   0, 110,   0,   0,   0, 106,  10, 108, 113, 124,  14,
    50, 123,   0,  89,   0,  18, 120, 142,  56, 129, 137,  88,  83,
    37,  30, 125,   0,   0, 105,  51, 130, 127,   0,  34,   0,   0,
    44,   0,  95,  38,  39,   0,  20,  45, 116,  90,
}

Definition at line 159469 of file sqlite3.c.

                                          {
    84, 102, 132,  82, 114,  29,   0,   0,  91,   0,  85,  72,   0,
    53,  35,  86,  15,   0,  42,  94,  54, 126, 133,  19,   0,   0,
   138,   0,  40, 128,   0,  22, 104,   0,   9,   0,   0, 122,  80,
     0,  78,   6,   0,  65,  99, 145,   0, 134, 112,   0,   0,  48,
     0, 100,  24,   0,  17,   0,  27,  70,  23,  26,   5,  60, 140,

Referenced by keywordCode().

◆ aKWLen

const unsigned char aKWLen[145]

static

Initial value:

= {
     7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
     7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   7,
     6,   9,   4,   2,   6,   5,   9,   9,   4,   7,   3,   2,   4,
     4,   6,  11,   6,   2,   7,   5,   5,   9,   6,  10,   4,   6,
     2,   3,   7,   5,   9,   6,   6,   4,   5,   5,  10,   6,   5,
     7,   4,   5,   7,   6,   7,   7,   6,   5,   7,   3,   7,   4,
     7,   6,  12,   9,   4,   6,   5,   4,   7,   6,   5,   6,   6,
     7,   6,   4,   5,   9,   5,   6,   3,   8,   8,   2,  13,   2,
     2,   4,   6,   6,   8,   5,  17,  12,   7,   9,   4,   9,   4,
     4,   6,   7,   5,   9,   4,   4,   5,   2,   5,   8,   6,   4,
     5,   8,   4,   3,   9,   5,   5,   6,   4,   6,   2,   2,   9,
     3,   7,
}

Definition at line 159499 of file sqlite3.c.

                                         {
     7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
     7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   7,
     6,   9,   4,   2,   6,   5,   9,   9,   4,   7,   3,   2,   4,
     4,   6,  11,   6,   2,   7,   5,   5,   9,   6,  10,   4,   6,
     2,   3,   7,   5,   9,   6,   6,   4,   5,   5,  10,   6,   5,
     7,   4,   5,   7,   6,   7,   7,   6,   5,   7,   3,   7,   4,
     7,   6,  12,   9,   4,   6,   5,   4,   7,   6,   5,   6,   6,

Referenced by keywordCode().

◆ aKWNext

const unsigned char aKWNext[145]

static

Initial value:

= {
     0,   0,   0,   0,   4,   0,  43,   0,   0, 103, 111,   0,   0,
     0,   2,   0,   0, 141,   0,   0,   0,  13,   0,   0,   0,   0,
   139,   0,   0, 118,  52,   0,   0, 135,  12,   0,   0,  62,   0,
   136,   0, 131,   0,   0,  36,   0,   0,  28,  77,   0,   0,   0,
     0,  59,   0,  47,   0,   0,   0,   0,   0,   0,   0,   0,   0,
     0,  69,   0,   0,   0,   0,   0, 144,   3,   0,  58,   0,   1,
    75,   0,   0,   0,  31,   0,   0,   0,   0,   0,   0,  64,  66,
    63,   0,   0,   0,   0,  46,   0,  16,   0, 115,   0,   0,   0,
     0,   0,   0,   0,   0,   0,   0,  81,  97,   0,   8,   0, 109,
    21,   7,  67,   0,  79,  93, 117,   0,   0,  68,   0,   0,  96,
     0,  55,   0,  76,   0,  92,  32,  33,  57,  25,   0,  98,   0,
     0,  87,
}

Definition at line 159484 of file sqlite3.c.

                                          {
     0,   0,   0,   0,   4,   0,  43,   0,   0, 103, 111,   0,   0,
     0,   2,   0,   0, 141,   0,   0,   0,  13,   0,   0,   0,   0,
   139,   0,   0, 118,  52,   0,   0, 135,  12,   0,   0,  62,   0,
   136,   0, 131,   0,   0,  36,   0,   0,  28,  77,   0,   0,   0,
     0,  59,   0,  47,   0,   0,   0,   0,   0,   0,   0,   0,   0,
     0,  69,   0,   0,   0,   0,   0, 144,   3,   0,  58,   0,   1,
    75,   0,   0,   0,  31,   0,   0,   0,   0,   0,   0,  64,  66,

Referenced by keywordCode().

◆ aKWOffset

const unsigned short int aKWOffset[145]

static

Initial value:

= {
     0,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
    36,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
    86,  90,  90,  94,  99, 101, 105, 111, 119, 123, 123, 123, 126,
   129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184,
   184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239,
   244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295,
   299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 360, 365, 371,
   377, 382, 388, 392, 395, 404, 408, 414, 416, 423, 424, 431, 433,
   435, 444, 448, 454, 460, 468, 473, 473, 473, 489, 498, 501, 510,
   513, 517, 522, 529, 534, 543, 547, 550, 555, 557, 561, 569, 575,
   578, 583, 591, 591, 595, 604, 609, 614, 620, 623, 626, 629, 631,
   636, 640,
}

Definition at line 159515 of file sqlite3.c.

                                                 {
     0,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
    36,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
    86,  90,  90,  94,  99, 101, 105, 111, 119, 123, 123, 123, 126,
   129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184,
   184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239,
   244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295,
   299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 360, 365, 371,

Referenced by keywordCode().

◆ aPragmaName

const PragmaName aPragmaName[]

static

Definition at line 125254 of file sqlite3.c.

                                        {
#if defined(SQLITE_ENABLE_CEROD)
 {/* zName:     */ "activate_extensions",
  /* ePragTyp:  */ PragTyp_ACTIVATE_EXTENSIONS,
  /* ePragFlg:  */ 0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
 {/* zName:     */ "analysis_limit",
  /* ePragTyp:  */ PragTyp_ANALYSIS_LIMIT,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "application_id",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_APPLICATION_ID },
#endif
#if !defined(SQLITE_OMIT_AUTOVACUUM)
 {/* zName:     */ "auto_vacuum",
  /* ePragTyp:  */ PragTyp_AUTO_VACUUM,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if !defined(SQLITE_OMIT_AUTOMATIC_INDEX)
 {/* zName:     */ "automatic_index",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_AutoIndex },
#endif
#endif
 {/* zName:     */ "busy_timeout",
  /* ePragTyp:  */ PragTyp_BUSY_TIMEOUT,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 50, 1,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "cache_size",
  /* ePragTyp:  */ PragTyp_CACHE_SIZE,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "cache_spill",
  /* ePragTyp:  */ PragTyp_CACHE_SPILL,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA)
 {/* zName:     */ "case_sensitive_like",
  /* ePragTyp:  */ PragTyp_CASE_SENSITIVE_LIKE,
  /* ePragFlg:  */ PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
 {/* zName:     */ "cell_size_check",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CellSizeCk },
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "checkpoint_fullfsync",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CkptFullFSync },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "collation_list",
  /* ePragTyp:  */ PragTyp_COLLATION_LIST,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 32, 2,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
 {/* zName:     */ "compile_options",
  /* ePragTyp:  */ PragTyp_COMPILE_OPTIONS,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "count_changes",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CountRows },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN
 {/* zName:     */ "data_store_directory",
  /* ePragTyp:  */ PragTyp_DATA_STORE_DIRECTORY,
  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "data_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_DATA_VERSION },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "database_list",
  /* ePragTyp:  */ PragTyp_DATABASE_LIST,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0,
  /* ColNames:  */ 41, 3,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
 {/* zName:     */ "default_cache_size",
  /* ePragTyp:  */ PragTyp_DEFAULT_CACHE_SIZE,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 49, 1,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 {/* zName:     */ "defer_foreign_keys",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_DeferFKs },
#endif
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "empty_result_callbacks",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_NullCallback },
#endif
#if !defined(SQLITE_OMIT_UTF16)
 {/* zName:     */ "encoding",
  /* ePragTyp:  */ PragTyp_ENCODING,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 {/* zName:     */ "foreign_key_check",
  /* ePragTyp:  */ PragTyp_FOREIGN_KEY_CHECK,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 37, 4,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FOREIGN_KEY)
 {/* zName:     */ "foreign_key_list",
  /* ePragTyp:  */ PragTyp_FOREIGN_KEY_LIST,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 0, 8,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 {/* zName:     */ "foreign_keys",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ForeignKeys },
#endif
#endif
#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "freelist_count",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_FREE_PAGE_COUNT },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "full_column_names",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_FullColNames },
 {/* zName:     */ "fullfsync",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_FullFSync },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS)
 {/* zName:     */ "function_list",
  /* ePragTyp:  */ PragTyp_FUNCTION_LIST,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 21, 6,
  /* iArg:      */ 0 },
#endif
#endif
 {/* zName:     */ "hard_heap_limit",
  /* ePragTyp:  */ PragTyp_HARD_HEAP_LIMIT,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if !defined(SQLITE_OMIT_CHECK)
 {/* zName:     */ "ignore_check_constraints",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_IgnoreChecks },
#endif
#endif
#if !defined(SQLITE_OMIT_AUTOVACUUM)
 {/* zName:     */ "incremental_vacuum",
  /* ePragTyp:  */ PragTyp_INCREMENTAL_VACUUM,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "index_info",
  /* ePragTyp:  */ PragTyp_INDEX_INFO,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 15, 3,
  /* iArg:      */ 0 },
 {/* zName:     */ "index_list",
  /* ePragTyp:  */ PragTyp_INDEX_LIST,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 32, 5,
  /* iArg:      */ 0 },
 {/* zName:     */ "index_xinfo",
  /* ePragTyp:  */ PragTyp_INDEX_INFO,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 15, 6,
  /* iArg:      */ 1 },
#endif
#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
 {/* zName:     */ "integrity_check",
  /* ePragTyp:  */ PragTyp_INTEGRITY_CHECK,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "journal_mode",
  /* ePragTyp:  */ PragTyp_JOURNAL_MODE,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "journal_size_limit",
  /* ePragTyp:  */ PragTyp_JOURNAL_SIZE_LIMIT,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "legacy_alter_table",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_LegacyAlter },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE
 {/* zName:     */ "lock_proxy_file",
  /* ePragTyp:  */ PragTyp_LOCK_PROXY_FILE,
  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
 {/* zName:     */ "lock_status",
  /* ePragTyp:  */ PragTyp_LOCK_STATUS,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 47, 2,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "locking_mode",
  /* ePragTyp:  */ PragTyp_LOCKING_MODE,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "max_page_count",
  /* ePragTyp:  */ PragTyp_PAGE_COUNT,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "mmap_size",
  /* ePragTyp:  */ PragTyp_MMAP_SIZE,
  /* ePragFlg:  */ 0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
#if !defined(SQLITE_OMIT_VIRTUALTABLE)
#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS)
 {/* zName:     */ "module_list",
  /* ePragTyp:  */ PragTyp_MODULE_LIST,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 9, 1,
  /* iArg:      */ 0 },
#endif
#endif
#endif
 {/* zName:     */ "optimize",
  /* ePragTyp:  */ PragTyp_OPTIMIZE,
  /* ePragFlg:  */ PragFlg_Result1|PragFlg_NeedSchema,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "page_count",
  /* ePragTyp:  */ PragTyp_PAGE_COUNT,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "page_size",
  /* ePragTyp:  */ PragTyp_PAGE_SIZE,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if defined(SQLITE_DEBUG)
 {/* zName:     */ "parser_trace",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ParserTrace },
#endif
#endif
#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS)
 {/* zName:     */ "pragma_list",
  /* ePragTyp:  */ PragTyp_PRAGMA_LIST,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 9, 1,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "query_only",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_QueryOnly },
#endif
#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
 {/* zName:     */ "quick_check",
  /* ePragTyp:  */ PragTyp_INTEGRITY_CHECK,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "read_uncommitted",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ReadUncommit },
 {/* zName:     */ "recursive_triggers",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_RecTriggers },
 {/* zName:     */ "reverse_unordered_selects",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ReverseOrder },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "schema_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_SCHEMA_VERSION },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "secure_delete",
  /* ePragTyp:  */ PragTyp_SECURE_DELETE,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "short_column_names",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ShortColNames },
#endif
 {/* zName:     */ "shrink_memory",
  /* ePragTyp:  */ PragTyp_SHRINK_MEMORY,
  /* ePragFlg:  */ PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "soft_heap_limit",
  /* ePragTyp:  */ PragTyp_SOFT_HEAP_LIMIT,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if defined(SQLITE_DEBUG)
 {/* zName:     */ "sql_trace",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_SqlTrace },
#endif
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG)
 {/* zName:     */ "stats",
  /* ePragTyp:  */ PragTyp_STATS,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 27, 5,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "synchronous",
  /* ePragTyp:  */ PragTyp_SYNCHRONOUS,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "table_info",
  /* ePragTyp:  */ PragTyp_TABLE_INFO,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 8, 6,
  /* iArg:      */ 0 },
 {/* zName:     */ "table_xinfo",
  /* ePragTyp:  */ PragTyp_TABLE_INFO,
  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 8, 7,
  /* iArg:      */ 1 },
#endif
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "temp_store",
  /* ePragTyp:  */ PragTyp_TEMP_STORE,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "temp_store_directory",
  /* ePragTyp:  */ PragTyp_TEMP_STORE_DIRECTORY,
  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#endif
 {/* zName:     */ "threads",
  /* ePragTyp:  */ PragTyp_THREADS,
  /* ePragFlg:  */ PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "trusted_schema",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_TrustedSchema },
#endif
#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "user_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_USER_VERSION },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
#if defined(SQLITE_DEBUG)
 {/* zName:     */ "vdbe_addoptrace",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeAddopTrace },
 {/* zName:     */ "vdbe_debug",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace },
 {/* zName:     */ "vdbe_eqp",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeEQP },
 {/* zName:     */ "vdbe_listing",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeListing },
 {/* zName:     */ "vdbe_trace",
  /* ePragTyp:  */ PragTyp_FLAG,
  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeTrace },
#endif
#endif
#if !defined(SQLITE_OMIT_WAL)
 {/* zName:     */ "wal_autocheckpoint",
  /* ePragTyp:  */ PragTyp_WAL_AUTOCHECKPOINT,
  /* ePragFlg:  */ 0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "wal_checkpoint",
  /* ePragTyp:  */ PragTyp_WAL_CHECKPOINT,
  /* ePragFlg:  */ PragFlg_NeedSchema,
  /* ColNames:  */ 44, 3,
  /* iArg:      */ 0 },
#endif
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "writable_schema",

Referenced by sqlite3Pragma().

◆ aPrefix

const char aPrefix[] = "-x0\000X0"

static

Definition at line 28205 of file sqlite3.c.

Referenced by sqlite3_str_vappendf().

◆ arRound

const double arRound[]

static

Initial value:

= {
  5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05,
  5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10,
}

Definition at line 28237 of file sqlite3.c.

  {  'T',  0, 0, etTOKEN,      0,  0 },
  {  'S',  0, 0, etSRCLIST,    0,  0 },
  {  'r', 10, 1, etORDINAL,    0,  0 },
};

Referenced by sqlite3_str_vappendf().

◆ aSyscall

struct unix_syscall aSyscall[]

static

Referenced by sqlite3_os_init(), unixGetSystemCall(), unixNextSystemCall(), and unixSetSystemCall().

◆ [struct]

const struct { ... } aXformType[]

Initial value:

= {
  { 0, 6, "second", 464269060800.0, 1000.0         },
  { 0, 6, "minute", 7737817680.0,   60000.0        },
  { 0, 4, "hour",   128963628.0,    3600000.0      },
  { 0, 3, "day",    5373485.0,      86400000.0     },
  { 1, 5, "month",  176546.0,       2592000000.0   },
  { 2, 4, "year",   14713.0,        31536000000.0  },
}

Referenced by parseModifier().

◆ cume_distName

const char cume_distName[] = "cume_dist"

static

Definition at line 151711 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ dense_rankName

const char dense_rankName[] = "dense_rank"

static

Definition at line 151708 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ eType

u8 eType

Definition at line 22327 of file sqlite3.c.

Referenced by allocateBtreePage(), btreeCreateTable(), checkPtrmap(), codeEqualityTerm(), fillInCell(), getOverflowPage(), incrVacuumStep(), isDate(), modifyPagePointer(), parseModifier(), ptrmapPut(), relocatePage(), sqlite3_value_numeric_type(), sqlite3AtoF(), sqlite3EndTransaction(), sqlite3ExprCodeIN(), sqlite3FindInIndex(), sqlite3RunParser(), sqlite3VdbeMemShallowCopy(), and unixOpen().

◆ first_valueName

const char first_valueName[] = "first_value"

static

Definition at line 151715 of file sqlite3.c.

Referenced by sqlite3WindowCodeInit(), windowAggStep(), windowInitAccum(), and windowReturnOneRow().

◆ fmtinfo

const et_info fmtinfo[]

static

Initial value:

= {
  {  'd', 10, 1, etDECIMAL,    0,  0 },
  {  's',  0, 4, etSTRING,     0,  0 },
  {  'g',  0, 1, etGENERIC,    30, 0 },
  {  'z',  0, 4, etDYNSTRING,  0,  0 },
  {  'q',  0, 4, etSQLESCAPE,  0,  0 },
  {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
  {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
  {  'c',  0, 0, etCHARX,      0,  0 },
  {  'o',  8, 0, etRADIX,      0,  2 },
  {  'u', 10, 0, etDECIMAL,    0,  0 },
  {  'x', 16, 0, etRADIX,      16, 1 },
  {  'X', 16, 0, etRADIX,      0,  4 },
 
  {  'f',  0, 1, etFLOAT,      0,  0 },
  {  'e',  0, 1, etEXP,        30, 0 },
  {  'E',  0, 1, etEXP,        14, 0 },
  {  'G',  0, 1, etGENERIC,    14, 0 },
 
  {  'i', 10, 1, etDECIMAL,    0,  0 },
  {  'n',  0, 0, etSIZE,       0,  0 },
  {  '%',  0, 0, etPERCENT,    0,  0 },
  {  'p', 16, 0, etPOINTER,    0,  1 },
 
  
  {  'T',  0, 0, etTOKEN,      0,  0 },
  {  'S',  0, 0, etSRCLIST,    0,  0 },
  {  'r', 10, 1, etORDINAL,    0,  0 },
}

Definition at line 28206 of file sqlite3.c.

                                 {
  {  'd', 10, 1, etDECIMAL,    0,  0 },
  {  's',  0, 4, etSTRING,     0,  0 },
  {  'g',  0, 1, etGENERIC,    30, 0 },
  {  'z',  0, 4, etDYNSTRING,  0,  0 },
  {  'q',  0, 4, etSQLESCAPE,  0,  0 },
  {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
  {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
  {  'c',  0, 0, etCHARX,      0,  0 },
  {  'o',  8, 0, etRADIX,      0,  2 },
  {  'u', 10, 0, etDECIMAL,    0,  0 },
  {  'x', 16, 0, etRADIX,      16, 1 },
  {  'X', 16, 0, etRADIX,      0,  4 },
#ifndef SQLITE_OMIT_FLOATING_POINT
  {  'f',  0, 1, etFLOAT,      0,  0 },
  {  'e',  0, 1, etEXP,        30, 0 },
  {  'E',  0, 1, etEXP,        14, 0 },
  {  'G',  0, 1, etGENERIC,    14, 0 },
#endif
  {  'i', 10, 1, etDECIMAL,    0,  0 },
  {  'n',  0, 0, etSIZE,       0,  0 },
  {  '%',  0, 0, etPERCENT,    0,  0 },
  {  'p', 16, 0, etPOINTER,    0,  1 },

Referenced by sqlite3_str_vappendf().

◆ globInfo

const struct compareInfo globInfo = { '*', '?', '[', 0 }

static

Definition at line 117671 of file sqlite3.c.

Referenced by sqlite3RegisterBuiltinFunctions().

◆ hexdigits

const char hexdigits[]

static

Initial value:

= {
  '0', '1', '2', '3', '4', '5', '6', '7',
  '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
}

Definition at line 118067 of file sqlite3.c.

Referenced by quoteFunc().

◆ inodeList

unixInodeInfo* inodeList = 0

static

Definition at line 34728 of file sqlite3.c.

Referenced by findInodeInfo(), findReusableFd(), and releaseInodeInfo().

◆ lagName

const char lagName[] = "lag"

static

Definition at line 151717 of file sqlite3.c.

Referenced by sqlite3WindowCodeInit(), sqlite3WindowUpdate(), and windowReturnOneRow().

◆ last_valueName

const char last_valueName[] = "last_value"

static

Definition at line 151713 of file sqlite3.c.

◆ leadName

const char leadName[] = "lead"

static

Definition at line 151716 of file sqlite3.c.

Referenced by sqlite3WindowCodeInit(), sqlite3WindowUpdate(), and windowReturnOneRow().

◆ likeInfoAlt

const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }

static

Definition at line 117677 of file sqlite3.c.

117677{ '*', '?', '[', 0 };

Referenced by sqlite3IsLikeFunction(), sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterLikeFunctions().

◆ likeInfoNorm

const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }

static

Definition at line 117674 of file sqlite3.c.

117674:sqlite3Utf8Read(&A))

Referenced by sqlite3RegisterBuiltinFunctions(), and sqlite3RegisterLikeFunctions().

◆ mem0

SQLITE_WSD struct Mem0Global mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 }

static

◆ MemJournalMethods

const struct sqlite3_io_methods MemJournalMethods

static

Initial value:

= {
  1,                
  memjrnlClose,     
  memjrnlRead,      
  memjrnlWrite,     
  memjrnlTruncate,  
  memjrnlSync,      
  memjrnlFileSize,  
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0,                
  0                 
}

Definition at line 97378 of file sqlite3.c.

                                                           {
  1,                /* iVersion */
  memjrnlClose,     /* xClose */
  memjrnlRead,      /* xRead */
  memjrnlWrite,     /* xWrite */
  memjrnlTruncate,  /* xTruncate */
  memjrnlSync,      /* xSync */
  memjrnlFileSize,  /* xFileSize */
  0,                /* xLock */
  0,                /* xUnlock */
  0,                /* xCheckReservedLock */
  0,                /* xFileControl */
  0,                /* xSectorSize */
  0,                /* xDeviceCharacteristics */
  0,                /* xShmMap */

Referenced by sqlite3JournalIsInMemory(), and sqlite3JournalOpen().

◆ nName

u8 nName

Definition at line 22328 of file sqlite3.c.

Referenced by findCollSeqEntry(), parseModifier(), sqlite3_bind_parameter_index(), sqlite3ColumnsFromExprList(), sqlite3CreateFunc(), sqlite3CreateIndex(), sqlite3EndTable(), sqlite3FindFunction(), sqlite3IsShadowTableOf(), sqlite3VdbeExec(), sqlite3VListAdd(), and sqlite3VtabCreateModule().

◆ nth_valueName

const char nth_valueName[] = "nth_value"

static

Definition at line 151714 of file sqlite3.c.

Referenced by sqlite3WindowCodeInit(), windowAggStep(), windowInitAccum(), and windowReturnOneRow().

◆ ntileName

const char ntileName[] = "ntile"

static

Definition at line 151712 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ pcache1_g

SQLITE_WSD struct PCacheGlobal pcache1_g

static

◆ percent_rankName

const char percent_rankName[] = "percent_rank"

static

Definition at line 151710 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ pragCName

const char* const pragCName[]

static

Definition at line 125187 of file sqlite3.c.

                                       {
  /*   0 */ "id",          /* Used by: foreign_key_list */
  /*   1 */ "seq",
  /*   2 */ "table",
  /*   3 */ "from",
  /*   4 */ "to",
  /*   5 */ "on_update",
  /*   6 */ "on_delete",
  /*   7 */ "match",
  /*   8 */ "cid",         /* Used by: table_xinfo */
  /*   9 */ "name",
  /*  10 */ "type",
  /*  11 */ "notnull",
  /*  12 */ "dflt_value",
  /*  13 */ "pk",
  /*  14 */ "hidden",
                           /* table_info reuses 8 */
  /*  15 */ "seqno",       /* Used by: index_xinfo */
  /*  16 */ "cid",
  /*  17 */ "name",
  /*  18 */ "desc",
  /*  19 */ "coll",
  /*  20 */ "key",
  /*  21 */ "name",        /* Used by: function_list */
  /*  22 */ "builtin",
  /*  23 */ "type",
  /*  24 */ "enc",
  /*  25 */ "narg",
  /*  26 */ "flags",
  /*  27 */ "tbl",         /* Used by: stats */
  /*  28 */ "idx",
  /*  29 */ "wdth",
  /*  30 */ "hght",
  /*  31 */ "flgs",
  /*  32 */ "seq",         /* Used by: index_list */
  /*  33 */ "name",
  /*  34 */ "unique",
  /*  35 */ "origin",
  /*  36 */ "partial",
  /*  37 */ "table",       /* Used by: foreign_key_check */
  /*  38 */ "rowid",
  /*  39 */ "parent",
  /*  40 */ "fkid",
                           /* index_info reuses 15 */
  /*  41 */ "seq",         /* Used by: database_list */
  /*  42 */ "name",
  /*  43 */ "file",
  /*  44 */ "busy",        /* Used by: wal_checkpoint */
  /*  45 */ "log",
  /*  46 */ "checkpointed",
                           /* collation_list reuses 32 */

◆ pragmaVtabModule

const sqlite3_module pragmaVtabModule

static

Initial value:

= {
  0,                           
  0,                           
  pragmaVtabConnect,           
  pragmaVtabBestIndex,         
  pragmaVtabDisconnect,        
  0,                           
  pragmaVtabOpen,              
  pragmaVtabClose,             
  pragmaVtabFilter,            
  pragmaVtabNext,              
  pragmaVtabEof,               
  pragmaVtabColumn,            
  pragmaVtabRowid,             
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0,                           
  0                            
}

Definition at line 128286 of file sqlite3.c.

                                               {
  0,                           /* iVersion */
  0,                           /* xCreate - create a table */
  pragmaVtabConnect,           /* xConnect - connect to an existing table */
  pragmaVtabBestIndex,         /* xBestIndex - Determine search strategy */
  pragmaVtabDisconnect,        /* xDisconnect - Disconnect from a table */
  0,                           /* xDestroy - Drop a table */
  pragmaVtabOpen,              /* xOpen - open a cursor */
  pragmaVtabClose,             /* xClose - close a cursor */
  pragmaVtabFilter,            /* xFilter - configure scan constraints */
  pragmaVtabNext,              /* xNext - advance a cursor */
  pragmaVtabEof,               /* xEof */
  pragmaVtabColumn,            /* xColumn - read data */
  pragmaVtabRowid,             /* xRowid - read data */
  0,                           /* xUpdate - write data */
  0,                           /* xBegin - begin transaction */
  0,                           /* xSync - sync transaction */
  0,                           /* xCommit - commit transaction */
  0,                           /* xRollback - rollback transaction */
  0,                           /* xFindFunction - function overloading */

Referenced by sqlite3PragmaVtabRegister().

◆ randomnessPid

pid_t randomnessPid = 0

static

Definition at line 33622 of file sqlite3.c.

Referenced by unixOpen(), and unixRandomness().

◆ rankName

const char rankName[] = "rank"

static

Definition at line 151709 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ rLimit

double rLimit

Definition at line 22330 of file sqlite3.c.

◆ row_numberName

const char row_numberName[] = "row_number"

static

Definition at line 151707 of file sqlite3.c.

Referenced by sqlite3WindowUpdate().

◆ rXform

double rXform

Definition at line 22331 of file sqlite3.c.

Referenced by parseModifier().

◆ sqlite3_data_directory

SQLITE_API char * sqlite3_data_directory = 0

Definition at line 7121 of file sqlite3.c.

Referenced by sqlite3_shutdown(), and sqlite3Pragma().

◆ sqlite3_temp_directory

SQLITE_API char * sqlite3_temp_directory = 0

Definition at line 7084 of file sqlite3.c.

Referenced by lsqlite_temp_directory(), sqlite3_shutdown(), and sqlite3Pragma().

◆ sqlite3_unsupported_selecttrace

SQLITE_API u32 sqlite3_unsupported_selecttrace = 0

Definition at line 20669 of file sqlite3.c.

Referenced by flattenSubquery(), havingToWhere(), and sqlite3Select().

◆ sqlite3_version

SQLITE_API const char sqlite3_version[] = SQLITE_VERSION

Definition at line 1210 of file sqlite3.c.

Referenced by sqlite3_libversion().

◆ sqlite3Apis

const sqlite3_api_routines sqlite3Apis

static

Definition at line 124365 of file sqlite3.c.

                                                {
  sqlite3_aggregate_context,
#ifndef SQLITE_OMIT_DEPRECATED
  sqlite3_aggregate_count,
#else
  0,
#endif
  sqlite3_bind_blob,
  sqlite3_bind_double,
  sqlite3_bind_int,
  sqlite3_bind_int64,
  sqlite3_bind_null,
  sqlite3_bind_parameter_count,
  sqlite3_bind_parameter_index,
  sqlite3_bind_parameter_name,
  sqlite3_bind_text,
  sqlite3_bind_text16,
  sqlite3_bind_value,
  sqlite3_busy_handler,
  sqlite3_busy_timeout,
  sqlite3_changes,
  sqlite3_close,
  sqlite3_collation_needed,
  sqlite3_collation_needed16,
  sqlite3_column_blob,
  sqlite3_column_bytes,
  sqlite3_column_bytes16,
  sqlite3_column_count,
  sqlite3_column_database_name,
  sqlite3_column_database_name16,
  sqlite3_column_decltype,
  sqlite3_column_decltype16,
  sqlite3_column_double,
  sqlite3_column_int,
  sqlite3_column_int64,
  sqlite3_column_name,
  sqlite3_column_name16,
  sqlite3_column_origin_name,
  sqlite3_column_origin_name16,
  sqlite3_column_table_name,
  sqlite3_column_table_name16,
  sqlite3_column_text,
  sqlite3_column_text16,
  sqlite3_column_type,
  sqlite3_column_value,
  sqlite3_commit_hook,
  sqlite3_complete,
  sqlite3_complete16,
  sqlite3_create_collation,
  sqlite3_create_collation16,
  sqlite3_create_function,
  sqlite3_create_function16,
  sqlite3_create_module,
  sqlite3_data_count,
  sqlite3_db_handle,
  sqlite3_declare_vtab,
  sqlite3_enable_shared_cache,
  sqlite3_errcode,
  sqlite3_errmsg,
  sqlite3_errmsg16,
  sqlite3_exec,
#ifndef SQLITE_OMIT_DEPRECATED
  sqlite3_expired,
#else
  0,
#endif
  sqlite3_finalize,
  sqlite3_free,
  sqlite3_free_table,
  sqlite3_get_autocommit,
  sqlite3_get_auxdata,
  sqlite3_get_table,
  0,     /* Was sqlite3_global_recover(), but that function is deprecated */
  sqlite3_interrupt,
  sqlite3_last_insert_rowid,
  sqlite3_libversion,
  sqlite3_libversion_number,
  sqlite3_malloc,
  sqlite3_mprintf,
  sqlite3_open,
  sqlite3_open16,
  sqlite3_prepare,
  sqlite3_prepare16,
  sqlite3_profile,
  sqlite3_progress_handler,
  sqlite3_realloc,
  sqlite3_reset,
  sqlite3_result_blob,
  sqlite3_result_double,
  sqlite3_result_error,
  sqlite3_result_error16,
  sqlite3_result_int,
  sqlite3_result_int64,
  sqlite3_result_null,
  sqlite3_result_text,
  sqlite3_result_text16,
  sqlite3_result_text16be,
  sqlite3_result_text16le,
  sqlite3_result_value,
  sqlite3_rollback_hook,
  sqlite3_set_authorizer,
  sqlite3_set_auxdata,
  sqlite3_snprintf,
  sqlite3_step,
  sqlite3_table_column_metadata,
#ifndef SQLITE_OMIT_DEPRECATED
  sqlite3_thread_cleanup,
#else
  0,
#endif
  sqlite3_total_changes,
  sqlite3_trace,
#ifndef SQLITE_OMIT_DEPRECATED
  sqlite3_transfer_bindings,
#else
  0,
#endif
  sqlite3_update_hook,
  sqlite3_user_data,
  sqlite3_value_blob,
  sqlite3_value_bytes,
  sqlite3_value_bytes16,
  sqlite3_value_double,
  sqlite3_value_int,
  sqlite3_value_int64,
  sqlite3_value_numeric_type,
  sqlite3_value_text,
  sqlite3_value_text16,
  sqlite3_value_text16be,
  sqlite3_value_text16le,
  sqlite3_value_type,
  sqlite3_vmprintf,
  /*
  ** The original API set ends here.  All extensions can call any
  ** of the APIs above provided that the pointer is not NULL.  But
  ** before calling APIs that follow, extension should check the
  ** sqlite3_libversion_number() to make sure they are dealing with
  ** a library that is new enough to support that API.
  *************************************************************************
  */
  sqlite3_overload_function,
 
  /*
  ** Added after 3.3.13
  */
  sqlite3_prepare_v2,
  sqlite3_prepare16_v2,
  sqlite3_clear_bindings,
 
  /*
  ** Added for 3.4.1
  */
  sqlite3_create_module_v2,
 
  /*
  ** Added for 3.5.0
  */
  sqlite3_bind_zeroblob,
  sqlite3_blob_bytes,
  sqlite3_blob_close,
  sqlite3_blob_open,
  sqlite3_blob_read,
  sqlite3_blob_write,
  sqlite3_create_collation_v2,
  sqlite3_file_control,
  sqlite3_memory_highwater,
  sqlite3_memory_used,
#ifdef SQLITE_MUTEX_OMIT
  0,
  0,
  0,
  0,
  0,
#else
  sqlite3_mutex_alloc,
  sqlite3_mutex_enter,
  sqlite3_mutex_free,
  sqlite3_mutex_leave,
  sqlite3_mutex_try,
#endif
  sqlite3_open_v2,
  sqlite3_release_memory,
  sqlite3_result_error_nomem,
  sqlite3_result_error_toobig,
  sqlite3_sleep,
  sqlite3_soft_heap_limit,
  sqlite3_vfs_find,
  sqlite3_vfs_register,
  sqlite3_vfs_unregister,
 
  /*
  ** Added for 3.5.8
  */
  sqlite3_threadsafe,
  sqlite3_result_zeroblob,
  sqlite3_result_error_code,
  sqlite3_test_control,
  sqlite3_randomness,
  sqlite3_context_db_handle,
 
  /*
  ** Added for 3.6.0
  */
  sqlite3_extended_result_codes,
  sqlite3_limit,
  sqlite3_next_stmt,
  sqlite3_sql,
  sqlite3_status,
 
  /*
  ** Added for 3.7.4
  */
  sqlite3_backup_finish,
  sqlite3_backup_init,
  sqlite3_backup_pagecount,
  sqlite3_backup_remaining,
  sqlite3_backup_step,
#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
  sqlite3_compileoption_get,
  sqlite3_compileoption_used,
#else
  0,
  0,
#endif
  sqlite3_create_function_v2,
  sqlite3_db_config,
  sqlite3_db_mutex,
  sqlite3_db_status,
  sqlite3_extended_errcode,
  sqlite3_log,
  sqlite3_soft_heap_limit64,
  sqlite3_sourceid,
  sqlite3_stmt_status,
  sqlite3_strnicmp,
#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
  sqlite3_unlock_notify,
#else
  0,
#endif
#ifndef SQLITE_OMIT_WAL
  sqlite3_wal_autocheckpoint,
  sqlite3_wal_checkpoint,
  sqlite3_wal_hook,
#else
  0,
  0,
  0,
#endif
  sqlite3_blob_reopen,
  sqlite3_vtab_config,
  sqlite3_vtab_on_conflict,
  sqlite3_close_v2,
  sqlite3_db_filename,
  sqlite3_db_readonly,
  sqlite3_db_release_memory,
  sqlite3_errstr,
  sqlite3_stmt_busy,
  sqlite3_stmt_readonly,
  sqlite3_stricmp,
  sqlite3_uri_boolean,
  sqlite3_uri_int64,
  sqlite3_uri_parameter,
  sqlite3_vsnprintf,
  sqlite3_wal_checkpoint_v2,
  /* Version 3.8.7 and later */
  sqlite3_auto_extension,
  sqlite3_bind_blob64,
  sqlite3_bind_text64,
  sqlite3_cancel_auto_extension,
  sqlite3_load_extension,
  sqlite3_malloc64,
  sqlite3_msize,
  sqlite3_realloc64,
  sqlite3_reset_auto_extension,
  sqlite3_result_blob64,
  sqlite3_result_text64,
  sqlite3_strglob,
  /* Version 3.8.11 and later */
  (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup,
  sqlite3_value_free,
  sqlite3_result_zeroblob64,
  sqlite3_bind_zeroblob64,
  /* Version 3.9.0 and later */
  sqlite3_value_subtype,
  sqlite3_result_subtype,
  /* Version 3.10.0 and later */
  sqlite3_status64,
  sqlite3_strlike,
  sqlite3_db_cacheflush,
  /* Version 3.12.0 and later */
  sqlite3_system_errno,
  /* Version 3.14.0 and later */
  sqlite3_trace_v2,
  sqlite3_expanded_sql,
  /* Version 3.18.0 and later */
  sqlite3_set_last_insert_rowid,
  /* Version 3.20.0 and later */
  sqlite3_prepare_v3,
  sqlite3_prepare16_v3,
  sqlite3_bind_pointer,
  sqlite3_result_pointer,
  sqlite3_value_pointer,
  /* Version 3.22.0 and later */
  sqlite3_vtab_nochange,
  sqlite3_value_nochange,
  sqlite3_vtab_collation,
  /* Version 3.24.0 and later */
  sqlite3_keyword_count,
  sqlite3_keyword_name,
  sqlite3_keyword_check,
  sqlite3_str_new,
  sqlite3_str_finish,
  sqlite3_str_appendf,
  sqlite3_str_vappendf,
  sqlite3_str_append,
  sqlite3_str_appendall,
  sqlite3_str_appendchar,
  sqlite3_str_reset,
  sqlite3_str_errcode,
  sqlite3_str_length,
  sqlite3_str_value,
  /* Version 3.25.0 and later */
  sqlite3_create_window_function,
  /* Version 3.26.0 and later */
#ifdef SQLITE_ENABLE_NORMALIZE
  sqlite3_normalized_sql,
#else
  0,
#endif
  /* Version 3.28.0 and later */
  sqlite3_stmt_isexplain,
  sqlite3_value_frombind,
  /* Version 3.30.0 and later */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  sqlite3_drop_modules,
#else
  0,
#endif
  /* Version 3.31.0 and later */
  sqlite3_hard_heap_limit64,
  sqlite3_uri_key,
  sqlite3_filename_database,
  sqlite3_filename_journal,

Referenced by sqlite3AutoLoadExtensions(), and sqlite3LoadExtension().

◆ sqlite3Autoext

SQLITE_WSD struct sqlite3AutoExtList sqlite3Autoext = { 0, 0 }

static

◆ sqlite3azCompileOpt

const char* const sqlite3azCompileOpt[]

static

Definition at line 72 of file sqlite3.c.

                                                  {
 
/*
** BEGIN CODE GENERATED BY tool/mkctime.tcl
*/
#if SQLITE_32BIT_ROWID
  "32BIT_ROWID",
#endif
#if SQLITE_4_BYTE_ALIGNED_MALLOC
  "4_BYTE_ALIGNED_MALLOC",
#endif
#if SQLITE_64BIT_STATS
  "64BIT_STATS",
#endif
#if SQLITE_ALLOW_COVERING_INDEX_SCAN
  "ALLOW_COVERING_INDEX_SCAN",
#endif
#if SQLITE_ALLOW_URI_AUTHORITY
  "ALLOW_URI_AUTHORITY",
#endif
#ifdef SQLITE_BITMASK_TYPE
  "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE),
#endif
#if SQLITE_BUG_COMPATIBLE_20160819
  "BUG_COMPATIBLE_20160819",
#endif
#if SQLITE_CASE_SENSITIVE_LIKE
  "CASE_SENSITIVE_LIKE",
#endif
#if SQLITE_CHECK_PAGES
  "CHECK_PAGES",
#endif
#if defined(__clang__) && defined(__clang_major__)
  "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "."
                    CTIMEOPT_VAL(__clang_minor__) "."
                    CTIMEOPT_VAL(__clang_patchlevel__),
#elif defined(_MSC_VER)
  "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),
#elif defined(__GNUC__) && defined(__VERSION__)
  "COMPILER=gcc-" __VERSION__,
#endif
#if SQLITE_COVERAGE_TEST
  "COVERAGE_TEST",
#endif
#if SQLITE_DEBUG
  "DEBUG",
#endif
#if SQLITE_DEFAULT_AUTOMATIC_INDEX
  "DEFAULT_AUTOMATIC_INDEX",
#endif
#if SQLITE_DEFAULT_AUTOVACUUM
  "DEFAULT_AUTOVACUUM",
#endif
#ifdef SQLITE_DEFAULT_CACHE_SIZE
  "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE),
#endif
#if SQLITE_DEFAULT_CKPTFULLFSYNC
  "DEFAULT_CKPTFULLFSYNC",
#endif
#ifdef SQLITE_DEFAULT_FILE_FORMAT
  "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT),
#endif
#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS
  "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS),
#endif
#if SQLITE_DEFAULT_FOREIGN_KEYS
  "DEFAULT_FOREIGN_KEYS",
#endif
#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
  "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT),
#endif
#ifdef SQLITE_DEFAULT_LOCKING_MODE
  "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
#endif
#ifdef SQLITE_DEFAULT_LOOKASIDE
  "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
#endif
#if SQLITE_DEFAULT_MEMSTATUS
  "DEFAULT_MEMSTATUS",
#endif
#ifdef SQLITE_DEFAULT_MMAP_SIZE
  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
#endif
#ifdef SQLITE_DEFAULT_PAGE_SIZE
  "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE),
#endif
#ifdef SQLITE_DEFAULT_PCACHE_INITSZ
  "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ),
#endif
#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
  "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS),
#endif
#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
  "DEFAULT_RECURSIVE_TRIGGERS",
#endif
#ifdef SQLITE_DEFAULT_ROWEST
  "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST),
#endif
#ifdef SQLITE_DEFAULT_SECTOR_SIZE
  "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE),
#endif
#ifdef SQLITE_DEFAULT_SYNCHRONOUS
  "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS),
#endif
#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
  "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT),
#endif
#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS
  "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS),
#endif
#ifdef SQLITE_DEFAULT_WORKER_THREADS
  "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS),
#endif
#if SQLITE_DIRECT_OVERFLOW_READ
  "DIRECT_OVERFLOW_READ",
#endif
#if SQLITE_DISABLE_DIRSYNC
  "DISABLE_DIRSYNC",
#endif
#if SQLITE_DISABLE_FTS3_UNICODE
  "DISABLE_FTS3_UNICODE",
#endif
#if SQLITE_DISABLE_FTS4_DEFERRED
  "DISABLE_FTS4_DEFERRED",
#endif
#if SQLITE_DISABLE_INTRINSIC
  "DISABLE_INTRINSIC",
#endif
#if SQLITE_DISABLE_LFS
  "DISABLE_LFS",
#endif
#if SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
  "DISABLE_PAGECACHE_OVERFLOW_STATS",
#endif
#if SQLITE_DISABLE_SKIPAHEAD_DISTINCT
  "DISABLE_SKIPAHEAD_DISTINCT",
#endif
#ifdef SQLITE_ENABLE_8_3_NAMES
  "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES),
#endif
#if SQLITE_ENABLE_API_ARMOR
  "ENABLE_API_ARMOR",
#endif
#if SQLITE_ENABLE_ATOMIC_WRITE
  "ENABLE_ATOMIC_WRITE",
#endif
#if SQLITE_ENABLE_BATCH_ATOMIC_WRITE
  "ENABLE_BATCH_ATOMIC_WRITE",
#endif
#if SQLITE_ENABLE_BYTECODE_VTAB
  "ENABLE_BYTECODE_VTAB",
#endif
#if SQLITE_ENABLE_CEROD
  "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
#endif
#if SQLITE_ENABLE_COLUMN_METADATA
  "ENABLE_COLUMN_METADATA",
#endif
#if SQLITE_ENABLE_COLUMN_USED_MASK
  "ENABLE_COLUMN_USED_MASK",
#endif
#if SQLITE_ENABLE_COSTMULT
  "ENABLE_COSTMULT",
#endif
#if SQLITE_ENABLE_CURSOR_HINTS
  "ENABLE_CURSOR_HINTS",
#endif
#if SQLITE_ENABLE_DBSTAT_VTAB
  "ENABLE_DBSTAT_VTAB",
#endif
#if SQLITE_ENABLE_EXPENSIVE_ASSERT
  "ENABLE_EXPENSIVE_ASSERT",
#endif
#if SQLITE_ENABLE_FTS1
  "ENABLE_FTS1",
#endif
#if SQLITE_ENABLE_FTS2
  "ENABLE_FTS2",
#endif
#if SQLITE_ENABLE_FTS3
  "ENABLE_FTS3",
#endif
#if SQLITE_ENABLE_FTS3_PARENTHESIS
  "ENABLE_FTS3_PARENTHESIS",
#endif
#if SQLITE_ENABLE_FTS3_TOKENIZER
  "ENABLE_FTS3_TOKENIZER",
#endif
#if SQLITE_ENABLE_FTS4
  "ENABLE_FTS4",
#endif
#if SQLITE_ENABLE_FTS5
  "ENABLE_FTS5",
#endif
#if SQLITE_ENABLE_GEOPOLY
  "ENABLE_GEOPOLY",
#endif
#if SQLITE_ENABLE_HIDDEN_COLUMNS
  "ENABLE_HIDDEN_COLUMNS",
#endif
#if SQLITE_ENABLE_ICU
  "ENABLE_ICU",
#endif
#if SQLITE_ENABLE_IOTRACE
  "ENABLE_IOTRACE",
#endif
#if SQLITE_ENABLE_JSON1
  "ENABLE_JSON1",
#endif
#if SQLITE_ENABLE_LOAD_EXTENSION
  "ENABLE_LOAD_EXTENSION",
#endif
#ifdef SQLITE_ENABLE_LOCKING_STYLE
  "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
#endif
#if SQLITE_ENABLE_MEMORY_MANAGEMENT
  "ENABLE_MEMORY_MANAGEMENT",
#endif
#if SQLITE_ENABLE_MEMSYS3
  "ENABLE_MEMSYS3",
#endif
#if SQLITE_ENABLE_MEMSYS5
  "ENABLE_MEMSYS5",
#endif
#if SQLITE_ENABLE_MULTIPLEX
  "ENABLE_MULTIPLEX",
#endif
#if SQLITE_ENABLE_NORMALIZE
  "ENABLE_NORMALIZE",
#endif
#if SQLITE_ENABLE_NULL_TRIM
  "ENABLE_NULL_TRIM",
#endif
#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK
  "ENABLE_OVERSIZE_CELL_CHECK",
#endif
#if SQLITE_ENABLE_PREUPDATE_HOOK
  "ENABLE_PREUPDATE_HOOK",
#endif
#if SQLITE_ENABLE_QPSG
  "ENABLE_QPSG",
#endif
#if SQLITE_ENABLE_RBU
  "ENABLE_RBU",
#endif
#if SQLITE_ENABLE_RTREE
  "ENABLE_RTREE",
#endif
#if SQLITE_ENABLE_SELECTTRACE
  "ENABLE_SELECTTRACE",
#endif
#if SQLITE_ENABLE_SESSION
  "ENABLE_SESSION",
#endif
#if SQLITE_ENABLE_SNAPSHOT
  "ENABLE_SNAPSHOT",
#endif
#if SQLITE_ENABLE_SORTER_REFERENCES
  "ENABLE_SORTER_REFERENCES",
#endif
#if SQLITE_ENABLE_SQLLOG
  "ENABLE_SQLLOG",
#endif
#if defined(SQLITE_ENABLE_STAT4)
  "ENABLE_STAT4",
#endif
#if SQLITE_ENABLE_STMTVTAB
  "ENABLE_STMTVTAB",
#endif
#if SQLITE_ENABLE_STMT_SCANSTATUS
  "ENABLE_STMT_SCANSTATUS",
#endif
#if SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
  "ENABLE_UNKNOWN_SQL_FUNCTION",
#endif
#if SQLITE_ENABLE_UNLOCK_NOTIFY
  "ENABLE_UNLOCK_NOTIFY",
#endif
#if SQLITE_ENABLE_UPDATE_DELETE_LIMIT
  "ENABLE_UPDATE_DELETE_LIMIT",
#endif
#if SQLITE_ENABLE_URI_00_ERROR
  "ENABLE_URI_00_ERROR",
#endif
#if SQLITE_ENABLE_VFSTRACE
  "ENABLE_VFSTRACE",
#endif
#if SQLITE_ENABLE_WHERETRACE
  "ENABLE_WHERETRACE",
#endif
#if SQLITE_ENABLE_ZIPVFS
  "ENABLE_ZIPVFS",
#endif
#if SQLITE_EXPLAIN_ESTIMATED_ROWS
  "EXPLAIN_ESTIMATED_ROWS",
#endif
#if SQLITE_EXTRA_IFNULLROW
  "EXTRA_IFNULLROW",
#endif
#ifdef SQLITE_EXTRA_INIT
  "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT),
#endif
#ifdef SQLITE_EXTRA_SHUTDOWN
  "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN),
#endif
#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH
  "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH),
#endif
#if SQLITE_FTS5_ENABLE_TEST_MI
  "FTS5_ENABLE_TEST_MI",
#endif
#if SQLITE_FTS5_NO_WITHOUT_ROWID
  "FTS5_NO_WITHOUT_ROWID",
#endif
#if HAVE_ISNAN || SQLITE_HAVE_ISNAN
  "HAVE_ISNAN",
#endif
#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX
  "HOMEGROWN_RECURSIVE_MUTEX",
#endif
#if SQLITE_IGNORE_AFP_LOCK_ERRORS
  "IGNORE_AFP_LOCK_ERRORS",
#endif
#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS
  "IGNORE_FLOCK_LOCK_ERRORS",
#endif
#if SQLITE_INLINE_MEMCPY
  "INLINE_MEMCPY",
#endif
#if SQLITE_INT64_TYPE
  "INT64_TYPE",
#endif
#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX
  "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX),
#endif
#if SQLITE_LIKE_DOESNT_MATCH_BLOBS
  "LIKE_DOESNT_MATCH_BLOBS",
#endif
#if SQLITE_LOCK_TRACE
  "LOCK_TRACE",
#endif
#if SQLITE_LOG_CACHE_SPILL
  "LOG_CACHE_SPILL",
#endif
#ifdef SQLITE_MALLOC_SOFT_LIMIT
  "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT),
#endif
#ifdef SQLITE_MAX_ATTACHED
  "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED),
#endif
#ifdef SQLITE_MAX_COLUMN
  "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN),
#endif
#ifdef SQLITE_MAX_COMPOUND_SELECT
  "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT),
#endif
#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE
  "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE),
#endif
#ifdef SQLITE_MAX_EXPR_DEPTH
  "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH),
#endif
#ifdef SQLITE_MAX_FUNCTION_ARG
  "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG),
#endif
#ifdef SQLITE_MAX_LENGTH
  "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH),
#endif
#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH
  "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH),
#endif
#ifdef SQLITE_MAX_MEMORY
  "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY),
#endif
#ifdef SQLITE_MAX_MMAP_SIZE
  "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),
#endif
#ifdef SQLITE_MAX_MMAP_SIZE_
  "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_),
#endif
#ifdef SQLITE_MAX_PAGE_COUNT
  "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT),
#endif
#ifdef SQLITE_MAX_PAGE_SIZE
  "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE),
#endif
#ifdef SQLITE_MAX_SCHEMA_RETRY
  "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
#endif
#ifdef SQLITE_MAX_SQL_LENGTH
  "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH),
#endif
#ifdef SQLITE_MAX_TRIGGER_DEPTH
  "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH),
#endif
#ifdef SQLITE_MAX_VARIABLE_NUMBER
  "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER),
#endif
#ifdef SQLITE_MAX_VDBE_OP
  "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP),
#endif
#ifdef SQLITE_MAX_WORKER_THREADS
  "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS),
#endif
#if SQLITE_MEMDEBUG
  "MEMDEBUG",
#endif
#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT
  "MIXED_ENDIAN_64BIT_FLOAT",
#endif
#if SQLITE_MMAP_READWRITE
  "MMAP_READWRITE",
#endif
#if SQLITE_MUTEX_NOOP
  "MUTEX_NOOP",
#endif
#if SQLITE_MUTEX_NREF
  "MUTEX_NREF",
#endif
#if SQLITE_MUTEX_OMIT
  "MUTEX_OMIT",
#endif
#if SQLITE_MUTEX_PTHREADS
  "MUTEX_PTHREADS",
#endif
#if SQLITE_MUTEX_W32
  "MUTEX_W32",
#endif
#if SQLITE_NEED_ERR_NAME
  "NEED_ERR_NAME",
#endif
#if SQLITE_NOINLINE
  "NOINLINE",
#endif
#if SQLITE_NO_SYNC
  "NO_SYNC",
#endif
#if SQLITE_OMIT_ALTERTABLE
  "OMIT_ALTERTABLE",
#endif
#if SQLITE_OMIT_ANALYZE
  "OMIT_ANALYZE",
#endif
#if SQLITE_OMIT_ATTACH
  "OMIT_ATTACH",
#endif
#if SQLITE_OMIT_AUTHORIZATION
  "OMIT_AUTHORIZATION",
#endif
#if SQLITE_OMIT_AUTOINCREMENT
  "OMIT_AUTOINCREMENT",
#endif
#if SQLITE_OMIT_AUTOINIT
  "OMIT_AUTOINIT",
#endif
#if SQLITE_OMIT_AUTOMATIC_INDEX
  "OMIT_AUTOMATIC_INDEX",
#endif
#if SQLITE_OMIT_AUTORESET
  "OMIT_AUTORESET",
#endif
#if SQLITE_OMIT_AUTOVACUUM
  "OMIT_AUTOVACUUM",
#endif
#if SQLITE_OMIT_BETWEEN_OPTIMIZATION
  "OMIT_BETWEEN_OPTIMIZATION",
#endif
#if SQLITE_OMIT_BLOB_LITERAL
  "OMIT_BLOB_LITERAL",
#endif
#if SQLITE_OMIT_CAST
  "OMIT_CAST",
#endif
#if SQLITE_OMIT_CHECK
  "OMIT_CHECK",
#endif
#if SQLITE_OMIT_COMPLETE
  "OMIT_COMPLETE",
#endif
#if SQLITE_OMIT_COMPOUND_SELECT
  "OMIT_COMPOUND_SELECT",
#endif
#if SQLITE_OMIT_CONFLICT_CLAUSE
  "OMIT_CONFLICT_CLAUSE",
#endif
#if SQLITE_OMIT_CTE
  "OMIT_CTE",
#endif
#if SQLITE_OMIT_DATETIME_FUNCS
  "OMIT_DATETIME_FUNCS",
#endif
#if SQLITE_OMIT_DECLTYPE
  "OMIT_DECLTYPE",
#endif
#if SQLITE_OMIT_DEPRECATED
  "OMIT_DEPRECATED",
#endif
#if SQLITE_OMIT_DISKIO
  "OMIT_DISKIO",
#endif
#if SQLITE_OMIT_EXPLAIN
  "OMIT_EXPLAIN",
#endif
#if SQLITE_OMIT_FLAG_PRAGMAS
  "OMIT_FLAG_PRAGMAS",
#endif
#if SQLITE_OMIT_FLOATING_POINT
  "OMIT_FLOATING_POINT",
#endif
#if SQLITE_OMIT_FOREIGN_KEY
  "OMIT_FOREIGN_KEY",
#endif
#if SQLITE_OMIT_GET_TABLE
  "OMIT_GET_TABLE",
#endif
#if SQLITE_OMIT_HEX_INTEGER
  "OMIT_HEX_INTEGER",
#endif
#if SQLITE_OMIT_INCRBLOB
  "OMIT_INCRBLOB",
#endif
#if SQLITE_OMIT_INTEGRITY_CHECK
  "OMIT_INTEGRITY_CHECK",
#endif
#if SQLITE_OMIT_LIKE_OPTIMIZATION
  "OMIT_LIKE_OPTIMIZATION",
#endif
#if SQLITE_OMIT_LOAD_EXTENSION
  "OMIT_LOAD_EXTENSION",
#endif
#if SQLITE_OMIT_LOCALTIME
  "OMIT_LOCALTIME",
#endif
#if SQLITE_OMIT_LOOKASIDE
  "OMIT_LOOKASIDE",
#endif
#if SQLITE_OMIT_MEMORYDB
  "OMIT_MEMORYDB",
#endif
#if SQLITE_OMIT_OR_OPTIMIZATION
  "OMIT_OR_OPTIMIZATION",
#endif
#if SQLITE_OMIT_PAGER_PRAGMAS
  "OMIT_PAGER_PRAGMAS",
#endif
#if SQLITE_OMIT_PARSER_TRACE
  "OMIT_PARSER_TRACE",
#endif
#if SQLITE_OMIT_POPEN
  "OMIT_POPEN",
#endif
#if SQLITE_OMIT_PRAGMA
  "OMIT_PRAGMA",
#endif
#if SQLITE_OMIT_PROGRESS_CALLBACK
  "OMIT_PROGRESS_CALLBACK",
#endif
#if SQLITE_OMIT_QUICKBALANCE
  "OMIT_QUICKBALANCE",
#endif
#if SQLITE_OMIT_REINDEX
  "OMIT_REINDEX",
#endif
#if SQLITE_OMIT_SCHEMA_PRAGMAS
  "OMIT_SCHEMA_PRAGMAS",
#endif
#if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
  "OMIT_SCHEMA_VERSION_PRAGMAS",
#endif
#if SQLITE_OMIT_SHARED_CACHE
  "OMIT_SHARED_CACHE",
#endif
#if SQLITE_OMIT_SHUTDOWN_DIRECTORIES
  "OMIT_SHUTDOWN_DIRECTORIES",
#endif
#if SQLITE_OMIT_SUBQUERY
  "OMIT_SUBQUERY",
#endif
#if SQLITE_OMIT_TCL_VARIABLE
  "OMIT_TCL_VARIABLE",
#endif
#if SQLITE_OMIT_TEMPDB
  "OMIT_TEMPDB",
#endif
#if SQLITE_OMIT_TEST_CONTROL
  "OMIT_TEST_CONTROL",
#endif
#if SQLITE_OMIT_TRACE
  "OMIT_TRACE",
#endif
#if SQLITE_OMIT_TRIGGER
  "OMIT_TRIGGER",
#endif
#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION
  "OMIT_TRUNCATE_OPTIMIZATION",
#endif
#if SQLITE_OMIT_UTF16
  "OMIT_UTF16",
#endif
#if SQLITE_OMIT_VACUUM
  "OMIT_VACUUM",
#endif
#if SQLITE_OMIT_VIEW
  "OMIT_VIEW",
#endif
#if SQLITE_OMIT_VIRTUALTABLE
  "OMIT_VIRTUALTABLE",
#endif
#if SQLITE_OMIT_WAL
  "OMIT_WAL",
#endif
#if SQLITE_OMIT_WSD
  "OMIT_WSD",
#endif
#if SQLITE_OMIT_XFER_OPT
  "OMIT_XFER_OPT",
#endif
#if SQLITE_PCACHE_SEPARATE_HEADER
  "PCACHE_SEPARATE_HEADER",
#endif
#if SQLITE_PERFORMANCE_TRACE
  "PERFORMANCE_TRACE",
#endif
#if SQLITE_POWERSAFE_OVERWRITE
  "POWERSAFE_OVERWRITE",
#endif
#if SQLITE_PREFER_PROXY_LOCKING
  "PREFER_PROXY_LOCKING",
#endif
#if SQLITE_PROXY_DEBUG
  "PROXY_DEBUG",
#endif
#if SQLITE_REVERSE_UNORDERED_SELECTS
  "REVERSE_UNORDERED_SELECTS",
#endif
#if SQLITE_RTREE_INT_ONLY
  "RTREE_INT_ONLY",
#endif
#if SQLITE_SECURE_DELETE
  "SECURE_DELETE",
#endif
#if SQLITE_SMALL_STACK
  "SMALL_STACK",
#endif
#ifdef SQLITE_SORTER_PMASZ
  "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ),
#endif
#if SQLITE_SOUNDEX
  "SOUNDEX",
#endif
#ifdef SQLITE_STAT4_SAMPLES
  "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES),
#endif
#ifdef SQLITE_STMTJRNL_SPILL
  "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
#endif
#if SQLITE_SUBSTR_COMPATIBILITY
  "SUBSTR_COMPATIBILITY",
#endif
#if SQLITE_SYSTEM_MALLOC
  "SYSTEM_MALLOC",
#endif
#if SQLITE_TCL
  "TCL",
#endif
#ifdef SQLITE_TEMP_STORE
  "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
#endif
#if SQLITE_TEST
  "TEST",
#endif
#if defined(SQLITE_THREADSAFE)
  "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
#elif defined(THREADSAFE)
  "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE),
#else
  "THREADSAFE=1",
#endif
#if SQLITE_UNLINK_AFTER_CLOSE
  "UNLINK_AFTER_CLOSE",
#endif
#if SQLITE_UNTESTABLE
  "UNTESTABLE",
#endif
#if SQLITE_USER_AUTHENTICATION
  "USER_AUTHENTICATION",
#endif
#if SQLITE_USE_ALLOCA
  "USE_ALLOCA",
#endif
#if SQLITE_USE_FCNTL_TRACE
  "USE_FCNTL_TRACE",
#endif
#if SQLITE_USE_URI
  "USE_URI",
#endif
#if SQLITE_VDBE_COVERAGE
  "VDBE_COVERAGE",
#endif
#if SQLITE_WIN32_MALLOC
  "WIN32_MALLOC",
#endif
#if SQLITE_ZERO_MALLOC
  "ZERO_MALLOC",
#endif
/*
** END CODE GENERATED BY tool/mkctime.tcl
*/
};

Referenced by sqlite3CompileOptions().

◆ sqlite3BuiltinExtensions

int(*const sqlite3BuiltinExtensions[])(sqlite3 *) ( sqlite3 * )

static

Definition at line 161057 of file sqlite3.c.

                                                           {
#ifdef SQLITE_ENABLE_FTS1
  sqlite3Fts1Init,
#endif
#ifdef SQLITE_ENABLE_FTS2
  sqlite3Fts2Init,
#endif
#ifdef SQLITE_ENABLE_FTS3
  sqlite3Fts3Init,
#endif
#ifdef SQLITE_ENABLE_FTS5
  sqlite3Fts5Init,
#endif
#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS)
  sqlite3IcuInit,
#endif
#ifdef SQLITE_ENABLE_RTREE
  sqlite3RtreeInit,
#endif
#ifdef SQLITE_ENABLE_DBPAGE_VTAB
  sqlite3DbpageRegister,
#endif
#ifdef SQLITE_ENABLE_DBSTAT_VTAB
  sqlite3DbstatRegister,
#endif
  sqlite3TestExtInit,
#ifdef SQLITE_ENABLE_JSON1
  sqlite3Json1Init,
#endif
#ifdef SQLITE_ENABLE_STMTVTAB

Referenced by openDatabase().

◆ sqlite3BuiltinFunctions

SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions

Definition at line 20634 of file sqlite3.c.

Referenced by sqlite3_initialize(), sqlite3Pragma(), and sqlite3RegisterBuiltinFunctions().

◆ sqlite3Config

SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config

Definition at line 20573 of file sqlite3.c.

                                                               {
   SQLITE_DEFAULT_MEMSTATUS,  /* bMemstat */
   1,                         /* bCoreMutex */
   SQLITE_THREADSAFE==1,      /* bFullMutex */
   SQLITE_USE_URI,            /* bOpenUri */
   SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */
   0,                         /* bSmallMalloc */
   1,                         /* bExtraSchemaChecks */
   0x7ffffffe,                /* mxStrlen */
   0,                         /* neverCorrupt */
   SQLITE_DEFAULT_LOOKASIDE,  /* szLookaside, nLookaside */
   SQLITE_STMTJRNL_SPILL,     /* nStmtSpill */
   {0,0,0,0,0,0,0,0},         /* m */
   {0,0,0,0,0,0,0,0,0},       /* mutex */
   {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
   (void*)0,                  /* pHeap */
   0,                         /* nHeap */
   0, 0,                      /* mnHeap, mxHeap */
   SQLITE_DEFAULT_MMAP_SIZE,  /* szMmap */
   SQLITE_MAX_MMAP_SIZE,      /* mxMmap */
   (void*)0,                  /* pPage */
   0,                         /* szPage */
   SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */
   0,                         /* mxParserStack */
   0,                         /* sharedCacheEnabled */
   SQLITE_SORTER_PMASZ,       /* szPma */
   /* All the rest should always be initialized to zero */
   0,                         /* isInit */
   0,                         /* inProgress */
   0,                         /* isMutexInit */
   0,                         /* isMallocInit */
   0,                         /* isPCacheInit */
   0,                         /* nRefInitMutex */
   0,                         /* pInitMutex */
   0,                         /* xLog */
   0,                         /* pLogArg */
#ifdef SQLITE_ENABLE_SQLLOG
   0,                         /* xSqllog */
   0,                         /* pSqllogArg */
#endif
#ifdef SQLITE_VDBE_COVERAGE
   0,                         /* xVdbeBranch */
   0,                         /* pVbeBranchArg */
#endif
#ifdef SQLITE_ENABLE_DESERIALIZE
   SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */
#endif
#ifndef SQLITE_UNTESTABLE
   0,                         /* xTestCallback */
#endif

Referenced by openSubJournal(), pager_open_journal(), sqlite3CheckObjectName(), and sqlite3InitCallback().

◆ sqlite3CtypeMap

SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256]

Definition at line 20453 of file sqlite3.c.

                                                          {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 00..07    ........ */
  0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,  /* 08..0f    ........ */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 10..17    ........ */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 18..1f    ........ */
  0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80,  /* 20..27     !"#$%&' */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 28..2f    ()*+,-./ */
  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,  /* 30..37    01234567 */
  0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 38..3f    89:;<=>? */
 
  0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02,  /* 40..47    @ABCDEFG */
  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 48..4f    HIJKLMNO */
  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 50..57    PQRSTUVW */
  0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40,  /* 58..5f    XYZ[\]^_ */
  0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22,  /* 60..67    `abcdefg */
  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 68..6f    hijklmno */
  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 70..77    pqrstuvw */
  0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 78..7f    xyz{|}~. */
 
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 80..87    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 88..8f    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 90..97    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 98..9f    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a0..a7    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a8..af    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b0..b7    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b8..bf    ........ */
 
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c0..c7    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c8..cf    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d0..d7    ........ */
  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d8..df    ........ */

Referenced by sqlite3VdbeExec().

◆ sqlite3Hooks

SQLITE_WSD struct BenignMallocHooks sqlite3Hooks = { 0, 0 }

static

◆ sqlite3one

const int sqlite3one = 1

Definition at line 14450 of file sqlite3.c.

◆ sqlite3OomStr

sqlite3_str sqlite3OomStr

static

Initial value:

= {
   0, 0, 0, 0, 0, SQLITE_NOMEM, 0
}

Definition at line 29179 of file sqlite3.c.

◆ sqlite3OpcodeProperty

SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER

Definition at line 20678 of file sqlite3.c.

Referenced by resolveP2Values(), sqlite3GenerateConstraintChecks(), sqlite3VdbeAddOpList(), and sqlite3VdbeExec().

◆ sqlite3OsDlSym

SQLITE_PRIVATE void()(void) sqlite3OsDlSym(sqlite3_vfs pVfs, void pHdle, const char zSym)	(	sqlite3_vfs *	pVfs,
		void *	pHdle,
		const char *	zSym )

Definition at line 16471 of file sqlite3.c.

Referenced by sqlite3LoadExtension().

◆ sqlite3PendingByte

SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000

Definition at line 20663 of file sqlite3.c.

◆ sqlite3Prng

SQLITE_WSD struct sqlite3PrngType sqlite3Prng

static

◆ sqlite3SavedPrng

SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng

static

Definition at line 30347 of file sqlite3.c.

◆ sqlite3SharedCacheList

BtShared* SQLITE_WSD sqlite3SharedCacheList = 0

static

Definition at line 64554 of file sqlite3.c.

Referenced by removeFromSharingList(), and sqlite3BtreeOpen().

◆ sqlite3SmallTypeSizes

const u8 sqlite3SmallTypeSizes[]

static

Initial value:

= {
        
   0,  1,  2,  3,  4,  6,  8,  8,  0,  0,
   0,  0,  0,  0,  1,  1,  2,  2,  3,  3,
   4,  4,  5,  5,  6,  6,  7,  7,  8,  8,
   9,  9, 10, 10, 11, 11, 12, 12, 13, 13,
  14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
  19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
  24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
  29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
  34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
  39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
  44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
  49, 49, 50, 50, 51, 51, 52, 52, 53, 53,
  54, 54, 55, 55, 56, 56, 57, 57
}

Definition at line 81433 of file sqlite3.c.

                                          {
        /*  0   1   2   3   4   5   6   7   8   9 */
/*   0 */   0,  1,  2,  3,  4,  6,  8,  8,  0,  0,
/*  10 */   0,  0,  0,  0,  1,  1,  2,  2,  3,  3,
/*  20 */   4,  4,  5,  5,  6,  6,  7,  7,  8,  8,
/*  30 */   9,  9, 10, 10, 11, 11, 12, 12, 13, 13,
/*  40 */  14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
/*  50 */  19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
/*  60 */  24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
/*  70 */  29, 29, 30, 30, 31, 31, 32, 32, 33, 33,

Referenced by sqlite3VdbeIdxRowid(), and sqlite3VdbeSerialPut().

◆ sqlite3Stat

SQLITE_WSD struct sqlite3StatType sqlite3Stat = { {0,}, {0,} }

static

◆ sqlite3StrBINARY

SQLITE_PRIVATE const char sqlite3StrBINARY[] = "BINARY"

Definition at line 20683 of file sqlite3.c.

Referenced by constructAutomaticIndex(), convertToWithoutRowidTable(), exprAnalyze(), openDatabase(), sqlite3_table_column_metadata(), sqlite3_vtab_collation(), sqlite3CreateIndex(), sqlite3FkLocateIndex(), sqlite3KeyInfoOfIndex(), whereIndexExprTrans(), and xferOptimization().

◆ sqlite3UpperToLower

SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[]

Definition at line 20387 of file sqlite3.c.

                                                           {
#ifdef SQLITE_ASCII
      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
     36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
     54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
    104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
    122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
    108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
    126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
    144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
    162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
    180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
    252,253,254,255
#endif
#ifdef SQLITE_EBCDIC
      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */
     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
     64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
     80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
     96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */
    112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */
    128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
    144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */
    160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
    176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
    192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */

Referenced by exprAnalyze(), parseModifier(), sqlite3AffinityType(), sqlite3FindFunction(), sqlite3LoadExtension(), and sqlite3VtabOverloadFunction().

◆ sqlite3Utf8Trans1

const unsigned char sqlite3Utf8Trans1[]

static

Initial value:

= {
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
}

Definition at line 30694 of file sqlite3.c.

                                                 {
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

Referenced by sqlite3Utf8Read().

◆ statGetFuncdef

const FuncDef statGetFuncdef

static

Initial value:

= {
  1+IsStat4,       
  SQLITE_UTF8,     
  0,               
  0,               
  statGet,         
  0,               
  0, 0,            
  "stat_get",      
  {0}
}

Definition at line 108472 of file sqlite3.c.

                                      {
  1+IsStat4,       /* nArg */
  SQLITE_UTF8,     /* funcFlags */
  0,               /* pUserData */
  0,               /* pNext */

◆ statInitFuncdef

const FuncDef statInitFuncdef

static

Initial value:

= {
  4,               
  SQLITE_UTF8,     
  0,               
  0,               
  statInit,        
  0,               
  0, 0,            
  "stat_init",     
  {0}
}

Definition at line 108030 of file sqlite3.c.

                                       {
  4,               /* nArg */
  SQLITE_UTF8,     /* funcFlags */
  0,               /* pUserData */
  0,               /* pNext */

Referenced by analyzeOneTable().

◆ statMutex

const char statMutex[]

static

Initial value:

Definition at line 21350 of file sqlite3.c.

                                {
  0,  /* SQLITE_STATUS_MEMORY_USED */
  1,  /* SQLITE_STATUS_PAGECACHE_USED */
  1,  /* SQLITE_STATUS_PAGECACHE_OVERFLOW */
  0,  /* SQLITE_STATUS_SCRATCH_USED */
  0,  /* SQLITE_STATUS_SCRATCH_OVERFLOW */
  0,  /* SQLITE_STATUS_MALLOC_SIZE */

Referenced by sqlite3StatusHighwater(), sqlite3StatusUp(), and sqlite3StatusValue().

◆ statPushFuncdef

const FuncDef statPushFuncdef

static

Initial value:

= {
  2+IsStat4,       
  SQLITE_UTF8,     
  0,               
  0,               
  statPush,        
  0,               
  0, 0,            
  "stat_push",     
  {0}
}

Definition at line 108320 of file sqlite3.c.

                                                                 {
    p->nSkipAhead++;
    sqlite3_result_int(context, p->current.anDLt[0]>0);
  }
}
 
static const FuncDef statPushFuncdef = {
  2+IsStat4,       /* nArg */
  SQLITE_UTF8,     /* funcFlags */
  0,               /* pUserData */
  0,               /* pNext */

Referenced by analyzeOneTable().

◆ unixBigLock

sqlite3_mutex* unixBigLock = 0

static

Definition at line 34278 of file sqlite3.c.

Referenced by sqlite3_os_end(), sqlite3_os_init(), and unixLeaveMutex().

◆ unixDlSym

void()(void) unixDlSym(sqlite3_vfs NotUsed, void p, const char zSym)	(	sqlite3_vfs *	NotUsed,
		void *	p,
		const char *	zSym )

static

Definition at line 39994 of file sqlite3.c.

            {
    sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
  }
  unixLeaveMutex();
}
static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
  /*
  ** GCC with -pedantic-errors says that C90 does not allow a void* to be
  ** cast into a pointer to a function.  And yet the library dlsym() routine
  ** returns a void* which is really a pointer to a function.  So how do we
  ** use dlsym() with -pedantic-errors?
  **
  ** Variable x below is defined to be a pointer to a function taking
  ** parameters void* and const char* and returning a pointer to a function.
  ** We initialize x by assigning it a pointer to the dlsym() function.
  ** (That assignment requires a cast.)  Then we call the function that
  ** x points to.
  **
  ** This work-around is unlikely to work correctly on any system where
  ** you really cannot cast a function pointer into void*.  But then, on the
  ** other hand, dlsym() will not work on such a system either, so we have
  ** not really lost anything.

◆ vfsList

sqlite3_vfs* SQLITE_WSD vfsList = 0

static

Definition at line 23300 of file sqlite3.c.

◆ yy_action

const YYACTIONTYPE yy_action[]

static

Definition at line 154593 of file sqlite3.c.

                                        {
 /*     0 */   546, 1222,  546,  451, 1260,  546, 1239,  546,  114,  111,
 /*    10 */   211,  546, 1537,  546, 1260,  523,  114,  111,  211,  392,
 /*    20 */  1232,  344,   42,   42,   42,   42, 1225,   42,   42,   71,
 /*    30 */    71,  937, 1224,   71,   71,   71,   71, 1462, 1493,  938,
 /*    40 */   820,  453,    6,  121,  122,  112, 1165, 1165, 1006, 1009,
 /*    50 */   999,  999,  119,  119,  120,  120,  120,  120, 1543,  392,
 /*    60 */  1358, 1517,  552,    2, 1193,  194,  528,  436,  143,  291,
 /*    70 */   528,  136,  528,  371,  261,  504,  272,  385, 1273,  527,
 /*    80 */   503,  493,  164,  121,  122,  112, 1165, 1165, 1006, 1009,
 /*    90 */   999,  999,  119,  119,  120,  120,  120,  120, 1358,  442,
 /*   100 */  1514,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   110 */   115,  424,  266,  266,  266,  266, 1498,  358, 1500,  435,
 /*   120 */   357, 1498,  517,  524, 1485,  543, 1114,  543, 1114,  392,
 /*   130 */   405,  241,  208,  114,  111,  211,   98,  290,  537,  221,
 /*   140 */  1029,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   150 */   115,  424, 1142,  121,  122,  112, 1165, 1165, 1006, 1009,
 /*   160 */   999,  999,  119,  119,  120,  120,  120,  120,  406,  428,
 /*   170 */   117,  117,  116,  116,  116,  115,  424, 1418,  468,  123,
 /*   180 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*   190 */   424,  116,  116,  116,  115,  424,  540,  540,  540,  392,
 /*   200 */   505,  120,  120,  120,  120,  113, 1051, 1142, 1143, 1144,
 /*   210 */  1051,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   220 */   115,  424, 1461,  121,  122,  112, 1165, 1165, 1006, 1009,
 /*   230 */   999,  999,  119,  119,  120,  120,  120,  120,  392,  444,
 /*   240 */   316,   83,  463,   81,  359,  382, 1142,   80,  118,  118,
 /*   250 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  179,
 /*   260 */   434,  424,  121,  122,  112, 1165, 1165, 1006, 1009,  999,
 /*   270 */   999,  119,  119,  120,  120,  120,  120,  434,  433,  266,
 /*   280 */   266,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   290 */   115,  424,  543, 1109,  903,  506, 1142,  114,  111,  211,
 /*   300 */  1431, 1142, 1143, 1144,  206,  491, 1109,  392,  449, 1109,
 /*   310 */   545,  330,  120,  120,  120,  120,  298, 1431, 1433,   17,
 /*   320 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*   330 */   424,  121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,
 /*   340 */   119,  119,  120,  120,  120,  120,  392, 1358,  434, 1142,
 /*   350 */   482, 1142, 1143, 1144,  996,  996, 1007, 1010,  445,  118,
 /*   360 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  424,
 /*   370 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
 /*   380 */   119,  120,  120,  120,  120, 1054, 1054,  465, 1431,  118,
 /*   390 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  424,
 /*   400 */  1142,  451,  546, 1426, 1142, 1143, 1144,  233,  966, 1142,
 /*   410 */   481,  478,  477,  171,  360,  392,  164,  407,  414,  842,
 /*   420 */   476,  164,  185,  334,   71,   71, 1243, 1000,  118,  118,
 /*   430 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  121,
 /*   440 */   122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,  119,
 /*   450 */   120,  120,  120,  120,  392, 1142, 1143, 1144,  835,   12,
 /*   460 */   314,  509,  163,  356, 1142, 1143, 1144,  114,  111,  211,
 /*   470 */   508,  290,  537,  546,  276,  180,  290,  537,  121,  122,
 /*   480 */   112, 1165, 1165, 1006, 1009,  999,  999,  119,  119,  120,
 /*   490 */   120,  120,  120,  345,  484,   71,   71,  118,  118,  118,
 /*   500 */   118,  117,  117,  116,  116,  116,  115,  424, 1142,  209,
 /*   510 */   411,  523, 1142, 1109, 1571,  378,  252,  269,  342,  487,
 /*   520 */   337,  486,  238,  392,  513,  364, 1109, 1127,  333, 1109,
 /*   530 */   191,  409,  286,   32,  457,  443,  118,  118,  118,  118,
 /*   540 */   117,  117,  116,  116,  116,  115,  424,  121,  122,  112,
 /*   550 */  1165, 1165, 1006, 1009,  999,  999,  119,  119,  120,  120,
 /*   560 */   120,  120,  392, 1142, 1143, 1144,  987, 1142, 1143, 1144,
 /*   570 */  1142,  233,  492, 1492,  481,  478,  477,    6,  163,  546,
 /*   580 */   512,  546,  115,  424,  476,    5,  121,  122,  112, 1165,
 /*   590 */  1165, 1006, 1009,  999,  999,  119,  119,  120,  120,  120,
 /*   600 */   120,   13,   13,   13,   13,  118,  118,  118,  118,  117,
 /*   610 */   117,  116,  116,  116,  115,  424,  403,  502,  408,  546,
 /*   620 */  1486,  544, 1142,  892,  892, 1142, 1143, 1144, 1473, 1142,
 /*   630 */   275,  392,  808,  809,  810,  971,  422,  422,  422,   16,
 /*   640 */    16,   55,   55, 1242,  118,  118,  118,  118,  117,  117,
 /*   650 */   116,  116,  116,  115,  424,  121,  122,  112, 1165, 1165,
 /*   660 */  1006, 1009,  999,  999,  119,  119,  120,  120,  120,  120,
 /*   670 */   392, 1189,    1,    1,  552,    2, 1193, 1142, 1143, 1144,
 /*   680 */   194,  291,  898,  136, 1142, 1143, 1144,  897,  521, 1492,
 /*   690 */  1273,    3,  380,    6,  121,  122,  112, 1165, 1165, 1006,
 /*   700 */  1009,  999,  999,  119,  119,  120,  120,  120,  120,  858,
 /*   710 */   546,  924,  546,  118,  118,  118,  118,  117,  117,  116,
 /*   720 */   116,  116,  115,  424,  266,  266, 1092, 1569, 1142,  551,
 /*   730 */  1569, 1193,   13,   13,   13,   13,  291,  543,  136,  392,
 /*   740 */   485,  421,  420,  966,  344, 1273,  468,  410,  859,  279,
 /*   750 */   140,  221,  118,  118,  118,  118,  117,  117,  116,  116,
 /*   760 */   116,  115,  424,  121,  122,  112, 1165, 1165, 1006, 1009,
 /*   770 */   999,  999,  119,  119,  120,  120,  120,  120,  546,  266,
 /*   780 */   266,  428,  392, 1142, 1143, 1144, 1172,  830, 1172,  468,
 /*   790 */   431,  145,  543, 1146,  401,  314,  439,  302,  838, 1490,
 /*   800 */    71,   71,  412,    6, 1090,  473,  221,  100,  112, 1165,
 /*   810 */  1165, 1006, 1009,  999,  999,  119,  119,  120,  120,  120,
 /*   820 */   120,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   830 */   115,  424,  237, 1425,  546,  451,  428,  287,  986,  546,
 /*   840 */   236,  235,  234,  830,   97,  529,  429, 1265, 1265, 1146,
 /*   850 */   494,  307,  430,  838,  977,  546,   71,   71,  976, 1241,
 /*   860 */   546,   51,   51,  300,  118,  118,  118,  118,  117,  117,
 /*   870 */   116,  116,  116,  115,  424,  194,  103,   70,   70,  266,
 /*   880 */   266,  546,   71,   71,  266,  266,   30,  391,  344,  976,
 /*   890 */   976,  978,  543,  528, 1109,  328,  392,  543,  495,  397,
 /*   900 */  1470,  195,  530,   13,   13, 1358,  240, 1109,  277,  280,
 /*   910 */  1109,  280,  304,  457,  306,  333,  392,   31,  188,  419,
 /*   920 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
 /*   930 */   119,  120,  120,  120,  120,  142,  392,  365,  457,  986,
 /*   940 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
 /*   950 */   119,  120,  120,  120,  120,  977,  323, 1142,  326,  976,
 /*   960 */   121,  110,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
 /*   970 */   119,  120,  120,  120,  120,  464,  377, 1185,  118,  118,
 /*   980 */   118,  118,  117,  117,  116,  116,  116,  115,  424, 1142,
 /*   990 */   976,  976,  978,  305,    9,  366,  244,  362,  118,  118,
 /*  1000 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  313,
 /*  1010 */   546,  344, 1142, 1143, 1144,  299,  290,  537,  118,  118,
 /*  1020 */   118,  118,  117,  117,  116,  116,  116,  115,  424, 1263,
 /*  1030 */  1263, 1163,   13,   13,  278,  421,  420,  468,  392,  923,
 /*  1040 */   260,  260,  289, 1169, 1142, 1143, 1144,  189, 1171,  266,
 /*  1050 */   266,  468,  390,  543, 1186,  546, 1170,  263,  144,  489,
 /*  1060 */   922,  546,  543,  122,  112, 1165, 1165, 1006, 1009,  999,
 /*  1070 */   999,  119,  119,  120,  120,  120,  120,   71,   71, 1142,
 /*  1080 */  1172, 1272, 1172,   13,   13,  898, 1070, 1163,  546,  468,
 /*  1090 */   897,  107,  538, 1491,    4, 1268, 1109,    6,  525, 1049,
 /*  1100 */    12, 1071, 1092, 1570,  312,  455, 1570,  520,  541, 1109,
 /*  1110 */    56,   56, 1109, 1489,  423, 1358, 1072,    6,  345,  285,
 /*  1120 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*  1130 */   424,  425, 1271,  321, 1142, 1143, 1144,  878,  266,  266,
 /*  1140 */  1277,  107,  538,  535,    4, 1488,  293,  879, 1211,    6,
 /*  1150 */   210,  543,  543,  164,  294,  496,  416,  204,  541,  267,
 /*  1160 */   267, 1214,  398,  511,  499,  204,  266,  266,  396,  531,
 /*  1170 */     8,  986,  543,  519,  546,  922,  458,  105,  105,  543,
 /*  1180 */  1090,  425,  266,  266,  106,  417,  425,  548,  547,  266,
 /*  1190 */   266,  976,  518,  535, 1373,  543,   15,   15,  266,  266,
 /*  1200 */   456, 1120,  543,  266,  266, 1070, 1372,  515,  290,  537,
 /*  1210 */   546,  543,  514,   97,  444,  316,  543,  546,  922,  125,
 /*  1220 */  1071,  986,  976,  976,  978,  979,   27,  105,  105,  401,
 /*  1230 */   343, 1511,   44,   44,  106, 1072,  425,  548,  547,   57,
 /*  1240 */    57,  976,  343, 1511,  107,  538,  546,    4,  462,  401,
 /*  1250 */   214, 1120,  459,  297,  377, 1091,  534, 1309,  546,  539,
 /*  1260 */   398,  541,  290,  537,  104,  244,  102,  526,   58,   58,
 /*  1270 */   546,  199,  976,  976,  978,  979,   27, 1516, 1131,  427,
 /*  1280 */    59,   59,  270,  237,  425,  138,   95,  375,  375,  374,
 /*  1290 */   255,  372,   60,   60,  817, 1180,  535,  546,  273,  546,
 /*  1300 */  1163, 1308,  389,  388,  546,  438,  546,  215,  210,  296,
 /*  1310 */   515,  849,  546,  265,  208,  516, 1476,  295,  274,   61,
 /*  1320 */    61,   62,   62,  308,  986,  109,   45,   45,   46,   46,
 /*  1330 */   105,  105, 1186,  922,   47,   47,  341,  106,  546,  425,
 /*  1340 */   548,  547, 1542,  546,  976,  867,  340,  217,  546,  937,
 /*  1350 */   397,  107,  538,  218,    4,  156, 1163,  938,  158,  546,
 /*  1360 */    49,   49, 1162,  546,  268,   50,   50,  546,  541, 1450,
 /*  1370 */    63,   63,  546, 1449,  216,  976,  976,  978,  979,   27,
 /*  1380 */   446,   64,   64,  546,  460,   65,   65,  546,  318,   14,
 /*  1390 */    14,  425, 1305,  546,   66,   66, 1087,  546,  141,  379,
 /*  1400 */    38,  546,  963,  535,  322,  127,  127,  546,  393,   67,
 /*  1410 */    67,  546,  325,  290,  537,   52,   52,  515,  546,   68,
 /*  1420 */    68,  845,  514,   69,   69,  399,  165,  857,  856,   53,
 /*  1430 */    53,  986,  311,  151,  151,   97,  432,  105,  105,  327,
 /*  1440 */   152,  152,  526, 1048,  106, 1048,  425,  548,  547, 1131,
 /*  1450 */   427,  976, 1032,  270,  968,  239,  329,  243,  375,  375,
 /*  1460 */   374,  255,  372,  940,  941,  817, 1296,  546,  220,  546,
 /*  1470 */   107,  538,  546,    4,  546, 1256,  199,  845,  215, 1036,
 /*  1480 */   296, 1530,  976,  976,  978,  979,   27,  541,  295,   76,
 /*  1490 */    76,   54,   54,  980,   72,   72,  128,  128,  864,  865,
 /*  1500 */   107,  538,  546,    4, 1047,  546, 1047,  533,  469,  546,
 /*  1510 */   425,  546,  450, 1240,  546,  243,  546,  541,  217,  546,
 /*  1520 */   452,  197,  535,  243,   73,   73,  156,  129,  129,  158,
 /*  1530 */   336,  130,  130,  126,  126, 1036,  150,  150,  149,  149,
 /*  1540 */   425,  134,  134,  317,  474,  216,   97,  239,  331,  980,
 /*  1550 */   986,   97,  535,  346,  347,  546,  105,  105,  902,  931,
 /*  1560 */   546,  895,  243,  106,  109,  425,  548,  547,  546, 1505,
 /*  1570 */   976,  828,   99,  538,  139,    4,  546,  133,  133,  393,
 /*  1580 */   986, 1317,  131,  131,  290,  537,  105,  105, 1357,  541,
 /*  1590 */   132,  132, 1292,  106, 1303,  425,  548,  547,   75,   75,
 /*  1600 */   976,  976,  976,  978,  979,   27,  546,  432,  896, 1289,
 /*  1610 */   532,  109,  425, 1363,  546, 1221, 1213, 1202,  258,  546,
 /*  1620 */   349,  546, 1201,   11,  535, 1203, 1524,  351,   77,   77,
 /*  1630 */   376,  976,  976,  978,  979,   27,   74,   74,  353,  213,
 /*  1640 */   301,   43,   43,   48,   48,  437,  310,  201,  303, 1350,
 /*  1650 */   315,  355,  986,  454,  479, 1239,  339,  192,  105,  105,
 /*  1660 */  1422, 1421,  193,  536,  205,  106, 1527,  425,  548,  547,
 /*  1670 */  1180,  167,  976,  270,  247, 1469, 1467, 1177,  375,  375,
 /*  1680 */   374,  255,  372,  200,  369,  817,  400,   83,   79,   82,
 /*  1690 */  1427,  448,  177,   95, 1342,  161,  169, 1339,  215,  440,
 /*  1700 */   296,  172,  173,  976,  976,  978,  979,   27,  295,  174,
 /*  1710 */   175,  441,  472,  223, 1347,  383,   35,  381,   36,  461,
 /*  1720 */    88, 1353,  181,  447,  384, 1416,  227,  467,  259,  229,
 /*  1730 */   186,  488,  470,  324, 1250,  230,  231,  320,  217, 1204,
 /*  1740 */  1438, 1259,  386, 1258,  413,   90,  156,  849, 1541,  158,
 /*  1750 */   206,  415, 1540,  507, 1300, 1257,   94,  348, 1229, 1301,
 /*  1760 */   387, 1510, 1228,  338, 1227,  216,  350, 1539,  498,  283,
 /*  1770 */   284, 1249,  501, 1299,  352,  245,  246,  418, 1298,  354,
 /*  1780 */  1496, 1495,  124,   10,  526,  363,  101, 1324,  253,   96,
 /*  1790 */   510, 1210,   34,  549, 1137,  254,  256,  257,  166,  393,
 /*  1800 */   550, 1199, 1282,  361,  290,  537, 1281,  196,  367,  368,
 /*  1810 */  1194,  153, 1454,  137,  281, 1323, 1455,  804,  154,  426,
 /*  1820 */   198,  155, 1453, 1452,  292,  212,  202,  432, 1402,  203,
 /*  1830 */   271,  135,  288,   78, 1046, 1044,  960,  168,  157,  881,
 /*  1840 */   170,  219,  309,  222, 1060,  176,  964,  159,  402,   84,
 /*  1850 */   178,  404,   85,   86,   87,  160, 1063,  224,  394,  395,
 /*  1860 */   225, 1059,  146,   18,  226,  319,  243, 1174,  466,  228,
 /*  1870 */  1052,  182,  183,   37,  819,  471,  340,  232,  332,  483,
 /*  1880 */   184,   89,  162,   19,   20,  475,   91,  480,  847,  335,
 /*  1890 */   147,  860,  282,   92,  490,   93, 1125,  148, 1012, 1095,
 /*  1900 */    39,  497, 1096,   40,  500,  262,  207,  264,  930,  187,
 /*  1910 */   925,  109, 1111, 1115, 1113,    7, 1099,  242,   33, 1119,

Referenced by yy_find_shift_action().

◆ yy_default

const YYACTIONTYPE yy_default[]

static

Definition at line 155115 of file sqlite3.c.

                                         {
 /*     0 */  1575, 1575, 1575, 1411, 1188, 1297, 1188, 1188, 1188, 1411,
 /*    10 */  1411, 1411, 1188, 1327, 1327, 1464, 1219, 1188, 1188, 1188,
 /*    20 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1410, 1188, 1188,
 /*    30 */  1188, 1188, 1494, 1494, 1188, 1188, 1188, 1188, 1188, 1188,
 /*    40 */  1188, 1188, 1188, 1336, 1188, 1188, 1188, 1188, 1188, 1188,
 /*    50 */  1412, 1413, 1188, 1188, 1188, 1463, 1465, 1428, 1346, 1345,
 /*    60 */  1344, 1343, 1446, 1314, 1341, 1334, 1338, 1406, 1407, 1405,
 /*    70 */  1409, 1413, 1412, 1188, 1337, 1377, 1391, 1376, 1188, 1188,
 /*    80 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*    90 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   100 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   110 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   120 */  1188, 1188, 1188, 1188, 1188, 1188, 1385, 1390, 1396, 1389,
 /*   130 */  1386, 1379, 1378, 1380, 1381, 1188, 1209, 1261, 1188, 1188,
 /*   140 */  1188, 1188, 1482, 1481, 1188, 1188, 1219, 1371, 1370, 1382,
 /*   150 */  1383, 1393, 1392, 1471, 1529, 1528, 1429, 1188, 1188, 1188,
 /*   160 */  1188, 1188, 1188, 1494, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   170 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   180 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1494, 1494,
 /*   190 */  1188, 1219, 1494, 1494, 1215, 1215, 1321, 1188, 1477, 1297,
 /*   200 */  1288, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   210 */  1188, 1188, 1188, 1188, 1188, 1468, 1466, 1188, 1188, 1188,
 /*   220 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   230 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   240 */  1188, 1188, 1188, 1188, 1188, 1293, 1188, 1188, 1188, 1188,
 /*   250 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1523, 1188, 1441,
 /*   260 */  1275, 1293, 1293, 1293, 1293, 1295, 1276, 1274, 1287, 1220,
 /*   270 */  1195, 1567, 1294, 1316, 1316, 1564, 1340, 1294, 1564, 1236,
 /*   280 */  1545, 1231, 1327, 1327, 1327, 1316, 1321, 1321, 1408, 1294,
 /*   290 */  1287, 1188, 1567, 1302, 1302, 1566, 1566, 1302, 1429, 1349,
 /*   300 */  1355, 1340, 1264, 1340, 1270, 1270, 1270, 1270, 1302, 1206,
 /*   310 */  1340, 1340, 1349, 1355, 1264, 1340, 1264, 1340, 1302, 1206,
 /*   320 */  1445, 1561, 1302, 1206, 1419, 1302, 1206, 1302, 1206, 1419,
 /*   330 */  1262, 1262, 1262, 1251, 1188, 1188, 1419, 1262, 1236, 1262,
 /*   340 */  1251, 1262, 1262, 1512, 1419, 1423, 1423, 1419, 1320, 1315,
 /*   350 */  1320, 1315, 1320, 1315, 1320, 1315, 1302, 1504, 1504, 1330,
 /*   360 */  1330, 1335, 1321, 1414, 1302, 1188, 1335, 1333, 1331, 1340,
 /*   370 */  1212, 1254, 1526, 1526, 1522, 1522, 1522, 1572, 1572, 1477,
 /*   380 */  1538, 1219, 1219, 1219, 1219, 1538, 1238, 1238, 1220, 1220,
 /*   390 */  1219, 1538, 1188, 1188, 1188, 1188, 1188, 1188, 1533, 1188,
 /*   400 */  1430, 1306, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   410 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   420 */  1188, 1188, 1188, 1188, 1188, 1360, 1188, 1191, 1474, 1188,
 /*   430 */  1188, 1472, 1188, 1188, 1188, 1188, 1188, 1188, 1307, 1188,
 /*   440 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   450 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1563, 1188, 1188,
 /*   460 */  1188, 1188, 1188, 1188, 1444, 1443, 1188, 1188, 1304, 1188,
 /*   470 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   480 */  1188, 1188, 1234, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   490 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
 /*   500 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1332,

Referenced by yy_find_shift_action().

◆ yy_lookahead

const YYCODETYPE yy_lookahead[]

static

Definition at line 154792 of file sqlite3.c.

                                         {
 /*     0 */   189,  211,  189,  189,  218,  189,  220,  189,  267,  268,
 /*    10 */   269,  189,  210,  189,  228,  189,  267,  268,  269,   19,
 /*    20 */   218,  189,  211,  212,  211,  212,  211,  211,  212,  211,
 /*    30 */   212,   31,  211,  211,  212,  211,  212,  288,  300,   39,
 /*    40 */    21,  189,  304,   43,   44,   45,   46,   47,   48,   49,
 /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,  225,   19,
 /*    60 */   189,  183,  184,  185,  186,  189,  248,  263,  236,  191,
 /*    70 */   248,  193,  248,  197,  208,  257,  262,  201,  200,  257,
 /*    80 */   200,  257,   81,   43,   44,   45,   46,   47,   48,   49,
 /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,  189,   80,
 /*   100 */   189,  101,  102,  103,  104,  105,  106,  107,  108,  109,
 /*   110 */   110,  111,  234,  235,  234,  235,  305,  306,  305,  118,
 /*   120 */   307,  305,  306,  297,  298,  247,   86,  247,   88,   19,
 /*   130 */   259,  251,  252,  267,  268,  269,   26,  136,  137,  261,
 /*   140 */   121,  101,  102,  103,  104,  105,  106,  107,  108,  109,
 /*   150 */   110,  111,   59,   43,   44,   45,   46,   47,   48,   49,
 /*   160 */    50,   51,   52,   53,   54,   55,   56,   57,  259,  291,
 /*   170 */   105,  106,  107,  108,  109,  110,  111,  158,  189,   69,
 /*   180 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
 /*   190 */   111,  107,  108,  109,  110,  111,  205,  206,  207,   19,
 /*   200 */    19,   54,   55,   56,   57,   58,   29,  114,  115,  116,
 /*   210 */    33,  101,  102,  103,  104,  105,  106,  107,  108,  109,
 /*   220 */   110,  111,  233,   43,   44,   45,   46,   47,   48,   49,
 /*   230 */    50,   51,   52,   53,   54,   55,   56,   57,   19,  126,
 /*   240 */   127,  148,   65,   24,  214,  200,   59,   67,  101,  102,
 /*   250 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   22,
 /*   260 */   189,  111,   43,   44,   45,   46,   47,   48,   49,   50,
 /*   270 */    51,   52,   53,   54,   55,   56,   57,  206,  207,  234,
 /*   280 */   235,  101,  102,  103,  104,  105,  106,  107,  108,  109,
 /*   290 */   110,  111,  247,   76,  107,  114,   59,  267,  268,  269,
 /*   300 */   189,  114,  115,  116,  162,  163,   89,   19,  263,   92,
 /*   310 */   189,   23,   54,   55,   56,   57,  189,  206,  207,   22,
 /*   320 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
 /*   330 */   111,   43,   44,   45,   46,   47,   48,   49,   50,   51,
 /*   340 */    52,   53,   54,   55,   56,   57,   19,  189,  277,   59,
 /*   350 */    23,  114,  115,  116,   46,   47,   48,   49,   61,  101,
 /*   360 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
 /*   370 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   380 */    53,   54,   55,   56,   57,  125,  126,  127,  277,  101,
 /*   390 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
 /*   400 */    59,  189,  189,  276,  114,  115,  116,  117,   73,   59,
 /*   410 */   120,  121,  122,   72,  214,   19,   81,  259,   19,   23,
 /*   420 */   130,   81,   72,   24,  211,  212,  221,  119,  101,  102,
 /*   430 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   43,
 /*   440 */    44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
 /*   450 */    54,   55,   56,   57,   19,  114,  115,  116,   23,  208,
 /*   460 */   125,  248,  189,  189,  114,  115,  116,  267,  268,  269,
 /*   470 */   189,  136,  137,  189,  262,   22,  136,  137,   43,   44,
 /*   480 */    45,   46,   47,   48,   49,   50,   51,   52,   53,   54,
 /*   490 */    55,   56,   57,  189,   95,  211,  212,  101,  102,  103,
 /*   500 */   104,  105,  106,  107,  108,  109,  110,  111,   59,  189,
 /*   510 */   111,  189,   59,   76,  294,  295,  117,  118,  119,  120,
 /*   520 */   121,  122,  123,   19,   87,  189,   89,   23,  129,   92,
 /*   530 */   279,  227,  248,   22,  189,  284,  101,  102,  103,  104,
 /*   540 */   105,  106,  107,  108,  109,  110,  111,   43,   44,   45,
 /*   550 */    46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
 /*   560 */    56,   57,   19,  114,  115,  116,   23,  114,  115,  116,
 /*   570 */    59,  117,  299,  300,  120,  121,  122,  304,  189,  189,
 /*   580 */   143,  189,  110,  111,  130,   22,   43,   44,   45,   46,
 /*   590 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 /*   600 */    57,  211,  212,  211,  212,  101,  102,  103,  104,  105,
 /*   610 */   106,  107,  108,  109,  110,  111,  226,  189,  226,  189,
 /*   620 */   298,  132,   59,  134,  135,  114,  115,  116,  189,   59,
 /*   630 */   285,   19,    7,    8,    9,   23,  205,  206,  207,  211,
 /*   640 */   212,  211,  212,  221,  101,  102,  103,  104,  105,  106,
 /*   650 */   107,  108,  109,  110,  111,   43,   44,   45,   46,   47,
 /*   660 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
 /*   670 */    19,  181,  182,  183,  184,  185,  186,  114,  115,  116,
 /*   680 */   189,  191,  133,  193,  114,  115,  116,  138,  299,  300,
 /*   690 */   200,   22,  201,  304,   43,   44,   45,   46,   47,   48,
 /*   700 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   35,
 /*   710 */   189,  141,  189,  101,  102,  103,  104,  105,  106,  107,
 /*   720 */   108,  109,  110,  111,  234,  235,   22,   23,   59,  184,
 /*   730 */    26,  186,  211,  212,  211,  212,  191,  247,  193,   19,
 /*   740 */    66,  105,  106,   73,  189,  200,  189,  226,   74,  226,
 /*   750 */    22,  261,  101,  102,  103,  104,  105,  106,  107,  108,
 /*   760 */   109,  110,  111,   43,   44,   45,   46,   47,   48,   49,
 /*   770 */    50,   51,   52,   53,   54,   55,   56,   57,  189,  234,
 /*   780 */   235,  291,   19,  114,  115,  116,  150,   59,  152,  189,
 /*   790 */   233,  236,  247,   59,  189,  125,  126,  127,   59,  300,
 /*   800 */   211,  212,  128,  304,  100,   19,  261,  156,   45,   46,
 /*   810 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 /*   820 */    57,  101,  102,  103,  104,  105,  106,  107,  108,  109,
 /*   830 */   110,  111,   46,  233,  189,  189,  291,  248,   99,  189,
 /*   840 */   125,  126,  127,  115,   26,  200,  289,  230,  231,  115,
 /*   850 */   200,   16,  189,  114,  115,  189,  211,  212,  119,  221,
 /*   860 */   189,  211,  212,  258,  101,  102,  103,  104,  105,  106,
 /*   870 */   107,  108,  109,  110,  111,  189,  156,  211,  212,  234,
 /*   880 */   235,  189,  211,  212,  234,  235,   22,  201,  189,  150,
 /*   890 */   151,  152,  247,  248,   76,   16,   19,  247,  248,  113,
 /*   900 */   189,   24,  257,  211,  212,  189,   26,   89,  262,  223,
 /*   910 */    92,  225,   77,  189,   79,  129,   19,   53,  226,  248,
 /*   920 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   930 */    53,   54,   55,   56,   57,  236,   19,  271,  189,   99,
 /*   940 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   950 */    53,   54,   55,   56,   57,  115,   77,   59,   79,  119,
 /*   960 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   970 */    53,   54,   55,   56,   57,  259,   22,   23,  101,  102,
 /*   980 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   59,
 /*   990 */   150,  151,  152,  158,   22,  244,   24,  246,  101,  102,
 /*  1000 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  285,
 /*  1010 */   189,  189,  114,  115,  116,  200,  136,  137,  101,  102,
 /*  1020 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  230,
 /*  1030 */   231,   59,  211,  212,  285,  105,  106,  189,   19,  141,
 /*  1040 */   234,  235,  239,  113,  114,  115,  116,  226,  118,  234,
 /*  1050 */   235,  189,  249,  247,  100,  189,  126,   23,  236,  107,
 /*  1060 */    26,  189,  247,   44,   45,   46,   47,   48,   49,   50,
 /*  1070 */    51,   52,   53,   54,   55,   56,   57,  211,  212,   59,
 /*  1080 */   150,  233,  152,  211,  212,  133,   12,  115,  189,  189,
 /*  1090 */   138,   19,   20,  300,   22,  233,   76,  304,  226,   11,
 /*  1100 */   208,   27,   22,   23,  200,   19,   26,   87,   36,   89,
 /*  1110 */   211,  212,   92,  300,  248,  189,   42,  304,  189,  250,
 /*  1120 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
 /*  1130 */   111,   59,  200,  233,  114,  115,  116,   63,  234,  235,
 /*  1140 */   235,   19,   20,   71,   22,  300,  189,   73,  200,  304,
 /*  1150 */   116,  247,  247,   81,  189,  200,  227,   26,   36,  234,
 /*  1160 */   235,  203,  204,  143,  200,   26,  234,  235,  194,  200,
 /*  1170 */    48,   99,  247,   66,  189,  141,  284,  105,  106,  247,
 /*  1180 */   100,   59,  234,  235,  112,  259,  114,  115,  116,  234,
 /*  1190 */   235,  119,   85,   71,  266,  247,  211,  212,  234,  235,
 /*  1200 */   114,   94,  247,  234,  235,   12,  266,   85,  136,  137,
 /*  1210 */   189,  247,   90,   26,  126,  127,  247,  189,   26,   22,
 /*  1220 */    27,   99,  150,  151,  152,  153,  154,  105,  106,  189,
 /*  1230 */   302,  303,  211,  212,  112,   42,  114,  115,  116,  211,
 /*  1240 */   212,  119,  302,  303,   19,   20,  189,   22,  274,  189,
 /*  1250 */    15,  144,  278,  189,   22,   23,   63,  189,  189,  203,
 /*  1260 */   204,   36,  136,  137,  155,   24,  157,  143,  211,  212,
 /*  1270 */   189,  140,  150,  151,  152,  153,  154,    0,    1,    2,
 /*  1280 */   211,  212,    5,   46,   59,  161,  147,   10,   11,   12,
 /*  1290 */    13,   14,  211,  212,   17,   60,   71,  189,  258,  189,
 /*  1300 */    59,  189,  105,  106,  189,  189,  189,   30,  116,   32,
 /*  1310 */    85,  124,  189,  251,  252,   90,  189,   40,  258,  211,
 /*  1320 */   212,  211,  212,  189,   99,   26,  211,  212,  211,  212,
 /*  1330 */   105,  106,  100,  141,  211,  212,  119,  112,  189,  114,
 /*  1340 */   115,  116,   23,  189,  119,   26,  129,   70,  189,   31,
 /*  1350 */   113,   19,   20,   24,   22,   78,  115,   39,   81,  189,
 /*  1360 */   211,  212,   26,  189,   22,  211,  212,  189,   36,  189,
 /*  1370 */   211,  212,  189,  189,   97,  150,  151,  152,  153,  154,
 /*  1380 */   127,  211,  212,  189,  189,  211,  212,  189,  189,  211,
 /*  1390 */   212,   59,  189,  189,  211,  212,   23,  189,   22,   26,
 /*  1400 */    24,  189,  149,   71,  189,  211,  212,  189,  131,  211,
 /*  1410 */   212,  189,  189,  136,  137,  211,  212,   85,  189,  211,
 /*  1420 */   212,   59,   90,  211,  212,  292,  293,  118,  119,  211,
 /*  1430 */   212,   99,   23,  211,  212,   26,  159,  105,  106,  189,
 /*  1440 */   211,  212,  143,  150,  112,  152,  114,  115,  116,    1,
 /*  1450 */     2,  119,   23,    5,   23,   26,  189,   26,   10,   11,
 /*  1460 */    12,   13,   14,   83,   84,   17,  253,  189,  139,  189,
 /*  1470 */    19,   20,  189,   22,  189,  189,  140,  115,   30,   59,
 /*  1480 */    32,  139,  150,  151,  152,  153,  154,   36,   40,  211,
 /*  1490 */   212,  211,  212,   59,  211,  212,  211,  212,    7,    8,
 /*  1500 */    19,   20,  189,   22,  150,  189,  152,  231,  281,  189,
 /*  1510 */    59,  189,   23,  189,  189,   26,  189,   36,   70,  189,
 /*  1520 */    23,  237,   71,   26,  211,  212,   78,  211,  212,   81,
 /*  1530 */   189,  211,  212,  211,  212,  115,  211,  212,  211,  212,
 /*  1540 */    59,  211,  212,   23,   23,   97,   26,   26,   23,  115,
 /*  1550 */    99,   26,   71,  189,  189,  189,  105,  106,  107,   23,
 /*  1560 */   189,   23,   26,  112,   26,  114,  115,  116,  189,  309,
 /*  1570 */   119,   23,   19,   20,   26,   22,  189,  211,  212,  131,
 /*  1580 */    99,  189,  211,  212,  136,  137,  105,  106,  189,   36,
 /*  1590 */   211,  212,  189,  112,  189,  114,  115,  116,  211,  212,
 /*  1600 */   119,  150,  151,  152,  153,  154,  189,  159,   23,  250,
 /*  1610 */   189,   26,   59,  189,  189,  189,  189,  189,  280,  189,
 /*  1620 */   250,  189,  189,  238,   71,  189,  189,  250,  211,  212,
 /*  1630 */   187,  150,  151,  152,  153,  154,  211,  212,  250,  290,
 /*  1640 */   240,  211,  212,  211,  212,  254,  286,  209,  254,  241,
 /*  1650 */   240,  254,   99,  286,  215,  220,  214,  244,  105,  106,
 /*  1660 */   214,  214,  244,  273,  224,  112,  192,  114,  115,  116,
 /*  1670 */    60,  290,  119,    5,  139,  196,  196,   38,   10,   11,
 /*  1680 */    12,   13,   14,  238,  240,   17,  196,  148,  287,  287,
 /*  1690 */   276,  113,   22,  147,  241,   43,  229,  241,   30,   18,
 /*  1700 */    32,  232,  232,  150,  151,  152,  153,  154,   40,  232,
 /*  1710 */   232,  196,   18,  195,  265,  265,  264,  241,  264,  196,
 /*  1720 */   155,  229,  229,  241,  241,  241,  195,   62,  196,  195,
 /*  1730 */    22,  113,  216,  196,  222,  195,  195,  282,   70,  196,
 /*  1740 */   283,  213,  216,  213,   64,   22,   78,  124,  219,   81,
 /*  1750 */   162,  111,  219,  142,  256,  213,  113,  255,  213,  256,
 /*  1760 */   216,  303,  215,  213,  213,   97,  255,  213,  216,  275,
 /*  1770 */   275,  222,  216,  256,  255,  196,   91,   82,  256,  255,
 /*  1780 */   308,  308,  146,   22,  143,  196,  155,  260,   25,  145,
 /*  1790 */   144,  199,   26,  198,   13,  190,  190,    6,  293,  131,
 /*  1800 */   188,  188,  245,  244,  136,  137,  245,  243,  242,  241,
 /*  1810 */   188,  202,  208,  217,  217,  260,  208,    4,  202,    3,
 /*  1820 */    22,  202,  208,  208,  160,   15,  209,  159,  270,  209,
 /*  1830 */    98,   16,  272,  208,   23,   23,  137,  148,  128,   20,
 /*  1840 */   140,   24,   16,  142,    1,  140,  149,  128,   61,   53,
 /*  1850 */   148,   37,   53,   53,   53,  128,  114,   34,  296,  296,
 /*  1860 */   139,    1,    5,   22,  113,  158,   26,   75,   41,  139,
 /*  1870 */    68,   68,  113,   24,   20,   19,  129,  123,   23,   96,
 /*  1880 */    22,   22,   37,   22,   22,   67,   22,   67,   59,   24,
 /*  1890 */    23,   28,   67,  147,   22,   26,   23,   23,   23,   23,
 /*  1900 */    22,   24,   23,   22,   24,   23,  139,   23,  114,   22,
 /*  1910 */   141,   26,   88,   75,   86,   44,   23,   34,   22,   75,
 /*  1920 */    34,   24,   34,   34,   34,   93,   34,   26,   26,   34,
 /*  1930 */    23,   23,   23,   23,   23,   11,   23,   22,   26,   22,
 /*  1940 */    22,  133,   23,   23,   22,   22,  139,   26,  139,   23,
 /*  1950 */    15,    1,    1,  310,  310,  310,  310,  310,  310,  310,
 /*  1960 */   139,  139,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  1970 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  1980 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  1990 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2000 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2010 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2020 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2030 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2040 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2050 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2060 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2070 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2080 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2090 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,

Referenced by yy_find_shift_action().

◆ yy_reduce_ofst

const short yy_reduce_ofst[]

static

Definition at line 155073 of file sqlite3.c.

                                      {
 /*     0 */   490, -122,  545,  645,  650, -120, -189, -187, -184, -182,
 /*    10 */  -178, -176,   45,   30,  200, -251, -134,  390,  392,  521,
 /*    20 */   523,  213,  692,  821,  284,  589,  872,  666,  671,  866,
 /*    30 */    71,  111,  273,  389,  686,  815,  904,  932,  948,  955,
 /*    40 */   964,  969, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    50 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    60 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    70 */  -259, -259, -259, -259, -259, -259, -259, -259,  428,  430,
 /*    80 */   899,  985, 1021, 1028, 1057, 1069, 1081, 1108, 1110, 1115,
 /*    90 */  1117, 1123, 1149, 1154, 1159, 1170, 1174, 1178, 1183, 1194,
 /*   100 */  1198, 1204, 1208, 1212, 1218, 1222, 1229, 1278, 1280, 1283,
 /*   110 */  1285, 1313, 1316, 1320, 1322, 1325, 1327, 1330, 1366, 1371,
 /*   120 */  1379, 1387, 1417, 1425, 1430, 1432, -259, -259, -259, -259,
 /*   130 */  -259, -259, -259, -259, -259,  557,  974, -214, -174,   -9,
 /*   140 */   431, -124,  806,  925,  806,  925,  251,  928,  940, -259,
 /*   150 */  -259, -259, -259, -198, -198, -198,  127, -186, -168,  212,
 /*   160 */   646,  617,  799, -262,  555,  220,  220,  491,  605, 1040,
 /*   170 */  1060,  699,  -11,  600,  848,  862,  345, -129,  724,  -91,
 /*   180 */   158,  749,  716,  900,  304,  822,  929,  926,  499,  793,
 /*   190 */   322,  892,  813,  845,  958, 1056,  751,  905, 1133, 1062,
 /*   200 */   803, -210, -185, -179, -148, -167,  -89,  121,  274,  281,
 /*   210 */   320,  336,  439,  663,  711,  957,  965, 1064, 1068, 1112,
 /*   220 */  1116, -196, 1127, 1134, 1180, 1184, 1195, 1199, 1203, 1215,
 /*   230 */  1223, 1250, 1267, 1286,  205,  422,  638, 1324, 1341, 1364,
 /*   240 */  1365, 1213, 1392, 1399, 1403,  869, 1260, 1405, 1421, 1276,
 /*   250 */  1424,  121, 1426, 1427, 1428, 1433, 1436, 1437, 1227, 1338,
 /*   260 */  1284, 1359, 1370, 1377, 1388, 1213, 1284, 1284, 1385, 1438,
 /*   270 */  1443, 1349, 1400, 1391, 1394, 1360, 1408, 1410, 1367, 1439,
 /*   280 */  1440, 1435, 1442, 1446, 1447, 1397, 1413, 1418, 1390, 1444,
 /*   290 */  1445, 1474, 1381, 1479, 1480, 1401, 1402, 1490, 1414, 1449,
 /*   300 */  1452, 1453, 1467, 1456, 1469, 1470, 1477, 1478, 1515, 1518,
 /*   310 */  1476, 1482, 1450, 1454, 1492, 1483, 1493, 1484, 1523, 1531,
 /*   320 */  1457, 1455, 1532, 1534, 1516, 1537, 1540, 1543, 1541, 1526,
 /*   330 */  1528, 1530, 1542, 1512, 1529, 1533, 1544, 1545, 1547, 1550,
 /*   340 */  1549, 1551, 1554, 1458, 1552, 1494, 1495, 1556, 1498, 1502,

◆ yy_shift_ofst

const unsigned short int yy_shift_ofst[]

static

Definition at line 155012 of file sqlite3.c.

                                                  {
 /*     0 */  1448, 1277, 1668, 1072, 1072,  340, 1122, 1225, 1332, 1481,
 /*    10 */  1481, 1481,  335,    0,    0,  180,  897, 1481, 1481, 1481,
 /*    20 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*    30 */   930,  930, 1020, 1020,  290,    1,  340,  340,  340,  340,
 /*    40 */   340,  340,   40,  110,  219,  288,  327,  396,  435,  504,
 /*    50 */   543,  612,  651,  720,  877,  897,  897,  897,  897,  897,
 /*    60 */   897,  897,  897,  897,  897,  897,  897,  897,  897,  897,
 /*    70 */   897,  897,  897,  917,  897, 1019,  763,  763, 1451, 1481,
 /*    80 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*    90 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   100 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   110 */  1481, 1481, 1553, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   120 */  1481, 1481, 1481, 1481, 1481, 1481,  147,  258,  258,  258,
 /*   130 */   258,  258,   79,   65,   84,  449,   19,  786,  449,  636,
 /*   140 */   636,  449,  880,  880,  880,  880,  113,  142,  142,  472,
 /*   150 */   150, 1962, 1962,  399,  399,  399,   93,  237,  341,  237,
 /*   160 */   237, 1074, 1074,  437,  350,  704, 1080,  449,  449,  449,
 /*   170 */   449,  449,  449,  449,  449,  449,  449,  449,  449,  449,
 /*   180 */   449,  449,  449,  449,  449,  449,  449,  449,  818,  818,
 /*   190 */   449, 1088,  217,  217,  734,  734, 1124, 1126, 1962, 1962,
 /*   200 */  1962,  739,  840,  840,  453,  454,  511,  187,  563,  570,
 /*   210 */   898,  669,  449,  449,  449,  449,  449,  449,  449,  449,
 /*   220 */   449,  670,  449,  449,  449,  449,  449,  449,  449,  449,
 /*   230 */   449,  449,  449,  449,  674,  674,  674,  449,  449,  449,
 /*   240 */   449, 1034,  449,  449,  449,  972, 1107,  449,  449, 1193,
 /*   250 */   449,  449,  449,  449,  449,  449,  449,  449,  260,  177,
 /*   260 */   489, 1241, 1241, 1241, 1241, 1192,  489,  489,  952, 1197,
 /*   270 */   625, 1235, 1131,  181,  181, 1086, 1139, 1131, 1086, 1187,
 /*   280 */  1319, 1237, 1318, 1318, 1318,  181, 1299, 1299, 1109, 1336,
 /*   290 */   549, 1376, 1610, 1535, 1535, 1639, 1639, 1535, 1539, 1578,
 /*   300 */  1670, 1546, 1652, 1546, 1681, 1681, 1681, 1681, 1535, 1694,
 /*   310 */  1546, 1546, 1578, 1670, 1652, 1546, 1652, 1546, 1535, 1694,
 /*   320 */  1565, 1665, 1535, 1694, 1708, 1535, 1694, 1535, 1694, 1708,
 /*   330 */  1618, 1618, 1618, 1680, 1723, 1723, 1708, 1618, 1623, 1618,
 /*   340 */  1680, 1618, 1618, 1588, 1708, 1640, 1640, 1708, 1611, 1643,
 /*   350 */  1611, 1643, 1611, 1643, 1611, 1643, 1535, 1685, 1685, 1695,
 /*   360 */  1695, 1636, 1641, 1761, 1535, 1631, 1636, 1644, 1646, 1546,
 /*   370 */  1763, 1766, 1781, 1781, 1791, 1791, 1791, 1962, 1962, 1962,
 /*   380 */  1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962,
 /*   390 */  1962, 1962,  308,  835,  954, 1232,  879,  715,  728, 1373,
 /*   400 */   864, 1329, 1253, 1409,  297, 1431, 1489, 1497, 1520, 1521,
 /*   410 */  1525, 1362, 1309, 1491, 1217, 1420, 1429, 1536, 1380, 1538,
 /*   420 */  1293, 1354, 1548, 1585, 1434, 1342, 1813, 1816, 1798, 1664,
 /*   430 */  1810, 1732, 1815, 1811, 1812, 1699, 1689, 1710, 1817, 1700,
 /*   440 */  1819, 1701, 1826, 1843, 1705, 1697, 1719, 1787, 1814, 1702,
 /*   450 */  1796, 1799, 1800, 1801, 1727, 1742, 1823, 1721, 1860, 1857,
 /*   460 */  1841, 1751, 1707, 1802, 1840, 1803, 1792, 1827, 1730, 1759,
 /*   470 */  1849, 1854, 1856, 1747, 1754, 1858, 1818, 1859, 1861, 1855,
 /*   480 */  1862, 1820, 1829, 1865, 1783, 1863, 1864, 1825, 1845, 1867,
 /*   490 */  1746, 1872, 1873, 1874, 1875, 1869, 1876, 1878, 1877, 1879,
 /*   500 */  1881, 1880, 1767, 1882, 1884, 1794, 1883, 1887, 1769, 1885,

Referenced by yy_find_shift_action().

◆ yyFallback

const YYCODETYPE yyFallback[]

static

Definition at line 155190 of file sqlite3.c.

                                       {
    0,  /*          $ => nothing */
    0,  /*       SEMI => nothing */
   59,  /*    EXPLAIN => ID */
   59,  /*      QUERY => ID */
   59,  /*       PLAN => ID */
   59,  /*      BEGIN => ID */
    0,  /* TRANSACTION => nothing */
   59,  /*   DEFERRED => ID */
   59,  /*  IMMEDIATE => ID */
   59,  /*  EXCLUSIVE => ID */
    0,  /*     COMMIT => nothing */
   59,  /*        END => ID */
   59,  /*   ROLLBACK => ID */
   59,  /*  SAVEPOINT => ID */
   59,  /*    RELEASE => ID */
    0,  /*         TO => nothing */
    0,  /*      TABLE => nothing */
    0,  /*     CREATE => nothing */
   59,  /*         IF => ID */
    0,  /*        NOT => nothing */
    0,  /*     EXISTS => nothing */
   59,  /*       TEMP => ID */
    0,  /*         LP => nothing */
    0,  /*         RP => nothing */
    0,  /*         AS => nothing */
   59,  /*    WITHOUT => ID */
    0,  /*      COMMA => nothing */
   59,  /*      ABORT => ID */
   59,  /*     ACTION => ID */
   59,  /*      AFTER => ID */
   59,  /*    ANALYZE => ID */
   59,  /*        ASC => ID */
   59,  /*     ATTACH => ID */
   59,  /*     BEFORE => ID */
   59,  /*         BY => ID */
   59,  /*    CASCADE => ID */
   59,  /*       CAST => ID */
   59,  /*   CONFLICT => ID */
   59,  /*   DATABASE => ID */
   59,  /*       DESC => ID */
   59,  /*     DETACH => ID */
   59,  /*       EACH => ID */
   59,  /*       FAIL => ID */
    0,  /*         OR => nothing */
    0,  /*        AND => nothing */
    0,  /*         IS => nothing */
   59,  /*      MATCH => ID */
   59,  /*    LIKE_KW => ID */
    0,  /*    BETWEEN => nothing */
    0,  /*         IN => nothing */
    0,  /*     ISNULL => nothing */
    0,  /*    NOTNULL => nothing */
    0,  /*         NE => nothing */
    0,  /*         EQ => nothing */
    0,  /*         GT => nothing */
    0,  /*         LE => nothing */
    0,  /*         LT => nothing */
    0,  /*         GE => nothing */
    0,  /*     ESCAPE => nothing */
    0,  /*         ID => nothing */
   59,  /*   COLUMNKW => ID */
   59,  /*         DO => ID */
   59,  /*        FOR => ID */
   59,  /*     IGNORE => ID */
   59,  /*  INITIALLY => ID */
   59,  /*    INSTEAD => ID */
   59,  /*         NO => ID */
   59,  /*        KEY => ID */
   59,  /*         OF => ID */
   59,  /*     OFFSET => ID */
   59,  /*     PRAGMA => ID */
   59,  /*      RAISE => ID */
   59,  /*  RECURSIVE => ID */
   59,  /*    REPLACE => ID */
   59,  /*   RESTRICT => ID */
   59,  /*        ROW => ID */
   59,  /*       ROWS => ID */
   59,  /*    TRIGGER => ID */
   59,  /*     VACUUM => ID */
   59,  /*       VIEW => ID */
   59,  /*    VIRTUAL => ID */
   59,  /*       WITH => ID */
   59,  /*      NULLS => ID */
   59,  /*      FIRST => ID */
   59,  /*       LAST => ID */
   59,  /*    CURRENT => ID */
   59,  /*  FOLLOWING => ID */
   59,  /*  PARTITION => ID */
   59,  /*  PRECEDING => ID */
   59,  /*      RANGE => ID */
   59,  /*  UNBOUNDED => ID */
   59,  /*    EXCLUDE => ID */
   59,  /*     GROUPS => ID */
   59,  /*     OTHERS => ID */
   59,  /*       TIES => ID */
   59,  /*  GENERATED => ID */
   59,  /*     ALWAYS => ID */
   59,  /*    REINDEX => ID */
   59,  /*     RENAME => ID */
   59,  /*   CTIME_KW => ID */
    0,  /*        ANY => nothing */
    0,  /*     BITAND => nothing */
    0,  /*      BITOR => nothing */
    0,  /*     LSHIFT => nothing */
    0,  /*     RSHIFT => nothing */
    0,  /*       PLUS => nothing */
    0,  /*      MINUS => nothing */
    0,  /*       STAR => nothing */
    0,  /*      SLASH => nothing */
    0,  /*        REM => nothing */
    0,  /*     CONCAT => nothing */
    0,  /*    COLLATE => nothing */
    0,  /*     BITNOT => nothing */
    0,  /*         ON => nothing */
    0,  /*    INDEXED => nothing */
    0,  /*     STRING => nothing */
    0,  /*    JOIN_KW => nothing */
    0,  /* CONSTRAINT => nothing */
    0,  /*    DEFAULT => nothing */
    0,  /*       NULL => nothing */
    0,  /*    PRIMARY => nothing */
    0,  /*     UNIQUE => nothing */
    0,  /*      CHECK => nothing */
    0,  /* REFERENCES => nothing */
    0,  /*   AUTOINCR => nothing */
    0,  /*     INSERT => nothing */
    0,  /*     DELETE => nothing */
    0,  /*     UPDATE => nothing */
    0,  /*        SET => nothing */
    0,  /* DEFERRABLE => nothing */
    0,  /*    FOREIGN => nothing */
    0,  /*       DROP => nothing */
    0,  /*      UNION => nothing */
    0,  /*        ALL => nothing */
    0,  /*     EXCEPT => nothing */
    0,  /*  INTERSECT => nothing */
    0,  /*     SELECT => nothing */
    0,  /*     VALUES => nothing */
    0,  /*   DISTINCT => nothing */
    0,  /*        DOT => nothing */
    0,  /*       FROM => nothing */
    0,  /*       JOIN => nothing */
    0,  /*      USING => nothing */
    0,  /*      ORDER => nothing */
    0,  /*      GROUP => nothing */
    0,  /*     HAVING => nothing */
    0,  /*      LIMIT => nothing */
    0,  /*      WHERE => nothing */
    0,  /*       INTO => nothing */
    0,  /*    NOTHING => nothing */
    0,  /*      FLOAT => nothing */
    0,  /*       BLOB => nothing */
    0,  /*    INTEGER => nothing */
    0,  /*   VARIABLE => nothing */
    0,  /*       CASE => nothing */
    0,  /*       WHEN => nothing */
    0,  /*       THEN => nothing */
    0,  /*       ELSE => nothing */
    0,  /*      INDEX => nothing */
    0,  /*      ALTER => nothing */
    0,  /*        ADD => nothing */
    0,  /*     WINDOW => nothing */
    0,  /*       OVER => nothing */
    0,  /*     FILTER => nothing */
    0,  /*     COLUMN => nothing */
    0,  /* AGG_FUNCTION => nothing */
    0,  /* AGG_COLUMN => nothing */
    0,  /*  TRUEFALSE => nothing */
    0,  /*      ISNOT => nothing */
    0,  /*   FUNCTION => nothing */
    0,  /*     UMINUS => nothing */
    0,  /*      UPLUS => nothing */
    0,  /*      TRUTH => nothing */
    0,  /*   REGISTER => nothing */
    0,  /*     VECTOR => nothing */
    0,  /* SELECT_COLUMN => nothing */

Referenced by yy_find_shift_action().

◆ yyRuleInfoLhs

const YYCODETYPE yyRuleInfoLhs[]

static

Definition at line 156667 of file sqlite3.c.

                                          {
   185,  /* (0) explain ::= EXPLAIN */
   185,  /* (1) explain ::= EXPLAIN QUERY PLAN */
   184,  /* (2) cmdx ::= cmd */
   186,  /* (3) cmd ::= BEGIN transtype trans_opt */
   187,  /* (4) transtype ::= */
   187,  /* (5) transtype ::= DEFERRED */
   187,  /* (6) transtype ::= IMMEDIATE */
   187,  /* (7) transtype ::= EXCLUSIVE */
   186,  /* (8) cmd ::= COMMIT|END trans_opt */
   186,  /* (9) cmd ::= ROLLBACK trans_opt */
   186,  /* (10) cmd ::= SAVEPOINT nm */
   186,  /* (11) cmd ::= RELEASE savepoint_opt nm */
   186,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
   191,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
   193,  /* (14) createkw ::= CREATE */
   195,  /* (15) ifnotexists ::= */
   195,  /* (16) ifnotexists ::= IF NOT EXISTS */
   194,  /* (17) temp ::= TEMP */
   194,  /* (18) temp ::= */
   192,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
   192,  /* (20) create_table_args ::= AS select */
   199,  /* (21) table_options ::= */
   199,  /* (22) table_options ::= WITHOUT nm */
   201,  /* (23) columnname ::= nm typetoken */
   203,  /* (24) typetoken ::= */
   203,  /* (25) typetoken ::= typename LP signed RP */
   203,  /* (26) typetoken ::= typename LP signed COMMA signed RP */
   204,  /* (27) typename ::= typename ID|STRING */
   208,  /* (28) scanpt ::= */
   209,  /* (29) scantok ::= */
   210,  /* (30) ccons ::= CONSTRAINT nm */
   210,  /* (31) ccons ::= DEFAULT scantok term */
   210,  /* (32) ccons ::= DEFAULT LP expr RP */
   210,  /* (33) ccons ::= DEFAULT PLUS scantok term */
   210,  /* (34) ccons ::= DEFAULT MINUS scantok term */
   210,  /* (35) ccons ::= DEFAULT scantok ID|INDEXED */
   210,  /* (36) ccons ::= NOT NULL onconf */
   210,  /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
   210,  /* (38) ccons ::= UNIQUE onconf */
   210,  /* (39) ccons ::= CHECK LP expr RP */
   210,  /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
   210,  /* (41) ccons ::= defer_subclause */
   210,  /* (42) ccons ::= COLLATE ID|STRING */
   219,  /* (43) generated ::= LP expr RP */
   219,  /* (44) generated ::= LP expr RP ID */
   215,  /* (45) autoinc ::= */
   215,  /* (46) autoinc ::= AUTOINCR */
   217,  /* (47) refargs ::= */
   217,  /* (48) refargs ::= refargs refarg */
   220,  /* (49) refarg ::= MATCH nm */
   220,  /* (50) refarg ::= ON INSERT refact */
   220,  /* (51) refarg ::= ON DELETE refact */
   220,  /* (52) refarg ::= ON UPDATE refact */
   221,  /* (53) refact ::= SET NULL */
   221,  /* (54) refact ::= SET DEFAULT */
   221,  /* (55) refact ::= CASCADE */
   221,  /* (56) refact ::= RESTRICT */
   221,  /* (57) refact ::= NO ACTION */
   218,  /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
   218,  /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
   222,  /* (60) init_deferred_pred_opt ::= */
   222,  /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
   222,  /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
   198,  /* (63) conslist_opt ::= */
   224,  /* (64) tconscomma ::= COMMA */
   225,  /* (65) tcons ::= CONSTRAINT nm */
   225,  /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
   225,  /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
   225,  /* (68) tcons ::= CHECK LP expr RP onconf */
   225,  /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
   228,  /* (70) defer_subclause_opt ::= */
   213,  /* (71) onconf ::= */
   213,  /* (72) onconf ::= ON CONFLICT resolvetype */
   229,  /* (73) orconf ::= */
   229,  /* (74) orconf ::= OR resolvetype */
   230,  /* (75) resolvetype ::= IGNORE */
   230,  /* (76) resolvetype ::= REPLACE */
   186,  /* (77) cmd ::= DROP TABLE ifexists fullname */
   232,  /* (78) ifexists ::= IF EXISTS */
   232,  /* (79) ifexists ::= */
   186,  /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
   186,  /* (81) cmd ::= DROP VIEW ifexists fullname */
   186,  /* (82) cmd ::= select */
   200,  /* (83) select ::= WITH wqlist selectnowith */
   200,  /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
   200,  /* (85) select ::= selectnowith */
   234,  /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
   237,  /* (87) multiselect_op ::= UNION */
   237,  /* (88) multiselect_op ::= UNION ALL */
   237,  /* (89) multiselect_op ::= EXCEPT|INTERSECT */
   235,  /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
   235,  /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
   247,  /* (92) values ::= VALUES LP nexprlist RP */
   247,  /* (93) values ::= values COMMA LP nexprlist RP */
   238,  /* (94) distinct ::= DISTINCT */
   238,  /* (95) distinct ::= ALL */
   238,  /* (96) distinct ::= */
   249,  /* (97) sclp ::= */
   239,  /* (98) selcollist ::= sclp scanpt expr scanpt as */
   239,  /* (99) selcollist ::= sclp scanpt STAR */
   239,  /* (100) selcollist ::= sclp scanpt nm DOT STAR */
   250,  /* (101) as ::= AS nm */
   250,  /* (102) as ::= */
   240,  /* (103) from ::= */
   240,  /* (104) from ::= FROM seltablist */
   252,  /* (105) stl_prefix ::= seltablist joinop */
   252,  /* (106) stl_prefix ::= */
   251,  /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
   251,  /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
   251,  /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
   251,  /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
   196,  /* (111) dbnm ::= */
   196,  /* (112) dbnm ::= DOT nm */
   233,  /* (113) fullname ::= nm */
   233,  /* (114) fullname ::= nm DOT nm */
   258,  /* (115) xfullname ::= nm */
   258,  /* (116) xfullname ::= nm DOT nm */
   258,  /* (117) xfullname ::= nm DOT nm AS nm */
   258,  /* (118) xfullname ::= nm AS nm */
   253,  /* (119) joinop ::= COMMA|JOIN */
   253,  /* (120) joinop ::= JOIN_KW JOIN */
   253,  /* (121) joinop ::= JOIN_KW nm JOIN */
   253,  /* (122) joinop ::= JOIN_KW nm nm JOIN */
   255,  /* (123) on_opt ::= ON expr */
   255,  /* (124) on_opt ::= */
   254,  /* (125) indexed_opt ::= */
   254,  /* (126) indexed_opt ::= INDEXED BY nm */
   254,  /* (127) indexed_opt ::= NOT INDEXED */
   256,  /* (128) using_opt ::= USING LP idlist RP */
   256,  /* (129) using_opt ::= */
   244,  /* (130) orderby_opt ::= */
   244,  /* (131) orderby_opt ::= ORDER BY sortlist */
   226,  /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
   226,  /* (133) sortlist ::= expr sortorder nulls */
   214,  /* (134) sortorder ::= ASC */
   214,  /* (135) sortorder ::= DESC */
   214,  /* (136) sortorder ::= */
   260,  /* (137) nulls ::= NULLS FIRST */
   260,  /* (138) nulls ::= NULLS LAST */
   260,  /* (139) nulls ::= */
   242,  /* (140) groupby_opt ::= */
   242,  /* (141) groupby_opt ::= GROUP BY nexprlist */
   243,  /* (142) having_opt ::= */
   243,  /* (143) having_opt ::= HAVING expr */
   245,  /* (144) limit_opt ::= */
   245,  /* (145) limit_opt ::= LIMIT expr */
   245,  /* (146) limit_opt ::= LIMIT expr OFFSET expr */
   245,  /* (147) limit_opt ::= LIMIT expr COMMA expr */
   186,  /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
   241,  /* (149) where_opt ::= */
   241,  /* (150) where_opt ::= WHERE expr */
   186,  /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
   262,  /* (152) setlist ::= setlist COMMA nm EQ expr */
   262,  /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */
   262,  /* (154) setlist ::= nm EQ expr */
   262,  /* (155) setlist ::= LP idlist RP EQ expr */
   186,  /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
   186,  /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
   265,  /* (158) upsert ::= */
   265,  /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
   265,  /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
   265,  /* (161) upsert ::= ON CONFLICT DO NOTHING */
   263,  /* (162) insert_cmd ::= INSERT orconf */
   263,  /* (163) insert_cmd ::= REPLACE */
   264,  /* (164) idlist_opt ::= */
   264,  /* (165) idlist_opt ::= LP idlist RP */
   259,  /* (166) idlist ::= idlist COMMA nm */
   259,  /* (167) idlist ::= nm */
   212,  /* (168) expr ::= LP expr RP */
   212,  /* (169) expr ::= ID|INDEXED */
   212,  /* (170) expr ::= JOIN_KW */
   212,  /* (171) expr ::= nm DOT nm */
   212,  /* (172) expr ::= nm DOT nm DOT nm */
   211,  /* (173) term ::= NULL|FLOAT|BLOB */
   211,  /* (174) term ::= STRING */
   211,  /* (175) term ::= INTEGER */
   212,  /* (176) expr ::= VARIABLE */
   212,  /* (177) expr ::= expr COLLATE ID|STRING */
   212,  /* (178) expr ::= CAST LP expr AS typetoken RP */
   212,  /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */
   212,  /* (180) expr ::= ID|INDEXED LP STAR RP */
   212,  /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
   212,  /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */
   211,  /* (183) term ::= CTIME_KW */
   212,  /* (184) expr ::= LP nexprlist COMMA expr RP */
   212,  /* (185) expr ::= expr AND expr */
   212,  /* (186) expr ::= expr OR expr */
   212,  /* (187) expr ::= expr LT|GT|GE|LE expr */
   212,  /* (188) expr ::= expr EQ|NE expr */
   212,  /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
   212,  /* (190) expr ::= expr PLUS|MINUS expr */
   212,  /* (191) expr ::= expr STAR|SLASH|REM expr */
   212,  /* (192) expr ::= expr CONCAT expr */
   267,  /* (193) likeop ::= NOT LIKE_KW|MATCH */
   212,  /* (194) expr ::= expr likeop expr */
   212,  /* (195) expr ::= expr likeop expr ESCAPE expr */
   212,  /* (196) expr ::= expr ISNULL|NOTNULL */
   212,  /* (197) expr ::= expr NOT NULL */
   212,  /* (198) expr ::= expr IS expr */
   212,  /* (199) expr ::= expr IS NOT expr */
   212,  /* (200) expr ::= NOT expr */
   212,  /* (201) expr ::= BITNOT expr */
   212,  /* (202) expr ::= PLUS|MINUS expr */
   268,  /* (203) between_op ::= BETWEEN */
   268,  /* (204) between_op ::= NOT BETWEEN */
   212,  /* (205) expr ::= expr between_op expr AND expr */
   269,  /* (206) in_op ::= IN */
   269,  /* (207) in_op ::= NOT IN */
   212,  /* (208) expr ::= expr in_op LP exprlist RP */
   212,  /* (209) expr ::= LP select RP */
   212,  /* (210) expr ::= expr in_op LP select RP */
   212,  /* (211) expr ::= expr in_op nm dbnm paren_exprlist */
   212,  /* (212) expr ::= EXISTS LP select RP */
   212,  /* (213) expr ::= CASE case_operand case_exprlist case_else END */
   272,  /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */
   272,  /* (215) case_exprlist ::= WHEN expr THEN expr */
   273,  /* (216) case_else ::= ELSE expr */
   273,  /* (217) case_else ::= */
   271,  /* (218) case_operand ::= expr */
   271,  /* (219) case_operand ::= */
   257,  /* (220) exprlist ::= */
   248,  /* (221) nexprlist ::= nexprlist COMMA expr */
   248,  /* (222) nexprlist ::= expr */
   270,  /* (223) paren_exprlist ::= */
   270,  /* (224) paren_exprlist ::= LP exprlist RP */
   186,  /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
   274,  /* (226) uniqueflag ::= UNIQUE */
   274,  /* (227) uniqueflag ::= */
   216,  /* (228) eidlist_opt ::= */
   216,  /* (229) eidlist_opt ::= LP eidlist RP */
   227,  /* (230) eidlist ::= eidlist COMMA nm collate sortorder */
   227,  /* (231) eidlist ::= nm collate sortorder */
   275,  /* (232) collate ::= */
   275,  /* (233) collate ::= COLLATE ID|STRING */
   186,  /* (234) cmd ::= DROP INDEX ifexists fullname */
   186,  /* (235) cmd ::= VACUUM vinto */
   186,  /* (236) cmd ::= VACUUM nm vinto */
   276,  /* (237) vinto ::= INTO expr */
   276,  /* (238) vinto ::= */
   186,  /* (239) cmd ::= PRAGMA nm dbnm */
   186,  /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */
   186,  /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */
   186,  /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */
   186,  /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */
   206,  /* (244) plus_num ::= PLUS INTEGER|FLOAT */
   207,  /* (245) minus_num ::= MINUS INTEGER|FLOAT */
   186,  /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
   278,  /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
   280,  /* (248) trigger_time ::= BEFORE|AFTER */
   280,  /* (249) trigger_time ::= INSTEAD OF */
   280,  /* (250) trigger_time ::= */
   281,  /* (251) trigger_event ::= DELETE|INSERT */
   281,  /* (252) trigger_event ::= UPDATE */
   281,  /* (253) trigger_event ::= UPDATE OF idlist */
   283,  /* (254) when_clause ::= */
   283,  /* (255) when_clause ::= WHEN expr */
   279,  /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
   279,  /* (257) trigger_cmd_list ::= trigger_cmd SEMI */
   285,  /* (258) trnm ::= nm DOT nm */
   286,  /* (259) tridxby ::= INDEXED BY nm */
   286,  /* (260) tridxby ::= NOT INDEXED */
   284,  /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
   284,  /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
   284,  /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
   284,  /* (264) trigger_cmd ::= scanpt select scanpt */
   212,  /* (265) expr ::= RAISE LP IGNORE RP */
   212,  /* (266) expr ::= RAISE LP raisetype COMMA nm RP */
   231,  /* (267) raisetype ::= ROLLBACK */
   231,  /* (268) raisetype ::= ABORT */
   231,  /* (269) raisetype ::= FAIL */
   186,  /* (270) cmd ::= DROP TRIGGER ifexists fullname */
   186,  /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
   186,  /* (272) cmd ::= DETACH database_kw_opt expr */
   288,  /* (273) key_opt ::= */
   288,  /* (274) key_opt ::= KEY expr */
   186,  /* (275) cmd ::= REINDEX */
   186,  /* (276) cmd ::= REINDEX nm dbnm */
   186,  /* (277) cmd ::= ANALYZE */
   186,  /* (278) cmd ::= ANALYZE nm dbnm */
   186,  /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */
   186,  /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
   289,  /* (281) add_column_fullname ::= fullname */
   186,  /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   186,  /* (283) cmd ::= create_vtab */
   186,  /* (284) cmd ::= create_vtab LP vtabarglist RP */
   291,  /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
   293,  /* (286) vtabarg ::= */
   294,  /* (287) vtabargtoken ::= ANY */
   294,  /* (288) vtabargtoken ::= lp anylist RP */
   295,  /* (289) lp ::= LP */
   261,  /* (290) with ::= WITH wqlist */
   261,  /* (291) with ::= WITH RECURSIVE wqlist */
   236,  /* (292) wqlist ::= nm eidlist_opt AS LP select RP */
   236,  /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
   297,  /* (294) windowdefn_list ::= windowdefn */
   297,  /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   298,  /* (296) windowdefn ::= nm AS LP window RP */
   299,  /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   299,  /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   299,  /* (299) window ::= ORDER BY sortlist frame_opt */
   299,  /* (300) window ::= nm ORDER BY sortlist frame_opt */
   299,  /* (301) window ::= frame_opt */
   299,  /* (302) window ::= nm frame_opt */
   300,  /* (303) frame_opt ::= */
   300,  /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   300,  /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   304,  /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */
   306,  /* (307) frame_bound_s ::= frame_bound */
   306,  /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */
   307,  /* (309) frame_bound_e ::= frame_bound */
   307,  /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */
   305,  /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */
   305,  /* (312) frame_bound ::= CURRENT ROW */
   308,  /* (313) frame_exclude_opt ::= */
   308,  /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */
   309,  /* (315) frame_exclude ::= NO OTHERS */
   309,  /* (316) frame_exclude ::= CURRENT ROW */
   309,  /* (317) frame_exclude ::= GROUP|TIES */
   246,  /* (318) window_clause ::= WINDOW windowdefn_list */
   266,  /* (319) filter_over ::= filter_clause over_clause */
   266,  /* (320) filter_over ::= over_clause */
   266,  /* (321) filter_over ::= filter_clause */
   303,  /* (322) over_clause ::= OVER LP window RP */
   303,  /* (323) over_clause ::= OVER nm */
   302,  /* (324) filter_clause ::= FILTER LP WHERE expr RP */
   181,  /* (325) input ::= cmdlist */
   182,  /* (326) cmdlist ::= cmdlist ecmd */
   182,  /* (327) cmdlist ::= ecmd */
   183,  /* (328) ecmd ::= SEMI */
   183,  /* (329) ecmd ::= cmdx SEMI */
   183,  /* (330) ecmd ::= explain cmdx SEMI */
   188,  /* (331) trans_opt ::= */
   188,  /* (332) trans_opt ::= TRANSACTION */
   188,  /* (333) trans_opt ::= TRANSACTION nm */
   190,  /* (334) savepoint_opt ::= SAVEPOINT */
   190,  /* (335) savepoint_opt ::= */
   186,  /* (336) cmd ::= create_table create_table_args */
   197,  /* (337) columnlist ::= columnlist COMMA columnname carglist */
   197,  /* (338) columnlist ::= columnname carglist */
   189,  /* (339) nm ::= ID|INDEXED */
   189,  /* (340) nm ::= STRING */
   189,  /* (341) nm ::= JOIN_KW */
   203,  /* (342) typetoken ::= typename */
   204,  /* (343) typename ::= ID|STRING */
   205,  /* (344) signed ::= plus_num */
   205,  /* (345) signed ::= minus_num */
   202,  /* (346) carglist ::= carglist ccons */
   202,  /* (347) carglist ::= */
   210,  /* (348) ccons ::= NULL onconf */
   210,  /* (349) ccons ::= GENERATED ALWAYS AS generated */
   210,  /* (350) ccons ::= AS generated */
   198,  /* (351) conslist_opt ::= COMMA conslist */
   223,  /* (352) conslist ::= conslist tconscomma tcons */
   223,  /* (353) conslist ::= tcons */
   224,  /* (354) tconscomma ::= */
   228,  /* (355) defer_subclause_opt ::= defer_subclause */
   230,  /* (356) resolvetype ::= raisetype */
   234,  /* (357) selectnowith ::= oneselect */
   235,  /* (358) oneselect ::= values */
   249,  /* (359) sclp ::= selcollist COMMA */
   250,  /* (360) as ::= ID|STRING */
   212,  /* (361) expr ::= term */
   267,  /* (362) likeop ::= LIKE_KW|MATCH */
   257,  /* (363) exprlist ::= nexprlist */
   277,  /* (364) nmnum ::= plus_num */
   277,  /* (365) nmnum ::= nm */
   277,  /* (366) nmnum ::= ON */
   277,  /* (367) nmnum ::= DELETE */
   277,  /* (368) nmnum ::= DEFAULT */
   206,  /* (369) plus_num ::= INTEGER|FLOAT */
   282,  /* (370) foreach_clause ::= */
   282,  /* (371) foreach_clause ::= FOR EACH ROW */
   285,  /* (372) trnm ::= nm */
   286,  /* (373) tridxby ::= */
   287,  /* (374) database_kw_opt ::= DATABASE */
   287,  /* (375) database_kw_opt ::= */
   290,  /* (376) kwcolumn_opt ::= */
   290,  /* (377) kwcolumn_opt ::= COLUMNKW */
   292,  /* (378) vtabarglist ::= vtabarg */
   292,  /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */

Referenced by yy_reduce().

◆ yyRuleInfoNRhs

const signed char yyRuleInfoNRhs[]

static

Definition at line 157057 of file sqlite3.c.

                                            {
   -1,  /* (0) explain ::= EXPLAIN */
   -3,  /* (1) explain ::= EXPLAIN QUERY PLAN */
   -1,  /* (2) cmdx ::= cmd */
   -3,  /* (3) cmd ::= BEGIN transtype trans_opt */
    0,  /* (4) transtype ::= */
   -1,  /* (5) transtype ::= DEFERRED */
   -1,  /* (6) transtype ::= IMMEDIATE */
   -1,  /* (7) transtype ::= EXCLUSIVE */
   -2,  /* (8) cmd ::= COMMIT|END trans_opt */
   -2,  /* (9) cmd ::= ROLLBACK trans_opt */
   -2,  /* (10) cmd ::= SAVEPOINT nm */
   -3,  /* (11) cmd ::= RELEASE savepoint_opt nm */
   -5,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
   -6,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
   -1,  /* (14) createkw ::= CREATE */
    0,  /* (15) ifnotexists ::= */
   -3,  /* (16) ifnotexists ::= IF NOT EXISTS */
   -1,  /* (17) temp ::= TEMP */
    0,  /* (18) temp ::= */
   -5,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
   -2,  /* (20) create_table_args ::= AS select */
    0,  /* (21) table_options ::= */
   -2,  /* (22) table_options ::= WITHOUT nm */
   -2,  /* (23) columnname ::= nm typetoken */
    0,  /* (24) typetoken ::= */
   -4,  /* (25) typetoken ::= typename LP signed RP */
   -6,  /* (26) typetoken ::= typename LP signed COMMA signed RP */
   -2,  /* (27) typename ::= typename ID|STRING */
    0,  /* (28) scanpt ::= */
    0,  /* (29) scantok ::= */
   -2,  /* (30) ccons ::= CONSTRAINT nm */
   -3,  /* (31) ccons ::= DEFAULT scantok term */
   -4,  /* (32) ccons ::= DEFAULT LP expr RP */
   -4,  /* (33) ccons ::= DEFAULT PLUS scantok term */
   -4,  /* (34) ccons ::= DEFAULT MINUS scantok term */
   -3,  /* (35) ccons ::= DEFAULT scantok ID|INDEXED */
   -3,  /* (36) ccons ::= NOT NULL onconf */
   -5,  /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
   -2,  /* (38) ccons ::= UNIQUE onconf */
   -4,  /* (39) ccons ::= CHECK LP expr RP */
   -4,  /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
   -1,  /* (41) ccons ::= defer_subclause */
   -2,  /* (42) ccons ::= COLLATE ID|STRING */
   -3,  /* (43) generated ::= LP expr RP */
   -4,  /* (44) generated ::= LP expr RP ID */
    0,  /* (45) autoinc ::= */
   -1,  /* (46) autoinc ::= AUTOINCR */
    0,  /* (47) refargs ::= */
   -2,  /* (48) refargs ::= refargs refarg */
   -2,  /* (49) refarg ::= MATCH nm */
   -3,  /* (50) refarg ::= ON INSERT refact */
   -3,  /* (51) refarg ::= ON DELETE refact */
   -3,  /* (52) refarg ::= ON UPDATE refact */
   -2,  /* (53) refact ::= SET NULL */
   -2,  /* (54) refact ::= SET DEFAULT */
   -1,  /* (55) refact ::= CASCADE */
   -1,  /* (56) refact ::= RESTRICT */
   -2,  /* (57) refact ::= NO ACTION */
   -3,  /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
   -2,  /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
    0,  /* (60) init_deferred_pred_opt ::= */
   -2,  /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
   -2,  /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
    0,  /* (63) conslist_opt ::= */
   -1,  /* (64) tconscomma ::= COMMA */
   -2,  /* (65) tcons ::= CONSTRAINT nm */
   -7,  /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
   -5,  /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
   -5,  /* (68) tcons ::= CHECK LP expr RP onconf */
  -10,  /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
    0,  /* (70) defer_subclause_opt ::= */
    0,  /* (71) onconf ::= */
   -3,  /* (72) onconf ::= ON CONFLICT resolvetype */
    0,  /* (73) orconf ::= */
   -2,  /* (74) orconf ::= OR resolvetype */
   -1,  /* (75) resolvetype ::= IGNORE */
   -1,  /* (76) resolvetype ::= REPLACE */
   -4,  /* (77) cmd ::= DROP TABLE ifexists fullname */
   -2,  /* (78) ifexists ::= IF EXISTS */
    0,  /* (79) ifexists ::= */
   -9,  /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
   -4,  /* (81) cmd ::= DROP VIEW ifexists fullname */
   -1,  /* (82) cmd ::= select */
   -3,  /* (83) select ::= WITH wqlist selectnowith */
   -4,  /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
   -1,  /* (85) select ::= selectnowith */
   -3,  /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
   -1,  /* (87) multiselect_op ::= UNION */
   -2,  /* (88) multiselect_op ::= UNION ALL */
   -1,  /* (89) multiselect_op ::= EXCEPT|INTERSECT */
   -9,  /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
  -10,  /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
   -4,  /* (92) values ::= VALUES LP nexprlist RP */
   -5,  /* (93) values ::= values COMMA LP nexprlist RP */
   -1,  /* (94) distinct ::= DISTINCT */
   -1,  /* (95) distinct ::= ALL */
    0,  /* (96) distinct ::= */
    0,  /* (97) sclp ::= */
   -5,  /* (98) selcollist ::= sclp scanpt expr scanpt as */
   -3,  /* (99) selcollist ::= sclp scanpt STAR */
   -5,  /* (100) selcollist ::= sclp scanpt nm DOT STAR */
   -2,  /* (101) as ::= AS nm */
    0,  /* (102) as ::= */
    0,  /* (103) from ::= */
   -2,  /* (104) from ::= FROM seltablist */
   -2,  /* (105) stl_prefix ::= seltablist joinop */
    0,  /* (106) stl_prefix ::= */
   -7,  /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
   -9,  /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
   -7,  /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
   -7,  /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
    0,  /* (111) dbnm ::= */
   -2,  /* (112) dbnm ::= DOT nm */
   -1,  /* (113) fullname ::= nm */
   -3,  /* (114) fullname ::= nm DOT nm */
   -1,  /* (115) xfullname ::= nm */
   -3,  /* (116) xfullname ::= nm DOT nm */
   -5,  /* (117) xfullname ::= nm DOT nm AS nm */
   -3,  /* (118) xfullname ::= nm AS nm */
   -1,  /* (119) joinop ::= COMMA|JOIN */
   -2,  /* (120) joinop ::= JOIN_KW JOIN */
   -3,  /* (121) joinop ::= JOIN_KW nm JOIN */
   -4,  /* (122) joinop ::= JOIN_KW nm nm JOIN */
   -2,  /* (123) on_opt ::= ON expr */
    0,  /* (124) on_opt ::= */
    0,  /* (125) indexed_opt ::= */
   -3,  /* (126) indexed_opt ::= INDEXED BY nm */
   -2,  /* (127) indexed_opt ::= NOT INDEXED */
   -4,  /* (128) using_opt ::= USING LP idlist RP */
    0,  /* (129) using_opt ::= */
    0,  /* (130) orderby_opt ::= */
   -3,  /* (131) orderby_opt ::= ORDER BY sortlist */
   -5,  /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
   -3,  /* (133) sortlist ::= expr sortorder nulls */
   -1,  /* (134) sortorder ::= ASC */
   -1,  /* (135) sortorder ::= DESC */
    0,  /* (136) sortorder ::= */
   -2,  /* (137) nulls ::= NULLS FIRST */
   -2,  /* (138) nulls ::= NULLS LAST */
    0,  /* (139) nulls ::= */
    0,  /* (140) groupby_opt ::= */
   -3,  /* (141) groupby_opt ::= GROUP BY nexprlist */
    0,  /* (142) having_opt ::= */
   -2,  /* (143) having_opt ::= HAVING expr */
    0,  /* (144) limit_opt ::= */
   -2,  /* (145) limit_opt ::= LIMIT expr */
   -4,  /* (146) limit_opt ::= LIMIT expr OFFSET expr */
   -4,  /* (147) limit_opt ::= LIMIT expr COMMA expr */
   -6,  /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
    0,  /* (149) where_opt ::= */
   -2,  /* (150) where_opt ::= WHERE expr */
   -9,  /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
   -5,  /* (152) setlist ::= setlist COMMA nm EQ expr */
   -7,  /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */
   -3,  /* (154) setlist ::= nm EQ expr */
   -5,  /* (155) setlist ::= LP idlist RP EQ expr */
   -7,  /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
   -7,  /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
    0,  /* (158) upsert ::= */
  -11,  /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
   -8,  /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
   -4,  /* (161) upsert ::= ON CONFLICT DO NOTHING */
   -2,  /* (162) insert_cmd ::= INSERT orconf */
   -1,  /* (163) insert_cmd ::= REPLACE */
    0,  /* (164) idlist_opt ::= */
   -3,  /* (165) idlist_opt ::= LP idlist RP */
   -3,  /* (166) idlist ::= idlist COMMA nm */
   -1,  /* (167) idlist ::= nm */
   -3,  /* (168) expr ::= LP expr RP */
   -1,  /* (169) expr ::= ID|INDEXED */
   -1,  /* (170) expr ::= JOIN_KW */
   -3,  /* (171) expr ::= nm DOT nm */
   -5,  /* (172) expr ::= nm DOT nm DOT nm */
   -1,  /* (173) term ::= NULL|FLOAT|BLOB */
   -1,  /* (174) term ::= STRING */
   -1,  /* (175) term ::= INTEGER */
   -1,  /* (176) expr ::= VARIABLE */
   -3,  /* (177) expr ::= expr COLLATE ID|STRING */
   -6,  /* (178) expr ::= CAST LP expr AS typetoken RP */
   -5,  /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */
   -4,  /* (180) expr ::= ID|INDEXED LP STAR RP */
   -6,  /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
   -5,  /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */
   -1,  /* (183) term ::= CTIME_KW */
   -5,  /* (184) expr ::= LP nexprlist COMMA expr RP */
   -3,  /* (185) expr ::= expr AND expr */
   -3,  /* (186) expr ::= expr OR expr */
   -3,  /* (187) expr ::= expr LT|GT|GE|LE expr */
   -3,  /* (188) expr ::= expr EQ|NE expr */
   -3,  /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
   -3,  /* (190) expr ::= expr PLUS|MINUS expr */
   -3,  /* (191) expr ::= expr STAR|SLASH|REM expr */
   -3,  /* (192) expr ::= expr CONCAT expr */
   -2,  /* (193) likeop ::= NOT LIKE_KW|MATCH */
   -3,  /* (194) expr ::= expr likeop expr */
   -5,  /* (195) expr ::= expr likeop expr ESCAPE expr */
   -2,  /* (196) expr ::= expr ISNULL|NOTNULL */
   -3,  /* (197) expr ::= expr NOT NULL */
   -3,  /* (198) expr ::= expr IS expr */
   -4,  /* (199) expr ::= expr IS NOT expr */
   -2,  /* (200) expr ::= NOT expr */
   -2,  /* (201) expr ::= BITNOT expr */
   -2,  /* (202) expr ::= PLUS|MINUS expr */
   -1,  /* (203) between_op ::= BETWEEN */
   -2,  /* (204) between_op ::= NOT BETWEEN */
   -5,  /* (205) expr ::= expr between_op expr AND expr */
   -1,  /* (206) in_op ::= IN */
   -2,  /* (207) in_op ::= NOT IN */
   -5,  /* (208) expr ::= expr in_op LP exprlist RP */
   -3,  /* (209) expr ::= LP select RP */
   -5,  /* (210) expr ::= expr in_op LP select RP */
   -5,  /* (211) expr ::= expr in_op nm dbnm paren_exprlist */
   -4,  /* (212) expr ::= EXISTS LP select RP */
   -5,  /* (213) expr ::= CASE case_operand case_exprlist case_else END */
   -5,  /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */
   -4,  /* (215) case_exprlist ::= WHEN expr THEN expr */
   -2,  /* (216) case_else ::= ELSE expr */
    0,  /* (217) case_else ::= */
   -1,  /* (218) case_operand ::= expr */
    0,  /* (219) case_operand ::= */
    0,  /* (220) exprlist ::= */
   -3,  /* (221) nexprlist ::= nexprlist COMMA expr */
   -1,  /* (222) nexprlist ::= expr */
    0,  /* (223) paren_exprlist ::= */
   -3,  /* (224) paren_exprlist ::= LP exprlist RP */
  -12,  /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
   -1,  /* (226) uniqueflag ::= UNIQUE */
    0,  /* (227) uniqueflag ::= */
    0,  /* (228) eidlist_opt ::= */
   -3,  /* (229) eidlist_opt ::= LP eidlist RP */
   -5,  /* (230) eidlist ::= eidlist COMMA nm collate sortorder */
   -3,  /* (231) eidlist ::= nm collate sortorder */
    0,  /* (232) collate ::= */
   -2,  /* (233) collate ::= COLLATE ID|STRING */
   -4,  /* (234) cmd ::= DROP INDEX ifexists fullname */
   -2,  /* (235) cmd ::= VACUUM vinto */
   -3,  /* (236) cmd ::= VACUUM nm vinto */
   -2,  /* (237) vinto ::= INTO expr */
    0,  /* (238) vinto ::= */
   -3,  /* (239) cmd ::= PRAGMA nm dbnm */
   -5,  /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */
   -6,  /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */
   -5,  /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */
   -6,  /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */
   -2,  /* (244) plus_num ::= PLUS INTEGER|FLOAT */
   -2,  /* (245) minus_num ::= MINUS INTEGER|FLOAT */
   -5,  /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
  -11,  /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
   -1,  /* (248) trigger_time ::= BEFORE|AFTER */
   -2,  /* (249) trigger_time ::= INSTEAD OF */
    0,  /* (250) trigger_time ::= */
   -1,  /* (251) trigger_event ::= DELETE|INSERT */
   -1,  /* (252) trigger_event ::= UPDATE */
   -3,  /* (253) trigger_event ::= UPDATE OF idlist */
    0,  /* (254) when_clause ::= */
   -2,  /* (255) when_clause ::= WHEN expr */
   -3,  /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
   -2,  /* (257) trigger_cmd_list ::= trigger_cmd SEMI */
   -3,  /* (258) trnm ::= nm DOT nm */
   -3,  /* (259) tridxby ::= INDEXED BY nm */
   -2,  /* (260) tridxby ::= NOT INDEXED */
   -9,  /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
   -8,  /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
   -6,  /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
   -3,  /* (264) trigger_cmd ::= scanpt select scanpt */
   -4,  /* (265) expr ::= RAISE LP IGNORE RP */
   -6,  /* (266) expr ::= RAISE LP raisetype COMMA nm RP */
   -1,  /* (267) raisetype ::= ROLLBACK */
   -1,  /* (268) raisetype ::= ABORT */
   -1,  /* (269) raisetype ::= FAIL */
   -4,  /* (270) cmd ::= DROP TRIGGER ifexists fullname */
   -6,  /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
   -3,  /* (272) cmd ::= DETACH database_kw_opt expr */
    0,  /* (273) key_opt ::= */
   -2,  /* (274) key_opt ::= KEY expr */
   -1,  /* (275) cmd ::= REINDEX */
   -3,  /* (276) cmd ::= REINDEX nm dbnm */
   -1,  /* (277) cmd ::= ANALYZE */
   -3,  /* (278) cmd ::= ANALYZE nm dbnm */
   -6,  /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */
   -7,  /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
   -1,  /* (281) add_column_fullname ::= fullname */
   -8,  /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   -1,  /* (283) cmd ::= create_vtab */
   -4,  /* (284) cmd ::= create_vtab LP vtabarglist RP */
   -8,  /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
    0,  /* (286) vtabarg ::= */
   -1,  /* (287) vtabargtoken ::= ANY */
   -3,  /* (288) vtabargtoken ::= lp anylist RP */
   -1,  /* (289) lp ::= LP */
   -2,  /* (290) with ::= WITH wqlist */
   -3,  /* (291) with ::= WITH RECURSIVE wqlist */
   -6,  /* (292) wqlist ::= nm eidlist_opt AS LP select RP */
   -8,  /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
   -1,  /* (294) windowdefn_list ::= windowdefn */
   -3,  /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   -5,  /* (296) windowdefn ::= nm AS LP window RP */
   -5,  /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   -6,  /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   -4,  /* (299) window ::= ORDER BY sortlist frame_opt */
   -5,  /* (300) window ::= nm ORDER BY sortlist frame_opt */
   -1,  /* (301) window ::= frame_opt */
   -2,  /* (302) window ::= nm frame_opt */
    0,  /* (303) frame_opt ::= */
   -3,  /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   -6,  /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   -1,  /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */
   -1,  /* (307) frame_bound_s ::= frame_bound */
   -2,  /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */
   -1,  /* (309) frame_bound_e ::= frame_bound */
   -2,  /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */
   -2,  /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */
   -2,  /* (312) frame_bound ::= CURRENT ROW */
    0,  /* (313) frame_exclude_opt ::= */
   -2,  /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */
   -2,  /* (315) frame_exclude ::= NO OTHERS */
   -2,  /* (316) frame_exclude ::= CURRENT ROW */
   -1,  /* (317) frame_exclude ::= GROUP|TIES */
   -2,  /* (318) window_clause ::= WINDOW windowdefn_list */
   -2,  /* (319) filter_over ::= filter_clause over_clause */
   -1,  /* (320) filter_over ::= over_clause */
   -1,  /* (321) filter_over ::= filter_clause */
   -4,  /* (322) over_clause ::= OVER LP window RP */
   -2,  /* (323) over_clause ::= OVER nm */
   -5,  /* (324) filter_clause ::= FILTER LP WHERE expr RP */
   -1,  /* (325) input ::= cmdlist */
   -2,  /* (326) cmdlist ::= cmdlist ecmd */
   -1,  /* (327) cmdlist ::= ecmd */
   -1,  /* (328) ecmd ::= SEMI */
   -2,  /* (329) ecmd ::= cmdx SEMI */
   -3,  /* (330) ecmd ::= explain cmdx SEMI */
    0,  /* (331) trans_opt ::= */
   -1,  /* (332) trans_opt ::= TRANSACTION */
   -2,  /* (333) trans_opt ::= TRANSACTION nm */
   -1,  /* (334) savepoint_opt ::= SAVEPOINT */
    0,  /* (335) savepoint_opt ::= */
   -2,  /* (336) cmd ::= create_table create_table_args */
   -4,  /* (337) columnlist ::= columnlist COMMA columnname carglist */
   -2,  /* (338) columnlist ::= columnname carglist */
   -1,  /* (339) nm ::= ID|INDEXED */
   -1,  /* (340) nm ::= STRING */
   -1,  /* (341) nm ::= JOIN_KW */
   -1,  /* (342) typetoken ::= typename */
   -1,  /* (343) typename ::= ID|STRING */
   -1,  /* (344) signed ::= plus_num */
   -1,  /* (345) signed ::= minus_num */
   -2,  /* (346) carglist ::= carglist ccons */
    0,  /* (347) carglist ::= */
   -2,  /* (348) ccons ::= NULL onconf */
   -4,  /* (349) ccons ::= GENERATED ALWAYS AS generated */
   -2,  /* (350) ccons ::= AS generated */
   -2,  /* (351) conslist_opt ::= COMMA conslist */
   -3,  /* (352) conslist ::= conslist tconscomma tcons */
   -1,  /* (353) conslist ::= tcons */
    0,  /* (354) tconscomma ::= */
   -1,  /* (355) defer_subclause_opt ::= defer_subclause */
   -1,  /* (356) resolvetype ::= raisetype */
   -1,  /* (357) selectnowith ::= oneselect */
   -1,  /* (358) oneselect ::= values */
   -2,  /* (359) sclp ::= selcollist COMMA */
   -1,  /* (360) as ::= ID|STRING */
   -1,  /* (361) expr ::= term */
   -1,  /* (362) likeop ::= LIKE_KW|MATCH */
   -1,  /* (363) exprlist ::= nexprlist */
   -1,  /* (364) nmnum ::= plus_num */
   -1,  /* (365) nmnum ::= nm */
   -1,  /* (366) nmnum ::= ON */
   -1,  /* (367) nmnum ::= DELETE */
   -1,  /* (368) nmnum ::= DEFAULT */
   -1,  /* (369) plus_num ::= INTEGER|FLOAT */
    0,  /* (370) foreach_clause ::= */
   -3,  /* (371) foreach_clause ::= FOR EACH ROW */
   -1,  /* (372) trnm ::= nm */
    0,  /* (373) tridxby ::= */
   -1,  /* (374) database_kw_opt ::= DATABASE */
    0,  /* (375) database_kw_opt ::= */
    0,  /* (376) kwcolumn_opt ::= */
   -1,  /* (377) kwcolumn_opt ::= COLUMNKW */
   -1,  /* (378) vtabarglist ::= vtabarg */
   -3,  /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */

Referenced by yy_reduce().

◆ zKWText

const char zKWText[647]

static

Definition at line 159430 of file sqlite3.c.

                                 {
  'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
  'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
  'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',
  'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F',
  'E','R','R','A','B','L','E','L','S','E','X','C','L','U','D','E','L','E',
  'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V',
  'E','P','O','I','N','T','E','R','S','E','C','T','I','E','S','N','O','T',
  'N','U','L','L','I','K','E','X','C','E','P','T','R','A','N','S','A','C',
  'T','I','O','N','A','T','U','R','A','L','T','E','R','A','I','S','E','X',
  'C','L','U','S','I','V','E','X','I','S','T','S','C','O','N','S','T','R',
  'A','I','N','T','O','F','F','S','E','T','R','I','G','G','E','R','A','N',
  'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N',
  'G','L','O','B','E','G','I','N','N','E','R','E','F','E','R','E','N','C',
  'E','S','U','N','I','Q','U','E','R','Y','W','I','T','H','O','U','T','E',
  'R','E','L','E','A','S','E','A','T','T','A','C','H','B','E','T','W','E',
  'E','N','O','T','H','I','N','G','R','O','U','P','S','C','A','S','C','A',
  'D','E','F','A','U','L','T','C','A','S','E','C','O','L','L','A','T','E',
  'C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A','T','E',
  'I','M','M','E','D','I','A','T','E','J','O','I','N','S','E','R','T','M',
  'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M',
  'A','B','O','R','T','U','P','D','A','T','E','V','A','L','U','E','S','V',
  'I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H','E','R',
  'E','C','U','R','S','I','V','E','A','F','T','E','R','E','N','A','M','E',
  'A','N','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','A',
  'U','T','O','I','N','C','R','E','M','E','N','T','C','A','S','T','C','O',
  'L','U','M','N','C','O','M','M','I','T','C','O','N','F','L','I','C','T',
  'C','R','O','S','S','C','U','R','R','E','N','T','_','T','I','M','E','S',
  'T','A','M','P','A','R','T','I','T','I','O','N','D','R','O','P','R','E',
  'C','E','D','I','N','G','F','A','I','L','A','S','T','F','I','L','T','E',
  'R','E','P','L','A','C','E','F','I','R','S','T','F','O','L','L','O','W',
  'I','N','G','F','R','O','M','F','U','L','L','I','M','I','T','I','F','O',

Referenced by keywordCode().

◆ zMagicHeader

const char zMagicHeader[] = SQLITE_FILE_HEADER

static

Definition at line 64499 of file sqlite3.c.

Referenced by lockBtree(), and newDatabase().

◆ zName

char* zName

Definition at line 22329 of file sqlite3.c.

Referenced by actionName(), attachFunc(), callCollNeeded(), createModule(), databaseName(), deleteTable(), detachFunc(), findCollSeqEntry(), generateColumnNames(), openStatTable(), parseModifier(), renameColumnElistNames(), renameColumnIdlistNames(), searchWith(), selectExpander(), sqlite3_bind_parameter_index(), sqlite3_database_file_object(), sqlite3_overload_function(), sqlite3BeginTrigger(), sqlite3CheckCollSeq(), sqlite3CheckObjectName(), sqlite3ColumnsFromExprList(), sqlite3CreateIndex(), sqlite3DropTrigger(), sqlite3EndTable(), sqlite3FindCollSeq(), sqlite3FindDb(), sqlite3FindDbName(), sqlite3FindFunction(), sqlite3FindIndex(), sqlite3FindTable(), sqlite3GenerateConstraintChecks(), sqlite3GetCollSeq(), sqlite3InvalidFunction(), sqlite3IsShadowTableOf(), sqlite3JournalOpen(), sqlite3LocateCollSeq(), sqlite3LocateTable(), sqlite3NameFromToken(), sqlite3Pragma(), sqlite3PragmaVtabRegister(), sqlite3ShadowTableName(), sqlite3StartTable(), sqlite3TableLock(), sqlite3TriggerStepSrc(), sqlite3VdbeExec(), sqlite3VdbeSetColName(), sqlite3VListAdd(), sqlite3VtabCreateModule(), sqlite3WithAdd(), sqliteProcessJoin(), unixGetSystemCall(), unixNextSystemCall(), unixOpen(), and unixSetSystemCall().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ __has_extension

◆ _FILE_OFFSET_BITS

◆ _FTS5_H

◆ _FTSINT_H

◆ _LARGE_FILE

◆ _LARGEFILE_SOURCE

◆ _OS_COMMON_H_

◆ _SQLITE3RTREE_H_

◆ _SQLITE_OS_H_

◆ _XOPEN_SOURCE

◆ ADDR

◆ ALLBITS

◆ ALT_SCHEMA_TABLE

◆ ALT_TEMP_SCHEMA_TABLE

◆ ALWAYS

◆ analyzeVdbeCommentIndexWithColumnName

◆ ApplyCostMultiplier

◆ ArraySize

◆ assertCellInfo

◆ assertParentIndex

◆ assertTruncateConstraint

◆ AtomicLoad

◆ AtomicStore

◆ bBatch

◆ BITVEC_HASH

◆ BITVEC_MXHASH

◆ BITVEC_NBIT

◆ BITVEC_NELEM

◆ BITVEC_NINT

◆ BITVEC_NPTR

◆ BITVEC_SZ

◆ BITVEC_SZELEM

◆ BITVEC_TELEM

◆ BITVEC_USIZE

◆ BMS

◆ BTALLOC_ANY

◆ BTALLOC_EXACT

◆ BTALLOC_LE

◆ BTCF_AtLast

◆ BTCF_Incrblob

◆ BTCF_Multiple

◆ BTCF_Pinned

◆ BTCF_ValidNKey

◆ BTCF_ValidOvfl

◆ BTCF_WriteFlag

◆ BTCURSOR_FIRST_UNINIT

◆ BTCURSOR_MAX_DEPTH

◆ BTREE_APPEND

◆ BTREE_APPLICATION_ID

◆ BTREE_AUTOVACUUM_FULL

◆ BTREE_AUTOVACUUM_INCR

◆ BTREE_AUTOVACUUM_NONE

◆ BTREE_AUXDELETE

◆ BTREE_BLOBKEY

◆ BTREE_BULKLOAD

◆ BTREE_DATA_VERSION

◆ BTREE_DEFAULT_CACHE_SIZE

◆ BTREE_FILE_FORMAT

◆ BTREE_FORDELETE

◆ BTREE_FREE_PAGE_COUNT

◆ BTREE_HINT_RANGE

◆ BTREE_INCR_VACUUM

◆ BTREE_INTKEY

◆ BTREE_LARGEST_ROOT_PAGE

◆ BTREE_MEMORY

◆ BTREE_OMIT_JOURNAL

◆ BTREE_SAVEPOSITION

◆ BTREE_SCHEMA_VERSION

◆ BTREE_SEEK_EQ

◆ BTREE_SINGLE

◆ BTREE_TEXT_ENCODING

◆ BTREE_UNORDERED

◆ BTREE_USER_VERSION

◆ BTREE_WRCSR