Index: third_party/sqlite/sqlite-src-3100200/tool/sqldiff.c |
diff --git a/third_party/sqlite/sqlite-src-3100200/tool/sqldiff.c b/third_party/sqlite/sqlite-src-3100200/tool/sqldiff.c |
deleted file mode 100644 |
index 56ff53ee25766d6e4941c60a1f85c5a73a89c73a..0000000000000000000000000000000000000000 |
--- a/third_party/sqlite/sqlite-src-3100200/tool/sqldiff.c |
+++ /dev/null |
@@ -1,1881 +0,0 @@ |
-/* |
-** 2015-04-06 |
-** |
-** The author disclaims copyright to this source code. In place of |
-** a legal notice, here is a blessing: |
-** |
-** May you do good and not evil. |
-** May you find forgiveness for yourself and forgive others. |
-** May you share freely, never taking more than you give. |
-** |
-************************************************************************* |
-** |
-** This is a utility program that computes the differences in content |
-** between two SQLite databases. |
-** |
-** To compile, simply link against SQLite. |
-** |
-** See the showHelp() routine below for a brief description of how to |
-** run the utility. |
-*/ |
-#include <stdio.h> |
-#include <stdlib.h> |
-#include <stdarg.h> |
-#include <ctype.h> |
-#include <string.h> |
-#include <assert.h> |
-#include "sqlite3.h" |
- |
-/* |
-** All global variables are gathered into the "g" singleton. |
-*/ |
-struct GlobalVars { |
- const char *zArgv0; /* Name of program */ |
- int bSchemaOnly; /* Only show schema differences */ |
- int bSchemaPK; /* Use the schema-defined PK, not the true PK */ |
- unsigned fDebug; /* Debug flags */ |
- sqlite3 *db; /* The database connection */ |
-} g; |
- |
-/* |
-** Allowed values for g.fDebug |
-*/ |
-#define DEBUG_COLUMN_NAMES 0x000001 |
-#define DEBUG_DIFF_SQL 0x000002 |
- |
-/* |
-** Dynamic string object |
-*/ |
-typedef struct Str Str; |
-struct Str { |
- char *z; /* Text of the string */ |
- int nAlloc; /* Bytes allocated in z[] */ |
- int nUsed; /* Bytes actually used in z[] */ |
-}; |
- |
-/* |
-** Initialize a Str object |
-*/ |
-static void strInit(Str *p){ |
- p->z = 0; |
- p->nAlloc = 0; |
- p->nUsed = 0; |
-} |
- |
-/* |
-** Print an error resulting from faulting command-line arguments and |
-** abort the program. |
-*/ |
-static void cmdlineError(const char *zFormat, ...){ |
- va_list ap; |
- fprintf(stderr, "%s: ", g.zArgv0); |
- va_start(ap, zFormat); |
- vfprintf(stderr, zFormat, ap); |
- va_end(ap); |
- fprintf(stderr, "\n\"%s --help\" for more help\n", g.zArgv0); |
- exit(1); |
-} |
- |
-/* |
-** Print an error message for an error that occurs at runtime, then |
-** abort the program. |
-*/ |
-static void runtimeError(const char *zFormat, ...){ |
- va_list ap; |
- fprintf(stderr, "%s: ", g.zArgv0); |
- va_start(ap, zFormat); |
- vfprintf(stderr, zFormat, ap); |
- va_end(ap); |
- fprintf(stderr, "\n"); |
- exit(1); |
-} |
- |
-/* |
-** Free all memory held by a Str object |
-*/ |
-static void strFree(Str *p){ |
- sqlite3_free(p->z); |
- strInit(p); |
-} |
- |
-/* |
-** Add formatted text to the end of a Str object |
-*/ |
-static void strPrintf(Str *p, const char *zFormat, ...){ |
- int nNew; |
- for(;;){ |
- if( p->z ){ |
- va_list ap; |
- va_start(ap, zFormat); |
- sqlite3_vsnprintf(p->nAlloc-p->nUsed, p->z+p->nUsed, zFormat, ap); |
- va_end(ap); |
- nNew = (int)strlen(p->z + p->nUsed); |
- }else{ |
- nNew = p->nAlloc; |
- } |
- if( p->nUsed+nNew < p->nAlloc-1 ){ |
- p->nUsed += nNew; |
- break; |
- } |
- p->nAlloc = p->nAlloc*2 + 1000; |
- p->z = sqlite3_realloc(p->z, p->nAlloc); |
- if( p->z==0 ) runtimeError("out of memory"); |
- } |
-} |
- |
- |
- |
-/* Safely quote an SQL identifier. Use the minimum amount of transformation |
-** necessary to allow the string to be used with %s. |
-** |
-** Space to hold the returned string is obtained from sqlite3_malloc(). The |
-** caller is responsible for ensuring this space is freed when no longer |
-** needed. |
-*/ |
-static char *safeId(const char *zId){ |
- /* All SQLite keywords, in alphabetical order */ |
- static const char *azKeywords[] = { |
- "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS", |
- "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY", |
- "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT", |
- "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE", |
- "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE", |
- "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH", |
- "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN", |
- "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF", |
- "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER", |
- "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY", |
- "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL", |
- "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA", |
- "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP", |
- "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT", |
- "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP", |
- "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE", |
- "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE", |
- "WITH", "WITHOUT", |
- }; |
- int lwr, upr, mid, c, i, x; |
- if( zId[0]==0 ) return sqlite3_mprintf("\"\""); |
- for(i=x=0; (c = zId[i])!=0; i++){ |
- if( !isalpha(c) && c!='_' ){ |
- if( i>0 && isdigit(c) ){ |
- x++; |
- }else{ |
- return sqlite3_mprintf("\"%w\"", zId); |
- } |
- } |
- } |
- if( x ) return sqlite3_mprintf("%s", zId); |
- lwr = 0; |
- upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1; |
- while( lwr<=upr ){ |
- mid = (lwr+upr)/2; |
- c = sqlite3_stricmp(azKeywords[mid], zId); |
- if( c==0 ) return sqlite3_mprintf("\"%w\"", zId); |
- if( c<0 ){ |
- lwr = mid+1; |
- }else{ |
- upr = mid-1; |
- } |
- } |
- return sqlite3_mprintf("%s", zId); |
-} |
- |
-/* |
-** Prepare a new SQL statement. Print an error and abort if anything |
-** goes wrong. |
-*/ |
-static sqlite3_stmt *db_vprepare(const char *zFormat, va_list ap){ |
- char *zSql; |
- int rc; |
- sqlite3_stmt *pStmt; |
- |
- zSql = sqlite3_vmprintf(zFormat, ap); |
- if( zSql==0 ) runtimeError("out of memory"); |
- rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0); |
- if( rc ){ |
- runtimeError("SQL statement error: %s\n\"%s\"", sqlite3_errmsg(g.db), |
- zSql); |
- } |
- sqlite3_free(zSql); |
- return pStmt; |
-} |
-static sqlite3_stmt *db_prepare(const char *zFormat, ...){ |
- va_list ap; |
- sqlite3_stmt *pStmt; |
- va_start(ap, zFormat); |
- pStmt = db_vprepare(zFormat, ap); |
- va_end(ap); |
- return pStmt; |
-} |
- |
-/* |
-** Free a list of strings |
-*/ |
-static void namelistFree(char **az){ |
- if( az ){ |
- int i; |
- for(i=0; az[i]; i++) sqlite3_free(az[i]); |
- sqlite3_free(az); |
- } |
-} |
- |
-/* |
-** Return a list of column names for the table zDb.zTab. Space to |
-** hold the list is obtained from sqlite3_malloc() and should released |
-** using namelistFree() when no longer needed. |
-** |
-** Primary key columns are listed first, followed by data columns. |
-** The number of columns in the primary key is returned in *pnPkey. |
-** |
-** Normally, the "primary key" in the previous sentence is the true |
-** primary key - the rowid or INTEGER PRIMARY KEY for ordinary tables |
-** or the declared PRIMARY KEY for WITHOUT ROWID tables. However, if |
-** the g.bSchemaPK flag is set, then the schema-defined PRIMARY KEY is |
-** used in all cases. In that case, entries that have NULL values in |
-** any of their primary key fields will be excluded from the analysis. |
-** |
-** If the primary key for a table is the rowid but rowid is inaccessible, |
-** then this routine returns a NULL pointer. |
-** |
-** Examples: |
-** CREATE TABLE t1(a INT UNIQUE, b INTEGER, c TEXT, PRIMARY KEY(c)); |
-** *pnPKey = 1; |
-** az = { "rowid", "a", "b", "c", 0 } // Normal case |
-** az = { "c", "a", "b", 0 } // g.bSchemaPK==1 |
-** |
-** CREATE TABLE t2(a INT UNIQUE, b INTEGER, c TEXT, PRIMARY KEY(b)); |
-** *pnPKey = 1; |
-** az = { "b", "a", "c", 0 } |
-** |
-** CREATE TABLE t3(x,y,z,PRIMARY KEY(y,z)); |
-** *pnPKey = 1 // Normal case |
-** az = { "rowid", "x", "y", "z", 0 } // Normal case |
-** *pnPKey = 2 // g.bSchemaPK==1 |
-** az = { "y", "x", "z", 0 } // g.bSchemaPK==1 |
-** |
-** CREATE TABLE t4(x,y,z,PRIMARY KEY(y,z)) WITHOUT ROWID; |
-** *pnPKey = 2 |
-** az = { "y", "z", "x", 0 } |
-** |
-** CREATE TABLE t5(rowid,_rowid_,oid); |
-** az = 0 // The rowid is not accessible |
-*/ |
-static char **columnNames( |
- const char *zDb, /* Database ("main" or "aux") to query */ |
- const char *zTab, /* Name of table to return details of */ |
- int *pnPKey, /* OUT: Number of PK columns */ |
- int *pbRowid /* OUT: True if PK is an implicit rowid */ |
-){ |
- char **az = 0; /* List of column names to be returned */ |
- int naz = 0; /* Number of entries in az[] */ |
- sqlite3_stmt *pStmt; /* SQL statement being run */ |
- char *zPkIdxName = 0; /* Name of the PRIMARY KEY index */ |
- int truePk = 0; /* PRAGMA table_info indentifies the PK to use */ |
- int nPK = 0; /* Number of PRIMARY KEY columns */ |
- int i, j; /* Loop counters */ |
- |
- if( g.bSchemaPK==0 ){ |
- /* Normal case: Figure out what the true primary key is for the table. |
- ** * For WITHOUT ROWID tables, the true primary key is the same as |
- ** the schema PRIMARY KEY, which is guaranteed to be present. |
- ** * For rowid tables with an INTEGER PRIMARY KEY, the true primary |
- ** key is the INTEGER PRIMARY KEY. |
- ** * For all other rowid tables, the rowid is the true primary key. |
- */ |
- pStmt = db_prepare("PRAGMA %s.index_list=%Q", zDb, zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- if( sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,3),"pk")==0 ){ |
- zPkIdxName = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1)); |
- break; |
- } |
- } |
- sqlite3_finalize(pStmt); |
- if( zPkIdxName ){ |
- int nKey = 0; |
- int nCol = 0; |
- truePk = 0; |
- pStmt = db_prepare("PRAGMA %s.index_xinfo=%Q", zDb, zPkIdxName); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- nCol++; |
- if( sqlite3_column_int(pStmt,5) ){ nKey++; continue; } |
- if( sqlite3_column_int(pStmt,1)>=0 ) truePk = 1; |
- } |
- if( nCol==nKey ) truePk = 1; |
- if( truePk ){ |
- nPK = nKey; |
- }else{ |
- nPK = 1; |
- } |
- sqlite3_finalize(pStmt); |
- sqlite3_free(zPkIdxName); |
- }else{ |
- truePk = 1; |
- nPK = 1; |
- } |
- pStmt = db_prepare("PRAGMA %s.table_info=%Q", zDb, zTab); |
- }else{ |
- /* The g.bSchemaPK==1 case: Use whatever primary key is declared |
- ** in the schema. The "rowid" will still be used as the primary key |
- ** if the table definition does not contain a PRIMARY KEY. |
- */ |
- nPK = 0; |
- pStmt = db_prepare("PRAGMA %s.table_info=%Q", zDb, zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- if( sqlite3_column_int(pStmt,5)>0 ) nPK++; |
- } |
- sqlite3_reset(pStmt); |
- if( nPK==0 ) nPK = 1; |
- truePk = 1; |
- } |
- *pnPKey = nPK; |
- naz = nPK; |
- az = sqlite3_malloc( sizeof(char*)*(nPK+1) ); |
- if( az==0 ) runtimeError("out of memory"); |
- memset(az, 0, sizeof(char*)*(nPK+1)); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- int iPKey; |
- if( truePk && (iPKey = sqlite3_column_int(pStmt,5))>0 ){ |
- az[iPKey-1] = safeId((char*)sqlite3_column_text(pStmt,1)); |
- }else{ |
- az = sqlite3_realloc(az, sizeof(char*)*(naz+2) ); |
- if( az==0 ) runtimeError("out of memory"); |
- az[naz++] = safeId((char*)sqlite3_column_text(pStmt,1)); |
- } |
- } |
- sqlite3_finalize(pStmt); |
- if( az ) az[naz] = 0; |
- |
- /* If it is non-NULL, set *pbRowid to indicate whether or not the PK of |
- ** this table is an implicit rowid (*pbRowid==1) or not (*pbRowid==0). */ |
- if( pbRowid ) *pbRowid = (az[0]==0); |
- |
- /* If this table has an implicit rowid for a PK, figure out how to refer |
- ** to it. There are three options - "rowid", "_rowid_" and "oid". Any |
- ** of these will work, unless the table has an explicit column of the |
- ** same name. */ |
- if( az[0]==0 ){ |
- const char *azRowid[] = { "rowid", "_rowid_", "oid" }; |
- for(i=0; i<sizeof(azRowid)/sizeof(azRowid[0]); i++){ |
- for(j=1; j<naz; j++){ |
- if( sqlite3_stricmp(az[j], azRowid[i])==0 ) break; |
- } |
- if( j>=naz ){ |
- az[0] = sqlite3_mprintf("%s", azRowid[i]); |
- break; |
- } |
- } |
- if( az[0]==0 ){ |
- for(i=1; i<naz; i++) sqlite3_free(az[i]); |
- sqlite3_free(az); |
- az = 0; |
- } |
- } |
- return az; |
-} |
- |
-/* |
-** Print the sqlite3_value X as an SQL literal. |
-*/ |
-static void printQuoted(FILE *out, sqlite3_value *X){ |
- switch( sqlite3_value_type(X) ){ |
- case SQLITE_FLOAT: { |
- double r1; |
- char zBuf[50]; |
- r1 = sqlite3_value_double(X); |
- sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); |
- fprintf(out, "%s", zBuf); |
- break; |
- } |
- case SQLITE_INTEGER: { |
- fprintf(out, "%lld", sqlite3_value_int64(X)); |
- break; |
- } |
- case SQLITE_BLOB: { |
- const unsigned char *zBlob = sqlite3_value_blob(X); |
- int nBlob = sqlite3_value_bytes(X); |
- if( zBlob ){ |
- int i; |
- fprintf(out, "x'"); |
- for(i=0; i<nBlob; i++){ |
- fprintf(out, "%02x", zBlob[i]); |
- } |
- fprintf(out, "'"); |
- }else{ |
- fprintf(out, "NULL"); |
- } |
- break; |
- } |
- case SQLITE_TEXT: { |
- const unsigned char *zArg = sqlite3_value_text(X); |
- int i, j; |
- |
- if( zArg==0 ){ |
- fprintf(out, "NULL"); |
- }else{ |
- fprintf(out, "'"); |
- for(i=j=0; zArg[i]; i++){ |
- if( zArg[i]=='\'' ){ |
- fprintf(out, "%.*s'", i-j+1, &zArg[j]); |
- j = i+1; |
- } |
- } |
- fprintf(out, "%s'", &zArg[j]); |
- } |
- break; |
- } |
- case SQLITE_NULL: { |
- fprintf(out, "NULL"); |
- break; |
- } |
- } |
-} |
- |
-/* |
-** Output SQL that will recreate the aux.zTab table. |
-*/ |
-static void dump_table(const char *zTab, FILE *out){ |
- char *zId = safeId(zTab); /* Name of the table */ |
- char **az = 0; /* List of columns */ |
- int nPk; /* Number of true primary key columns */ |
- int nCol; /* Number of data columns */ |
- int i; /* Loop counter */ |
- sqlite3_stmt *pStmt; /* SQL statement */ |
- const char *zSep; /* Separator string */ |
- Str ins; /* Beginning of the INSERT statement */ |
- |
- pStmt = db_prepare("SELECT sql FROM aux.sqlite_master WHERE name=%Q", zTab); |
- if( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- fprintf(out, "%s;\n", sqlite3_column_text(pStmt,0)); |
- } |
- sqlite3_finalize(pStmt); |
- if( !g.bSchemaOnly ){ |
- az = columnNames("aux", zTab, &nPk, 0); |
- strInit(&ins); |
- if( az==0 ){ |
- pStmt = db_prepare("SELECT * FROM aux.%s", zId); |
- strPrintf(&ins,"INSERT INTO %s VALUES", zId); |
- }else{ |
- Str sql; |
- strInit(&sql); |
- zSep = "SELECT"; |
- for(i=0; az[i]; i++){ |
- strPrintf(&sql, "%s %s", zSep, az[i]); |
- zSep = ","; |
- } |
- strPrintf(&sql," FROM aux.%s", zId); |
- zSep = " ORDER BY"; |
- for(i=1; i<=nPk; i++){ |
- strPrintf(&sql, "%s %d", zSep, i); |
- zSep = ","; |
- } |
- pStmt = db_prepare("%s", sql.z); |
- strFree(&sql); |
- strPrintf(&ins, "INSERT INTO %s", zId); |
- zSep = "("; |
- for(i=0; az[i]; i++){ |
- strPrintf(&ins, "%s%s", zSep, az[i]); |
- zSep = ","; |
- } |
- strPrintf(&ins,") VALUES"); |
- namelistFree(az); |
- } |
- nCol = sqlite3_column_count(pStmt); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- fprintf(out, "%s",ins.z); |
- zSep = "("; |
- for(i=0; i<nCol; i++){ |
- fprintf(out, "%s",zSep); |
- printQuoted(out, sqlite3_column_value(pStmt,i)); |
- zSep = ","; |
- } |
- fprintf(out, ");\n"); |
- } |
- sqlite3_finalize(pStmt); |
- strFree(&ins); |
- } /* endif !g.bSchemaOnly */ |
- pStmt = db_prepare("SELECT sql FROM aux.sqlite_master" |
- " WHERE type='index' AND tbl_name=%Q AND sql IS NOT NULL", |
- zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- fprintf(out, "%s;\n", sqlite3_column_text(pStmt,0)); |
- } |
- sqlite3_finalize(pStmt); |
-} |
- |
- |
-/* |
-** Compute all differences for a single table. |
-*/ |
-static void diff_one_table(const char *zTab, FILE *out){ |
- char *zId = safeId(zTab); /* Name of table (translated for us in SQL) */ |
- char **az = 0; /* Columns in main */ |
- char **az2 = 0; /* Columns in aux */ |
- int nPk; /* Primary key columns in main */ |
- int nPk2; /* Primary key columns in aux */ |
- int n = 0; /* Number of columns in main */ |
- int n2; /* Number of columns in aux */ |
- int nQ; /* Number of output columns in the diff query */ |
- int i; /* Loop counter */ |
- const char *zSep; /* Separator string */ |
- Str sql; /* Comparison query */ |
- sqlite3_stmt *pStmt; /* Query statement to do the diff */ |
- |
- strInit(&sql); |
- if( g.fDebug==DEBUG_COLUMN_NAMES ){ |
- /* Simply run columnNames() on all tables of the origin |
- ** database and show the results. This is used for testing |
- ** and debugging of the columnNames() function. |
- */ |
- az = columnNames("aux",zTab, &nPk, 0); |
- if( az==0 ){ |
- printf("Rowid not accessible for %s\n", zId); |
- }else{ |
- printf("%s:", zId); |
- for(i=0; az[i]; i++){ |
- printf(" %s", az[i]); |
- if( i+1==nPk ) printf(" *"); |
- } |
- printf("\n"); |
- } |
- goto end_diff_one_table; |
- } |
- |
- |
- if( sqlite3_table_column_metadata(g.db,"aux",zTab,0,0,0,0,0,0) ){ |
- if( !sqlite3_table_column_metadata(g.db,"main",zTab,0,0,0,0,0,0) ){ |
- /* Table missing from second database. */ |
- fprintf(out, "DROP TABLE %s;\n", zId); |
- } |
- goto end_diff_one_table; |
- } |
- |
- if( sqlite3_table_column_metadata(g.db,"main",zTab,0,0,0,0,0,0) ){ |
- /* Table missing from source */ |
- dump_table(zTab, out); |
- goto end_diff_one_table; |
- } |
- |
- az = columnNames("main", zTab, &nPk, 0); |
- az2 = columnNames("aux", zTab, &nPk2, 0); |
- if( az && az2 ){ |
- for(n=0; az[n] && az2[n]; n++){ |
- if( sqlite3_stricmp(az[n],az2[n])!=0 ) break; |
- } |
- } |
- if( az==0 |
- || az2==0 |
- || nPk!=nPk2 |
- || az[n] |
- ){ |
- /* Schema mismatch */ |
- fprintf(out, "DROP TABLE %s; -- due to schema mismatch\n", zId); |
- dump_table(zTab, out); |
- goto end_diff_one_table; |
- } |
- |
- /* Build the comparison query */ |
- for(n2=n; az2[n2]; n2++){ |
- fprintf(out, "ALTER TABLE %s ADD COLUMN %s;\n", zId, safeId(az2[n2])); |
- } |
- nQ = nPk2+1+2*(n2-nPk2); |
- if( n2>nPk2 ){ |
- zSep = "SELECT "; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%sB.%s", zSep, az[i]); |
- zSep = ", "; |
- } |
- strPrintf(&sql, ", 1%s -- changed row\n", nPk==n ? "" : ","); |
- while( az[i] ){ |
- strPrintf(&sql, " A.%s IS NOT B.%s, B.%s%s\n", |
- az[i], az2[i], az2[i], az2[i+1]==0 ? "" : ","); |
- i++; |
- } |
- while( az2[i] ){ |
- strPrintf(&sql, " B.%s IS NOT NULL, B.%s%s\n", |
- az2[i], az2[i], az2[i+1]==0 ? "" : ","); |
- i++; |
- } |
- strPrintf(&sql, " FROM main.%s A, aux.%s B\n", zId, zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- zSep = "\n AND ("; |
- while( az[i] ){ |
- strPrintf(&sql, "%sA.%s IS NOT B.%s%s\n", |
- zSep, az[i], az2[i], az2[i+1]==0 ? ")" : ""); |
- zSep = " OR "; |
- i++; |
- } |
- while( az2[i] ){ |
- strPrintf(&sql, "%sB.%s IS NOT NULL%s\n", |
- zSep, az2[i], az2[i+1]==0 ? ")" : ""); |
- zSep = " OR "; |
- i++; |
- } |
- strPrintf(&sql, " UNION ALL\n"); |
- } |
- zSep = "SELECT "; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%sA.%s", zSep, az[i]); |
- zSep = ", "; |
- } |
- strPrintf(&sql, ", 2%s -- deleted row\n", nPk==n ? "" : ","); |
- while( az2[i] ){ |
- strPrintf(&sql, " NULL, NULL%s\n", i==n2-1 ? "" : ","); |
- i++; |
- } |
- strPrintf(&sql, " FROM main.%s A\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM aux.%s B\n", zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n"); |
- zSep = " UNION ALL\nSELECT "; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%sB.%s", zSep, az[i]); |
- zSep = ", "; |
- } |
- strPrintf(&sql, ", 3%s -- inserted row\n", nPk==n ? "" : ","); |
- while( az2[i] ){ |
- strPrintf(&sql, " 1, B.%s%s\n", az2[i], az2[i+1]==0 ? "" : ","); |
- i++; |
- } |
- strPrintf(&sql, " FROM aux.%s B\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM main.%s A\n", zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n ORDER BY"); |
- zSep = " "; |
- for(i=1; i<=nPk; i++){ |
- strPrintf(&sql, "%s%d", zSep, i); |
- zSep = ", "; |
- } |
- strPrintf(&sql, ";\n"); |
- |
- if( g.fDebug & DEBUG_DIFF_SQL ){ |
- printf("SQL for %s:\n%s\n", zId, sql.z); |
- goto end_diff_one_table; |
- } |
- |
- /* Drop indexes that are missing in the destination */ |
- pStmt = db_prepare( |
- "SELECT name FROM main.sqlite_master" |
- " WHERE type='index' AND tbl_name=%Q" |
- " AND sql IS NOT NULL" |
- " AND sql NOT IN (SELECT sql FROM aux.sqlite_master" |
- " WHERE type='index' AND tbl_name=%Q" |
- " AND sql IS NOT NULL)", |
- zTab, zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- char *z = safeId((const char*)sqlite3_column_text(pStmt,0)); |
- fprintf(out, "DROP INDEX %s;\n", z); |
- sqlite3_free(z); |
- } |
- sqlite3_finalize(pStmt); |
- |
- /* Run the query and output differences */ |
- if( !g.bSchemaOnly ){ |
- pStmt = db_prepare(sql.z); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- int iType = sqlite3_column_int(pStmt, nPk); |
- if( iType==1 || iType==2 ){ |
- if( iType==1 ){ /* Change the content of a row */ |
- fprintf(out, "UPDATE %s", zId); |
- zSep = " SET"; |
- for(i=nPk+1; i<nQ; i+=2){ |
- if( sqlite3_column_int(pStmt,i)==0 ) continue; |
- fprintf(out, "%s %s=", zSep, az2[(i+nPk-1)/2]); |
- zSep = ","; |
- printQuoted(out, sqlite3_column_value(pStmt,i+1)); |
- } |
- }else{ /* Delete a row */ |
- fprintf(out, "DELETE FROM %s", zId); |
- } |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- fprintf(out, "%s %s=", zSep, az2[i]); |
- printQuoted(out, sqlite3_column_value(pStmt,i)); |
- zSep = " AND"; |
- } |
- fprintf(out, ";\n"); |
- }else{ /* Insert a row */ |
- fprintf(out, "INSERT INTO %s(%s", zId, az2[0]); |
- for(i=1; az2[i]; i++) fprintf(out, ",%s", az2[i]); |
- fprintf(out, ") VALUES"); |
- zSep = "("; |
- for(i=0; i<nPk2; i++){ |
- fprintf(out, "%s", zSep); |
- zSep = ","; |
- printQuoted(out, sqlite3_column_value(pStmt,i)); |
- } |
- for(i=nPk2+2; i<nQ; i+=2){ |
- fprintf(out, ","); |
- printQuoted(out, sqlite3_column_value(pStmt,i)); |
- } |
- fprintf(out, ");\n"); |
- } |
- } |
- sqlite3_finalize(pStmt); |
- } /* endif !g.bSchemaOnly */ |
- |
- /* Create indexes that are missing in the source */ |
- pStmt = db_prepare( |
- "SELECT sql FROM aux.sqlite_master" |
- " WHERE type='index' AND tbl_name=%Q" |
- " AND sql IS NOT NULL" |
- " AND sql NOT IN (SELECT sql FROM main.sqlite_master" |
- " WHERE type='index' AND tbl_name=%Q" |
- " AND sql IS NOT NULL)", |
- zTab, zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- fprintf(out, "%s;\n", sqlite3_column_text(pStmt,0)); |
- } |
- sqlite3_finalize(pStmt); |
- |
-end_diff_one_table: |
- strFree(&sql); |
- sqlite3_free(zId); |
- namelistFree(az); |
- namelistFree(az2); |
- return; |
-} |
- |
-/* |
-** Check that table zTab exists and has the same schema in both the "main" |
-** and "aux" databases currently opened by the global db handle. If they |
-** do not, output an error message on stderr and exit(1). Otherwise, if |
-** the schemas do match, return control to the caller. |
-*/ |
-static void checkSchemasMatch(const char *zTab){ |
- sqlite3_stmt *pStmt = db_prepare( |
- "SELECT A.sql=B.sql FROM main.sqlite_master A, aux.sqlite_master B" |
- " WHERE A.name=%Q AND B.name=%Q", zTab, zTab |
- ); |
- if( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- if( sqlite3_column_int(pStmt,0)==0 ){ |
- runtimeError("schema changes for table %s", safeId(zTab)); |
- } |
- }else{ |
- runtimeError("table %s missing from one or both databases", safeId(zTab)); |
- } |
- sqlite3_finalize(pStmt); |
-} |
- |
-/************************************************************************** |
-** The following code is copied from fossil. It is used to generate the |
-** fossil delta blobs sometimes used in RBU update records. |
-*/ |
- |
-typedef unsigned short u16; |
-typedef unsigned int u32; |
-typedef unsigned char u8; |
- |
-/* |
-** The width of a hash window in bytes. The algorithm only works if this |
-** is a power of 2. |
-*/ |
-#define NHASH 16 |
- |
-/* |
-** The current state of the rolling hash. |
-** |
-** z[] holds the values that have been hashed. z[] is a circular buffer. |
-** z[i] is the first entry and z[(i+NHASH-1)%NHASH] is the last entry of |
-** the window. |
-** |
-** Hash.a is the sum of all elements of hash.z[]. Hash.b is a weighted |
-** sum. Hash.b is z[i]*NHASH + z[i+1]*(NHASH-1) + ... + z[i+NHASH-1]*1. |
-** (Each index for z[] should be module NHASH, of course. The %NHASH operator |
-** is omitted in the prior expression for brevity.) |
-*/ |
-typedef struct hash hash; |
-struct hash { |
- u16 a, b; /* Hash values */ |
- u16 i; /* Start of the hash window */ |
- char z[NHASH]; /* The values that have been hashed */ |
-}; |
- |
-/* |
-** Initialize the rolling hash using the first NHASH characters of z[] |
-*/ |
-static void hash_init(hash *pHash, const char *z){ |
- u16 a, b, i; |
- a = b = 0; |
- for(i=0; i<NHASH; i++){ |
- a += z[i]; |
- b += (NHASH-i)*z[i]; |
- pHash->z[i] = z[i]; |
- } |
- pHash->a = a & 0xffff; |
- pHash->b = b & 0xffff; |
- pHash->i = 0; |
-} |
- |
-/* |
-** Advance the rolling hash by a single character "c" |
-*/ |
-static void hash_next(hash *pHash, int c){ |
- u16 old = pHash->z[pHash->i]; |
- pHash->z[pHash->i] = (char)c; |
- pHash->i = (pHash->i+1)&(NHASH-1); |
- pHash->a = pHash->a - old + (char)c; |
- pHash->b = pHash->b - NHASH*old + pHash->a; |
-} |
- |
-/* |
-** Return a 32-bit hash value |
-*/ |
-static u32 hash_32bit(hash *pHash){ |
- return (pHash->a & 0xffff) | (((u32)(pHash->b & 0xffff))<<16); |
-} |
- |
-/* |
-** Write an base-64 integer into the given buffer. |
-*/ |
-static void putInt(unsigned int v, char **pz){ |
- static const char zDigits[] = |
- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"; |
- /* 123456789 123456789 123456789 123456789 123456789 123456789 123 */ |
- int i, j; |
- char zBuf[20]; |
- if( v==0 ){ |
- *(*pz)++ = '0'; |
- return; |
- } |
- for(i=0; v>0; i++, v>>=6){ |
- zBuf[i] = zDigits[v&0x3f]; |
- } |
- for(j=i-1; j>=0; j--){ |
- *(*pz)++ = zBuf[j]; |
- } |
-} |
- |
-/* |
-** Return the number digits in the base-64 representation of a positive integer |
-*/ |
-static int digit_count(int v){ |
- unsigned int i, x; |
- for(i=1, x=64; (unsigned int)v>=x; i++, x <<= 6){} |
- return i; |
-} |
- |
-/* |
-** Compute a 32-bit checksum on the N-byte buffer. Return the result. |
-*/ |
-static unsigned int checksum(const char *zIn, size_t N){ |
- const unsigned char *z = (const unsigned char *)zIn; |
- unsigned sum0 = 0; |
- unsigned sum1 = 0; |
- unsigned sum2 = 0; |
- unsigned sum3 = 0; |
- while(N >= 16){ |
- sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]); |
- sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]); |
- sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]); |
- sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]); |
- z += 16; |
- N -= 16; |
- } |
- while(N >= 4){ |
- sum0 += z[0]; |
- sum1 += z[1]; |
- sum2 += z[2]; |
- sum3 += z[3]; |
- z += 4; |
- N -= 4; |
- } |
- sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24); |
- switch(N){ |
- case 3: sum3 += (z[2] << 8); |
- case 2: sum3 += (z[1] << 16); |
- case 1: sum3 += (z[0] << 24); |
- default: ; |
- } |
- return sum3; |
-} |
- |
-/* |
-** Create a new delta. |
-** |
-** The delta is written into a preallocated buffer, zDelta, which |
-** should be at least 60 bytes longer than the target file, zOut. |
-** The delta string will be NUL-terminated, but it might also contain |
-** embedded NUL characters if either the zSrc or zOut files are |
-** binary. This function returns the length of the delta string |
-** in bytes, excluding the final NUL terminator character. |
-** |
-** Output Format: |
-** |
-** The delta begins with a base64 number followed by a newline. This |
-** number is the number of bytes in the TARGET file. Thus, given a |
-** delta file z, a program can compute the size of the output file |
-** simply by reading the first line and decoding the base-64 number |
-** found there. The delta_output_size() routine does exactly this. |
-** |
-** After the initial size number, the delta consists of a series of |
-** literal text segments and commands to copy from the SOURCE file. |
-** A copy command looks like this: |
-** |
-** NNN@MMM, |
-** |
-** where NNN is the number of bytes to be copied and MMM is the offset |
-** into the source file of the first byte (both base-64). If NNN is 0 |
-** it means copy the rest of the input file. Literal text is like this: |
-** |
-** NNN:TTTTT |
-** |
-** where NNN is the number of bytes of text (base-64) and TTTTT is the text. |
-** |
-** The last term is of the form |
-** |
-** NNN; |
-** |
-** In this case, NNN is a 32-bit bigendian checksum of the output file |
-** that can be used to verify that the delta applied correctly. All |
-** numbers are in base-64. |
-** |
-** Pure text files generate a pure text delta. Binary files generate a |
-** delta that may contain some binary data. |
-** |
-** Algorithm: |
-** |
-** The encoder first builds a hash table to help it find matching |
-** patterns in the source file. 16-byte chunks of the source file |
-** sampled at evenly spaced intervals are used to populate the hash |
-** table. |
-** |
-** Next we begin scanning the target file using a sliding 16-byte |
-** window. The hash of the 16-byte window in the target is used to |
-** search for a matching section in the source file. When a match |
-** is found, a copy command is added to the delta. An effort is |
-** made to extend the matching section to regions that come before |
-** and after the 16-byte hash window. A copy command is only issued |
-** if the result would use less space that just quoting the text |
-** literally. Literal text is added to the delta for sections that |
-** do not match or which can not be encoded efficiently using copy |
-** commands. |
-*/ |
-static int rbuDeltaCreate( |
- const char *zSrc, /* The source or pattern file */ |
- unsigned int lenSrc, /* Length of the source file */ |
- const char *zOut, /* The target file */ |
- unsigned int lenOut, /* Length of the target file */ |
- char *zDelta /* Write the delta into this buffer */ |
-){ |
- unsigned int i, base; |
- char *zOrigDelta = zDelta; |
- hash h; |
- int nHash; /* Number of hash table entries */ |
- int *landmark; /* Primary hash table */ |
- int *collide; /* Collision chain */ |
- int lastRead = -1; /* Last byte of zSrc read by a COPY command */ |
- |
- /* Add the target file size to the beginning of the delta |
- */ |
- putInt(lenOut, &zDelta); |
- *(zDelta++) = '\n'; |
- |
- /* If the source file is very small, it means that we have no |
- ** chance of ever doing a copy command. Just output a single |
- ** literal segment for the entire target and exit. |
- */ |
- if( lenSrc<=NHASH ){ |
- putInt(lenOut, &zDelta); |
- *(zDelta++) = ':'; |
- memcpy(zDelta, zOut, lenOut); |
- zDelta += lenOut; |
- putInt(checksum(zOut, lenOut), &zDelta); |
- *(zDelta++) = ';'; |
- return zDelta - zOrigDelta; |
- } |
- |
- /* Compute the hash table used to locate matching sections in the |
- ** source file. |
- */ |
- nHash = lenSrc/NHASH; |
- collide = sqlite3_malloc( nHash*2*sizeof(int) ); |
- landmark = &collide[nHash]; |
- memset(landmark, -1, nHash*sizeof(int)); |
- memset(collide, -1, nHash*sizeof(int)); |
- for(i=0; i<lenSrc-NHASH; i+=NHASH){ |
- int hv; |
- hash_init(&h, &zSrc[i]); |
- hv = hash_32bit(&h) % nHash; |
- collide[i/NHASH] = landmark[hv]; |
- landmark[hv] = i/NHASH; |
- } |
- |
- /* Begin scanning the target file and generating copy commands and |
- ** literal sections of the delta. |
- */ |
- base = 0; /* We have already generated everything before zOut[base] */ |
- while( base+NHASH<lenOut ){ |
- int iSrc, iBlock; |
- int bestCnt, bestOfst=0, bestLitsz=0; |
- hash_init(&h, &zOut[base]); |
- i = 0; /* Trying to match a landmark against zOut[base+i] */ |
- bestCnt = 0; |
- while( 1 ){ |
- int hv; |
- int limit = 250; |
- |
- hv = hash_32bit(&h) % nHash; |
- iBlock = landmark[hv]; |
- while( iBlock>=0 && (limit--)>0 ){ |
- /* |
- ** The hash window has identified a potential match against |
- ** landmark block iBlock. But we need to investigate further. |
- ** |
- ** Look for a region in zOut that matches zSrc. Anchor the search |
- ** at zSrc[iSrc] and zOut[base+i]. Do not include anything prior to |
- ** zOut[base] or after zOut[outLen] nor anything after zSrc[srcLen]. |
- ** |
- ** Set cnt equal to the length of the match and set ofst so that |
- ** zSrc[ofst] is the first element of the match. litsz is the number |
- ** of characters between zOut[base] and the beginning of the match. |
- ** sz will be the overhead (in bytes) needed to encode the copy |
- ** command. Only generate copy command if the overhead of the |
- ** copy command is less than the amount of literal text to be copied. |
- */ |
- int cnt, ofst, litsz; |
- int j, k, x, y; |
- int sz; |
- |
- /* Beginning at iSrc, match forwards as far as we can. j counts |
- ** the number of characters that match */ |
- iSrc = iBlock*NHASH; |
- for( |
- j=0, x=iSrc, y=base+i; |
- (unsigned int)x<lenSrc && (unsigned int)y<lenOut; |
- j++, x++, y++ |
- ){ |
- if( zSrc[x]!=zOut[y] ) break; |
- } |
- j--; |
- |
- /* Beginning at iSrc-1, match backwards as far as we can. k counts |
- ** the number of characters that match */ |
- for(k=1; k<iSrc && (unsigned int)k<=i; k++){ |
- if( zSrc[iSrc-k]!=zOut[base+i-k] ) break; |
- } |
- k--; |
- |
- /* Compute the offset and size of the matching region */ |
- ofst = iSrc-k; |
- cnt = j+k+1; |
- litsz = i-k; /* Number of bytes of literal text before the copy */ |
- /* sz will hold the number of bytes needed to encode the "insert" |
- ** command and the copy command, not counting the "insert" text */ |
- sz = digit_count(i-k)+digit_count(cnt)+digit_count(ofst)+3; |
- if( cnt>=sz && cnt>bestCnt ){ |
- /* Remember this match only if it is the best so far and it |
- ** does not increase the file size */ |
- bestCnt = cnt; |
- bestOfst = iSrc-k; |
- bestLitsz = litsz; |
- } |
- |
- /* Check the next matching block */ |
- iBlock = collide[iBlock]; |
- } |
- |
- /* We have a copy command that does not cause the delta to be larger |
- ** than a literal insert. So add the copy command to the delta. |
- */ |
- if( bestCnt>0 ){ |
- if( bestLitsz>0 ){ |
- /* Add an insert command before the copy */ |
- putInt(bestLitsz,&zDelta); |
- *(zDelta++) = ':'; |
- memcpy(zDelta, &zOut[base], bestLitsz); |
- zDelta += bestLitsz; |
- base += bestLitsz; |
- } |
- base += bestCnt; |
- putInt(bestCnt, &zDelta); |
- *(zDelta++) = '@'; |
- putInt(bestOfst, &zDelta); |
- *(zDelta++) = ','; |
- if( bestOfst + bestCnt -1 > lastRead ){ |
- lastRead = bestOfst + bestCnt - 1; |
- } |
- bestCnt = 0; |
- break; |
- } |
- |
- /* If we reach this point, it means no match is found so far */ |
- if( base+i+NHASH>=lenOut ){ |
- /* We have reached the end of the file and have not found any |
- ** matches. Do an "insert" for everything that does not match */ |
- putInt(lenOut-base, &zDelta); |
- *(zDelta++) = ':'; |
- memcpy(zDelta, &zOut[base], lenOut-base); |
- zDelta += lenOut-base; |
- base = lenOut; |
- break; |
- } |
- |
- /* Advance the hash by one character. Keep looking for a match */ |
- hash_next(&h, zOut[base+i+NHASH]); |
- i++; |
- } |
- } |
- /* Output a final "insert" record to get all the text at the end of |
- ** the file that does not match anything in the source file. |
- */ |
- if( base<lenOut ){ |
- putInt(lenOut-base, &zDelta); |
- *(zDelta++) = ':'; |
- memcpy(zDelta, &zOut[base], lenOut-base); |
- zDelta += lenOut-base; |
- } |
- /* Output the final checksum record. */ |
- putInt(checksum(zOut, lenOut), &zDelta); |
- *(zDelta++) = ';'; |
- sqlite3_free(collide); |
- return zDelta - zOrigDelta; |
-} |
- |
-/* |
-** End of code copied from fossil. |
-**************************************************************************/ |
- |
-static void strPrintfArray( |
- Str *pStr, /* String object to append to */ |
- const char *zSep, /* Separator string */ |
- const char *zFmt, /* Format for each entry */ |
- char **az, int n /* Array of strings & its size (or -1) */ |
-){ |
- int i; |
- for(i=0; az[i] && (i<n || n<0); i++){ |
- if( i!=0 ) strPrintf(pStr, "%s", zSep); |
- strPrintf(pStr, zFmt, az[i], az[i], az[i]); |
- } |
-} |
- |
-static void getRbudiffQuery( |
- const char *zTab, |
- char **azCol, |
- int nPK, |
- int bOtaRowid, |
- Str *pSql |
-){ |
- int i; |
- |
- /* First the newly inserted rows: **/ |
- strPrintf(pSql, "SELECT "); |
- strPrintfArray(pSql, ", ", "%s", azCol, -1); |
- strPrintf(pSql, ", 0, "); /* Set ota_control to 0 for an insert */ |
- strPrintfArray(pSql, ", ", "NULL", azCol, -1); |
- strPrintf(pSql, " FROM aux.%Q AS n WHERE NOT EXISTS (\n", zTab); |
- strPrintf(pSql, " SELECT 1 FROM ", zTab); |
- strPrintf(pSql, " main.%Q AS o WHERE ", zTab); |
- strPrintfArray(pSql, " AND ", "(n.%Q IS o.%Q)", azCol, nPK); |
- strPrintf(pSql, "\n)"); |
- |
- /* Deleted rows: */ |
- strPrintf(pSql, "\nUNION ALL\nSELECT "); |
- strPrintfArray(pSql, ", ", "%s", azCol, nPK); |
- if( azCol[nPK] ){ |
- strPrintf(pSql, ", "); |
- strPrintfArray(pSql, ", ", "NULL", &azCol[nPK], -1); |
- } |
- strPrintf(pSql, ", 1, "); /* Set ota_control to 1 for a delete */ |
- strPrintfArray(pSql, ", ", "NULL", azCol, -1); |
- strPrintf(pSql, " FROM main.%Q AS n WHERE NOT EXISTS (\n", zTab); |
- strPrintf(pSql, " SELECT 1 FROM ", zTab); |
- strPrintf(pSql, " aux.%Q AS o WHERE ", zTab); |
- strPrintfArray(pSql, " AND ", "(n.%Q IS o.%Q)", azCol, nPK); |
- strPrintf(pSql, "\n) "); |
- |
- /* Updated rows. If all table columns are part of the primary key, there |
- ** can be no updates. In this case this part of the compound SELECT can |
- ** be omitted altogether. */ |
- if( azCol[nPK] ){ |
- strPrintf(pSql, "\nUNION ALL\nSELECT "); |
- strPrintfArray(pSql, ", ", "n.%s", azCol, nPK); |
- strPrintf(pSql, ",\n"); |
- strPrintfArray(pSql, " ,\n", |
- " CASE WHEN n.%s IS o.%s THEN NULL ELSE n.%s END", &azCol[nPK], -1 |
- ); |
- |
- if( bOtaRowid==0 ){ |
- strPrintf(pSql, ", '"); |
- strPrintfArray(pSql, "", ".", azCol, nPK); |
- strPrintf(pSql, "' ||\n"); |
- }else{ |
- strPrintf(pSql, ",\n"); |
- } |
- strPrintfArray(pSql, " ||\n", |
- " CASE WHEN n.%s IS o.%s THEN '.' ELSE 'x' END", &azCol[nPK], -1 |
- ); |
- strPrintf(pSql, "\nAS ota_control, "); |
- strPrintfArray(pSql, ", ", "NULL", azCol, nPK); |
- strPrintf(pSql, ",\n"); |
- strPrintfArray(pSql, " ,\n", |
- " CASE WHEN n.%s IS o.%s THEN NULL ELSE o.%s END", &azCol[nPK], -1 |
- ); |
- |
- strPrintf(pSql, "\nFROM main.%Q AS o, aux.%Q AS n\nWHERE ", zTab, zTab); |
- strPrintfArray(pSql, " AND ", "(n.%Q IS o.%Q)", azCol, nPK); |
- strPrintf(pSql, " AND ota_control LIKE '%%x%%'"); |
- } |
- |
- /* Now add an ORDER BY clause to sort everything by PK. */ |
- strPrintf(pSql, "\nORDER BY "); |
- for(i=1; i<=nPK; i++) strPrintf(pSql, "%s%d", ((i>1)?", ":""), i); |
-} |
- |
-static void rbudiff_one_table(const char *zTab, FILE *out){ |
- int bOtaRowid; /* True to use an ota_rowid column */ |
- int nPK; /* Number of primary key columns in table */ |
- char **azCol; /* NULL terminated array of col names */ |
- int i; |
- int nCol; |
- Str ct = {0, 0, 0}; /* The "CREATE TABLE data_xxx" statement */ |
- Str sql = {0, 0, 0}; /* Query to find differences */ |
- Str insert = {0, 0, 0}; /* First part of output INSERT statement */ |
- sqlite3_stmt *pStmt = 0; |
- |
- /* --rbu mode must use real primary keys. */ |
- g.bSchemaPK = 1; |
- |
- /* Check that the schemas of the two tables match. Exit early otherwise. */ |
- checkSchemasMatch(zTab); |
- |
- /* Grab the column names and PK details for the table(s). If no usable PK |
- ** columns are found, bail out early. */ |
- azCol = columnNames("main", zTab, &nPK, &bOtaRowid); |
- if( azCol==0 ){ |
- runtimeError("table %s has no usable PK columns", zTab); |
- } |
- for(nCol=0; azCol[nCol]; nCol++); |
- |
- /* Build and output the CREATE TABLE statement for the data_xxx table */ |
- strPrintf(&ct, "CREATE TABLE IF NOT EXISTS 'data_%q'(", zTab); |
- if( bOtaRowid ) strPrintf(&ct, "rbu_rowid, "); |
- strPrintfArray(&ct, ", ", "%s", &azCol[bOtaRowid], -1); |
- strPrintf(&ct, ", rbu_control);"); |
- |
- /* Get the SQL for the query to retrieve data from the two databases */ |
- getRbudiffQuery(zTab, azCol, nPK, bOtaRowid, &sql); |
- |
- /* Build the first part of the INSERT statement output for each row |
- ** in the data_xxx table. */ |
- strPrintf(&insert, "INSERT INTO 'data_%q' (", zTab); |
- if( bOtaRowid ) strPrintf(&insert, "rbu_rowid, "); |
- strPrintfArray(&insert, ", ", "%s", &azCol[bOtaRowid], -1); |
- strPrintf(&insert, ", rbu_control) VALUES("); |
- |
- pStmt = db_prepare("%s", sql.z); |
- |
- while( sqlite3_step(pStmt)==SQLITE_ROW ){ |
- |
- /* If this is the first row output, print out the CREATE TABLE |
- ** statement first. And then set ct.z to NULL so that it is not |
- ** printed again. */ |
- if( ct.z ){ |
- fprintf(out, "%s\n", ct.z); |
- strFree(&ct); |
- } |
- |
- /* Output the first part of the INSERT statement */ |
- fprintf(out, "%s", insert.z); |
- |
- if( sqlite3_column_type(pStmt, nCol)==SQLITE_INTEGER ){ |
- for(i=0; i<=nCol; i++){ |
- if( i>0 ) fprintf(out, ", "); |
- printQuoted(out, sqlite3_column_value(pStmt, i)); |
- } |
- }else{ |
- char *zOtaControl; |
- int nOtaControl = sqlite3_column_bytes(pStmt, nCol); |
- |
- zOtaControl = (char*)sqlite3_malloc(nOtaControl); |
- memcpy(zOtaControl, sqlite3_column_text(pStmt, nCol), nOtaControl+1); |
- |
- for(i=0; i<nCol; i++){ |
- int bDone = 0; |
- if( i>=nPK |
- && sqlite3_column_type(pStmt, i)==SQLITE_BLOB |
- && sqlite3_column_type(pStmt, nCol+1+i)==SQLITE_BLOB |
- ){ |
- const char *aSrc = sqlite3_column_blob(pStmt, nCol+1+i); |
- int nSrc = sqlite3_column_bytes(pStmt, nCol+1+i); |
- const char *aFinal = sqlite3_column_blob(pStmt, i); |
- int nFinal = sqlite3_column_bytes(pStmt, i); |
- char *aDelta; |
- int nDelta; |
- |
- aDelta = sqlite3_malloc(nFinal + 60); |
- nDelta = rbuDeltaCreate(aSrc, nSrc, aFinal, nFinal, aDelta); |
- if( nDelta<nFinal ){ |
- int j; |
- fprintf(out, "x'"); |
- for(j=0; j<nDelta; j++) fprintf(out, "%02x", (u8)aDelta[j]); |
- fprintf(out, "'"); |
- zOtaControl[i-bOtaRowid] = 'f'; |
- bDone = 1; |
- } |
- sqlite3_free(aDelta); |
- } |
- |
- if( bDone==0 ){ |
- printQuoted(out, sqlite3_column_value(pStmt, i)); |
- } |
- fprintf(out, ", "); |
- } |
- fprintf(out, "'%s'", zOtaControl); |
- sqlite3_free(zOtaControl); |
- } |
- |
- /* And the closing bracket of the insert statement */ |
- fprintf(out, ");\n"); |
- } |
- |
- sqlite3_finalize(pStmt); |
- |
- strFree(&ct); |
- strFree(&sql); |
- strFree(&insert); |
-} |
- |
-/* |
-** Display a summary of differences between two versions of the same |
-** table table. |
-** |
-** * Number of rows changed |
-** * Number of rows added |
-** * Number of rows deleted |
-** * Number of identical rows |
-*/ |
-static void summarize_one_table(const char *zTab, FILE *out){ |
- char *zId = safeId(zTab); /* Name of table (translated for us in SQL) */ |
- char **az = 0; /* Columns in main */ |
- char **az2 = 0; /* Columns in aux */ |
- int nPk; /* Primary key columns in main */ |
- int nPk2; /* Primary key columns in aux */ |
- int n = 0; /* Number of columns in main */ |
- int n2; /* Number of columns in aux */ |
- int i; /* Loop counter */ |
- const char *zSep; /* Separator string */ |
- Str sql; /* Comparison query */ |
- sqlite3_stmt *pStmt; /* Query statement to do the diff */ |
- sqlite3_int64 nUpdate; /* Number of updated rows */ |
- sqlite3_int64 nUnchanged; /* Number of unmodified rows */ |
- sqlite3_int64 nDelete; /* Number of deleted rows */ |
- sqlite3_int64 nInsert; /* Number of inserted rows */ |
- |
- strInit(&sql); |
- if( sqlite3_table_column_metadata(g.db,"aux",zTab,0,0,0,0,0,0) ){ |
- if( !sqlite3_table_column_metadata(g.db,"main",zTab,0,0,0,0,0,0) ){ |
- /* Table missing from second database. */ |
- fprintf(out, "%s: missing from second database\n", zTab); |
- } |
- goto end_summarize_one_table; |
- } |
- |
- if( sqlite3_table_column_metadata(g.db,"main",zTab,0,0,0,0,0,0) ){ |
- /* Table missing from source */ |
- fprintf(out, "%s: missing from first database\n", zTab); |
- goto end_summarize_one_table; |
- } |
- |
- az = columnNames("main", zTab, &nPk, 0); |
- az2 = columnNames("aux", zTab, &nPk2, 0); |
- if( az && az2 ){ |
- for(n=0; az[n]; n++){ |
- if( sqlite3_stricmp(az[n],az2[n])!=0 ) break; |
- } |
- } |
- if( az==0 |
- || az2==0 |
- || nPk!=nPk2 |
- || az[n] |
- ){ |
- /* Schema mismatch */ |
- fprintf(out, "%s: incompatible schema\n", zTab); |
- goto end_summarize_one_table; |
- } |
- |
- /* Build the comparison query */ |
- for(n2=n; az[n2]; n2++){} |
- strPrintf(&sql, "SELECT 1, count(*)"); |
- if( n2==nPk2 ){ |
- strPrintf(&sql, ", 0\n"); |
- }else{ |
- zSep = ", sum("; |
- for(i=nPk; az[i]; i++){ |
- strPrintf(&sql, "%sA.%s IS NOT B.%s", zSep, az[i], az[i]); |
- zSep = " OR "; |
- } |
- strPrintf(&sql, ")\n"); |
- } |
- strPrintf(&sql, " FROM main.%s A, aux.%s B\n", zId, zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, " UNION ALL\n"); |
- strPrintf(&sql, "SELECT 2, count(*), 0\n"); |
- strPrintf(&sql, " FROM main.%s A\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM aux.%s B ", zId); |
- zSep = "WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n"); |
- strPrintf(&sql, " UNION ALL\n"); |
- strPrintf(&sql, "SELECT 3, count(*), 0\n"); |
- strPrintf(&sql, " FROM aux.%s B\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM main.%s A ", zId); |
- zSep = "WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, az[i], az[i]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n ORDER BY 1;\n"); |
- |
- if( (g.fDebug & DEBUG_DIFF_SQL)!=0 ){ |
- printf("SQL for %s:\n%s\n", zId, sql.z); |
- goto end_summarize_one_table; |
- } |
- |
- /* Run the query and output difference summary */ |
- pStmt = db_prepare(sql.z); |
- nUpdate = 0; |
- nInsert = 0; |
- nDelete = 0; |
- nUnchanged = 0; |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- switch( sqlite3_column_int(pStmt,0) ){ |
- case 1: |
- nUpdate = sqlite3_column_int64(pStmt,2); |
- nUnchanged = sqlite3_column_int64(pStmt,1) - nUpdate; |
- break; |
- case 2: |
- nDelete = sqlite3_column_int64(pStmt,1); |
- break; |
- case 3: |
- nInsert = sqlite3_column_int64(pStmt,1); |
- break; |
- } |
- } |
- sqlite3_finalize(pStmt); |
- fprintf(out, "%s: %lld changes, %lld inserts, %lld deletes, %lld unchanged\n", |
- zTab, nUpdate, nInsert, nDelete, nUnchanged); |
- |
-end_summarize_one_table: |
- strFree(&sql); |
- sqlite3_free(zId); |
- namelistFree(az); |
- namelistFree(az2); |
- return; |
-} |
- |
-/* |
-** Write a 64-bit signed integer as a varint onto out |
-*/ |
-static void putsVarint(FILE *out, sqlite3_uint64 v){ |
- int i, n; |
- unsigned char p[12]; |
- if( v & (((sqlite3_uint64)0xff000000)<<32) ){ |
- p[8] = (unsigned char)v; |
- v >>= 8; |
- for(i=7; i>=0; i--){ |
- p[i] = (unsigned char)((v & 0x7f) | 0x80); |
- v >>= 7; |
- } |
- fwrite(p, 8, 1, out); |
- }else{ |
- n = 9; |
- do{ |
- p[n--] = (unsigned char)((v & 0x7f) | 0x80); |
- v >>= 7; |
- }while( v!=0 ); |
- p[9] &= 0x7f; |
- fwrite(p+n+1, 9-n, 1, out); |
- } |
-} |
- |
-/* |
-** Write an SQLite value onto out. |
-*/ |
-static void putValue(FILE *out, sqlite3_value *pVal){ |
- int iDType = sqlite3_value_type(pVal); |
- sqlite3_int64 iX; |
- double rX; |
- sqlite3_uint64 uX; |
- int j; |
- |
- putc(iDType, out); |
- switch( iDType ){ |
- case SQLITE_INTEGER: |
- iX = sqlite3_value_int64(pVal); |
- memcpy(&uX, &iX, 8); |
- for(j=56; j>=0; j-=8) putc((uX>>j)&0xff, out); |
- break; |
- case SQLITE_FLOAT: |
- rX = sqlite3_value_double(pVal); |
- memcpy(&uX, &rX, 8); |
- for(j=56; j>=0; j-=8) putc((uX>>j)&0xff, out); |
- break; |
- case SQLITE_TEXT: |
- iX = sqlite3_value_bytes(pVal); |
- putsVarint(out, (sqlite3_uint64)iX); |
- fwrite(sqlite3_value_text(pVal),1,(size_t)iX,out); |
- break; |
- case SQLITE_BLOB: |
- iX = sqlite3_value_bytes(pVal); |
- putsVarint(out, (sqlite3_uint64)iX); |
- fwrite(sqlite3_value_blob(pVal),1,(size_t)iX,out); |
- break; |
- case SQLITE_NULL: |
- break; |
- } |
-} |
- |
-/* |
-** Generate a CHANGESET for all differences from main.zTab to aux.zTab. |
-*/ |
-static void changeset_one_table(const char *zTab, FILE *out){ |
- sqlite3_stmt *pStmt; /* SQL statment */ |
- char *zId = safeId(zTab); /* Escaped name of the table */ |
- char **azCol = 0; /* List of escaped column names */ |
- int nCol = 0; /* Number of columns */ |
- int *aiFlg = 0; /* 0 if column is not part of PK */ |
- int *aiPk = 0; /* Column numbers for each PK column */ |
- int nPk = 0; /* Number of PRIMARY KEY columns */ |
- Str sql; /* SQL for the diff query */ |
- int i, k; /* Loop counters */ |
- const char *zSep; /* List separator */ |
- |
- /* Check that the schemas of the two tables match. Exit early otherwise. */ |
- checkSchemasMatch(zTab); |
- |
- pStmt = db_prepare("PRAGMA main.table_info=%Q", zTab); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- nCol++; |
- azCol = sqlite3_realloc(azCol, sizeof(char*)*nCol); |
- if( azCol==0 ) runtimeError("out of memory"); |
- aiFlg = sqlite3_realloc(aiFlg, sizeof(int)*nCol); |
- if( aiFlg==0 ) runtimeError("out of memory"); |
- azCol[nCol-1] = safeId((const char*)sqlite3_column_text(pStmt,1)); |
- aiFlg[nCol-1] = i = sqlite3_column_int(pStmt,5); |
- if( i>0 ){ |
- if( i>nPk ){ |
- nPk = i; |
- aiPk = sqlite3_realloc(aiPk, sizeof(int)*nPk); |
- if( aiPk==0 ) runtimeError("out of memory"); |
- } |
- aiPk[i-1] = nCol-1; |
- } |
- } |
- sqlite3_finalize(pStmt); |
- if( nPk==0 ) goto end_changeset_one_table; |
- strInit(&sql); |
- if( nCol>nPk ){ |
- strPrintf(&sql, "SELECT %d", SQLITE_UPDATE); |
- for(i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- strPrintf(&sql, ",\n A.%s", azCol[i]); |
- }else{ |
- strPrintf(&sql, ",\n A.%s IS NOT B.%s, A.%s, B.%s", |
- azCol[i], azCol[i], azCol[i], azCol[i]); |
- } |
- } |
- strPrintf(&sql,"\n FROM main.%s A, aux.%s B\n", zId, zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, azCol[aiPk[i]], azCol[aiPk[i]]); |
- zSep = " AND"; |
- } |
- zSep = "\n AND ("; |
- for(i=0; i<nCol; i++){ |
- if( aiFlg[i] ) continue; |
- strPrintf(&sql, "%sA.%s IS NOT B.%s", zSep, azCol[i], azCol[i]); |
- zSep = " OR\n "; |
- } |
- strPrintf(&sql,")\n UNION ALL\n"); |
- } |
- strPrintf(&sql, "SELECT %d", SQLITE_DELETE); |
- for(i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- strPrintf(&sql, ",\n A.%s", azCol[i]); |
- }else{ |
- strPrintf(&sql, ",\n 1, A.%s, NULL", azCol[i]); |
- } |
- } |
- strPrintf(&sql, "\n FROM main.%s A\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM aux.%s B\n", zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, azCol[aiPk[i]], azCol[aiPk[i]]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n UNION ALL\n"); |
- strPrintf(&sql, "SELECT %d", SQLITE_INSERT); |
- for(i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- strPrintf(&sql, ",\n B.%s", azCol[i]); |
- }else{ |
- strPrintf(&sql, ",\n 1, NULL, B.%s", azCol[i]); |
- } |
- } |
- strPrintf(&sql, "\n FROM aux.%s B\n", zId); |
- strPrintf(&sql, " WHERE NOT EXISTS(SELECT 1 FROM main.%s A\n", zId); |
- zSep = " WHERE"; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s A.%s=B.%s", zSep, azCol[aiPk[i]], azCol[aiPk[i]]); |
- zSep = " AND"; |
- } |
- strPrintf(&sql, ")\n"); |
- strPrintf(&sql, " ORDER BY"); |
- zSep = " "; |
- for(i=0; i<nPk; i++){ |
- strPrintf(&sql, "%s %d", zSep, aiPk[i]+2); |
- zSep = ","; |
- } |
- strPrintf(&sql, ";\n"); |
- |
- if( g.fDebug & DEBUG_DIFF_SQL ){ |
- printf("SQL for %s:\n%s\n", zId, sql.z); |
- goto end_changeset_one_table; |
- } |
- |
- putc('T', out); |
- putsVarint(out, (sqlite3_uint64)nCol); |
- for(i=0; i<nCol; i++) putc(aiFlg[i]!=0, out); |
- fwrite(zTab, 1, strlen(zTab), out); |
- putc(0, out); |
- |
- pStmt = db_prepare("%s", sql.z); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- int iType = sqlite3_column_int(pStmt,0); |
- putc(iType, out); |
- putc(0, out); |
- switch( sqlite3_column_int(pStmt,0) ){ |
- case SQLITE_UPDATE: { |
- for(k=1, i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- putValue(out, sqlite3_column_value(pStmt,k)); |
- k++; |
- }else if( sqlite3_column_int(pStmt,k) ){ |
- putValue(out, sqlite3_column_value(pStmt,k+1)); |
- k += 3; |
- }else{ |
- putc(0, out); |
- k += 3; |
- } |
- } |
- for(k=1, i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- putc(0, out); |
- k++; |
- }else if( sqlite3_column_int(pStmt,k) ){ |
- putValue(out, sqlite3_column_value(pStmt,k+2)); |
- k += 3; |
- }else{ |
- putc(0, out); |
- k += 3; |
- } |
- } |
- break; |
- } |
- case SQLITE_INSERT: { |
- for(k=1, i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- putValue(out, sqlite3_column_value(pStmt,k)); |
- k++; |
- }else{ |
- putValue(out, sqlite3_column_value(pStmt,k+2)); |
- k += 3; |
- } |
- } |
- break; |
- } |
- case SQLITE_DELETE: { |
- for(k=1, i=0; i<nCol; i++){ |
- if( aiFlg[i] ){ |
- putValue(out, sqlite3_column_value(pStmt,k)); |
- k++; |
- }else{ |
- putValue(out, sqlite3_column_value(pStmt,k+1)); |
- k += 3; |
- } |
- } |
- break; |
- } |
- } |
- } |
- sqlite3_finalize(pStmt); |
- |
-end_changeset_one_table: |
- while( nCol>0 ) sqlite3_free(azCol[--nCol]); |
- sqlite3_free(azCol); |
- sqlite3_free(aiPk); |
- sqlite3_free(zId); |
-} |
- |
-/* |
-** Print sketchy documentation for this utility program |
-*/ |
-static void showHelp(void){ |
- printf("Usage: %s [options] DB1 DB2\n", g.zArgv0); |
- printf( |
-"Output SQL text that would transform DB1 into DB2.\n" |
-"Options:\n" |
-" --changeset FILE Write a CHANGESET into FILE\n" |
-" -L|--lib LIBRARY Load an SQLite extension library\n" |
-" --primarykey Use schema-defined PRIMARY KEYs\n" |
-" --rbu Output SQL to create/populate RBU table(s)\n" |
-" --schema Show only differences in the schema\n" |
-" --summary Show only a summary of the differences\n" |
-" --table TAB Show only differences in table TAB\n" |
-" --transaction Show SQL output inside a transaction\n" |
- ); |
-} |
- |
-int main(int argc, char **argv){ |
- const char *zDb1 = 0; |
- const char *zDb2 = 0; |
- int i; |
- int rc; |
- char *zErrMsg = 0; |
- char *zSql; |
- sqlite3_stmt *pStmt; |
- char *zTab = 0; |
- FILE *out = stdout; |
- void (*xDiff)(const char*,FILE*) = diff_one_table; |
- int nExt = 0; |
- char **azExt = 0; |
- int useTransaction = 0; |
- int neverUseTransaction = 0; |
- |
- g.zArgv0 = argv[0]; |
- sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); |
- for(i=1; i<argc; i++){ |
- const char *z = argv[i]; |
- if( z[0]=='-' ){ |
- z++; |
- if( z[0]=='-' ) z++; |
- if( strcmp(z,"changeset")==0 ){ |
- if( i==argc-1 ) cmdlineError("missing argument to %s", argv[i]); |
- out = fopen(argv[++i], "wb"); |
- if( out==0 ) cmdlineError("cannot open: %s", argv[i]); |
- xDiff = changeset_one_table; |
- neverUseTransaction = 1; |
- }else |
- if( strcmp(z,"debug")==0 ){ |
- if( i==argc-1 ) cmdlineError("missing argument to %s", argv[i]); |
- g.fDebug = strtol(argv[++i], 0, 0); |
- }else |
- if( strcmp(z,"help")==0 ){ |
- showHelp(); |
- return 0; |
- }else |
-#ifndef SQLITE_OMIT_LOAD_EXTENSION |
- if( strcmp(z,"lib")==0 || strcmp(z,"L")==0 ){ |
- if( i==argc-1 ) cmdlineError("missing argument to %s", argv[i]); |
- azExt = realloc(azExt, sizeof(azExt[0])*(nExt+1)); |
- if( azExt==0 ) cmdlineError("out of memory"); |
- azExt[nExt++] = argv[++i]; |
- }else |
-#endif |
- if( strcmp(z,"primarykey")==0 ){ |
- g.bSchemaPK = 1; |
- }else |
- if( strcmp(z,"rbu")==0 ){ |
- xDiff = rbudiff_one_table; |
- }else |
- if( strcmp(z,"schema")==0 ){ |
- g.bSchemaOnly = 1; |
- }else |
- if( strcmp(z,"summary")==0 ){ |
- xDiff = summarize_one_table; |
- }else |
- if( strcmp(z,"table")==0 ){ |
- if( i==argc-1 ) cmdlineError("missing argument to %s", argv[i]); |
- zTab = argv[++i]; |
- }else |
- if( strcmp(z,"transaction")==0 ){ |
- useTransaction = 1; |
- }else |
- { |
- cmdlineError("unknown option: %s", argv[i]); |
- } |
- }else if( zDb1==0 ){ |
- zDb1 = argv[i]; |
- }else if( zDb2==0 ){ |
- zDb2 = argv[i]; |
- }else{ |
- cmdlineError("unknown argument: %s", argv[i]); |
- } |
- } |
- if( zDb2==0 ){ |
- cmdlineError("two database arguments required"); |
- } |
- rc = sqlite3_open(zDb1, &g.db); |
- if( rc ){ |
- cmdlineError("cannot open database file \"%s\"", zDb1); |
- } |
- rc = sqlite3_exec(g.db, "SELECT * FROM sqlite_master", 0, 0, &zErrMsg); |
- if( rc || zErrMsg ){ |
- cmdlineError("\"%s\" does not appear to be a valid SQLite database", zDb1); |
- } |
-#ifndef SQLITE_OMIT_LOAD_EXTENSION |
- sqlite3_enable_load_extension(g.db, 1); |
- for(i=0; i<nExt; i++){ |
- rc = sqlite3_load_extension(g.db, azExt[i], 0, &zErrMsg); |
- if( rc || zErrMsg ){ |
- cmdlineError("error loading %s: %s", azExt[i], zErrMsg); |
- } |
- } |
-#endif |
- free(azExt); |
- zSql = sqlite3_mprintf("ATTACH %Q as aux;", zDb2); |
- rc = sqlite3_exec(g.db, zSql, 0, 0, &zErrMsg); |
- if( rc || zErrMsg ){ |
- cmdlineError("cannot attach database \"%s\"", zDb2); |
- } |
- rc = sqlite3_exec(g.db, "SELECT * FROM aux.sqlite_master", 0, 0, &zErrMsg); |
- if( rc || zErrMsg ){ |
- cmdlineError("\"%s\" does not appear to be a valid SQLite database", zDb2); |
- } |
- |
- if( neverUseTransaction ) useTransaction = 0; |
- if( useTransaction ) printf("BEGIN TRANSACTION;\n"); |
- if( zTab ){ |
- xDiff(zTab, out); |
- }else{ |
- /* Handle tables one by one */ |
- pStmt = db_prepare( |
- "SELECT name FROM main.sqlite_master\n" |
- " WHERE type='table' AND sql NOT LIKE 'CREATE VIRTUAL%%'\n" |
- " UNION\n" |
- "SELECT name FROM aux.sqlite_master\n" |
- " WHERE type='table' AND sql NOT LIKE 'CREATE VIRTUAL%%'\n" |
- " ORDER BY name" |
- ); |
- while( SQLITE_ROW==sqlite3_step(pStmt) ){ |
- xDiff((const char*)sqlite3_column_text(pStmt,0), out); |
- } |
- sqlite3_finalize(pStmt); |
- } |
- if( useTransaction ) printf("COMMIT;\n"); |
- |
- /* TBD: Handle trigger differences */ |
- /* TBD: Handle view differences */ |
- sqlite3_close(g.db); |
- return 0; |
-} |