Lines Matching refs:access
485 ** direct access to string constants within the DLL. ^The
1346 ** shortly after it is opened in order to provide a custom VFS with access
1636 ** structure that SQLite will ever modify. SQLite will only access
1710 ** for exclusive access.
1769 ** from one release to the next. Applications must not attempt to access
2112 ** The application is responsible for serializing access to
2128 ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
3036 ** an attempt is made to access a database table associated with
3051 ** access the database and [SQLITE_BUSY] is returned
3054 ** is made to access the database and the cycle repeats.
3179 ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
3356 ** applications to access the same PRNG for other purposes.
3398 ** access is denied.
3414 ** return can be used to deny an untrusted user access to individual
3426 ** do not try to access data they are not allowed to see, or that they do not
3480 #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */
3498 ** the access attempt or NULL if this access attempt is directly from
3865 ** be used to access the database file on disk. ^If this option is set to
3875 ** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
3878 ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
3942 ** Open file "data.db" in the current directory for read-only access.
4050 ** it has access to all the same query parameters as were found on the
4085 ** undefined and is likely a memory access violation.
5137 ** caller. The values may be accessed using the [column access functions].
5242 ** KEYWORDS: {column access functions}
5591 ** function can gain access to this pointer using [sqlite3_user_data()].)^
5833 ** ^These routines work just like the corresponding [column access functions]
7264 ** access to extension loading capabilities.
7298 ** access to extension loading capabilities.
7813 ** and write access. ^If the flags parameter is zero, the BLOB is opened for
7814 ** read-only access.
7832 ** constraint and the blob is being opened for read/write access)^,
7835 ** being opened for read/write access)^.
7919 ** ^If the blob handle being closed was opened for read-write access, and if
8322 ** serializes access to the [database connection] given in the argument
8439 ** These routines provide access to the set of SQL language keywords
10169 ** ^(Use these routines to access all values on the right-hand side
12838 ** function may be used to access the properties of each matched row.
13275 ** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory.
13911 ** code should not attempt to access or modify the fields of this structure
15051 ** random so two separate readers can probably access the file at the
15571 ** the header value access routines since its access pattern is the same.
15797 ** use mutexes to access the BtShared structures. So make the
15857 ** simple program to access and modify the underlying database.
16809 ** to access Schema content. This implies that the thread must also be
17104 void *pAuthArg; /* 1st argument to the access auth function */
17695 ** instance of the sqlite3_vtab* handle used to access the virtual table
17701 ** then be used by the virtual table implementation to access real tables
17709 ** When an sqlite3_prepare() operation is required to access the virtual
17736 u8 eVtabRisk; /* Riskiness of allowing hacker access */
18322 ** access them will result in a segfault or malfunction.
18334 ** access them will result in a segfault or malfunction.
18617 int iCursor; /* The VDBE cursor number used to access this table */
25844 ** Mutex to control access to the memory allocation subsystem.
26404 ** Mutex to control access to the memory allocation subsystem.
27081 ** Mutex to control access to the memory allocation subsystem.
27168 ** Obtain or release the mutex needed to access global data structures.
27729 "illegal multi-threaded access to database connection"
29087 sqlite3_mutex *mutex; /* Mutex to serialize access */
36044 if( access(zXKey, R_OK)!=0
36655 ** Test for access permissions. Return true if the requested permission
37210 { "access", (sqlite3_syscall_ptr)access, 0 },
37866 ** This means that we cannot use POSIX locks to synchronize file access
37868 ** to synchronize access for threads in separate processes, but not
38424 ** in order to coordinate access between separate database connections
38997 ** prevent simultaneous access of the same database by two or more
39032 ** files (really a directory) to control access to the database. This works
39321 ** access the file.
39498 ** access the file.
40578 ** size, access time, etc) are synced. If dataOnly!=0 then only the
40585 ** SQLite to access the file will not know that the journal exists (because
40675 ** use read() and write() to access data beyond this point from now on.
41171 sqlite3_mutex *pShmMutex; /* Mutex to access this object */
41456 ** from the database file is used, then differing access permissions
43129 /* Failed to open the file for read/write access. Try read-only. */
43304 ** Test the existence of or access permissions of file zPath. The
43743 ** database file to coordinate safe, concurrent access by multiple readers
43764 ** address the requirements for concurrent database access by multiple
43769 ** changes the way database access is controlled by limiting access to a
43811 ** * conch file to limit access to the database file to a single host
44661 ** (c) the file system is read-only, then enable no-locking access.
45351 HANDLE hMutex; /* Mutex used to control access to shared lock */
45406 * be freed immediately and any attempt to access any of that freed
45407 * data will almost certainly result in an immediate access violation.
46378 ** be able to even access the heap. Attempt to destroy and recreate our
48538 ** prevent simultaneous access of the same database by two or more
48800 sqlite3_mutex *mutex; /* Mutex to access this object */
50214 ** created. SQLite doesn't use it to indicate "exclusive access"
50319 OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name,
50345 OSTRACE(("OPEN file=%p, name=%s, access=%lx, pOutFlags=%p, *pOutFlags=%d, "
51301 ** access to randomness, etc.
51309 ** memdb objects to coordinate access. Separate memdb objects are only
51366 ** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
51905 ** Test for access permissions. Return true if the requested permission
53777 ** All code in this file should access the global structure above via the
54754 ** sqlite3_status() routine needs access to this mutex.
55336 ** The pager is used to access a database disk file. It implements
56285 ** interfaces to access the database using memory-mapped I/O.
57316 ** If the pager is not in exclusive-access mode, the database file is
60467 /* If the file was successfully opened for read/write access,
60782 ** exclusive access mode. */
60823 ** other process attempting to access the database file will get to
60836 ** journal for read/write access. Write access is required because
60837 ** in exclusive-access mode the file descriptor will be kept open
60838 ** and possibly used for a transaction later on. Also, write-access
60916 ** occurring on the very first access to a file, in order to save a
64129 ** If there is the possibility of concurrent access to the SHM file
66058 ** access any database page that is modified by a WAL frame up to and
66544 ** if we had exclusive access to the hash-table:
68016 sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */
68526 ** access are:
68663 ** but the test harness needs to access it so we make it global for
71488 /* The pBt is no longer on the sharing list, so we can access
72097 ** to access the database. A preexisting transaction may not be
73831 ** pages. When that is so, this routine can be used to access the
73876 ** These routines is used to get quick access to key and data
74871 ** which in turn can make database access faster.
75807 ** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
78650 ** database file. It is a number computed by the pager. But its access
79459 ** open so it is safe to access without the BtShared mutex.
79472 ** open so it is safe to access without the BtShared mutex.
88912 ** Undocumented behavior: If iArg is negative then access a cache of
88942 ** access code.
89116 ** The following routines are used to access elements of the current row
91917 ** structure to provide access to the r(P1)..r(P1+P2-1) values as
92198 ** publicly. Only built-in functions have access to this feature.
97603 ** address space. This is used by trigger programs to access the new.*
99298 ** sqlite3_blob_read() or sqlite3_blob_write() access the specified row.
99385 int wrFlag, /* True -> read/write access, false -> read-only */
99725 ** so no mutex is required for access.
100165 ** own. Instead, it has exclusive access to mxSz bytes of space beginning
103182 ** access writes are not required. The only exception to this is when
106911 ** Check to see if a function is usable according to current access
108389 ** that can be simplified to a direct table access, then return
117212 ** Set or clear the access authorization function.
117214 ** The access authorization function is be called during the compilation
117215 ** phase to verify that the user has read and/or write access permission on
117247 ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
117309 sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);
117793 ** list of users and their access credentials.
117816 /* All mutexes are required for schema access. Make sure we hold them. */
118000 /* All mutexes are required for schema access. Make sure we hold them. */
119503 ** cookie. Thereafter, whenever it goes to access the database,
122916 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
123168 ** This file contains functions used to access the internal hash tables
132309 ** it can get access to the sqlite3_api_routines structure
135301 ** the value sets a specific file to be used for database access locks.
137543 ** The primary purpose of this is to allow access to the sqlite_schema
144063 sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
147779 ** Triggers may access values stored in the old.* or new.* pseudo-table.
150125 ** Return a pointer to the VTable object used by connection db to access
150176 ** this makes it safe to access the sqlite3.pDisconnect list of any
151381 int iTabCur; /* The VDBE cursor used to access the table */
151382 int iIdxCur; /* The VDBE cursor used to access pIdx */
152843 Index *pIdx; /* The index used to access the table */
152909 ** Also, if the node is a TK_COLUMN that does access the table idenified
152912 ** an access of the index rather than the original table.
153338 ** to access the data.
153401 VdbeOp *pOp; /* Opcode to access the value of the IN constraint */
153958 /* pIdx is a covering index. No need to access the main table. */
157311 const SrcItem *pSrc /* Table we are trying to access */
157336 ** could be used with an index to access pSrc, assuming an appropriate
157341 const SrcItem *pSrc, /* Table we are trying to access */
159864 /* We don't have access to the full query, so we cannot check to see
160161 ** because the cursor used to access the index might not be
166278 ** has access to the the size of the yyParser object and so the parser
169788 ** access to the lookahead token (if any). The yyLookahead will be YYNOCODE
173690 ** The following mutex is what serializes access to the appdef pcache xInit
175022 /* SQLITE_PERM */ "access permission denied",
176512 zModeType = "access";
176928 ** option gives access to internal functions by default.
177906 ** Test access for the LogEst conversion routines.
178852 ** making it efficient to directly access large doclists. The
179232 ** code should not attempt to access or modify the fields of this structure
182947 char *zSql; /* SQL statement used to access %_content */
189127 ** Set up SQL objects in database db used to access the contents of
189138 ** provide read/write access to the contents of *pHash.
205211 sqlite3 *db, /* Database handle to access db through */
205367 ** access to all of the R-Tree internals.
205474 /* Macros to access coordinates of a GeoPoly.
207699 ** To access ICU "language specific" case mapping, upper() or lower()
208292 ** random order, access to pages within the database is also likely to be in
208565 ** By default, RBU uses the default VFS to access the files on disk. To
208646 ** connection to access the target and rbu update databases. This
208647 ** API allows the application direct access to these database handles.
208650 ** handle. The second argument should be passed zero to access the target
208651 ** database handle, or non-zero to access the rbu update database handle.
208841 ** then the new RBU VFS uses the default system VFS to access the file-system.
208852 ** (for example multiplexor) to access the file-system. For example,
208861 ** // access the file-system via the system default VFS, bypassing the
210839 ** used to access that PK index. For example, if the target table is
213937 ** Test for access permissions. Return true if the requested permission
214208 /* #include "sqliteInt.h" ** Requires access to internal data structures ** */
215121 /* #include "sqliteInt.h" ** Requires access to internal data structures ** */
221499 ** function may be used to access the properties of each matched row.
222287 ** to access the data stored in the %_data table.
222568 ** code to access the data stored in the %_content and %_docsize tables.
223770 ** access to the lookahead token (if any). The fts5yyLookahead will be fts5YYNOCODE
229211 ** This function is used to access the current position list for phrase
230018 ** Low level access to the FTS index stored in the database file. The
230019 ** routines in this file file implement all read and write access to the
230020 ** %_data table. Other parts of the system access this functionality via
243477 ** This is an SQLite virtual table module implementing direct access to an