← Back to branch summary

~svn/ubuntu/oneiric/subversion/ppa

« back to all changes in this revision

Viewing changes to subversion/libsvn_fs_base/bdb/strings-table.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-12-13 17:57:16 UTC
  • mfrom: (1.1.6 upstream) (0.1.3 etch)
  • Revision ID: james.westby@ubuntu.com-20061213175716-2ysv6z4w5dpa2r2f
Tags: 1.4.2dfsg1-2ubuntu1
* Merge with Debian unstable; remaining changes:
  - Create pot file on build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/libsvn_fs_base/bdb/strings-table.c
33
33
/*** Creating and opening the strings table. ***/
34
34
 
35
35
int
36
 
svn_fs_bdb__open_strings_table (DB **strings_p,
37
 
                                DB_ENV *env,
38
 
                                svn_boolean_t create)
 
36
svn_fs_bdb__open_strings_table(DB **strings_p,
 
37
                               DB_ENV *env,
 
38
                               svn_boolean_t create)
39
39
{
40
40
  const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
41
41
  DB *strings;
42
42
 
43
 
  BDB_ERR (svn_fs_bdb__check_version());
44
 
  BDB_ERR (db_create (&strings, env, 0));
 
43
  BDB_ERR(svn_fs_bdb__check_version());
 
44
  BDB_ERR(db_create(&strings, env, 0));
45
45
 
46
46
  /* Enable duplicate keys. This allows the data to be spread out across
47
47
     multiple records. Note: this must occur before ->open().  */
48
 
  BDB_ERR (strings->set_flags (strings, DB_DUP));
 
48
  BDB_ERR(strings->set_flags(strings, DB_DUP));
49
49
 
50
 
  BDB_ERR (strings->open (SVN_BDB_OPEN_PARAMS(strings, NULL),
51
 
                         "strings", 0, DB_BTREE,
52
 
                         open_flags | SVN_BDB_AUTO_COMMIT,
53
 
                         0666));
 
50
  BDB_ERR(strings->open(SVN_BDB_OPEN_PARAMS(strings, NULL),
 
51
                        "strings", 0, DB_BTREE,
 
52
                        open_flags, 0666));
54
53
 
55
54
  if (create)
56
55
    {
57
56
      DBT key, value;
58
57
 
59
58
      /* Create the `next-key' table entry.  */
60
 
      BDB_ERR (strings->put
 
59
      BDB_ERR(strings->put
61
60
              (strings, 0,
62
 
               svn_fs_base__str_to_dbt (&key, NEXT_KEY_KEY),
63
 
               svn_fs_base__str_to_dbt (&value, "0"),
64
 
               SVN_BDB_AUTO_COMMIT));
 
61
               svn_fs_base__str_to_dbt(&key, NEXT_KEY_KEY),
 
62
               svn_fs_base__str_to_dbt(&value, "0"), 0));
65
63
    }
66
64
 
67
65
  *strings_p = strings;
76
74
   whose key is defined by QUERY.  Set *LENGTH to the size of that
77
75
   first row.  */
78
76
static svn_error_t *
79
 
locate_key (apr_size_t *length,
80
 
            DBC **cursor,
81
 
            DBT *query,
82
 
            svn_fs_t *fs,
83
 
            trail_t *trail,
84
 
            apr_pool_t *pool)
 
77
locate_key(apr_size_t *length,
 
78
           DBC **cursor,
 
79
           DBT *query,
 
80
           svn_fs_t *fs,
 
81
           trail_t *trail,
 
82
           apr_pool_t *pool)
