コード例 #1
0
ファイル: sqlite3api.c プロジェクト: aaronlifton/IdrisWeb
int sqlite3_backup_pagecount_idr(void *backup){
	
	DBbackup* dbi=(DBbackup*) backup;
	int res =sqlite3_backup_pagecount(dbi-> backup);
	return res;
	
}
コード例 #2
0
ファイル: database.cpp プロジェクト: Korvox/Clementine
void Database::BackupFile(const QString& filename) {
    qLog(Debug) << "Starting database backup";
    QString dest_filename = QString("%1.bak").arg(filename);
    const int task_id =
        app_->task_manager()->StartTask(tr("Backing up database"));

    sqlite3* source_connection = nullptr;
    sqlite3* dest_connection = nullptr;

    BOOST_SCOPE_EXIT((source_connection)(dest_connection)(task_id)(app_)) {
        // Harmless to call sqlite3_close() with a nullptr pointer.
        sqlite3_close(source_connection);
        sqlite3_close(dest_connection);
        app_->task_manager()->SetTaskFinished(task_id);
    }
    BOOST_SCOPE_EXIT_END

    bool success = OpenDatabase(filename, &source_connection);
    if (!success) {
        return;
    }

    success = OpenDatabase(dest_filename, &dest_connection);
    if (!success) {
        return;
    }

    sqlite3_backup* backup =
        sqlite3_backup_init(dest_connection, "main", source_connection, "main");
    if (!backup) {
        const char* error_message = sqlite3_errmsg(dest_connection);
        qLog(Error) << "Failed to start database backup:" << error_message;
        return;
    }

    int ret = SQLITE_OK;
    do {
        ret = sqlite3_backup_step(backup, 16);
        const int page_count = sqlite3_backup_pagecount(backup);
        app_->task_manager()->SetTaskProgress(
            task_id, page_count - sqlite3_backup_remaining(backup), page_count);
    } while (ret == SQLITE_OK);

    if (ret != SQLITE_DONE) {
        qLog(Error) << "Database backup failed";
    }

    sqlite3_backup_finish(backup);
}
コード例 #3
0
Int32 CBackup::NativePagecount()
{
    Int32 result = 0;
#if HAVE_SQLITE3 && HAVE_SQLITE3_BACKUPAPI
    hbk *bk = mHandle;

    if (bk) {
    if (bk->bkup) {
        result = sqlite3_backup_pagecount(bk->bkup);
    }
    }
#else
    return E_SQL_SQLITE_THROWEX_EXCEPTION;
#endif
    return result;
}
コード例 #4
0
/**
 * @brief Perform an online backup of our database db to the database file named
 * by zFilename. Used to store our memory table in between map changes to disk
 *
 * This function copies 5 database pages from pDb to
 * zFilename, then unlocks pDb and sleeps for 250 ms, then repeats the
 * process until the entire database is backed up.
 *
 * The third argument passed to this function must be a pointer to a progress
 * function. After each set of 5 pages is backed up, the progress function
 * is invoked with two integer parameters: the number of pages left to
 * copy, and the total number of pages in the source file. This information
 * may be used, for example, to update a GUI progress bar.
 *
 * While this function is running, another thread may use the database pDb, or
 * another process may access the underlying database file via a separate
 * connection.
 *
 * If the backup process is successfully completed, SQLITE_OK is returned.
 * Otherwise, if an error occurs, an SQLite error code is returned.
 *
 * @param zFilename
 *
 * @return
 *
 */
