initial commitHEADmaster

1 files changed, 725 insertions, 0 deletions

diff --git a/src/descendants.c b/src/descendants.c
new file mode 100644
index 0000000..7702b0c
--- /dev/null
+++ b/src/descendants.c
@@ -0,0 +1,725 @@
+/*
+** Copyright (c) 2007 D. Richard Hipp
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the terms of the Simplified BSD License (also
+** known as the "2-Clause License" or "FreeBSD License".)
+
+** This program is distributed in the hope that it will be useful,
+** but without any warranty; without even the implied warranty of
+** merchantability or fitness for a particular purpose.
+**
+** Author contact information:
+**   drh@hwaci.com
+**   http://www.hwaci.com/drh/
+**
+*******************************************************************************
+**
+** This file contains code used to find descendants of a version
+** or leaves of a version tree.
+*/
+#include "config.h"
+#include "descendants.h"
+#include <assert.h>
+
+
+/*
+** Create a temporary table named "leaves" if it does not
+** already exist.  Load this table with the RID of all
+** check-ins that are leaves which are descended from
+** check-in iBase.
+**
+** A "leaf" is a check-in that has no children in the same branch.
+** There is a separate permanent table LEAF that contains all leaves
+** in the tree.  This routine is used to compute a subset of that
+** table consisting of leaves that are descended from a single check-in.
+**
+** The closeMode flag determines behavior associated with the "closed"
+** tag:
+**
+**    closeMode==0       Show all leaves regardless of the "closed" tag.
+**
+**    closeMode==1       Show only leaves without the "closed" tag.
+**
+**    closeMode==2       Show only leaves with the "closed" tag.
+**
+** The default behavior is to ignore closed leaves (closeMode==0).  To
+** Show all leaves, use closeMode==1.  To show only closed leaves, use
+** closeMode==2.
+*/
+void compute_leaves(int iBase, int closeMode){
+
+  /* Create the LEAVES table if it does not already exist.  Make sure
+  ** it is empty.
+  */
+  db_multi_exec(
+    "CREATE TEMP TABLE IF NOT EXISTS leaves("
+    "  rid INTEGER PRIMARY KEY"
+    ");"
+    "DELETE FROM leaves;"
+  );
+
+  if( iBase>0 ){
+    Bag seen;     /* Descendants seen */
+    Bag pending;  /* Unpropagated descendants */
+    Stmt q1;      /* Query to find children of a check-in */
+    Stmt isBr;    /* Query to check to see if a check-in starts a new branch */
+    Stmt ins;     /* INSERT statement for a new record */
+
+    /* Initialize the bags. */
+    bag_init(&seen);
+    bag_init(&pending);
+    bag_insert(&pending, iBase);
+
+    /* This query returns all non-branch-merge children of check-in :rid.
+    **
+    ** If a child is a merge of a fork within the same branch, it is
+    ** returned.  Only merge children in different branches are excluded.
+    */
+    db_prepare(&q1,
+      "SELECT cid FROM plink"
+      " WHERE pid=:rid"
+      "   AND (isprim"
+      "        OR coalesce((SELECT value FROM tagxref"
+                        "   WHERE tagid=%d AND rid=plink.pid), 'trunk')"
+                 "=coalesce((SELECT value FROM tagxref"
+                        "   WHERE tagid=%d AND rid=plink.cid), 'trunk'))",
+      TAG_BRANCH, TAG_BRANCH
+    );
+
+    /* This query returns a single row if check-in :rid is the first
+    ** check-in of a new branch.
+    */
+    db_prepare(&isBr,
+       "SELECT 1 FROM tagxref"
+       " WHERE rid=:rid AND tagid=%d AND tagtype=2"
+       "   AND srcid>0",
+       TAG_BRANCH
+    );
+
+    /* This statement inserts check-in :rid into the LEAVES table.
+    */
+    db_prepare(&ins, "INSERT OR IGNORE INTO leaves VALUES(:rid)");
+
+    while( bag_count(&pending) ){
+      int rid = bag_first(&pending);
+      int cnt = 0;
+      bag_remove(&pending, rid);
+      db_bind_int(&q1, ":rid", rid);
+      while( db_step(&q1)==SQLITE_ROW ){
+        int cid = db_column_int(&q1, 0);
+        if( bag_insert(&seen, cid) ){
+          bag_insert(&pending, cid);
+        }
+        db_bind_int(&isBr, ":rid", cid);
+        if( db_step(&isBr)==SQLITE_DONE ){
+          cnt++;
+        }
+        db_reset(&isBr);
+      }
+      db_reset(&q1);
+      if( cnt==0 && !is_a_leaf(rid) ){
+        cnt++;
+      }
+      if( cnt==0 ){
+        db_bind_int(&ins, ":rid", rid);
+        db_step(&ins);
+        db_reset(&ins);
+      }
+    }
+    db_finalize(&ins);
+    db_finalize(&isBr);
+    db_finalize(&q1);
+    bag_clear(&pending);
+    bag_clear(&seen);
+  }else{
+    db_multi_exec(
+      "INSERT INTO leaves"
+      "  SELECT leaf.rid FROM leaf"
+    );
+  }
+  if( closeMode==1 ){
+    db_multi_exec(
+      "DELETE FROM leaves WHERE rid IN"
+      "  (SELECT leaves.rid FROM leaves, tagxref"
+      "    WHERE tagxref.rid=leaves.rid "
+      "      AND tagxref.tagid=%d"
+      "      AND tagxref.tagtype>0)",
+      TAG_CLOSED
+    );
+  }else if( closeMode==2 ){
+    db_multi_exec(
+      "DELETE FROM leaves WHERE rid NOT IN"
+      "  (SELECT leaves.rid FROM leaves, tagxref"
+      "    WHERE tagxref.rid=leaves.rid "
+      "      AND tagxref.tagid=%d"
+      "      AND tagxref.tagtype>0)",
+      TAG_CLOSED
+    );
+  }
+}
+
+/*
+** If RID refers to a check-in, return the mtime of that check-in - the
+** Julian day number of when the check-in occurred.
+*/
+double mtime_of_rid(int rid, double mtime){
+  static Stmt q;
+  db_static_prepare(&q,"SELECT mtime FROM event WHERE objid=:rid");
+  db_bind_int(&q, ":rid", rid);
+  if( db_step(&q)==SQLITE_ROW ){
+    mtime = db_column_double(&q,0);
+  }
+  db_reset(&q);
+  return mtime;
+}
+
+
+
+/*
+** Load the record ID rid and up to |N|-1 closest ancestors into
+** the "ok" table.  If N is zero, no limit.  If ridBackTo is not zero
+** then stop the search upon reaching the ancestor with rid==ridBackTo.
+*/
+void compute_ancestors(int rid, int N, int directOnly, int ridBackTo){
+  if( !N ){
+     N = -1;
+  }else if( N<0 ){
+     N = -N;
+  }
+  if( directOnly ){
+    /* Direct mode means to show primary parents only */
+    db_multi_exec(
+      "WITH RECURSIVE "
+      "  ancestor(rid, mtime) AS ("
+      "    SELECT %d, mtime FROM event WHERE objid=%d "
+      "    UNION "
+      "    SELECT plink.pid, event.mtime"
+      "      FROM ancestor, plink, event"
+      "     WHERE plink.cid=ancestor.rid"
+      "       AND event.objid=plink.pid"
+      "       AND plink.isPrim"
+      "     ORDER BY mtime DESC LIMIT %d"
+      "  )"
+      "INSERT INTO ok"
+      "  SELECT rid FROM ancestor;",
+      rid, rid, N
+    );
+  }else{
+    /* If not in directMode, also include merge parents, including
+    ** cherrypick merges.  Except, terminate searches at the cherrypick
+    ** merge parent itself.  In other words, include:
+    **    (1)  Primary parents
+    **    (2)  Merge parents
+    **    (3)  Cherrypick merge parents.
+    **    (4)  All ancestores of 1 and 2 but not of 3.
+    */
+    double rLimitMtime = 0.0;
+    if( ridBackTo ){
+      rLimitMtime = mtime_of_rid(ridBackTo, 0.0);
+    }
+    db_multi_exec(
+      "WITH RECURSIVE\n"
+      "  parent(pid,cid,isCP) AS (\n"
+      "    SELECT plink.pid, plink.cid, 0 AS xisCP FROM plink\n"
+      "    UNION ALL\n"
+      "    SELECT parentid, childid, 1 FROM cherrypick WHERE NOT isExclude\n"
+      "  ),\n"
+      "  ancestor(rid, mtime, isCP) AS (\n"
+      "    SELECT %d, mtime, 0 FROM event WHERE objid=%d\n"
+      "    UNION\n"
+      "    SELECT parent.pid, event.mtime, parent.isCP\n"
+      "      FROM ancestor, parent, event\n"
+      "     WHERE parent.cid=ancestor.rid\n"
+      "       AND event.objid=parent.pid\n"
+      "       AND NOT ancestor.isCP\n"
+      "       AND (event.mtime>=%.17g OR parent.pid=%d)\n"
+      "     ORDER BY mtime DESC LIMIT %d\n"
+      "  )\n"
+      "INSERT OR IGNORE INTO ok SELECT rid FROM ancestor;",
+      rid, rid, rLimitMtime, ridBackTo, N
+    );
+    if( ridBackTo && db_changes()>1 ){
+      db_multi_exec("INSERT OR IGNORE INTO ok VALUES(%d)", ridBackTo);
+    }
+  }
+}
+
+/*
+** Compute the youngest ancestor of record ID rid that is a member of
+** branch zBranch.
+*/
+int compute_youngest_ancestor_in_branch(int rid, const char *zBranch){
+  return db_int(0,
+    "WITH RECURSIVE "
+    "  ancestor(rid, mtime) AS ("
+    "    SELECT %d, mtime FROM event WHERE objid=%d "
+    "    UNION "
+    "    SELECT plink.pid, event.mtime"
+    "      FROM ancestor, plink, event"
+    "     WHERE plink.cid=ancestor.rid"
+    "       AND event.objid=plink.pid"
+    "     ORDER BY mtime DESC"
+    "  )"
+    "  SELECT ancestor.rid FROM ancestor"
+    "   WHERE EXISTS(SELECT 1 FROM tagxref"
+                    " WHERE tagid=%d AND tagxref.rid=ancestor.rid"
+                    "   AND value=%Q AND tagtype>0)"
+    "  ORDER BY mtime DESC"
+    "  LIMIT 1",
+    rid, rid, TAG_BRANCH, zBranch
+  );
+}
+
+/*
+** Compute all direct ancestors (merge ancestors do not count)
+** for the check-in rid and put them in a table named "ancestor".
+** Label each generation with consecutive integers going backwards
+** in time such that rid has the smallest generation number and the oldest
+** direct ancestor as the largest generation number.
+*/
+void compute_direct_ancestors(int rid){
+  db_multi_exec(
+    "CREATE TEMP TABLE IF NOT EXISTS ancestor(rid INTEGER UNIQUE NOT NULL,"
+                                            " generation INTEGER PRIMARY KEY);"
+    "DELETE FROM ancestor;"
+    "WITH RECURSIVE g(x,i) AS ("
+    "  VALUES(%d,1)"
+    "  UNION ALL"
+    "  SELECT plink.pid, g.i+1 FROM plink, g"
+    "   WHERE plink.cid=g.x AND plink.isprim)"
+    "INSERT INTO ancestor(rid,generation) SELECT x,i FROM g;",
+    rid
+  );
+}
+
+/*
+** Compute the "mtime" of the file given whose blob.rid is "fid" that
+** is part of check-in "vid".  The mtime will be the mtime on vid or
+** some ancestor of vid where fid first appears.
+*/
+int mtime_of_manifest_file(
+  int vid,       /* The check-in that contains fid */
+  int fid,       /* The id of the file whose check-in time is sought */
+  i64 *pMTime    /* Write result here */
+){
+  static int prevVid = -1;
+  static Stmt q;
+
+  if( prevVid!=vid ){
+    prevVid = vid;
+    db_multi_exec("CREATE TEMP TABLE IF NOT EXISTS ok(rid INTEGER PRIMARY KEY);"
+                  "DELETE FROM ok;");
+    compute_ancestors(vid, 100000000, 1, 0);
+  }
+  db_static_prepare(&q,
+    "SELECT (max(event.mtime)-2440587.5)*86400 FROM mlink, event"
+    " WHERE mlink.mid=event.objid"
+    "   AND +mlink.mid IN ok"
+    "   AND mlink.fid=:fid");
+  db_bind_int(&q, ":fid", fid);
+  if( db_step(&q)!=SQLITE_ROW ){
+    db_reset(&q);
+    return 1;
+  }
+  *pMTime = db_column_int64(&q, 0);
+  db_reset(&q);
+  return 0;
+}
+
+/*
+** Load the record ID rid and up to |N|-1 closest descendants into
+** the "ok" table.  If N is zero, no limit.
+*/
+void compute_descendants(int rid, int N){
+  if( !N ){
+     N = -1;
+  }else if( N<0 ){
+     N = -N;
+  }
+  db_multi_exec(
+    "WITH RECURSIVE\n"
+    "  dx(rid,mtime) AS (\n"
+    "     SELECT %d, 0\n"
+    "     UNION\n"
+    "     SELECT plink.cid, plink.mtime FROM dx, plink\n"
+    "      WHERE plink.pid=dx.rid\n"
+    "      ORDER BY 2\n"
+    "  )\n"
+    "INSERT OR IGNORE INTO ok SELECT rid FROM dx LIMIT %d",
+    rid, N
+  );
+}
+
+/*
+** COMMAND: descendants*
+**
+** Usage: %fossil descendants ?CHECKIN? ?OPTIONS?
+**
+** Find all leaf descendants of the check-in specified or if the argument
+** is omitted, of the check-in currently checked out.
+**
+** Options:
+**    -R|--repository REPO       Extract info from repository REPO
+**    -W|--width N               Width of lines (default is to auto-detect).
+**                               Must be greater than 20 or else 0 for no
+**                               limit, resulting in a one line per entry.
+**
+** See also: [[finfo]], [[info]], [[leaves]]
+*/
+void descendants_cmd(void){
+  Stmt q;
+  int base, width;
+  const char *zWidth;
+
+  db_find_and_open_repository(0,0);
+  zWidth = find_option("width","W",1);
+  if( zWidth ){
+    width = atoi(zWidth);
+    if( (width!=0) && (width<=20) ){
+      fossil_fatal("-W|--width value must be >20 or 0");
+    }
+  }else{
+    width = -1;
+  }
+
+  /* We should be done with options.. */
+  verify_all_options();
+
+  if( g.argc==2 ){
+    base = db_lget_int("checkout", 0);
+  }else{
+    base = name_to_typed_rid(g.argv[2], "ci");
+  }
+  if( base==0 ) return;
+  compute_leaves(base, 0);
+  db_prepare(&q,
+    "%s"
+    "   AND event.objid IN (SELECT rid FROM leaves)"
+    " ORDER BY event.mtime DESC",
+    timeline_query_for_tty()
+  );
+  print_timeline(&q, 0, width, 0, 0);
+  db_finalize(&q);
+}
+
+/*
+** COMMAND: leaves*
+**
+** Usage: %fossil leaves ?OPTIONS?
+**
+** Find leaves of all branches.  By default show only open leaves.
+** The -a|--all flag causes all leaves (closed and open) to be shown.
+** The -c|--closed flag shows only closed leaves.
+**
+** The --recompute flag causes the content of the "leaf" table in the
+** repository database to be recomputed.
+**
+** Options:
+**   -a|--all         Show ALL leaves
+**   --bybranch       Order output by branch name
+**   -c|--closed      Show only closed leaves
+**   -m|--multiple    Show only cases with multiple leaves on a single branch
+**   --recompute      Recompute the "leaf" table in the repository DB
+**   -W|--width N     Width of lines (default is to auto-detect). Must be
+**                    more than 39 or else 0 no limit, resulting in a single
+**                    line per entry.
+**
+** See also: [[descendants]], [[finfo]], [[info]], [[branch]]
+*/
+void leaves_cmd(void){
+  Stmt q;
+  Blob sql;
+  int showAll = find_option("all", "a", 0)!=0;
+  int showClosed = find_option("closed", "c", 0)!=0;
+  int recomputeFlag = find_option("recompute",0,0)!=0;
+  int byBranch = find_option("bybranch",0,0)!=0;
+  int multipleFlag = find_option("multiple","m",0)!=0;
+  const char *zWidth = find_option("width","W",1);
+  char *zLastBr = 0;
+  int n, width;
+  char zLineNo[10];
+  const char *zMainBranch = db_main_branch();
+
+  if( multipleFlag ) byBranch = 1;
+  if( zWidth ){
+    width = atoi(zWidth);
+    if( (width!=0) && (width<=39) ){
+      fossil_fatal("-W|--width value must be >39 or 0");
+    }
+  }else{
+    width = -1;
+  }
+  db_find_and_open_repository(0,0);
+
+  /* We should be done with options.. */
+  verify_all_options();
+
+  if( recomputeFlag ) leaf_rebuild();
+  blob_zero(&sql);
+  blob_append(&sql, timeline_query_for_tty(), -1);
+  if( !multipleFlag ){
+    /* The usual case - show all leaves */
+    blob_append_sql(&sql, " AND blob.rid IN leaf");
+  }else{
+    /* Show only leaves where two are more occur in the same branch */
+    db_multi_exec(
+      "CREATE TEMP TABLE openLeaf(rid INTEGER PRIMARY KEY);"
+      "INSERT INTO openLeaf(rid)"
+      "  SELECT rid FROM leaf"
+      "   WHERE NOT EXISTS("
+      "     SELECT 1 FROM tagxref"
+      "      WHERE tagid=%d AND tagtype>0 AND rid=leaf.rid);",
+      TAG_CLOSED
+    );
+    db_multi_exec(
+      "CREATE TEMP TABLE ambiguousBranch(brname TEXT);"
+      "INSERT INTO ambiguousBranch(brname)"
+      " SELECT (SELECT value FROM tagxref WHERE tagid=%d AND rid=openLeaf.rid)"
+      "   FROM openLeaf"
+      "  GROUP BY 1 HAVING count(*)>1;",
+      TAG_BRANCH
+    );
+    db_multi_exec(
+      "CREATE TEMP TABLE ambiguousLeaf(rid INTEGER PRIMARY KEY);\n"
+      "INSERT INTO ambiguousLeaf(rid)\n"
+      "  SELECT rid FROM openLeaf\n"
+      "   WHERE (SELECT value FROM tagxref WHERE tagid=%d AND rid=openLeaf.rid)"
+      "         IN (SELECT brname FROM ambiguousBranch);",
+      TAG_BRANCH
+    );
+    blob_append_sql(&sql, " AND blob.rid IN ambiguousLeaf");
+  }
+  if( showClosed ){
+    blob_append_sql(&sql," AND %z", leaf_is_closed_sql("blob.rid"));
+  }else if( !showAll ){
+    blob_append_sql(&sql," AND NOT %z", leaf_is_closed_sql("blob.rid"));
+  }
+  if( byBranch ){
+    db_prepare(&q, "%s ORDER BY nullif(branch,'trunk') COLLATE nocase,"
+                   " event.mtime DESC",
+                   blob_sql_text(&sql));
+  }else{
+    db_prepare(&q, "%s ORDER BY event.mtime DESC", blob_sql_text(&sql));
+  }
+  blob_reset(&sql);
+  n = 0;
+  while( db_step(&q)==SQLITE_ROW ){
+    const char *zId = db_column_text(&q, 1);
+    const char *zDate = db_column_text(&q, 2);
+    const char *zCom = db_column_text(&q, 3);
+    const char *zBr = db_column_text(&q, 7);
+    char *z = 0;
+    char * zBranchPoint = 0;
+
+    if( byBranch && fossil_strcmp(zBr, zLastBr)!=0 ){
+      fossil_print("*** %s ***\n", zBr);
+      fossil_free(zLastBr);
+      zLastBr = fossil_strdup(zBr);
+      if( multipleFlag ) n = 0;
+    }
+    n++;
+    sqlite3_snprintf(sizeof(zLineNo), zLineNo, "(%d)", n);
+    fossil_print("%6s ", zLineNo);
+    if(0!=fossil_strcmp(zBr,zMainBranch)){
+      int ridOfRoot;
+      z = mprintf("root:%s", zId);
+      ridOfRoot = symbolic_name_to_rid(z, "ci");
+      if(ridOfRoot>0){
+        zBranchPoint = mprintf(" (branched from: [%.*z])", hash_digits(0),
+                               rid_to_uuid(ridOfRoot));
+      }
+      fossil_free(z);
+    }
+    z = mprintf("%s [%S] %s%s", zDate, zId, zCom,
+                zBranchPoint ? zBranchPoint : "");
+    comment_print(z, zCom, 7, width, get_comment_format());
+    fossil_free(z);
+    fossil_free(zBranchPoint);
+  }
+  fossil_free(zLastBr);
+  db_finalize(&q);
+}
+
+/*
+** WEBPAGE: leaves
+**
+** Show leaf check-ins in a timeline.  By default only open leaves
+** are listed.
+**
+** A "leaf" is a check-in with no children in the same branch.  A
+** "closed leaf" is a leaf that has a "closed" tag.  An "open leaf"
+** is a leaf without a "closed" tag.
+**
+** Query parameters:
+**
+**     all           Show all leaves
+**     closed        Show only closed leaves
+**     ng            No graph
+**     nohidden      Hide check-ins with "hidden" tag
+**     onlyhidden    Show only check-ins with "hidden" tag
+**     brbg          Background color by branch name
+**     ubg           Background color by user name
+*/
+void leaves_page(void){
+  Blob sql;
+  Stmt q;
+  int showAll = P("all")!=0;
+  int showClosed = P("closed")!=0;
+  int fNg = PB("ng")!=0;           /* Flag for the "ng" query parameter */
+  int fNoHidden = PB("nohidden")!=0;      /* "nohidden" query parameter */
+  int fOnlyHidden = PB("onlyhidden")!=0;  /* "onlyhidden" query parameter */
+  int fBrBg = PB("brbg")!=0;       /* Flag for the "brbg" query parameter */
+  int fUBg = PB("ubg")!=0;         /* Flag for the "ubg" query parameter */
+  HQuery url;                      /* URL to /leaves plus query parameters */
+  int tmFlags;                     /* Timeline display flags */
+
+  login_check_credentials();
+  if( !g.perm.Read ){ login_needed(g.anon.Read); return; }
+  url_initialize(&url, "leaves");
+  if( fNg ) url_add_parameter(&url, "ng", "");
+  if( fNoHidden ) url_add_parameter(&url, "nohidden", "");
+  if( fOnlyHidden ) url_add_parameter(&url, "onlyhidden", "");
+  if( fBrBg ) url_add_parameter(&url, "brbg", "");
+  if( fUBg ) url_add_parameter(&url, "ubg", "");
+  if( !showAll ){
+    style_submenu_element("All", "%s", url_render(&url, "all", "", 0, 0));
+  }
+  if( !showClosed ){
+    style_submenu_element("Closed", "%s", url_render(&url, "closed", "", 0, 0));
+  }
+  if( showClosed || showAll ){
+    style_submenu_element("Open", "%s", url_render(&url, 0, 0, 0, 0));
+  }
+  url_reset(&url);
+  cgi_check_for_malice();
+  style_set_current_feature("leaves");
+  style_header("Leaves");
+  login_anonymous_available();
+  timeline_ss_submenu();
+#if 0
+  style_sidebox_begin("Nomenclature:", "33%");
+  @ <ol>
+  @ <li> A <div class="sideboxDescribed">leaf</div>
+  @ is a check-in with no descendants in the same branch.</li>
+  @ <li> An <div class="sideboxDescribed">open leaf</div>
+  @ is a leaf that does not have a "closed" tag
+  @ and is thus assumed to still be in use.</li>
+  @ <li> A <div class="sideboxDescribed">closed leaf</div>
+  @ has a "closed" tag and is thus assumed to
+  @ be historical and no longer in active use.</li>
+  @ </ol>
+  style_sidebox_end();
+#endif
+
+  if( showAll ){
+    @ <h1>All leaves, both open and closed:</h1>
+  }else if( showClosed ){
+    @ <h1>Closed leaves:</h1>
+  }else{
+    @ <h1>Open leaves:</h1>
+  }
+  blob_zero(&sql);
+  blob_append(&sql, timeline_query_for_www(), -1);
+  blob_append_sql(&sql, " AND blob.rid IN leaf");
+  if( showClosed ){
+    blob_append_sql(&sql," AND %z", leaf_is_closed_sql("blob.rid"));
+  }else if( !showAll ){
+    blob_append_sql(&sql," AND NOT %z", leaf_is_closed_sql("blob.rid"));
+  }
+  if( fNoHidden || fOnlyHidden ){
+    const char* zUnaryOp = fNoHidden ? "NOT" : "";
+    blob_append_sql(&sql,
+      " AND %s EXISTS(SELECT 1 FROM tagxref"
+      " WHERE tagid=%d AND tagtype>0 AND rid=blob.rid)\n",
+      zUnaryOp/*safe-for-%s*/, TAG_HIDDEN);
+  }
+  db_prepare(&q, "%s ORDER BY event.mtime DESC", blob_sql_text(&sql));
+  blob_reset(&sql);
+  /* Always specify TIMELINE_DISJOINT, or graph_finish() may fail because of too
+  ** many descenders to (off-screen) parents. */
+  tmFlags = TIMELINE_LEAFONLY | TIMELINE_DISJOINT | TIMELINE_NOSCROLL;
+  if( fNg==0 ) tmFlags |= TIMELINE_GRAPH;
+  if( fBrBg ) tmFlags |= TIMELINE_BRCOLOR;
+  if( fUBg ) tmFlags |= TIMELINE_UCOLOR;
+  www_print_timeline(&q, tmFlags, 0);
+  db_finalize(&q);
+  @ <br>
+  style_finish_page();
+}
+
+#if INTERFACE
+/* Flag parameters to compute_uses_file() */
+#define USESFILE_DELETE   0x01  /* Include the check-ins where file deleted */
+
+#endif
+
+/*
+** Append a new VALUES term.
+*/
+static void uses_file_append_term(Blob *pSql, int *pnCnt, int rid){
+  if( *pnCnt==0 ){
+    blob_append_sql(pSql, "(%d)", rid);
+    *pnCnt = 4;
+  }else if( (*pnCnt)%10==9 ){
+    blob_append_sql(pSql, ",\n  (%d)", rid);
+  }else{
+    blob_append_sql(pSql, ",(%d)", rid);
+  }
+  ++*pnCnt;
+}
+
+
+/*
+** Add to table zTab the record ID (rid) of every check-in that contains
+** the file fid.
+*/
+void compute_uses_file(const char *zTab, int fid, int usesFlags){
+  Bag seen;
+  Bag pending;
+  Blob ins = BLOB_INITIALIZER;
+  int nIns = 0;
+  Stmt q;
+  int rid;
+
+  bag_init(&seen);
+  bag_init(&pending);
+  blob_append_sql(&ins, "INSERT OR IGNORE INTO \"%w\" VALUES", zTab);
+  db_prepare(&q, "SELECT mid FROM mlink WHERE fid=%d", fid);
+  while( db_step(&q)==SQLITE_ROW ){
+    int mid = db_column_int(&q, 0);
+    bag_insert(&pending, mid);
+    bag_insert(&seen, mid);
+    uses_file_append_term(&ins, &nIns, mid);
+  }
+  db_finalize(&q);
+
+  db_prepare(&q, "SELECT mid FROM mlink WHERE pid=%d", fid);
+  while( db_step(&q)==SQLITE_ROW ){
+    int mid = db_column_int(&q, 0);
+    bag_insert(&seen, mid);
+    if( usesFlags & USESFILE_DELETE ){
+      uses_file_append_term(&ins, &nIns, mid);
+    }
+  }
+  db_finalize(&q);
+  db_prepare(&q, "SELECT cid FROM plink WHERE pid=:rid AND isprim");
+
+  while( (rid = bag_first(&pending))!=0 ){
+    bag_remove(&pending, rid);
+    db_bind_int(&q, ":rid", rid);
+    while( db_step(&q)==SQLITE_ROW ){
+      int mid = db_column_int(&q, 0);
+      if( bag_find(&seen, mid) ) continue;
+      bag_insert(&seen, mid);
+      bag_insert(&pending, mid);
+      uses_file_append_term(&ins, &nIns, mid);
+    }
+    db_reset(&q);
+  }
+  db_finalize(&q);
+  if( nIns>0 ) db_exec_sql(blob_str(&ins));
+  blob_reset(&ins);
+  bag_clear(&seen);
+  bag_clear(&pending);
+}