~ubuntu-branches/debian/sid/subversion/sid

« back to all changes in this revision

Viewing changes to subversion/libsvn_wc/wc-queries.h

  • Committer: Package Import Robot
  • Author(s): James McCoy
  • Date: 2015-08-07 21:32:47 UTC
  • mfrom: (0.2.15) (4.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20150807213247-ozyewtmgsr6tkewl
Tags: 1.9.0-1
* Upload to unstable
* New upstream release.
  + Security fixes
    - CVE-2015-3184: Mixed anonymous/authenticated path-based authz with
      httpd 2.4
    - CVE-2015-3187: svn_repos_trace_node_locations() reveals paths hidden
      by authz
* Add >= 2.7 requirement for python-all-dev Build-Depends, needed to run
  tests.
* Remove Build-Conflicts against ruby-test-unit.  (Closes: #791844)
* Remove patches/apache_module_dependency in favor of expressing the
  dependencies in authz_svn.load/dav_svn.load.
* Build-Depend on apache2-dev (>= 2.4.16) to ensure ap_some_authn_required()
  is available when building mod_authz_svn and Depend on apache2-bin (>=
  2.4.16) for runtime support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* This file is automatically generated from wc-queries.sql and .dist_sandbox/subversion-1.8.13/subversion/libsvn_wc/token-map.h.
 
1
/* This file is automatically generated from wc-queries.sql and .dist_sandbox/subversion-1.9.0/subversion/libsvn_wc/token-map.h.
2
2
 * Do not edit this file -- edit the source and rerun gen-make.py */
3
3
 
4
4
#define STMT_SELECT_NODE_INFO 0
55
55
#define STMT_4_INFO {"STMT_SELECT_BASE_CHILDREN_INFO", NULL}
56
56
#define STMT_4 \
57
57
  "SELECT local_relpath, nodes.repos_id, nodes.repos_path, presence, kind, " \
 
58
  "  revision, depth, file_external " \
 
59
  "FROM nodes " \
 
60
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0 " \
 
61
  ""
 
62
 
 
63
#define STMT_SELECT_BASE_CHILDREN_INFO_LOCK 5
 
64
#define STMT_5_INFO {"STMT_SELECT_BASE_CHILDREN_INFO_LOCK", NULL}
 
65
#define STMT_5 \
 
66
  "SELECT local_relpath, nodes.repos_id, nodes.repos_path, presence, kind, " \
58
67
  "  revision, depth, file_external, " \
59
68
  "  lock_token, lock_owner, lock_comment, lock_date " \
60
69
  "FROM nodes " \
63
72
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0 " \
64
73
  ""
65
74
 
66
 
#define STMT_SELECT_WORKING_NODE 5
67
 
#define STMT_5_INFO {"STMT_SELECT_WORKING_NODE", NULL}
68
 
#define STMT_5 \
 
75
#define STMT_SELECT_WORKING_NODE 6
 
76
#define STMT_6_INFO {"STMT_SELECT_WORKING_NODE", NULL}
 
77
#define STMT_6 \
69
78
  "SELECT op_depth, presence, kind, checksum, translated_size, " \
70
79
  "  changed_revision, changed_date, changed_author, depth, symlink_target, " \
71
80
  "  repos_id, repos_path, revision, " \
76
85
  "LIMIT 1 " \
77
86
  ""
78
87
 
79
 
#define STMT_SELECT_DEPTH_NODE 6
80
 
#define STMT_6_INFO {"STMT_SELECT_DEPTH_NODE", NULL}
81
 
#define STMT_6 \
82
 
  "SELECT repos_id, repos_path, presence, kind, revision, checksum, " \
83
 
  "  translated_size, changed_revision, changed_date, changed_author, depth, " \
84
 
  "  symlink_target, last_mod_time, properties " \
85
 
  "FROM nodes " \
86
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
87
 
  ""
88
 
 
89
 
#define STMT_SELECT_LOWEST_WORKING_NODE 7
90
 
#define STMT_7_INFO {"STMT_SELECT_LOWEST_WORKING_NODE", NULL}
 
88
#define STMT_SELECT_DEPTH_NODE 7
 
89
#define STMT_7_INFO {"STMT_SELECT_DEPTH_NODE", NULL}
91
90
#define STMT_7 \
 
91
  "SELECT repos_id, repos_path, presence, kind, revision, checksum, " \
 
92
  "  translated_size, changed_revision, changed_date, changed_author, depth, " \
 
93
  "  symlink_target, properties, moved_to, moved_here " \
 
94
  "FROM nodes " \
 
95
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
96
  ""
 
97
 
 
98
#define STMT_SELECT_LOWEST_WORKING_NODE 8
 
99
#define STMT_8_INFO {"STMT_SELECT_LOWEST_WORKING_NODE", NULL}
 
100
#define STMT_8 \
92
101
  "SELECT op_depth, presence, kind, moved_to " \
93
102
  "FROM nodes " \
94
103
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3 " \
96
105
  "LIMIT 1 " \
97
106
  ""
98
107
 
99
 
#define STMT_SELECT_HIGHEST_WORKING_NODE 8
100
 
#define STMT_8_INFO {"STMT_SELECT_HIGHEST_WORKING_NODE", NULL}
101
 
#define STMT_8 \
 
108
#define STMT_SELECT_HIGHEST_WORKING_NODE 9
 
109
#define STMT_9_INFO {"STMT_SELECT_HIGHEST_WORKING_NODE", NULL}
 
110
#define STMT_9 \
102
111
  "SELECT op_depth " \
103
112
  "FROM nodes " \
104
113
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth < ?3 " \
106
115
  "LIMIT 1 " \
107
116
  ""
108
117
 
109
 
#define STMT_SELECT_ACTUAL_NODE 9
110
 
#define STMT_9_INFO {"STMT_SELECT_ACTUAL_NODE", NULL}
111
 
#define STMT_9 \
 
118
#define STMT_SELECT_ACTUAL_NODE 10
 
119
#define STMT_10_INFO {"STMT_SELECT_ACTUAL_NODE", NULL}
 
120
#define STMT_10 \
112
121
  "SELECT changelist, properties, conflict_data " \
113
122
  "FROM actual_node " \
114
123
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
115
124
  ""
116
125
 
117
 
#define STMT_SELECT_NODE_CHILDREN_INFO 10
118
 
#define STMT_10_INFO {"STMT_SELECT_NODE_CHILDREN_INFO", NULL}
119
 
#define STMT_10 \
120
 
  "SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision, " \
121
 
  "  checksum, translated_size, changed_revision, changed_date, changed_author, " \
122
 
  "  depth, symlink_target, last_mod_time, properties, lock_token, lock_owner, " \
123
 
  "  lock_comment, lock_date, local_relpath, moved_here, moved_to, file_external " \
124
 
  "FROM nodes " \
125
 
  "LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id " \
126
 
  "  AND nodes.repos_path = lock.repos_relpath AND op_depth = 0 " \
127
 
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
128
 
  ""
129
 
 
130
 
#define STMT_SELECT_NODE_CHILDREN_WALKER_INFO 11
131
 
#define STMT_11_INFO {"STMT_SELECT_NODE_CHILDREN_WALKER_INFO", NULL}
 
126
#define STMT_SELECT_NODE_CHILDREN_INFO 11
 
127
#define STMT_11_INFO {"STMT_SELECT_NODE_CHILDREN_INFO", NULL}
132
128
#define STMT_11 \
 
129
  "SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision, " \
 
130
  "  checksum, translated_size, changed_revision, changed_date, changed_author, " \
 
131
  "  depth, symlink_target, last_mod_time, properties, lock_token, lock_owner, " \
 
132
  "  lock_comment, lock_date, local_relpath, moved_here, moved_to, file_external " \
 
133
  "FROM nodes " \
 
134
  "LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id " \
 
135
  "  AND nodes.repos_path = lock.repos_relpath AND op_depth = 0 " \
 
136
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
 
137
  "ORDER BY local_relpath DESC, op_depth DESC " \
 
138
  ""
 
139
 
 
140
#define STMT_SELECT_BASE_NODE_CHILDREN_INFO 12
 
141
#define STMT_12_INFO {"STMT_SELECT_BASE_NODE_CHILDREN_INFO", NULL}
 
142
#define STMT_12 \
 
143
  "SELECT op_depth, nodes.repos_id, nodes.repos_path, presence, kind, revision, " \
 
144
  "  checksum, translated_size, changed_revision, changed_date, changed_author, " \
 
145
  "  depth, symlink_target, last_mod_time, properties, lock_token, lock_owner, " \
 
146
  "  lock_comment, lock_date, local_relpath, moved_here, moved_to, file_external " \
 
147
  "FROM nodes " \
 
148
  "LEFT OUTER JOIN lock ON nodes.repos_id = lock.repos_id " \
 
149
  "  AND nodes.repos_path = lock.repos_relpath AND op_depth = 0 " \
 
150
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0 " \
 
151
  "ORDER BY local_relpath DESC " \
 
152
  ""
 
153
 
 
154
#define STMT_SELECT_NODE_CHILDREN_WALKER_INFO 13
 
155
#define STMT_13_INFO {"STMT_SELECT_NODE_CHILDREN_WALKER_INFO", NULL}
 
156
#define STMT_13 \
133
157
  "SELECT local_relpath, op_depth, presence, kind " \
134
158
  "FROM nodes_current " \
135
159
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
 
160
  "ORDER BY local_relpath " \
136
161
  ""
137
162
 
138
 
#define STMT_SELECT_ACTUAL_CHILDREN_INFO 12
139
 
#define STMT_12_INFO {"STMT_SELECT_ACTUAL_CHILDREN_INFO", NULL}
140
 
#define STMT_12 \
 
163
#define STMT_SELECT_ACTUAL_CHILDREN_INFO 14
 
164
#define STMT_14_INFO {"STMT_SELECT_ACTUAL_CHILDREN_INFO", NULL}
 
165
#define STMT_14 \
141
166
  "SELECT local_relpath, changelist, properties, conflict_data " \
142
167
  "FROM actual_node " \
143
168
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
144
169
  ""
145
170
 
146
 
#define STMT_SELECT_REPOSITORY_BY_ID 13
147
 
#define STMT_13_INFO {"STMT_SELECT_REPOSITORY_BY_ID", NULL}
148
 
#define STMT_13 \
 
171
#define STMT_SELECT_REPOSITORY_BY_ID 15
 
172
#define STMT_15_INFO {"STMT_SELECT_REPOSITORY_BY_ID", NULL}
 
173
#define STMT_15 \
149
174
  "SELECT root, uuid FROM repository WHERE id = ?1 " \
150
175
  ""
151
176
 
152
 
#define STMT_SELECT_WCROOT_NULL 14
153
 
#define STMT_14_INFO {"STMT_SELECT_WCROOT_NULL", NULL}
154
 
#define STMT_14 \
 
177
#define STMT_SELECT_WCROOT_NULL 16
 
178
#define STMT_16_INFO {"STMT_SELECT_WCROOT_NULL", NULL}
 
179
#define STMT_16 \
155
180
  "SELECT id FROM wcroot WHERE local_abspath IS NULL " \
156
181
  ""
157
182
 
158
 
#define STMT_SELECT_REPOSITORY 15
159
 
#define STMT_15_INFO {"STMT_SELECT_REPOSITORY", NULL}
160
 
#define STMT_15 \
 
183
#define STMT_SELECT_REPOSITORY 17
 
184
#define STMT_17_INFO {"STMT_SELECT_REPOSITORY", NULL}
 
185
#define STMT_17 \
161
186
  "SELECT id FROM repository WHERE root = ?1 " \
162
187
  ""
163
188
 
164
 
#define STMT_INSERT_REPOSITORY 16
165
 
#define STMT_16_INFO {"STMT_INSERT_REPOSITORY", NULL}
166
 
#define STMT_16 \
 
189
#define STMT_INSERT_REPOSITORY 18
 
190
#define STMT_18_INFO {"STMT_INSERT_REPOSITORY", NULL}
 
191
#define STMT_18 \
167
192
  "INSERT INTO repository (root, uuid) VALUES (?1, ?2) " \
168
193
  ""
169
194
 
170
 
#define STMT_INSERT_NODE 17
171
 
#define STMT_17_INFO {"STMT_INSERT_NODE", NULL}
172
 
#define STMT_17 \
 
195
#define STMT_INSERT_NODE 19
 
196
#define STMT_19_INFO {"STMT_INSERT_NODE", NULL}
 
197
#define STMT_19 \
173
198
  "INSERT OR REPLACE INTO nodes ( " \
174
199
  "  wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
175
200
  "  revision, presence, depth, kind, changed_revision, changed_date, " \
180
205
  "        ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23) " \
181
206
  ""
182
207
 
183
 
#define STMT_SELECT_BASE_PRESENT 18
184
 
#define STMT_18_INFO {"STMT_SELECT_BASE_PRESENT", NULL}
185
 
#define STMT_18 \
186
 
  "SELECT local_relpath, kind FROM nodes n " \
187
 
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
188
 
  "  AND op_depth = 0 " \
189
 
  "  AND presence in ('normal', 'incomplete') " \
190
 
  "  AND NOT EXISTS(SELECT 1 FROM NODES w " \
191
 
  "                 WHERE w.wc_id = ?1 AND w.local_relpath = n.local_relpath " \
192
 
  "                   AND op_depth > 0) " \
193
 
  "ORDER BY local_relpath DESC " \
194
 
  ""
195
 
 
196
 
#define STMT_SELECT_WORKING_PRESENT 19
197
 
#define STMT_19_INFO {"STMT_SELECT_WORKING_PRESENT", NULL}
198
 
#define STMT_19 \
 
208
#define STMT_SELECT_WORKING_PRESENT 20
 
209
#define STMT_20_INFO {"STMT_SELECT_WORKING_PRESENT", NULL}
 
210
#define STMT_20 \
199
211
  "SELECT local_relpath, kind, checksum, translated_size, last_mod_time " \
200
212
  "FROM nodes n " \
201
213
  "WHERE wc_id = ?1 " \
208
220
  "ORDER BY local_relpath DESC " \
209
221
  ""
210
222
 
211
 
#define STMT_DELETE_NODE_RECURSIVE 20
212
 
#define STMT_20_INFO {"STMT_DELETE_NODE_RECURSIVE", NULL}
213
 
#define STMT_20 \
 
223
#define STMT_DELETE_NODE_RECURSIVE 21
 
224
#define STMT_21_INFO {"STMT_DELETE_NODE_RECURSIVE", NULL}
 
225
#define STMT_21 \
214
226
  "DELETE FROM NODES " \
215
227
  "WHERE wc_id = ?1 " \
216
228
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
217
229
  ""
218
230
 
219
 
#define STMT_DELETE_NODE 21
220
 
#define STMT_21_INFO {"STMT_DELETE_NODE", NULL}
221
 
#define STMT_21 \
 
231
#define STMT_DELETE_NODE 22
 
232
#define STMT_22_INFO {"STMT_DELETE_NODE", NULL}
 
233
#define STMT_22 \
222
234
  "DELETE " \
223
235
  "FROM NODES " \
224
236
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
225
237
  ""
226
238
 
227
 
#define STMT_DELETE_ACTUAL_FOR_BASE_RECURSIVE 22
228
 
#define STMT_22_INFO {"STMT_DELETE_ACTUAL_FOR_BASE_RECURSIVE", NULL}
229
 
#define STMT_22 \
 
239
#define STMT_DELETE_ACTUAL_FOR_BASE_RECURSIVE 23
 
240
#define STMT_23_INFO {"STMT_DELETE_ACTUAL_FOR_BASE_RECURSIVE", NULL}
 
241
#define STMT_23 \
230
242
  "DELETE FROM actual_node " \
231
243
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
232
244
  "  AND EXISTS(SELECT 1 FROM NODES b " \
240
252
  "                   AND presence in ('normal', 'incomplete', 'not-present')) " \
241
253
  ""
242
254
 
243
 
#define STMT_DELETE_WORKING_BASE_DELETE 23
244
 
#define STMT_23_INFO {"STMT_DELETE_WORKING_BASE_DELETE", NULL}
245
 
#define STMT_23 \
246
 
  "DELETE FROM nodes " \
247
 
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
248
 
  "  AND presence = 'base-deleted' " \
249
 
  "  AND op_depth > 0 " \
250
 
  "  AND op_depth = (SELECT MIN(op_depth) FROM nodes n " \
251
 
  "                    WHERE n.wc_id = ?1 " \
252
 
  "                      AND n.local_relpath = nodes.local_relpath " \
253
 
  "                      AND op_depth > 0) " \
254
 
  ""
255
 
 
256
 
#define STMT_DELETE_WORKING_RECURSIVE 24
257
 
#define STMT_24_INFO {"STMT_DELETE_WORKING_RECURSIVE", NULL}
 
255
#define STMT_DELETE_WORKING_BASE_DELETE 24
 
256
#define STMT_24_INFO {"STMT_DELETE_WORKING_BASE_DELETE", NULL}
258
257
#define STMT_24 \
259
258
  "DELETE FROM nodes " \
260
 
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
261
 
  "  AND op_depth > 0 " \
 
259
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
260
  "  AND presence = 'base-deleted' " \
 
261
  "  AND op_depth > ?3 " \
 
262
  "  AND op_depth = (SELECT MIN(op_depth) FROM nodes n " \
 
263
  "                    WHERE n.wc_id = ?1 " \
 
264
  "                      AND n.local_relpath = nodes.local_relpath " \
 
265
  "                      AND op_depth > ?3) " \
262
266
  ""
263
267
 
264
 
#define STMT_DELETE_BASE_RECURSIVE 25
265
 
#define STMT_25_INFO {"STMT_DELETE_BASE_RECURSIVE", NULL}
 
268
#define STMT_DELETE_WORKING_BASE_DELETE_RECURSIVE 25
 
269
#define STMT_25_INFO {"STMT_DELETE_WORKING_BASE_DELETE_RECURSIVE", NULL}
266
270
#define STMT_25 \
267
271
  "DELETE FROM nodes " \
268
272
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
269
 
  "  AND op_depth = 0 " \
 
273
  "  AND presence = 'base-deleted' " \
 
274
  "  AND op_depth > ?3 " \
 
275
  "  AND op_depth = (SELECT MIN(op_depth) FROM nodes n " \
 
276
  "                    WHERE n.wc_id = ?1 " \
 
277
  "                      AND n.local_relpath = nodes.local_relpath " \
 
278
  "                      AND op_depth > ?3) " \
270
279
  ""
271
280
 
272
 
#define STMT_DELETE_WORKING_OP_DEPTH 26
273
 
#define STMT_26_INFO {"STMT_DELETE_WORKING_OP_DEPTH", NULL}
 
281
#define STMT_DELETE_WORKING_RECURSIVE 26
 
282
#define STMT_26_INFO {"STMT_DELETE_WORKING_RECURSIVE", NULL}
274
283
#define STMT_26 \
275
284
  "DELETE FROM nodes " \
276
 
  "WHERE wc_id = ?1 " \
277
 
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
278
 
  "  AND op_depth = ?3 " \
 
285
  "WHERE wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
286
  "  AND op_depth > 0 " \
279
287
  ""
280
288
 
281
 
#define STMT_DELETE_WORKING_OP_DEPTH_ABOVE 27
282
 
#define STMT_27_INFO {"STMT_DELETE_WORKING_OP_DEPTH_ABOVE", NULL}
 
289
#define STMT_DELETE_BASE_RECURSIVE 27
 
290
#define STMT_27_INFO {"STMT_DELETE_BASE_RECURSIVE", NULL}
283
291
#define STMT_27 \
284
292
  "DELETE FROM nodes " \
285
 
  "WHERE wc_id = ?1 " \
286
 
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
287
 
  "  AND op_depth > ?3 " \
 
293
  "WHERE wc_id = ?1 AND (local_relpath = ?2 " \
 
294
  "                      OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
295
  "  AND op_depth = 0 " \
288
296
  ""
289
297
 
290
 
#define STMT_SELECT_LOCAL_RELPATH_OP_DEPTH 28
291
 
#define STMT_28_INFO {"STMT_SELECT_LOCAL_RELPATH_OP_DEPTH", NULL}
 
298
#define STMT_DELETE_WORKING_OP_DEPTH 28
 
299
#define STMT_28_INFO {"STMT_DELETE_WORKING_OP_DEPTH", NULL}
292
300
#define STMT_28 \
293
 
  "SELECT local_relpath " \
294
 
  "FROM nodes " \
 
301
  "DELETE FROM nodes " \
295
302
  "WHERE wc_id = ?1 " \
296
303
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
297
304
  "  AND op_depth = ?3 " \
298
305
  ""
299
306
 
300
 
#define STMT_SELECT_CHILDREN_OP_DEPTH 29
301
 
#define STMT_29_INFO {"STMT_SELECT_CHILDREN_OP_DEPTH", NULL}
 
307
#define STMT_SELECT_LAYER_FOR_REPLACE 29
 
308
#define STMT_29_INFO {"STMT_SELECT_LAYER_FOR_REPLACE", NULL}
302
309
#define STMT_29 \
303
 
  "SELECT local_relpath, kind " \
304
 
  "FROM nodes " \
305
 
  "WHERE wc_id = ?1 " \
306
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
307
 
  "  AND op_depth = ?3 " \
308
 
  "ORDER BY local_relpath DESC " \
 
310
  "SELECT s.local_relpath, s.kind, " \
 
311
  "  (CASE WHEN (?2) = '' THEN (CASE WHEN (?4) = '' THEN (s.local_relpath) WHEN (s.local_relpath) = '' THEN (?4) ELSE (?4) || '/' || (s.local_relpath) END) WHEN (?4) = '' THEN (CASE WHEN (?2) = '' THEN (s.local_relpath)  WHEN SUBSTR((s.local_relpath), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(s.local_relpath) THEN '' WHEN SUBSTR((s.local_relpath), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((s.local_relpath), LENGTH(?2)+2) END END) WHEN SUBSTR((s.local_relpath), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(s.local_relpath) THEN (?4) WHEN SUBSTR((s.local_relpath), LENGTH(?2)+1, 1) = '/' THEN (?4) || SUBSTR((s.local_relpath), LENGTH(?2)+1) END END) drp, 'normal' " \
 
312
  "FROM nodes s " \
 
313
  "WHERE s.wc_id = ?1 AND s.local_relpath = ?2 AND s.op_depth = ?3 " \
 
314
  "UNION ALL " \
 
315
  "SELECT s.local_relpath, s.kind, " \
 
316
  "  (CASE WHEN (?2) = '' THEN (CASE WHEN (?4) = '' THEN (s.local_relpath) WHEN (s.local_relpath) = '' THEN (?4) ELSE (?4) || '/' || (s.local_relpath) END) WHEN (?4) = '' THEN (CASE WHEN (?2) = '' THEN (s.local_relpath)  WHEN SUBSTR((s.local_relpath), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(s.local_relpath) THEN '' WHEN SUBSTR((s.local_relpath), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((s.local_relpath), LENGTH(?2)+2) END END) WHEN SUBSTR((s.local_relpath), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(s.local_relpath) THEN (?4) WHEN SUBSTR((s.local_relpath), LENGTH(?2)+1, 1) = '/' THEN (?4) || SUBSTR((s.local_relpath), LENGTH(?2)+1) END END) drp, d.presence " \
 
317
  "FROM nodes s " \
 
318
  "LEFT OUTER JOIN nodes d ON d.wc_id= ?1 AND d.op_depth = ?5 " \
 
319
  "     AND d.local_relpath = drp " \
 
320
  "WHERE s.wc_id = ?1 " \
 
321
  "  AND (((s.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((s.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
322
  "  AND s.op_depth = ?3 " \
 
323
  "ORDER BY s.local_relpath " \
309
324
  ""
310
325
 
311
 
#define STMT_COPY_NODE_MOVE 30
312
 
#define STMT_30_INFO {"STMT_COPY_NODE_MOVE", NULL}
 
326
#define STMT_SELECT_DESCENDANTS_OP_DEPTH_RV 30
 
327
#define STMT_30_INFO {"STMT_SELECT_DESCENDANTS_OP_DEPTH_RV", NULL}
313
328
#define STMT_30 \
314
 
  "INSERT OR REPLACE INTO nodes ( " \
315
 
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
316
 
  "    revision, presence, depth, kind, changed_revision, changed_date, " \
317
 
  "    changed_author, checksum, properties, translated_size, last_mod_time, " \
318
 
  "    symlink_target, moved_here, moved_to ) " \
319
 
  "SELECT " \
320
 
  "    wc_id, ?4 , ?5 , ?6 , " \
321
 
  "    repos_id, " \
322
 
  "    repos_path, revision, presence, depth, kind, changed_revision, " \
323
 
  "    changed_date, changed_author, checksum, properties, translated_size, " \
324
 
  "    last_mod_time, symlink_target, 1, " \
325
 
  "    (SELECT dst.moved_to FROM nodes AS dst " \
326
 
  "                         WHERE dst.wc_id = ?1 " \
327
 
  "                         AND dst.local_relpath = ?4 " \
328
 
  "                         AND dst.op_depth = ?5) " \
 
329
  "SELECT local_relpath, kind " \
329
330
  "FROM nodes " \
330
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
331
  "WHERE wc_id = ?1 " \
 
332
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
333
  "  AND op_depth = ?3 " \
 
334
  "  AND presence in ('normal', 'incomplete') " \
 
335
  "ORDER BY local_relpath DESC " \
331
336
  ""
332
337
 
333
 
#define STMT_SELECT_OP_DEPTH_CHILDREN 31
334
 
#define STMT_31_INFO {"STMT_SELECT_OP_DEPTH_CHILDREN", NULL}
 
338
#define STMT_COPY_NODE_MOVE 31
 
339
#define STMT_31_INFO {"STMT_COPY_NODE_MOVE", NULL}
335
340
#define STMT_31 \
 
341
  "INSERT OR REPLACE INTO nodes ( " \
 
342
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
 
343
  "    revision, presence, depth, kind, changed_revision, changed_date, " \
 
344
  "    changed_author, checksum, properties, translated_size, last_mod_time, " \
 
345
  "    symlink_target, moved_here, moved_to ) " \
 
346
  "SELECT " \
 
347
  "    s.wc_id, ?4 , ?5 , ?6 , " \
 
348
  "    s.repos_id, " \
 
349
  "    s.repos_path, s.revision, s.presence, s.depth, s.kind, s.changed_revision, " \
 
350
  "    s.changed_date, s.changed_author, s.checksum, s.properties, " \
 
351
  "    CASE WHEN d.checksum=s.checksum THEN d.translated_size END, " \
 
352
  "    CASE WHEN d.checksum=s.checksum THEN d.last_mod_time END, " \
 
353
  "    s.symlink_target, 1, d.moved_to " \
 
354
  "FROM nodes s " \
 
355
  "LEFT JOIN nodes d ON d.wc_id=?1 AND d.local_relpath=?4 AND d.op_depth=?5 " \
 
356
  "WHERE s.wc_id = ?1 AND s.local_relpath = ?2 AND s.op_depth = ?3 " \
 
357
  ""
 
358
 
 
359
#define STMT_SELECT_NO_LONGER_MOVED_RV 32
 
360
#define STMT_32_INFO {"STMT_SELECT_NO_LONGER_MOVED_RV", NULL}
 
361
#define STMT_32 \
 
362
  "SELECT d.local_relpath, (CASE WHEN (?2) = '' THEN (CASE WHEN (?4) = '' THEN (d.local_relpath) WHEN (d.local_relpath) = '' THEN (?4) ELSE (?4) || '/' || (d.local_relpath) END) WHEN (?4) = '' THEN (CASE WHEN (?2) = '' THEN (d.local_relpath)  WHEN SUBSTR((d.local_relpath), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(d.local_relpath) THEN '' WHEN SUBSTR((d.local_relpath), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((d.local_relpath), LENGTH(?2)+2) END END) WHEN SUBSTR((d.local_relpath), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(d.local_relpath) THEN (?4) WHEN SUBSTR((d.local_relpath), LENGTH(?2)+1, 1) = '/' THEN (?4) || SUBSTR((d.local_relpath), LENGTH(?2)+1) END END) srp, " \
 
363
  "       b.presence, b.op_depth " \
 
364
  "FROM nodes d " \
 
365
  "LEFT OUTER JOIN nodes b ON b.wc_id = ?1 AND b.local_relpath = d.local_relpath " \
 
366
  "            AND b.op_depth = (SELECT MAX(x.op_depth) FROM nodes x " \
 
367
  "                              WHERE x.wc_id = ?1 " \
 
368
  "                                AND x.local_relpath = b.local_relpath " \
 
369
  "                                AND x.op_depth < ?3) " \
 
370
  "WHERE d.wc_id = ?1 " \
 
371
  "  AND (((d.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((d.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
372
  "  AND d.op_depth = ?3 " \
 
373
  "  AND NOT EXISTS(SELECT * FROM nodes s " \
 
374
  "                 WHERE s.wc_id = ?1 " \
 
375
  "                   AND s.local_relpath = srp " \
 
376
  "                   AND s.op_depth = ?5) " \
 
377
  "ORDER BY d.local_relpath DESC " \
 
378
  ""
 
379
 
 
380
#define STMT_SELECT_OP_DEPTH_CHILDREN 33
 
381
#define STMT_33_INFO {"STMT_SELECT_OP_DEPTH_CHILDREN", NULL}
 
382
#define STMT_33 \
336
383
  "SELECT local_relpath, kind FROM nodes " \
337
384
  "WHERE wc_id = ?1 " \
338
385
  "  AND parent_relpath = ?2 " \
339
386
  "  AND op_depth = ?3 " \
340
387
  "  AND presence != 'base-deleted' " \
341
388
  "  AND file_external is NULL " \
342
 
  ""
343
 
 
344
 
#define STMT_SELECT_GE_OP_DEPTH_CHILDREN 32
345
 
#define STMT_32_INFO {"STMT_SELECT_GE_OP_DEPTH_CHILDREN", NULL}
346
 
#define STMT_32 \
 
389
  "ORDER BY local_relpath " \
 
390
  ""
 
391
 
 
392
#define STMT_SELECT_OP_DEPTH_CHILDREN_EXISTS 34
 
393
#define STMT_34_INFO {"STMT_SELECT_OP_DEPTH_CHILDREN_EXISTS", NULL}
 
394
#define STMT_34 \
 
395
  "SELECT local_relpath, kind FROM nodes " \
 
396
  "WHERE wc_id = ?1 " \
 
397
  "  AND parent_relpath = ?2 " \
 
398
  "  AND op_depth = ?3 " \
 
399
  "  AND presence IN ('normal', 'incomplete') " \
 
400
  "ORDER BY local_relpath " \
 
401
  ""
 
402
 
 
403
#define STMT_SELECT_GE_OP_DEPTH_CHILDREN 35
 
404
#define STMT_35_INFO {"STMT_SELECT_GE_OP_DEPTH_CHILDREN", NULL}
 
405
#define STMT_35 \
347
406
  "SELECT 1 FROM nodes " \
348
407
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
349
 
  "  AND (op_depth > ?3 OR (op_depth = ?3 AND presence != 'base-deleted')) " \
 
408
  "  AND (op_depth > ?3 OR (op_depth = ?3 " \
 
409
  "                         AND presence IN ('normal', 'incomplete'))) " \
350
410
  "UNION ALL " \
351
411
  "SELECT 1 FROM ACTUAL_NODE a " \
352
412
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
354
414
  "                   WHERE wc_id = ?1 AND n.local_relpath = a.local_relpath) " \
355
415
  ""
356
416
 
357
 
#define STMT_DELETE_SHADOWED_RECURSIVE 33
358
 
#define STMT_33_INFO {"STMT_DELETE_SHADOWED_RECURSIVE", NULL}
359
 
#define STMT_33 \
 
417
#define STMT_DELETE_SHADOWED_RECURSIVE 36
 
418
#define STMT_36_INFO {"STMT_DELETE_SHADOWED_RECURSIVE", NULL}
 
419
#define STMT_36 \
360
420
  "DELETE FROM nodes " \
361
421
  "WHERE wc_id = ?1 " \
362
422
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
364
424
  "       OR (op_depth = ?3 AND presence = 'base-deleted')) " \
365
425
  ""
366
426
 
367
 
#define STMT_CLEAR_MOVED_TO_FROM_DEST 34
368
 
#define STMT_34_INFO {"STMT_CLEAR_MOVED_TO_FROM_DEST", NULL}
369
 
#define STMT_34 \
 
427
#define STMT_CLEAR_MOVED_TO_FROM_DEST 37
 
428
#define STMT_37_INFO {"STMT_CLEAR_MOVED_TO_FROM_DEST", NULL}
 
429
#define STMT_37 \
370
430
  "UPDATE NODES SET moved_to = NULL " \
371
431
  "WHERE wc_id = ?1 " \
372
432
  "  AND moved_to = ?2 " \
373
433
  ""
374
434
 
375
 
#define STMT_SELECT_NOT_PRESENT_DESCENDANTS 35
376
 
#define STMT_35_INFO {"STMT_SELECT_NOT_PRESENT_DESCENDANTS", NULL}
377
 
#define STMT_35 \
 
435
#define STMT_SELECT_NOT_PRESENT_DESCENDANTS 38
 
436
#define STMT_38_INFO {"STMT_SELECT_NOT_PRESENT_DESCENDANTS", NULL}
 
437
#define STMT_38 \
378
438
  "SELECT local_relpath FROM nodes " \
379
439
  "WHERE wc_id = ?1 AND op_depth = ?3 " \
380
440
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
381
441
  "  AND presence = 'not-present' " \
382
442
  ""
383
443
 
384
 
#define STMT_COMMIT_DESCENDANTS_TO_BASE 36
385
 
#define STMT_36_INFO {"STMT_COMMIT_DESCENDANTS_TO_BASE", NULL}
386
 
#define STMT_36 \
 
444
#define STMT_COMMIT_DESCENDANTS_TO_BASE 39
 
445
#define STMT_39_INFO {"STMT_COMMIT_DESCENDANTS_TO_BASE", NULL}
 
446
#define STMT_39 \
387
447
  "UPDATE NODES SET op_depth = 0, " \
388
448
  "                 repos_id = ?4, " \
389
 
  "                 repos_path = ?5 || SUBSTR(local_relpath, LENGTH(?2)+1), " \
 
449
  "                 repos_path = (CASE WHEN (?2) = '' THEN (CASE WHEN (?5) = '' THEN (local_relpath) WHEN (local_relpath) = '' THEN (?5) ELSE (?5) || '/' || (local_relpath) END) WHEN (?5) = '' THEN (CASE WHEN (?2) = '' THEN (local_relpath)  WHEN SUBSTR((local_relpath), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(local_relpath) THEN '' WHEN SUBSTR((local_relpath), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((local_relpath), LENGTH(?2)+2) END END) WHEN SUBSTR((local_relpath), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(local_relpath) THEN (?5) WHEN SUBSTR((local_relpath), LENGTH(?2)+1, 1) = '/' THEN (?5) || SUBSTR((local_relpath), LENGTH(?2)+1) END END), " \
390
450
  "                 revision = ?6, " \
391
451
  "                 dav_cache = NULL, " \
392
452
  "                 moved_here = NULL, " \
 
453
  "                 moved_to = NULL, " \
393
454
  "                 presence = CASE presence " \
394
455
  "                              WHEN 'normal' THEN 'normal' " \
395
456
  "                              WHEN 'excluded' THEN 'excluded' " \
400
461
  "  AND op_depth = ?3 " \
401
462
  ""
402
463
 
403
 
#define STMT_SELECT_NODE_CHILDREN 37
404
 
#define STMT_37_INFO {"STMT_SELECT_NODE_CHILDREN", NULL}
405
 
#define STMT_37 \
406
 
  "SELECT local_relpath FROM nodes " \
 
464
#define STMT_SELECT_NODE_CHILDREN 40
 
465
#define STMT_40_INFO {"STMT_SELECT_NODE_CHILDREN", NULL}
 
466
#define STMT_40 \
 
467
  "SELECT DISTINCT local_relpath FROM nodes " \
407
468
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
 
469
  "ORDER BY local_relpath " \
408
470
  ""
409
471
 
410
 
#define STMT_SELECT_WORKING_CHILDREN 38
411
 
#define STMT_38_INFO {"STMT_SELECT_WORKING_CHILDREN", NULL}
412
 
#define STMT_38 \
413
 
  "SELECT local_relpath FROM nodes " \
 
472
#define STMT_SELECT_WORKING_CHILDREN 41
 
473
#define STMT_41_INFO {"STMT_SELECT_WORKING_CHILDREN", NULL}
 
474
#define STMT_41 \
 
475
  "SELECT DISTINCT local_relpath FROM nodes " \
414
476
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
415
477
  "  AND (op_depth > (SELECT MAX(op_depth) FROM nodes " \
416
478
  "                   WHERE wc_id = ?1 AND local_relpath = ?2) " \
417
479
  "       OR " \
418
480
  "       (op_depth = (SELECT MAX(op_depth) FROM nodes " \
419
481
  "                    WHERE wc_id = ?1 AND local_relpath = ?2) " \
420
 
  "        AND presence != 'base-deleted')) " \
421
 
  ""
422
 
 
423
 
#define STMT_SELECT_NODE_PROPS 39
424
 
#define STMT_39_INFO {"STMT_SELECT_NODE_PROPS", NULL}
425
 
#define STMT_39 \
 
482
  "        AND presence IN ('normal', 'incomplete'))) " \
 
483
  "ORDER BY local_relpath " \
 
484
  ""
 
485
 
 
486
#define STMT_SELECT_BASE_NOT_PRESENT_CHILDREN 42
 
487
#define STMT_42_INFO {"STMT_SELECT_BASE_NOT_PRESENT_CHILDREN", NULL}
 
488
#define STMT_42 \
 
489
  "SELECT local_relpath FROM nodes " \
 
490
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0 " \
 
491
  "  AND presence = 'not-present' " \
 
492
  "ORDER BY local_relpath " \
 
493
  ""
 
494
 
 
495
#define STMT_SELECT_NODE_PROPS 43
 
496
#define STMT_43_INFO {"STMT_SELECT_NODE_PROPS", NULL}
 
497
#define STMT_43 \
426
498
  "SELECT properties, presence FROM nodes " \
427
499
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
428
500
  "ORDER BY op_depth DESC " \
429
501
  ""
430
502
 
431
 
#define STMT_SELECT_ACTUAL_PROPS 40
432
 
#define STMT_40_INFO {"STMT_SELECT_ACTUAL_PROPS", NULL}
433
 
#define STMT_40 \
 
503
#define STMT_SELECT_ACTUAL_PROPS 44
 
504
#define STMT_44_INFO {"STMT_SELECT_ACTUAL_PROPS", NULL}
 
505
#define STMT_44 \
434
506
  "SELECT properties FROM actual_node " \
435
507
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
436
508
  ""
437
509
 
438
 
#define STMT_UPDATE_ACTUAL_PROPS 41
439
 
#define STMT_41_INFO {"STMT_UPDATE_ACTUAL_PROPS", NULL}
440
 
#define STMT_41 \
 
510
#define STMT_UPDATE_ACTUAL_PROPS 45
 
511
#define STMT_45_INFO {"STMT_UPDATE_ACTUAL_PROPS", NULL}
 
512
#define STMT_45 \
441
513
  "UPDATE actual_node SET properties = ?3 " \
442
514
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
443
515
  ""
444
516
 
445
 
#define STMT_INSERT_ACTUAL_PROPS 42
446
 
#define STMT_42_INFO {"STMT_INSERT_ACTUAL_PROPS", NULL}
447
 
#define STMT_42 \
 
517
#define STMT_INSERT_ACTUAL_PROPS 46
 
518
#define STMT_46_INFO {"STMT_INSERT_ACTUAL_PROPS", NULL}
 
519
#define STMT_46 \
448
520
  "INSERT INTO actual_node (wc_id, local_relpath, parent_relpath, properties) " \
449
521
  "VALUES (?1, ?2, ?3, ?4) " \
450
522
  ""
451
523
 
452
 
#define STMT_INSERT_LOCK 43
453
 
#define STMT_43_INFO {"STMT_INSERT_LOCK", NULL}
454
 
#define STMT_43 \
 
524
#define STMT_INSERT_LOCK 47
 
525
#define STMT_47_INFO {"STMT_INSERT_LOCK", NULL}
 
526
#define STMT_47 \
455
527
  "INSERT OR REPLACE INTO lock " \
456
528
  "(repos_id, repos_relpath, lock_token, lock_owner, lock_comment, " \
457
529
  " lock_date) " \
458
530
  "VALUES (?1, ?2, ?3, ?4, ?5, ?6) " \
459
531
  ""
460
532
 
461
 
#define STMT_SELECT_BASE_NODE_LOCK_TOKENS_RECURSIVE 44
462
 
#define STMT_44_INFO {"STMT_SELECT_BASE_NODE_LOCK_TOKENS_RECURSIVE", NULL}
463
 
#define STMT_44 \
 
533
#define STMT_SELECT_BASE_NODE_LOCK_TOKENS_RECURSIVE 48
 
534
#define STMT_48_INFO {"STMT_SELECT_BASE_NODE_LOCK_TOKENS_RECURSIVE", NULL}
 
535
#define STMT_48 \
464
536
  "SELECT nodes.repos_id, nodes.repos_path, lock_token " \
465
537
  "FROM nodes " \
466
538
  "LEFT JOIN lock ON nodes.repos_id = lock.repos_id " \
469
541
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
470
542
  ""
471
543
 
472
 
#define STMT_INSERT_WCROOT 45
473
 
#define STMT_45_INFO {"STMT_INSERT_WCROOT", NULL}
474
 
#define STMT_45 \
 
544
#define STMT_INSERT_WCROOT 49
 
545
#define STMT_49_INFO {"STMT_INSERT_WCROOT", NULL}
 
546
#define STMT_49 \
475
547
  "INSERT INTO wcroot (local_abspath) " \
476
548
  "VALUES (?1) " \
477
549
  ""
478
550
 
479
 
#define STMT_UPDATE_BASE_NODE_DAV_CACHE 46
480
 
#define STMT_46_INFO {"STMT_UPDATE_BASE_NODE_DAV_CACHE", NULL}
481
 
#define STMT_46 \
 
551
#define STMT_UPDATE_BASE_NODE_DAV_CACHE 50
 
552
#define STMT_50_INFO {"STMT_UPDATE_BASE_NODE_DAV_CACHE", NULL}
 
553
#define STMT_50 \
482
554
  "UPDATE nodes SET dav_cache = ?3 " \
483
555
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
484
556
  ""
485
557
 
486
 
#define STMT_SELECT_BASE_DAV_CACHE 47
487
 
#define STMT_47_INFO {"STMT_SELECT_BASE_DAV_CACHE", NULL}
488
 
#define STMT_47 \
 
558
#define STMT_SELECT_BASE_DAV_CACHE 51
 
559
#define STMT_51_INFO {"STMT_SELECT_BASE_DAV_CACHE", NULL}
 
560
#define STMT_51 \
489
561
  "SELECT dav_cache FROM nodes " \
490
562
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
491
563
  ""
492
564
 
493
 
#define STMT_SELECT_DELETION_INFO 48
494
 
#define STMT_48_INFO {"STMT_SELECT_DELETION_INFO", NULL}
495
 
#define STMT_48 \
496
 
  "SELECT (SELECT b.presence FROM nodes AS b " \
497
 
  "         WHERE b.wc_id = ?1 AND b.local_relpath = ?2 AND b.op_depth = 0), " \
498
 
  "       work.presence, work.op_depth " \
499
 
  "FROM nodes_current AS work " \
500
 
  "WHERE work.wc_id = ?1 AND work.local_relpath = ?2 AND work.op_depth > 0 " \
501
 
  "LIMIT 1 " \
502
 
  ""
503
 
 
504
 
#define STMT_SELECT_DELETION_INFO_SCAN 49
505
 
#define STMT_49_INFO {"STMT_SELECT_DELETION_INFO_SCAN", NULL}
506
 
#define STMT_49 \
507
 
  "SELECT (SELECT b.presence FROM nodes AS b " \
508
 
  "         WHERE b.wc_id = ?1 AND b.local_relpath = ?2 AND b.op_depth = 0), " \
509
 
  "       work.presence, work.op_depth, moved.moved_to " \
510
 
  "FROM nodes_current AS work " \
511
 
  "LEFT OUTER JOIN nodes AS moved " \
512
 
  "  ON moved.wc_id = work.wc_id " \
513
 
  " AND moved.local_relpath = work.local_relpath " \
514
 
  " AND moved.moved_to IS NOT NULL " \
515
 
  "WHERE work.wc_id = ?1 AND work.local_relpath = ?2 AND work.op_depth > 0 " \
516
 
  "LIMIT 1 " \
517
 
  ""
518
 
 
519
 
#define STMT_SELECT_MOVED_TO_NODE 50
520
 
#define STMT_50_INFO {"STMT_SELECT_MOVED_TO_NODE", NULL}
521
 
#define STMT_50 \
522
 
  "SELECT op_depth, moved_to " \
523
 
  "FROM nodes " \
524
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND moved_to IS NOT NULL " \
525
 
  "ORDER BY op_depth DESC " \
526
 
  ""
527
 
 
528
 
#define STMT_SELECT_OP_DEPTH_MOVED_TO 51
529
 
#define STMT_51_INFO {"STMT_SELECT_OP_DEPTH_MOVED_TO", NULL}
530
 
#define STMT_51 \
531
 
  "SELECT op_depth, moved_to, repos_path, revision " \
532
 
  "FROM nodes " \
533
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
534
 
  " AND op_depth <= (SELECT MIN(op_depth) FROM nodes " \
535
 
  "                  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3) " \
536
 
  "ORDER BY op_depth DESC " \
537
 
  ""
538
 
 
539
 
#define STMT_SELECT_MOVED_TO 52
540
 
#define STMT_52_INFO {"STMT_SELECT_MOVED_TO", NULL}
 
565
#define STMT_SELECT_DELETION_INFO 52
 
566
#define STMT_52_INFO {"STMT_SELECT_DELETION_INFO", NULL}
541
567
#define STMT_52 \
542
 
  "SELECT moved_to " \
543
 
  "FROM nodes " \
544
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
568
  "SELECT b.presence, w.presence, w.op_depth, w.moved_to " \
 
569
  "FROM nodes w " \
 
570
  "LEFT JOIN nodes b ON b.wc_id = ?1 AND b.local_relpath = ?2 AND b.op_depth = 0 " \
 
571
  "WHERE w.wc_id = ?1 AND w.local_relpath = ?2 " \
 
572
  "  AND w.op_depth = (SELECT MAX(op_depth) FROM nodes d " \
 
573
  "                    WHERE d.wc_id = ?1 AND d.local_relpath = ?2 " \
 
574
  "                      AND d.op_depth > 0) " \
 
575
  "LIMIT 1 " \
545
576
  ""
546
577
 
547
 
#define STMT_SELECT_MOVED_HERE 53
548
 
#define STMT_53_INFO {"STMT_SELECT_MOVED_HERE", NULL}
 
578
#define STMT_SELECT_MOVED_TO_NODE 53
 
579
#define STMT_53_INFO {"STMT_SELECT_MOVED_TO_NODE", NULL}
549
580
#define STMT_53 \
550
 
  "SELECT moved_here, presence, repos_path, revision " \
 
581
  "SELECT op_depth, moved_to " \
551
582
  "FROM nodes " \
552
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth >= ?3 " \
553
 
  "ORDER BY op_depth " \
 
583
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND moved_to IS NOT NULL " \
 
584
  "ORDER BY op_depth DESC " \
554
585
  ""
555
586
 
556
 
#define STMT_SELECT_MOVED_BACK 54
557
 
#define STMT_54_INFO {"STMT_SELECT_MOVED_BACK", NULL}
 
587
#define STMT_SELECT_OP_DEPTH_MOVED_TO 54
 
588
#define STMT_54_INFO {"STMT_SELECT_OP_DEPTH_MOVED_TO", NULL}
558
589
#define STMT_54 \
 
590
  "SELECT op_depth, moved_to " \
 
591
  "FROM nodes " \
 
592
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3 " \
 
593
  "  AND EXISTS(SELECT * from nodes " \
 
594
  "             WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
595
  "             AND presence IN ('normal', 'incomplete')) " \
 
596
  "ORDER BY op_depth ASC " \
 
597
  "LIMIT 1 " \
 
598
  ""
 
599
 
 
600
#define STMT_SELECT_MOVED_TO 55
 
601
#define STMT_55_INFO {"STMT_SELECT_MOVED_TO", NULL}
 
602
#define STMT_55 \
 
603
  "SELECT moved_to " \
 
604
  "FROM nodes " \
 
605
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
606
  ""
 
607
 
 
608
#define STMT_SELECT_MOVED_BACK 56
 
609
#define STMT_56_INFO {"STMT_SELECT_MOVED_BACK", NULL}
 
610
#define STMT_56 \
559
611
  "SELECT u.local_relpath, " \
560
612
  "       u.presence, u.repos_id, u.repos_path, u.revision, " \
561
613
  "       l.presence, l.repos_id, l.repos_path, l.revision, " \
581
633
  "  AND u.op_depth = ?4 " \
582
634
  ""
583
635
 
584
 
#define STMT_DELETE_MOVED_BACK 55
585
 
#define STMT_55_INFO {"STMT_DELETE_MOVED_BACK", NULL}
586
 
#define STMT_55 \
587
 
  "DELETE FROM nodes " \
588
 
  "WHERE wc_id = ?1 " \
589
 
  "  AND (local_relpath = ?2 " \
590
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
591
 
  "  AND op_depth = ?3 " \
592
 
  ""
593
 
 
594
 
#define STMT_DELETE_LOCK 56
595
 
#define STMT_56_INFO {"STMT_DELETE_LOCK", NULL}
596
 
#define STMT_56 \
 
636
#define STMT_DELETE_LOCK 57
 
637
#define STMT_57_INFO {"STMT_DELETE_LOCK", NULL}
 
638
#define STMT_57 \
597
639
  "DELETE FROM lock " \
598
640
  "WHERE repos_id = ?1 AND repos_relpath = ?2 " \
599
641
  ""
600
642
 
601
 
#define STMT_DELETE_LOCK_RECURSIVELY 57
602
 
#define STMT_57_INFO {"STMT_DELETE_LOCK_RECURSIVELY", NULL}
603
 
#define STMT_57 \
 
643
#define STMT_DELETE_LOCK_RECURSIVELY 58
 
644
#define STMT_58_INFO {"STMT_DELETE_LOCK_RECURSIVELY", NULL}
 
645
#define STMT_58 \
604
646
  "DELETE FROM lock " \
605
647
  "WHERE repos_id = ?1 AND (repos_relpath = ?2 OR (((repos_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((repos_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
606
648
  ""
607
649
 
608
 
#define STMT_CLEAR_BASE_NODE_RECURSIVE_DAV_CACHE 58
609
 
#define STMT_58_INFO {"STMT_CLEAR_BASE_NODE_RECURSIVE_DAV_CACHE", NULL}
610
 
#define STMT_58 \
 
650
#define STMT_CLEAR_BASE_NODE_RECURSIVE_DAV_CACHE 59
 
651
#define STMT_59_INFO {"STMT_CLEAR_BASE_NODE_RECURSIVE_DAV_CACHE", NULL}
 
652
#define STMT_59 \
611
653
  "UPDATE nodes SET dav_cache = NULL " \
612
654
  "WHERE dav_cache IS NOT NULL AND wc_id = ?1 AND op_depth = 0 " \
613
655
  "  AND (local_relpath = ?2 " \
614
656
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
615
657
  ""
616
658
 
617
 
#define STMT_RECURSIVE_UPDATE_NODE_REPO 59
618
 
#define STMT_59_INFO {"STMT_RECURSIVE_UPDATE_NODE_REPO", NULL}
619
 
#define STMT_59 \
 
659
#define STMT_RECURSIVE_UPDATE_NODE_REPO 60
 
660
#define STMT_60_INFO {"STMT_RECURSIVE_UPDATE_NODE_REPO", NULL}
 
661
#define STMT_60 \
620
662
  "UPDATE nodes SET repos_id = ?4, dav_cache = NULL " \
621
663
  "WHERE (wc_id = ?1 AND local_relpath = ?2 AND repos_id = ?3) " \
622
664
  "   OR (wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
623
665
  "       AND repos_id = ?3) " \
624
666
  ""
625
667
 
626
 
#define STMT_UPDATE_LOCK_REPOS_ID 60
627
 
#define STMT_60_INFO {"STMT_UPDATE_LOCK_REPOS_ID", NULL}
628
 
#define STMT_60 \
 
668
#define STMT_UPDATE_LOCK_REPOS_ID 61
 
669
#define STMT_61_INFO {"STMT_UPDATE_LOCK_REPOS_ID", NULL}
 
670
#define STMT_61 \
629
671
  "UPDATE lock SET repos_id = ?2 " \
630
672
  "WHERE repos_id = ?1 " \
631
673
  ""
632
674
 
633
 
#define STMT_UPDATE_NODE_FILEINFO 61
634
 
#define STMT_61_INFO {"STMT_UPDATE_NODE_FILEINFO", NULL}
635
 
#define STMT_61 \
 
675
#define STMT_UPDATE_NODE_FILEINFO 62
 
676
#define STMT_62_INFO {"STMT_UPDATE_NODE_FILEINFO", NULL}
 
677
#define STMT_62 \
636
678
  "UPDATE nodes SET translated_size = ?3, last_mod_time = ?4 " \
637
679
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
638
680
  "  AND op_depth = (SELECT MAX(op_depth) FROM nodes " \
639
681
  "                  WHERE wc_id = ?1 AND local_relpath = ?2) " \
640
682
  ""
641
683
 
642
 
#define STMT_INSERT_ACTUAL_CONFLICT 62
643
 
#define STMT_62_INFO {"STMT_INSERT_ACTUAL_CONFLICT", NULL}
644
 
#define STMT_62 \
645
 
  "INSERT INTO actual_node (wc_id, local_relpath, conflict_data, parent_relpath) " \
646
 
  "VALUES (?1, ?2, ?3, ?4) " \
647
 
  ""
648
 
 
649
 
#define STMT_UPDATE_ACTUAL_CONFLICT 63
650
 
#define STMT_63_INFO {"STMT_UPDATE_ACTUAL_CONFLICT", NULL}
 
684
#define STMT_INSERT_ACTUAL_CONFLICT 63
 
685
#define STMT_63_INFO {"STMT_INSERT_ACTUAL_CONFLICT", NULL}
651
686
#define STMT_63 \
652
 
  "UPDATE actual_node SET conflict_data = ?3 " \
653
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
687
  "INSERT INTO actual_node (wc_id, local_relpath, conflict_data, parent_relpath) " \
 
688
  "VALUES (?1, ?2, ?3, ?4) " \
654
689
  ""
655
690
 
656
 
#define STMT_UPDATE_ACTUAL_CHANGELISTS 64
657
 
#define STMT_64_INFO {"STMT_UPDATE_ACTUAL_CHANGELISTS", NULL}
 
691
#define STMT_UPDATE_ACTUAL_CONFLICT 64
 
692
#define STMT_64_INFO {"STMT_UPDATE_ACTUAL_CONFLICT", NULL}
658
693
#define STMT_64 \
 
694
  "UPDATE actual_node SET conflict_data = ?3 " \
 
695
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
696
  ""
 
697
 
 
698
#define STMT_UPDATE_ACTUAL_CHANGELISTS 65
 
699
#define STMT_65_INFO {"STMT_UPDATE_ACTUAL_CHANGELISTS", NULL}
 
700
#define STMT_65 \
659
701
  "UPDATE actual_node SET changelist = ?3 " \
660
702
  "WHERE wc_id = ?1 " \
661
703
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
665
707
  "                         AND kind = 'file') " \
666
708
  ""
667
709
 
668
 
#define STMT_UPDATE_ACTUAL_CLEAR_CHANGELIST 65
669
 
#define STMT_65_INFO {"STMT_UPDATE_ACTUAL_CLEAR_CHANGELIST", NULL}
670
 
#define STMT_65 \
 
710
#define STMT_UPDATE_ACTUAL_CLEAR_CHANGELIST 66
 
711
#define STMT_66_INFO {"STMT_UPDATE_ACTUAL_CLEAR_CHANGELIST", NULL}
 
712
#define STMT_66 \
671
713
  "UPDATE actual_node SET changelist = NULL " \
672
714
  " WHERE wc_id = ?1 AND local_relpath = ?2 " \
673
715
  ""
674
716
 
675
 
#define STMT_MARK_SKIPPED_CHANGELIST_DIRS 66
676
 
#define STMT_66_INFO {"STMT_MARK_SKIPPED_CHANGELIST_DIRS", NULL}
677
 
#define STMT_66 \
 
717
#define STMT_MARK_SKIPPED_CHANGELIST_DIRS 67
 
718
#define STMT_67_INFO {"STMT_MARK_SKIPPED_CHANGELIST_DIRS", NULL}
 
719
#define STMT_67 \
678
720
  "INSERT INTO changelist_list (wc_id, local_relpath, notify, changelist) " \
679
721
  "SELECT wc_id, local_relpath, 7, ?3 " \
680
722
  "FROM targets_list " \
683
725
  "  AND kind = 'dir' " \
684
726
  ""
685
727
 
686
 
#define STMT_RESET_ACTUAL_WITH_CHANGELIST 67
687
 
#define STMT_67_INFO {"STMT_RESET_ACTUAL_WITH_CHANGELIST", NULL}
688
 
#define STMT_67 \
 
728
#define STMT_RESET_ACTUAL_WITH_CHANGELIST 68
 
729
#define STMT_68_INFO {"STMT_RESET_ACTUAL_WITH_CHANGELIST", NULL}
 
730
#define STMT_68 \
689
731
  "REPLACE INTO actual_node ( " \
690
732
  "  wc_id, local_relpath, parent_relpath, changelist) " \
691
733
  "VALUES (?1, ?2, ?3, ?4) " \
692
734
  ""
693
735
 
694
 
#define STMT_CREATE_CHANGELIST_LIST 68
695
 
#define STMT_68_INFO {"STMT_CREATE_CHANGELIST_LIST", NULL}
696
 
#define STMT_68 \
 
736
#define STMT_CREATE_CHANGELIST_LIST 69
 
737
#define STMT_69_INFO {"STMT_CREATE_CHANGELIST_LIST", NULL}
 
738
#define STMT_69 \
697
739
  "DROP TABLE IF EXISTS changelist_list; " \
698
740
  "CREATE TEMPORARY TABLE changelist_list ( " \
699
741
  "  wc_id  INTEGER NOT NULL, " \
704
746
  ") " \
705
747
  ""
706
748
 
707
 
#define STMT_CREATE_CHANGELIST_TRIGGER 69
708
 
#define STMT_69_INFO {"STMT_CREATE_CHANGELIST_TRIGGER", NULL}
709
 
#define STMT_69 \
 
749
#define STMT_CREATE_CHANGELIST_TRIGGER 70
 
750
#define STMT_70_INFO {"STMT_CREATE_CHANGELIST_TRIGGER", NULL}
 
751
#define STMT_70 \
710
752
  "DROP TRIGGER IF EXISTS   trigger_changelist_list_change; " \
711
753
  "CREATE TEMPORARY TRIGGER trigger_changelist_list_change " \
712
754
  "BEFORE UPDATE ON actual_node " \
721
763
  "END " \
722
764
  ""
723
765
 
724
 
#define STMT_FINALIZE_CHANGELIST 70
725
 
#define STMT_70_INFO {"STMT_FINALIZE_CHANGELIST", NULL}
726
 
#define STMT_70 \
 
766
#define STMT_FINALIZE_CHANGELIST 71
 
767
#define STMT_71_INFO {"STMT_FINALIZE_CHANGELIST", NULL}
 
768
#define STMT_71 \
727
769
  "DROP TRIGGER trigger_changelist_list_change; " \
728
770
  "DROP TABLE changelist_list; " \
729
771
  "DROP TABLE targets_list " \
730
772
  ""
731
773
 
732
 
#define STMT_SELECT_CHANGELIST_LIST 71
733
 
#define STMT_71_INFO {"STMT_SELECT_CHANGELIST_LIST", NULL}
734
 
#define STMT_71 \
 
774
#define STMT_SELECT_CHANGELIST_LIST 72
 
775
#define STMT_72_INFO {"STMT_SELECT_CHANGELIST_LIST", NULL}
 
776
#define STMT_72 \
735
777
  "SELECT wc_id, local_relpath, notify, changelist " \
736
778
  "FROM changelist_list " \
737
779
  "ORDER BY wc_id, local_relpath ASC, notify DESC " \
738
780
  ""
739
781
 
740
 
#define STMT_CREATE_TARGETS_LIST 72
741
 
#define STMT_72_INFO {"STMT_CREATE_TARGETS_LIST", NULL}
742
 
#define STMT_72 \
 
782
#define STMT_CREATE_TARGETS_LIST 73
 
783
#define STMT_73_INFO {"STMT_CREATE_TARGETS_LIST", NULL}
 
784
#define STMT_73 \
743
785
  "DROP TABLE IF EXISTS targets_list; " \
744
786
  "CREATE TEMPORARY TABLE targets_list ( " \
745
787
  "  wc_id  INTEGER NOT NULL, " \
750
792
  "  ); " \
751
793
  ""
752
794
 
753
 
#define STMT_DROP_TARGETS_LIST 73
754
 
#define STMT_73_INFO {"STMT_DROP_TARGETS_LIST", NULL}
755
 
#define STMT_73 \
756
 
  "DROP TABLE targets_list " \
757
 
  ""
758
 
 
759
 
#define STMT_INSERT_TARGET 74
760
 
#define STMT_74_INFO {"STMT_INSERT_TARGET", NULL}
 
795
#define STMT_DROP_TARGETS_LIST 74
 
796
#define STMT_74_INFO {"STMT_DROP_TARGETS_LIST", NULL}
761
797
#define STMT_74 \
762
 
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
763
 
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
764
 
  "FROM nodes_current " \
765
 
  "WHERE wc_id = ?1 " \
766
 
  "  AND local_relpath = ?2 " \
 
798
  "DROP TABLE targets_list " \
767
799
  ""
768
800
 
769
 
#define STMT_INSERT_TARGET_DEPTH_FILES 75
770
 
#define STMT_75_INFO {"STMT_INSERT_TARGET_DEPTH_FILES", NULL}
 
801
#define STMT_INSERT_TARGET 75
 
802
#define STMT_75_INFO {"STMT_INSERT_TARGET", NULL}
771
803
#define STMT_75 \
772
804
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
773
805
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
774
806
  "FROM nodes_current " \
775
807
  "WHERE wc_id = ?1 " \
 
808
  "  AND local_relpath = ?2 " \
 
809
  ""
 
810
 
 
811
#define STMT_INSERT_TARGET_DEPTH_FILES 76
 
812
#define STMT_76_INFO {"STMT_INSERT_TARGET_DEPTH_FILES", NULL}
 
813
#define STMT_76 \
 
814
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
 
815
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
 
816
  "FROM nodes_current " \
 
817
  "WHERE wc_id = ?1 " \
776
818
  "  AND parent_relpath = ?2 " \
777
819
  "  AND kind = 'file' " \
778
820
  ""
779
821
 
780
 
#define STMT_INSERT_TARGET_DEPTH_IMMEDIATES 76
781
 
#define STMT_76_INFO {"STMT_INSERT_TARGET_DEPTH_IMMEDIATES", NULL}
782
 
#define STMT_76 \
783
 
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
784
 
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
785
 
  "FROM nodes_current " \
786
 
  "WHERE wc_id = ?1 " \
787
 
  "  AND parent_relpath = ?2 " \
788
 
  ""
789
 
 
790
 
#define STMT_INSERT_TARGET_DEPTH_INFINITY 77
791
 
#define STMT_77_INFO {"STMT_INSERT_TARGET_DEPTH_INFINITY", NULL}
 
822
#define STMT_INSERT_TARGET_DEPTH_IMMEDIATES 77
 
823
#define STMT_77_INFO {"STMT_INSERT_TARGET_DEPTH_IMMEDIATES", NULL}
792
824
#define STMT_77 \
793
825
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
794
826
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
795
827
  "FROM nodes_current " \
796
828
  "WHERE wc_id = ?1 " \
797
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
829
  "  AND parent_relpath = ?2 " \
798
830
  ""
799
831
 
800
 
#define STMT_INSERT_TARGET_WITH_CHANGELIST 78
801
 
#define STMT_78_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST", NULL}
 
832
#define STMT_INSERT_TARGET_DEPTH_INFINITY 78
 
833
#define STMT_78_INFO {"STMT_INSERT_TARGET_DEPTH_INFINITY", NULL}
802
834
#define STMT_78 \
803
835
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
 
836
  "SELECT wc_id, local_relpath, parent_relpath, kind " \
 
837
  "FROM nodes_current " \
 
838
  "WHERE wc_id = ?1 " \
 
839
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
840
  ""
 
841
 
 
842
#define STMT_INSERT_TARGET_WITH_CHANGELIST 79
 
843
#define STMT_79_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST", NULL}
 
844
#define STMT_79 \
 
845
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
804
846
  "SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind " \
805
847
  "  FROM actual_node AS A JOIN nodes_current AS N " \
806
848
  "    ON A.wc_id = N.wc_id AND A.local_relpath = N.local_relpath " \
809
851
  "   AND A.changelist = ?3 " \
810
852
  ""
811
853
 
812
 
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_FILES 79
813
 
#define STMT_79_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_FILES", NULL}
814
 
#define STMT_79 \
 
854
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_FILES 80
 
855
#define STMT_80_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_FILES", NULL}
 
856
#define STMT_80 \
815
857
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
816
858
  "SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind " \
817
859
  "  FROM actual_node AS A JOIN nodes_current AS N " \
822
864
  "   AND A.changelist = ?3 " \
823
865
  ""
824
866
 
825
 
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_IMMEDIATES 80
826
 
#define STMT_80_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_IMMEDIATES", NULL}
827
 
#define STMT_80 \
 
867
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_IMMEDIATES 81
 
868
#define STMT_81_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_IMMEDIATES", NULL}
 
869
#define STMT_81 \
828
870
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
829
871
  "SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind " \
830
872
  "  FROM actual_node AS A JOIN nodes_current AS N " \
834
876
  "  AND A.changelist = ?3 " \
835
877
  ""
836
878
 
837
 
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_INFINITY 81
838
 
#define STMT_81_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_INFINITY", NULL}
839
 
#define STMT_81 \
 
879
#define STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_INFINITY 82
 
880
#define STMT_82_INFO {"STMT_INSERT_TARGET_WITH_CHANGELIST_DEPTH_INFINITY", NULL}
 
881
#define STMT_82 \
840
882
  "INSERT INTO targets_list(wc_id, local_relpath, parent_relpath, kind) " \
841
883
  "SELECT N.wc_id, N.local_relpath, N.parent_relpath, N.kind " \
842
884
  "  FROM actual_node AS A JOIN nodes_current AS N " \
846
888
  "   AND A.changelist = ?3 " \
847
889
  ""
848
890
 
849
 
#define STMT_INSERT_ACTUAL_EMPTIES 82
850
 
#define STMT_82_INFO {"STMT_INSERT_ACTUAL_EMPTIES", NULL}
851
 
#define STMT_82 \
852
 
  "INSERT OR IGNORE INTO actual_node ( " \
853
 
  "     wc_id, local_relpath, parent_relpath) " \
854
 
  "SELECT wc_id, local_relpath, parent_relpath " \
855
 
  "FROM targets_list " \
856
 
  ""
857
 
 
858
 
#define STMT_DELETE_ACTUAL_EMPTY 83
859
 
#define STMT_83_INFO {"STMT_DELETE_ACTUAL_EMPTY", NULL}
 
891
#define STMT_INSERT_ACTUAL_EMPTIES 83
 
892
#define STMT_83_INFO {"STMT_INSERT_ACTUAL_EMPTIES", NULL}
860
893
#define STMT_83 \
861
 
  "DELETE FROM actual_node " \
862
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
863
 
  "  AND properties IS NULL " \
864
 
  "  AND conflict_data IS NULL " \
865
 
  "  AND changelist IS NULL " \
866
 
  "  AND text_mod IS NULL " \
867
 
  "  AND older_checksum IS NULL " \
868
 
  "  AND right_checksum IS NULL " \
869
 
  "  AND left_checksum IS NULL " \
 
894
  "INSERT OR IGNORE INTO actual_node ( " \
 
895
  "     wc_id, local_relpath, parent_relpath) " \
 
896
  "SELECT wc_id, local_relpath, parent_relpath " \
 
897
  "FROM targets_list " \
870
898
  ""
871
899
 
872
 
#define STMT_DELETE_ACTUAL_EMPTIES 84
873
 
#define STMT_84_INFO {"STMT_DELETE_ACTUAL_EMPTIES", NULL}
 
900
#define STMT_INSERT_ACTUAL_EMPTIES_FILES 84
 
901
#define STMT_84_INFO {"STMT_INSERT_ACTUAL_EMPTIES_FILES", NULL}
874
902
#define STMT_84 \
875
 
  "DELETE FROM actual_node " \
876
 
  "WHERE wc_id = ?1 " \
877
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
878
 
  "  AND properties IS NULL " \
879
 
  "  AND conflict_data IS NULL " \
880
 
  "  AND changelist IS NULL " \
881
 
  "  AND text_mod IS NULL " \
882
 
  "  AND older_checksum IS NULL " \
883
 
  "  AND right_checksum IS NULL " \
884
 
  "  AND left_checksum IS NULL " \
 
903
  "INSERT OR IGNORE INTO actual_node ( " \
 
904
  "     wc_id, local_relpath, parent_relpath) " \
 
905
  "SELECT wc_id, local_relpath, parent_relpath " \
 
906
  "FROM targets_list " \
 
907
  "WHERE kind='file' " \
885
908
  ""
886
909
 
887
 
#define STMT_DELETE_BASE_NODE 85
888
 
#define STMT_85_INFO {"STMT_DELETE_BASE_NODE", NULL}
 
910
#define STMT_DELETE_ACTUAL_EMPTY 85
 
911
#define STMT_85_INFO {"STMT_DELETE_ACTUAL_EMPTY", NULL}
889
912
#define STMT_85 \
890
 
  "DELETE FROM nodes " \
891
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
 
913
  "DELETE FROM actual_node " \
 
914
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
915
  "  AND properties IS NULL " \
 
916
  "  AND conflict_data IS NULL " \
 
917
  "  AND changelist IS NULL " \
 
918
  "  AND text_mod IS NULL " \
 
919
  "  AND older_checksum IS NULL " \
 
920
  "  AND right_checksum IS NULL " \
 
921
  "  AND left_checksum IS NULL " \
892
922
  ""
893
923
 
894
 
#define STMT_DELETE_WORKING_NODE 86
895
 
#define STMT_86_INFO {"STMT_DELETE_WORKING_NODE", NULL}
 
924
#define STMT_DELETE_ACTUAL_EMPTIES 86
 
925
#define STMT_86_INFO {"STMT_DELETE_ACTUAL_EMPTIES", NULL}
896
926
#define STMT_86 \
897
 
  "DELETE FROM nodes " \
898
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
899
 
  "  AND op_depth = (SELECT MAX(op_depth) FROM nodes " \
900
 
  "                  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > 0) " \
 
927
  "DELETE FROM actual_node " \
 
928
  "WHERE wc_id = ?1 " \
 
929
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
930
  "  AND properties IS NULL " \
 
931
  "  AND conflict_data IS NULL " \
 
932
  "  AND changelist IS NULL " \
 
933
  "  AND text_mod IS NULL " \
 
934
  "  AND older_checksum IS NULL " \
 
935
  "  AND right_checksum IS NULL " \
 
936
  "  AND left_checksum IS NULL " \
901
937
  ""
902
938
 
903
 
#define STMT_DELETE_LOWEST_WORKING_NODE 87
904
 
#define STMT_87_INFO {"STMT_DELETE_LOWEST_WORKING_NODE", NULL}
 
939
#define STMT_DELETE_BASE_NODE 87
 
940
#define STMT_87_INFO {"STMT_DELETE_BASE_NODE", NULL}
905
941
#define STMT_87 \
906
942
  "DELETE FROM nodes " \
907
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
908
 
  "  AND op_depth = (SELECT MIN(op_depth) FROM nodes " \
909
 
  "                  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3) " \
910
 
  "  AND presence = 'base-deleted' " \
 
943
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
911
944
  ""
912
945
 
913
 
#define STMT_DELETE_NODE_ALL_LAYERS 88
914
 
#define STMT_88_INFO {"STMT_DELETE_NODE_ALL_LAYERS", NULL}
 
946
#define STMT_DELETE_WORKING_NODE 88
 
947
#define STMT_88_INFO {"STMT_DELETE_WORKING_NODE", NULL}
915
948
#define STMT_88 \
916
949
  "DELETE FROM nodes " \
917
950
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
951
  "  AND op_depth = (SELECT MAX(op_depth) FROM nodes " \
 
952
  "                  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > 0) " \
918
953
  ""
919
954
 
920
 
#define STMT_DELETE_NODES_ABOVE_DEPTH_RECURSIVE 89
921
 
#define STMT_89_INFO {"STMT_DELETE_NODES_ABOVE_DEPTH_RECURSIVE", NULL}
 
955
#define STMT_DELETE_LOWEST_WORKING_NODE 89
 
956
#define STMT_89_INFO {"STMT_DELETE_LOWEST_WORKING_NODE", NULL}
922
957
#define STMT_89 \
923
958
  "DELETE FROM nodes " \
924
 
  "WHERE wc_id = ?1 " \
925
 
  "  AND (local_relpath = ?2 " \
926
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
927
 
  "  AND op_depth >= ?3 " \
 
959
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
960
  "  AND op_depth = (SELECT MIN(op_depth) FROM nodes " \
 
961
  "                  WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3) " \
 
962
  "  AND presence = 'base-deleted' " \
928
963
  ""
929
964
 
930
 
#define STMT_DELETE_ACTUAL_NODE 90
931
 
#define STMT_90_INFO {"STMT_DELETE_ACTUAL_NODE", NULL}
 
965
#define STMT_DELETE_NODE_ALL_LAYERS 90
 
966
#define STMT_90_INFO {"STMT_DELETE_NODE_ALL_LAYERS", NULL}
932
967
#define STMT_90 \
933
 
  "DELETE FROM actual_node " \
 
968
  "DELETE FROM nodes " \
934
969
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
935
970
  ""
936
971
 
937
 
#define STMT_DELETE_ACTUAL_NODE_RECURSIVE 91
938
 
#define STMT_91_INFO {"STMT_DELETE_ACTUAL_NODE_RECURSIVE", NULL}
 
972
#define STMT_DELETE_NODES_ABOVE_DEPTH_RECURSIVE 91
 
973
#define STMT_91_INFO {"STMT_DELETE_NODES_ABOVE_DEPTH_RECURSIVE", NULL}
939
974
#define STMT_91 \
940
 
  "DELETE FROM actual_node " \
 
975
  "DELETE FROM nodes " \
941
976
  "WHERE wc_id = ?1 " \
942
977
  "  AND (local_relpath = ?2 " \
943
978
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
979
  "  AND op_depth >= ?3 " \
944
980
  ""
945
981
 
946
 
#define STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST 92
947
 
#define STMT_92_INFO {"STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST", NULL}
 
982
#define STMT_DELETE_ACTUAL_NODE 92
 
983
#define STMT_92_INFO {"STMT_DELETE_ACTUAL_NODE", NULL}
948
984
#define STMT_92 \
949
985
  "DELETE FROM actual_node " \
 
986
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
987
  ""
 
988
 
 
989
#define STMT_DELETE_ACTUAL_NODE_RECURSIVE 93
 
990
#define STMT_93_INFO {"STMT_DELETE_ACTUAL_NODE_RECURSIVE", NULL}
 
991
#define STMT_93 \
 
992
  "DELETE FROM actual_node " \
 
993
  "WHERE wc_id = ?1 " \
 
994
  "  AND (local_relpath = ?2 " \
 
995
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
996
  ""
 
997
 
 
998
#define STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST 94
 
999
#define STMT_94_INFO {"STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST", NULL}
 
1000
#define STMT_94 \
 
1001
  "DELETE FROM actual_node " \
950
1002
  "WHERE wc_id = ?1 " \
951
1003
  "  AND local_relpath = ?2 " \
952
1004
  "  AND (changelist IS NULL " \
955
1007
  "                        AND c.kind = 'file')) " \
956
1008
  ""
957
1009
 
958
 
#define STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE 93
959
 
#define STMT_93_INFO {"STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE", NULL}
960
 
#define STMT_93 \
 
1010
#define STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE 95
 
1011
#define STMT_95_INFO {"STMT_DELETE_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE", NULL}
 
1012
#define STMT_95 \
961
1013
  "DELETE FROM actual_node " \
962
1014
  "WHERE wc_id = ?1 " \
963
1015
  "  AND (local_relpath = ?2 " \
969
1021
  "                        AND c.kind = 'file')) " \
970
1022
  ""
971
1023
 
972
 
#define STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST 94
973
 
#define STMT_94_INFO {"STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST", NULL}
974
 
#define STMT_94 \
975
 
  "UPDATE actual_node " \
976
 
  "SET properties = NULL, " \
977
 
  "    text_mod = NULL, " \
978
 
  "    conflict_data = NULL, " \
979
 
  "    tree_conflict_data = NULL, " \
980
 
  "    older_checksum = NULL, " \
981
 
  "    left_checksum = NULL, " \
982
 
  "    right_checksum = NULL " \
983
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
984
 
  ""
985
 
 
986
 
#define STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE 95
987
 
#define STMT_95_INFO {"STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE", NULL}
988
 
#define STMT_95 \
989
 
  "UPDATE actual_node " \
990
 
  "SET properties = NULL, " \
991
 
  "    text_mod = NULL, " \
992
 
  "    conflict_data = NULL, " \
993
 
  "    tree_conflict_data = NULL, " \
994
 
  "    older_checksum = NULL, " \
995
 
  "    left_checksum = NULL, " \
996
 
  "    right_checksum = NULL " \
997
 
  "WHERE wc_id = ?1 " \
998
 
  "  AND (local_relpath = ?2 " \
999
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1000
 
  ""
1001
 
 
1002
 
#define STMT_UPDATE_NODE_BASE_DEPTH 96
1003
 
#define STMT_96_INFO {"STMT_UPDATE_NODE_BASE_DEPTH", NULL}
 
1024
#define STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST 96
 
1025
#define STMT_96_INFO {"STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST", NULL}
1004
1026
#define STMT_96 \
 
1027
  "UPDATE actual_node " \
 
1028
  "SET properties = NULL, " \
 
1029
  "    text_mod = NULL, " \
 
1030
  "    conflict_data = NULL, " \
 
1031
  "    tree_conflict_data = NULL, " \
 
1032
  "    older_checksum = NULL, " \
 
1033
  "    left_checksum = NULL, " \
 
1034
  "    right_checksum = NULL " \
 
1035
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
1036
  ""
 
1037
 
 
1038
#define STMT_CLEAR_ACTUAL_NODE_LEAVING_CONFLICT 97
 
1039
#define STMT_97_INFO {"STMT_CLEAR_ACTUAL_NODE_LEAVING_CONFLICT", NULL}
 
1040
#define STMT_97 \
 
1041
  "UPDATE actual_node " \
 
1042
  "SET properties = NULL, " \
 
1043
  "    text_mod = NULL, " \
 
1044
  "    tree_conflict_data = NULL, " \
 
1045
  "    older_checksum = NULL, " \
 
1046
  "    left_checksum = NULL, " \
 
1047
  "    right_checksum = NULL, " \
 
1048
  "    changelist = NULL " \
 
1049
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
 
1050
  ""
 
1051
 
 
1052
#define STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE 98
 
1053
#define STMT_98_INFO {"STMT_CLEAR_ACTUAL_NODE_LEAVING_CHANGELIST_RECURSIVE", NULL}
 
1054
#define STMT_98 \
 
1055
  "UPDATE actual_node " \
 
1056
  "SET properties = NULL, " \
 
1057
  "    text_mod = NULL, " \
 
1058
  "    conflict_data = NULL, " \
 
1059
  "    tree_conflict_data = NULL, " \
 
1060
  "    older_checksum = NULL, " \
 
1061
  "    left_checksum = NULL, " \
 
1062
  "    right_checksum = NULL " \
 
1063
  "WHERE wc_id = ?1 " \
 
1064
  "  AND (local_relpath = ?2 " \
 
1065
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
1066
  ""
 
1067
 
 
1068
#define STMT_UPDATE_NODE_BASE_DEPTH 99
 
1069
#define STMT_99_INFO {"STMT_UPDATE_NODE_BASE_DEPTH", NULL}
 
1070
#define STMT_99 \
1005
1071
  "UPDATE nodes SET depth = ?3 " \
1006
1072
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1007
1073
  "  AND kind='dir' " \
 
1074
  "  AND presence IN ('normal', 'incomplete') " \
1008
1075
  ""
1009
1076
 
1010
 
#define STMT_UPDATE_NODE_BASE_PRESENCE 97
1011
 
#define STMT_97_INFO {"STMT_UPDATE_NODE_BASE_PRESENCE", NULL}
1012
 
#define STMT_97 \
 
1077
#define STMT_UPDATE_NODE_BASE_PRESENCE 100
 
1078
#define STMT_100_INFO {"STMT_UPDATE_NODE_BASE_PRESENCE", NULL}
 
1079
#define STMT_100 \
1013
1080
  "UPDATE nodes SET presence = ?3 " \
1014
1081
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1015
1082
  ""
1016
1083
 
1017
 
#define STMT_UPDATE_BASE_NODE_PRESENCE_REVNUM_AND_REPOS_PATH 98
1018
 
#define STMT_98_INFO {"STMT_UPDATE_BASE_NODE_PRESENCE_REVNUM_AND_REPOS_PATH", NULL}
1019
 
#define STMT_98 \
 
1084
#define STMT_UPDATE_BASE_NODE_PRESENCE_REVNUM_AND_REPOS_PATH 101
 
1085
#define STMT_101_INFO {"STMT_UPDATE_BASE_NODE_PRESENCE_REVNUM_AND_REPOS_PATH", NULL}
 
1086
#define STMT_101 \
1020
1087
  "UPDATE nodes SET presence = ?3, revision = ?4, repos_path = ?5 " \
1021
1088
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1022
1089
  ""
1023
1090
 
1024
 
#define STMT_LOOK_FOR_WORK 99
1025
 
#define STMT_99_INFO {"STMT_LOOK_FOR_WORK", NULL}
1026
 
#define STMT_99 \
 
1091
#define STMT_LOOK_FOR_WORK 102
 
1092
#define STMT_102_INFO {"STMT_LOOK_FOR_WORK", NULL}
 
1093
#define STMT_102 \
1027
1094
  "SELECT id FROM work_queue LIMIT 1 " \
1028
1095
  ""
1029
1096
 
1030
 
#define STMT_INSERT_WORK_ITEM 100
1031
 
#define STMT_100_INFO {"STMT_INSERT_WORK_ITEM", NULL}
1032
 
#define STMT_100 \
 
1097
#define STMT_INSERT_WORK_ITEM 103
 
1098
#define STMT_103_INFO {"STMT_INSERT_WORK_ITEM", NULL}
 
1099
#define STMT_103 \
1033
1100
  "INSERT INTO work_queue (work) VALUES (?1) " \
1034
1101
  ""
1035
1102
 
1036
 
#define STMT_SELECT_WORK_ITEM 101
1037
 
#define STMT_101_INFO {"STMT_SELECT_WORK_ITEM", NULL}
1038
 
#define STMT_101 \
 
1103
#define STMT_SELECT_WORK_ITEM 104
 
1104
#define STMT_104_INFO {"STMT_SELECT_WORK_ITEM", NULL}
 
1105
#define STMT_104 \
1039
1106
  "SELECT id, work FROM work_queue ORDER BY id LIMIT 1 " \
1040
1107
  ""
1041
1108
 
1042
 
#define STMT_DELETE_WORK_ITEM 102
1043
 
#define STMT_102_INFO {"STMT_DELETE_WORK_ITEM", NULL}
1044
 
#define STMT_102 \
 
1109
#define STMT_DELETE_WORK_ITEM 105
 
1110
#define STMT_105_INFO {"STMT_DELETE_WORK_ITEM", NULL}
 
1111
#define STMT_105 \
1045
1112
  "DELETE FROM work_queue WHERE id = ?1 " \
1046
1113
  ""
1047
1114
 
1048
 
#define STMT_INSERT_OR_IGNORE_PRISTINE 103
1049
 
#define STMT_103_INFO {"STMT_INSERT_OR_IGNORE_PRISTINE", NULL}
1050
 
#define STMT_103 \
 
1115
#define STMT_INSERT_OR_IGNORE_PRISTINE 106
 
1116
#define STMT_106_INFO {"STMT_INSERT_OR_IGNORE_PRISTINE", NULL}
 
1117
#define STMT_106 \
1051
1118
  "INSERT OR IGNORE INTO pristine (checksum, md5_checksum, size, refcount) " \
1052
1119
  "VALUES (?1, ?2, ?3, 0) " \
1053
1120
  ""
1054
1121
 
1055
 
#define STMT_INSERT_PRISTINE 104
1056
 
#define STMT_104_INFO {"STMT_INSERT_PRISTINE", NULL}
1057
 
#define STMT_104 \
 
1122
#define STMT_INSERT_PRISTINE 107
 
1123
#define STMT_107_INFO {"STMT_INSERT_PRISTINE", NULL}
 
1124
#define STMT_107 \
1058
1125
  "INSERT INTO pristine (checksum, md5_checksum, size, refcount) " \
1059
1126
  "VALUES (?1, ?2, ?3, 0) " \
1060
1127
  ""
1061
1128
 
1062
 
#define STMT_SELECT_PRISTINE 105
1063
 
#define STMT_105_INFO {"STMT_SELECT_PRISTINE", NULL}
1064
 
#define STMT_105 \
 
1129
#define STMT_SELECT_PRISTINE 108
 
1130
#define STMT_108_INFO {"STMT_SELECT_PRISTINE", NULL}
 
1131
#define STMT_108 \
1065
1132
  "SELECT md5_checksum " \
1066
1133
  "FROM pristine " \
1067
1134
  "WHERE checksum = ?1 " \
1068
1135
  ""
1069
1136
 
1070
 
#define STMT_SELECT_PRISTINE_SIZE 106
1071
 
#define STMT_106_INFO {"STMT_SELECT_PRISTINE_SIZE", NULL}
1072
 
#define STMT_106 \
 
1137
#define STMT_SELECT_PRISTINE_SIZE 109
 
1138
#define STMT_109_INFO {"STMT_SELECT_PRISTINE_SIZE", NULL}
 
1139
#define STMT_109 \
1073
1140
  "SELECT size " \
1074
1141
  "FROM pristine " \
1075
1142
  "WHERE checksum = ?1 LIMIT 1 " \
1076
1143
  ""
1077
1144
 
1078
 
#define STMT_SELECT_PRISTINE_BY_MD5 107
1079
 
#define STMT_107_INFO {"STMT_SELECT_PRISTINE_BY_MD5", NULL}
1080
 
#define STMT_107 \
 
1145
#define STMT_SELECT_PRISTINE_BY_MD5 110
 
1146
#define STMT_110_INFO {"STMT_SELECT_PRISTINE_BY_MD5", NULL}
 
1147
#define STMT_110 \
1081
1148
  "SELECT checksum " \
1082
1149
  "FROM pristine " \
1083
1150
  "WHERE md5_checksum = ?1 " \
1084
1151
  ""
1085
1152
 
1086
 
#define STMT_SELECT_UNREFERENCED_PRISTINES 108
1087
 
#define STMT_108_INFO {"STMT_SELECT_UNREFERENCED_PRISTINES", NULL}
1088
 
#define STMT_108 \
 
1153
#define STMT_SELECT_UNREFERENCED_PRISTINES 111
 
1154
#define STMT_111_INFO {"STMT_SELECT_UNREFERENCED_PRISTINES", NULL}
 
1155
#define STMT_111 \
1089
1156
  "SELECT checksum " \
1090
1157
  "FROM pristine " \
1091
1158
  "WHERE refcount = 0 " \
1092
1159
  ""
1093
1160
 
1094
 
#define STMT_DELETE_PRISTINE_IF_UNREFERENCED 109
1095
 
#define STMT_109_INFO {"STMT_DELETE_PRISTINE_IF_UNREFERENCED", NULL}
1096
 
#define STMT_109 \
 
1161
#define STMT_DELETE_PRISTINE_IF_UNREFERENCED 112
 
1162
#define STMT_112_INFO {"STMT_DELETE_PRISTINE_IF_UNREFERENCED", NULL}
 
1163
#define STMT_112 \
1097
1164
  "DELETE FROM pristine " \
1098
1165
  "WHERE checksum = ?1 AND refcount = 0 " \
1099
1166
  ""
1100
1167
 
1101
 
#define STMT_SELECT_COPY_PRISTINES 110
1102
 
#define STMT_110_INFO {"STMT_SELECT_COPY_PRISTINES", NULL}
1103
 
#define STMT_110 \
 
1168
#define STMT_SELECT_COPY_PRISTINES 113
 
1169
#define STMT_113_INFO {"STMT_SELECT_COPY_PRISTINES", NULL}
 
1170
#define STMT_113 \
1104
1171
  "SELECT n.checksum, md5_checksum, size " \
1105
1172
  "FROM nodes_current n " \
1106
1173
  "LEFT JOIN pristine p ON n.checksum = p.checksum " \
1118
1185
  "  AND n.checksum IS NOT NULL " \
1119
1186
  ""
1120
1187
 
1121
 
#define STMT_VACUUM 111
1122
 
#define STMT_111_INFO {"STMT_VACUUM", NULL}
1123
 
#define STMT_111 \
 
1188
#define STMT_VACUUM 114
 
1189
#define STMT_114_INFO {"STMT_VACUUM", NULL}
 
1190
#define STMT_114 \
1124
1191
  "VACUUM " \
1125
1192
  ""
1126
1193
 
1127
 
#define STMT_SELECT_CONFLICT_VICTIMS 112
1128
 
#define STMT_112_INFO {"STMT_SELECT_CONFLICT_VICTIMS", NULL}
1129
 
#define STMT_112 \
 
1194
#define STMT_SELECT_CONFLICT_VICTIMS 115
 
1195
#define STMT_115_INFO {"STMT_SELECT_CONFLICT_VICTIMS", NULL}
 
1196
#define STMT_115 \
1130
1197
  "SELECT local_relpath, conflict_data " \
1131
1198
  "FROM actual_node " \
1132
1199
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND " \
1133
1200
  "  NOT (conflict_data IS NULL) " \
1134
1201
  ""
1135
1202
 
1136
 
#define STMT_INSERT_WC_LOCK 113
1137
 
#define STMT_113_INFO {"STMT_INSERT_WC_LOCK", NULL}
1138
 
#define STMT_113 \
 
1203
#define STMT_INSERT_WC_LOCK 116
 
1204
#define STMT_116_INFO {"STMT_INSERT_WC_LOCK", NULL}
 
1205
#define STMT_116 \
1139
1206
  "INSERT INTO wc_lock (wc_id, local_dir_relpath, locked_levels) " \
1140
1207
  "VALUES (?1, ?2, ?3) " \
1141
1208
  ""
1142
1209
 
1143
 
#define STMT_SELECT_WC_LOCK 114
1144
 
#define STMT_114_INFO {"STMT_SELECT_WC_LOCK", NULL}
1145
 
#define STMT_114 \
 
1210
#define STMT_SELECT_WC_LOCK 117
 
1211
#define STMT_117_INFO {"STMT_SELECT_WC_LOCK", NULL}
 
1212
#define STMT_117 \
1146
1213
  "SELECT locked_levels FROM wc_lock " \
1147
1214
  "WHERE wc_id = ?1 AND local_dir_relpath = ?2 " \
1148
1215
  ""
1149
1216
 
1150
 
#define STMT_SELECT_ANCESTOR_WCLOCKS 115
1151
 
#define STMT_115_INFO {"STMT_SELECT_ANCESTOR_WCLOCKS", NULL}
1152
 
#define STMT_115 \
 
1217
#define STMT_SELECT_ANCESTOR_WCLOCKS 118
 
1218
#define STMT_118_INFO {"STMT_SELECT_ANCESTOR_WCLOCKS", NULL}
 
1219
#define STMT_118 \
1153
1220
  "SELECT local_dir_relpath, locked_levels FROM wc_lock " \
1154
1221
  "WHERE wc_id = ?1 " \
1155
1222
  "  AND ((local_dir_relpath >= ?3 AND local_dir_relpath <= ?2) " \
1156
1223
  "       OR local_dir_relpath = '') " \
1157
1224
  ""
1158
1225
 
1159
 
#define STMT_DELETE_WC_LOCK 116
1160
 
#define STMT_116_INFO {"STMT_DELETE_WC_LOCK", NULL}
1161
 
#define STMT_116 \
 
1226
#define STMT_DELETE_WC_LOCK 119
 
1227
#define STMT_119_INFO {"STMT_DELETE_WC_LOCK", NULL}
 
1228
#define STMT_119 \
1162
1229
  "DELETE FROM wc_lock " \
1163
1230
  "WHERE wc_id = ?1 AND local_dir_relpath = ?2 " \
1164
1231
  ""
1165
1232
 
1166
 
#define STMT_FIND_WC_LOCK 117
1167
 
#define STMT_117_INFO {"STMT_FIND_WC_LOCK", NULL}
1168
 
#define STMT_117 \
 
1233
#define STMT_FIND_WC_LOCK 120
 
1234
#define STMT_120_INFO {"STMT_FIND_WC_LOCK", NULL}
 
1235
#define STMT_120 \
1169
1236
  "SELECT local_dir_relpath FROM wc_lock " \
1170
1237
  "WHERE wc_id = ?1 " \
1171
1238
  "  AND (((local_dir_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_dir_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1172
1239
  ""
1173
1240
 
1174
 
#define STMT_DELETE_WC_LOCK_ORPHAN 118
1175
 
#define STMT_118_INFO {"STMT_DELETE_WC_LOCK_ORPHAN", NULL}
1176
 
#define STMT_118 \
 
1241
#define STMT_FIND_CONFLICT_DESCENDANT 121
 
1242
#define STMT_121_INFO {"STMT_FIND_CONFLICT_DESCENDANT", NULL}
 
1243
#define STMT_121 \
 
1244
  "SELECT 1 FROM actual_node " \
 
1245
  "WHERE wc_id = ?1 " \
 
1246
  "  AND local_relpath > (?2 || '/') " \
 
1247
  "  AND local_relpath < (?2 || '0') " \
 
1248
  "  AND conflict_data IS NOT NULL " \
 
1249
  "LIMIT 1 " \
 
1250
  ""
 
1251
 
 
1252
#define STMT_DELETE_WC_LOCK_ORPHAN 122
 
1253
#define STMT_122_INFO {"STMT_DELETE_WC_LOCK_ORPHAN", NULL}
 
1254
#define STMT_122 \
1177
1255
  "DELETE FROM wc_lock " \
1178
1256
  "WHERE wc_id = ?1 AND local_dir_relpath = ?2 " \
1179
1257
  "AND NOT EXISTS (SELECT 1 FROM nodes " \
1181
1259
  "                   AND nodes.local_relpath = wc_lock.local_dir_relpath) " \
1182
1260
  ""
1183
1261
 
1184
 
#define STMT_DELETE_WC_LOCK_ORPHAN_RECURSIVE 119
1185
 
#define STMT_119_INFO {"STMT_DELETE_WC_LOCK_ORPHAN_RECURSIVE", NULL}
1186
 
#define STMT_119 \
 
1262
#define STMT_DELETE_WC_LOCK_ORPHAN_RECURSIVE 123
 
1263
#define STMT_123_INFO {"STMT_DELETE_WC_LOCK_ORPHAN_RECURSIVE", NULL}
 
1264
#define STMT_123 \
1187
1265
  "DELETE FROM wc_lock " \
1188
1266
  "WHERE wc_id = ?1 " \
1189
1267
  "  AND (local_dir_relpath = ?2 " \
1193
1271
  "                     AND nodes.local_relpath = wc_lock.local_dir_relpath) " \
1194
1272
  ""
1195
1273
 
1196
 
#define STMT_APPLY_CHANGES_TO_BASE_NODE 120
1197
 
#define STMT_120_INFO {"STMT_APPLY_CHANGES_TO_BASE_NODE", NULL}
1198
 
#define STMT_120 \
 
1274
#define STMT_APPLY_CHANGES_TO_BASE_NODE 124
 
1275
#define STMT_124_INFO {"STMT_APPLY_CHANGES_TO_BASE_NODE", NULL}
 
1276
#define STMT_124 \
1199
1277
  "INSERT OR REPLACE INTO nodes ( " \
1200
1278
  "  wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
1201
1279
  "  revision, presence, depth, kind, changed_revision, changed_date, " \
1209
1287
  "            AND op_depth = 0)) " \
1210
1288
  ""
1211
1289
 
1212
 
#define STMT_INSTALL_WORKING_NODE_FOR_DELETE 121
1213
 
#define STMT_121_INFO {"STMT_INSTALL_WORKING_NODE_FOR_DELETE", NULL}
1214
 
#define STMT_121 \
1215
 
  "INSERT OR REPLACE INTO nodes ( " \
 
1290
#define STMT_INSTALL_WORKING_NODE_FOR_DELETE 125
 
1291
#define STMT_125_INFO {"STMT_INSTALL_WORKING_NODE_FOR_DELETE", NULL}
 
1292
#define STMT_125 \
 
1293
  "INSERT INTO nodes ( " \
1216
1294
  "    wc_id, local_relpath, op_depth, " \
1217
1295
  "    parent_relpath, presence, kind) " \
1218
1296
  "VALUES(?1, ?2, ?3, ?4, 'base-deleted', ?5) " \
1219
1297
  ""
1220
1298
 
1221
 
#define STMT_DELETE_NO_LOWER_LAYER 122
1222
 
#define STMT_122_INFO {"STMT_DELETE_NO_LOWER_LAYER", NULL}
1223
 
#define STMT_122 \
1224
 
  "DELETE FROM nodes " \
1225
 
  " WHERE wc_id = ?1 " \
1226
 
  "   AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1227
 
  "   AND op_depth = ?3 " \
1228
 
  "   AND NOT EXISTS (SELECT 1 FROM nodes n " \
1229
 
  "                    WHERE n.wc_id = ?1 " \
1230
 
  "                    AND n.local_relpath = nodes.local_relpath " \
1231
 
  "                    AND n.op_depth = ?4 " \
1232
 
  "                    AND n.presence IN ('normal', 'incomplete')) " \
1233
 
  ""
1234
 
 
1235
 
#define STMT_REPLACE_WITH_BASE_DELETED 123
1236
 
#define STMT_123_INFO {"STMT_REPLACE_WITH_BASE_DELETED", NULL}
1237
 
#define STMT_123 \
 
1299
#define STMT_REPLACE_WITH_BASE_DELETED 126
 
1300
#define STMT_126_INFO {"STMT_REPLACE_WITH_BASE_DELETED", NULL}
 
1301
#define STMT_126 \
1238
1302
  "INSERT OR REPLACE INTO nodes (wc_id, local_relpath, op_depth, parent_relpath, " \
1239
1303
  "                              kind, moved_to, presence) " \
1240
1304
  "SELECT wc_id, local_relpath, op_depth, parent_relpath, " \
1241
1305
  "       kind, moved_to, 'base-deleted' " \
1242
1306
  "  FROM nodes " \
1243
1307
  " WHERE wc_id = ?1 " \
1244
 
  "   AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
1308
  "   AND local_relpath = ?2 " \
1245
1309
  "   AND op_depth = ?3 " \
1246
1310
  ""
1247
1311
 
1248
 
#define STMT_INSERT_DELETE_FROM_NODE_RECURSIVE 124
1249
 
#define STMT_124_INFO {"STMT_INSERT_DELETE_FROM_NODE_RECURSIVE", NULL}
1250
 
#define STMT_124 \
 
1312
#define STMT_INSERT_DELETE_FROM_NODE_RECURSIVE 127
 
1313
#define STMT_127_INFO {"STMT_INSERT_DELETE_FROM_NODE_RECURSIVE", NULL}
 
1314
#define STMT_127 \
1251
1315
  "INSERT INTO nodes ( " \
1252
1316
  "    wc_id, local_relpath, op_depth, parent_relpath, presence, kind) " \
1253
1317
  "SELECT wc_id, local_relpath, ?4 , parent_relpath, 'base-deleted', " \
1254
1318
  "       kind " \
1255
1319
  "FROM nodes " \
 
1320
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
1321
  "UNION ALL " \
 
1322
  "SELECT wc_id, local_relpath, ?4 , parent_relpath, 'base-deleted', " \
 
1323
  "       kind " \
 
1324
  "FROM nodes " \
1256
1325
  "WHERE wc_id = ?1 " \
1257
 
  "  AND (local_relpath = ?2 " \
1258
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
1326
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1259
1327
  "  AND op_depth = ?3 " \
1260
1328
  "  AND presence NOT IN ('base-deleted', 'not-present', 'excluded', 'server-excluded') " \
1261
1329
  "  AND file_external IS NULL " \
 
1330
  "ORDER BY local_relpath " \
1262
1331
  ""
1263
1332
 
1264
 
#define STMT_INSERT_WORKING_NODE_FROM_BASE_COPY 125
1265
 
#define STMT_125_INFO {"STMT_INSERT_WORKING_NODE_FROM_BASE_COPY", NULL}
1266
 
#define STMT_125 \
1267
 
  "INSERT INTO nodes ( " \
 
1333
#define STMT_INSERT_WORKING_NODE_FROM_BASE_COPY 128
 
1334
#define STMT_128_INFO {"STMT_INSERT_WORKING_NODE_FROM_BASE_COPY", NULL}
 
1335
#define STMT_128 \
 
1336
  "INSERT OR REPLACE INTO nodes ( " \
1268
1337
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
1269
1338
  "    revision, presence, depth, kind, changed_revision, changed_date, " \
1270
1339
  "    changed_author, checksum, properties, translated_size, last_mod_time, " \
1271
 
  "    symlink_target ) " \
 
1340
  "    symlink_target, moved_to ) " \
1272
1341
  "SELECT wc_id, local_relpath, ?3 , parent_relpath, repos_id, " \
1273
1342
  "    repos_path, revision, presence, depth, kind, changed_revision, " \
1274
1343
  "    changed_date, changed_author, checksum, properties, translated_size, " \
1275
 
  "    last_mod_time, symlink_target " \
 
1344
  "    last_mod_time, symlink_target, " \
 
1345
  "    (SELECT moved_to FROM nodes " \
 
1346
  "     WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3) moved_to " \
1276
1347
  "FROM nodes " \
1277
1348
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1278
1349
  ""
1279
1350
 
1280
 
#define STMT_INSERT_DELETE_FROM_BASE 126
1281
 
#define STMT_126_INFO {"STMT_INSERT_DELETE_FROM_BASE", NULL}
1282
 
#define STMT_126 \
 
1351
#define STMT_INSERT_DELETE_FROM_BASE 129
 
1352
#define STMT_129_INFO {"STMT_INSERT_DELETE_FROM_BASE", NULL}
 
1353
#define STMT_129 \
1283
1354
  "INSERT INTO nodes ( " \
1284
1355
  "    wc_id, local_relpath, op_depth, parent_relpath, presence, kind) " \
1285
1356
  "SELECT wc_id, local_relpath, ?3 , parent_relpath, " \
1288
1359
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1289
1360
  ""
1290
1361
 
1291
 
#define STMT_UPDATE_OP_DEPTH_INCREASE_RECURSIVE 127
1292
 
#define STMT_127_INFO {"STMT_UPDATE_OP_DEPTH_INCREASE_RECURSIVE", NULL}
1293
 
#define STMT_127 \
 
1362
#define STMT_UPDATE_OP_DEPTH_INCREASE_RECURSIVE 130
 
1363
#define STMT_130_INFO {"STMT_UPDATE_OP_DEPTH_INCREASE_RECURSIVE", NULL}
 
1364
#define STMT_130 \
1294
1365
  "UPDATE nodes SET op_depth = ?3 + 1 " \
1295
1366
  "WHERE wc_id = ?1 " \
1296
1367
  " AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1297
1368
  " AND op_depth = ?3 " \
1298
1369
  ""
1299
1370
 
1300
 
#define STMT_UPDATE_OP_DEPTH_RECURSIVE 128
1301
 
#define STMT_128_INFO {"STMT_UPDATE_OP_DEPTH_RECURSIVE", NULL}
1302
 
#define STMT_128 \
1303
 
  "UPDATE nodes SET op_depth = ?4, moved_here = NULL " \
1304
 
  "WHERE wc_id = ?1 " \
1305
 
  " AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1306
 
  " AND op_depth = ?3 " \
 
1371
#define STMT_COPY_OP_DEPTH_RECURSIVE 131
 
1372
#define STMT_131_INFO {"STMT_COPY_OP_DEPTH_RECURSIVE", NULL}
 
1373
#define STMT_131 \
 
1374
  "INSERT INTO nodes ( " \
 
1375
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, repos_path, " \
 
1376
  "    revision, presence, depth, kind, changed_revision, changed_date, " \
 
1377
  "    changed_author, checksum, properties, translated_size, last_mod_time, " \
 
1378
  "    symlink_target, moved_here, moved_to ) " \
 
1379
  "SELECT " \
 
1380
  "    wc_id, local_relpath, ?4, parent_relpath, repos_id, " \
 
1381
  "    repos_path, revision, presence, depth, kind, changed_revision, " \
 
1382
  "    changed_date, changed_author, checksum, properties, translated_size, " \
 
1383
  "    last_mod_time, symlink_target, NULL, NULL " \
 
1384
  "FROM nodes " \
 
1385
  "WHERE wc_id = ?1 AND op_depth = ?3 AND local_relpath = ?2 " \
 
1386
  "UNION ALL " \
 
1387
  "SELECT " \
 
1388
  "    wc_id, local_relpath, ?4, parent_relpath, repos_id, " \
 
1389
  "    repos_path, revision, presence, depth, kind, changed_revision, " \
 
1390
  "    changed_date, changed_author, checksum, properties, translated_size, " \
 
1391
  "    last_mod_time, symlink_target, NULL, NULL " \
 
1392
  "FROM nodes " \
 
1393
  "WHERE wc_id = ?1 AND op_depth = ?3 " \
 
1394
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
1395
  "ORDER BY local_relpath " \
1307
1396
  ""
1308
1397
 
1309
 
#define STMT_DOES_NODE_EXIST 129
1310
 
#define STMT_129_INFO {"STMT_DOES_NODE_EXIST", NULL}
1311
 
#define STMT_129 \
 
1398
#define STMT_DOES_NODE_EXIST 132
 
1399
#define STMT_132_INFO {"STMT_DOES_NODE_EXIST", NULL}
 
1400
#define STMT_132 \
1312
1401
  "SELECT 1 FROM nodes WHERE wc_id = ?1 AND local_relpath = ?2 " \
1313
1402
  "LIMIT 1 " \
1314
1403
  ""
1315
1404
 
1316
 
#define STMT_HAS_SERVER_EXCLUDED_DESCENDANTS 130
1317
 
#define STMT_130_INFO {"STMT_HAS_SERVER_EXCLUDED_DESCENDANTS", NULL}
1318
 
#define STMT_130 \
 
1405
#define STMT_HAS_SERVER_EXCLUDED_DESCENDANTS 133
 
1406
#define STMT_133_INFO {"STMT_HAS_SERVER_EXCLUDED_DESCENDANTS", NULL}
 
1407
#define STMT_133 \
1319
1408
  "SELECT local_relpath FROM nodes " \
1320
1409
  "WHERE wc_id = ?1 " \
1321
1410
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1323
1412
  "LIMIT 1 " \
1324
1413
  ""
1325
1414
 
1326
 
#define STMT_SELECT_ALL_EXCLUDED_DESCENDANTS 131
1327
 
#define STMT_131_INFO {"STMT_SELECT_ALL_EXCLUDED_DESCENDANTS", NULL}
1328
 
#define STMT_131 \
 
1415
#define STMT_SELECT_ALL_EXCLUDED_DESCENDANTS 134
 
1416
#define STMT_134_INFO {"STMT_SELECT_ALL_EXCLUDED_DESCENDANTS", NULL}
 
1417
#define STMT_134 \
1329
1418
  "SELECT local_relpath FROM nodes " \
1330
1419
  "WHERE wc_id = ?1 " \
1331
1420
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1333
1422
  "  AND (presence = 'server-excluded' OR presence = 'excluded') " \
1334
1423
  ""
1335
1424
 
1336
 
#define STMT_INSERT_WORKING_NODE_COPY_FROM 132
1337
 
#define STMT_132_INFO {"STMT_INSERT_WORKING_NODE_COPY_FROM", NULL}
1338
 
#define STMT_132 \
 
1425
#define STMT_INSERT_WORKING_NODE_COPY_FROM 135
 
1426
#define STMT_135_INFO {"STMT_INSERT_WORKING_NODE_COPY_FROM", NULL}
 
1427
#define STMT_135 \
1339
1428
  "INSERT OR REPLACE INTO nodes ( " \
1340
1429
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, " \
1341
1430
  "    repos_path, revision, presence, depth, moved_here, kind, changed_revision, " \
1354
1443
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
1355
1444
  ""
1356
1445
 
1357
 
#define STMT_INSERT_WORKING_NODE_COPY_FROM_DEPTH 133
1358
 
#define STMT_133_INFO {"STMT_INSERT_WORKING_NODE_COPY_FROM_DEPTH", NULL}
1359
 
#define STMT_133 \
 
1446
#define STMT_INSERT_WORKING_NODE_COPY_FROM_DEPTH 136
 
1447
#define STMT_136_INFO {"STMT_INSERT_WORKING_NODE_COPY_FROM_DEPTH", NULL}
 
1448
#define STMT_136 \
1360
1449
  "INSERT OR REPLACE INTO nodes ( " \
1361
1450
  "    wc_id, local_relpath, op_depth, parent_relpath, repos_id, " \
1362
1451
  "    repos_path, revision, presence, depth, moved_here, kind, changed_revision, " \
1375
1464
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?7 " \
1376
1465
  ""
1377
1466
 
1378
 
#define STMT_UPDATE_BASE_REVISION 134
1379
 
#define STMT_134_INFO {"STMT_UPDATE_BASE_REVISION", NULL}
1380
 
#define STMT_134 \
 
1467
#define STMT_UPDATE_BASE_REVISION 137
 
1468
#define STMT_137_INFO {"STMT_UPDATE_BASE_REVISION", NULL}
 
1469
#define STMT_137 \
1381
1470
  "UPDATE nodes SET revision = ?3 " \
1382
1471
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1383
1472
  ""
1384
1473
 
1385
 
#define STMT_UPDATE_BASE_REPOS 135
1386
 
#define STMT_135_INFO {"STMT_UPDATE_BASE_REPOS", NULL}
1387
 
#define STMT_135 \
 
1474
#define STMT_UPDATE_BASE_REPOS 138
 
1475
#define STMT_138_INFO {"STMT_UPDATE_BASE_REPOS", NULL}
 
1476
#define STMT_138 \
1388
1477
  "UPDATE nodes SET repos_id = ?3, repos_path = ?4 " \
1389
1478
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0 " \
1390
1479
  ""
1391
1480
 
1392
 
#define STMT_ACTUAL_HAS_CHILDREN 136
1393
 
#define STMT_136_INFO {"STMT_ACTUAL_HAS_CHILDREN", NULL}
1394
 
#define STMT_136 \
 
1481
#define STMT_ACTUAL_HAS_CHILDREN 139
 
1482
#define STMT_139_INFO {"STMT_ACTUAL_HAS_CHILDREN", NULL}
 
1483
#define STMT_139 \
1395
1484
  "SELECT 1 FROM actual_node " \
1396
1485
  "WHERE wc_id = ?1 AND parent_relpath = ?2 " \
1397
1486
  "LIMIT 1 " \
1398
1487
  ""
1399
1488
 
1400
 
#define STMT_INSERT_EXTERNAL 137
1401
 
#define STMT_137_INFO {"STMT_INSERT_EXTERNAL", NULL}
1402
 
#define STMT_137 \
 
1489
#define STMT_INSERT_EXTERNAL 140
 
1490
#define STMT_140_INFO {"STMT_INSERT_EXTERNAL", NULL}
 
1491
#define STMT_140 \
1403
1492
  "INSERT OR REPLACE INTO externals ( " \
1404
1493
  "    wc_id, local_relpath, parent_relpath, presence, kind, def_local_relpath, " \
1405
1494
  "    repos_id, def_repos_relpath, def_operational_revision, def_revision) " \
1406
1495
  "VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10) " \
1407
1496
  ""
1408
1497
 
1409
 
#define STMT_SELECT_EXTERNAL_INFO 138
1410
 
#define STMT_138_INFO {"STMT_SELECT_EXTERNAL_INFO", NULL}
1411
 
#define STMT_138 \
 
1498
#define STMT_SELECT_EXTERNAL_INFO 141
 
1499
#define STMT_141_INFO {"STMT_SELECT_EXTERNAL_INFO", NULL}
 
1500
#define STMT_141 \
1412
1501
  "SELECT presence, kind, def_local_relpath, repos_id, " \
1413
1502
  "    def_repos_relpath, def_operational_revision, def_revision " \
1414
1503
  "FROM externals WHERE wc_id = ?1 AND local_relpath = ?2 " \
1415
1504
  "LIMIT 1 " \
1416
1505
  ""
1417
1506
 
1418
 
#define STMT_DELETE_FILE_EXTERNALS 139
1419
 
#define STMT_139_INFO {"STMT_DELETE_FILE_EXTERNALS", NULL}
1420
 
#define STMT_139 \
 
1507
#define STMT_DELETE_FILE_EXTERNALS 142
 
1508
#define STMT_142_INFO {"STMT_DELETE_FILE_EXTERNALS", NULL}
 
1509
#define STMT_142 \
1421
1510
  "DELETE FROM nodes " \
1422
1511
  "WHERE wc_id = ?1 " \
1423
1512
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1425
1514
  "  AND file_external IS NOT NULL " \
1426
1515
  ""
1427
1516
 
1428
 
#define STMT_DELETE_FILE_EXTERNAL_REGISTATIONS 140
1429
 
#define STMT_140_INFO {"STMT_DELETE_FILE_EXTERNAL_REGISTATIONS", NULL}
1430
 
#define STMT_140 \
 
1517
#define STMT_DELETE_FILE_EXTERNAL_REGISTATIONS 143
 
1518
#define STMT_143_INFO {"STMT_DELETE_FILE_EXTERNAL_REGISTATIONS", NULL}
 
1519
#define STMT_143 \
1431
1520
  "DELETE FROM externals " \
1432
1521
  "WHERE wc_id = ?1 " \
1433
1522
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1434
1523
  "  AND kind != 'dir' " \
1435
1524
  ""
1436
1525
 
1437
 
#define STMT_DELETE_EXTERNAL_REGISTATIONS 141
1438
 
#define STMT_141_INFO {"STMT_DELETE_EXTERNAL_REGISTATIONS", NULL}
1439
 
#define STMT_141 \
 
1526
#define STMT_DELETE_EXTERNAL_REGISTATIONS 144
 
1527
#define STMT_144_INFO {"STMT_DELETE_EXTERNAL_REGISTATIONS", NULL}
 
1528
#define STMT_144 \
1440
1529
  "DELETE FROM externals " \
1441
1530
  "WHERE wc_id = ?1 " \
1442
1531
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1443
1532
  ""
1444
1533
 
1445
 
#define STMT_SELECT_COMMITTABLE_EXTERNALS_BELOW 142
1446
 
#define STMT_142_INFO {"STMT_SELECT_COMMITTABLE_EXTERNALS_BELOW", NULL}
1447
 
#define STMT_142 \
 
1534
#define STMT_SELECT_COMMITTABLE_EXTERNALS_BELOW 145
 
1535
#define STMT_145_INFO {"STMT_SELECT_COMMITTABLE_EXTERNALS_BELOW", NULL}
 
1536
#define STMT_145 \
1448
1537
  "SELECT local_relpath, kind, def_repos_relpath, " \
1449
1538
  "  (SELECT root FROM repository AS r WHERE r.id = e.repos_id) " \
1450
1539
  "FROM externals e " \
1462
1551
  "                  AND nodes.local_relpath = e.parent_relpath)) " \
1463
1552
  ""
1464
1553
 
1465
 
#define STMT_SELECT_COMMITTABLE_EXTERNALS_IMMEDIATELY_BELOW 143
1466
 
#define STMT_143_INFO {"STMT_SELECT_COMMITTABLE_EXTERNALS_IMMEDIATELY_BELOW", NULL}
1467
 
#define STMT_143 \
 
1554
#define STMT_SELECT_COMMITTABLE_EXTERNALS_IMMEDIATELY_BELOW 146
 
1555
#define STMT_146_INFO {"STMT_SELECT_COMMITTABLE_EXTERNALS_IMMEDIATELY_BELOW", NULL}
 
1556
#define STMT_146 \
1468
1557
  "SELECT local_relpath, kind, def_repos_relpath, " \
1469
1558
  "  (SELECT root FROM repository AS r WHERE r.id = e.repos_id) " \
1470
1559
  "FROM externals e " \
1483
1572
  "                  AND nodes.local_relpath = e.parent_relpath)) " \
1484
1573
  ""
1485
1574
 
1486
 
#define STMT_SELECT_EXTERNALS_DEFINED 144
1487
 
#define STMT_144_INFO {"STMT_SELECT_EXTERNALS_DEFINED", NULL}
1488
 
#define STMT_144 \
 
1575
#define STMT_SELECT_EXTERNALS_DEFINED 147
 
1576
#define STMT_147_INFO {"STMT_SELECT_EXTERNALS_DEFINED", NULL}
 
1577
#define STMT_147 \
1489
1578
  "SELECT local_relpath, def_local_relpath " \
1490
1579
  "FROM externals " \
1491
1580
  "WHERE (wc_id = ?1 AND def_local_relpath = ?2) " \
1492
1581
  "   OR (wc_id = ?1 AND (((def_local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((def_local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1493
1582
  ""
1494
1583
 
1495
 
#define STMT_DELETE_EXTERNAL 145
1496
 
#define STMT_145_INFO {"STMT_DELETE_EXTERNAL", NULL}
1497
 
#define STMT_145 \
 
1584
#define STMT_DELETE_EXTERNAL 148
 
1585
#define STMT_148_INFO {"STMT_DELETE_EXTERNAL", NULL}
 
1586
#define STMT_148 \
1498
1587
  "DELETE FROM externals " \
1499
1588
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
1500
1589
  ""
1501
1590
 
1502
 
#define STMT_SELECT_EXTERNAL_PROPERTIES 146
1503
 
#define STMT_146_INFO {"STMT_SELECT_EXTERNAL_PROPERTIES", NULL}
1504
 
#define STMT_146 \
 
1591
#define STMT_SELECT_EXTERNAL_PROPERTIES 149
 
1592
#define STMT_149_INFO {"STMT_SELECT_EXTERNAL_PROPERTIES", NULL}
 
1593
#define STMT_149 \
1505
1594
  "SELECT IFNULL((SELECT properties FROM actual_node a " \
1506
1595
  "               WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath), " \
1507
1596
  "              properties), " \
1519
1608
  "  AND kind = 'dir' AND presence IN ('normal', 'incomplete') " \
1520
1609
  ""
1521
1610
 
1522
 
#define STMT_SELECT_CURRENT_PROPS_RECURSIVE 147
1523
 
#define STMT_147_INFO {"STMT_SELECT_CURRENT_PROPS_RECURSIVE", NULL}
1524
 
#define STMT_147 \
 
1611
#define STMT_SELECT_CURRENT_PROPS_RECURSIVE 150
 
1612
#define STMT_150_INFO {"STMT_SELECT_CURRENT_PROPS_RECURSIVE", NULL}
 
1613
#define STMT_150 \
1525
1614
  "SELECT IFNULL((SELECT properties FROM actual_node a " \
1526
1615
  "               WHERE a.wc_id = ?1 AND A.local_relpath = n.local_relpath), " \
1527
1616
  "              properties), " \
1531
1620
  "   OR (wc_id = ?1 AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1532
1621
  ""
1533
1622
 
1534
 
#define STMT_PRAGMA_LOCKING_MODE 148
1535
 
#define STMT_148_INFO {"STMT_PRAGMA_LOCKING_MODE", NULL}
1536
 
#define STMT_148 \
 
1623
#define STMT_PRAGMA_LOCKING_MODE 151
 
1624
#define STMT_151_INFO {"STMT_PRAGMA_LOCKING_MODE", NULL}
 
1625
#define STMT_151 \
1537
1626
  "PRAGMA locking_mode = exclusive " \
1538
1627
  ""
1539
1628
 
1540
 
#define STMT_INSERT_ACTUAL_NODE 149
1541
 
#define STMT_149_INFO {"STMT_INSERT_ACTUAL_NODE", NULL}
1542
 
#define STMT_149 \
 
1629
#define STMT_INSERT_ACTUAL_NODE 152
 
1630
#define STMT_152_INFO {"STMT_INSERT_ACTUAL_NODE", NULL}
 
1631
#define STMT_152 \
1543
1632
  "INSERT OR REPLACE INTO actual_node ( " \
1544
1633
  "  wc_id, local_relpath, parent_relpath, properties, changelist, conflict_data) " \
1545
1634
  "VALUES (?1, ?2, ?3, ?4, ?5, ?6) " \
1546
1635
  ""
1547
1636
 
1548
 
#define STMT_UPDATE_ACTUAL_CONFLICT_DATA 150
1549
 
#define STMT_150_INFO {"STMT_UPDATE_ACTUAL_CONFLICT_DATA", NULL}
1550
 
#define STMT_150 \
1551
 
  "UPDATE actual_node SET conflict_data = ?3 " \
1552
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 " \
1553
 
  ""
1554
 
 
1555
 
#define STMT_INSERT_ACTUAL_CONFLICT_DATA 151
1556
 
#define STMT_151_INFO {"STMT_INSERT_ACTUAL_CONFLICT_DATA", NULL}
1557
 
#define STMT_151 \
1558
 
  "INSERT INTO actual_node (wc_id, local_relpath, conflict_data, parent_relpath) " \
1559
 
  "VALUES (?1, ?2, ?3, ?4) " \
1560
 
  ""
1561
 
 
1562
 
#define STMT_SELECT_ALL_FILES 152
1563
 
#define STMT_152_INFO {"STMT_SELECT_ALL_FILES", NULL}
1564
 
#define STMT_152 \
 
1637
#define STMT_SELECT_ALL_FILES 153
 
1638
#define STMT_153_INFO {"STMT_SELECT_ALL_FILES", NULL}
 
1639
#define STMT_153 \
1565
1640
  "SELECT local_relpath FROM nodes_current " \
1566
1641
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND kind = 'file' " \
1567
1642
  ""
1568
1643
 
1569
 
#define STMT_UPDATE_NODE_PROPS 153
1570
 
#define STMT_153_INFO {"STMT_UPDATE_NODE_PROPS", NULL}
1571
 
#define STMT_153 \
 
1644
#define STMT_UPDATE_NODE_PROPS 154
 
1645
#define STMT_154_INFO {"STMT_UPDATE_NODE_PROPS", NULL}
 
1646
#define STMT_154 \
1572
1647
  "UPDATE nodes SET properties = ?4 " \
1573
1648
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
1574
1649
  ""
1575
1650
 
1576
 
#define STMT_PRAGMA_TABLE_INFO_NODES 154
1577
 
#define STMT_154_INFO {"STMT_PRAGMA_TABLE_INFO_NODES", NULL}
1578
 
#define STMT_154 \
 
1651
#define STMT_PRAGMA_TABLE_INFO_NODES 155
 
1652
#define STMT_155_INFO {"STMT_PRAGMA_TABLE_INFO_NODES", NULL}
 
1653
#define STMT_155 \
1579
1654
  "PRAGMA table_info(\"NODES\") " \
1580
1655
  ""
1581
1656
 
1582
 
#define STMT_CREATE_TARGET_PROP_CACHE 155
1583
 
#define STMT_155_INFO {"STMT_CREATE_TARGET_PROP_CACHE", NULL}
1584
 
#define STMT_155 \
 
1657
#define STMT_CREATE_TARGET_PROP_CACHE 156
 
1658
#define STMT_156_INFO {"STMT_CREATE_TARGET_PROP_CACHE", NULL}
 
1659
#define STMT_156 \
1585
1660
  "DROP TABLE IF EXISTS target_prop_cache; " \
1586
1661
  "CREATE TEMPORARY TABLE target_prop_cache ( " \
1587
1662
  "  local_relpath TEXT NOT NULL PRIMARY KEY, " \
1590
1665
  "); " \
1591
1666
  ""
1592
1667
 
1593
 
#define STMT_CACHE_TARGET_PROPS 156
1594
 
#define STMT_156_INFO {"STMT_CACHE_TARGET_PROPS", NULL}
1595
 
#define STMT_156 \
 
1668
#define STMT_CACHE_TARGET_PROPS 157
 
1669
#define STMT_157_INFO {"STMT_CACHE_TARGET_PROPS", NULL}
 
1670
#define STMT_157 \
1596
1671
  "INSERT INTO target_prop_cache(local_relpath, kind, properties) " \
1597
1672
  " SELECT n.local_relpath, n.kind, " \
1598
1673
  "        IFNULL((SELECT properties FROM actual_node AS a " \
1611
1686
  "  ORDER BY t.local_relpath " \
1612
1687
  ""
1613
1688
 
1614
 
#define STMT_CACHE_TARGET_PRISTINE_PROPS 157
1615
 
#define STMT_157_INFO {"STMT_CACHE_TARGET_PRISTINE_PROPS", NULL}
1616
 
#define STMT_157 \
 
1689
#define STMT_CACHE_TARGET_PRISTINE_PROPS 158
 
1690
#define STMT_158_INFO {"STMT_CACHE_TARGET_PRISTINE_PROPS", NULL}
 
1691
#define STMT_158 \
1617
1692
  "INSERT INTO target_prop_cache(local_relpath, kind, properties) " \
1618
1693
  " SELECT n.local_relpath, n.kind, " \
1619
1694
  "        CASE n.presence " \
1638
1713
  "  ORDER BY t.local_relpath " \
1639
1714
  ""
1640
1715
 
1641
 
#define STMT_SELECT_ALL_TARGET_PROP_CACHE 158
1642
 
#define STMT_158_INFO {"STMT_SELECT_ALL_TARGET_PROP_CACHE", NULL}
1643
 
#define STMT_158 \
 
1716
#define STMT_SELECT_ALL_TARGET_PROP_CACHE 159
 
1717
#define STMT_159_INFO {"STMT_SELECT_ALL_TARGET_PROP_CACHE", NULL}
 
1718
#define STMT_159 \
1644
1719
  "SELECT local_relpath, properties FROM target_prop_cache " \
1645
1720
  "ORDER BY local_relpath " \
1646
1721
  ""
1647
1722
 
1648
 
#define STMT_DROP_TARGET_PROP_CACHE 159
1649
 
#define STMT_159_INFO {"STMT_DROP_TARGET_PROP_CACHE", NULL}
1650
 
#define STMT_159 \
 
1723
#define STMT_DROP_TARGET_PROP_CACHE 160
 
1724
#define STMT_160_INFO {"STMT_DROP_TARGET_PROP_CACHE", NULL}
 
1725
#define STMT_160 \
1651
1726
  "DROP TABLE target_prop_cache; " \
1652
1727
  ""
1653
1728
 
1654
 
#define STMT_CREATE_REVERT_LIST 160
1655
 
#define STMT_160_INFO {"STMT_CREATE_REVERT_LIST", NULL}
1656
 
#define STMT_160 \
 
1729
#define STMT_CREATE_REVERT_LIST 161
 
1730
#define STMT_161_INFO {"STMT_CREATE_REVERT_LIST", NULL}
 
1731
#define STMT_161 \
1657
1732
  "DROP TABLE IF EXISTS revert_list; " \
1658
1733
  "CREATE TEMPORARY TABLE revert_list ( " \
1659
1734
  "   local_relpath TEXT NOT NULL, " \
1687
1762
  "                            WHERE n.wc_id = OLD.wc_id " \
1688
1763
  "                              AND n.local_relpath = OLD.local_relpath) " \
1689
1764
  "            THEN 1 " \
1690
 
  "            ELSE NULL " \
1691
 
  "          END; " \
 
1765
  "          END notify " \
 
1766
  "   WHERE OLD.conflict_data IS NOT NULL " \
 
1767
  "      OR notify IS NOT NULL; " \
1692
1768
  "END; " \
1693
1769
  "DROP TRIGGER IF EXISTS   trigger_revert_list_actual_update; " \
1694
1770
  "CREATE TEMPORARY TRIGGER trigger_revert_list_actual_update " \
1704
1780
  "                            WHERE n.wc_id = OLD.wc_id " \
1705
1781
  "                              AND n.local_relpath = OLD.local_relpath) " \
1706
1782
  "            THEN 1 " \
1707
 
  "            ELSE NULL " \
1708
 
  "          END; " \
 
1783
  "          END notify " \
 
1784
  "   WHERE OLD.conflict_data IS NOT NULL " \
 
1785
  "      OR notify IS NOT NULL; " \
1709
1786
  "END " \
1710
1787
  ""
1711
1788
 
1712
 
#define STMT_DROP_REVERT_LIST_TRIGGERS 161
1713
 
#define STMT_161_INFO {"STMT_DROP_REVERT_LIST_TRIGGERS", NULL}
1714
 
#define STMT_161 \
 
1789
#define STMT_DROP_REVERT_LIST_TRIGGERS 162
 
1790
#define STMT_162_INFO {"STMT_DROP_REVERT_LIST_TRIGGERS", NULL}
 
1791
#define STMT_162 \
1715
1792
  "DROP TRIGGER trigger_revert_list_nodes; " \
1716
1793
  "DROP TRIGGER trigger_revert_list_actual_delete; " \
1717
1794
  "DROP TRIGGER trigger_revert_list_actual_update " \
1718
1795
  ""
1719
1796
 
1720
 
#define STMT_SELECT_REVERT_LIST 162
1721
 
#define STMT_162_INFO {"STMT_SELECT_REVERT_LIST", NULL}
1722
 
#define STMT_162 \
 
1797
#define STMT_SELECT_REVERT_LIST 163
 
1798
#define STMT_163_INFO {"STMT_SELECT_REVERT_LIST", NULL}
 
1799
#define STMT_163 \
1723
1800
  "SELECT actual, notify, kind, op_depth, repos_id, conflict_data " \
1724
1801
  "FROM revert_list " \
1725
1802
  "WHERE local_relpath = ?1 " \
1726
1803
  "ORDER BY actual DESC " \
1727
1804
  ""
1728
1805
 
1729
 
#define STMT_SELECT_REVERT_LIST_COPIED_CHILDREN 163
1730
 
#define STMT_163_INFO {"STMT_SELECT_REVERT_LIST_COPIED_CHILDREN", NULL}
1731
 
#define STMT_163 \
 
1806
#define STMT_SELECT_REVERT_LIST_COPIED_CHILDREN 164
 
1807
#define STMT_164_INFO {"STMT_SELECT_REVERT_LIST_COPIED_CHILDREN", NULL}
 
1808
#define STMT_164 \
1732
1809
  "SELECT local_relpath, kind " \
1733
1810
  "FROM revert_list " \
1734
1811
  "WHERE (((local_relpath) > (CASE (?1) WHEN '' THEN '' ELSE (?1) || '/' END)) AND ((local_relpath) < CASE (?1) WHEN '' THEN X'FFFF' ELSE (?1) || '0' END)) " \
1737
1814
  "ORDER BY local_relpath " \
1738
1815
  ""
1739
1816
 
1740
 
#define STMT_DELETE_REVERT_LIST 164
1741
 
#define STMT_164_INFO {"STMT_DELETE_REVERT_LIST", NULL}
1742
 
#define STMT_164 \
 
1817
#define STMT_DELETE_REVERT_LIST 165
 
1818
#define STMT_165_INFO {"STMT_DELETE_REVERT_LIST", NULL}
 
1819
#define STMT_165 \
1743
1820
  "DELETE FROM revert_list WHERE local_relpath = ?1 " \
1744
1821
  ""
1745
1822
 
1746
 
#define STMT_SELECT_REVERT_LIST_RECURSIVE 165
1747
 
#define STMT_165_INFO {"STMT_SELECT_REVERT_LIST_RECURSIVE", NULL}
1748
 
#define STMT_165 \
1749
 
  "SELECT DISTINCT local_relpath " \
1750
 
  "FROM revert_list " \
1751
 
  "WHERE (local_relpath = ?1 " \
1752
 
  "       OR (((local_relpath) > (CASE (?1) WHEN '' THEN '' ELSE (?1) || '/' END)) AND ((local_relpath) < CASE (?1) WHEN '' THEN X'FFFF' ELSE (?1) || '0' END))) " \
1753
 
  "  AND (notify OR actual = 0) " \
1754
 
  "ORDER BY local_relpath " \
1755
 
  ""
1756
 
 
1757
 
#define STMT_DELETE_REVERT_LIST_RECURSIVE 166
1758
 
#define STMT_166_INFO {"STMT_DELETE_REVERT_LIST_RECURSIVE", NULL}
 
1823
#define STMT_SELECT_REVERT_LIST_RECURSIVE 166
 
1824
#define STMT_166_INFO {"STMT_SELECT_REVERT_LIST_RECURSIVE", NULL}
1759
1825
#define STMT_166 \
 
1826
  "SELECT p.local_relpath, n.kind, a.notify, a.kind " \
 
1827
  "FROM (SELECT DISTINCT local_relpath " \
 
1828
  "      FROM revert_list " \
 
1829
  "      WHERE (local_relpath = ?1 " \
 
1830
  "        OR (((local_relpath) > (CASE (?1) WHEN '' THEN '' ELSE (?1) || '/' END)) AND ((local_relpath) < CASE (?1) WHEN '' THEN X'FFFF' ELSE (?1) || '0' END)))) p " \
 
1831
  "LEFT JOIN revert_list n ON n.local_relpath=p.local_relpath AND n.actual=0 " \
 
1832
  "LEFT JOIN revert_list a ON a.local_relpath=p.local_relpath AND a.actual=1 " \
 
1833
  "ORDER BY p.local_relpath " \
 
1834
  ""
 
1835
 
 
1836
#define STMT_DELETE_REVERT_LIST_RECURSIVE 167
 
1837
#define STMT_167_INFO {"STMT_DELETE_REVERT_LIST_RECURSIVE", NULL}
 
1838
#define STMT_167 \
1760
1839
  "DELETE FROM revert_list " \
1761
1840
  "WHERE (local_relpath = ?1 " \
1762
1841
  "       OR (((local_relpath) > (CASE (?1) WHEN '' THEN '' ELSE (?1) || '/' END)) AND ((local_relpath) < CASE (?1) WHEN '' THEN X'FFFF' ELSE (?1) || '0' END))) " \
1763
1842
  ""
1764
1843
 
1765
 
#define STMT_DROP_REVERT_LIST 167
1766
 
#define STMT_167_INFO {"STMT_DROP_REVERT_LIST", NULL}
1767
 
#define STMT_167 \
 
1844
#define STMT_DROP_REVERT_LIST 168
 
1845
#define STMT_168_INFO {"STMT_DROP_REVERT_LIST", NULL}
 
1846
#define STMT_168 \
1768
1847
  "DROP TABLE IF EXISTS revert_list " \
1769
1848
  ""
1770
1849
 
1771
 
#define STMT_CREATE_DELETE_LIST 168
1772
 
#define STMT_168_INFO {"STMT_CREATE_DELETE_LIST", NULL}
1773
 
#define STMT_168 \
 
1850
#define STMT_CREATE_DELETE_LIST 169
 
1851
#define STMT_169_INFO {"STMT_CREATE_DELETE_LIST", NULL}
 
1852
#define STMT_169 \
1774
1853
  "DROP TABLE IF EXISTS delete_list; " \
1775
1854
  "CREATE TEMPORARY TABLE delete_list ( " \
1776
1855
  "   local_relpath TEXT PRIMARY KEY NOT NULL UNIQUE " \
1777
1856
  "   ) " \
1778
1857
  ""
1779
1858
 
1780
 
#define STMT_INSERT_DELETE_LIST 169
1781
 
#define STMT_169_INFO {"STMT_INSERT_DELETE_LIST", NULL}
1782
 
#define STMT_169 \
 
1859
#define STMT_INSERT_DELETE_LIST 170
 
1860
#define STMT_170_INFO {"STMT_INSERT_DELETE_LIST", NULL}
 
1861
#define STMT_170 \
1783
1862
  "INSERT INTO delete_list(local_relpath) " \
 
1863
  "SELECT ?2 " \
 
1864
  "UNION ALL " \
1784
1865
  "SELECT local_relpath FROM nodes AS n " \
1785
1866
  "WHERE wc_id = ?1 " \
1786
 
  "  AND (local_relpath = ?2 " \
1787
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
1867
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1788
1868
  "  AND op_depth >= ?3 " \
1789
1869
  "  AND op_depth = (SELECT MAX(s.op_depth) FROM nodes AS s " \
1790
1870
  "                  WHERE s.wc_id = ?1 " \
1791
1871
  "                    AND s.local_relpath = n.local_relpath) " \
1792
1872
  "  AND presence NOT IN ('base-deleted', 'not-present', 'excluded', 'server-excluded') " \
1793
1873
  "  AND file_external IS NULL " \
 
1874
  "ORDER by local_relpath " \
1794
1875
  ""
1795
1876
 
1796
 
#define STMT_SELECT_DELETE_LIST 170
1797
 
#define STMT_170_INFO {"STMT_SELECT_DELETE_LIST", NULL}
1798
 
#define STMT_170 \
 
1877
#define STMT_SELECT_DELETE_LIST 171
 
1878
#define STMT_171_INFO {"STMT_SELECT_DELETE_LIST", NULL}
 
1879
#define STMT_171 \
1799
1880
  "SELECT local_relpath FROM delete_list " \
1800
1881
  "ORDER BY local_relpath " \
1801
1882
  ""
1802
1883
 
1803
 
#define STMT_FINALIZE_DELETE 171
1804
 
#define STMT_171_INFO {"STMT_FINALIZE_DELETE", NULL}
1805
 
#define STMT_171 \
 
1884
#define STMT_FINALIZE_DELETE 172
 
1885
#define STMT_172_INFO {"STMT_FINALIZE_DELETE", NULL}
 
1886
#define STMT_172 \
1806
1887
  "DROP TABLE IF EXISTS delete_list " \
1807
1888
  ""
1808
1889
 
1809
 
#define STMT_CREATE_UPDATE_MOVE_LIST 172
1810
 
#define STMT_172_INFO {"STMT_CREATE_UPDATE_MOVE_LIST", NULL}
1811
 
#define STMT_172 \
 
1890
#define STMT_CREATE_UPDATE_MOVE_LIST 173
 
1891
#define STMT_173_INFO {"STMT_CREATE_UPDATE_MOVE_LIST", NULL}
 
1892
#define STMT_173 \
1812
1893
  "DROP TABLE IF EXISTS update_move_list; " \
1813
1894
  "CREATE TEMPORARY TABLE update_move_list ( " \
1814
1895
  "  local_relpath TEXT PRIMARY KEY NOT NULL UNIQUE, " \
1815
1896
  "  action INTEGER NOT NULL, " \
1816
 
  "  kind  INTEGER NOT NULL, " \
 
1897
  "  kind TEXT NOT NULL, " \
1817
1898
  "  content_state INTEGER NOT NULL, " \
1818
1899
  "  prop_state  INTEGER NOT NULL " \
1819
1900
  "  ) " \
1820
1901
  ""
1821
1902
 
1822
 
#define STMT_INSERT_UPDATE_MOVE_LIST 173
1823
 
#define STMT_173_INFO {"STMT_INSERT_UPDATE_MOVE_LIST", NULL}
1824
 
#define STMT_173 \
 
1903
#define STMT_INSERT_UPDATE_MOVE_LIST 174
 
1904
#define STMT_174_INFO {"STMT_INSERT_UPDATE_MOVE_LIST", NULL}
 
1905
#define STMT_174 \
1825
1906
  "INSERT INTO update_move_list(local_relpath, action, kind, content_state, " \
1826
1907
  "  prop_state) " \
1827
1908
  "VALUES (?1, ?2, ?3, ?4, ?5) " \
1828
1909
  ""
1829
1910
 
1830
 
#define STMT_SELECT_UPDATE_MOVE_LIST 174
1831
 
#define STMT_174_INFO {"STMT_SELECT_UPDATE_MOVE_LIST", NULL}
1832
 
#define STMT_174 \
 
1911
#define STMT_SELECT_UPDATE_MOVE_LIST 175
 
1912
#define STMT_175_INFO {"STMT_SELECT_UPDATE_MOVE_LIST", NULL}
 
1913
#define STMT_175 \
1833
1914
  "SELECT local_relpath, action, kind, content_state, prop_state " \
1834
1915
  "FROM update_move_list " \
1835
1916
  "ORDER BY local_relpath " \
1836
1917
  ""
1837
1918
 
1838
 
#define STMT_FINALIZE_UPDATE_MOVE 175
1839
 
#define STMT_175_INFO {"STMT_FINALIZE_UPDATE_MOVE", NULL}
1840
 
#define STMT_175 \
 
1919
#define STMT_FINALIZE_UPDATE_MOVE 176
 
1920
#define STMT_176_INFO {"STMT_FINALIZE_UPDATE_MOVE", NULL}
 
1921
#define STMT_176 \
1841
1922
  "DROP TABLE IF EXISTS update_move_list " \
1842
1923
  ""
1843
1924
 
1844
 
#define STMT_SELECT_MIN_MAX_REVISIONS 176
1845
 
#define STMT_176_INFO {"STMT_SELECT_MIN_MAX_REVISIONS", NULL}
1846
 
#define STMT_176 \
 
1925
#define STMT_MOVE_NOTIFY_TO_REVERT 177
 
1926
#define STMT_177_INFO {"STMT_MOVE_NOTIFY_TO_REVERT", NULL}
 
1927
#define STMT_177 \
 
1928
  "INSERT INTO revert_list (local_relpath, notify, kind, actual) " \
 
1929
  "       SELECT local_relpath, 2, kind, 1 FROM update_move_list; " \
 
1930
  "DROP TABLE update_move_list " \
 
1931
  ""
 
1932
 
 
1933
#define STMT_SELECT_MIN_MAX_REVISIONS 178
 
1934
#define STMT_178_INFO {"STMT_SELECT_MIN_MAX_REVISIONS", NULL}
 
1935
#define STMT_178 \
1847
1936
  "SELECT MIN(revision), MAX(revision), " \
1848
1937
  "       MIN(changed_revision), MAX(changed_revision) FROM nodes " \
1849
1938
  "  WHERE wc_id = ?1 " \
1854
1943
  "    AND op_depth = 0 " \
1855
1944
  ""
1856
1945
 
1857
 
#define STMT_HAS_SPARSE_NODES 177
1858
 
#define STMT_177_INFO {"STMT_HAS_SPARSE_NODES", NULL}
1859
 
#define STMT_177 \
 
1946
#define STMT_HAS_SPARSE_NODES 179
 
1947
#define STMT_179_INFO {"STMT_HAS_SPARSE_NODES", NULL}
 
1948
#define STMT_179 \
1860
1949
  "SELECT 1 FROM nodes " \
1861
1950
  "WHERE wc_id = ?1 " \
1862
1951
  "  AND (local_relpath = ?2 " \
1868
1957
  "LIMIT 1 " \
1869
1958
  ""
1870
1959
 
1871
 
#define STMT_SUBTREE_HAS_TREE_MODIFICATIONS 178
1872
 
#define STMT_178_INFO {"STMT_SUBTREE_HAS_TREE_MODIFICATIONS", NULL}
1873
 
#define STMT_178 \
 
1960
#define STMT_SUBTREE_HAS_TREE_MODIFICATIONS 180
 
1961
#define STMT_180_INFO {"STMT_SUBTREE_HAS_TREE_MODIFICATIONS", NULL}
 
1962
#define STMT_180 \
1874
1963
  "SELECT 1 FROM nodes " \
1875
1964
  "WHERE wc_id = ?1 " \
1876
1965
  "  AND (local_relpath = ?2 " \
1879
1968
  "LIMIT 1 " \
1880
1969
  ""
1881
1970
 
1882
 
#define STMT_SUBTREE_HAS_PROP_MODIFICATIONS 179
1883
 
#define STMT_179_INFO {"STMT_SUBTREE_HAS_PROP_MODIFICATIONS", NULL}
1884
 
#define STMT_179 \
 
1971
#define STMT_SUBTREE_HAS_PROP_MODIFICATIONS 181
 
1972
#define STMT_181_INFO {"STMT_SUBTREE_HAS_PROP_MODIFICATIONS", NULL}
 
1973
#define STMT_181 \
1885
1974
  "SELECT 1 FROM actual_node " \
1886
1975
  "WHERE wc_id = ?1 " \
1887
1976
  "  AND (local_relpath = ?2 " \
1890
1979
  "LIMIT 1 " \
1891
1980
  ""
1892
1981
 
1893
 
#define STMT_HAS_SWITCHED 180
1894
 
#define STMT_180_INFO {"STMT_HAS_SWITCHED", NULL}
1895
 
#define STMT_180 \
 
1982
#define STMT_HAS_SWITCHED 182
 
1983
#define STMT_182_INFO {"STMT_HAS_SWITCHED", NULL}
 
1984
#define STMT_182 \
1896
1985
  "SELECT 1 " \
1897
1986
  "FROM nodes " \
1898
1987
  "WHERE wc_id = ?1 " \
1904
1993
  "LIMIT 1 " \
1905
1994
  ""
1906
1995
 
1907
 
#define STMT_SELECT_BASE_FILES_RECURSIVE 181
1908
 
#define STMT_181_INFO {"STMT_SELECT_BASE_FILES_RECURSIVE", NULL}
1909
 
#define STMT_181 \
1910
 
  "SELECT local_relpath, translated_size, last_mod_time FROM nodes AS n " \
1911
 
  "WHERE wc_id = ?1 " \
1912
 
  "  AND (local_relpath = ?2 " \
1913
 
  "       OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1914
 
  "  AND op_depth = 0 " \
1915
 
  "  AND kind='file' " \
1916
 
  "  AND presence='normal' " \
1917
 
  "  AND file_external IS NULL " \
1918
 
  ""
1919
 
 
1920
 
#define STMT_SELECT_MOVED_FROM_RELPATH 182
1921
 
#define STMT_182_INFO {"STMT_SELECT_MOVED_FROM_RELPATH", NULL}
1922
 
#define STMT_182 \
 
1996
#define STMT_SELECT_MOVED_FROM_RELPATH 183
 
1997
#define STMT_183_INFO {"STMT_SELECT_MOVED_FROM_RELPATH", NULL}
 
1998
#define STMT_183 \
1923
1999
  "SELECT local_relpath, op_depth FROM nodes " \
1924
2000
  "WHERE wc_id = ?1 AND moved_to = ?2 AND op_depth > 0 " \
1925
2001
  ""
1926
2002
 
1927
 
#define STMT_UPDATE_MOVED_TO_RELPATH 183
1928
 
#define STMT_183_INFO {"STMT_UPDATE_MOVED_TO_RELPATH", NULL}
1929
 
#define STMT_183 \
 
2003
#define STMT_UPDATE_MOVED_TO_RELPATH 184
 
2004
#define STMT_184_INFO {"STMT_UPDATE_MOVED_TO_RELPATH", NULL}
 
2005
#define STMT_184 \
1930
2006
  "UPDATE nodes SET moved_to = ?4 " \
1931
2007
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
1932
2008
  ""
1933
2009
 
1934
 
#define STMT_CLEAR_MOVED_TO_RELPATH 184
1935
 
#define STMT_184_INFO {"STMT_CLEAR_MOVED_TO_RELPATH", NULL}
1936
 
#define STMT_184 \
1937
 
  "UPDATE nodes SET moved_to = NULL " \
1938
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
1939
 
  ""
1940
 
 
1941
 
#define STMT_CLEAR_MOVED_HERE_RECURSIVE 185
1942
 
#define STMT_185_INFO {"STMT_CLEAR_MOVED_HERE_RECURSIVE", NULL}
 
2010
#define STMT_CLEAR_MOVED_TO_RELPATH 185
 
2011
#define STMT_185_INFO {"STMT_CLEAR_MOVED_TO_RELPATH", NULL}
1943
2012
#define STMT_185 \
 
2013
  "UPDATE nodes SET moved_to = NULL " \
 
2014
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3 " \
 
2015
  ""
 
2016
 
 
2017
#define STMT_CLEAR_MOVED_HERE_RECURSIVE 186
 
2018
#define STMT_186_INFO {"STMT_CLEAR_MOVED_HERE_RECURSIVE", NULL}
 
2019
#define STMT_186 \
1944
2020
  "UPDATE nodes SET moved_here = NULL " \
1945
2021
  "WHERE wc_id = ?1 " \
1946
2022
  " AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
1947
2023
  " AND op_depth = ?3 " \
1948
2024
  ""
1949
2025
 
1950
 
#define STMT_SELECT_MOVED_HERE_CHILDREN 186
1951
 
#define STMT_186_INFO {"STMT_SELECT_MOVED_HERE_CHILDREN", NULL}
1952
 
#define STMT_186 \
 
2026
#define STMT_SELECT_MOVED_HERE_CHILDREN 187
 
2027
#define STMT_187_INFO {"STMT_SELECT_MOVED_HERE_CHILDREN", NULL}
 
2028
#define STMT_187 \
1953
2029
  "SELECT moved_to, local_relpath FROM nodes " \
1954
2030
  "WHERE wc_id = ?1 AND op_depth > 0 " \
1955
2031
  "  AND (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1956
2032
  ""
1957
2033
 
1958
 
#define STMT_SELECT_MOVED_FOR_DELETE 187
1959
 
#define STMT_187_INFO {"STMT_SELECT_MOVED_FOR_DELETE", NULL}
1960
 
#define STMT_187 \
 
2034
#define STMT_SELECT_MOVED_FOR_DELETE 188
 
2035
#define STMT_188_INFO {"STMT_SELECT_MOVED_FOR_DELETE", NULL}
 
2036
#define STMT_188 \
1961
2037
  "SELECT local_relpath, moved_to, op_depth, " \
1962
2038
  "       (SELECT CASE WHEN r.moved_here THEN r.op_depth END FROM nodes r " \
1963
2039
  "        WHERE r.wc_id = ?1 " \
1971
2047
  "  AND op_depth >= ?3 " \
1972
2048
  ""
1973
2049
 
1974
 
#define STMT_SELECT_MOVED_FROM_FOR_DELETE 188
1975
 
#define STMT_188_INFO {"STMT_SELECT_MOVED_FROM_FOR_DELETE", NULL}
1976
 
#define STMT_188 \
 
2050
#define STMT_SELECT_MOVED_FROM_FOR_DELETE 189
 
2051
#define STMT_189_INFO {"STMT_SELECT_MOVED_FROM_FOR_DELETE", NULL}
 
2052
#define STMT_189 \
1977
2053
  "SELECT local_relpath, op_depth, " \
1978
2054
  "       (SELECT CASE WHEN r.moved_here THEN r.op_depth END FROM nodes r " \
1979
2055
  "        WHERE r.wc_id = ?1 " \
1984
2060
  "WHERE wc_id = ?1 AND moved_to = ?2 AND op_depth > 0 " \
1985
2061
  ""
1986
2062
 
1987
 
#define STMT_UPDATE_MOVED_TO_DESCENDANTS 189
1988
 
#define STMT_189_INFO {"STMT_UPDATE_MOVED_TO_DESCENDANTS", NULL}
1989
 
#define STMT_189 \
 
2063
#define STMT_UPDATE_MOVED_TO_DESCENDANTS 190
 
2064
#define STMT_190_INFO {"STMT_UPDATE_MOVED_TO_DESCENDANTS", NULL}
 
2065
#define STMT_190 \
1990
2066
  "UPDATE nodes SET moved_to = (CASE WHEN (?2) = '' THEN (CASE WHEN (?3) = '' THEN (moved_to) WHEN (moved_to) = '' THEN (?3) ELSE (?3) || '/' || (moved_to) END) WHEN (?3) = '' THEN (CASE WHEN (?2) = '' THEN (moved_to)  WHEN SUBSTR((moved_to), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(moved_to) THEN '' WHEN SUBSTR((moved_to), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((moved_to), LENGTH(?2)+2) END END) WHEN SUBSTR((moved_to), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(moved_to) THEN (?3) WHEN SUBSTR((moved_to), LENGTH(?2)+1, 1) = '/' THEN (?3) || SUBSTR((moved_to), LENGTH(?2)+1) END END) " \
1991
2067
  " WHERE wc_id = ?1 " \
1992
2068
  "   AND (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
1993
2069
  ""
1994
2070
 
1995
 
#define STMT_CLEAR_MOVED_TO_DESCENDANTS 190
1996
 
#define STMT_190_INFO {"STMT_CLEAR_MOVED_TO_DESCENDANTS", NULL}
1997
 
#define STMT_190 \
1998
 
  "UPDATE nodes SET moved_to = NULL " \
1999
 
  " WHERE wc_id = ?1 " \
2000
 
  "   AND (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2001
 
  ""
2002
 
 
2003
 
#define STMT_SELECT_MOVED_PAIR2 191
2004
 
#define STMT_191_INFO {"STMT_SELECT_MOVED_PAIR2", NULL}
 
2071
#define STMT_CLEAR_MOVED_TO_DESCENDANTS 191
 
2072
#define STMT_191_INFO {"STMT_CLEAR_MOVED_TO_DESCENDANTS", NULL}
2005
2073
#define STMT_191 \
2006
 
  "SELECT local_relpath, moved_to, op_depth FROM nodes " \
2007
 
  "WHERE wc_id = ?1 " \
2008
 
  "  AND (local_relpath = ?2 OR (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
2009
 
  "  AND moved_to IS NOT NULL " \
2010
 
  "  AND NOT (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2011
 
  "  AND op_depth >= (SELECT MAX(op_depth) FROM nodes o " \
2012
 
  "                    WHERE o.wc_id = ?1 " \
2013
 
  "                      AND o.local_relpath = ?2) " \
 
2074
  "UPDATE nodes SET moved_to = NULL " \
 
2075
  " WHERE wc_id = ?1 " \
 
2076
  "   AND (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2014
2077
  ""
2015
2078
 
2016
2079
#define STMT_SELECT_MOVED_PAIR3 192
2017
2080
#define STMT_192_INFO {"STMT_SELECT_MOVED_PAIR3", NULL}
2018
2081
#define STMT_192 \
2019
 
  "SELECT local_relpath, moved_to, op_depth, kind FROM nodes " \
2020
 
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3 " \
2021
 
  "  AND moved_to IS NOT NULL " \
 
2082
  "SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind " \
 
2083
  "FROM nodes n " \
 
2084
  "JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath " \
 
2085
  " AND d.op_depth = (SELECT MIN(dd.op_depth) " \
 
2086
  "                    FROM nodes dd " \
 
2087
  "                    WHERE dd.wc_id = ?1 " \
 
2088
  "                      AND dd.local_relpath = d.local_relpath " \
 
2089
  "                      AND dd.op_depth > ?3) " \
 
2090
  "WHERE n.wc_id = ?1 AND n.local_relpath = ?2 AND n.op_depth = ?3 " \
 
2091
  "  AND d.moved_to IS NOT NULL " \
2022
2092
  "UNION ALL " \
2023
 
  "SELECT local_relpath, moved_to, op_depth, kind FROM nodes " \
2024
 
  "WHERE wc_id = ?1 " \
2025
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2026
 
  "  AND op_depth > ?3 " \
2027
 
  "  AND moved_to IS NOT NULL " \
2028
 
  "ORDER BY local_relpath, op_depth " \
 
2093
  "SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind " \
 
2094
  "FROM nodes n " \
 
2095
  "JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath " \
 
2096
  " AND d.op_depth = (SELECT MIN(dd.op_depth) " \
 
2097
  "                    FROM nodes dd " \
 
2098
  "                    WHERE dd.wc_id = ?1 " \
 
2099
  "                      AND dd.local_relpath = d.local_relpath " \
 
2100
  "                      AND dd.op_depth > ?3) " \
 
2101
  "WHERE n.wc_id = ?1 AND (((n.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((n.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
2102
  "  AND n.op_depth = ?3 " \
 
2103
  "  AND d.moved_to IS NOT NULL " \
 
2104
  "ORDER BY n.local_relpath " \
2029
2105
  ""
2030
2106
 
2031
2107
#define STMT_SELECT_MOVED_OUTSIDE 193
2039
2115
  "  AND NOT (((moved_to) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((moved_to) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2040
2116
  ""
2041
2117
 
2042
 
#define STMT_SELECT_OP_DEPTH_MOVED_PAIR 194
2043
 
#define STMT_194_INFO {"STMT_SELECT_OP_DEPTH_MOVED_PAIR", NULL}
 
2118
#define STMT_SELECT_MOVED_DESCENDANTS_SRC 194
 
2119
#define STMT_194_INFO {"STMT_SELECT_MOVED_DESCENDANTS_SRC", NULL}
2044
2120
#define STMT_194 \
2045
 
  "SELECT n.local_relpath, n.moved_to, " \
2046
 
  "       (SELECT o.repos_path FROM nodes AS o " \
2047
 
  "        WHERE o.wc_id = n.wc_id " \
2048
 
  "          AND o.local_relpath = n.local_relpath " \
2049
 
  "          AND o.op_depth < ?3 ORDER BY o.op_depth DESC LIMIT 1) " \
2050
 
  "FROM nodes AS n " \
2051
 
  "WHERE n.wc_id = ?1 " \
2052
 
  "  AND (((n.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((n.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2053
 
  "  AND n.op_depth = ?3 " \
2054
 
  "  AND n.moved_to IS NOT NULL " \
 
2121
  "SELECT s.op_depth, n.local_relpath, n.kind, n.repos_path, s.moved_to " \
 
2122
  "FROM nodes n " \
 
2123
  "JOIN nodes s ON s.wc_id = n.wc_id AND s.local_relpath = n.local_relpath " \
 
2124
  " AND s.op_depth = (SELECT MIN(d.op_depth) " \
 
2125
  "                    FROM nodes d " \
 
2126
  "                    WHERE d.wc_id = ?1 " \
 
2127
  "                      AND d.local_relpath = s.local_relpath " \
 
2128
  "                      AND d.op_depth > ?3) " \
 
2129
  "WHERE n.wc_id = ?1 AND n.op_depth = ?3 " \
 
2130
  "  AND (n.local_relpath = ?2 OR (((n.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((n.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END))) " \
 
2131
  "  AND s.moved_to IS NOT NULL " \
2055
2132
  ""
2056
2133
 
2057
 
#define STMT_SELECT_MOVED_DESCENDANTS 195
2058
 
#define STMT_195_INFO {"STMT_SELECT_MOVED_DESCENDANTS", NULL}
 
2134
#define STMT_COMMIT_UPDATE_ORIGIN 195
 
2135
#define STMT_195_INFO {"STMT_COMMIT_UPDATE_ORIGIN", NULL}
2059
2136
#define STMT_195 \
2060
 
  "SELECT n.local_relpath, h.moved_to " \
2061
 
  "FROM nodes n, nodes h " \
2062
 
  "WHERE n.wc_id = ?1 " \
2063
 
  "  AND h.wc_id = ?1 " \
2064
 
  "  AND (((n.local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((n.local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2065
 
  "  AND h.local_relpath = n.local_relpath " \
2066
 
  "  AND n.op_depth = ?3 " \
2067
 
  "  AND h.op_depth = (SELECT MIN(o.op_depth) " \
2068
 
  "                    FROM nodes o " \
2069
 
  "                    WHERE o.wc_id = ?1 " \
2070
 
  "                      AND o.local_relpath = n.local_relpath " \
2071
 
  "                      AND o.op_depth > ?3) " \
2072
 
  "  AND h.moved_to IS NOT NULL " \
2073
 
  ""
2074
 
 
2075
 
#define STMT_COMMIT_UPDATE_ORIGIN 196
2076
 
#define STMT_196_INFO {"STMT_COMMIT_UPDATE_ORIGIN", NULL}
2077
 
#define STMT_196 \
2078
2137
  "UPDATE nodes SET repos_id = ?4, " \
2079
 
  "                 repos_path = ?5 || SUBSTR(local_relpath, LENGTH(?2)+1), " \
 
2138
  "                 repos_path = (CASE WHEN (?2) = '' THEN (CASE WHEN (?5) = '' THEN (local_relpath) WHEN (local_relpath) = '' THEN (?5) ELSE (?5) || '/' || (local_relpath) END) WHEN (?5) = '' THEN (CASE WHEN (?2) = '' THEN (local_relpath)  WHEN SUBSTR((local_relpath), 1, LENGTH(?2)) = (?2)  THEN CASE WHEN LENGTH(?2) = LENGTH(local_relpath) THEN '' WHEN SUBSTR((local_relpath), LENGTH(?2)+1, 1) = '/' THEN SUBSTR((local_relpath), LENGTH(?2)+2) END END) WHEN SUBSTR((local_relpath), 1, LENGTH(?2)) = (?2) THEN CASE WHEN LENGTH(?2) = LENGTH(local_relpath) THEN (?5) WHEN SUBSTR((local_relpath), LENGTH(?2)+1, 1) = '/' THEN (?5) || SUBSTR((local_relpath), LENGTH(?2)+1) END END), " \
2080
2139
  "                 revision = ?6 " \
2081
2140
  "WHERE wc_id = ?1 " \
2082
2141
  "  AND (local_relpath = ?2 " \
2084
2143
  "  AND op_depth = ?3 " \
2085
2144
  ""
2086
2145
 
2087
 
#define STMT_HAS_LAYER_BETWEEN 197
2088
 
#define STMT_197_INFO {"STMT_HAS_LAYER_BETWEEN", NULL}
2089
 
#define STMT_197 \
 
2146
#define STMT_HAS_LAYER_BETWEEN 196
 
2147
#define STMT_196_INFO {"STMT_HAS_LAYER_BETWEEN", NULL}
 
2148
#define STMT_196 \
2090
2149
  "SELECT 1 FROM NODES " \
2091
2150
  "WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3 AND op_depth < ?4 " \
2092
2151
  ""
2093
2152
 
2094
 
#define STMT_SELECT_REPOS_PATH_REVISION 198
2095
 
#define STMT_198_INFO {"STMT_SELECT_REPOS_PATH_REVISION", NULL}
 
2153
#define STMT_SELECT_REPOS_PATH_REVISION 197
 
2154
#define STMT_197_INFO {"STMT_SELECT_REPOS_PATH_REVISION", NULL}
 
2155
#define STMT_197 \
 
2156
  "SELECT local_relpath, repos_path, revision FROM nodes " \
 
2157
  "WHERE wc_id = ?1 " \
 
2158
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
2159
  "  AND op_depth = 0 " \
 
2160
  "ORDER BY local_relpath " \
 
2161
  ""
 
2162
 
 
2163
#define STMT_SELECT_HAS_NON_FILE_CHILDREN 198
 
2164
#define STMT_198_INFO {"STMT_SELECT_HAS_NON_FILE_CHILDREN", NULL}
2096
2165
#define STMT_198 \
2097
 
  "SELECT local_relpath, repos_path, revision FROM nodes " \
2098
 
  "WHERE wc_id = ?1 " \
2099
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2100
 
  "  AND op_depth = 0 " \
2101
 
  "ORDER BY local_relpath " \
 
2166
  "SELECT 1 FROM nodes " \
 
2167
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = ?3 AND kind != 'file' " \
 
2168
  "LIMIT 1 " \
2102
2169
  ""
2103
2170
 
2104
 
#define STMT_SELECT_HAS_NON_FILE_CHILDREN 199
2105
 
#define STMT_199_INFO {"STMT_SELECT_HAS_NON_FILE_CHILDREN", NULL}
 
2171
#define STMT_SELECT_HAS_GRANDCHILDREN 199
 
2172
#define STMT_199_INFO {"STMT_SELECT_HAS_GRANDCHILDREN", NULL}
2106
2173
#define STMT_199 \
2107
2174
  "SELECT 1 FROM nodes " \
2108
 
  "WHERE wc_id = ?1 AND parent_relpath = ?2 AND op_depth = 0 AND kind != 'file' " \
 
2175
  "WHERE wc_id = ?1 " \
 
2176
  "  AND (((parent_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((parent_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
2177
  "  AND op_depth = ?3 " \
 
2178
  "  AND file_external IS NULL " \
 
2179
  "LIMIT 1 " \
2109
2180
  ""
2110
2181
 
2111
 
#define STMT_SELECT_HAS_GRANDCHILDREN 200
2112
 
#define STMT_200_INFO {"STMT_SELECT_HAS_GRANDCHILDREN", NULL}
 
2182
#define STMT_SELECT_ALL_NODES 200
 
2183
#define STMT_200_INFO {"STMT_SELECT_ALL_NODES", NULL}
2113
2184
#define STMT_200 \
2114
 
  "SELECT 1 FROM nodes " \
 
2185
  "SELECT op_depth, local_relpath, parent_relpath, file_external FROM nodes " \
2115
2186
  "WHERE wc_id = ?1 " \
2116
 
  "  AND (((parent_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((parent_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2117
 
  "  AND op_depth = 0 " \
2118
 
  "  AND file_external IS NULL " \
2119
2187
  ""
2120
2188
 
2121
 
#define STMT_SELECT_ALL_NODES 201
2122
 
#define STMT_201_INFO {"STMT_SELECT_ALL_NODES", NULL}
 
2189
#define STMT_SELECT_IPROPS 201
 
2190
#define STMT_201_INFO {"STMT_SELECT_IPROPS", NULL}
2123
2191
#define STMT_201 \
2124
 
  "SELECT op_depth, local_relpath, parent_relpath, file_external FROM nodes " \
 
2192
  "SELECT inherited_props FROM nodes " \
2125
2193
  "WHERE wc_id = ?1 " \
 
2194
  "  AND local_relpath = ?2 " \
 
2195
  "  AND op_depth = 0 " \
2126
2196
  ""
2127
2197
 
2128
 
#define STMT_SELECT_IPROPS 202
2129
 
#define STMT_202_INFO {"STMT_SELECT_IPROPS", NULL}
 
2198
#define STMT_UPDATE_IPROP 202
 
2199
#define STMT_202_INFO {"STMT_UPDATE_IPROP", NULL}
2130
2200
#define STMT_202 \
2131
 
  "SELECT inherited_props FROM nodes " \
2132
 
  "WHERE wc_id = ?1 " \
2133
 
  "  AND local_relpath = ?2 " \
2134
 
  "  AND op_depth = 0 " \
2135
 
  ""
2136
 
 
2137
 
#define STMT_UPDATE_IPROP 203
2138
 
#define STMT_203_INFO {"STMT_UPDATE_IPROP", NULL}
2139
 
#define STMT_203 \
2140
2201
  "UPDATE nodes " \
2141
2202
  "SET inherited_props = ?3 " \
2142
2203
  "WHERE (wc_id = ?1 AND local_relpath = ?2 AND op_depth = 0) " \
2143
2204
  ""
2144
2205
 
2145
 
#define STMT_SELECT_IPROPS_NODE 204
2146
 
#define STMT_204_INFO {"STMT_SELECT_IPROPS_NODE", NULL}
 
2206
#define STMT_SELECT_IPROPS_NODE 203
 
2207
#define STMT_203_INFO {"STMT_SELECT_IPROPS_NODE", NULL}
 
2208
#define STMT_203 \
 
2209
  "SELECT local_relpath, repos_path FROM nodes " \
 
2210
  "WHERE wc_id = ?1 " \
 
2211
  "  AND local_relpath = ?2 " \
 
2212
  "  AND op_depth = 0 " \
 
2213
  "  AND (inherited_props not null) " \
 
2214
  ""
 
2215
 
 
2216
#define STMT_SELECT_IPROPS_RECURSIVE 204
 
2217
#define STMT_204_INFO {"STMT_SELECT_IPROPS_RECURSIVE", NULL}
2147
2218
#define STMT_204 \
2148
2219
  "SELECT local_relpath, repos_path FROM nodes " \
2149
2220
  "WHERE wc_id = ?1 " \
2150
 
  "  AND local_relpath = ?2 " \
 
2221
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
2151
2222
  "  AND op_depth = 0 " \
2152
2223
  "  AND (inherited_props not null) " \
2153
2224
  ""
2154
2225
 
2155
 
#define STMT_SELECT_IPROPS_RECURSIVE 205
2156
 
#define STMT_205_INFO {"STMT_SELECT_IPROPS_RECURSIVE", NULL}
 
2226
#define STMT_SELECT_IPROPS_CHILDREN 205
 
2227
#define STMT_205_INFO {"STMT_SELECT_IPROPS_CHILDREN", NULL}
2157
2228
#define STMT_205 \
2158
2229
  "SELECT local_relpath, repos_path FROM nodes " \
2159
2230
  "WHERE wc_id = ?1 " \
2160
 
  "  AND (((local_relpath) > (CASE (?2) WHEN '' THEN '' ELSE (?2) || '/' END)) AND ((local_relpath) < CASE (?2) WHEN '' THEN X'FFFF' ELSE (?2) || '0' END)) " \
 
2231
  "  AND parent_relpath = ?2 " \
2161
2232
  "  AND op_depth = 0 " \
2162
2233
  "  AND (inherited_props not null) " \
2163
2234
  ""
2164
2235
 
2165
 
#define STMT_SELECT_IPROPS_CHILDREN 206
2166
 
#define STMT_206_INFO {"STMT_SELECT_IPROPS_CHILDREN", NULL}
 
2236
#define STMT_HAVE_STAT1_TABLE 206
 
2237
#define STMT_206_INFO {"STMT_HAVE_STAT1_TABLE", NULL}
2167
2238
#define STMT_206 \
2168
 
  "SELECT local_relpath, repos_path FROM nodes " \
2169
 
  "WHERE wc_id = ?1 " \
2170
 
  "  AND parent_relpath = ?2 " \
2171
 
  "  AND op_depth = 0 " \
2172
 
  "  AND (inherited_props not null) " \
 
2239
  "SELECT 1 FROM sqlite_master WHERE name='sqlite_stat1' AND type='table' " \
 
2240
  "LIMIT 1 " \
2173
2241
  ""
2174
2242
 
2175
 
#define STMT_HAVE_STAT1_TABLE 207
2176
 
#define STMT_207_INFO {"STMT_HAVE_STAT1_TABLE", NULL}
 
2243
#define STMT_CREATE_SCHEMA 207
 
2244
#define STMT_207_INFO {"STMT_CREATE_SCHEMA", NULL}
2177
2245
#define STMT_207 \
2178
 
  "SELECT 1 FROM sqlite_master WHERE name='sqlite_stat1' AND type='table' " \
2179
 
  "LIMIT 1 " \
2180
 
  ""
2181
 
 
2182
 
#define STMT_CREATE_SCHEMA 208
2183
 
#define STMT_208_INFO {"STMT_CREATE_SCHEMA", NULL}
2184
 
#define STMT_208 \
2185
2246
  "CREATE TABLE REPOSITORY ( " \
2186
2247
  "  id INTEGER PRIMARY KEY AUTOINCREMENT, " \
2187
2248
  "  root  TEXT UNIQUE NOT NULL, " \
2246
2307
  "; " \
2247
2308
  ""
2248
2309
 
2249
 
#define STMT_CREATE_NODES 209
2250
 
#define STMT_209_INFO {"STMT_CREATE_NODES", NULL}
2251
 
#define STMT_209 \
 
2310
#define STMT_CREATE_NODES 208
 
2311
#define STMT_208_INFO {"STMT_CREATE_NODES", NULL}
 
2312
#define STMT_208 \
2252
2313
  "CREATE TABLE NODES ( " \
2253
2314
  "  wc_id  INTEGER NOT NULL REFERENCES WCROOT (id), " \
2254
2315
  "  local_relpath  TEXT NOT NULL, " \
2288
2349
  "  WHERE op_depth = 0; " \
2289
2350
  ""
2290
2351
 
2291
 
#define STMT_CREATE_NODES_TRIGGERS 210
2292
 
#define STMT_210_INFO {"STMT_CREATE_NODES_TRIGGERS", NULL}
 
2352
#define STMT_CREATE_NODES_TRIGGERS 209
 
2353
#define STMT_209_INFO {"STMT_CREATE_NODES_TRIGGERS", NULL}
 
2354
#define STMT_209 \
 
2355
  "CREATE TRIGGER nodes_insert_trigger " \
 
2356
  "AFTER INSERT ON nodes " \
 
2357
  "WHEN NEW.checksum IS NOT NULL " \
 
2358
  "BEGIN " \
 
2359
  "  UPDATE pristine SET refcount = refcount + 1 " \
 
2360
  "  WHERE checksum = NEW.checksum; " \
 
2361
  "END; " \
 
2362
  "CREATE TRIGGER nodes_delete_trigger " \
 
2363
  "AFTER DELETE ON nodes " \
 
2364
  "WHEN OLD.checksum IS NOT NULL " \
 
2365
  "BEGIN " \
 
2366
  "  UPDATE pristine SET refcount = refcount - 1 " \
 
2367
  "  WHERE checksum = OLD.checksum; " \
 
2368
  "END; " \
 
2369
  "CREATE TRIGGER nodes_update_checksum_trigger " \
 
2370
  "AFTER UPDATE OF checksum ON nodes " \
 
2371
  "WHEN NEW.checksum IS NOT OLD.checksum " \
 
2372
  "BEGIN " \
 
2373
  "  UPDATE pristine SET refcount = refcount + 1 " \
 
2374
  "  WHERE checksum = NEW.checksum; " \
 
2375
  "  UPDATE pristine SET refcount = refcount - 1 " \
 
2376
  "  WHERE checksum = OLD.checksum; " \
 
2377
  "END; " \
 
2378
  ""
 
2379
 
 
2380
#define STMT_CREATE_EXTERNALS 210
 
2381
#define STMT_210_INFO {"STMT_CREATE_EXTERNALS", NULL}
2293
2382
#define STMT_210 \
2294
 
  "CREATE TRIGGER nodes_insert_trigger " \
2295
 
  "AFTER INSERT ON nodes " \
2296
 
  "WHEN NEW.checksum IS NOT NULL " \
2297
 
  "BEGIN " \
2298
 
  "  UPDATE pristine SET refcount = refcount + 1 " \
2299
 
  "  WHERE checksum = NEW.checksum; " \
2300
 
  "END; " \
2301
 
  "CREATE TRIGGER nodes_delete_trigger " \
2302
 
  "AFTER DELETE ON nodes " \
2303
 
  "WHEN OLD.checksum IS NOT NULL " \
2304
 
  "BEGIN " \
2305
 
  "  UPDATE pristine SET refcount = refcount - 1 " \
2306
 
  "  WHERE checksum = OLD.checksum; " \
2307
 
  "END; " \
2308
 
  "CREATE TRIGGER nodes_update_checksum_trigger " \
2309
 
  "AFTER UPDATE OF checksum ON nodes " \
2310
 
  "WHEN NEW.checksum IS NOT OLD.checksum " \
2311
 
  "BEGIN " \
2312
 
  "  UPDATE pristine SET refcount = refcount + 1 " \
2313
 
  "  WHERE checksum = NEW.checksum; " \
2314
 
  "  UPDATE pristine SET refcount = refcount - 1 " \
2315
 
  "  WHERE checksum = OLD.checksum; " \
2316
 
  "END; " \
2317
 
  ""
2318
 
 
2319
 
#define STMT_CREATE_EXTERNALS 211
2320
 
#define STMT_211_INFO {"STMT_CREATE_EXTERNALS", NULL}
2321
 
#define STMT_211 \
2322
2383
  "CREATE TABLE EXTERNALS ( " \
2323
2384
  "  wc_id  INTEGER NOT NULL REFERENCES WCROOT (id), " \
2324
2385
  "  local_relpath  TEXT NOT NULL, " \
2337
2398
  "                                                      local_relpath); " \
2338
2399
  ""
2339
2400
 
2340
 
#define STMT_INSTALL_SCHEMA_STATISTICS 212
2341
 
#define STMT_212_INFO {"STMT_INSTALL_SCHEMA_STATISTICS", NULL}
2342
 
#define STMT_212 \
 
2401
#define STMT_INSTALL_SCHEMA_STATISTICS 211
 
2402
#define STMT_211_INFO {"STMT_INSTALL_SCHEMA_STATISTICS", NULL}
 
2403
#define STMT_211 \
2343
2404
  "ANALYZE sqlite_master; " \
2344
2405
  "DELETE FROM sqlite_stat1 " \
2345
 
  "WHERE tbl in ('NODES', 'ACTUAL_NODE', 'LOCK', 'WC_LOCK'); " \
2346
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2406
  "WHERE tbl in ('NODES', 'ACTUAL_NODE', 'LOCK', 'WC_LOCK', 'EXTERNALS'); " \
 
2407
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2347
2408
  "    ('NODES', 'sqlite_autoindex_NODES_1',               '8000 8000 2 1'); " \
2348
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2409
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2349
2410
  "    ('NODES', 'I_NODES_PARENT',                         '8000 8000 10 2 1'); " \
2350
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2411
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2351
2412
  "    ('NODES', 'I_NODES_MOVED',                          '8000 8000 1 1'); " \
2352
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2413
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2353
2414
  "    ('ACTUAL_NODE', 'sqlite_autoindex_ACTUAL_NODE_1',   '8000 8000 1'); " \
2354
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2415
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2355
2416
  "    ('ACTUAL_NODE', 'I_ACTUAL_PARENT',                  '8000 8000 10 1'); " \
2356
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2417
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2357
2418
  "    ('LOCK', 'sqlite_autoindex_LOCK_1',                 '100 100 1'); " \
2358
 
  "INSERT OR REPLACE INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2419
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
2359
2420
  "    ('WC_LOCK', 'sqlite_autoindex_WC_LOCK_1',           '100 100 1'); " \
 
2421
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2422
  "    ('EXTERNALS','sqlite_autoindex_EXTERNALS_1',        '100 100 1'); " \
 
2423
  "INSERT INTO sqlite_stat1(tbl, idx, stat) VALUES " \
 
2424
  "    ('EXTERNALS','I_EXTERNALS_DEFINED',                 '100 100 3 1'); " \
2360
2425
  "ANALYZE sqlite_master; " \
2361
2426
  ""
2362
2427
 
2363
 
#define STMT_UPGRADE_TO_20 213
2364
 
#define STMT_213_INFO {"STMT_UPGRADE_TO_20", NULL}
2365
 
#define STMT_213 \
 
2428
#define STMT_UPGRADE_TO_20 212
 
2429
#define STMT_212_INFO {"STMT_UPGRADE_TO_20", NULL}
 
2430
#define STMT_212 \
2366
2431
  "UPDATE BASE_NODE SET checksum = (SELECT checksum FROM pristine " \
2367
2432
  "                                 WHERE md5_checksum = BASE_NODE.checksum) " \
2368
2433
  "WHERE EXISTS (SELECT 1 FROM pristine WHERE md5_checksum = BASE_NODE.checksum); " \
2403
2468
  "PRAGMA user_version = 20; " \
2404
2469
  ""
2405
2470
 
2406
 
#define STMT_UPGRADE_TO_21 214
2407
 
#define STMT_214_INFO {"STMT_UPGRADE_TO_21", NULL}
 
2471
#define STMT_UPGRADE_TO_21 213
 
2472
#define STMT_213_INFO {"STMT_UPGRADE_TO_21", NULL}
 
2473
#define STMT_213 \
 
2474
  "PRAGMA user_version = 21; " \
 
2475
  ""
 
2476
 
 
2477
#define STMT_UPGRADE_21_SELECT_OLD_TREE_CONFLICT 214
 
2478
#define STMT_214_INFO {"STMT_UPGRADE_21_SELECT_OLD_TREE_CONFLICT", NULL}
2408
2479
#define STMT_214 \
2409
 
  "PRAGMA user_version = 21; " \
2410
 
  ""
2411
 
 
2412
 
#define STMT_UPGRADE_21_SELECT_OLD_TREE_CONFLICT 215
2413
 
#define STMT_215_INFO {"STMT_UPGRADE_21_SELECT_OLD_TREE_CONFLICT", NULL}
2414
 
#define STMT_215 \
2415
2480
  "SELECT wc_id, local_relpath, tree_conflict_data " \
2416
2481
  "FROM actual_node " \
2417
2482
  "WHERE tree_conflict_data IS NOT NULL " \
2418
2483
  ""
2419
2484
 
2420
 
#define STMT_UPGRADE_21_ERASE_OLD_CONFLICTS 216
2421
 
#define STMT_216_INFO {"STMT_UPGRADE_21_ERASE_OLD_CONFLICTS", NULL}
 
2485
#define STMT_UPGRADE_21_ERASE_OLD_CONFLICTS 215
 
2486
#define STMT_215_INFO {"STMT_UPGRADE_21_ERASE_OLD_CONFLICTS", NULL}
 
2487
#define STMT_215 \
 
2488
  "UPDATE actual_node SET tree_conflict_data = NULL " \
 
2489
  ""
 
2490
 
 
2491
#define STMT_UPGRADE_TO_22 216
 
2492
#define STMT_216_INFO {"STMT_UPGRADE_TO_22", NULL}
2422
2493
#define STMT_216 \
2423
 
  "UPDATE actual_node SET tree_conflict_data = NULL " \
2424
 
  ""
2425
 
 
2426
 
#define STMT_UPGRADE_TO_22 217
2427
 
#define STMT_217_INFO {"STMT_UPGRADE_TO_22", NULL}
2428
 
#define STMT_217 \
2429
2494
  "UPDATE actual_node SET tree_conflict_data = conflict_data; " \
2430
2495
  "UPDATE actual_node SET conflict_data = NULL; " \
2431
2496
  "PRAGMA user_version = 22; " \
2432
2497
  ""
2433
2498
 
2434
 
#define STMT_UPGRADE_TO_23 218
2435
 
#define STMT_218_INFO {"STMT_UPGRADE_TO_23", NULL}
 
2499
#define STMT_UPGRADE_TO_23 217
 
2500
#define STMT_217_INFO {"STMT_UPGRADE_TO_23", NULL}
 
2501
#define STMT_217 \
 
2502
  "PRAGMA user_version = 23; " \
 
2503
  ""
 
2504
 
 
2505
#define STMT_UPGRADE_23_HAS_WORKING_NODES 218
 
2506
#define STMT_218_INFO {"STMT_UPGRADE_23_HAS_WORKING_NODES", NULL}
2436
2507
#define STMT_218 \
2437
 
  "PRAGMA user_version = 23; " \
 
2508
  "SELECT 1 FROM nodes WHERE op_depth > 0 " \
 
2509
  "LIMIT 1 " \
2438
2510
  ""
2439
2511
 
2440
 
#define STMT_UPGRADE_23_HAS_WORKING_NODES 219
2441
 
#define STMT_219_INFO {"STMT_UPGRADE_23_HAS_WORKING_NODES", NULL}
 
2512
#define STMT_UPGRADE_TO_24 219
 
2513
#define STMT_219_INFO {"STMT_UPGRADE_TO_24", NULL}
2442
2514
#define STMT_219 \
2443
 
  "SELECT 1 FROM nodes WHERE op_depth > 0 " \
2444
 
  "LIMIT 1 " \
2445
 
  ""
2446
 
 
2447
 
#define STMT_UPGRADE_TO_24 220
2448
 
#define STMT_220_INFO {"STMT_UPGRADE_TO_24", NULL}
2449
 
#define STMT_220 \
2450
2515
  "UPDATE pristine SET refcount = " \
2451
2516
  "  (SELECT COUNT(*) FROM nodes " \
2452
2517
  "   WHERE checksum = pristine.checksum ); " \
2453
2518
  "PRAGMA user_version = 24; " \
2454
2519
  ""
2455
2520
 
2456
 
#define STMT_UPGRADE_TO_25 221
2457
 
#define STMT_221_INFO {"STMT_UPGRADE_TO_25", NULL}
2458
 
#define STMT_221 \
 
2521
#define STMT_UPGRADE_TO_25 220
 
2522
#define STMT_220_INFO {"STMT_UPGRADE_TO_25", NULL}
 
2523
#define STMT_220 \
2459
2524
  "DROP VIEW IF EXISTS NODES_CURRENT; " \
2460
2525
  "CREATE VIEW NODES_CURRENT AS " \
2461
2526
  "  SELECT * FROM nodes " \
2467
2532
  "PRAGMA user_version = 25; " \
2468
2533
  ""
2469
2534
 
2470
 
#define STMT_UPGRADE_TO_26 222
2471
 
#define STMT_222_INFO {"STMT_UPGRADE_TO_26", NULL}
2472
 
#define STMT_222 \
 
2535
#define STMT_UPGRADE_TO_26 221
 
2536
#define STMT_221_INFO {"STMT_UPGRADE_TO_26", NULL}
 
2537
#define STMT_221 \
2473
2538
  "DROP VIEW IF EXISTS NODES_BASE; " \
2474
2539
  "CREATE VIEW NODES_BASE AS " \
2475
2540
  "  SELECT * FROM nodes " \
2477
2542
  "PRAGMA user_version = 26; " \
2478
2543
  ""
2479
2544
 
2480
 
#define STMT_UPGRADE_TO_27 223
2481
 
#define STMT_223_INFO {"STMT_UPGRADE_TO_27", NULL}
 
2545
#define STMT_UPGRADE_TO_27 222
 
2546
#define STMT_222_INFO {"STMT_UPGRADE_TO_27", NULL}
 
2547
#define STMT_222 \
 
2548
  "PRAGMA user_version = 27; " \
 
2549
  ""
 
2550
 
 
2551
#define STMT_UPGRADE_27_HAS_ACTUAL_NODES_CONFLICTS 223
 
2552
#define STMT_223_INFO {"STMT_UPGRADE_27_HAS_ACTUAL_NODES_CONFLICTS", NULL}
2482
2553
#define STMT_223 \
2483
 
  "PRAGMA user_version = 27; " \
2484
 
  ""
2485
 
 
2486
 
#define STMT_UPGRADE_27_HAS_ACTUAL_NODES_CONFLICTS 224
2487
 
#define STMT_224_INFO {"STMT_UPGRADE_27_HAS_ACTUAL_NODES_CONFLICTS", NULL}
2488
 
#define STMT_224 \
2489
2554
  "SELECT 1 FROM actual_node " \
2490
2555
  "WHERE NOT ((prop_reject IS NULL) AND (conflict_old IS NULL) " \
2491
2556
  "           AND (conflict_new IS NULL) AND (conflict_working IS NULL) " \
2493
2558
  "LIMIT 1 " \
2494
2559
  ""
2495
2560
 
2496
 
#define STMT_UPGRADE_TO_28 225
2497
 
#define STMT_225_INFO {"STMT_UPGRADE_TO_28", NULL}
2498
 
#define STMT_225 \
 
2561
#define STMT_UPGRADE_TO_28 224
 
2562
#define STMT_224_INFO {"STMT_UPGRADE_TO_28", NULL}
 
2563
#define STMT_224 \
2499
2564
  "UPDATE NODES SET checksum = (SELECT checksum FROM pristine " \
2500
2565
  "                             WHERE md5_checksum = nodes.checksum) " \
2501
2566
  "WHERE EXISTS (SELECT 1 FROM pristine WHERE md5_checksum = nodes.checksum); " \
2502
2567
  "PRAGMA user_version = 28; " \
2503
2568
  ""
2504
2569
 
2505
 
#define STMT_UPGRADE_TO_29 226
2506
 
#define STMT_226_INFO {"STMT_UPGRADE_TO_29", NULL}
2507
 
#define STMT_226 \
 
2570
#define STMT_UPGRADE_TO_29 225
 
2571
#define STMT_225_INFO {"STMT_UPGRADE_TO_29", NULL}
 
2572
#define STMT_225 \
2508
2573
  "DROP TRIGGER IF EXISTS nodes_update_checksum_trigger; " \
2509
2574
  "DROP TRIGGER IF EXISTS nodes_insert_trigger; " \
2510
2575
  "DROP TRIGGER IF EXISTS nodes_delete_trigger; " \
2534
2599
  "PRAGMA user_version = 29; " \
2535
2600
  ""
2536
2601
 
2537
 
#define STMT_UPGRADE_TO_30 227
2538
 
#define STMT_227_INFO {"STMT_UPGRADE_TO_30", NULL}
2539
 
#define STMT_227 \
 
2602
#define STMT_UPGRADE_TO_30 226
 
2603
#define STMT_226_INFO {"STMT_UPGRADE_TO_30", NULL}
 
2604
#define STMT_226 \
2540
2605
  "CREATE UNIQUE INDEX IF NOT EXISTS I_NODES_MOVED " \
2541
2606
  "ON NODES (wc_id, moved_to, op_depth); " \
2542
2607
  "CREATE INDEX IF NOT EXISTS I_PRISTINE_MD5 ON PRISTINE (md5_checksum); " \
2544
2609
  "UPDATE nodes SET file_external=1 WHERE file_external IS NOT NULL; " \
2545
2610
  ""
2546
2611
 
2547
 
#define STMT_UPGRADE_30_SELECT_CONFLICT_SEPARATE 228
2548
 
#define STMT_228_INFO {"STMT_UPGRADE_30_SELECT_CONFLICT_SEPARATE", NULL}
2549
 
#define STMT_228 \
 
2612
#define STMT_UPGRADE_30_SELECT_CONFLICT_SEPARATE 227
 
2613
#define STMT_227_INFO {"STMT_UPGRADE_30_SELECT_CONFLICT_SEPARATE", NULL}
 
2614
#define STMT_227 \
2550
2615
  "SELECT wc_id, local_relpath, " \
2551
2616
  "  conflict_old, conflict_working, conflict_new, prop_reject, tree_conflict_data " \
2552
2617
  "FROM actual_node " \
2558
2623
  "ORDER by wc_id, local_relpath " \
2559
2624
  ""
2560
2625
 
2561
 
#define STMT_UPGRADE_30_SET_CONFLICT 229
2562
 
#define STMT_229_INFO {"STMT_UPGRADE_30_SET_CONFLICT", NULL}
2563
 
#define STMT_229 \
 
2626
#define STMT_UPGRADE_30_SET_CONFLICT 228
 
2627
#define STMT_228_INFO {"STMT_UPGRADE_30_SET_CONFLICT", NULL}
 
2628
#define STMT_228 \
2564
2629
  "UPDATE actual_node SET conflict_data = ?3, conflict_old = NULL, " \
2565
2630
  "  conflict_working = NULL, conflict_new = NULL, prop_reject = NULL, " \
2566
2631
  "  tree_conflict_data = NULL " \
2567
2632
  "WHERE wc_id = ?1 and local_relpath = ?2 " \
2568
2633
  ""
2569
2634
 
2570
 
#define STMT_UPGRADE_TO_31_ALTER_TABLE 230
2571
 
#define STMT_230_INFO {"STMT_UPGRADE_TO_31_ALTER_TABLE", NULL}
 
2635
#define STMT_UPGRADE_TO_31_ALTER_TABLE 229
 
2636
#define STMT_229_INFO {"STMT_UPGRADE_TO_31_ALTER_TABLE", NULL}
 
2637
#define STMT_229 \
 
2638
  "ALTER TABLE NODES ADD COLUMN inherited_props BLOB; " \
 
2639
  ""
 
2640
 
 
2641
#define STMT_UPGRADE_TO_31_FINALIZE 230
 
2642
#define STMT_230_INFO {"STMT_UPGRADE_TO_31_FINALIZE", NULL}
2572
2643
#define STMT_230 \
2573
 
  "ALTER TABLE NODES ADD COLUMN inherited_props BLOB; " \
 
2644
  "DROP INDEX IF EXISTS I_ACTUAL_CHANGELIST; " \
 
2645
  "DROP INDEX IF EXISTS I_EXTERNALS_PARENT; " \
 
2646
  "DROP INDEX I_NODES_PARENT; " \
 
2647
  "CREATE UNIQUE INDEX I_NODES_PARENT ON NODES (wc_id, parent_relpath, " \
 
2648
  "                                             local_relpath, op_depth); " \
 
2649
  "DROP INDEX I_ACTUAL_PARENT; " \
 
2650
  "CREATE UNIQUE INDEX I_ACTUAL_PARENT ON ACTUAL_NODE (wc_id, parent_relpath, " \
 
2651
  "                                                    local_relpath); " \
 
2652
  "PRAGMA user_version = 31; " \
2574
2653
  ""
2575
2654
 
2576
 
#define STMT_UPGRADE_TO_31_FINALIZE 231
2577
 
#define STMT_231_INFO {"STMT_UPGRADE_TO_31_FINALIZE", NULL}
 
2655
#define STMT_UPGRADE_31_SELECT_WCROOT_NODES 231
 
2656
#define STMT_231_INFO {"STMT_UPGRADE_31_SELECT_WCROOT_NODES", NULL}
2578
2657
#define STMT_231 \
2579
 
  "DROP INDEX IF EXISTS I_ACTUAL_CHANGELIST; " \
2580
 
  "DROP INDEX IF EXISTS I_EXTERNALS_PARENT; " \
2581
 
  "DROP INDEX I_NODES_PARENT; " \
2582
 
  "CREATE UNIQUE INDEX I_NODES_PARENT ON NODES (wc_id, parent_relpath, " \
2583
 
  "                                             local_relpath, op_depth); " \
2584
 
  "DROP INDEX I_ACTUAL_PARENT; " \
2585
 
  "CREATE UNIQUE INDEX I_ACTUAL_PARENT ON ACTUAL_NODE (wc_id, parent_relpath, " \
2586
 
  "                                                    local_relpath); " \
2587
 
  "PRAGMA user_version = 31; " \
2588
 
  ""
2589
 
 
2590
 
#define STMT_UPGRADE_31_SELECT_WCROOT_NODES 232
2591
 
#define STMT_232_INFO {"STMT_UPGRADE_31_SELECT_WCROOT_NODES", NULL}
2592
 
#define STMT_232 \
2593
2658
  "SELECT l.wc_id, l.local_relpath FROM nodes as l " \
2594
2659
  "LEFT OUTER JOIN nodes as r " \
2595
2660
  "ON l.wc_id = r.wc_id " \
2601
2666
  "       OR (l.repos_path IS NOT (CASE WHEN (r.local_relpath) = '' THEN (CASE WHEN (r.repos_path) = '' THEN (l.local_relpath) WHEN (l.local_relpath) = '' THEN (r.repos_path) ELSE (r.repos_path) || '/' || (l.local_relpath) END) WHEN (r.repos_path) = '' THEN (CASE WHEN (r.local_relpath) = '' THEN (l.local_relpath)  WHEN SUBSTR((l.local_relpath), 1, LENGTH(r.local_relpath)) = (r.local_relpath)  THEN CASE WHEN LENGTH(r.local_relpath) = LENGTH(l.local_relpath) THEN '' WHEN SUBSTR((l.local_relpath), LENGTH(r.local_relpath)+1, 1) = '/' THEN SUBSTR((l.local_relpath), LENGTH(r.local_relpath)+2) END END) WHEN SUBSTR((l.local_relpath), 1, LENGTH(r.local_relpath)) = (r.local_relpath) THEN CASE WHEN LENGTH(r.local_relpath) = LENGTH(l.local_relpath) THEN (r.repos_path) WHEN SUBSTR((l.local_relpath), LENGTH(r.local_relpath)+1, 1) = '/' THEN (r.repos_path) || SUBSTR((l.local_relpath), LENGTH(r.local_relpath)+1) END END))) " \
2602
2667
  ""
2603
2668
 
2604
 
#define STMT_UPGRADE_TO_32 233
2605
 
#define STMT_233_INFO {"STMT_UPGRADE_TO_32", NULL}
2606
 
#define STMT_233 \
 
2669
#define STMT_UPGRADE_TO_32 232
 
2670
#define STMT_232_INFO {"STMT_UPGRADE_TO_32", NULL}
 
2671
#define STMT_232 \
2607
2672
  "DROP INDEX IF EXISTS I_ACTUAL_CHANGELIST; " \
2608
2673
  "DROP INDEX IF EXISTS I_EXTERNALS_PARENT; " \
2609
2674
  "CREATE INDEX I_EXTERNALS_PARENT ON EXTERNALS (wc_id, parent_relpath); " \
2656
2721
  "DROP TABLE ACTUAL_NODE_BACKUP; " \
2657
2722
  ""
2658
2723
 
2659
 
#define STMT_VERIFICATION_TRIGGERS 234
2660
 
#define STMT_234_INFO {"STMT_VERIFICATION_TRIGGERS", NULL}
2661
 
#define STMT_234 \
 
2724
#define STMT_VERIFICATION_TRIGGERS 233
 
2725
#define STMT_233_INFO {"STMT_VERIFICATION_TRIGGERS", NULL}
 
2726
#define STMT_233 \
2662
2727
  "CREATE TEMPORARY TRIGGER no_repository_updates BEFORE UPDATE ON repository " \
2663
2728
  "BEGIN " \
2664
2729
  "  SELECT RAISE(FAIL, 'Updates to REPOSITORY are not allowed.'); " \
2697
2762
  "END; " \
2698
2763
  ""
2699
2764
 
 
2765
#define STMT_STATIC_VERIFY 234
 
2766
#define STMT_234_INFO {"STMT_STATIC_VERIFY", NULL}
 
2767
#define STMT_234 \
 
2768
  "SELECT local_relpath, op_depth, 1, 'Invalid parent relpath set in NODES' " \
 
2769
  "FROM nodes n WHERE local_relpath != '' " \
 
2770
  " AND (parent_relpath IS NULL " \
 
2771
  "      OR NOT (((local_relpath) > (CASE (parent_relpath) WHEN '' THEN '' ELSE (parent_relpath) || '/' END)) AND ((local_relpath) < CASE (parent_relpath) WHEN '' THEN X'FFFF' ELSE (parent_relpath) || '0' END)) " \
 
2772
  "      OR relpath_depth(local_relpath) != relpath_depth(parent_relpath)+1) " \
 
2773
  "UNION ALL " \
 
2774
  "SELECT local_relpath, -1, 2, 'Invalid parent relpath set in ACTUAL' " \
 
2775
  "FROM actual_node a WHERE local_relpath != '' " \
 
2776
  " AND (parent_relpath IS NULL " \
 
2777
  "      OR NOT (((local_relpath) > (CASE (parent_relpath) WHEN '' THEN '' ELSE (parent_relpath) || '/' END)) AND ((local_relpath) < CASE (parent_relpath) WHEN '' THEN X'FFFF' ELSE (parent_relpath) || '0' END)) " \
 
2778
  "      OR relpath_depth(local_relpath) != relpath_depth(parent_relpath)+1) " \
 
2779
  "UNION ALL " \
 
2780
  "SELECT local_relpath, -1, 10, 'No ancestor in ACTUAL' " \
 
2781
  "FROM actual_node a WHERE local_relpath != '' " \
 
2782
  " AND NOT EXISTS(SELECT 1 from nodes i " \
 
2783
  "                WHERE i.wc_id=a.wc_id " \
 
2784
  "                  AND i.local_relpath=a.parent_relpath) " \
 
2785
  " AND NOT EXISTS(SELECT 1 from nodes i " \
 
2786
  "                WHERE i.wc_id=a.wc_id " \
 
2787
  "                  AND i.local_relpath=a.local_relpath) " \
 
2788
  "UNION ALL " \
 
2789
  "SELECT a.local_relpath, -1, 11, 'Bad or Unneeded actual data' " \
 
2790
  "FROM actual_node a " \
 
2791
  "LEFT JOIN nodes n on n.wc_id = a.wc_id AND n.local_relpath = a.local_relpath " \
 
2792
  "   AND n.op_depth = (SELECT MAX(op_depth) from nodes i " \
 
2793
  "                     WHERE i.wc_id=a.wc_id AND i.local_relpath=a.local_relpath) " \
 
2794
  "WHERE (a.properties IS NOT NULL " \
 
2795
  "       AND (n.presence IS NULL " \
 
2796
  "            OR n.presence NOT IN ('normal', 'incomplete'))) " \
 
2797
  "   OR (a.changelist IS NOT NULL AND (n.kind IS NOT NULL AND n.kind != 'file')) " \
 
2798
  "   OR (a.conflict_data IS NULL AND a.properties IS NULL AND a.changelist IS NULL) " \
 
2799
  " AND NOT EXISTS(SELECT 1 from nodes i " \
 
2800
  "                WHERE i.wc_id=a.wc_id " \
 
2801
  "                  AND i.local_relpath=a.parent_relpath) " \
 
2802
  "UNION ALL " \
 
2803
  "SELECT local_relpath, op_depth, 20, 'No ancestor in NODES' " \
 
2804
  "FROM nodes n WHERE local_relpath != '' " \
 
2805
  " AND file_external IS NULL " \
 
2806
  " AND NOT EXISTS(SELECT 1 from nodes i " \
 
2807
  "                WHERE i.wc_id=n.wc_id " \
 
2808
  "                  AND i.local_relpath=n.parent_relpath " \
 
2809
  "                  AND i.op_depth <= n.op_depth) " \
 
2810
  "UNION ALL " \
 
2811
  "SELECT local_relpath, op_depth, 21, 'Unneeded node data' " \
 
2812
  "FROM nodes " \
 
2813
  "WHERE presence NOT IN ('normal', 'incomplete') " \
 
2814
  "AND (properties IS NOT NULL " \
 
2815
  "     OR checksum IS NOT NULL " \
 
2816
  "     OR depth IS NOT NULL " \
 
2817
  "     OR symlink_target IS NOT NULL " \
 
2818
  "     OR changed_revision IS NOT NULL " \
 
2819
  "     OR (changed_date IS NOT NULL AND changed_date != 0) " \
 
2820
  "     OR changed_author IS NOT NULL " \
 
2821
  "     OR translated_size IS NOT NULL " \
 
2822
  "     OR last_mod_time IS NOT NULL " \
 
2823
  "     OR dav_cache IS NOT NULL " \
 
2824
  "     OR file_external IS NOT NULL " \
 
2825
  "     OR inherited_props IS NOT NULL) " \
 
2826
  "UNION ALL " \
 
2827
  "SELECT local_relpath, op_depth, 22, 'Unneeded base-deleted node data' " \
 
2828
  "FROM nodes " \
 
2829
  "WHERE presence IN ('base-deleted') " \
 
2830
  "AND (repos_id IS NOT NULL " \
 
2831
  "     OR repos_path IS NOT NULL " \
 
2832
  "     OR revision IS NOT NULL) " \
 
2833
  "UNION ALL " \
 
2834
  "SELECT local_relpath, op_depth, 23, 'Kind specific data invalid on normal' " \
 
2835
  "FROM nodes " \
 
2836
  "WHERE presence IN ('normal', 'incomplete') " \
 
2837
  "AND (kind IS NULL " \
 
2838
  "     OR (repos_path IS NULL " \
 
2839
  "         AND (properties IS NOT NULL " \
 
2840
  "              OR changed_revision IS NOT NULL " \
 
2841
  "              OR changed_author IS NOT NULL " \
 
2842
  "              OR (changed_date IS NOT NULL AND changed_date != 0))) " \
 
2843
  "     OR (CASE WHEN kind = 'file' AND repos_path IS NOT NULL " \
 
2844
  "                                   THEN checksum IS NULL " \
 
2845
  "                                   ELSE checksum IS NOT NULL END) " \
 
2846
  "     OR (CASE WHEN kind = 'dir' THEN depth IS NULL " \
 
2847
  "                                  ELSE depth IS NOT NULL END) " \
 
2848
  "     OR (CASE WHEN kind = 'symlink' THEN symlink_target IS NULL " \
 
2849
  "                                      ELSE symlink_target IS NOT NULL END)) " \
 
2850
  "UNION ALL " \
 
2851
  "SELECT local_relpath, op_depth, 24, 'Invalid op-depth for local add' " \
 
2852
  "FROM nodes " \
 
2853
  "WHERE presence IN ('normal', 'incomplete') " \
 
2854
  "  AND repos_path IS NULL " \
 
2855
  "  AND op_depth != relpath_depth(local_relpath) " \
 
2856
  "UNION ALL " \
 
2857
  "SELECT local_relpath, op_depth, 25, 'Node missing op-depth ancestor' " \
 
2858
  "FROM nodes n " \
 
2859
  "WHERE op_depth < relpath_depth(local_relpath) " \
 
2860
  "  AND file_external IS NULL " \
 
2861
  "  AND NOT EXISTS(SELECT 1 FROM nodes p " \
 
2862
  "                 WHERE p.wc_id=n.wc_id AND p.local_relpath=n.parent_relpath " \
 
2863
  "                   AND p.op_depth=n.op_depth " \
 
2864
  "                   AND (p.presence IN ('normal', 'incomplete') " \
 
2865
  "                        OR (p.presence IN ('base-deleted', 'not-present') " \
 
2866
  "                            AND n.presence = 'base-deleted'))) " \
 
2867
  "UNION ALL " \
 
2868
  "SELECT n.local_relpath, n.op_depth, 26, 'Copied descendant mismatch' " \
 
2869
  "FROM nodes n " \
 
2870
  "JOIN nodes p " \
 
2871
  "  ON p.wc_id=n.wc_id AND p.local_relpath=n.parent_relpath " \
 
2872
  "  AND n.op_depth=p.op_depth " \
 
2873
  "WHERE n.op_depth > 0 AND n.presence IN ('normal', 'incomplete') " \
 
2874
  "   AND (n.repos_id != p.repos_id " \
 
2875
  "        OR n.repos_path != " \
 
2876
  "           (CASE WHEN (n.parent_relpath) = '' THEN (CASE WHEN (p.repos_path) = '' THEN (n.local_relpath) WHEN (n.local_relpath) = '' THEN (p.repos_path) ELSE (p.repos_path) || '/' || (n.local_relpath) END) WHEN (p.repos_path) = '' THEN (CASE WHEN (n.parent_relpath) = '' THEN (n.local_relpath)  WHEN SUBSTR((n.local_relpath), 1, LENGTH(n.parent_relpath)) = (n.parent_relpath)  THEN CASE WHEN LENGTH(n.parent_relpath) = LENGTH(n.local_relpath) THEN '' WHEN SUBSTR((n.local_relpath), LENGTH(n.parent_relpath)+1, 1) = '/' THEN SUBSTR((n.local_relpath), LENGTH(n.parent_relpath)+2) END END) WHEN SUBSTR((n.local_relpath), 1, LENGTH(n.parent_relpath)) = (n.parent_relpath) THEN CASE WHEN LENGTH(n.parent_relpath) = LENGTH(n.local_relpath) THEN (p.repos_path) WHEN SUBSTR((n.local_relpath), LENGTH(n.parent_relpath)+1, 1) = '/' THEN (p.repos_path) || SUBSTR((n.local_relpath), LENGTH(n.parent_relpath)+1) END END) " \
 
2877
  "        OR n.revision != p.revision " \
 
2878
  "        OR p.kind != 'dir' " \
 
2879
  "        OR n.moved_here IS NOT p.moved_here) " \
 
2880
  "UNION ALL " \
 
2881
  "SELECT n.local_relpath, n.op_depth, 27, 'Invalid op-root presence' " \
 
2882
  "FROM nodes n " \
 
2883
  "WHERE n.op_depth = relpath_depth(local_relpath) " \
 
2884
  "  AND presence NOT IN ('normal', 'incomplete', 'base-deleted') " \
 
2885
  "UNION ALL " \
 
2886
  "SELECT n.local_relpath, s.op_depth, 28, 'Incomplete shadowing' " \
 
2887
  "FROM nodes n " \
 
2888
  "JOIN nodes s ON s.wc_id=n.wc_id AND s.local_relpath=n.local_relpath " \
 
2889
  " AND s.op_depth = relpath_depth(s.local_relpath) " \
 
2890
  " AND s.op_depth = (SELECT MIN(op_depth) FROM nodes d " \
 
2891
  "                   WHERE d.wc_id=s.wc_id AND d.local_relpath=s.local_relpath " \
 
2892
  "                     AND d.op_depth > n.op_depth) " \
 
2893
  "WHERE n.presence IN ('normal', 'incomplete') " \
 
2894
  "  AND EXISTS(SELECT 1 " \
 
2895
  "             FROM nodes dn " \
 
2896
  "             WHERE dn.wc_id=n.wc_id AND dn.op_depth=n.op_depth " \
 
2897
  "               AND dn.presence IN ('normal', 'incomplete') " \
 
2898
  "               AND (((dn.local_relpath) > (CASE (n.local_relpath) WHEN '' THEN '' ELSE (n.local_relpath) || '/' END)) AND ((dn.local_relpath) < CASE (n.local_relpath) WHEN '' THEN X'FFFF' ELSE (n.local_relpath) || '0' END)) " \
 
2899
  "               AND dn.file_external IS NULL " \
 
2900
  "               AND NOT EXISTS(SELECT 1 " \
 
2901
  "                              FROM nodes ds " \
 
2902
  "                              WHERE ds.wc_id=n.wc_id AND ds.op_depth=s.op_depth " \
 
2903
  "                                AND ds.local_relpath=dn.local_relpath)) " \
 
2904
  "UNION ALL " \
 
2905
  "SELECT s.local_relpath, s.op_depth, 29, 'Invalid base-delete' " \
 
2906
  "FROM nodes s " \
 
2907
  "LEFT JOIN nodes n ON n.wc_id=s.wc_id AND n.local_relpath=s.local_relpath " \
 
2908
  " AND n.op_depth = (SELECT MAX(op_depth) FROM nodes d " \
 
2909
  "                   WHERE d.wc_id=s.wc_id AND d.local_relpath=s.local_relpath " \
 
2910
  "                     AND d.op_depth < s.op_depth) " \
 
2911
  "WHERE s.presence = 'base-deleted' " \
 
2912
  "  AND (n.presence IS NULL " \
 
2913
  "       OR n.presence NOT IN ('normal', 'incomplete') " \
 
2914
  "       ) " \
 
2915
  "UNION ALL " \
 
2916
  "SELECT n.local_relpath, n.op_depth, 30, 'Invalid data for BASE' " \
 
2917
  "FROM nodes n " \
 
2918
  "WHERE n.op_depth = 0 " \
 
2919
  "  AND (n.moved_to IS NOT NULL " \
 
2920
  "       OR n.moved_here IS NOT NULL) " \
 
2921
  "UNION ALL " \
 
2922
  "SELECT d.local_relpath, d.op_depth, 60, 'Moved here without origin' " \
 
2923
  "FROM nodes d " \
 
2924
  "WHERE d.op_depth = relpath_depth(d.local_relpath) " \
 
2925
  "  AND d.moved_here IS NOT NULL " \
 
2926
  "  AND NOT EXISTS(SELECT 1 FROM nodes s " \
 
2927
  "                 WHERE s.wc_id = d.wc_id AND s.moved_to = d.local_relpath) " \
 
2928
  "UNION ALL " \
 
2929
  "SELECT s.local_relpath, s.op_depth, 61, 'Moved to without target' " \
 
2930
  "FROM nodes s " \
 
2931
  "WHERE s.moved_to IS NOT NULL " \
 
2932
  "  AND NOT EXISTS(SELECT 1 FROM nodes d " \
 
2933
  "                 WHERE d.wc_id = s.wc_id AND d.local_relpath = s.moved_to " \
 
2934
  "                   AND d.op_depth = relpath_depth(d.local_relpath) " \
 
2935
  "                   AND d.moved_here =1 AND d.repos_path IS NOT NULL) " \
 
2936
  ""
 
2937
 
2700
2938
#define WC_QUERIES_SQL_DECLARE_STATEMENTS(varname) \
2701
2939
  static const char * const varname[] = { \
2702
2940
    STMT_0, \