text: /* wc-queries.sql -- queries used to interact with the wc-metadata
   *                   SQLite database
   *     This is intended for use with SQLite 3
   *
   * ====================================================================
   *    Licensed to the Apache Software Foundation (ASF) under one
   *    or more contributor license agreements.  See the NOTICE file
   *    distributed with this work for additional information
   *    regarding copyright ownership.  The ASF licenses this file
   *    to you under the Apache License, Version 2.0 (the
   *    "License"); you may not use this file except in compliance
   *    with the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   *    Unless required by applicable law or agreed to in writing,
   *    software distributed under the License is distributed on an
   *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   *    KIND, either express or implied.  See the License for the
   *    specific language governing permissions and limitations
   *    under the License.
   * ====================================================================
   */
  
  /* ------------------------------------------------------------------------- */
  
  /* these are used in wc_db.c  */
  
  -- STMT_SELECT_NODE_INFO
  SELECT op_depth, repos_id, repos_path, presence, kind, revision, checksum,
    translated_size, changed_revision, changed_date, changed_author, depth,
    symlink_target, last_mod_time, properties, moved_here, inherited_props,
    moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
  ORDER BY op_depth DESC
  
  -- STMT_SELECT_NODE_INFO_WITH_LOCK
  SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision,
    checksum, translated_size, changed_revision, changed_date, changed_author,
    depth, symlink_target, last_mod_time, properties, moved_here,
    inherited_props,
    /* All the columns until now must match those returned by
       STMT_SELECT_NODE_INFO. The implementation of svn_wc__db_read_info()
       assumes that these columns are followed by the lock information) */
    lock_token, lock_owner, lock_comment, lock_date
  FROM nodes
  LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath AND nodes.op_depth=0
  WHERE wc_id = ?1 AND local_relpath = ?2
  ORDER BY op_depth DESC
  
  -- STMT_SELECT_BASE_NODE
  SELECT repos_id, repos_path, presence, kind, revision, checksum,
    translated_size, changed_revision, changed_date, changed_author, depth,
    symlink_target, last_mod_time, properties, file_external
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_SELECT_BASE_NODE_WITH_LOCK
  SELECT nodes.repos_id, nodes.repos_path, presence, kind, revision,
    checksum, translated_size, changed_revision, changed_date, changed_author,
    depth, symlink_target, last_mod_time, properties, file_external,
    /* All the columns until now must match those returned by
       STMT_SELECT_BASE_NODE. The implementation of svn_wc__db_base_get_info()
       assumes that these columns are followed by the lock information) */
    lock_token, lock_owner, lock_comment, lock_date
  FROM nodes
  LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_SELECT_BASE_CHILDREN_INFO
  SELECT local_relpath, nodes.repos_id, nodes.repos_path, presence, kind,
    revision, depth, file_external
  FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0
  
  -- STMT_SELECT_BASE_CHILDREN_INFO_LOCK
  SELECT local_relpath, nodes.repos_id, nodes.repos_path, presence, kind,
    revision, depth, file_external,
    lock_token, lock_owner, lock_comment, lock_date
  FROM nodes
  LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0
  
  
  -- STMT_SELECT_WORKING_NODE
  SELECT op_depth, presence, kind, checksum, translated_size,
    changed_revision, changed_date, changed_author, depth, symlink_target,
    repos_id, repos_path, revision,
    moved_here, moved_to, last_mod_time, properties
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > 0
  ORDER BY op_depth DESC
  LIMIT 1
  
  -- STMT_SELECT_DEPTH_NODE
  SELECT repos_id, repos_path, presence, kind, revision, checksum,
    translated_size, changed_revision, changed_date, changed_author, depth,
    symlink_target, properties, moved_to, moved_here
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_SELECT_LOWEST_WORKING_NODE
  SELECT op_depth, presence, kind, moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3
  ORDER BY op_depth
  LIMIT 1
  
  -- STMT_SELECT_HIGHEST_WORKING_NODE
  SELECT op_depth
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth < ?3
  ORDER BY op_depth DESC
  LIMIT 1
  
  -- STMT_SELECT_PRESENT_HIGHEST_WORKING_NODES_BY_BASENAME_AND_KIND
  SELECT presence, local_relpath
  FROM nodes n
  WHERE wc_id = ?1 AND local_relpath = RELPATH_JOIN(parent_relpath, ?2)
    AND kind = ?3
    AND presence in (MAP_NORMAL, MAP_INCOMPLETE)
    AND op_depth = (SELECT MAX(op_depth)
                    FROM NODES w
                    WHERE w.wc_id = ?1
                      AND w.local_relpath = n.local_relpath)
  
  -- STMT_SELECT_ACTUAL_NODE
  SELECT changelist, properties, conflict_data
  FROM actual_node
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_SELECT_NODE_CHILDREN_INFO
  /* Getting rows in an advantageous order using
       ORDER BY local_relpath, op_depth DESC
     doesn't work as the index is created without the DESC keyword.
     Using both local_relpath and op_depth descending does work without any
     performance penalty. */
  SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision,
    checksum, translated_size, changed_revision, changed_date, changed_author,
    depth, symlink_target, last_mod_time, properties, lock_token, lock_owner,
    lock_comment, lock_date, local_relpath, moved_here, moved_to, file_external
  FROM nodes
  LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath AND nodes.op_depth = 0
  WHERE wc_id = ?1 AND parent_relpath = ?2
  ORDER BY local_relpath DESC, op_depth DESC
  
  -- STMT_SELECT_BASE_NODE_CHILDREN_INFO
  /* See above re: result ordering. The results of this query must be in
  the same order as returned by STMT_SELECT_NODE_CHILDREN_INFO, because
  read_children_info expects them to be. */
  SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision,
    checksum, translated_size, changed_revision, changed_date, changed_author,
    depth, symlink_target, last_mod_time, properties, lock_token, lock_owner,
    lock_comment, lock_date, local_relpath, moved_here, moved_to, file_external
  FROM nodes
  LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0
  ORDER BY local_relpath DESC
  
  -- STMT_SELECT_NODE_CHILDREN_WALKER_INFO
  SELECT local_relpath, op_depth, presence, kind
  FROM nodes_current
  WHERE wc_id = ?1 AND parent_relpath = ?2
  ORDER BY local_relpath
  
  -- STMT_SELECT_ACTUAL_CHILDREN_INFO
  SELECT local_relpath, changelist, properties, conflict_data
  FROM actual_node
  WHERE wc_id = ?1 AND parent_relpath = ?2
  
  -- STMT_SELECT_REPOSITORY_BY_ID
  SELECT root, uuid FROM repository WHERE id = ?1
  
  -- STMT_SELECT_WCROOT_NULL
  SELECT id FROM wcroot WHERE local_abspath IS NULL
  
  -- STMT_SELECT_REPOSITORY
  SELECT id FROM repository WHERE root = ?1
  
  -- STMT_INSERT_REPOSITORY
  INSERT INTO repository (root, uuid) VALUES (?1, ?2)
  
  -- STMT_INSERT_NODE
  INSERT OR REPLACE INTO nodes (
    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path,
    revision, presence, depth, kind, changed_revision, changed_date,
    changed_author, checksum, properties, translated_size, last_mod_time,
    dav_cache, symlink_target, file_external, moved_to, moved_here,
    inherited_props)
  VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14,
          ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23)
  
  -- STMT_SELECT_WORKING_PRESENT
  SELECT local_relpath, kind, checksum, translated_size, last_mod_time
  FROM nodes n
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND presence in (MAP_NORMAL, MAP_INCOMPLETE)
    AND op_depth = (SELECT MAX(op_depth)
                    FROM NODES w
                    WHERE w.wc_id = ?1
                      AND w.local_relpath = n.local_relpath)
  ORDER BY local_relpath DESC
  
  -- STMT_DELETE_NODE_RECURSIVE
  DELETE FROM NODES
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
  
  -- STMT_DELETE_NODE
  DELETE
  FROM NODES
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_DELETE_ACTUAL_FOR_BASE_RECURSIVE
  /* The ACTUAL_NODE applies to BASE, unless there is in at least one op_depth
     a WORKING node that could have a conflict */
  DELETE FROM actual_node
  WHERE wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND EXISTS(SELECT 1 FROM NODES b
               WHERE b.wc_id = ?1
                 AND b.local_relpath = actual_node.local_relpath
                 AND op_depth = 0)
    AND NOT EXISTS(SELECT 1 FROM NODES w
                   WHERE w.wc_id = ?1
                     AND w.local_relpath = actual_node.local_relpath
                     AND op_depth > 0
                     AND presence in (MAP_NORMAL, MAP_INCOMPLETE, MAP_NOT_PRESENT))
  
  -- STMT_DELETE_WORKING_BASE_DELETE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND presence = MAP_BASE_DELETED
    AND op_depth > ?3
    AND op_depth = (SELECT MIN(op_depth) FROM nodes n
                      WHERE n.wc_id = ?1
                        AND n.local_relpath = nodes.local_relpath
                        AND op_depth > ?3)
  
  -- STMT_DELETE_WORKING_BASE_DELETE_RECURSIVE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND presence = MAP_BASE_DELETED
    AND op_depth > ?3
    AND op_depth = (SELECT MIN(op_depth) FROM nodes n
                      WHERE n.wc_id = ?1
                        AND n.local_relpath = nodes.local_relpath
                        AND op_depth > ?3)
  
  -- STMT_DELETE_WORKING_RECURSIVE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth > 0
  
  -- STMT_DELETE_BASE_RECURSIVE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND (local_relpath = ?2 
                        OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth = 0
  
  -- STMT_DELETE_WORKING_OP_DEPTH
  DELETE FROM nodes
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth = ?3
  
  /* Full layer replacement check code for handling moves
  The op_root must exist (or there is no layer to replace) and an op-root
     always has presence 'normal' */
  -- STMT_SELECT_LAYER_FOR_REPLACE
  SELECT s.local_relpath, s.kind,
    RELPATH_SKIP_JOIN(?2, ?4, s.local_relpath) drp, 'normal'
  FROM nodes s
  WHERE s.wc_id = ?1 AND s.local_relpath = ?2 AND s.op_depth = ?3
  UNION ALL
  SELECT s.local_relpath, s.kind,
    RELPATH_SKIP_JOIN(?2, ?4, s.local_relpath) drp, d.presence
  FROM nodes s
  LEFT OUTER JOIN nodes d ON d.wc_id= ?1 AND d.op_depth = ?5
       AND d.local_relpath = drp
  WHERE s.wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(s.local_relpath, ?2)
    AND s.op_depth = ?3
  ORDER BY s.local_relpath
  
  -- STMT_SELECT_DESCENDANTS_OP_DEPTH_RV
  SELECT local_relpath, kind
  FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = ?3
    AND presence in (MAP_NORMAL, MAP_INCOMPLETE)
  ORDER BY local_relpath DESC
  
  -- STMT_COPY_NODE_MOVE
  INSERT OR REPLACE INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path,
      revision, presence, depth, kind, changed_revision, changed_date,
      changed_author, checksum, properties, translated_size, last_mod_time,
      symlink_target, moved_here, moved_to )
  SELECT
      s.wc_id, ?4 /*local_relpath */, ?5 /*op_depth*/, ?6 /* parent_relpath */,
      s.repos_id,
      s.repos_path, s.revision, s.presence, s.depth, s.kind, s.changed_revision,
      s.changed_date, s.changed_author, s.checksum, s.properties,
      CASE WHEN d.checksum=s.checksum THEN d.translated_size END,
      CASE WHEN d.checksum=s.checksum THEN d.last_mod_time END,
      s.symlink_target, 1, d.moved_to
  FROM nodes s
  LEFT JOIN nodes d ON d.wc_id=?1 AND d.local_relpath=?4 AND d.op_depth=?5
  WHERE s.wc_id = ?1 AND s.local_relpath = ?2 AND s.op_depth = ?3
  
  -- STMT_SELECT_NO_LONGER_MOVED_RV
  SELECT d.local_relpath, RELPATH_SKIP_JOIN(?2, ?4, d.local_relpath) srp,
         b.presence, b.op_depth
  FROM nodes d
  LEFT OUTER JOIN nodes b ON b.wc_id = ?1 AND b.local_relpath = d.local_relpath
              AND b.op_depth = (SELECT MAX(x.op_depth) FROM nodes x
                                WHERE x.wc_id = ?1
                                  AND x.local_relpath = b.local_relpath
                                  AND x.op_depth < ?3)
  WHERE d.wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(d.local_relpath, ?2)
    AND d.op_depth = ?3
    AND NOT EXISTS(SELECT * FROM nodes s
                   WHERE s.wc_id = ?1
                     AND s.local_relpath = srp
                     AND s.op_depth = ?5)
  ORDER BY d.local_relpath DESC
  
  -- STMT_SELECT_OP_DEPTH_CHILDREN
  SELECT local_relpath, kind FROM nodes
  WHERE wc_id = ?1
    AND parent_relpath = ?2
    AND op_depth = ?3
    AND presence != MAP_BASE_DELETED
    AND file_external is NULL
  ORDER BY local_relpath
  
  -- STMT_SELECT_OP_DEPTH_CHILDREN_EXISTS
  SELECT local_relpath, kind FROM nodes
  WHERE wc_id = ?1
    AND parent_relpath = ?2
    AND op_depth = ?3
    AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
  ORDER BY local_relpath
  
  /* Used by non-recursive revert to detect higher level children, and
     actual-only rows that would be left orphans, if the revert
     proceeded. */
  -- STMT_SELECT_GE_OP_DEPTH_CHILDREN
  SELECT 1 FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2
    AND (op_depth > ?3 OR (op_depth = ?3
                           AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)))
  UNION ALL
  SELECT 1 FROM ACTUAL_NODE a
  WHERE wc_id = ?1 AND parent_relpath = ?2
    AND NOT EXISTS (SELECT 1 FROM nodes n
                     WHERE wc_id = ?1 AND n.local_relpath = a.local_relpath)
  
  /* Delete the nodes shadowed by local_relpath. Not valid for the wc-root */
  -- STMT_DELETE_SHADOWED_RECURSIVE
  DELETE FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND (op_depth < ?3
         OR (op_depth = ?3 AND presence = MAP_BASE_DELETED))
  
  -- STMT_CLEAR_MOVED_TO_FROM_DEST
  UPDATE NODES SET moved_to = NULL
  WHERE wc_id = ?1
    AND moved_to = ?2
  
  /* Get not-present descendants of a copied node. Not valid for the wc-root */
  -- STMT_SELECT_NOT_PRESENT_DESCENDANTS
  SELECT local_relpath FROM nodes
  WHERE wc_id = ?1 AND op_depth = ?3
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND presence = MAP_NOT_PRESENT
  
  -- STMT_COMMIT_DESCENDANTS_TO_BASE
  UPDATE NODES SET op_depth = 0,
                   repos_id = ?4,
                   repos_path = RELPATH_SKIP_JOIN(?2, ?5, local_relpath),
                   revision = ?6,
                   dav_cache = NULL,
                   moved_here = NULL,
                   moved_to = NULL,
                   presence = CASE presence
                                WHEN MAP_NORMAL THEN MAP_NORMAL
                                WHEN MAP_EXCLUDED THEN MAP_EXCLUDED
                                ELSE MAP_NOT_PRESENT
                              END
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = ?3
  
  -- STMT_SELECT_NODE_CHILDREN
  /* Return all paths that are children of the directory (?1, ?2) in any
     op-depth, including children of any underlying, replaced directories. */
  SELECT DISTINCT local_relpath FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2
  ORDER BY local_relpath
  
  -- STMT_SELECT_WORKING_CHILDREN
  /* Return all paths that are children of the working version of the
     directory (?1, ?2).  A given path is not included just because it is a
     child of an underlying (replaced) directory, it has to be in the
     working version of the directory. */
  SELECT DISTINCT local_relpath FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2
    AND (op_depth > (SELECT MAX(op_depth) FROM nodes
                     WHERE wc_id = ?1 AND local_relpath = ?2)
         OR
         (op_depth = (SELECT MAX(op_depth) FROM nodes
                      WHERE wc_id = ?1 AND local_relpath = ?2)
          AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)))
  ORDER BY local_relpath
  
  -- STMT_SELECT_BASE_NOT_PRESENT_CHILDREN
  SELECT local_relpath FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0
    AND presence = MAP_NOT_PRESENT
  ORDER BY local_relpath
  
  -- STMT_SELECT_NODE_PROPS
  SELECT properties, presence FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
  ORDER BY op_depth DESC
  
  -- STMT_SELECT_ACTUAL_PROPS
  SELECT properties FROM actual_node
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_UPDATE_ACTUAL_PROPS
  UPDATE actual_node SET properties = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_INSERT_ACTUAL_PROPS
  INSERT INTO actual_node (wc_id, local_relpath, parent_relpath, properties)
  VALUES (?1, ?2, ?3, ?4)
  
  -- STMT_INSERT_LOCK
  INSERT OR REPLACE INTO lock
  (repos_id, repos_relpath, lock_token, lock_owner, lock_comment,
   lock_date)
  VALUES (?1, ?2, ?3, ?4, ?5, ?6)
  
  /* Not valid for the working copy root */
  -- STMT_SELECT_BASE_NODE_LOCK_TOKENS_RECURSIVE
  SELECT nodes.repos_id, nodes.repos_path, lock_token
  FROM nodes
  LEFT JOIN lock ON nodes.repos_id = lock.repos_id
    AND nodes.repos_path = lock.repos_relpath
  WHERE wc_id = ?1 AND op_depth = 0
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
  
  -- STMT_INSERT_WCROOT
  INSERT INTO wcroot (local_abspath)
  VALUES (?1)
  
  -- STMT_UPDATE_BASE_NODE_DAV_CACHE
  UPDATE nodes SET dav_cache = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_SELECT_BASE_DAV_CACHE
  SELECT dav_cache FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_SELECT_DELETION_INFO
  SELECT b.presence, w.presence, w.op_depth, w.moved_to
  FROM nodes w
  LEFT JOIN nodes b ON b.wc_id = ?1 AND b.local_relpath = ?2 AND b.op_depth = 0
  WHERE w.wc_id = ?1 AND w.local_relpath = ?2
    AND w.op_depth = (SELECT MAX(op_depth) FROM nodes d
                      WHERE d.wc_id = ?1 AND d.local_relpath = ?2
                        AND d.op_depth > 0)
  LIMIT 1
  
  -- STMT_SELECT_MOVED_TO_NODE
  SELECT op_depth, moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND moved_to IS NOT NULL
  ORDER BY op_depth DESC
  
  -- STMT_SELECT_OP_DEPTH_MOVED_TO
  SELECT op_depth, moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3
    AND EXISTS(SELECT * from nodes
               WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
               AND presence IN (MAP_NORMAL, MAP_INCOMPLETE))
  ORDER BY op_depth ASC
  LIMIT 1
  
  -- STMT_SELECT_MOVED_TO
  SELECT moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_SELECT_MOVED_BACK
  SELECT u.local_relpath,
         u.presence, u.repos_id, u.repos_path, u.revision,
         l.presence, l.repos_id, l.repos_path, l.revision,
         u.moved_here, u.moved_to
  FROM nodes u
  LEFT OUTER JOIN nodes l ON l.wc_id = ?1
                         AND l.local_relpath = u.local_relpath
                         AND l.op_depth = ?3
  WHERE u.wc_id = ?1
    AND u.local_relpath = ?2
    AND u.op_depth = ?4
  UNION ALL
  SELECT u.local_relpath,
         u.presence, u.repos_id, u.repos_path, u.revision,
         l.presence, l.repos_id, l.repos_path, l.revision,
         u.moved_here, NULL
  FROM nodes u
  LEFT OUTER JOIN nodes l ON l.wc_id=?1
                         AND l.local_relpath=u.local_relpath
                         AND l.op_depth=?3
  WHERE u.wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(u.local_relpath, ?2)
    AND u.op_depth = ?4
  
  -- STMT_DELETE_LOCK
  DELETE FROM lock
  WHERE repos_id = ?1 AND repos_relpath = ?2
  
  -- STMT_DELETE_LOCK_RECURSIVELY
  DELETE FROM lock
  WHERE repos_id = ?1 AND (repos_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(repos_relpath, ?2))
  
  -- STMT_CLEAR_BASE_NODE_RECURSIVE_DAV_CACHE
  UPDATE nodes SET dav_cache = NULL
  WHERE dav_cache IS NOT NULL AND wc_id = ?1 AND op_depth = 0
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
  
  -- STMT_RECURSIVE_UPDATE_NODE_REPO
  UPDATE nodes SET repos_id = ?4, dav_cache = NULL
  /* ### The Sqlite optimizer needs help here ###
   * WHERE wc_id = ?1
   *   AND repos_id = ?3
   *   AND (local_relpath = ?2
   *        OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))*/
  WHERE (wc_id = ?1 AND local_relpath = ?2 AND repos_id = ?3)
     OR (wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
         AND repos_id = ?3)
  
  
  -- STMT_UPDATE_LOCK_REPOS_ID
  UPDATE lock SET repos_id = ?2
  WHERE repos_id = ?1
  
  -- STMT_UPDATE_NODE_FILEINFO
  UPDATE nodes SET translated_size = ?3, last_mod_time = ?4
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND op_depth = (SELECT MAX(op_depth) FROM nodes
                    WHERE wc_id = ?1 AND local_relpath = ?2)
  
  -- STMT_INSERT_ACTUAL_CONFLICT
  INSERT INTO actual_node (wc_id, local_relpath, conflict_data, parent_relpath)
  VALUES (?1, ?2, ?3, ?4)
  
  -- STMT_UPDATE_ACTUAL_CONFLICT
  UPDATE actual_node SET conflict_data = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_UPDATE_ACTUAL_CHANGELISTS
  UPDATE actual_node SET changelist = ?3
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND local_relpath = (SELECT local_relpath FROM targets_list AS t
                         WHERE wc_id = ?1
                           AND t.local_relpath = actual_node.local_relpath
                           AND kind = MAP_FILE)
  
  -- STMT_UPDATE_ACTUAL_CLEAR_CHANGELIST
  UPDATE actual_node SET changelist = NULL
   WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_MARK_SKIPPED_CHANGELIST_DIRS
  /* 7 corresponds to svn_wc_notify_skip */
  INSERT INTO changelist_list (wc_id, local_relpath, notify, changelist)
  SELECT wc_id, local_relpath, 7, ?3
  FROM targets_list
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND kind = MAP_DIR
  
  -- STMT_RESET_ACTUAL_WITH_CHANGELIST
  REPLACE INTO actual_node (
    wc_id, local_relpath, parent_relpath, changelist)
  VALUES (?1, ?2, ?3, ?4)
  
  -- STMT_CREATE_CHANGELIST_LIST
  DROP TABLE IF EXISTS changelist_list;
  CREATE TEMPORARY TABLE changelist_list (
    wc_id  INTEGER NOT NULL,
    local_relpath TEXT NOT NULL,
    notify INTEGER NOT NULL,
    changelist TEXT NOT NULL,
    /* Order NOTIFY descending to make us show clears (27) before adds (26) */
    PRIMARY KEY (wc_id, local_relpath, notify DESC)
  )
  
  /* Create notify items for when a node is removed from a changelist and
     when a node is added to a changelist. Make sure nothing is notified
     if there were no changes.
  */
  -- STMT_CREATE_CHANGELIST_TRIGGER
  DROP TRIGGER IF EXISTS   trigger_changelist_list_change;
  CREATE TEMPORARY TRIGGER trigger_changelist_list_change
  BEFORE UPDATE ON actual_node
  WHEN old.changelist IS NOT new.changelist
  BEGIN
    /* 27 corresponds to svn_wc_notify_changelist_clear */
    INSERT INTO changelist_list(wc_id, local_relpath, notify, changelist)
    SELECT old.wc_id, old.local_relpath, 27, old.changelist
     WHERE old.changelist is NOT NULL;
  
    /* 26 corresponds to svn_wc_notify_changelist_set */
    INSERT INTO changelist_list(wc_id, local_relpath, notify, changelist)
    SELECT new.wc_id, new.local_relpath, 26, new.changelist
     WHERE new.changelist IS NOT NULL;
  END
  
  -- STMT_FINALIZE_CHANGELIST
  DROP TRIGGER trigger_changelist_list_change;
  DROP TABLE changelist_list;
  DROP TABLE targets_list
  
  -- STMT_SELECT_CHANGELIST_LIST
  SELECT wc_id, local_relpath, notify, changelist
  FROM changelist_list
  ORDER BY wc_id, local_relpath ASC, notify DESC
  
  -- STMT_CREATE_TARGETS_LIST
  DROP TABLE IF EXISTS targets_list;
  CREATE TEMPORARY TABLE targets_list (
    wc_id  INTEGER NOT NULL,
    local_relpath TEXT NOT NULL,
    parent_relpath TEXT,
    kind TEXT NOT NULL,
    PRIMARY KEY (wc_id, local_relpath)
    );
  /* need more indicies? */
  
  -- STMT_DROP_TARGETS_LIST
  DROP TABLE targets_list
  
  -- STMT_INSERT_TARGET
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT wc_id, local_relpath, parent_relpath, kind
  FROM nodes_current
  WHERE wc_id = ?1
    AND local_relpath = ?2
  
  -- STMT_INSERT_TARGET_DEPTH_FILES
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT wc_id, local_relpath, parent_relpath, kind
  FROM nodes_current
  WHERE wc_id = ?1
    AND parent_relpath = ?2
    AND kind = MAP_FILE
  
  -- STMT_INSERT_TARGET_DEPTH_IMMEDIATES
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT wc_id, local_relpath, parent_relpath, kind
  FROM nodes_current
  WHERE wc_id = ?1
    AND parent_relpath = ?2
  
  -- STMT_INSERT_TARGET_DEPTH_INFINITY
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT wc_id, local_relpath, parent_relpath, kind
  FROM nodes_current
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
  
  -- STMT_INSERT_TARGET_WITH_CHANGELIST
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind
    FROM actual_node AS A JOIN nodes_current AS N
      ON A.wc_id = N.wc_id AND A.local_relpath = N.local_relpath
   WHERE N.wc_id = ?1
     AND N.local_relpath = ?2
     AND A.changelist = ?3
  
  -- STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_FILES
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind
    FROM actual_node AS A JOIN nodes_current AS N
      ON A.wc_id = N.wc_id AND A.local_relpath = N.local_relpath
   WHERE N.wc_id = ?1
     AND N.parent_relpath = ?2
     AND kind = MAP_FILE
     AND A.changelist = ?3
  
  -- STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_IMMEDIATES
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind
    FROM actual_node AS A JOIN nodes_current AS N
      ON A.wc_id = N.wc_id AND A.local_relpath = N.local_relpath
   WHERE N.wc_id = ?1
     AND N.parent_relpath = ?2
    AND A.changelist = ?3
  
  -- STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_INFINITY
  INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind)
  SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind
    FROM actual_node AS A JOIN nodes_current AS N
      ON A.wc_id = N.wc_id AND A.local_relpath = N.local_relpath
   WHERE N.wc_id = ?1
     AND IS_STRICT_DESCENDANT_OF(N.local_relpath, ?2)
     AND A.changelist = ?3
  
  /* Only used by commented dump_targets() in wc_db.c */
  /*-- STMT_SELECT_TARGETS
  SELECT local_relpath, parent_relpath from targets_list*/
  
  -- STMT_INSERT_ACTUAL_EMPTIES
  INSERT OR IGNORE INTO actual_node (
       wc_id, local_relpath, parent_relpath)
  SELECT wc_id, local_relpath, parent_relpath
  FROM targets_list
  
  -- STMT_INSERT_ACTUAL_EMPTIES_FILES
  INSERT OR IGNORE INTO actual_node (
       wc_id, local_relpath, parent_relpath)
  SELECT wc_id, local_relpath, parent_relpath
  FROM targets_list
  WHERE kind=MAP_FILE
  
  -- STMT_DELETE_ACTUAL_EMPTY
  DELETE FROM actual_node
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND properties IS NULL
    AND conflict_data IS NULL
    AND changelist IS NULL
    AND text_mod IS NULL
    AND older_checksum IS NULL
    AND right_checksum IS NULL
    AND left_checksum IS NULL
  
  -- STMT_DELETE_ACTUAL_EMPTIES
  DELETE FROM actual_node
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND properties IS NULL
    AND conflict_data IS NULL
    AND changelist IS NULL
    AND text_mod IS NULL
    AND older_checksum IS NULL
    AND right_checksum IS NULL
    AND left_checksum IS NULL
  
  -- STMT_DELETE_BASE_NODE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_DELETE_WORKING_NODE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND op_depth = (SELECT MAX(op_depth) FROM nodes
                    WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > 0)
  
  -- STMT_DELETE_LOWEST_WORKING_NODE
  DELETE FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND op_depth = (SELECT MIN(op_depth) FROM nodes
                    WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3)
    AND presence = MAP_BASE_DELETED
  
  -- STMT_DELETE_NODE_ALL_LAYERS
  DELETE FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_DELETE_NODES_ABOVE_DEPTH_RECURSIVE
  DELETE FROM nodes
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth >= ?3
  
  -- STMT_DELETE_ACTUAL_NODE
  DELETE FROM actual_node
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  /* Will not delete recursive when run on the wcroot */
  -- STMT_DELETE_ACTUAL_NODE_RECURSIVE
  DELETE FROM actual_node
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
  
  -- STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST
  DELETE FROM actual_node
  WHERE wc_id = ?1
    AND local_relpath = ?2
    AND (changelist IS NULL
         OR NOT EXISTS (SELECT 1 FROM nodes_current c
                        WHERE c.wc_id = ?1 AND c.local_relpath = ?2
                          AND c.kind = MAP_FILE))
  
  -- STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE
  DELETE FROM actual_node
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND (changelist IS NULL
         OR NOT EXISTS (SELECT 1 FROM nodes_current c
                        WHERE c.wc_id = ?1
                          AND c.local_relpath = actual_node.local_relpath
                          AND c.kind = MAP_FILE))
  
  -- STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST
  UPDATE actual_node
  SET properties = NULL,
      text_mod = NULL,
      conflict_data = NULL,
      tree_conflict_data = NULL,
      older_checksum = NULL,
      left_checksum = NULL,
      right_checksum = NULL
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_CLEAR_ACTUAL_NODE_LEAVING_CONFLICT
  UPDATE actual_node
  SET properties = NULL,
      text_mod = NULL,
      tree_conflict_data = NULL,
      older_checksum = NULL,
      left_checksum = NULL,
      right_checksum = NULL,
      changelist = NULL
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE
  UPDATE actual_node
  SET properties = NULL,
      text_mod = NULL,
      conflict_data = NULL,
      tree_conflict_data = NULL,
      older_checksum = NULL,
      left_checksum = NULL,
      right_checksum = NULL
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
  
  -- STMT_UPDATE_NODE_BASE_DEPTH
  UPDATE nodes SET depth = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
    AND kind=MAP_DIR
    AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
  
  -- STMT_UPDATE_NODE_BASE_PRESENCE
  UPDATE nodes SET presence = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_UPDATE_BASE_NODE_PRESENCE_REVNUM_AND_REPOS_PATH
  UPDATE nodes SET presence = ?3, revision = ?4, repos_path = ?5
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_LOOK_FOR_WORK
  SELECT id FROM work_queue LIMIT 1
  
  -- STMT_INSERT_WORK_ITEM
  INSERT INTO work_queue (work) VALUES (?1)
  
  -- STMT_SELECT_WORK_ITEM
  SELECT id, work FROM work_queue ORDER BY id LIMIT 1
  
  -- STMT_DELETE_WORK_ITEM
  DELETE FROM work_queue WHERE id = ?1
  
  -- STMT_INSERT_OR_IGNORE_PRISTINE
  INSERT OR IGNORE INTO pristine (checksum, md5_checksum, size, refcount)
  VALUES (?1, ?2, ?3, 0)
  
  -- STMT_INSERT_PRISTINE
  INSERT INTO pristine (checksum, md5_checksum, size, refcount)
  VALUES (?1, ?2, ?3, 0)
  
  -- STMT_SELECT_PRISTINE
  SELECT md5_checksum
  FROM pristine
  WHERE checksum = ?1
  
  -- STMT_SELECT_PRISTINE_SIZE
  SELECT size
  FROM pristine
  WHERE checksum = ?1 LIMIT 1
  
  -- STMT_SELECT_PRISTINE_BY_MD5
  SELECT checksum
  FROM pristine
  WHERE md5_checksum = ?1
  
  -- STMT_SELECT_UNREFERENCED_PRISTINES
  SELECT checksum
  FROM pristine
  WHERE refcount = 0
  
  -- STMT_DELETE_PRISTINE_IF_UNREFERENCED
  DELETE FROM pristine
  WHERE checksum = ?1 AND refcount = 0
  
  -- STMT_SELECT_COPY_PRISTINES
  /* For the root itself */
  SELECT n.checksum, md5_checksum, size
  FROM nodes_current n
  LEFT JOIN pristine p ON n.checksum = p.checksum
  WHERE wc_id = ?1
    AND n.local_relpath = ?2
    AND n.checksum IS NOT NULL
  UNION ALL
  /* And all descendants */
  SELECT n.checksum, md5_checksum, size
  FROM nodes n
  LEFT JOIN pristine p ON n.checksum = p.checksum
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(n.local_relpath, ?2)
    AND op_depth >=
        (SELECT MAX(op_depth) FROM nodes WHERE wc_id = ?1 AND local_relpath = ?2)
    AND n.checksum IS NOT NULL
  
  -- STMT_VACUUM
  VACUUM
  
  -- STMT_SELECT_CONFLICT_VICTIMS
  SELECT local_relpath, conflict_data
  FROM actual_node
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND
    NOT (conflict_data IS NULL)
  
  -- STMT_INSERT_WC_LOCK
  INSERT INTO wc_lock (wc_id, local_dir_relpath, locked_levels)
  VALUES (?1, ?2, ?3)
  
  -- STMT_SELECT_WC_LOCK
  SELECT locked_levels FROM wc_lock
  WHERE wc_id = ?1 AND local_dir_relpath = ?2
  
  -- STMT_SELECT_ANCESTOR_WCLOCKS
  SELECT local_dir_relpath, locked_levels FROM wc_lock
  WHERE wc_id = ?1
    AND ((local_dir_relpath >= ?3 AND local_dir_relpath <= ?2)
         OR local_dir_relpath = '')
  
  -- STMT_DELETE_WC_LOCK
  DELETE FROM wc_lock
  WHERE wc_id = ?1 AND local_dir_relpath = ?2
  
  -- STMT_FIND_WC_LOCK
  SELECT local_dir_relpath FROM wc_lock
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_dir_relpath, ?2)
  
  -- STMT_FIND_CONFLICT_DESCENDANT
  SELECT 1 FROM actual_node
  WHERE wc_id = ?1
    AND local_relpath > (?2 || '/')
    AND local_relpath < (?2 || '0') /* '0' = ascii('/') +1 */
    AND conflict_data IS NOT NULL
  LIMIT 1
  
  -- STMT_DELETE_WC_LOCK_ORPHAN
  DELETE FROM wc_lock
  WHERE wc_id = ?1 AND local_dir_relpath = ?2
  AND NOT EXISTS (SELECT 1 FROM nodes
                   WHERE nodes.wc_id = ?1
                     AND nodes.local_relpath = wc_lock.local_dir_relpath)
  
  -- STMT_DELETE_WC_LOCK_ORPHAN_RECURSIVE
  DELETE FROM wc_lock
  WHERE wc_id = ?1
    AND (local_dir_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_dir_relpath, ?2))
    AND NOT EXISTS (SELECT 1 FROM nodes
                     WHERE nodes.wc_id = ?1
                       AND nodes.local_relpath = wc_lock.local_dir_relpath)
  
  -- STMT_APPLY_CHANGES_TO_BASE_NODE
  /* translated_size and last_mod_time are not mentioned here because they will
     be tweaked after the working-file is installed. When we replace an existing
     BASE node (read: bump), preserve its file_external status. */
  INSERT OR REPLACE INTO nodes (
    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path,
    revision, presence, depth, kind, changed_revision, changed_date,
    changed_author, checksum, properties, dav_cache, symlink_target,
    inherited_props, file_external )
  VALUES (?1, ?2, 0,
          ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17,
          (SELECT file_external FROM nodes
            WHERE wc_id = ?1
              AND local_relpath = ?2
              AND op_depth = 0))
  
  -- STMT_INSTALL_WORKING_NODE_FOR_DELETE
  INSERT INTO nodes (
      wc_id, local_relpath, op_depth,
      parent_relpath, presence, kind)
  VALUES(?1, ?2, ?3, ?4, MAP_BASE_DELETED, ?5)
  
  -- STMT_REPLACE_WITH_BASE_DELETED
  INSERT OR REPLACE INTO nodes (wc_id, local_relpath, op_depth, parent_relpath,
                                kind, moved_to, presence)
  SELECT wc_id, local_relpath, op_depth, parent_relpath,
         kind, moved_to, MAP_BASE_DELETED
    FROM nodes
   WHERE wc_id = ?1
     AND local_relpath = ?2
     AND op_depth = ?3
  
  /* If this query is updated, STMT_INSERT_DELETE_LIST should too.
     Use UNION ALL instead of a simple 'OR' to avoid creating a temp table */
  -- STMT_INSERT_DELETE_FROM_NODE_RECURSIVE
  INSERT INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, presence, kind)
  SELECT wc_id, local_relpath, ?4 /*op_depth*/, parent_relpath, MAP_BASE_DELETED,
         kind
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  UNION ALL
  SELECT wc_id, local_relpath, ?4 /*op_depth*/, parent_relpath, MAP_BASE_DELETED,
         kind
  FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = ?3
    AND presence NOT IN (MAP_BASE_DELETED, MAP_NOT_PRESENT, MAP_EXCLUDED, MAP_SERVER_EXCLUDED)
    AND file_external IS NULL
  ORDER BY local_relpath
  
  -- STMT_INSERT_WORKING_NODE_FROM_BASE_COPY
  INSERT OR REPLACE INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path,
      revision, presence, depth, kind, changed_revision, changed_date,
      changed_author, checksum, properties, translated_size, last_mod_time,
      symlink_target, moved_to )
  SELECT wc_id, local_relpath, ?3 /*op_depth*/, parent_relpath, repos_id,
      repos_path, revision, presence, depth, kind, changed_revision,
      changed_date, changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target,
      (SELECT moved_to FROM nodes
       WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3) moved_to
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_INSERT_DELETE_FROM_BASE
  INSERT INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, presence, kind)
  SELECT wc_id, local_relpath, ?3 /*op_depth*/, parent_relpath,
      MAP_BASE_DELETED, kind
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  /* Not valid on the wc-root */
  -- STMT_UPDATE_OP_DEPTH_INCREASE_RECURSIVE
  UPDATE nodes SET op_depth = ?3 + 1
  WHERE wc_id = ?1
   AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
   AND op_depth = ?3
  
  /* Duplicated SELECT body to avoid creating temporary table */
  -- STMT_COPY_OP_DEPTH_RECURSIVE
  INSERT INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path,
      revision, presence, depth, kind, changed_revision, changed_date,
      changed_author, checksum, properties, translated_size, last_mod_time,
      symlink_target, moved_here, moved_to )
  SELECT
      wc_id, local_relpath, ?4, parent_relpath, repos_id,
      repos_path, revision, presence, depth, kind, changed_revision,
      changed_date, changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target, NULL, NULL
  FROM nodes
  WHERE wc_id = ?1 AND op_depth = ?3 AND local_relpath = ?2
  UNION ALL
  SELECT
      wc_id, local_relpath, ?4, parent_relpath, repos_id,
      repos_path, revision, presence, depth, kind, changed_revision,
      changed_date, changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target, NULL, NULL
  FROM nodes
  WHERE wc_id = ?1 AND op_depth = ?3
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
  ORDER BY local_relpath
  
  -- STMT_DOES_NODE_EXIST
  SELECT 1 FROM nodes WHERE wc_id = ?1 AND local_relpath = ?2
  LIMIT 1
  
  -- STMT_HAS_SERVER_EXCLUDED_DESCENDANTS
  SELECT local_relpath FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0 AND presence = MAP_SERVER_EXCLUDED
  LIMIT 1
  
  /* Select all excluded nodes. Not valid on the WC-root */
  -- STMT_SELECT_ALL_EXCLUDED_DESCENDANTS
  SELECT local_relpath FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0
    AND (presence = MAP_SERVER_EXCLUDED OR presence = MAP_EXCLUDED)
  
  /* Creates a copy from one top level NODE to a different location */
  -- STMT_INSERT_WORKING_NODE_COPY_FROM
  INSERT OR REPLACE INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, repos_id,
      repos_path, revision, presence, depth, moved_here, kind, changed_revision,
      changed_date, changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target, moved_to )
  SELECT wc_id, ?3 /*local_relpath*/, ?4 /*op_depth*/, ?5 /*parent_relpath*/,
      repos_id, repos_path, revision, ?6 /*presence*/, depth,
      ?7/*moved_here*/, kind, changed_revision, changed_date,
      changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target,
      (SELECT dst.moved_to FROM nodes AS dst
                           WHERE dst.wc_id = ?1
                           AND dst.local_relpath = ?3
                           AND dst.op_depth = ?4)
  FROM nodes_current
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_INSERT_WORKING_NODE_COPY_FROM_DEPTH
  INSERT OR REPLACE INTO nodes (
      wc_id, local_relpath, op_depth, parent_relpath, repos_id,
      repos_path, revision, presence, depth, moved_here, kind, changed_revision,
      changed_date, changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target, moved_to )
  SELECT wc_id, ?3 /*local_relpath*/, ?4 /*op_depth*/, ?5 /*parent_relpath*/,
      repos_id, repos_path, revision, ?6 /*presence*/, depth,
      ?8 /*moved_here*/, kind, changed_revision, changed_date,
      changed_author, checksum, properties, translated_size,
      last_mod_time, symlink_target,
      (SELECT dst.moved_to FROM nodes AS dst
                           WHERE dst.wc_id = ?1
                           AND dst.local_relpath = ?3
                           AND dst.op_depth = ?4)
  FROM nodes
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?7
  
  -- STMT_UPDATE_BASE_REVISION
  UPDATE nodes SET revision = ?3
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_UPDATE_BASE_REPOS
  UPDATE nodes SET repos_id = ?3, repos_path = ?4
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0
  
  -- STMT_ACTUAL_HAS_CHILDREN
  SELECT 1 FROM actual_node
  WHERE wc_id = ?1 AND parent_relpath = ?2
  LIMIT 1
  
  -- STMT_INSERT_EXTERNAL
  INSERT OR REPLACE INTO externals (
      wc_id, local_relpath, parent_relpath, presence, kind, def_local_relpath,
      repos_id, def_repos_relpath, def_operational_revision, def_revision)
  VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
  
  -- STMT_SELECT_EXTERNAL_INFO
  SELECT presence, kind, def_local_relpath, repos_id,
      def_repos_relpath, def_operational_revision, def_revision
  FROM externals WHERE wc_id = ?1 AND local_relpath = ?2
  LIMIT 1
  
  -- STMT_DELETE_FILE_EXTERNALS
  DELETE FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0
    AND file_external IS NOT NULL
  
  -- STMT_DELETE_FILE_EXTERNAL_REGISTATIONS
  DELETE FROM externals
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND kind != MAP_DIR
  
  -- STMT_DELETE_EXTERNAL_REGISTATIONS
  DELETE FROM externals
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
  
  /* Select all committable externals, i.e. only unpegged ones on the same
   * repository as the target path ?2, that are defined by WC ?1 to
   * live below the target path. It does not matter which ancestor has the
   * svn:externals definition, only the local path at which the external is
   * supposed to be checked out is queried.
   * Arguments:
   *  ?1: wc_id.
   *  ?2: the target path, local relpath inside ?1.
   *
   * ### NOTE: This statement deliberately removes file externals that live
   * inside an unversioned dir, because commit still breaks on those.
   * Once that's been fixed, the conditions below "--->8---" become obsolete. */
  -- STMT_SELECT_COMMITTABLE_EXTERNALS_BELOW
  SELECT local_relpath, kind, def_repos_relpath,
    (SELECT root FROM repository AS r WHERE r.id = e.repos_id)
  FROM externals e
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND def_revision IS NULL
    AND repos_id = (SELECT repos_id
                    FROM nodes AS n
                    WHERE n.wc_id = ?1
                      AND n.local_relpath = ''
                      AND n.op_depth = 0)
    AND ((kind='dir')
         OR EXISTS (SELECT 1 FROM nodes
                    WHERE nodes.wc_id = e.wc_id
                    AND nodes.local_relpath = e.parent_relpath))
  
  -- STMT_SELECT_COMMITTABLE_EXTERNALS_IMMEDIATELY_BELOW
  SELECT local_relpath, kind, def_repos_relpath,
    (SELECT root FROM repository AS r WHERE r.id = e.repos_id)
  FROM externals e
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(e.local_relpath, ?2)
    AND parent_relpath = ?2
    AND def_revision IS NULL
    AND repos_id = (SELECT repos_id
                      FROM nodes AS n
                      WHERE n.wc_id = ?1
                        AND n.local_relpath = ''
                        AND n.op_depth = 0)
    AND ((kind='dir')
         OR EXISTS (SELECT 1 FROM nodes
                    WHERE nodes.wc_id = e.wc_id
                    AND nodes.local_relpath = e.parent_relpath))
  
  -- STMT_SELECT_EXTERNALS_DEFINED
  SELECT local_relpath, def_local_relpath
  FROM externals
  /* ### The Sqlite optimizer needs help here ###
   * WHERE wc_id = ?1
   *   AND (def_local_relpath = ?2
   *        OR IS_STRICT_DESCENDANT_OF(def_local_relpath, ?2)) */
  WHERE (wc_id = ?1 AND def_local_relpath = ?2)
     OR (wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(def_local_relpath, ?2))
  
  -- STMT_DELETE_EXTERNAL
  DELETE FROM externals
  WHERE wc_id = ?1 AND local_relpath = ?2
  
  -- STMT_SELECT_EXTERNAL_PROPERTIES
  /* ### It would be nice if Sqlite would handle
   * SELECT IFNULL((SELECT properties FROM actual_node a
   *                WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath),
   *               properties),
   *        local_relpath, depth
   * FROM nodes_current n
   * WHERE wc_id = ?1
   *   AND (local_relpath = ?2
   *        OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
   *   AND kind = MAP_DIR AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
   * ### But it would take a double table scan execution plan for it.
   * ### Maybe there is something else going on? */
  SELECT IFNULL((SELECT properties FROM actual_node a
                 WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath),
                properties),
         local_relpath, depth
  FROM nodes_current n
  WHERE wc_id = ?1 AND local_relpath = ?2
    AND kind = MAP_DIR AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
  UNION ALL
  SELECT IFNULL((SELECT properties FROM actual_node a
                 WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath),
                properties),
         local_relpath, depth
  FROM nodes_current n
  WHERE wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND kind = MAP_DIR AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
  
  -- STMT_SELECT_CURRENT_PROPS_RECURSIVE
  /* ### Ugly OR to make sqlite use the proper optimizations */
  SELECT IFNULL((SELECT properties FROM actual_node a
                 WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath),
                properties),
         local_relpath
  FROM nodes_current n
  WHERE (wc_id = ?1 AND local_relpath = ?2)
     OR (wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
  
  -- STMT_PRAGMA_LOCKING_MODE
  PRAGMA locking_mode = exclusive;
  /* Testing shows DELETE is faster than TRUNCATE on NFS and
     exclusive-locking is mostly used on remote file systems. */
  PRAGMA journal_mode = DELETE
  
  -- STMT_FIND_REPOS_PATH_IN_WC
  SELECT local_relpath FROM nodes_current
    WHERE wc_id = ?1 AND repos_path = ?2
  
  /* ------------------------------------------------------------------------- */
  
  /* these are used in entries.c  */
  
  -- STMT_INSERT_ACTUAL_NODE
  INSERT OR REPLACE INTO actual_node (
    wc_id, local_relpath, parent_relpath, properties, changelist, conflict_data)
  VALUES (?1, ?2, ?3, ?4, ?5, ?6)
  
  /* ------------------------------------------------------------------------- */
  
  /* these are used in upgrade.c  */
  
  -- STMT_SELECT_ALL_FILES
  SELECT local_relpath FROM nodes_current
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND kind = MAP_FILE
  
  -- STMT_UPDATE_NODE_PROPS
  UPDATE nodes SET properties = ?4
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_PRAGMA_TABLE_INFO_NODES
  PRAGMA table_info("NODES")
  
  /* --------------------------------------------------------------------------
   * Complex queries for callback walks, caching results in a temporary table.
   *
   * These target table are then used for joins against NODES, or for reporting
   */
  
  -- STMT_CREATE_TARGET_PROP_CACHE
  DROP TABLE IF EXISTS target_prop_cache;
  CREATE TEMPORARY TABLE target_prop_cache (
    local_relpath TEXT NOT NULL PRIMARY KEY,
    kind TEXT NOT NULL,
    properties BLOB
  );
  /* ###  Need index?
  CREATE UNIQUE INDEX temp__node_props_cache_unique
    ON temp__node_props_cache (local_relpath) */
  
  -- STMT_CACHE_TARGET_PROPS
  INSERT INTO target_prop_cache(local_relpath, kind, properties)
   SELECT n.local_relpath, n.kind,
          IFNULL((SELECT properties FROM actual_node AS a
                   WHERE a.wc_id = n.wc_id
                     AND a.local_relpath = n.local_relpath),
                 n.properties)
     FROM targets_list AS t
     JOIN nodes AS n
       ON n.wc_id = ?1
      AND n.local_relpath = t.local_relpath
      AND n.op_depth = (SELECT MAX(op_depth) FROM nodes AS n3
                        WHERE n3.wc_id = ?1
                          AND n3.local_relpath = t.local_relpath)
    WHERE t.wc_id = ?1
      AND (presence=MAP_NORMAL OR presence=MAP_INCOMPLETE)
    ORDER BY t.local_relpath
  
  -- STMT_CACHE_TARGET_PRISTINE_PROPS
  INSERT INTO target_prop_cache(local_relpath, kind, properties)
   SELECT n.local_relpath, n.kind,
          CASE n.presence
            WHEN MAP_BASE_DELETED
            THEN (SELECT properties FROM nodes AS p
                   WHERE p.wc_id = n.wc_id
                     AND p.local_relpath = n.local_relpath
                     AND p.op_depth < n.op_depth
                   ORDER BY p.op_depth DESC /* LIMIT 1 */)
            ELSE properties END
    FROM targets_list AS t
    JOIN nodes AS n
      ON n.wc_id = ?1
     AND n.local_relpath = t.local_relpath
     AND n.op_depth = (SELECT MAX(op_depth) FROM nodes AS n3
                       WHERE n3.wc_id = ?1
                         AND n3.local_relpath = t.local_relpath)
    WHERE t.wc_id = ?1
      AND (presence = MAP_NORMAL
           OR presence = MAP_INCOMPLETE
           OR presence = MAP_BASE_DELETED)
    ORDER BY t.local_relpath
  
  -- STMT_SELECT_ALL_TARGET_PROP_CACHE
  SELECT local_relpath, properties FROM target_prop_cache
  ORDER BY local_relpath
  
  -- STMT_DROP_TARGET_PROP_CACHE
  DROP TABLE target_prop_cache;
  
  -- STMT_CREATE_REVERT_LIST
  DROP TABLE IF EXISTS revert_list;
  CREATE TEMPORARY TABLE revert_list (
     /* need wc_id if/when revert spans multiple working copies */
     local_relpath TEXT NOT NULL,
     actual INTEGER NOT NULL,         /* 1 if an actual row, 0 if a nodes row */
     conflict_data BLOB,
     notify INTEGER,         /* 1 if an actual row had props or tree conflict */
     op_depth INTEGER,
     repos_id INTEGER,
     kind TEXT,
     PRIMARY KEY (local_relpath, actual)
     );
  DROP TRIGGER IF EXISTS   trigger_revert_list_nodes;
  CREATE TEMPORARY TRIGGER trigger_revert_list_nodes
  BEFORE DELETE ON nodes
  BEGIN
     INSERT OR REPLACE INTO revert_list(local_relpath, actual, op_depth,
                                        repos_id, kind)
     SELECT OLD.local_relpath, 0, OLD.op_depth, OLD.repos_id, OLD.kind;
  END;
  DROP TRIGGER IF EXISTS   trigger_revert_list_actual_delete;
  CREATE TEMPORARY TRIGGER trigger_revert_list_actual_delete
  BEFORE DELETE ON actual_node
  BEGIN
     INSERT OR REPLACE INTO revert_list(local_relpath, actual, conflict_data,
                                        notify)
     SELECT OLD.local_relpath, 1, OLD.conflict_data,
            CASE
              WHEN OLD.properties IS NOT NULL
              THEN 1
              WHEN NOT EXISTS(SELECT 1 FROM NODES n
                              WHERE n.wc_id = OLD.wc_id
                                AND n.local_relpath = OLD.local_relpath)
              THEN 1
            END notify
     WHERE OLD.conflict_data IS NOT NULL
        OR notify IS NOT NULL;
  END;
  DROP TRIGGER IF EXISTS   trigger_revert_list_actual_update;
  CREATE TEMPORARY TRIGGER trigger_revert_list_actual_update
  BEFORE UPDATE ON actual_node
  BEGIN
     INSERT OR REPLACE INTO revert_list(local_relpath, actual, conflict_data,
                                        notify)
     SELECT OLD.local_relpath, 1, OLD.conflict_data,
            CASE
              WHEN OLD.properties IS NOT NULL
              THEN 1
              WHEN NOT EXISTS(SELECT 1 FROM NODES n
                              WHERE n.wc_id = OLD.wc_id
                                AND n.local_relpath = OLD.local_relpath)
              THEN 1
            END notify
     WHERE OLD.conflict_data IS NOT NULL
        OR notify IS NOT NULL;
  END
  
  -- STMT_DROP_REVERT_LIST_TRIGGERS
  DROP TRIGGER trigger_revert_list_nodes;
  DROP TRIGGER trigger_revert_list_actual_delete;
  DROP TRIGGER trigger_revert_list_actual_update
  
  -- STMT_SELECT_REVERT_LIST
  SELECT actual, notify, kind, op_depth, repos_id, conflict_data
  FROM revert_list
  WHERE local_relpath = ?1
  ORDER BY actual DESC
  
  -- STMT_SELECT_REVERT_LIST_COPIED_CHILDREN
  SELECT local_relpath, kind
  FROM revert_list
  WHERE IS_STRICT_DESCENDANT_OF(local_relpath, ?1)
    AND op_depth >= ?2
    AND repos_id IS NOT NULL
  ORDER BY local_relpath
  
  -- STMT_DELETE_REVERT_LIST
  DELETE FROM revert_list WHERE local_relpath = ?1
  
  -- STMT_SELECT_REVERT_LIST_RECURSIVE
  SELECT p.local_relpath, n.kind, a.notify, a.kind
  FROM (SELECT DISTINCT local_relpath
        FROM revert_list
        WHERE (local_relpath = ?1
          OR IS_STRICT_DESCENDANT_OF(local_relpath, ?1))) p
  
  LEFT JOIN revert_list n ON n.local_relpath=p.local_relpath AND n.actual=0
  LEFT JOIN revert_list a ON a.local_relpath=p.local_relpath AND a.actual=1
  ORDER BY p.local_relpath
  
  -- STMT_DELETE_REVERT_LIST_RECURSIVE
  DELETE FROM revert_list
  WHERE (local_relpath = ?1
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?1))
  
  -- STMT_DROP_REVERT_LIST
  DROP TABLE IF EXISTS revert_list
  
  -- STMT_CREATE_DELETE_LIST
  DROP TABLE IF EXISTS delete_list;
  CREATE TEMPORARY TABLE delete_list (
  /* ### we should put the wc_id in here in case a delete spans multiple
     ### working copies. queries, etc will need to be adjusted.  */
     local_relpath TEXT PRIMARY KEY NOT NULL UNIQUE
     )
  
  /* This matches the selection in STMT_INSERT_DELETE_FROM_NODE_RECURSIVE.
     A subquery is used instead of nodes_current to avoid a table scan */
  -- STMT_INSERT_DELETE_LIST
  INSERT INTO delete_list(local_relpath)
  SELECT ?2
  UNION ALL
  SELECT local_relpath FROM nodes AS n
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth >= ?3
    AND op_depth = (SELECT MAX(s.op_depth) FROM nodes AS s
                    WHERE s.wc_id = ?1
                      AND s.local_relpath = n.local_relpath)
    AND presence NOT IN (MAP_BASE_DELETED, MAP_NOT_PRESENT, MAP_EXCLUDED, MAP_SERVER_EXCLUDED)
    AND file_external IS NULL
  ORDER by local_relpath
  
  -- STMT_SELECT_DELETE_LIST
  SELECT local_relpath FROM delete_list
  ORDER BY local_relpath
  
  -- STMT_FINALIZE_DELETE
  DROP TABLE IF EXISTS delete_list
  
  -- STMT_CREATE_UPDATE_MOVE_LIST
  DROP TABLE IF EXISTS update_move_list;
  CREATE TEMPORARY TABLE update_move_list (
  /* ### we should put the wc_id in here in case a move update spans multiple
     ### working copies. queries, etc will need to be adjusted.  */
    local_relpath TEXT PRIMARY KEY NOT NULL UNIQUE,
    action INTEGER NOT NULL,
    kind TEXT NOT NULL,
    content_state INTEGER NOT NULL,
    prop_state  INTEGER NOT NULL
    )
  
  -- STMT_INSERT_UPDATE_MOVE_LIST
  INSERT INTO update_move_list(local_relpath, action, kind, content_state,
    prop_state)
  VALUES (?1, ?2, ?3, ?4, ?5)
  
  -- STMT_SELECT_UPDATE_MOVE_LIST
  SELECT local_relpath, action, kind, content_state, prop_state
  FROM update_move_list
  ORDER BY local_relpath
  
  -- STMT_FINALIZE_UPDATE_MOVE
  DROP TABLE IF EXISTS update_move_list
  
  -- STMT_MOVE_NOTIFY_TO_REVERT
  INSERT INTO revert_list (local_relpath, notify, kind, actual)
         SELECT local_relpath, 2, kind, 1 FROM update_move_list;
  DROP TABLE update_move_list
  
  /* ------------------------------------------------------------------------- */
  
  /* Queries for revision status. */
  
  -- STMT_SELECT_MIN_MAX_REVISIONS
  SELECT MIN(revision), MAX(revision),
         MIN(changed_revision), MAX(changed_revision) FROM nodes
    WHERE wc_id = ?1
      AND (local_relpath = ?2
           OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
      AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
      AND file_external IS NULL
      AND op_depth = 0
  
  -- STMT_HAS_SPARSE_NODES
  SELECT 1 FROM nodes
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth = 0
    AND (presence IN (MAP_SERVER_EXCLUDED, MAP_EXCLUDED)
          OR depth NOT IN (MAP_DEPTH_INFINITY, MAP_DEPTH_UNKNOWN))
    AND file_external IS NULL
  LIMIT 1
  
  -- STMT_SUBTREE_HAS_TREE_MODIFICATIONS
  SELECT 1 FROM nodes
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth > 0
  LIMIT 1
  
  -- STMT_SUBTREE_HAS_PROP_MODIFICATIONS
  SELECT 1 FROM actual_node
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND properties IS NOT NULL
  LIMIT 1
  
  -- STMT_HAS_SWITCHED
  SELECT 1
  FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0
    AND file_external IS NULL
    AND presence IN (MAP_NORMAL, MAP_INCOMPLETE)
    AND repos_path IS NOT RELPATH_SKIP_JOIN(?2, ?3, local_relpath)
  LIMIT 1
  
  -- STMT_SELECT_MOVED_FROM_RELPATH
  SELECT local_relpath, op_depth FROM nodes
  WHERE wc_id = ?1 AND moved_to = ?2 AND op_depth > 0
  
  -- STMT_UPDATE_MOVED_TO_RELPATH
  UPDATE nodes SET moved_to = ?4
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_CLEAR_MOVED_TO_RELPATH
  UPDATE nodes SET moved_to = NULL
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
  
  -- STMT_CLEAR_MOVED_HERE_RECURSIVE
  UPDATE nodes SET moved_here = NULL
  WHERE wc_id = ?1
   AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
   AND op_depth = ?3
  
  /* This statement returns pairs of move-roots below the path ?2 in WC_ID ?1.
   * Each row returns a moved-here path (always a child of ?2) in the first
   * column, and its matching moved-away (deleted) path in the second column. */
  -- STMT_SELECT_MOVED_HERE_CHILDREN
  SELECT moved_to, local_relpath FROM nodes
  WHERE wc_id = ?1 AND op_depth > 0
    AND IS_STRICT_DESCENDANT_OF(moved_to, ?2)
  
  /* If the node is moved here (r.moved_here = 1) we are really interested in
     where the node was moved from. To obtain that we need the op_depth, but
     this form of select only allows a single return value */
  -- STMT_SELECT_MOVED_FOR_DELETE
  SELECT local_relpath, moved_to, op_depth,
         (SELECT CASE WHEN r.moved_here THEN r.op_depth END FROM nodes r
          WHERE r.wc_id = ?1
            AND r.local_relpath = n.local_relpath
            AND r.op_depth < n.op_depth
          ORDER BY r.op_depth DESC LIMIT 1) AS moved_here_op_depth
   FROM nodes n
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND moved_to IS NOT NULL
    AND op_depth >= ?3
  
  -- STMT_SELECT_MOVED_FROM_FOR_DELETE
  SELECT local_relpath, op_depth,
         (SELECT CASE WHEN r.moved_here THEN r.op_depth END FROM nodes r
          WHERE r.wc_id = ?1
            AND r.local_relpath = n.local_relpath
            AND r.op_depth < n.op_depth
          ORDER BY r.op_depth DESC LIMIT 1) AS moved_here_op_depth
   FROM nodes n
  WHERE wc_id = ?1 AND moved_to = ?2 AND op_depth > 0
  
  -- STMT_UPDATE_MOVED_TO_DESCENDANTS
  UPDATE nodes SET moved_to = RELPATH_SKIP_JOIN(?2, ?3, moved_to)
   WHERE wc_id = ?1
     AND IS_STRICT_DESCENDANT_OF(moved_to, ?2)
  
  -- STMT_CLEAR_MOVED_TO_DESCENDANTS
  UPDATE nodes SET moved_to = NULL
   WHERE wc_id = ?1
     AND IS_STRICT_DESCENDANT_OF(moved_to, ?2)
  
  -- STMT_SELECT_MOVED_PAIR3
  SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind
  FROM nodes n
  JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath
   AND d.op_depth = (SELECT MIN(dd.op_depth)
                      FROM nodes dd
                      WHERE dd.wc_id = ?1
                        AND dd.local_relpath = d.local_relpath
                        AND dd.op_depth > ?3)
  WHERE n.wc_id = ?1 AND n.local_relpath = ?2 AND n.op_depth = ?3
    AND d.moved_to IS NOT NULL
  UNION ALL
  SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind
  FROM nodes n
  JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath
   AND d.op_depth = (SELECT MIN(dd.op_depth)
                      FROM nodes dd
                      WHERE dd.wc_id = ?1
                        AND dd.local_relpath = d.local_relpath
                        AND dd.op_depth > ?3)
  WHERE n.wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(n.local_relpath, ?2)
    AND n.op_depth = ?3
    AND d.moved_to IS NOT NULL
  ORDER BY n.local_relpath
  
  -- STMT_SELECT_MOVED_OUTSIDE
  SELECT local_relpath, moved_to, op_depth FROM nodes
  WHERE wc_id = ?1
    AND (local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth >= ?3
    AND moved_to IS NOT NULL
    AND NOT IS_STRICT_DESCENDANT_OF(moved_to, ?2)
  
  -- STMT_SELECT_MOVED_DESCENDANTS_SRC
  SELECT s.op_depth, n.local_relpath, n.kind, n.repos_path, s.moved_to
  FROM nodes n
  JOIN nodes s ON s.wc_id = n.wc_id AND s.local_relpath = n.local_relpath
   AND s.op_depth = (SELECT MIN(d.op_depth)
                      FROM nodes d
                      WHERE d.wc_id = ?1
                        AND d.local_relpath = s.local_relpath
                        AND d.op_depth > ?3)
  WHERE n.wc_id = ?1 AND n.op_depth = ?3
    AND (n.local_relpath = ?2 OR IS_STRICT_DESCENDANT_OF(n.local_relpath, ?2))
    AND s.moved_to IS NOT NULL
  
  -- STMT_COMMIT_UPDATE_ORIGIN
  UPDATE nodes SET repos_id = ?4,
                   repos_path = RELPATH_SKIP_JOIN(?2, ?5, local_relpath),
                   revision = ?6
  WHERE wc_id = ?1
    AND (local_relpath = ?2
         OR IS_STRICT_DESCENDANT_OF(local_relpath, ?2))
    AND op_depth = ?3
  
  -- STMT_HAS_LAYER_BETWEEN
  SELECT 1 FROM NODES
  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3 AND op_depth < ?4
  
  -- STMT_SELECT_REPOS_PATH_REVISION
  SELECT local_relpath, repos_path, revision FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0
  ORDER BY local_relpath
  
  -- STMT_SELECT_HAS_NON_FILE_CHILDREN
  SELECT 1 FROM nodes
  WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = ?3 AND kind != MAP_FILE
  LIMIT 1
  
  -- STMT_SELECT_HAS_GRANDCHILDREN
  SELECT 1 FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(parent_relpath, ?2)
    AND op_depth = ?3
    AND file_external IS NULL
  LIMIT 1
  
  /* ------------------------------------------------------------------------- */
  
  /* Queries for verification. */
  
  -- STMT_SELECT_ALL_NODES
  SELECT op_depth, local_relpath, parent_relpath, file_external FROM nodes
  WHERE wc_id = ?1
  
  /* ------------------------------------------------------------------------- */
  
  /* Queries for cached inherited properties. */
  
  /* Update the inherited properties of a single base node. */
  -- STMT_UPDATE_IPROP
  UPDATE nodes
  SET inherited_props = ?3
  WHERE (wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0)
  
  /* Select a single path if its base node has cached inherited properties. */
  -- STMT_SELECT_IPROPS_NODE
  SELECT local_relpath, repos_path FROM nodes
  WHERE wc_id = ?1
    AND local_relpath = ?2
    AND op_depth = 0
    AND (inherited_props not null)
  
  /* Select all paths whose base nodes are below a given path, which
     have cached inherited properties. */
  -- STMT_SELECT_IPROPS_RECURSIVE
  SELECT local_relpath, repos_path FROM nodes
  WHERE wc_id = ?1
    AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
    AND op_depth = 0
    AND (inherited_props not null)
  
  -- STMT_SELECT_IPROPS_CHILDREN
  SELECT local_relpath, repos_path FROM nodes
  WHERE wc_id = ?1
    AND parent_relpath = ?2
    AND op_depth = 0
    AND (inherited_props not null)
  
  -- STMT_HAVE_STAT1_TABLE
  SELECT 1 FROM sqlite_master WHERE name='sqlite_stat1' AND type='table'
  LIMIT 1
  
  -- STMT_SELECT_COPIES_OF_REPOS_RELPATH
  SELECT local_relpath
  FROM nodes n
  WHERE wc_id = ?1 AND repos_path = ?2 AND kind = ?3
    AND presence = MAP_NORMAL
    AND op_depth = (SELECT MAX(op_depth)
                    FROM NODES w
                    WHERE w.wc_id = ?1
                      AND w.local_relpath = n.local_relpath)
  ORDER BY local_relpath ASC
  
  /* ------------------------------------------------------------------------- */
  
  /* Grab all the statements related to the schema.  */
  
  -- include: wc-metadata
  -- include: wc-checks
  