int DB_BackupDB(const char *zFilename, void (*xProgress)(int, int)) // Progress function to invoke
{
	int            rc;        // Function return code
	sqlite3        *pFile;    // Database connection opened on zFilename
	sqlite3_backup *pBackup;  // Backup handle used to copy data

	// Open the database file identified by zFilename.
	rc = sqlite3_open(zFilename, &pFile);
	if (rc == SQLITE_OK)
	{
		// Open the sqlite3_backup object used to accomplish the transfer
		pBackup = sqlite3_backup_init(pFile, "main", db, "main");
		if (pBackup)
		{
			// Each iteration of this loop copies 5 database pages from database
			// pDb to the backup database. If the return value of backup_step()
			// indicates that there are still further pages to copy, sleep for
			// 250 ms before repeating.
			do
			{
				rc = sqlite3_backup_step(pBackup, 5);
				xProgress(sqlite3_backup_remaining(pBackup), sqlite3_backup_pagecount(pBackup));
				if (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
				{
					sqlite3_sleep(250);
				}
			}
			while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);

			// Release resources allocated by backup_init().
			(void) sqlite3_backup_finish(pBackup);
		}
		rc = sqlite3_errcode(pFile);
	}

	// Close the database connection opened on database file zFilename and return the result of this function.
	(void) sqlite3_close(pFile);
	return rc;
}
コード例 #5
0
ファイル: backup.cpp プロジェクト: ImportantProjects/sqxx
int backup::pagecount() {
	return sqlite3_backup_pagecount(handle);
}
コード例 #6
0
ファイル: backup.c プロジェクト: ocochard/pkgng
static int
copy_database(sqlite3 *src, sqlite3 *dst, const char *name)
{
	sqlite3_backup	*b;
	char		*errmsg;
	off_t		 total;
	off_t		 done;
	off_t		 page_size;
	time_t		 start;
	time_t		 elapsed;
	int		 ret;

	assert(src != NULL);
	assert(dst != NULL);

	/* Do not remove until gcc has gone from FreeBSD base */
	done = total = 0;

	ret = sqlite3_exec(dst, "PRAGMA main.locking_mode=EXCLUSIVE;"
			   "BEGIN IMMEDIATE;COMMIT;", NULL, NULL, &errmsg);
	if (ret != SQLITE_OK) {
		pkg_emit_error("sqlite error -- %s", errmsg);
		sqlite3_free(errmsg);
		return (EPKG_FATAL);
	}

	ret = sqlite3_exec(dst, "PRAGMA page_size", ps_cb, &page_size, &errmsg);
	if (ret != SQLITE_OK) {
		pkg_emit_error("sqlite error -- %s", errmsg);
		sqlite3_free(errmsg);
		return (EPKG_FATAL);
	}

	b = sqlite3_backup_init(dst, "main", src, "main");

	elapsed = -1;
	done = total = 0;
	start = time(NULL);

	do {
		ret = sqlite3_backup_step(b, NPAGES);

		if (ret != SQLITE_OK && ret != SQLITE_DONE ) {
			if (ret == SQLITE_BUSY) {
				sqlite3_sleep(250);
			} else {
				ERROR_SQLITE(dst);
				break;
			}
		}

		total = sqlite3_backup_pagecount(b) * page_size;
		done = total - sqlite3_backup_remaining(b) * page_size; 

		/* Callout no more than once a second */
		if (elapsed < time(NULL) - start) {
			elapsed = time(NULL) - start;
			pkg_emit_fetching(name, total, done, elapsed);
		}
	} while(done < total);

	ret = sqlite3_backup_finish(b);
	pkg_emit_fetching(name, total, done, time(NULL) - start); 

	sqlite3_exec(dst, "PRAGMA main.locking_mode=NORMAL;"
			   "BEGIN IMMEDIATE;COMMIT;", NULL, NULL, &errmsg);

	if (ret != SQLITE_OK) {
		pkg_emit_error("sqlite error -- %s", errmsg);
		sqlite3_free(errmsg);
		return (EPKG_FATAL);
	}

	return ret;
}
コード例 #7
0
ファイル: test_backup.c プロジェクト: 1018824313/sqlite
static int backupTestCmd(
  ClientData clientData, 
  Tcl_Interp *interp, 
  int objc,
  Tcl_Obj *const*objv
){
  enum BackupSubCommandEnum {
    BACKUP_STEP, BACKUP_FINISH, BACKUP_REMAINING, BACKUP_PAGECOUNT
  };
  struct BackupSubCommand {
    const char *zCmd;
    enum BackupSubCommandEnum eCmd;
    int nArg;
    const char *zArg;
  } aSub[] = {
    {"step",      BACKUP_STEP      , 1, "npage" },
    {"finish",    BACKUP_FINISH    , 0, ""      },
    {"remaining", BACKUP_REMAINING , 0, ""      },
    {"pagecount", BACKUP_PAGECOUNT , 0, ""      },
    {0, 0, 0, 0}
  };

  sqlite3_backup *p = (sqlite3_backup *)clientData;
  int iCmd;
  int rc;

  rc = Tcl_GetIndexFromObjStruct(
      interp, objv[1], aSub, sizeof(aSub[0]), "option", 0, &iCmd
  );
  if( rc!=TCL_OK ){
    return rc;
  }
  if( objc!=(2 + aSub[iCmd].nArg) ){
    Tcl_WrongNumArgs(interp, 2, objv, aSub[iCmd].zArg);
    return TCL_ERROR;
  }

  switch( aSub[iCmd].eCmd ){

    case BACKUP_FINISH: {
      const char *zCmdName;
      Tcl_CmdInfo cmdInfo;
      zCmdName = Tcl_GetString(objv[0]);
      Tcl_GetCommandInfo(interp, zCmdName, &cmdInfo);
      cmdInfo.deleteProc = 0;
      Tcl_SetCommandInfo(interp, zCmdName, &cmdInfo);
      Tcl_DeleteCommand(interp, zCmdName);

      rc = sqlite3_backup_finish(p);
      Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
      break;
    }

    case BACKUP_STEP: {
      int nPage;
      if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &nPage) ){
        return TCL_ERROR;
      }
      rc = sqlite3_backup_step(p, nPage);
      Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
      break;
    }

    case BACKUP_REMAINING:
      Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_backup_remaining(p)));
      break;

    case BACKUP_PAGECOUNT:
      Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_backup_pagecount(p)));
      break;
  }

  return TCL_OK;
}
コード例 #8
0
// Get the number of total source pages to be copied in this backup process
int Backup::getTotalPageCount()
{
    return sqlite3_backup_pagecount(mpSQLiteBackup);
}
コード例 #9
0
static int
copy_database(sqlite3 *src, sqlite3 *dst, const char *name)
{
    sqlite3_backup	*b;
    char		*errmsg;
    off_t		 total;
    off_t		 done;
    off_t		 page_size;
    int		 ret;

    assert(src != NULL);
    assert(dst != NULL);

    ret = sqlite3_exec(dst, "PRAGMA main.locking_mode=EXCLUSIVE;"
                       "BEGIN IMMEDIATE;COMMIT;", NULL, NULL, &errmsg);
    if (ret != SQLITE_OK) {
        pkg_emit_error("sqlite error -- %s", errmsg);
        sqlite3_free(errmsg);
        return (EPKG_FATAL);
    }

    ret = sqlite3_exec(dst, "PRAGMA page_size", ps_cb, &page_size, &errmsg);
    if (ret != SQLITE_OK) {
        pkg_emit_error("sqlite error -- %s", errmsg);
        sqlite3_free(errmsg);
        return (EPKG_FATAL);
    }

    b = sqlite3_backup_init(dst, "main", src, "main");

    done = total = 0;

    pkg_emit_progress_start(NULL);
    do {
        ret = sqlite3_backup_step(b, NPAGES);
        total = sqlite3_backup_pagecount(b);
        done = total - sqlite3_backup_remaining(b);
        pkg_emit_progress_tick(done, total);

        if (ret != SQLITE_OK && ret != SQLITE_DONE ) {
            if (ret == SQLITE_BUSY) {
                sqlite3_sleep(250);
            } else {
                ERROR_SQLITE(dst, "backup step");
                break;
            }
        }
    } while(done < total);

    ret = sqlite3_backup_finish(b);
    pkg_emit_progress_tick(total, total);

    sqlite3_exec(dst, "PRAGMA main.locking_mode=NORMAL;"
                 "BEGIN IMMEDIATE;COMMIT;", NULL, NULL, &errmsg);

    if (ret != SQLITE_OK) {
        pkg_emit_error("sqlite error -- %s", errmsg);
        sqlite3_free(errmsg);
        return (EPKG_FATAL);
    }

    return ret;
}
コード例 #10
0
ファイル: database.cpp プロジェクト: barkinet/quiterss
void Database::sqliteDBMemFile(bool save)
{
  if (save) qWarning() << "sqliteDBMemFile(): from memory to file...";
  else qWarning() << "sqliteDBMemFile(): from file to memory...";

  int rc = -1;                   /* Function return code */
  QVariant v = QSqlDatabase::database().driver()->handle();
  if (v.isValid() && qstrcmp(v.typeName(),"sqlite3*") == 0) {
    // v.data() returns a pointer to the handle
    sqlite3 *handle = *static_cast<sqlite3 **>(v.data());
    if (handle != 0) {  // check that it is not NULL
      sqlite3 *pInMemory = handle;
      sqlite3 *pFile;           /* Database connection opened on zFilename */
      sqlite3_backup *pBackup;  /* Backup object used to copy data */
      sqlite3 *pTo;             /* Database to copy to (pFile or pInMemory) */
      sqlite3 *pFrom;           /* Database to copy from (pFile or pInMemory) */

      /* Open the database file identified by zFilename. Exit early if this fails
      ** for any reason. */
      rc = sqlite3_open(mainApp->dbFileName().toUtf8().data(), &pFile);
      if (rc == SQLITE_OK) {
        /* If this is a 'load' operation (isSave==0), then data is copied
        ** from the database file just opened to database pInMemory.
        ** Otherwise, if this is a 'save' operation (isSave==1), then data
        ** is copied from pInMemory to pFile.  Set the variables pFrom and
        ** pTo accordingly. */
        pFrom = (save ? pInMemory : pFile);
        pTo   = (save ? pFile     : pInMemory);

        /* Set up the backup procedure to copy from the "main" database of
        ** connection pFile to the main database of connection pInMemory.
        ** If something goes wrong, pBackup will be set to NULL and an error
        ** code and  message left in connection pTo.
        **
        ** If the backup object is successfully created, call backup_step()
        ** to copy data from pFile to pInMemory. Then call backup_finish()
        ** to release resources associated with the pBackup object.  If an
        ** error occurred, then  an error code and message will be left in
        ** connection pTo. If no error occurred, then the error code belonging
        ** to pTo is set to SQLITE_OK.
        */

        pBackup = sqlite3_backup_init(pTo, "main", pFrom, "main");

        /* Each iteration of this loop copies 5 database pages from database
        ** pDb to the backup database. If the return value of backup_step()
        ** indicates that there are still further pages to copy, sleep for
        ** 250 ms before repeating. */
        do {
          rc = sqlite3_backup_step(pBackup, 10000);

          if (!mainApp->isNoDebugOutput()) {
            int remaining = sqlite3_backup_remaining(pBackup);
            int pagecount = sqlite3_backup_pagecount(pBackup);
            qDebug() << rc << "backup" << pagecount << "remain" << remaining;
          }

          if((rc == SQLITE_OK) || (rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED))
            sqlite3_sleep(100);
        } while((rc == SQLITE_OK) || (rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED));

        /* Release resources allocated by backup_init(). */
        (void)sqlite3_backup_finish(pBackup);

        if (rc != SQLITE_DONE)
          qCritical() << "sqliteDBMemFile(): return code =" << rc;
      } else {
        qCritical() << "sqliteDBMemFile(): error open =" << rc;
      }

      /* Close the database connection opened on database file zFilename
      ** and return the result of this function. */
      (void)sqlite3_close(pFile);
    }
  }
  qWarning() << "sqliteDBMemFile(): finished!";
}