85
83
{
86
84
  base_fs_data_t *bfd = fs->fsap_data;
87
85
  int db_err;
88
86
  DBT result;
89
87
 
90
 
  svn_fs_base__trail_debug (trail, "strings", "cursor");
91
 
  SVN_ERR (BDB_WRAP (fs, _("creating cursor for reading a string"),
92
 
                     bfd->strings->cursor (bfd->strings, trail->db_txn,
93
 
                                           cursor, 0)));
 
88
  svn_fs_base__trail_debug(trail, "strings", "cursor");
 
89
  SVN_ERR(BDB_WRAP(fs, _("creating cursor for reading a string"),
 
90
                   bfd->strings->cursor(bfd->strings, trail->db_txn,
 
91
                                        cursor, 0)));
94
92
 
95
93
  /* Set up the DBT for reading the length of the record. */
96
 
  svn_fs_base__clear_dbt (&result);
 
94
  svn_fs_base__clear_dbt(&result);
97
95
  result.ulen = 0;
98
96
  result.flags |= DB_DBT_USERMEM;
99
97
 
100
98
  /* Advance the cursor to the key that we're looking for. */
101
 
  db_err = (*cursor)->c_get (*cursor, query, &result, DB_SET);
 
99
  db_err = (*cursor)->c_get(*cursor, query, &result, DB_SET);
102
100
 
103
101
  /* We don't need to svn_fs_base__track_dbt() the result, because nothing
104
102
     was allocated in it. */
106
104
  /* If there's no such node, return an appropriately specific error.  */
107
105
  if (db_err == DB_NOTFOUND)
108
106
    {
109
 
      (*cursor)->c_close (*cursor);
 
107
      (*cursor)->c_close(*cursor);
110
108
      return svn_error_createf
111
109
        (SVN_ERR_FS_NO_SUCH_STRING, 0,
112
110
         "No such string '%s'", (const char *)query->data);
117
115
 
118
116
      if (db_err != SVN_BDB_DB_BUFFER_SMALL)
119
117
        {
120
 
          (*cursor)->c_close (*cursor);
121
 
          return BDB_WRAP (fs, "moving cursor", db_err);
 
118
          (*cursor)->c_close(*cursor);
 
119
          return BDB_WRAP(fs, "moving cursor", db_err);
122
120
        }
123
121
 
124
122
      /* We got an SVN_BDB_DB_BUFFER_SMALL (typical since we have a
125
123
         zero length buf), so we need to re-run the operation to make
126
124
         it happen. */
127
 
      svn_fs_base__clear_dbt (&rerun);
 
125
      svn_fs_base__clear_dbt(&rerun);
128
126
      rerun.flags |= DB_DBT_USERMEM | DB_DBT_PARTIAL;
129
 
      db_err = (*cursor)->c_get (*cursor, query, &rerun, DB_SET);
 
127
      db_err = (*cursor)->c_get(*cursor, query, &rerun, DB_SET);
130
128
      if (db_err)
131
129
        {
132
 
          (*cursor)->c_close (*cursor);
133
 
          return BDB_WRAP (fs, "rerunning cursor move", db_err);
 
130
          (*cursor)->c_close(*cursor);
 
131
          return BDB_WRAP(fs, "rerunning cursor move", db_err);
134
132
        }
135
133
    }
136
134
 
145
143
   CURSOR's current location.  Set *LENGTH to the size of that next
146
144
   row.  If any error occurs, CURSOR will be destroyed.  */
147
145
static int
148
 
get_next_length (apr_size_t *length, DBC *cursor, DBT *query)
 
146
get_next_length(apr_size_t *length, DBC *cursor, DBT *query)
149
147
{
150
148
  DBT result;
151
149
  int db_err;
152
150
 
153
151
  /* Set up the DBT for reading the length of the record. */
154
 
  svn_fs_base__clear_dbt (&result);
 
152
  svn_fs_base__clear_dbt(&result);
155
153
  result.ulen = 0;
156
154
  result.flags |= DB_DBT_USERMEM;
157
155
 
158
156
  /* Note: this may change the QUERY DBT, but that's okay: we're going
159
157
     to be sticking with the same key anyways.  */
160
 
  db_err = cursor->c_get (cursor, query, &result, DB_NEXT_DUP);
 
158
  db_err = cursor->c_get(cursor, query, &result, DB_NEXT_DUP);
161
159
 
162
160
  /* Note that we exit on DB_NOTFOUND. The caller uses that to end a loop. */
163
161
  if (db_err)
166
164
 
167
165
      if (db_err != SVN_BDB_DB_BUFFER_SMALL)
168
166
        {
169
 
          cursor->c_close (cursor);
 
167
          cursor->c_close(cursor);
170
168
          return db_err;
171
169
        }
172
170
 
173
171
      /* We got an SVN_BDB_DB_BUFFER_SMALL (typical since we have a
174
172
         zero length buf), so we need to re-run the operation to make
175
173
         it happen. */
176
 
      svn_fs_base__clear_dbt (&rerun);
 
174
      svn_fs_base__clear_dbt(&rerun);
177
175
      rerun.flags |= DB_DBT_USERMEM | DB_DBT_PARTIAL;
178
 
      db_err = cursor->c_get (cursor, query, &rerun, DB_NEXT_DUP);
 
176
      db_err = cursor->c_get(cursor, query, &rerun, DB_NEXT_DUP);
179
177
      if (db_err)
180
 
        cursor->c_close (cursor);
 
178
        cursor->c_close(cursor);
181
179
    }
182
180
 
183
181
  /* ### this cast might not be safe? */
187
185
 
188
186
 
189
187
svn_error_t *
190
 
svn_fs_bdb__string_read (svn_fs_t *fs,
191
 
                         const char *key,
192
 
                         char *buf,
193
 
                         svn_filesize_t offset,
194
 
                         apr_size_t *len,
195
 
                         trail_t *trail,
196
 
                         apr_pool_t *pool)
 
188
svn_fs_bdb__string_read(svn_fs_t *fs,
 
189
                        const char *key,
 
190
                        char *buf,
 
191
                        svn_filesize_t offset,
 
192
                        apr_size_t *len,
 
193
                        trail_t *trail,
 
194
                        apr_pool_t *pool)
197
195
{
198
196
  int db_err;
199
197
  DBT query, result;
200
198
  DBC *cursor;
201
199
  apr_size_t length, bytes_read = 0;
202
200
 
203
 
  svn_fs_base__str_to_dbt (&query, key);
 
201
  svn_fs_base__str_to_dbt(&query, key);
204
202
 
205
 
  SVN_ERR (locate_key (&length, &cursor, &query, fs, trail, pool));
 
203
  SVN_ERR(locate_key(&length, &cursor, &query, fs, trail, pool));
206
204
 
207
205
  /* Seek through the records for this key, trying to find the record that
208
206
     includes OFFSET. Note that we don't require reading from more than
213
211
 
214
212
      /* Remember, if any error happens, our cursor has been closed
215
213
         for us. */
216
 
      db_err = get_next_length (&length, cursor, &query);
 
214
      db_err = get_next_length(&length, cursor, &query);
217
215
 
218
216
      /* No more records? They tried to read past the end. */
219
217
      if (db_err == DB_NOTFOUND)
222
220
          return SVN_NO_ERROR;
223
221
        }
224
222
      if (db_err)
225
 
        return BDB_WRAP (fs, "reading string", db_err);
 
223
        return BDB_WRAP(fs, "reading string", db_err);
226
224
    }
