Lines Matching refs:zPath
7064 ** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
7068 ** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
23116 const char *zPath,
23127 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut);
23131 SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
23134 return pVfs->xDelete(pVfs, zPath, dirSync);
23138 const char *zPath,
23143 return pVfs->xAccess(pVfs, zPath, flags, pResOut);
23147 const char *zPath,
23153 return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
23156 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
23157 return pVfs->xDlOpen(pVfs, zPath);
33481 const char *zPath; /* Name of the file */
34675 const char *zPath, /* File path associated with error */
34715 if( zPath==0 ) zPath = "";
34718 iLine, iErrno, zFunc, zPath, zErr
34740 pFile ? pFile->zPath : 0, lineno);
34909 (osStat(pFile->zPath, &buf)!=0
34933 sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
34937 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
34941 sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
34945 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
35557 osUnlink(pFile->zPath);
35558 sqlite3_free(*(char**)&pFile->zPath);
35559 pFile->zPath = 0;
37187 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
37196 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
37198 rc = osOpenDirectory(pFile->zPath, &dirfd);
37232 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
37353 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
37995 const char *zBasePath = pDbFd->zPath;
38025 sqlite3FileSuffix3(pDbFd->zPath, zShm);
38039 if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
38553 unixLogError(SQLITE_OK, zErr, pFd->zPath);
38997 pNew->zPath = zFilename;
39225 ** zPath with SQLITE_OPEN_XXX flags matching those passed as the second
39238 static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
39259 if( inodeList!=0 && 0==osStat(zPath, &sStat) ){
39328 const char *zPath, /* Path of file (possibly) being created */
39342 /* zPath is a path to a WAL or journal file. The following block derives
39343 ** the path to the associated database file from zPath. This block handles
39354 nDb = sqlite3Strlen30(zPath) - 1;
39355 while( zPath[nDb]!='-' ){
39360 if( nDb==0 || zPath[nDb]=='.' ) return SQLITE_OK;
39363 memcpy(zDb, zPath, nDb);
39374 const char *z = sqlite3_uri_parameter(zPath, "modeof");
39383 ** Open the file zPath.
39406 const char *zPath, /* Pathname of file to be opened */
39441 /* If argument zPath is a NULL pointer, this function is required to open
39445 const char *zName = zPath;
39589 zPath = zName;
39591 zPath = sqlite3_mprintf("%s", zName);
39592 if( zPath==0 ){
39632 if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
39644 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
39661 assert( zPath==0 || zPath[0]=='/'
39664 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
39675 ** Delete the file at zPath. If the dirSync argument is true, fsync()
39680 const char *zPath, /* Name of file to be deleted */
39686 if( osUnlink(zPath)==(-1) ){
39689 || osAccess(zPath,0)!=0
39694 rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
39701 rc = osOpenDirectory(zPath, &fd);
39704 rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
39717 ** Test the existence of or access permissions of file zPath. The
39728 const char *zPath, /* Path of the file to examine */
39729 int flags, /* What do we want to learn about the zPath file? */
39742 *pResOut = 0==osStat(zPath, &buf) &&
39745 *pResOut = osAccess(zPath, W_OK|R_OK)==0;
39754 const char *zPath, /* Input path */
39758 int nPath = sqlite3Strlen30(zPath);
39760 if( zPath[0]!='/' ){
39762 return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
39773 sqlite3_snprintf(nOut-iOff, &zOut[iOff], "%s", zPath);
39780 ** zPath.
39788 const char *zPath, /* Possibly relative input path */
39793 return mkFullPathname(zPath, zOut, nOut);
39798 const char *zIn = zPath; /* Input path for each iteration of loop */
41859 const char *zPath; /* Full pathname of this file */
43667 const char *zPath, /* File path associated with error */
43676 if( zPath==0 ) zPath = "";
43681 iLine, lastErrno, zFunc, zPath, zMsg
44194 "winSeekFile", pFile->zPath);
44215 "winSeekFile", pFile->zPath);
44290 "winClose", pFile->zPath);
44358 "winRead", pFile->zPath);
44470 "winWrite1", pFile->zPath);
44475 "winWrite2", pFile->zPath);
44541 "winTruncate1", pFile->zPath);
44546 "winTruncate2", pFile->zPath);
44638 "winSync1", pFile->zPath);
44653 "winSync2", pFile->zPath);
44679 "winFileSize", pFile->zPath);
44694 "winFileSize", pFile->zPath);
44789 "winUnlockReadLock", pFile->zPath);
45015 "winUnlock", pFile->zPath);
45513 nName = sqlite3Strlen30(pDbFd->zPath);
45520 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
45521 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
45553 if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
45830 "winShmMap1", pDbFd->zPath);
45845 "winShmMap2", pDbFd->zPath);
45904 "winShmMap3", pDbFd->zPath);
45953 "winUnmapfile1", pFile->zPath);
45964 "winUnmapfile2", pFile->zPath);
46041 "winMapfile1", pFd->zPath);
46059 "winMapfile2", pFd->zPath);
46593 /* If argument zPath is a NULL pointer, this function is required to open
46866 pFile->zPath = zName;
48088 ** Delete the file located at zPath. If the dirSync argument is true,
48092 static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
48105 const char *zPath,
48115 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
48120 const char *zPath,
48124 sqlite3_snprintf(nOut, zOut, "%s", zPath);
48129 ** Open the dynamic library located at zPath and return a handle.
48131 static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){
48132 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
109235 char *zPath = 0;
109309 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
109318 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
109351 sqlite3_free_filename( zPath );
185666 ** Search along zPath to find the node specified. Return a pointer
185667 ** to that node, or NULL if zPath is malformed or if there is no such
185670 ** If pApnd!=0, then try to append new nodes to complete zPath if it is
185671 ** possible to do so and if no existing node corresponds to zPath. If
185677 const char *zPath, /* The path to search */
185679 const char **pzErr /* Make *pzErr point to any syntax error in zPath */
185684 if( zPath[0]==0 ) return pRoot;
185686 if( zPath[0]=='.' ){
185688 zPath++;
185689 if( zPath[0]=='"' ){
185690 zKey = zPath + 1;
185691 for(i=1; zPath[i] && zPath[i]!='"'; i++){}
185693 if( zPath[i] ){
185696 *pzErr = zPath;
185700 zKey = zPath;
185701 for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){}
185705 *pzErr = zPath;
185712 return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr);
185727 zPath += i;
185728 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
185738 }else if( zPath[0]=='[' ){
185741 while( safe_isdigit(zPath[j]) ){
185742 i = i*10 + zPath[j] - '0';
185745 if( j<2 || zPath[j]!=']' ){
185746 if( zPath[1]=='#' ){
185761 if( zPath[2]=='-' && safe_isdigit(zPath[3]) ){
185765 x = x*10 + zPath[j] - '0';
185767 }while( safe_isdigit(zPath[j]) );
185771 if( zPath[j]!=']' ){
185772 *pzErr = zPath;
185776 *pzErr = zPath;
185781 zPath += j + 1;
185794 return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr);
185800 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
185810 *pzErr = zPath;
185816 ** Append content to pParse that will complete zPath. Return a pointer
185821 const char *zPath, /* Description of content to append */
185826 if( zPath[0]==0 ){
185830 if( zPath[0]=='.' ){
185832 }else if( strncmp(zPath,"[0]",3)==0 ){
185838 return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr);
185850 ** Do a node lookup using zPath. Return a pointer to the node on success.
185861 const char *zPath, /* The path to search */
185869 if( zPath==0 ) return 0;
185870 if( zPath[0]!='$' ){
185871 zErr = zPath;
185874 zPath++;
185875 pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr);
186054 const char *zPath = (const char*)sqlite3_value_text(argv[1]);
186055 pNode = jsonLookup(p, zPath, 0, ctx);
186086 const char *zPath;
186096 zPath = (const char*)sqlite3_value_text(argv[i]);
186097 pNode = jsonLookup(p, zPath, 0, ctx);
186271 const char *zPath;
186278 zPath = (const char*)sqlite3_value_text(argv[i]);
186279 if( zPath==0 ) goto remove_done;
186280 pNode = jsonLookup(&x, zPath, 0, ctx);
186304 const char *zPath;
186315 zPath = (const char*)sqlite3_value_text(argv[i]);
186316 pNode = jsonLookup(&x, zPath, 0, ctx);
186351 const char *zPath;
186364 zPath = (const char*)sqlite3_value_text(argv[i]);
186366 pNode = jsonLookup(&x, zPath, &bApnd, ctx);
186399 const char *zPath;
186405 zPath = (const char*)sqlite3_value_text(argv[1]);
186406 pNode = jsonLookup(p, zPath, 0, ctx);
200012 ** Delete the file located at zPath.
200014 static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
200016 return pRealVfs->xDelete(pRealVfs, zPath, dirSync);
200025 const char *zPath,
200033 rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
200050 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath, 1);
200068 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
200073 const char *zPath,
200078 return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
200083 ** Open the dynamic library located at zPath and return a handle.
200085 static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
200087 return pRealVfs->xDlOpen(pRealVfs, zPath);
200365 char *zPath; /* Path to this page */
200390 char *zPath; /* Value of 'path' column */
200578 sqlite3_free(p->zPath);
200589 sqlite3_free(pCsr->zPath);
200590 pCsr->zPath = 0;
200796 sqlite3_free(pCsr->zPath);
200797 pCsr->zPath = 0;
200816 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
200851 pCsr->zPath = z = sqlite3_mprintf(
200852 "%s%.3x+%.6x", p->zPath, p->iCell, iOvfl
200888 p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
200925 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
201031 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);