/* Find or create a record the value of a column and return the id */
DBint64 id_of_with_insert(DB *db, const char *table, const char *column, const char *value, int *inserted)
{
DBStatement *select, *insert;
DBint64 id;
char sql[256];
snprintf(sql, sizeof(sql), "select id from %s where %s = ?;", table, column);
select = db_prep(db, sql);
db_bind_text(select, 1, value);
if (db_step(select) == DB_DONE) {
snprintf(sql, sizeof(sql), "insert into %s (%s) values (?);", table, column);
insert = db_prep(db, sql);
db_bind_text(insert, 1, value);
db_step(insert);
id = db_last_insert_rowid(db);
db_finalize(insert);
*inserted = TRUE;
} else {
id = db_column_int64(select, 0);
*inserted = FALSE;
}
db_finalize(select);
return id;
}
/*
** Create a new phantom with the given UUID and return its artifact ID.
*/
int content_new(const char *zUuid, int isPrivate){
int rid;
static Stmt s1, s2, s3;
assert( g.repositoryOpen );
db_begin_transaction();
if( uuid_is_shunned(zUuid) ){
db_end_transaction(0);
return 0;
}
db_static_prepare(&s1,
"INSERT INTO blob(rcvid,size,uuid,content)"
"VALUES(0,-1,:uuid,NULL)"
);
db_bind_text(&s1, ":uuid", zUuid);
db_exec(&s1);
rid = db_last_insert_rowid();
db_static_prepare(&s2,
"INSERT INTO phantom VALUES(:rid)"
);
db_bind_int(&s2, ":rid", rid);
db_exec(&s2);
if( g.markPrivate || isPrivate ){
db_multi_exec("INSERT INTO private VALUES(%d)", rid);
}else{
db_static_prepare(&s3,
"INSERT INTO unclustered VALUES(:rid)"
);
db_bind_int(&s3, ":rid", rid);
db_exec(&s3);
}
bag_insert(&contentCache.missing, rid);
db_end_transaction(0);
return rid;
}
INT32 sms_get_or_create_thread_id(DatabaseHandle* db_handle,const CHAR* address,INT64* thread_id_output)
{
INT32 result =DB_OK;
ContentValues* values = NULL;
CHAR* name = NULL;
return_val_if_fail(address&&thread_id_output, DB_ERROR);
result = sms_get_thread_id(db_handle,address,thread_id_output);
if (result == DB_OK)
return result;
values = content_values_create();
return_val_if_fail(values, DB_NOMEM);
content_values_put_string(values,SMS_THREADS_TABLE_COL_ADDRESS,address);
//query the cached name from contacts db
name = _sms_query_name_from_contacts(db_handle,address);
if (name)
{
content_values_put_string(values,SMS_THREADS_TABLE_COL_CACHED_NAME,name);
TG_FREE(name);
}
result= db_insert(db_handle,SMS_THREADS_TABLE_NAME,values);
content_values_destroy(values);
if (result==DB_OK)
*thread_id_output = db_last_insert_rowid(db_handle); //it is a skill, if the key id is auto increate id, it is the same with rowid
return result;
}
int save_character(Character *ch, const Lookup *flag_table)
{
static const int CharSaveVersion = 1;
const int maxStat = MAX_STAT;
const int maxDam = MAX_DAM;
field_map char_values[] =
{
{"version", &CharSaveVersion, SQL_INT},
{"name", &ch->name, SQL_TEXT},
{"description", &ch->description, SQL_TEXT},
{"level", &ch->level, SQL_INT},
{"sex", &ch->sex, SQL_LOOKUP, sex_table},
{"raceId", &ch->race->id, SQL_INT},
{"hit", &ch->hit, SQL_INT},
{"maxHit", &ch->maxHit, SQL_INT},
{"mana", &ch->mana, SQL_INT},
{"maxMana", &ch->maxMana, SQL_INT},
{"move", &ch->move, SQL_INT},
{"maxMove", &ch->maxMove, SQL_INT},
{"gold", &ch->gold, SQL_DOUBLE},
{"position", &ch->position, SQL_LOOKUP, position_table},
{"flags", &ch->flags, SQL_FLAG, flag_table},
{"classes", &ch->classes, SQL_CUSTOM, NULL, NULL, 0, save_char_classes},
{
"stats", &ch->stats, SQL_ARRAY, NULL, &maxStat, 0, db_save_int_array
},
{"alignment", &ch->alignment, SQL_INT},
{
"resists", &ch->resists, SQL_ARRAY, NULL, &maxDam, 0, db_save_int_array
},
{"size", &ch->size, SQL_FLOAT},
{"level", &ch->level, SQL_INT},
{0}
};
if (ch->id == 0)
{
if (sql_insert_query(char_values, "character") != SQL_OK)
{
log_data("could not insert character");
return 0;
}
ch->id = db_last_insert_rowid();
return 1;
}
else
{
if (sql_update_query(char_values, "character", ch->id) !=
SQL_OK)
{
log_data("could not update character");
return 0;
}
return 2;
}
}
/*
** Get a tagid for the given TAG. Create a new tag if necessary
** if createFlag is 1.
*/
int tag_findid(const char *zTag, int createFlag){
int id;
id = db_int(0, "SELECT tagid FROM tag WHERE tagname=%Q", zTag);
if( id==0 && createFlag ){
db_multi_exec("INSERT INTO tag(tagname) VALUES(%Q)", zTag);
id = db_last_insert_rowid();
}
return id;
}
DBint64 roles_write_entries(const gchar *id, Logbook *logbook)
{
const gchar
*ident,
*name;
gboolean
pic,
sic,
fe,
solo,
dual,
instruct,
total;
DBStatement *stmt;
ident = gtk_entry_get_text(GTK_ENTRY(logbook->roles_ident));
name = gtk_entry_get_text(GTK_ENTRY(logbook->roles_name));
pic = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_pic));
sic = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_sic));
fe = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_fe));
solo = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_solo));
dual = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_dual));
instruct = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_instruct));
total = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(logbook->roles_total));
/* Write entries to database */
if (id) {
stmt = logbook->roles_update;
db_bind_text(stmt, ROLES_WRITE_ID, id);
} else {
stmt = logbook->roles_insert;
}
db_bind_nonempty_text_else_null(stmt, ROLES_WRITE_IDENT, ident);
db_bind_nonempty_text_else_null(stmt, ROLES_WRITE_NAME, name);
db_bind_int(stmt, ROLES_WRITE_PIC, pic ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_SIC, sic ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_FE, fe ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_SOLO, solo ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_DUAL, dual ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_INSTRUCT, instruct ? 1 : 0);
db_bind_int(stmt, ROLES_WRITE_TOTAL, total ? 1 : 0);
db_stp_res_clr(stmt);
if (id) {
return 0;
} else {
return db_last_insert_rowid(logbook->db);
}
}
END_TEST
START_TEST(test_get_rowid_in_transaction)
{
db_begin_transaction();
if ( sql_exec( "insert into "DBNAME"(name,intval) values('testA', '5')") != SQLITE_OK)
{
fail( "could not insert to test table" );
}
int id = db_last_insert_rowid( );
fail_if(id == 0);
db_end_transaction();
}
/*
** Figure out what user is at the controls.
**
** (1) Use the --user and -U command-line options.
**
** (2) If the local database is open, check in VVAR.
**
** (3) Check the default user in the repository
**
** (4) Try the USER environment variable.
**
** (5) Use the first user in the USER table.
**
** The user name is stored in g.zLogin. The uid is in g.userUid.
*/
void user_select(void){
Stmt s;
if( g.userUid ) return;
if( attempt_user(g.zLogin) ) return;
if( g.localOpen && attempt_user(db_lget("default-user",0)) ) return;
if( attempt_user(db_get("default-user", 0)) ) return;
if( attempt_user(getenv("USER")) ) return;
db_prepare(&s,
"SELECT uid, login FROM user"
" WHERE login NOT IN ('anonymous','nobody','reader','developer')"
);
if( db_step(&s)==SQLITE_ROW ){
g.userUid = db_column_int(&s, 0);
g.zLogin = mprintf("%s", db_column_text(&s, 1));
}
db_finalize(&s);
if( g.userUid==0 ){
db_prepare(&s, "SELECT uid, login FROM user");
if( db_step(&s)==SQLITE_ROW ){
g.userUid = db_column_int(&s, 0);
g.zLogin = mprintf("%s", db_column_text(&s, 1));
}
db_finalize(&s);
}
if( g.userUid==0 ){
db_multi_exec(
"INSERT INTO user(login, pw, cap, info)"
"VALUES('anonymous', '', 'cfghjkmnoqw', '')"
);
g.userUid = db_last_insert_rowid();
g.zLogin = "******";
}
}
/*
** Insert an artifact into the BLOB table if it isn't there already.
** If zMark is not zero, create a cross-reference from that mark back
** to the newly inserted artifact.
**
** If saveUuid is true, then pContent is a commit record. Record its
** UUID in gg.zPrevCheckin.
*/
static int fast_insert_content(Blob *pContent, const char *zMark, int saveUuid){
Blob hash;
Blob cmpr;
int rid;
sha1sum_blob(pContent, &hash);
rid = db_int(0, "SELECT rid FROM blob WHERE uuid=%B", &hash);
if( rid==0 ){
static Stmt ins;
db_static_prepare(&ins,
"INSERT INTO blob(uuid, size, content) VALUES(:uuid, :size, :content)"
);
db_bind_text(&ins, ":uuid", blob_str(&hash));
db_bind_int(&ins, ":size", gg.nData);
blob_compress(pContent, &cmpr);
db_bind_blob(&ins, ":content", &cmpr);
db_step(&ins);
db_reset(&ins);
blob_reset(&cmpr);
rid = db_last_insert_rowid();
}
if( zMark ){
db_multi_exec(
"INSERT OR IGNORE INTO xmark(tname, trid, tuuid)"
"VALUES(%Q,%d,%B)",
zMark, rid, &hash
);
db_multi_exec(
"INSERT OR IGNORE INTO xmark(tname, trid, tuuid)"
"VALUES(%B,%d,%B)",
&hash, rid, &hash
);
}
if( saveUuid ){
fossil_free(gg.zPrevCheckin);
gg.zPrevCheckin = fossil_strdup(blob_str(&hash));
}
blob_reset(&hash);
return rid;
}
/*
** Write content into the database. Return the record ID. If the
** content is already in the database, just return the record ID.
**
** If srcId is specified, then pBlob is delta content from
** the srcId record. srcId might be a phantom.
**
** pBlob is normally uncompressed text. But if nBlob>0 then the
** pBlob value has already been compressed and nBlob is its uncompressed
** size. If nBlob>0 then zUuid must be valid.
**
** zUuid is the UUID of the artifact, if it is specified. When srcId is
** specified then zUuid must always be specified. If srcId is zero,
** and zUuid is zero then the correct zUuid is computed from pBlob.
**
** If the record already exists but is a phantom, the pBlob content
** is inserted and the phatom becomes a real record.
**
** The original content of pBlob is not disturbed. The caller continues
** to be responsible for pBlob. This routine does *not* take over
** responsibility for freeing pBlob.
*/
int content_put_ex(
Blob *pBlob, /* Content to add to the repository */
const char *zUuid, /* SHA1 hash of reconstructed pBlob */
int srcId, /* pBlob is a delta from this entry */
int nBlob, /* pBlob is compressed. Original size is this */
int isPrivate /* The content should be marked private */
){
int size;
int rid;
Stmt s1;
Blob cmpr;
Blob hash;
int markAsUnclustered = 0;
int isDephantomize = 0;
assert( g.repositoryOpen );
assert( pBlob!=0 );
assert( srcId==0 || zUuid!=0 );
if( zUuid==0 ){
assert( nBlob==0 );
sha1sum_blob(pBlob, &hash);
}else{
blob_init(&hash, zUuid, -1);
}
if( nBlob ){
size = nBlob;
}else{
size = blob_size(pBlob);
if( srcId ){
size = delta_output_size(blob_buffer(pBlob), size);
}
}
db_begin_transaction();
/* Check to see if the entry already exists and if it does whether
** or not the entry is a phantom
*/
db_prepare(&s1, "SELECT rid, size FROM blob WHERE uuid=%B", &hash);
if( db_step(&s1)==SQLITE_ROW ){
rid = db_column_int(&s1, 0);
if( db_column_int(&s1, 1)>=0 || pBlob==0 ){
/* Either the entry is not a phantom or it is a phantom but we
** have no data with which to dephantomize it. In either case,
** there is nothing for us to do other than return the RID. */
db_finalize(&s1);
db_end_transaction(0);
return rid;
}
}else{
rid = 0; /* No entry with the same UUID currently exists */
markAsUnclustered = 1;
}
db_finalize(&s1);
/* Construct a received-from ID if we do not already have one */
if( g.rcvid==0 ){
db_multi_exec(
"INSERT INTO rcvfrom(uid, mtime, nonce, ipaddr)"
"VALUES(%d, julianday('now'), %Q, %Q)",
g.userUid, g.zNonce, g.zIpAddr
);
g.rcvid = db_last_insert_rowid();
}
if( nBlob ){
cmpr = pBlob[0];
}else{
blob_compress(pBlob, &cmpr);
}
if( rid>0 ){
/* We are just adding data to a phantom */
db_prepare(&s1,
"UPDATE blob SET rcvid=%d, size=%d, content=:data WHERE rid=%d",
g.rcvid, size, rid
);
db_bind_blob(&s1, ":data", &cmpr);
db_exec(&s1);
db_multi_exec("DELETE FROM phantom WHERE rid=%d", rid);
if( srcId==0 || content_is_available(srcId) ){
isDephantomize = 1;
content_mark_available(rid);
}
}else{
/* We are creating a new entry */
db_prepare(&s1,
"INSERT INTO blob(rcvid,size,uuid,content)"
"VALUES(%d,%d,'%b',:data)",
g.rcvid, size, &hash
);
db_bind_blob(&s1, ":data", &cmpr);
db_exec(&s1);
rid = db_last_insert_rowid();
if( !pBlob ){
db_multi_exec("INSERT OR IGNORE INTO phantom VALUES(%d)", rid);
}
if( g.markPrivate || isPrivate ){
db_multi_exec("INSERT INTO private VALUES(%d)", rid);
markAsUnclustered = 0;
}
}
if( nBlob==0 ) blob_reset(&cmpr);
/* If the srcId is specified, then the data we just added is
** really a delta. Record this fact in the delta table.
*/
if( srcId ){
db_multi_exec("REPLACE INTO delta(rid,srcid) VALUES(%d,%d)", rid, srcId);
}
if( !isDephantomize && bag_find(&contentCache.missing, rid) &&
(srcId==0 || content_is_available(srcId)) ){
content_mark_available(rid);
}
if( isDephantomize ){
after_dephantomize(rid, 0);
}
/* Add the element to the unclustered table if has never been
** previously seen.
*/
if( markAsUnclustered ){
db_multi_exec("INSERT OR IGNORE INTO unclustered VALUES(%d)", rid);
}
/* Finish the transaction and cleanup */
db_finalize(&s1);
db_end_transaction(0);
blob_reset(&hash);
/* Make arrangements to verify that the data can be recovered
** before we commit */
verify_before_commit(rid);
return rid;
}
/*
** COMMAND: merge
**
** Usage: %fossil merge ?OPTIONS? ?VERSION?
**
** The argument VERSION is a version that should be merged into the
** current checkout. All changes from VERSION back to the nearest
** common ancestor are merged. Except, if either of the --cherrypick or
** --backout options are used only the changes associated with the
** single check-in VERSION are merged. The --backout option causes
** the changes associated with VERSION to be removed from the current
** checkout rather than added.
**
** If the VERSION argument is omitted, then Fossil attempts to find
** a recent fork on the current branch to merge.
**
** Only file content is merged. The result continues to use the
** file and directory names from the current checkout even if those
** names might have been changed in the branch being merged in.
**
** Other options:
**
** --baseline BASELINE Use BASELINE as the "pivot" of the merge instead
** of the nearest common ancestor. This allows
** a sequence of changes in a branch to be merged
** without having to merge the entire branch.
**
** --binary GLOBPATTERN Treat files that match GLOBPATTERN as binary
** and do not try to merge parallel changes. This
** option overrides the "binary-glob" setting.
**
** --case-sensitive BOOL Override the case-sensitive setting. If false,
** files whose names differ only in case are taken
** to be the same file.
**
** -f|--force Force the merge even if it would be a no-op.
**
** --force-missing Force the merge even if there is missing content.
**
** --integrate Merged branch will be closed when committing.
**
** -n|--dry-run If given, display instead of run actions
**
** -v|--verbose Show additional details of the merge
*/
void merge_cmd(void){
int vid; /* Current version "V" */
int mid; /* Version we are merging from "M" */
int pid; /* The pivot version - most recent common ancestor P */
int verboseFlag; /* True if the -v|--verbose option is present */
int integrateFlag; /* True if the --integrate option is present */
int pickFlag; /* True if the --cherrypick option is present */
int backoutFlag; /* True if the --backout option is present */
int dryRunFlag; /* True if the --dry-run or -n option is present */
int forceFlag; /* True if the --force or -f option is present */
int forceMissingFlag; /* True if the --force-missing option is present */
const char *zBinGlob; /* The value of --binary */
const char *zPivot; /* The value of --baseline */
int debugFlag; /* True if --debug is present */
int nChng; /* Number of file name changes */
int *aChng; /* An array of file name changes */
int i; /* Loop counter */
int nConflict = 0; /* Number of conflicts seen */
int nOverwrite = 0; /* Number of unmanaged files overwritten */
Stmt q;
/* Notation:
**
** V The current checkout
** M The version being merged in
** P The "pivot" - the most recent common ancestor of V and M.
*/
undo_capture_command_line();
verboseFlag = find_option("verbose","v",0)!=0;
forceMissingFlag = find_option("force-missing",0,0)!=0;
if( !verboseFlag ){
verboseFlag = find_option("detail",0,0)!=0; /* deprecated */
}
pickFlag = find_option("cherrypick",0,0)!=0;
integrateFlag = find_option("integrate",0,0)!=0;
backoutFlag = find_option("backout",0,0)!=0;
debugFlag = find_option("debug",0,0)!=0;
zBinGlob = find_option("binary",0,1);
dryRunFlag = find_option("dry-run","n",0)!=0;
if( !dryRunFlag ){
dryRunFlag = find_option("nochange",0,0)!=0; /* deprecated */
}
forceFlag = find_option("force","f",0)!=0;
zPivot = find_option("baseline",0,1);
verify_all_options();
db_must_be_within_tree();
if( zBinGlob==0 ) zBinGlob = db_get("binary-glob",0);
vid = db_lget_int("checkout", 0);
if( vid==0 ){
fossil_fatal("nothing is checked out");
}
/* Find mid, the artifactID of the version to be merged into the current
** check-out */
if( g.argc==3 ){
/* Mid is specified as an argument on the command-line */
mid = name_to_typed_rid(g.argv[2], "ci");
if( mid==0 || !is_a_version(mid) ){
fossil_fatal("not a version: %s", g.argv[2]);
}
}else if( g.argc==2 ){
/* No version specified on the command-line so pick the most recent
** leaf that is (1) not the version currently checked out and (2)
** has not already been merged into the current checkout and (3)
** the leaf is not closed and (4) the leaf is in the same branch
** as the current checkout.
*/
Stmt q;
if( pickFlag || backoutFlag || integrateFlag){
fossil_fatal("cannot use --backout, --cherrypick or --integrate with a fork merge");
}
mid = db_int(0,
"SELECT leaf.rid"
" FROM leaf, event"
" WHERE leaf.rid=event.objid"
" AND leaf.rid!=%d" /* Constraint (1) */
" AND leaf.rid NOT IN (SELECT merge FROM vmerge)" /* Constraint (2) */
" AND NOT EXISTS(SELECT 1 FROM tagxref" /* Constraint (3) */
" WHERE rid=leaf.rid"
" AND tagid=%d"
" AND tagtype>0)"
" AND (SELECT value FROM tagxref" /* Constraint (4) */
" WHERE tagid=%d AND rid=%d AND tagtype>0) ="
" (SELECT value FROM tagxref"
" WHERE tagid=%d AND rid=leaf.rid AND tagtype>0)"
" ORDER BY event.mtime DESC LIMIT 1",
vid, TAG_CLOSED, TAG_BRANCH, vid, TAG_BRANCH
);
if( mid==0 ){
fossil_fatal("no unmerged forks of branch \"%s\"",
db_text(0, "SELECT value FROM tagxref"
" WHERE tagid=%d AND rid=%d AND tagtype>0",
TAG_BRANCH, vid)
);
}
db_prepare(&q,
"SELECT blob.uuid,"
" datetime(event.mtime%s),"
" coalesce(ecomment, comment),"
" coalesce(euser, user)"
" FROM event, blob"
" WHERE event.objid=%d AND blob.rid=%d",
timeline_utc(), mid, mid
);
if( db_step(&q)==SQLITE_ROW ){
char *zCom = mprintf("Merging fork [%S] at %s by %s: \"%s\"",
db_column_text(&q, 0), db_column_text(&q, 1),
db_column_text(&q, 3), db_column_text(&q, 2));
comment_print(zCom, db_column_text(&q,2), 0, -1, g.comFmtFlags);
fossil_free(zCom);
}
db_finalize(&q);
}else{
usage("?OPTIONS? ?VERSION?");
return;
}
if( zPivot ){
pid = name_to_typed_rid(zPivot, "ci");
if( pid==0 || !is_a_version(pid) ){
fossil_fatal("not a version: %s", zPivot);
}
if( pickFlag ){
fossil_fatal("incompatible options: --cherrypick & --baseline");
}
}else if( pickFlag || backoutFlag ){
if( integrateFlag ){
fossil_fatal("incompatible options: --integrate & --cherrypick or --backout");
}
pid = db_int(0, "SELECT pid FROM plink WHERE cid=%d AND isprim", mid);
if( pid<=0 ){
fossil_fatal("cannot find an ancestor for %s", g.argv[2]);
}
}else{
pivot_set_primary(mid);
pivot_set_secondary(vid);
db_prepare(&q, "SELECT merge FROM vmerge WHERE id=0");
while( db_step(&q)==SQLITE_ROW ){
pivot_set_secondary(db_column_int(&q,0));
}
db_finalize(&q);
pid = pivot_find();
if( pid<=0 ){
fossil_fatal("cannot find a common ancestor between the current "
"checkout and %s", g.argv[2]);
}
}
if( backoutFlag ){
int t = pid;
pid = mid;
mid = t;
}
if( !is_a_version(pid) ){
fossil_fatal("not a version: record #%d", pid);
}
if( !forceFlag && mid==pid ){
fossil_print("Merge skipped because it is a no-op. "
" Use --force to override.\n");
return;
}
if( integrateFlag && !is_a_leaf(mid)){
fossil_warning("ignoring --integrate: %s is not a leaf", g.argv[2]);
integrateFlag = 0;
}
if( verboseFlag ){
print_checkin_description(mid, 12, integrateFlag?"integrate:":"merge-from:");
print_checkin_description(pid, 12, "baseline:");
}
vfile_check_signature(vid, CKSIG_ENOTFILE);
db_begin_transaction();
if( !dryRunFlag ) undo_begin();
if( load_vfile_from_rid(mid) && !forceMissingFlag ){
fossil_fatal("missing content, unable to merge");
}
if( load_vfile_from_rid(pid) && !forceMissingFlag ){
fossil_fatal("missing content, unable to merge");
}
if( debugFlag ){
char *z;
z = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", pid);
fossil_print("P=%d %z\n", pid, z);
z = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", mid);
fossil_print("M=%d %z\n", mid, z);
z = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", vid);
fossil_print("V=%d %z\n", vid, z);
}
/*
** The vfile.pathname field is used to match files against each other. The
** FV table contains one row for each each unique filename in
** in the current checkout, the pivot, and the version being merged.
*/
db_multi_exec(
"DROP TABLE IF EXISTS fv;"
"CREATE TEMP TABLE fv("
" fn TEXT PRIMARY KEY %s," /* The filename */
" idv INTEGER," /* VFILE entry for current version */
" idp INTEGER," /* VFILE entry for the pivot */
" idm INTEGER," /* VFILE entry for version merging in */
" chnged BOOLEAN," /* True if current version has been edited */
" ridv INTEGER," /* Record ID for current version */
" ridp INTEGER," /* Record ID for pivot */
" ridm INTEGER," /* Record ID for merge */
" isexe BOOLEAN," /* Execute permission enabled */
" fnp TEXT %s," /* The filename in the pivot */
" fnm TEXT %s," /* the filename in the merged version */
" islinkv BOOLEAN," /* True if current version is a symlink */
" islinkm BOOLEAN" /* True if merged version in is a symlink */
");",
filename_collation(), filename_collation(), filename_collation()
);
/* Add files found in V
*/
db_multi_exec(
"INSERT OR IGNORE"
" INTO fv(fn,fnp,fnm,idv,idp,idm,ridv,ridp,ridm,isexe,chnged)"
" SELECT pathname, pathname, pathname, id, 0, 0, rid, 0, 0, isexe, chnged "
" FROM vfile WHERE vid=%d",
vid
);
/*
** Compute name changes from P->V
*/
find_filename_changes(pid, vid, 0, &nChng, &aChng, debugFlag ? "P->V" : 0);
if( nChng ){
for(i=0; i<nChng; i++){
char *z;
z = db_text(0, "SELECT name FROM filename WHERE fnid=%d", aChng[i*2]);
db_multi_exec(
"UPDATE fv SET fnp=%Q, fnm=%Q"
" WHERE fn=(SELECT name FROM filename WHERE fnid=%d)",
z, z, aChng[i*2+1]
);
free(z);
}
fossil_free(aChng);
db_multi_exec("UPDATE fv SET fnm=fnp WHERE fnp!=fn");
}
/* Add files found in P but not in V
*/
db_multi_exec(
"INSERT OR IGNORE"
" INTO fv(fn,fnp,fnm,idv,idp,idm,ridv,ridp,ridm,isexe,chnged)"
" SELECT pathname, pathname, pathname, 0, 0, 0, 0, 0, 0, isexe, 0 "
" FROM vfile"
" WHERE vid=%d AND pathname %s NOT IN (SELECT fnp FROM fv)",
pid, filename_collation()
);
/*
** Compute name changes from P->M
*/
find_filename_changes(pid, mid, 0, &nChng, &aChng, debugFlag ? "P->M" : 0);
if( nChng ){
if( nChng>4 ) db_multi_exec("CREATE INDEX fv_fnp ON fv(fnp)");
for(i=0; i<nChng; i++){
db_multi_exec(
"UPDATE fv SET fnm=(SELECT name FROM filename WHERE fnid=%d)"
" WHERE fnp=(SELECT name FROM filename WHERE fnid=%d)",
aChng[i*2+1], aChng[i*2]
);
}
fossil_free(aChng);
}
/* Add files found in M but not in P or V.
*/
db_multi_exec(
"INSERT OR IGNORE"
" INTO fv(fn,fnp,fnm,idv,idp,idm,ridv,ridp,ridm,isexe,chnged)"
" SELECT pathname, pathname, pathname, 0, 0, 0, 0, 0, 0, isexe, 0 "
" FROM vfile"
" WHERE vid=%d"
" AND pathname %s NOT IN (SELECT fnp FROM fv UNION SELECT fnm FROM fv)",
mid, filename_collation()
);
/*
** Compute the file version ids for P and M.
*/
db_multi_exec(
"UPDATE fv SET"
" idp=coalesce((SELECT id FROM vfile WHERE vid=%d AND fnp=pathname),0),"
" ridp=coalesce((SELECT rid FROM vfile WHERE vid=%d AND fnp=pathname),0),"
" idm=coalesce((SELECT id FROM vfile WHERE vid=%d AND fnm=pathname),0),"
" ridm=coalesce((SELECT rid FROM vfile WHERE vid=%d AND fnm=pathname),0),"
" islinkv=coalesce((SELECT islink FROM vfile"
" WHERE vid=%d AND fnm=pathname),0),"
" islinkm=coalesce((SELECT islink FROM vfile"
" WHERE vid=%d AND fnm=pathname),0)",
pid, pid, mid, mid, vid, mid
);
if( debugFlag ){
db_prepare(&q,
"SELECT rowid, fn, fnp, fnm, chnged, ridv, ridp, ridm, "
" isexe, islinkv, islinkm FROM fv"
);
while( db_step(&q)==SQLITE_ROW ){
fossil_print("%3d: ridv=%-4d ridp=%-4d ridm=%-4d chnged=%d isexe=%d "
" islinkv=%d islinkm=%d\n",
db_column_int(&q, 0),
db_column_int(&q, 5),
db_column_int(&q, 6),
db_column_int(&q, 7),
db_column_int(&q, 4),
db_column_int(&q, 8),
db_column_int(&q, 9),
db_column_int(&q, 10));
fossil_print(" fn = [%s]\n", db_column_text(&q, 1));
fossil_print(" fnp = [%s]\n", db_column_text(&q, 2));
fossil_print(" fnm = [%s]\n", db_column_text(&q, 3));
}
db_finalize(&q);
}
/*
** Find files in M and V but not in P and report conflicts.
** The file in M will be ignored. It will be treated as if it
** does not exist.
*/
db_prepare(&q,
"SELECT idm FROM fv WHERE idp=0 AND idv>0 AND idm>0"
);
while( db_step(&q)==SQLITE_ROW ){
int idm = db_column_int(&q, 0);
char *zName = db_text(0, "SELECT pathname FROM vfile WHERE id=%d", idm);
fossil_warning("WARNING - no common ancestor: %s", zName);
free(zName);
db_multi_exec("UPDATE fv SET idm=0 WHERE idm=%d", idm);
}
db_finalize(&q);
/*
** Add to V files that are not in V or P but are in M
*/
db_prepare(&q,
"SELECT idm, rowid, fnm FROM fv AS x"
" WHERE idp=0 AND idv=0 AND idm>0"
);
while( db_step(&q)==SQLITE_ROW ){
int idm = db_column_int(&q, 0);
int rowid = db_column_int(&q, 1);
int idv;
const char *zName;
char *zFullName;
db_multi_exec(
"INSERT INTO vfile(vid,chnged,deleted,rid,mrid,isexe,islink,pathname)"
" SELECT %d,%d,0,rid,mrid,isexe,islink,pathname FROM vfile WHERE id=%d",
vid, integrateFlag?5:3, idm
);
idv = db_last_insert_rowid();
db_multi_exec("UPDATE fv SET idv=%d WHERE rowid=%d", idv, rowid);
zName = db_column_text(&q, 2);
zFullName = mprintf("%s%s", g.zLocalRoot, zName);
if( file_wd_isfile_or_link(zFullName) ){
fossil_print("ADDED %s (overwrites an unmanaged file)\n", zName);
nOverwrite++;
}else{
fossil_print("ADDED %s\n", zName);
}
fossil_free(zFullName);
if( !dryRunFlag ){
undo_save(zName);
vfile_to_disk(0, idm, 0, 0);
}
}
db_finalize(&q);
/*
** Find files that have changed from P->M but not P->V.
** Copy the M content over into V.
*/
db_prepare(&q,
"SELECT idv, ridm, fn, islinkm FROM fv"
" WHERE idp>0 AND idv>0 AND idm>0"
" AND ridm!=ridp AND ridv=ridp AND NOT chnged"
);
while( db_step(&q)==SQLITE_ROW ){
int idv = db_column_int(&q, 0);
int ridm = db_column_int(&q, 1);
const char *zName = db_column_text(&q, 2);
int islinkm = db_column_int(&q, 3);
/* Copy content from idm over into idv. Overwrite idv. */
fossil_print("UPDATE %s\n", zName);
if( !dryRunFlag ){
undo_save(zName);
db_multi_exec(
"UPDATE vfile SET mtime=0, mrid=%d, chnged=%d, islink=%d "
" WHERE id=%d", ridm, integrateFlag?4:2, islinkm, idv
);
vfile_to_disk(0, idv, 0, 0);
}
}
db_finalize(&q);
/*
** Do a three-way merge on files that have changes on both P->M and P->V.
*/
db_prepare(&q,
"SELECT ridm, idv, ridp, ridv, %s, fn, isexe, islinkv, islinkm FROM fv"
" WHERE idp>0 AND idv>0 AND idm>0"
" AND ridm!=ridp AND (ridv!=ridp OR chnged)",
glob_expr("fv.fn", zBinGlob)
);
while( db_step(&q)==SQLITE_ROW ){
int ridm = db_column_int(&q, 0);
int idv = db_column_int(&q, 1);
int ridp = db_column_int(&q, 2);
int ridv = db_column_int(&q, 3);
int isBinary = db_column_int(&q, 4);
const char *zName = db_column_text(&q, 5);
int isExe = db_column_int(&q, 6);
int islinkv = db_column_int(&q, 7);
int islinkm = db_column_int(&q, 8);
int rc;
char *zFullPath;
Blob m, p, r;
/* Do a 3-way merge of idp->idm into idp->idv. The results go into idv. */
if( verboseFlag ){
fossil_print("MERGE %s (pivot=%d v1=%d v2=%d)\n",
zName, ridp, ridm, ridv);
}else{
fossil_print("MERGE %s\n", zName);
}
if( islinkv || islinkm /* || file_wd_islink(zFullPath) */ ){
fossil_print("***** Cannot merge symlink %s\n", zName);
nConflict++;
}else{
undo_save(zName);
zFullPath = mprintf("%s/%s", g.zLocalRoot, zName);
content_get(ridp, &p);
content_get(ridm, &m);
if( isBinary ){
rc = -1;
blob_zero(&r);
}else{
unsigned mergeFlags = dryRunFlag ? MERGE_DRYRUN : 0;
rc = merge_3way(&p, zFullPath, &m, &r, mergeFlags);
}
if( rc>=0 ){
if( !dryRunFlag ){
blob_write_to_file(&r, zFullPath);
file_wd_setexe(zFullPath, isExe);
}
db_multi_exec("UPDATE vfile SET mtime=0 WHERE id=%d", idv);
if( rc>0 ){
fossil_print("***** %d merge conflicts in %s\n", rc, zName);
nConflict++;
}
}else{
fossil_print("***** Cannot merge binary file %s\n", zName);
nConflict++;
}
blob_reset(&p);
blob_reset(&m);
blob_reset(&r);
}
db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(%d,%d)",
idv,ridm);
}
db_finalize(&q);
/*
** Drop files that are in P and V but not in M
*/
db_prepare(&q,
"SELECT idv, fn, chnged FROM fv"
" WHERE idp>0 AND idv>0 AND idm=0"
);
while( db_step(&q)==SQLITE_ROW ){
int idv = db_column_int(&q, 0);
const char *zName = db_column_text(&q, 1);
int chnged = db_column_int(&q, 2);
/* Delete the file idv */
fossil_print("DELETE %s\n", zName);
if( chnged ){
fossil_warning("WARNING: local edits lost for %s\n", zName);
nConflict++;
}
undo_save(zName);
db_multi_exec(
"UPDATE vfile SET deleted=1 WHERE id=%d", idv
);
if( !dryRunFlag ){
char *zFullPath = mprintf("%s%s", g.zLocalRoot, zName);
file_delete(zFullPath);
free(zFullPath);
}
}
db_finalize(&q);
/*
** Rename files that have taken a rename on P->M but which keep the same
** name o P->V. If a file is renamed on P->V only or on both P->V and
** P->M then we retain the V name of the file.
*/
db_prepare(&q,
"SELECT idv, fnp, fnm FROM fv"
" WHERE idv>0 AND idp>0 AND idm>0 AND fnp=fn AND fnm!=fnp"
);
while( db_step(&q)==SQLITE_ROW ){
int idv = db_column_int(&q, 0);
const char *zOldName = db_column_text(&q, 1);
const char *zNewName = db_column_text(&q, 2);
fossil_print("RENAME %s -> %s\n", zOldName, zNewName);
undo_save(zOldName);
undo_save(zNewName);
db_multi_exec(
"UPDATE vfile SET pathname=%Q, origname=coalesce(origname,pathname)"
" WHERE id=%d AND vid=%d", zNewName, idv, vid
);
if( !dryRunFlag ){
char *zFullOldPath = mprintf("%s%s", g.zLocalRoot, zOldName);
char *zFullNewPath = mprintf("%s%s", g.zLocalRoot, zNewName);
if( file_wd_islink(zFullOldPath) ){
symlink_copy(zFullOldPath, zFullNewPath);
}else{
file_copy(zFullOldPath, zFullNewPath);
}
file_delete(zFullOldPath);
free(zFullNewPath);
free(zFullOldPath);
}
}
db_finalize(&q);
/* Report on conflicts
*/
if( nConflict ){
fossil_warning("WARNING: %d merge conflicts", nConflict);
}
if( nOverwrite ){
fossil_warning("WARNING: %d unmanaged files were overwritten",
nOverwrite);
}
if( dryRunFlag ){
fossil_warning("REMINDER: this was a dry run -"
" no files were actually changed.");
}
/*
** Clean up the mid and pid VFILE entries. Then commit the changes.
*/
db_multi_exec("DELETE FROM vfile WHERE vid!=%d", vid);
if( pickFlag ){
db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(-1,%d)",mid);
/* For a cherry-pick merge, make the default check-in comment the same
** as the check-in comment on the check-in that is being merged in. */
db_multi_exec(
"REPLACE INTO vvar(name,value)"
" SELECT 'ci-comment', coalesce(ecomment,comment) FROM event"
" WHERE type='ci' AND objid=%d",
mid
);
}else if( backoutFlag ){
db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(-2,%d)",pid);
}else if( integrateFlag ){
db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(-4,%d)",mid);
}else{
db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(0,%d)", mid);
}
undo_finish();
db_end_transaction(dryRunFlag);
}
static INT32 contact_provider_insert(ContentProvider* thiz,ContentProviderDestination dest,const CHAR* col_list,INT32 col_num, ContentValues* values)
{
ContactProvider* sub_provider =(ContactProvider*) thiz->priv_data;
const CHAR* table = NULL;
ContentValuesItor itor;
ContentValues *values_me, *values_ext;
CHAR* values_ret = NULL;
INT64 ID;
INT32 db_ret=DB_OK;
DatabaseStatement* stmt = NULL;
DatabaseHandle* db_handle = contact_base_provider_obtain_db_handle();
UINT32 t1 = db_get_ticks();
UINT32 t2 = 0;
return_val_if_fail(sub_provider&&db_handle, DB_ERROR);
switch (dest)
{
case CONTACT_PROVIDER_DESTINATION_CONTACTS:
table = CONTACT_ME_CONTACTS_TABLE_NAME;
break;
case CONTACT_PROVIDER_DESTINATION_GROUP:
table = CONTACT_ME_GROUP_TABLE_NAME;
break;
case CONTACT_PROVIDER_DESTINATION_EXTENSION_NUMBER:
table = CONTACT_EXTENSION_TABLE_NUMBER_NAME;
break;
case CONTACT_PROVIDER_DESTINATION_EXTENSION_OTHER:
table = CONTACT_EXTENSION_TABLE_OTHER_NAME;
break;
case CONTACT_PROVIDER_DESTINATION_SIM:
table = CONTACT_SIM_TABLE_NAME;
break;
}
if (CONTACT_PROVIDER_DESTINATION_CONTACTS==dest)
{
INT64 value_group_id,value_main_num_tag;
WCHAR* str_name=NULL;
values_me = content_values_create();
content_values_get_int(values,"group_id",&value_group_id);
content_values_delete_key(values,"group_id");
content_values_put_int(values_me,"group_id",value_group_id);
content_values_get_int(values,"main_num_tag",&value_main_num_tag);
content_values_delete_key(values,"main_num_tag");
content_values_put_int(values_me,"main_num_tag",value_main_num_tag);
content_values_get_string16(values,"name",&str_name);
content_values_delete_key(values,"name");
content_values_put_string_16(values_me,"name",str_name);
db_ret = db_insert(db_handle,table,values_me);
content_values_destroy(values_me);
TG_FREE(str_name);
ID = db_last_insert_rowid(db_handle);
for (itor=content_values_first(values);itor;itor=content_values_next(values,itor))
{
const CHAR* key = content_values_get_key(itor);
content_values_get_string(values,key,&values_ret);
values_ext = content_values_create();
if (0 == strcmp(key,"mobile"))
{
content_values_put_int(values_ext,"ID",ID);
content_values_put_int(values_ext,"tag_id",CONTACT_EXTENSION_TAG_MOBILE);
content_values_put_string(values_ext,"value",values_ret);
db_ret |= db_insert(db_handle,CONTACT_EXTENSION_TABLE_NUMBER_NAME,values_ext);
}
else if (0 == strcmp(key,"home"))
{
content_values_put_int(values_ext,"ID",ID);
content_values_put_int(values_ext,"tag_id",CONTACT_EXTENSION_TAG_HOME);
content_values_put_string(values_ext,"value",values_ret);
db_ret |= db_insert(db_handle,CONTACT_EXTENSION_TABLE_NUMBER_NAME,values_ext);
}
else if (0 == strcmp(key,"office"))
{
content_values_put_int(values_ext,"ID",ID);
content_values_put_int(values_ext,"tag_id",CONTACT_EXTENSION_TAG_OFFICE);
content_values_put_string(values_ext,"value",values_ret);
db_ret |= db_insert(db_handle,CONTACT_EXTENSION_TABLE_NUMBER_NAME,values_ext);
}
else if (0 == strcmp(key,"email"))
{
content_values_put_int(values_ext,"ID",ID);
content_values_put_int(values_ext,"tag_id",CONTACT_EXTENSION_TAG_EMAIL);
content_values_put_string(values_ext,"value",values_ret);
db_ret |= db_insert(db_handle,CONTACT_EXTENSION_TABLE_OTHER_NAME,values_ext);
}
content_values_destroy(values_ext);
TG_FREE(values_ret);
}
if (DB_OK == db_ret)
{
db_ret = (INT32)ID;
}
else
{
db_ret = -1;
}
}
else
{
stmt = db_stmt_build_insert_statement(db_handle,table,col_list,col_num);
return_val_if_fail(stmt, DB_ERROR);
db_ret= db_stmt_bind_content_values( stmt,(ContentValues*)values);
if (db_ret==DB_OK)
db_ret=db_stmt_step(stmt);
db_stmt_finalize(stmt);
}
contact_base_provider_release_db_handle();
t2 = db_get_ticks();
DB_PRINTF("contact_provider_insert use %d\n",t2-t1);
return db_ret;
}
/*
** Update an entry of the TICKET and TICKETCHNG tables according to the
** information in the ticket artifact given in p. Attempt to create
** the appropriate TICKET table entry if tktid is zero. If tktid is nonzero
** then it will be the ROWID of an existing TICKET entry.
**
** Parameter rid is the recordID for the ticket artifact in the BLOB table.
**
** Return the new rowid of the TICKET table entry.
*/
static int ticket_insert(const Manifest *p, int rid, int tktid){
Blob sql1, sql2, sql3;
Stmt q;
int i, j;
char *aUsed;
if( tktid==0 ){
db_multi_exec("INSERT INTO ticket(tkt_uuid, tkt_mtime) "
"VALUES(%Q, 0)", p->zTicketUuid);
tktid = db_last_insert_rowid();
}
blob_zero(&sql1);
blob_zero(&sql2);
blob_zero(&sql3);
blob_appendf(&sql1, "UPDATE OR REPLACE ticket SET tkt_mtime=:mtime");
if( haveTicketCTime ){
blob_appendf(&sql1, ", tkt_ctime=coalesce(tkt_ctime,:mtime)");
}
aUsed = fossil_malloc( nField );
memset(aUsed, 0, nField);
for(i=0; i<p->nField; i++){
const char *zName = p->aField[i].zName;
const char *zBaseName = zName[0]=='+' ? zName+1 : zName;
j = fieldId(zBaseName);
if( j<0 ) continue;
aUsed[j] = 1;
if( aField[j].mUsed & USEDBY_TICKET ){
if( zName[0]=='+' ){
zName++;
blob_appendf(&sql1,", %s=coalesce(%s,'') || %Q",
zName, zName, p->aField[i].zValue);
}else{
blob_appendf(&sql1,", %s=%Q", zName, p->aField[i].zValue);
}
}
if( aField[j].mUsed & USEDBY_TICKETCHNG ){
blob_appendf(&sql2, ",%s", zName);
blob_appendf(&sql3, ",%Q", p->aField[i].zValue);
}
if( rid>0 ){
wiki_extract_links(p->aField[i].zValue, rid, 1, p->rDate, i==0, 0);
}
}
blob_appendf(&sql1, " WHERE tkt_id=%d", tktid);
db_prepare(&q, "%s", blob_str(&sql1));
db_bind_double(&q, ":mtime", p->rDate);
db_step(&q);
db_finalize(&q);
blob_reset(&sql1);
if( blob_size(&sql2)>0 || haveTicketChngRid ){
int fromTkt = 0;
if( haveTicketChngRid ){
blob_append(&sql2, ",tkt_rid", -1);
blob_appendf(&sql3, ",%d", rid);
}
for(i=0; i<nField; i++){
if( aUsed[i]==0
&& (aField[i].mUsed & USEDBY_BOTH)==USEDBY_BOTH
){
const char *z = aField[i].zName;
if( z[0]=='+' ) z++;
fromTkt = 1;
blob_appendf(&sql2, ",%s", z);
blob_appendf(&sql3, ",%s", z);
}
}
if( fromTkt ){
db_prepare(&q, "INSERT INTO ticketchng(tkt_id,tkt_mtime%s)"
"SELECT %d,:mtime%s FROM ticket WHERE tkt_id=%d",
blob_str(&sql2), tktid, blob_str(&sql3), tktid);
}else{
db_prepare(&q, "INSERT INTO ticketchng(tkt_id,tkt_mtime%s)"
"VALUES(%d,:mtime%s)",
blob_str(&sql2), tktid, blob_str(&sql3));
}
db_bind_double(&q, ":mtime", p->rDate);
db_step(&q);
db_finalize(&q);
}
blob_reset(&sql2);
blob_reset(&sql3);
fossil_free(aUsed);
return tktid;
}