227
225
 
228
226
  /* The current record contains OFFSET. Fetch the contents now. Note that
231
229
     read successive records until we've filled the request.  */
232
230
  while (1)
233
231
    {
234
 
      svn_fs_base__clear_dbt (&result);
 
232
      svn_fs_base__clear_dbt(&result);
235
233
      result.data = buf + bytes_read;
236
234
      result.ulen = *len - bytes_read;
237
235
      result.doff = (u_int32_t)offset;
238
236
      result.dlen = *len - bytes_read;
239
237
      result.flags |= (DB_DBT_USERMEM | DB_DBT_PARTIAL);
240
 
      db_err = cursor->c_get (cursor, &query, &result, DB_CURRENT);
 
238
      db_err = cursor->c_get(cursor, &query, &result, DB_CURRENT);
241
239
      if (db_err)
242
240
        {
243
 
          cursor->c_close (cursor);
244
 
          return BDB_WRAP (fs, "reading string", db_err);
 
241
          cursor->c_close(cursor);
 
242
          return BDB_WRAP(fs, "reading string", db_err);
245
243
        }
246
244
 
247
245
      bytes_read += result.size;
248
246
      if (bytes_read == *len)
249
247
        {
250
248
          /* Done with the cursor. */
251
 
          SVN_ERR (BDB_WRAP (fs, "closing string-reading cursor",
252
 
                            cursor->c_close (cursor)));
 
249
          SVN_ERR(BDB_WRAP(fs, "closing string-reading cursor",
 
250
                           cursor->c_close(cursor)));
253
251
          break;
254
252
        }
255
253
 
256
254
      /* Remember, if any error happens, our cursor has been closed
257
255
         for us. */
258
 
      db_err = get_next_length (&length, cursor, &query);
 
256
      db_err = get_next_length(&length, cursor, &query);
259
257
      if (db_err == DB_NOTFOUND)
260
258
        break;
261
259
      if (db_err)
262
 
        return BDB_WRAP (fs, "reading string", db_err);
 
260
        return BDB_WRAP(fs, "reading string", db_err);
263
261
 
264
262
      /* We'll be reading from the beginning of the next record */
265
263
      offset = 0;
272
270
 
273
271
/* Get the current 'next-key' value and bump the record. */
274
272
static svn_error_t *
275
 
get_key_and_bump (svn_fs_t *fs, 
276
 
                  const char **key, 
277
 
                  trail_t *trail,
278
 
                  apr_pool_t *pool)
 
273
get_key_and_bump(svn_fs_t *fs, 
 
274
                 const char **key, 
 
275
                 trail_t *trail,
 
276
                 apr_pool_t *pool)
279
277
{
280
278
  base_fs_data_t *bfd = fs->fsap_data;
281
279
  DBC *cursor;
293
291
     this database allows duplicates, we can't do an arbitrary 'put' to
294
292
     write the new value -- that would append, not overwrite.  */
295
293
 
296
 
  svn_fs_base__trail_debug (trail, "strings", "cursor");
297
 
  SVN_ERR (BDB_WRAP (fs, "creating cursor for reading a string",
298
 
                     bfd->strings->cursor (bfd->strings, trail->db_txn,
299
 
                                           &cursor, 0)));
 
294
  svn_fs_base__trail_debug(trail, "strings", "cursor");
 
295
  SVN_ERR(BDB_WRAP(fs, "creating cursor for reading a string",
 
296
                   bfd->strings->cursor(bfd->strings, trail->db_txn,
 
297
                                        &cursor, 0)));
300
298
 
301
299
  /* Advance the cursor to 'next-key' and read it. */
302
300
 
303
 
  db_err = cursor->c_get (cursor,
304
 
                          svn_fs_base__str_to_dbt (&query, NEXT_KEY_KEY),
305
 
                          svn_fs_base__result_dbt (&result),
306
 
                          DB_SET);
 
301
  db_err = cursor->c_get(cursor,
 
302
                         svn_fs_base__str_to_dbt(&query, NEXT_KEY_KEY),
 
303
                         svn_fs_base__result_dbt(&result),
 
304
                         DB_SET);
307
305
  if (db_err)
308
306
    {
309
 
      cursor->c_close (cursor);
310
 
      return BDB_WRAP (fs, "getting next-key value", db_err);
 
307
      cursor->c_close(cursor);
 
308
      return BDB_WRAP(fs, "getting next-key value", db_err);
311
309
    }
312
310
 
313
 
  svn_fs_base__track_dbt (&result, pool);
314
 
  *key = apr_pstrmemdup (pool, result.data, result.size);
 
311
  svn_fs_base__track_dbt(&result, pool);
 
312
  *key = apr_pstrmemdup(pool, result.data, result.size);
315
313
 
316
314
  /* Bump to future key. */
317
315
  key_len = result.size;
318
 
  svn_fs_base__next_key (result.data, &key_len, next_key);
 
316
  svn_fs_base__next_key(result.data, &key_len, next_key);
319
317
 
320
318
  /* Shove the new key back into the database, at the cursor position. */
321
 
  db_err = cursor->c_put (cursor, &query,
322
 
                          svn_fs_base__str_to_dbt (&result, next_key),
323
 
                          DB_CURRENT);
 
319
  db_err = cursor->c_put(cursor, &query,
 
320
                         svn_fs_base__str_to_dbt(&result, next_key),
 
321
                         DB_CURRENT);
324
322
  if (db_err)
325
323
    {
326
 
      cursor->c_close (cursor); /* ignore the error, the original is
 
324
      cursor->c_close(cursor); /* ignore the error, the original is
327
325
                                   more important. */
328
 
      return BDB_WRAP (fs, "bumping next string key", db_err);
 
326
      return BDB_WRAP(fs, "bumping next string key", db_err);
329
327
    }
330
328
 
331
 
  return BDB_WRAP (fs, "closing string-reading cursor",
332
 
                  cursor->c_close (cursor));
 
329
  return BDB_WRAP(fs, "closing string-reading cursor",
 
330
                  cursor->c_close(cursor));
333
331
}
334
332
 
335
333
svn_error_t *
336
 
svn_fs_bdb__string_append (svn_fs_t *fs,
337
 
                           const char **key,
338
 
                           apr_size_t len,
339
 
                           const char *buf,
340
 
                           trail_t *trail,
341
 
                           apr_pool_t *pool)
 
334
svn_fs_bdb__string_append(svn_fs_t *fs,
 
335
                          const char **key,
 
336
                          apr_size_t len,
 
337
                          const char *buf,
 
338
                          trail_t *trail,
 
339
                          apr_pool_t *pool)
342
340
{
343
341
  base_fs_data_t *bfd = fs->fsap_data;
344
342
  DBT query, result;
347
345
     using the value of the `next-key' record in the strings table. */
348
346
  if (*key == NULL)
349
347
    {
350
 
      SVN_ERR (get_key_and_bump (fs, key, trail, pool));
 
348
      SVN_ERR(get_key_and_bump(fs, key, trail, pool));
351
349
    }
352
350
 
353
351
  /* Store a new record into the database. */
354
 
  svn_fs_base__trail_debug (trail, "strings", "put");
355
 
  SVN_ERR (BDB_WRAP (fs, "appending string",
356
 
                     bfd->strings->put
357
 
                     (bfd->strings, trail->db_txn,
358
 
                      svn_fs_base__str_to_dbt (&query, *key),
359
 
                      svn_fs_base__set_dbt (&result, buf, len),
360
 
                      0)));
 
352
  svn_fs_base__trail_debug(trail, "strings", "put");
 
353
  SVN_ERR(BDB_WRAP(fs, "appending string",
 
354
                   bfd->strings->put
 
355
                   (bfd->strings, trail->db_txn,
 
356
                    svn_fs_base__str_to_dbt(&query, *key),
 
357
                    svn_fs_base__set_dbt(&result, buf, len),
 
358
                    0)));
361
359
 
362
360
  return SVN_NO_ERROR;
363
361
}
364
362
 
365
363
 
366
364
svn_error_t *
367
 
svn_fs_bdb__string_clear (svn_fs_t *fs,
368
 
                          const char *key,
369
 
                          trail_t *trail,
370
 
                          apr_pool_t *pool)
 
365
svn_fs_bdb__string_clear(svn_fs_t *fs,
 
366
                         const char *key,
 
367
                         trail_t *trail,
 
368
                         apr_pool_t *pool)
371
369
{
372
370
  base_fs_data_t *bfd = fs->fsap_data;
373
371
  int db_err;
374
372
  DBT query, result;
375
373
 
376
 
  svn_fs_base__str_to_dbt (&query, key);
 
374
  svn_fs_base__str_to_dbt(&query, key);
377
375
 
378
376
  /* Torch the prior contents */
379
 
  svn_fs_base__trail_debug (trail, "strings", "del");
380
 
  db_err = bfd->strings->del (bfd->strings, trail->db_txn, &query, 0);
 
377
  svn_fs_base__trail_debug(trail, "strings", "del");
 
378
  db_err = bfd->strings->del(bfd->strings, trail->db_txn, &query, 0);
381
379
 
382
380
  /* If there's no such node, return an appropriately specific error.  */
383
381
  if (db_err == DB_NOTFOUND)
386
384
       "No such string '%s'", key);
387
385
 
388
386
  /* Handle any other error conditions.  */
389
 
  SVN_ERR (BDB_WRAP (fs, "clearing string", db_err));
 
387
  SVN_ERR(BDB_WRAP(fs, "clearing string", db_err));
390
388
 
391
389
  /* Shove empty data back in for this key. */
392
 
  svn_fs_base__clear_dbt (&result);
 
390
  svn_fs_base__clear_dbt(&result);
393
391
  result.data = 0;
394
392
  result.size = 0;
395
393
  result.flags |= DB_DBT_USERMEM;
396
394
 
397
 
  svn_fs_base__trail_debug (trail, "strings", "put");
398
 
  return BDB_WRAP (fs, "storing empty contents",
399
 
                   bfd->strings->put (bfd->strings, trail->db_txn,
400
 
                                      &query, &result, 0));
 
395
  svn_fs_base__trail_debug(trail, "strings", "put");
 
396
  return BDB_WRAP(fs, "storing empty contents",
 
397
                  bfd->strings->put(bfd->strings, trail->db_txn,
 
398
                                    &query, &result, 0));
401
399
}
402
400
 
403
401
 
404
402
svn_error_t *
405
 
svn_fs_bdb__string_size (svn_filesize_t *size,
406
 
                         svn_fs_t *fs,
407
 
                         const char *key,
408
 
                         trail_t *trail,
409
 
                         apr_pool_t *pool)
 
403
svn_fs_bdb__string_size(svn_filesize_t *size,
 
404
                        svn_fs_t *fs,
 
405
                        const char *key,
 
406
                        trail_t *trail,
 
407
                        apr_pool_t *pool)
410
408
{
411
409
  int db_err;
412
410
  DBT query;
414
412
  apr_size_t length;
415
413
  svn_filesize_t total;
416
414
 
417
 
  svn_fs_base__str_to_dbt (&query, key);
 
415
  svn_fs_base__str_to_dbt(&query, key);
418
416
 
419
 
  SVN_ERR (locate_key (&length, &cursor, &query, fs, trail, pool));
 
417
  SVN_ERR(locate_key(&length, &cursor, &query, fs, trail, pool));
420
418
 
421
419
  total = length;
422
420
  while (1)
423
421
    {
424
422
      /* Remember, if any error happens, our cursor has been closed
425
423
         for us. */
426
 
      db_err = get_next_length (&length, cursor, &query);
 
424
      db_err = get_next_length(&length, cursor, &query);
427
425
 
428
426
      /* No more records? Then return the total length. */
429
427
      if (db_err == DB_NOTFOUND)
432
430
          return SVN_NO_ERROR;
433
431
        }
434
432
      if (db_err)
435
 
        return BDB_WRAP (fs, "fetching string length", db_err);
 
433
        return BDB_WRAP(fs, "fetching string length", db_err);
436
434
 
437
435
      total += length;
438
436
    }
442
440
 
443
441
 
444
442
svn_error_t *
445
 
svn_fs_bdb__string_delete (svn_fs_t *fs,
446
 
                           const char *key,
447
 
                           trail_t *trail,
448
 
                           apr_pool_t *pool)
 
443
svn_fs_bdb__string_delete(svn_fs_t *fs,
 
444
                          const char *key,
 
445
                          trail_t *trail,
 
446
                          apr_pool_t *pool)
449
447
{
450
448
  base_fs_data_t *bfd = fs->fsap_data;
451
449
  int db_err;
452
450
  DBT query;
453
451
 
454
 
  svn_fs_base__trail_debug (trail, "strings", "del");
455
 
  db_err = bfd->strings->del (bfd->strings, trail->db_txn,
456
 
                              svn_fs_base__str_to_dbt (&query, key), 0);
 
452
  svn_fs_base__trail_debug(trail, "strings", "del");
 
453
  db_err = bfd->strings->del(bfd->strings, trail->db_txn,
 
454
                             svn_fs_base__str_to_dbt(&query, key), 0);
457
455
 
458
456
  /* If there's no such node, return an appropriately specific error.  */
459
457
  if (db_err == DB_NOTFOUND)
462
460
       "No such string '%s'", key);
463
461
 
464
462
  /* Handle any other error conditions.  */
465
 
  SVN_ERR (BDB_WRAP (fs, "deleting string", db_err));
 
463
  SVN_ERR(BDB_WRAP(fs, "deleting string", db_err));
466
464
 
467
465
  return SVN_NO_ERROR;
468
466
}
469
467
 
470
468
 
471
469
svn_error_t *
472
 
svn_fs_bdb__string_copy (svn_fs_t *fs,
473
 
                         const char **new_key,
474
 
                         const char *key,
475
 
                         trail_t *trail,
476
 
                         apr_pool_t *pool)
 
470
svn_fs_bdb__string_copy(svn_fs_t *fs,
 
471
                        const char **new_key,
 
472
                        const char *key,
 
473
                        trail_t *trail,
 
474
                        apr_pool_t *pool)
477
475
{
478
476
  base_fs_data_t *bfd = fs->fsap_data;
479
477
  DBT query;
484
482
 
485
483
  /* Copy off the old key in case the caller is sharing storage
486
484
     between the old and new keys. */
487
 
  const char *old_key = apr_pstrdup (pool, key);
488
 
 
489
 
  SVN_ERR (get_key_and_bump (fs, new_key, trail, pool));
490
 
 
491
 
  svn_fs_base__trail_debug (trail, "strings", "cursor");
492
 
  SVN_ERR (BDB_WRAP (fs, "creating cursor for reading a string",
493
 
                     bfd->strings->cursor (bfd->strings, trail->db_txn,
494
 
                                           &cursor, 0)));
495
 
 
496
 
  svn_fs_base__str_to_dbt (&query, old_key);
497
 
  svn_fs_base__str_to_dbt (&copykey, *new_key);
498
 
 
499
 
  svn_fs_base__clear_dbt (&result);
 
485
  const char *old_key = apr_pstrdup(pool, key);
 
486
 
 
487
  SVN_ERR(get_key_and_bump(fs, new_key, trail, pool));
 
488
 
 
489
  svn_fs_base__trail_debug(trail, "strings", "cursor");
 
490
  SVN_ERR(BDB_WRAP(fs, "creating cursor for reading a string",
 
491
                   bfd->strings->cursor(bfd->strings, trail->db_txn,
 
492
                                        &cursor, 0)));
 
493
 
 
494
  svn_fs_base__str_to_dbt(&query, old_key);
 
495
  svn_fs_base__str_to_dbt(&copykey, *new_key);
 
496
 
 
497
  svn_fs_base__clear_dbt(&result);
500
498
 
501
499
  /* Move to the first record and fetch its data (under BDB's mem mgmt). */
502
 
  db_err = cursor->c_get (cursor, &query, &result, DB_SET);
 
500
  db_err = cursor->c_get(cursor, &query, &result, DB_SET);
503
501
  if (db_err)
504
502
    {
505
 
      cursor->c_close (cursor);
506
 
      return BDB_WRAP (fs, "getting next-key value", db_err);
 
503
      cursor->c_close(cursor);
 
504
      return BDB_WRAP(fs, "getting next-key value", db_err);
507
505
    }
508
506
 
509
507
  while (1)
516
514
      */
517
515
 
518
516
      /* Write the data to the database */
519
 
      svn_fs_base__trail_debug (trail, "strings", "put");
520
 
      db_err = bfd->strings->put (bfd->strings, trail->db_txn,
521
 
                                  &copykey, &result, 0);
 
517
      svn_fs_base__trail_debug(trail, "strings", "put");
 
518
      db_err = bfd->strings->put(bfd->strings, trail->db_txn,
 
519
                                 &copykey, &result, 0);
522
520
      if (db_err)
523
521
        {
524
 
          cursor->c_close (cursor);
525
 
          return BDB_WRAP (fs, "writing copied data", db_err);
 
522
          cursor->c_close(cursor);
 
523
          return BDB_WRAP(fs, "writing copied data", db_err);
526
524
        }
527
525
 
528
526
      /* Read the next chunk. Terminate loop if we're done. */
529
 
      svn_fs_base__clear_dbt (&result);
530
 
      db_err = cursor->c_get (cursor, &query, &result, DB_NEXT_DUP);
 
527
      svn_fs_base__clear_dbt(&result);
 
528
      db_err = cursor->c_get(cursor, &query, &result, DB_NEXT_DUP);
531
529
      if (db_err == DB_NOTFOUND)
532
530
        break;
533
531
      if (db_err)
534
532
        {
535
 
          cursor->c_close (cursor);
536
 
          return BDB_WRAP (fs, "fetching string data for a copy", db_err);
 
533
          cursor->c_close(cursor);
 
534
          return BDB_WRAP(fs, "fetching string data for a copy", db_err);
537
535
        }
538
536
    }
539
537
 
540
 
  return BDB_WRAP (fs, "closing string-reading cursor",
541
 
                  cursor->c_close (cursor));
 
538
  return BDB_WRAP(fs, "closing string-reading cursor",
 
539
                  cursor->c_close(cursor));
542
540
}