ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/BDB/BDB.xs
(Generate patch)

Comparing BDB/BDB.xs (file contents):
Revision 1.55 by root, Fri Sep 26 02:37:33 2008 UTC vs.
Revision 1.67 by root, Fri Jan 9 22:32:12 2009 UTC

1#include <sys/user.h>
2#include <sys/ptrace.h>
3
4#define X_STACKSIZE 1024 * 128 + sizeof (long) * 64 * 1024 / 4 1#define X_STACKSIZE 1024 * 128 + sizeof (long) * 64 * 1024 / 4
5 2
6#include "xthread.h" 3#include "xthread.h"
7 4
8#include <errno.h> 5#include <errno.h>
… …
56#if DB_VERSION_MINOR >= 3 53#if DB_VERSION_MINOR >= 3
57typedef DB_SEQUENCE DB_SEQUENCE_ornull; 54typedef DB_SEQUENCE DB_SEQUENCE_ornull;
58typedef DB_SEQUENCE DB_SEQUENCE_ornuked; 55typedef DB_SEQUENCE DB_SEQUENCE_ornuked;
59#endif 56#endif
60 57
61typedef SV SV8; /* byte-sv, used for argument-checking */
62typedef char *bdb_filename; 58typedef char *bdb_filename;
63 59
64static SV *prepare_cb; 60static SV *prepare_cb;
65 61
66#if DB_VERSION_MINOR >= 6 62#if DB_VERSION_MINOR >= 6
… …
153 149
154enum { 150enum {
155 REQ_QUIT, 151 REQ_QUIT,
156 REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT, 152 REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
157 REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE, REQ_ENV_DBREMOVE, REQ_ENV_DBRENAME, 153 REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE, REQ_ENV_DBREMOVE, REQ_ENV_DBRENAME,
154 REQ_ENV_LOG_ARCHIVE,
158 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_UPGRADE, 155 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_VERIFY, REQ_DB_UPGRADE,
159 REQ_DB_PUT, REQ_DB_EXISTS, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE, 156 REQ_DB_PUT, REQ_DB_EXISTS, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE,
160 REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_TXN_FINISH, 157 REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_TXN_FINISH,
161 REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL, 158 REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
162 REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE, 159 REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,
163}; 160};
… …
353 abort (); 350 abort ();
354} 351}
355 352
356static int poll_cb (void); 353static int poll_cb (void);
357static void req_free (bdb_req req); 354static void req_free (bdb_req req);
358static void req_cancel (bdb_req req);
359 355
360static int req_invoke (bdb_req req) 356static int req_invoke (bdb_req req)
361{ 357{
362 switch (req->type) 358 switch (req->type)
363 { 359 {
… …
382 378
383 av_push (av, newSVnv (req->key_range.less)); 379 av_push (av, newSVnv (req->key_range.less));
384 av_push (av, newSVnv (req->key_range.equal)); 380 av_push (av, newSVnv (req->key_range.equal));
385 av_push (av, newSVnv (req->key_range.greater)); 381 av_push (av, newSVnv (req->key_range.greater));
386 382
383 av = (AV *)newRV_noinc ((SV *)av);
384
387 SvREADONLY_off (req->sv1); 385 SvREADONLY_off (req->sv1);
388 sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av)); 386 sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av));
387 SvREFCNT_dec (av);
389 SvREFCNT_dec (req->sv1); 388 SvREFCNT_dec (req->sv1);
390 } 389 }
391 break; 390 break;
392 391
393#if DB_VERSION_MINOR >= 3 392#if DB_VERSION_MINOR >= 3
… …
400 sv_setnv_mg (req->sv1, (NV)req->seq_t); 399 sv_setnv_mg (req->sv1, (NV)req->seq_t);
401 400
402 SvREFCNT_dec (req->sv1); 401 SvREFCNT_dec (req->sv1);
403 break; 402 break;
404#endif 403#endif
404
405 case REQ_ENV_LOG_ARCHIVE:
406 {
407 AV *av = newAV ();
408 char **listp = (char **)req->buf1;
409
410 if (listp)
411 while (*listp)
412 av_push (av, newSVpv (*listp, 0)), ++listp;
413
414 av = (AV *)newRV_noinc ((SV *)av);
415
416 SvREADONLY_off (req->sv1);
417 sv_setsv_mg (req->sv1, (SV *)av);
418 SvREFCNT_dec (av);
419 SvREFCNT_dec (req->sv1);
420 }
421 break;
405 } 422 }
406 423
407 errno = req->result; 424 errno = req->result;
408 425
409 if (req->callback) 426 if (req->callback)
… …
442} 459}
443 460
444#ifdef USE_SOCKETS_AS_HANDLES 461#ifdef USE_SOCKETS_AS_HANDLES
445# define TO_SOCKET(x) (win32_get_osfhandle (x)) 462# define TO_SOCKET(x) (win32_get_osfhandle (x))
446#else 463#else
464# define EV_SELECT_IS_WINSOCKET 1
447# define TO_SOCKET(x) (x) 465# define TO_SOCKET(x) (x)
466#endif
467
468#ifdef _WIN32
469/* taken verbatim from libev's ev_win32.c */
470/* oh, the humanity! */
471static int
472ev_pipe (int filedes [2])
473{
474 struct sockaddr_in addr = { 0 };
475 int addr_size = sizeof (addr);
476 struct sockaddr_in adr2;
477 int adr2_size;
478 SOCKET listener;
479 SOCKET sock [2] = { -1, -1 };
480
481 if ((listener = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
482 return -1;
483
484 addr.sin_family = AF_INET;
485 addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
486 addr.sin_port = 0;
487
488 if (bind (listener, (struct sockaddr *)&addr, addr_size))
489 goto fail;
490
491 if (getsockname (listener, (struct sockaddr *)&addr, &addr_size))
492 goto fail;
493
494 if (listen (listener, 1))
495 goto fail;
496
497 if ((sock [0] = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
498 goto fail;
499
500 if (connect (sock [0], (struct sockaddr *)&addr, addr_size))
501 goto fail;
502
503 if ((sock [1] = accept (listener, 0, 0)) < 0)
504 goto fail;
505
506 /* windows vista returns fantasy port numbers for getpeername.
507 * example for two interconnected tcp sockets:
508 *
509 * (Socket::unpack_sockaddr_in getsockname $sock0)[0] == 53364
510 * (Socket::unpack_sockaddr_in getpeername $sock0)[0] == 53363
511 * (Socket::unpack_sockaddr_in getsockname $sock1)[0] == 53363
512 * (Socket::unpack_sockaddr_in getpeername $sock1)[0] == 53365
513 *
514 * wow! tridirectional sockets!
515 *
516 * this way of checking ports seems to work:
517 */
518 if (getpeername (sock [0], (struct sockaddr *)&addr, &addr_size))
519 goto fail;
520
521 if (getsockname (sock [1], (struct sockaddr *)&adr2, &adr2_size))
522 goto fail;
523
524 errno = WSAEINVAL;
525 if (addr_size != adr2_size
526 || addr.sin_addr.s_addr != adr2.sin_addr.s_addr /* just to be sure, I mean, it's windows */
527 || addr.sin_port != adr2.sin_port)
528 goto fail;
529
530 closesocket (listener);
531
532#if EV_SELECT_IS_WINSOCKET
533 filedes [0] = _open_osfhandle (sock [0], 0);
534 filedes [1] = _open_osfhandle (sock [1], 0);
535#else
536 /* when select isn't winsocket, we also expect socket, connect, accept etc.
537 * to work on fds */
538 filedes [0] = sock [0];
539 filedes [1] = sock [1];
540#endif
541
542 return 0;
543
544fail:
545 closesocket (listener);
546
547 if (sock [0] != INVALID_SOCKET) closesocket (sock [0]);
548 if (sock [1] != INVALID_SOCKET) closesocket (sock [1]);
549
550 return -1;
551}
552
553#define pipe(filedes) ev_pipe(filedes)
448#endif 554#endif
449 555
450static void 556static void
451create_respipe (void) 557create_respipe (void)
452{ 558{
… …
456 int old_readfd = respipe [0]; 562 int old_readfd = respipe [0];
457 563
458 if (respipe [1] >= 0) 564 if (respipe [1] >= 0)
459 respipe_close (TO_SOCKET (respipe [1])); 565 respipe_close (TO_SOCKET (respipe [1]));
460 566
461#ifdef _WIN32
462 if (PerlSock_socketpair (AF_UNIX, SOCK_STREAM, 0, respipe))
463#else
464 if (pipe (respipe)) 567 if (pipe (respipe))
465#endif
466 croak ("unable to initialize result pipe"); 568 croak ("unable to initialize result pipe");
467 569
468 if (old_readfd >= 0) 570 if (old_readfd >= 0)
469 { 571 {
470 if (dup2 (TO_SOCKET (respipe [0]), TO_SOCKET (old_readfd)) < 0) 572 if (dup2 (TO_SOCKET (respipe [0]), TO_SOCKET (old_readfd)) < 0)
… …
773 req->result = req->db->close (req->db, req->uint1); 875 req->result = req->db->close (req->db, req->uint1);
774 break; 876 break;
775 877
776#if DB_VERSION_MINOR >= 4 878#if DB_VERSION_MINOR >= 4
777 case REQ_DB_COMPACT: 879 case REQ_DB_COMPACT:
778 req->result = req->db->compact (req->db, req->txn, &req->dbt1, &req->dbt2, 0, req->uint1, 0); 880 req->result = req->db->compact (req->db, req->txn, req->dbt1.data ? &req->dbt1 : 0, req->dbt2.data ? &req->dbt2 : 0, 0, req->uint1, 0);
779 break; 881 break;
780#endif 882#endif
781 883
782 case REQ_DB_SYNC: 884 case REQ_DB_SYNC:
783 req->result = req->db->sync (req->db, req->uint1); 885 req->result = req->db->sync (req->db, req->uint1);
886 break;
887
888 case REQ_DB_VERIFY:
889 req->result = req->db->verify (req->db, req->buf1, req->buf2, 0, req->uint1);
784 break; 890 break;
785 891
786 case REQ_DB_UPGRADE: 892 case REQ_DB_UPGRADE:
787 req->result = req->db->upgrade (req->db, req->buf1, req->uint1); 893 req->result = req->db->upgrade (req->db, req->buf1, req->uint1);
788 break; 894 break;
… …
874 980
875 case REQ_SEQ_REMOVE: 981 case REQ_SEQ_REMOVE:
876 req->result = req->seq->remove (req->seq, req->txn, req->uint1); 982 req->result = req->seq->remove (req->seq, req->txn, req->uint1);
877 break; 983 break;
878#endif 984#endif
985
986 case REQ_ENV_LOG_ARCHIVE:
987 {
988 char **listp = 0; /* DB_ARCH_REMOVE does not touch listp, contrary to docs */
989 req->result = req->env->log_archive (req->env, &listp, req->uint1);
990 req->buf1 = (char *)listp;
991 }
992 break;
879 993
880 default: 994 default:
881 req->result = ENOSYS; 995 req->result = ENOSYS;
882 break; 996 break;
883 } 997 }
… …
1138 } 1252 }
1139 1253
1140 return 0; 1254 return 0;
1141} 1255}
1142 1256
1257/*****************************************************************************/
1258
1259#if 0
1260static int
1261bt_pfxc_compare (DB *db, const DBT *dbt1, const DBT *dbt2)
1262{
1263 ssize_t size1 = dbt1->size;
1264 ssize_t size2 = dbt2->size;
1265 int res = memcmp ((void *)dbt1->data, (void *)dbt2->data,
1266 size1 <= size2 ? size1 : size2);
1267
1268 if (res)
1269 return res;
1270 else if (size1 - size2)
1271 return size1 - size2;
1272 else
1273 return 0;
1274}
1275
1276static size_t
1277bt_pfxc_prefix_x (DB *db, const DBT *dbt1, const DBT *dbt2)
1278{
1279 ssize_t size1 = dbt1->size;
1280 ssize_t size2 = dbt2->size;
1281 u_int8_t *p1 = (u_int8_t *)dbt1->data;
1282 u_int8_t *p2 = (u_int8_t *)dbt2->data;
1283 u_int8_t *pe = p1 + (size1 <= size2 ? size1 : size2);
1284
1285 while (p1 < pe)
1286 if (*p1++ != *p2++)
1287 return p1 - (u_int8_t *)dbt1->data - 1;
1288
1289 if (size1 < size2) return size1 + 1;
1290 if (size1 > size2) return size2 + 1;
1291
1292 return size1;
1293}
1294#endif
1295
1296/*****************************************************************************/
1297
1143/* stupid windoes defined CALLBACK as well */ 1298/* stupid windows defines CALLBACK as well */
1144#undef CALLBACK 1299#undef CALLBACK
1145#define CALLBACK SV *cb = pop_callback (&items, ST (items - 1)); 1300#define CALLBACK SV *cb = pop_callback (&items, ST (items - 1));
1146 1301
1147MODULE = BDB PACKAGE = BDB 1302MODULE = BDB PACKAGE = BDB
1148 1303
… …
1201 const_iv (NOSYNC) 1356 const_iv (NOSYNC)
1202 const_iv (CHKSUM) 1357 const_iv (CHKSUM)
1203 const_iv (ENCRYPT) 1358 const_iv (ENCRYPT)
1204 const_iv (DUP) 1359 const_iv (DUP)
1205 const_iv (DUPSORT) 1360 const_iv (DUPSORT)
1206 const_iv (RECNUM) 1361 //const_iv (RECNUM)
1207 const_iv (RENUMBER) 1362 const_iv (RENUMBER)
1208 const_iv (REVSPLITOFF) 1363 const_iv (REVSPLITOFF)
1209 const_iv (CONSUME) 1364 const_iv (CONSUME)
1210 const_iv (CONSUME_WAIT) 1365 const_iv (CONSUME_WAIT)
1211 const_iv (GET_BOTH) 1366 const_iv (GET_BOTH)
… …
1283 const_iv (REP_UNAVAIL) 1438 const_iv (REP_UNAVAIL)
1284 const_iv (RUNRECOVERY) 1439 const_iv (RUNRECOVERY)
1285 const_iv (SECONDARY_BAD) 1440 const_iv (SECONDARY_BAD)
1286 const_iv (VERIFY_BAD) 1441 const_iv (VERIFY_BAD)
1287 1442
1443 const_iv (SALVAGE)
1444 const_iv (AGGRESSIVE)
1445 const_iv (PRINTABLE)
1446 const_iv (NOORDERCHK)
1447 const_iv (ORDERCHKONLY)
1448
1449 const_iv (ARCH_ABS)
1450 const_iv (ARCH_DATA)
1451 const_iv (ARCH_LOG)
1452 const_iv (ARCH_REMOVE)
1453
1288 const_iv (VERB_DEADLOCK) 1454 const_iv (VERB_DEADLOCK)
1289 const_iv (VERB_RECOVERY) 1455 const_iv (VERB_RECOVERY)
1290 const_iv (VERB_REPLICATION) 1456 const_iv (VERB_REPLICATION)
1291 const_iv (VERB_WAITSFOR) 1457 const_iv (VERB_WAITSFOR)
1292 1458
… …
1325 const_iv (PRIORITY_VERY_LOW) 1491 const_iv (PRIORITY_VERY_LOW)
1326 const_iv (PRIORITY_LOW) 1492 const_iv (PRIORITY_LOW)
1327 const_iv (PRIORITY_DEFAULT) 1493 const_iv (PRIORITY_DEFAULT)
1328 const_iv (PRIORITY_HIGH) 1494 const_iv (PRIORITY_HIGH)
1329 const_iv (PRIORITY_VERY_HIGH) 1495 const_iv (PRIORITY_VERY_HIGH)
1496 const_iv (IGNORE_LEASE)
1330#endif 1497#endif
1331#if DB_VERSION_MINOR >= 7 1498#if DB_VERSION_MINOR >= 7
1499 //const_iv (MULTIPLE_KEY)
1332 const_iv (LOG_DIRECT) 1500 const_iv (LOG_DIRECT)
1333 const_iv (LOG_DSYNC) 1501 const_iv (LOG_DSYNC)
1334 const_iv (LOG_AUTO_REMOVE) 1502 const_iv (LOG_AUTO_REMOVE)
1335 const_iv (LOG_IN_MEMORY) 1503 const_iv (LOG_IN_MEMORY)
1336 const_iv (LOG_ZERO) 1504 const_iv (LOG_ZERO)
… …
1553db_env_close (DB_ENV *env, U32 flags = 0, SV *callback = 0) 1721db_env_close (DB_ENV *env, U32 flags = 0, SV *callback = 0)
1554 PREINIT: 1722 PREINIT:
1555 CALLBACK 1723 CALLBACK
1556 CODE: 1724 CODE:
1557{ 1725{
1726 dREQ (REQ_ENV_CLOSE, 0);
1558 ptr_nuke (ST (0)); 1727 ptr_nuke (ST (0));
1559 dREQ (REQ_ENV_CLOSE, 0);
1560 req->env = env; 1728 req->env = env;
1561 req->uint1 = flags; 1729 req->uint1 = flags;
1562 REQ_SEND; 1730 REQ_SEND;
1563} 1731}
1564 1732
… …
1636 dREQ (REQ_ENV_DBRENAME, 2); 1804 dREQ (REQ_ENV_DBRENAME, 2);
1637 req->env = env; 1805 req->env = env;
1638 req->buf1 = strdup_ornull (file); 1806 req->buf1 = strdup_ornull (file);
1639 req->buf2 = strdup_ornull (database); 1807 req->buf2 = strdup_ornull (database);
1640 req->buf3 = strdup_ornull (newname); 1808 req->buf3 = strdup_ornull (newname);
1809 req->uint1 = flags;
1810 REQ_SEND;
1811}
1812
1813void
1814db_env_log_archive (DB_ENV *env, SV_mutable *listp, U32 flags = 0, SV *callback = 0)
1815 PREINIT:
1816 CALLBACK
1817 CODE:
1818{
1819 dREQ (REQ_ENV_LOG_ARCHIVE, 1);
1820 req->sv1 = SvREFCNT_inc (listp);
1821 req->env = env;
1641 req->uint1 = flags; 1822 req->uint1 = flags;
1642 REQ_SEND; 1823 REQ_SEND;
1643} 1824}
1644 1825
1645DB * 1826DB *
… …
1677db_close (DB *db, U32 flags = 0, SV *callback = 0) 1858db_close (DB *db, U32 flags = 0, SV *callback = 0)
1678 PREINIT: 1859 PREINIT:
1679 CALLBACK 1860 CALLBACK
1680 CODE: 1861 CODE:
1681{ 1862{
1863 dREQ (REQ_DB_CLOSE, 0);
1682 ptr_nuke (ST (0)); 1864 ptr_nuke (ST (0));
1683 dREQ (REQ_DB_CLOSE, 0);
1684 req->db = db; 1865 req->db = db;
1685 req->uint1 = flags; 1866 req->uint1 = flags;
1686 req->sv1 = (SV *)db->app_private; 1867 req->sv1 = (SV *)db->app_private;
1687 REQ_SEND; 1868 REQ_SEND;
1688} 1869}
… …
1696 CODE: 1877 CODE:
1697{ 1878{
1698 dREQ (REQ_DB_COMPACT, 2); 1879 dREQ (REQ_DB_COMPACT, 2);
1699 req->db = db; 1880 req->db = db;
1700 req->txn = txn; 1881 req->txn = txn;
1701 sv_to_dbt (&req->dbt1, start); 1882 if (start) sv_to_dbt (&req->dbt1, start);
1702 sv_to_dbt (&req->dbt2, stop); 1883 if (stop ) sv_to_dbt (&req->dbt2, stop );
1703 req->uint1 = flags; 1884 req->uint1 = flags;
1704 REQ_SEND; 1885 REQ_SEND;
1705} 1886}
1706 1887
1707#endif 1888#endif
… …
1717 req->uint1 = flags; 1898 req->uint1 = flags;
1718 REQ_SEND; 1899 REQ_SEND;
1719} 1900}
1720 1901
1721void 1902void
1903db_verify (DB *db, bdb_filename file, bdb_filename database = 0, SV *dummy = 0, U32 flags = 0, SV *callback = 0)
1904 PREINIT:
1905 CALLBACK
1906 CODE:
1907{
1908 dREQ (REQ_DB_VERIFY, 1);
1909 ptr_nuke (ST (0)); /* verify destroys the database handle, hopefully it is freed as well */
1910 req->db = db;
1911 req->buf1 = strdup (file);
1912 req->buf2 = strdup_ornull (database);
1913 req->uint1 = flags;
1914 REQ_SEND;
1915}
1916
1917void
1722db_upgrade (DB *db, bdb_filename file, U32 flags = 0, SV *callback = 0) 1918db_upgrade (DB *db, bdb_filename file, U32 flags = 0, SV *callback = 0)
1723 PREINIT: 1919 PREINIT:
1724 CALLBACK 1920 CALLBACK
1725 CODE: 1921 CODE:
1726{ 1922{
1727 dREQ (REQ_DB_SYNC, 1); 1923 dREQ (REQ_DB_UPGRADE, 1);
1728 req->db = db; 1924 req->db = db;
1729 req->buf1 = strdup (file); 1925 req->buf1 = strdup (file);
1730 req->uint1 = flags; 1926 req->uint1 = flags;
1731 REQ_SEND; 1927 REQ_SEND;
1732} 1928}
… …
1836db_txn_commit (DB_TXN *txn, U32 flags = 0, SV *callback = 0) 2032db_txn_commit (DB_TXN *txn, U32 flags = 0, SV *callback = 0)
1837 PREINIT: 2033 PREINIT:
1838 CALLBACK 2034 CALLBACK
1839 CODE: 2035 CODE:
1840{ 2036{
2037 dREQ (REQ_TXN_COMMIT, 0);
1841 ptr_nuke (ST (0)); 2038 ptr_nuke (ST (0));
1842 dREQ (REQ_TXN_COMMIT, 0);
1843 req->txn = txn; 2039 req->txn = txn;
1844 req->uint1 = flags; 2040 req->uint1 = flags;
1845 REQ_SEND; 2041 REQ_SEND;
1846} 2042}
1847 2043
… …
1849db_txn_abort (DB_TXN *txn, SV *callback = 0) 2045db_txn_abort (DB_TXN *txn, SV *callback = 0)
1850 PREINIT: 2046 PREINIT:
1851 CALLBACK 2047 CALLBACK
1852 CODE: 2048 CODE:
1853{ 2049{
2050 dREQ (REQ_TXN_ABORT, 0);
1854 ptr_nuke (ST (0)); 2051 ptr_nuke (ST (0));
1855 dREQ (REQ_TXN_ABORT, 0);
1856 req->txn = txn; 2052 req->txn = txn;
1857 REQ_SEND; 2053 REQ_SEND;
1858} 2054}
1859 2055
1860void 2056void
1861db_txn_finish (DB_TXN *txn, U32 flags = 0, SV *callback = 0) 2057db_txn_finish (DB_TXN *txn, U32 flags = 0, SV *callback = 0)
1862 PREINIT: 2058 PREINIT:
1863 CALLBACK 2059 CALLBACK
1864 CODE: 2060 CODE:
1865{ 2061{
2062 dREQ (REQ_TXN_FINISH, 0);
1866 ptr_nuke (ST (0)); 2063 ptr_nuke (ST (0));
1867 dREQ (REQ_TXN_FINISH, 0);
1868 req->txn = txn; 2064 req->txn = txn;
1869 req->uint1 = flags; 2065 req->uint1 = flags;
1870 REQ_SEND; 2066 REQ_SEND;
1871} 2067}
1872 2068
… …
1874db_c_close (DBC *dbc, SV *callback = 0) 2070db_c_close (DBC *dbc, SV *callback = 0)
1875 PREINIT: 2071 PREINIT:
1876 CALLBACK 2072 CALLBACK
1877 CODE: 2073 CODE:
1878{ 2074{
2075 dREQ (REQ_C_CLOSE, 0);
1879 ptr_nuke (ST (0)); 2076 ptr_nuke (ST (0));
1880 dREQ (REQ_C_CLOSE, 0);
1881 req->dbc = dbc; 2077 req->dbc = dbc;
1882 REQ_SEND; 2078 REQ_SEND;
1883} 2079}
1884 2080
1885void 2081void
… …
1912db_c_get (DBC *dbc, SV *key, SV_mutable *data, U32 flags = 0, SV *callback = 0) 2108db_c_get (DBC *dbc, SV *key, SV_mutable *data, U32 flags = 0, SV *callback = 0)
1913 PREINIT: 2109 PREINIT:
1914 CALLBACK 2110 CALLBACK
1915 CODE: 2111 CODE:
1916{ 2112{
1917 if (flags & DB_OPFLAGS_MASK != DB_SET && SvREADONLY (key)) 2113 if ((flags & DB_OPFLAGS_MASK) != DB_SET && SvREADONLY (key))
1918 croak ("db_c_get was passed a read-only/constant 'key' argument but operation is not DB_SET"); 2114 croak ("db_c_get was passed a read-only/constant 'key' argument but operation is not DB_SET");
2115 if (SvPOKp (key) && !sv_utf8_downgrade (key, 1))
2116 croak ("argument \"%s\" must be byte/octet-encoded in %s",
2117 "key",
2118 "BDB::db_c_get");
1919 2119
2120 {
1920 dREQ (REQ_C_GET, 1); 2121 dREQ (REQ_C_GET, 1);
1921 req->dbc = dbc; 2122 req->dbc = dbc;
1922 req->uint1 = flags; 2123 req->uint1 = flags;
1923 if (flags & DB_OPFLAGS_MASK == DB_SET) 2124 if ((flags & DB_OPFLAGS_MASK) == DB_SET)
1924 sv_to_dbt (&req->dbt1, key); 2125 sv_to_dbt (&req->dbt1, key);
1925 else 2126 else
1926 { 2127 {
1927 if (flags & DB_OPFLAGS_MASK == DB_SET_RANGE) 2128 if ((flags & DB_OPFLAGS_MASK) == DB_SET_RANGE)
1928 sv_to_dbt (&req->dbt1, key); 2129 sv_to_dbt (&req->dbt1, key);
1929 else 2130 else
1930 req->dbt1.flags = DB_DBT_MALLOC; 2131 req->dbt1.flags = DB_DBT_MALLOC;
1931 2132
1932 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key); 2133 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
1933 } 2134 }
1934 2135
1935 if (flags & DB_OPFLAGS_MASK == DB_GET_BOTH 2136 if ((flags & DB_OPFLAGS_MASK) == DB_GET_BOTH
1936 || flags & DB_OPFLAGS_MASK == DB_GET_BOTH_RANGE) 2137 || (flags & DB_OPFLAGS_MASK) == DB_GET_BOTH_RANGE)
1937 sv_to_dbt (&req->dbt3, data); 2138 sv_to_dbt (&req->dbt3, data);
1938 else 2139 else
1939 req->dbt3.flags = DB_DBT_MALLOC; 2140 req->dbt3.flags = DB_DBT_MALLOC;
1940 2141
1941 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data); 2142 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1942 REQ_SEND; 2143 REQ_SEND;
2144 }
1943} 2145}
1944 2146
1945void 2147void
1946db_c_pget (DBC *dbc, SV *key, SV_mutable *pkey, SV_mutable *data, U32 flags = 0, SV *callback = 0) 2148db_c_pget (DBC *dbc, SV *key, SV_mutable *pkey, SV_mutable *data, U32 flags = 0, SV *callback = 0)
1947 PREINIT: 2149 PREINIT:
1948 CALLBACK 2150 CALLBACK
1949 CODE: 2151 CODE:
1950{ 2152{
1951 if (flags & DB_OPFLAGS_MASK != DB_SET && SvREADONLY (key)) 2153 if ((flags & DB_OPFLAGS_MASK) != DB_SET && SvREADONLY (key))
1952 croak ("db_c_pget was passed a read-only/constant 'key' argument but operation is not DB_SET"); 2154 croak ("db_c_pget was passed a read-only/constant 'key' argument but operation is not DB_SET");
2155 if (SvPOKp (key) && !sv_utf8_downgrade (key, 1))
2156 croak ("argument \"%s\" must be byte/octet-encoded in %s",
2157 "key",
2158 "BDB::db_c_pget");
1953 2159
2160 {
1954 dREQ (REQ_C_PGET, 1); 2161 dREQ (REQ_C_PGET, 1);
1955 req->dbc = dbc; 2162 req->dbc = dbc;
1956 req->uint1 = flags; 2163 req->uint1 = flags;
1957 if (flags & DB_OPFLAGS_MASK == DB_SET) 2164 if ((flags & DB_OPFLAGS_MASK) == DB_SET)
1958 sv_to_dbt (&req->dbt1, key); 2165 sv_to_dbt (&req->dbt1, key);
1959 else 2166 else
1960 { 2167 {
1961 if (flags & DB_OPFLAGS_MASK == DB_SET_RANGE) 2168 if ((flags & DB_OPFLAGS_MASK) == DB_SET_RANGE)
1962 sv_to_dbt (&req->dbt1, key); 2169 sv_to_dbt (&req->dbt1, key);
1963 else 2170 else
1964 req->dbt1.flags = DB_DBT_MALLOC; 2171 req->dbt1.flags = DB_DBT_MALLOC;
1965 2172
1966 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key); 2173 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
1967 } 2174 }
1968 2175
1969 req->dbt2.flags = DB_DBT_MALLOC; 2176 req->dbt2.flags = DB_DBT_MALLOC;
1970 req->sv2 = SvREFCNT_inc (pkey); SvREADONLY_on (pkey); 2177 req->sv2 = SvREFCNT_inc (pkey); SvREADONLY_on (pkey);
1971 2178
1972 if (flags & DB_OPFLAGS_MASK == DB_GET_BOTH 2179 if ((flags & DB_OPFLAGS_MASK) == DB_GET_BOTH
1973 || flags & DB_OPFLAGS_MASK == DB_GET_BOTH_RANGE) 2180 || (flags & DB_OPFLAGS_MASK) == DB_GET_BOTH_RANGE)
1974 sv_to_dbt (&req->dbt3, data); 2181 sv_to_dbt (&req->dbt3, data);
1975 else 2182 else
1976 req->dbt3.flags = DB_DBT_MALLOC; 2183 req->dbt3.flags = DB_DBT_MALLOC;
1977 2184
1978 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data); 2185 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1979 REQ_SEND; 2186 REQ_SEND;
2187 }
1980} 2188}
1981 2189
1982void 2190void
1983db_c_del (DBC *dbc, U32 flags = 0, SV *callback = 0) 2191db_c_del (DBC *dbc, U32 flags = 0, SV *callback = 0)
1984 PREINIT: 2192 PREINIT:
… …
2012db_sequence_close (DB_SEQUENCE *seq, U32 flags = 0, SV *callback = 0) 2220db_sequence_close (DB_SEQUENCE *seq, U32 flags = 0, SV *callback = 0)
2013 PREINIT: 2221 PREINIT:
2014 CALLBACK 2222 CALLBACK
2015 CODE: 2223 CODE:
2016{ 2224{
2225 dREQ (REQ_SEQ_CLOSE, 0);
2017 ptr_nuke (ST (0)); 2226 ptr_nuke (ST (0));
2018 dREQ (REQ_SEQ_CLOSE, 0);
2019 req->seq = seq; 2227 req->seq = seq;
2020 req->uint1 = flags; 2228 req->uint1 = flags;
2021 REQ_SEND; 2229 REQ_SEND;
2022} 2230}
2023 2231
… …
2259 CODE: 2467 CODE:
2260 RETVAL = db->set_cachesize (db, gbytes, bytes, ncache); 2468 RETVAL = db->set_cachesize (db, gbytes, bytes, ncache);
2261 OUTPUT: 2469 OUTPUT:
2262 RETVAL 2470 RETVAL
2263 2471
2472int set_pagesize (DB *db, U32 pagesize)
2473 CODE:
2474 RETVAL = db->set_pagesize (db, pagesize);
2475 OUTPUT:
2476 RETVAL
2477
2264int set_flags (DB *db, U32 flags) 2478int set_flags (DB *db, U32 flags)
2265 CODE: 2479 CODE:
2266 RETVAL = db->set_flags (db, flags); 2480 RETVAL = db->set_flags (db, flags);
2267 OUTPUT: 2481 OUTPUT:
2268 RETVAL 2482 RETVAL

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines