sqlite3_backup() vs page_size.

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <sqlite3.h>
#include <unistd.h>

const char kDstFile[] = "/tmp/dbdst";
const char kSrcFile[] = "/tmp/dbsrc";

int sqlite3_append(char** pzBuf, const char* zOtherBuf) {
  size_t nOtherBuf = strlen(zOtherBuf);
  size_t nBuf = *pzBuf ? strlen(*pzBuf) : 0;
  *pzBuf = sqlite3_realloc(*pzBuf, nBuf + nOtherBuf + 1);
  if (!*pzBuf)
    return SQLITE_NOMEM;
  strcpy(*pzBuf + nBuf, zOtherBuf);
  return SQLITE_OK;
}

int sqlite3_gather(void* context, int nArgs, char** zArgs, char** zColumns) {
  char** pzOut = (char**)context;
  if (*pzOut && SQLITE_OK != sqlite3_append(pzOut, "\n"))
    return 1;

  for (int i = 0; i < nArgs; ++i) {
    if (i && SQLITE_OK != sqlite3_append(pzOut, "|"))
      return 1;
    if (SQLITE_OK != sqlite3_append(pzOut, zArgs[i]))
      return 1;
  }
  return 0;
}

int sqlite3_execute(sqlite3* db, const char* zSql) {
  return sqlite3_exec(db, zSql, NULL, NULL, NULL);
}

int sqlite3_execute_and_gather(sqlite3* db, const char* zSql, char** pzOut) {
  return sqlite3_exec(db, zSql, sqlite3_gather, pzOut, NULL);
}

int main(void) {
  unlink(kDstFile);
  unlink(kSrcFile);

  // Create a database with page_size 1024.
  sqlite3* dst = NULL;
  assert(SQLITE_OK == sqlite3_open(kDstFile, &dst));
  assert(SQLITE_OK ==
         sqlite3_execute(dst,
                         "PRAGMA page_size = 1024;"
                         "CREATE TABLE t (c);"
                         "INSERT INTO t VALUES ('a');"
                         "INSERT INTO t VALUES ('b');"
                         "INSERT INTO t VALUES ('c');"
                         "INSERT INTO t VALUES ('d');"
                         ));
  char* zResults = NULL;
  assert(SQLITE_OK == sqlite3_execute_and_gather(dst, "PRAGMA page_size", &zResults));
  assert(!strcmp("1024", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // Changing the page_size does not change the page size.
  assert(SQLITE_OK == sqlite3_open(kDstFile, &dst));
  assert(SQLITE_OK == sqlite3_execute(dst, "PRAGMA page_size = 4096"));
  assert(SQLITE_OK == sqlite3_execute_and_gather(dst, "PRAGMA page_size", &zResults));
  assert(!strcmp("1024", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // Create another database with page_size 4096.
  sqlite3* src = NULL;
  assert(SQLITE_OK == sqlite3_open(kSrcFile, &src));
  assert(SQLITE_OK ==
         sqlite3_execute(src,
                         "PRAGMA page_size = 4096;"
                         "CREATE TABLE t (c);"
                         "INSERT INTO t VALUES ('e');"
                         "INSERT INTO t VALUES ('f');"
                         "INSERT INTO t VALUES ('g');"
                         "INSERT INTO t VALUES ('h');"
                         ));
  assert(SQLITE_OK == sqlite3_execute_and_gather(src, "PRAGMA page_size", &zResults));
  assert(!strcmp("4096", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // Backup src over dst.  Both should end up with the same page_size of 4096.
  sqlite3_backup* backup = sqlite3_backup_init(dst, "main", src, "main");
  assert(backup);
  assert(SQLITE_DONE == sqlite3_backup_step(backup, -1));
  assert(SQLITE_OK == sqlite3_backup_finish(backup));

  // The dst page_size stayed at 1024?
  assert(SQLITE_OK == sqlite3_execute_and_gather(dst, "PRAGMA page_size", &zResults));
  assert(!strcmp("1024", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // But the data in dst is from src.
  assert(SQLITE_OK == sqlite3_execute_and_gather(dst, "SELECT * FROM t ORDER BY c", &zResults));
  assert(!strcmp("e\nf\ng\nh", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // Maybe it's just in memory?
  assert(SQLITE_OK == sqlite3_close(dst));
  assert(SQLITE_OK == sqlite3_open(kDstFile, &dst));

  // Indeed, page size really did change.
  assert(SQLITE_OK == sqlite3_execute_and_gather(dst, "PRAGMA page_size", &zResults));
  assert(!strcmp("4096", zResults));
  sqlite3_free(zResults);
  zResults = NULL;

  // Make sure everything didn't succeed simply because assertions were turned
  // off.
  assert(!"Assertion succeeded!");
  fprintf(stderr, "You don't have assertions on.\n");
  return 0;
}