Lines Matching refs:path
3848 ** ^SQLite uses the path component of the URI as the name of the disk file
3849 ** which contains the database. ^If the path begins with a '/' character,
3850 ** then it is interpreted as an absolute path. ^If the path does not begin
3852 ** then the path is interpreted as a relative path.
3853 ** ^(On windows, the first component of an absolute path
3953 ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
3956 ** specifying an octet value. ^Before the path or query components of a
16879 ** in a performance-critical path. sz should be set by to szTrue whenever
36947 ** Maximum supported path-length.
37720 ** a performance-critical path, so it is sufficient to put these
38036 ** failed (e.g. "unlink", "open") and the associated file-system path,
38043 const char *zPath, /* File path associated with error */
38538 ** unixFile, do nothing. Don't use the end_lock: exit path, as
39634 const char *path, /* Name of the file to be locked or unlocked */
39635 unixFile *pFile, /* Open file descriptor on path */
39652 err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
39657 path, tErrno, strerror(tErrno)));
39760 ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
42621 /* AFP locking uses the file path so it needs to be included in
42648 /* Dotfile locking uses the file path so it needs to be included in
42666 /* Named semaphore locking uses the file path so it needs to be
42828 ** almost certain that an open() call on the same path will also fail.
42831 ** descriptor on the same path, fail, and return an error to SQLite.
42915 char zDb[MAX_PATHNAME+1]; /* Database file path */
42918 /* zPath is a path to a WAL or journal file. The following block derives
42919 ** the path to the associated database file from zPath. This block handles
42922 ** "<path to db>-journal"
42923 ** "<path to db>-wal"
42924 ** "<path to db>-journalNN"
42925 ** "<path to db>-walNN"
43361 const char *zPath, /* Input path */
43421 ** Turn a relative pathname into a full pathname. The relative path
43426 ** (in this case, MAX_PATHNAME bytes). The full-path is written to
43431 const char *zPath, /* Possibly relative input path */
43441 const char *zIn = zPath; /* Input path for each iteration of loop */
43456 /* Call stat() on path zIn. Set bLink to true if the path is a symbolic
43791 ** host ID in it, the proxy path in the conch file will be used, otherwise
43792 ** a proxy path based on the user's temp dir
43794 ** actual proxy file name is generated from the name and path of the
43797 ** For database path "/Users/me/foo.db"
43798 ** The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
43801 ** be removed, however it may be switched to a different proxy path via
43820 ** proxy path against the values stored in the conch. The conch file is
43824 ** host ID and/or proxy path, then the lock is escalated to an exclusive
43826 ** path and the lock is downgraded to a shared lock again. If the conch
43885 ** The proxyLockingContext has the path and file structures for the remote
43902 ** The proxy lock file path for the database at dbPath is written into lPath,
43904 ** file path.
43935 /* transform the db path to a unique cache name */
43943 OSTRACE(("GETLOCKPATH proxy lock path=%s pid=%d\n", lPath, osGetpid(0)));
43969 "'%s' proxy lock path=%s pid=%d\n",
43979 OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n",lockPath,osGetpid(0)));
43985 ** sqlite3_malloc) and open the file named "path" in the file descriptor.
43991 const char *path, /* path for the new unixFile */
44009 pUnused = findReusableFd(path, openFlags);
44019 fd = robust_open(path, openFlags, 0);
44022 if( proxyCreateLockPath(path) == SQLITE_OK ){
44023 fd = robust_open(path, openFlags, 0);
44029 fd = robust_open(path, openFlags, 0);
44061 rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
44115 /* The conch file contains the header, host id and lock file path
44117 #define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */
44123 ** Takes an open conch file, copies the contents to a new path and then moves
44141 /* create a new path by replace the trailing '-conch' with '-break' */
44145 sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
44267 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
44269 ** host IDs match, or a new lock path will be generated automatically
44321 /* if the host id matches and the lock path already exists in the conch
44322 ** we'll try to use the path there, if we can't open that path, we'll
44323 ** retry with a new auto-generated path
44333 ** use the local lock file path that's already in there
44345 /* create a copy of the lock path if the conch is taken */
44352 /* conch host and lock path match */
44367 /* create a copy of the lock path _only_ if the conch is taken */
44370 /* update conch with host and path (this will fail if other process
44453 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
44454 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
44456 /* we couldn't create the proxy lock file with the old lock file path
44465 /* Need to make a copy of path if we extracted the value
44466 ** from the conch file or the path was allocated on the stack
44562 ** the local lock file path
44564 static int switchLockProxyPath(unixFile *pFile, const char *path) {
44573 /* nothing to do if the path is NULL, :auto: or matches the existing path */
44574 if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
44575 (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
44587 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
44603 /* afp style keeps a reference to the db path in the filePath field
44612 ** file path */
44616 /* all other styles use the locking context to store the db file path */
44631 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
44641 if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
44644 lockPath=(char *)path;
47155 ** failed and the associated file-system path, if any.
47162 const char *zPath, /* File path associated with error */
48001 ** but involves adding a few branches in the common write code path which
48329 ** OsFile, do nothing. Don't use the end_lock: exit path, as
49891 /* If the path starts with a drive letter followed by the colon
49892 ** character, assume it is already a native Win32 path; otherwise,
49893 ** it must be converted to a native Win32 path via the Cygwin API
50087 sqlite3_vfs *pVfs, /* Used to get maximum path length and AppData */
50592 ** Returns non-zero if the specified path name starts with the "long path"
50603 ** Returns non-zero if the specified path name starts with a drive letter
50613 ** Returns non-zero if the specified path name should be used verbatim. If
50615 ** use the provided path name verbatim -OR- resolve it into a full path name
50622 ** If the path name starts with a forward slash or a backslash, it is either
50623 ** a legal UNC name, a volume relative path, or an absolute path name in the
50633 ** If the path name starts with a letter and a colon it is either a volume
50634 ** relative path or an absolute path. Callers of this function must not
50635 ** attempt to treat it as a relative path name (i.e. they should simply use
50643 ** If we get to this point, the path name should almost certainly be a purely
50656 const char *zRelative, /* Possibly relative input path */
50666 /* If this path name begins with "/X:" or "\\?\", where "X" is any
50680 ** NOTE: We are dealing with a relative path name and the data
50682 ** for converting the relative path name to an absolute
50734 /* WinRT has no way to convert a relative path to an absolute one. */
50737 ** NOTE: We are dealing with a relative path name and the data
50739 ** for converting the relative path name to an absolute
50759 ** NOTE: We are dealing with a relative path name and the data
50761 ** for converting the relative path name to an absolute
50835 const char *zRelative, /* Possibly relative input path */
60216 ** The zFilename argument is the path to the database file to open.
60264 char *zPathname = 0; /* Full path to database file */
60324 /* This branch is taken when the journal path required by
78106 ** The bPreserve value records which path is required:
124350 } /* End non-truncate path */
135262 ** a relative path will probably be based on the current directory for the
135263 ** process. Database file specified with an absolute path are not impacted
151503 ** Then a WherePath object is a path through the graph that visits some
151513 Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */
151515 LogEst nRow; /* Estimated number of rows generated by this path */
151516 LogEst rCost; /* Total cost of this path */
151517 LogEst rUnsorted; /* Total cost of this path ignoring sorting costs */
151519 WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */
161319 ** attempts to find the lowest cost path that visits each WhereLoop
161320 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
161338 LogEst mxUnsorted = 0; /* Maximum unsorted cost of a set of path */
161352 /* TUNING: For simple queries, only the best path is tracked.
161421 LogEst rCost; /* Cost of path (pFrom+pWLoop) */
161484 ** First look for an existing path among best-so-far paths
161486 ** setting as the current path candidate.
161517 /* If we reach this points it means that the new candidate path
161523 /* New path replaces the prior worst to keep count below mxChoice */
161535 /* Control reaches here if best-so-far path pTo=aTo[jj] covers the
161537 ** candidate path. Check to see if the candidate should replace
161561 /* Discard the candidate path from further consideration */
161566 /* Control reaches here if the candidate path is better than the
161567 ** pTo path. Replace pTo with the candidate. */
161635 /* Find the lowest cost path. pFrom will be left pointing to that path */
161641 /* Load the lowest cost path into pWInfo */
176380 ** like file://///host/path to be converted into UNCs like //host/path.
176382 ** file://host/path or file:////host/path. But 5 leading slashes is a
176426 ** case we ignore all text in the remainder of the path, name or
199344 const char *zPath, /* The path to search */
199345 int *pApnd, /* Append nodes to complete path if not NULL */
199517 ** Return the text of a syntax error message on a JSON path. Space is
199521 return sqlite3_mprintf("JSON path error near '%q'", zErr);
199536 const char *zPath, /* The path to search */
199537 int *pApnd, /* Append nodes to complete path if not NULL */
199756 #define JSON_ABPATH 0x03 /* Allow abbreviated JSON path specs */
199776 ** Abbreviated JSON path expressions are allows if JSON_ABPATH, for
200411 "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
200549 /* Append the name of the path for element i to pStr
200553 JsonString *pStr, /* Write the path here */
200658 /* For json_each() path and root are the same so fall through
208544 ** Argument zTarget is the path to the target database. Argument zRbu is
208545 ** the path to the RBU database. Each call to this function must be matched
208556 ** Or, if zState is non-NULL, it must be a path to a database file in which
208784 ** will move the *-oal file to the equivalent *-wal path. If the current
208813 ** path. Normally, it does this by invoking POSIX function rename(2) directly.
208821 ** argument (pArg) passed to this function. The second is the full path
208822 ** to the file to move and the third the full path to which it should be
208938 ** to the *-wal path.
212008 ** on the database file. This proc moves the *-oal file to the *-wal path,
214224 ** The value of the 'path' column describes the path taken from the
214226 ** root-node path is '/'.
214228 ** The value of the path for the left-most child page of the root of
214237 ** six-digit hexadecimal value to the path to the cell they are linked
214255 " path TEXT," /* 1 Path to page from root (NULL for agg) */
214309 StatPage aPage[32]; /* Pages in path to current page */
214315 char *zPath; /* Value of 'path' column */
214396 ** 0x08 Output should be ordered by name and path
214446 /* Records are always returned in ascending order of (name, path).
214993 case 1: /* path */