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

Comparing BDB/BDB.xs (file contents):
Revision 1.5 by root, Mon Feb 5 23:46:15 2007 UTC vs.
Revision 1.6 by root, Tue Feb 6 01:09:04 2007 UTC

… …
56strdup_ornull (const char *s) 56strdup_ornull (const char *s)
57{ 57{
58 return s ? strdup (s) : 0; 58 return s ? strdup (s) : 0;
59} 59}
60 60
61inline void 61static inline void
62sv_to_dbt (DBT *dbt, SV *sv) 62sv_to_dbt (DBT *dbt, SV *sv)
63{ 63{
64 STRLEN len; 64 STRLEN len;
65 char *data = SvPVbyte (sv, len); 65 char *data = SvPVbyte (sv, len);
66 66
67 dbt->data = malloc (len); 67 dbt->data = malloc (len);
68 memcpy (dbt->data, data, len); 68 memcpy (dbt->data, data, len);
69 dbt->size = len; 69 dbt->size = len;
70 dbt->flags = DB_DBT_REALLOC;
70} 71}
71 72
72inline void 73static inline void
73dbt_to_sv (SV *sv, DBT *dbt) 74dbt_to_sv (SV *sv, DBT *dbt)
74{ 75{
76 if (sv)
77 {
75 SvREADONLY_off (sv); 78 SvREADONLY_off (sv);
76 sv_setpvn_mg (sv, dbt->data, dbt->size); 79 sv_setpvn_mg (sv, dbt->data, dbt->size);
80 SvREFCNT_dec (sv);
81 }
77 82
78 free (dbt->data); 83 free (dbt->data);
79} 84}
80 85
81enum { 86enum {
82 REQ_QUIT, 87 REQ_QUIT,
83 REQ_ENV_OPEN, REQ_ENV_CLOSE, 88 REQ_ENV_OPEN, REQ_ENV_CLOSE,
84 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, 89 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL,
85 REQ_TXN_COMMIT, REQ_TXN_ABORT, 90 REQ_TXN_COMMIT, REQ_TXN_ABORT,
91 REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
86}; 92};
87 93
88typedef struct aio_cb 94typedef struct aio_cb
89{ 95{
90 struct aio_cb *volatile next; 96 struct aio_cb *volatile next;
… …
92 int type, pri, result; 98 int type, pri, result;
93 99
94 DB_ENV *env; 100 DB_ENV *env;
95 DB *db; 101 DB *db;
96 DB_TXN *txn; 102 DB_TXN *txn;
97 DBC *cursor; 103 DBC *dbc;
104
105 UV uv1;
98 int int1, int2; 106 int int1, int2;
99 U32 uint1, uint2; 107 U32 uint1, uint2;
100 char *buf1, *buf2; 108 char *buf1, *buf2;
101 SV *sv1, *sv2; 109 SV *sv1, *sv2, *sv3;
102 110
103 DBT dbt1, dbt2, dbt3; 111 DBT dbt1, dbt2, dbt3;
104} aio_cb; 112} aio_cb;
105 113
106typedef aio_cb *aio_req; 114typedef aio_cb *aio_req;
… …
289 PUSHMARK (SP); 297 PUSHMARK (SP);
290 EXTEND (SP, 1); 298 EXTEND (SP, 1);
291 299
292 switch (req->type) 300 switch (req->type)
293 { 301 {
302 case REQ_DB_CLOSE:
303 SvREFCNT_dec (req->sv1);
304 break;
305
294 case REQ_DB_GET: 306 case REQ_DB_GET:
295 case REQ_DB_PGET: 307 case REQ_DB_PGET:
296 dbt_to_sv (req->sv1, &req->dbt3); 308 dbt_to_sv (req->sv3, &req->dbt3);
297 SvREFCNT_dec (req->sv1);
298 break; 309 break;
299 310
300 case REQ_DB_CLOSE: 311 case REQ_C_GET:
301 SvREFCNT_dec (req->sv1); 312 case REQ_C_PGET:
313 dbt_to_sv (req->sv1, &req->dbt1);
314 dbt_to_sv (req->sv2, &req->dbt2);
315 dbt_to_sv (req->sv3, &req->dbt3);
302 break; 316 break;
303 } 317 }
304 318
305 errno = req->result; 319 errno = req->result;
306 320
… …
654 668
655 case REQ_DB_PGET: 669 case REQ_DB_PGET:
656 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1); 670 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
657 break; 671 break;
658 672
673 case REQ_DB_DEL:
674 req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
675 break;
676
659 case REQ_TXN_COMMIT: 677 case REQ_TXN_COMMIT:
660 req->result = req->txn->commit (req->txn, req->uint1); 678 req->result = req->txn->commit (req->txn, req->uint1);
661 break; 679 break;
662 680
663 case REQ_TXN_ABORT: 681 case REQ_TXN_ABORT:
664 req->result = req->txn->abort (req->txn); 682 req->result = req->txn->abort (req->txn);
683 break;
684
685 case REQ_C_CLOSE:
686 req->result = req->dbc->c_close (req->dbc);
687 break;
688
689 case REQ_C_COUNT:
690 {
691 db_recno_t recno;
692 req->result = req->dbc->c_count (req->dbc, &recno, req->uint1);
693 req->uv1 = recno;
694 }
695 break;
696
697 case REQ_C_PUT:
698 req->result = req->dbc->c_put (req->dbc, &req->dbt1, &req->dbt2, req->uint1);
699 break;
700
701 case REQ_C_GET:
702 req->result = req->dbc->c_get (req->dbc, &req->dbt1, &req->dbt3, req->uint1);
703 break;
704
705 case REQ_C_PGET:
706 req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
707 break;
708
709 case REQ_C_DEL:
710 req->result = req->dbc->c_del (req->dbc, req->uint1);
665 break; 711 break;
666 712
667 default: 713 default:
668 req->result = ENOSYS; 714 req->result = ENOSYS;
669 break; 715 break;
… …
859 const_iv (REVSPLITOFF) 905 const_iv (REVSPLITOFF)
860 const_iv (INORDER) 906 const_iv (INORDER)
861 const_iv (CONSUME) 907 const_iv (CONSUME)
862 const_iv (CONSUME_WAIT) 908 const_iv (CONSUME_WAIT)
863 const_iv (GET_BOTH) 909 const_iv (GET_BOTH)
910 const_iv (GET_BOTH_RANGE)
864 //const_iv (SET_RECNO) 911 //const_iv (SET_RECNO)
865 //const_iv (MULTIPLE) 912 //const_iv (MULTIPLE)
866 const_iv (SNAPSHOT) 913 const_iv (SNAPSHOT)
867 const_iv (JOIN_ITEM) 914 const_iv (JOIN_ITEM)
868 const_iv (RMW) 915 const_iv (RMW)
… …
873 const_iv (LOCK_NOTGRANTED) 920 const_iv (LOCK_NOTGRANTED)
874 const_iv (RUNRECOVERY) 921 const_iv (RUNRECOVERY)
875 const_iv (OLD_VERSION) 922 const_iv (OLD_VERSION)
876 const_iv (REP_HANDLE_DEAD) 923 const_iv (REP_HANDLE_DEAD)
877 const_iv (REP_LOCKOUT) 924 const_iv (REP_LOCKOUT)
925 const_iv (SECONDARY_BAD)
878 926
879 const_iv (FREE_SPACE) 927 const_iv (FREE_SPACE)
880 const_iv (FREELIST_ONLY) 928 const_iv (FREELIST_ONLY)
881 929
882 const_iv (APPEND) 930 const_iv (APPEND)
… …
887 const_iv (TXN_SNAPSHOT) 935 const_iv (TXN_SNAPSHOT)
888 const_iv (TXN_SYNC) 936 const_iv (TXN_SYNC)
889 937
890 const_iv (SET_LOCK_TIMEOUT) 938 const_iv (SET_LOCK_TIMEOUT)
891 const_iv (SET_TXN_TIMEOUT) 939 const_iv (SET_TXN_TIMEOUT)
940
941 const_iv (JOIN_ITEM)
942 const_iv (FIRST)
943 const_iv (NEXT)
944 const_iv (NEXT_DUP)
945 const_iv (NEXT_NODUP)
946 const_iv (PREV)
947 const_iv (PREV_NODUP)
948 const_iv (SET)
949 const_iv (SET_RANGE)
950 const_iv (LAST)
951 const_iv (BEFORE)
952 const_iv (AFTER)
953 const_iv (CURRENT)
954 const_iv (KEYFIRST)
955 const_iv (KEYLAST)
956 const_iv (NODUPDATA)
892 }; 957 };
893 958
894 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 959 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
895 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 960 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
896 961
… …
1075db_create (DB_ENV *env = 0, U32 flags = 0) 1140db_create (DB_ENV *env = 0, U32 flags = 0)
1076 CODE: 1141 CODE:
1077{ 1142{
1078 errno = db_create (&RETVAL, env, flags); 1143 errno = db_create (&RETVAL, env, flags);
1079 if (errno) 1144 if (errno)
1080 croak ("db_env_create: %s", db_strerror (errno)); 1145 croak ("db_create: %s", db_strerror (errno));
1081 1146
1082 if (RETVAL) 1147 if (RETVAL)
1083 RETVAL->app_private = (void *)newSVsv (ST (0)); 1148 RETVAL->app_private = (void *)newSVsv (ST (0));
1084} 1149}
1085 OUTPUT: 1150 OUTPUT:
… …
1153 CODE: 1218 CODE:
1154{ 1219{
1155 dREQ (REQ_DB_GET); 1220 dREQ (REQ_DB_GET);
1156 req->db = db; 1221 req->db = db;
1157 req->txn = txn; 1222 req->txn = txn;
1223 req->uint1 = flags;
1158 sv_to_dbt (&req->dbt1, key); 1224 sv_to_dbt (&req->dbt1, key);
1159 req->dbt3.flags = DB_DBT_MALLOC; 1225 req->dbt3.flags = DB_DBT_MALLOC;
1160 req->uint1 = flags;
1161 req->sv1 = SvREFCNT_inc (data); 1226 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1162 SvREADONLY_on (data);
1163 REQ_SEND; 1227 REQ_SEND;
1164} 1228}
1165 1229
1166void 1230void
1167db_pget (DB *db, DB_TXN_ornull *txn, SV *key, SV *pkey, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef) 1231db_pget (DB *db, DB_TXN_ornull *txn, SV *key, SV *pkey, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
1168 CODE: 1232 CODE:
1169{ 1233{
1170 dREQ (REQ_DB_PGET); 1234 dREQ (REQ_DB_PGET);
1171 req->db = db; 1235 req->db = db;
1172 req->txn = txn; 1236 req->txn = txn;
1237 req->uint1 = flags;
1173 sv_to_dbt (&req->dbt1, key); 1238 sv_to_dbt (&req->dbt1, key);
1174 sv_to_dbt (&req->dbt2, pkey); 1239 sv_to_dbt (&req->dbt2, pkey);
1175 req->dbt3.flags = DB_DBT_MALLOC; 1240 req->dbt3.flags = DB_DBT_MALLOC;
1241 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1242 REQ_SEND;
1243}
1244
1245void
1246db_del (DB *db, DB_TXN_ornull *txn, SV *key, U32 flags = 0, SV *callback = &PL_sv_undef)
1247 CODE:
1248{
1249 dREQ (REQ_DB_DEL);
1250 req->db = db;
1251 req->txn = txn;
1176 req->uint1 = flags; 1252 req->uint1 = flags;
1177 req->sv1 = SvREFCNT_inc (data); 1253 sv_to_dbt (&req->dbt1, key);
1178 SvREADONLY_on (data);
1179 REQ_SEND; 1254 REQ_SEND;
1180} 1255}
1181 1256
1182void 1257void
1183db_txn_commit (DB_TXN *txn, U32 flags = 0, SV *callback = &PL_sv_undef) 1258db_txn_commit (DB_TXN *txn, U32 flags = 0, SV *callback = &PL_sv_undef)
… …
1198 req->txn = txn; 1273 req->txn = txn;
1199 REQ_SEND; 1274 REQ_SEND;
1200 ptr_nuke (ST (0)); 1275 ptr_nuke (ST (0));
1201} 1276}
1202 1277
1278void
1279db_c_close (DBC *dbc, SV *callback = &PL_sv_undef)
1280 CODE:
1281{
1282 dREQ (REQ_C_CLOSE);
1283 req->dbc = dbc;
1284 REQ_SEND;
1285 ptr_nuke (ST (0));
1286}
1287
1288void
1289db_c_count (DBC *dbc, SV *count, U32 flags = 0, SV *callback = &PL_sv_undef)
1290 CODE:
1291{
1292 dREQ (REQ_C_COUNT);
1293 req->dbc = dbc;
1294 req->sv1 = SvREFCNT_inc (count);
1295 REQ_SEND;
1296}
1297
1298void
1299db_c_put (DBC *dbc, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
1300 CODE:
1301{
1302 dREQ (REQ_C_PUT);
1303 req->dbc = dbc;
1304 sv_to_dbt (&req->dbt1, key);
1305 sv_to_dbt (&req->dbt2, data);
1306 req->uint1 = flags;
1307 REQ_SEND;
1308}
1309
1310void
1311db_c_get (DBC *dbc, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
1312 CODE:
1313{
1314 dREQ (REQ_C_GET);
1315 req->dbc = dbc;
1316 req->uint1 = flags;
1317 if ((flags & DB_SET) == DB_SET
1318 || (flags & DB_SET_RANGE) == DB_SET_RANGE)
1319 sv_to_dbt (&req->dbt1, key);
1320 else
1321 req->dbt1.flags = DB_DBT_MALLOC;
1322
1323 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
1324
1325 if ((flags & DB_GET_BOTH) == DB_GET_BOTH
1326 || (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
1327 sv_to_dbt (&req->dbt3, data);
1328 else
1329 req->dbt3.flags = DB_DBT_MALLOC;
1330
1331 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1332 REQ_SEND;
1333}
1334
1335void
1336db_c_pget (DBC *dbc, SV *key, SV *pkey, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
1337 CODE:
1338{
1339 dREQ (REQ_C_PGET);
1340 req->dbc = dbc;
1341 req->uint1 = flags;
1342 if ((flags & DB_SET) == DB_SET
1343 || (flags & DB_SET_RANGE) == DB_SET_RANGE)
1344 sv_to_dbt (&req->dbt1, key);
1345 else
1346 req->dbt1.flags = DB_DBT_MALLOC;
1347
1348 req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
1349
1350 req->dbt2.flags = DB_DBT_MALLOC;
1351 req->sv2 = SvREFCNT_inc (pkey); SvREADONLY_on (pkey);
1352
1353 if ((flags & DB_GET_BOTH) == DB_GET_BOTH
1354 || (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
1355 sv_to_dbt (&req->dbt3, data);
1356 else
1357 req->dbt3.flags = DB_DBT_MALLOC;
1358
1359 req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1360 REQ_SEND;
1361}
1362
1363void
1364db_c_del (DBC *dbc, U32 flags = 0, SV *callback = &PL_sv_undef)
1365 CODE:
1366{
1367 dREQ (REQ_C_DEL);
1368 req->dbc = dbc;
1369 req->uint1 = flags;
1370 REQ_SEND;
1371}
1372
1203 1373
1204MODULE = BDB PACKAGE = BDB::Env 1374MODULE = BDB PACKAGE = BDB::Env
1205 1375
1206void 1376void
1207DESTROY (DB_ENV_ornull *env) 1377DESTROY (DB_ENV_ornull *env)
… …
1236DB_TXN * 1406DB_TXN *
1237txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0) 1407txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0)
1238 CODE: 1408 CODE:
1239 errno = env->txn_begin (env, parent, &RETVAL, flags); 1409 errno = env->txn_begin (env, parent, &RETVAL, flags);
1240 if (errno) 1410 if (errno)
1241 croak ("txn_begin: %s", db_strerror (errno)); 1411 croak ("DB_ENV->txn_begin: %s", db_strerror (errno));
1242 OUTPUT: 1412 OUTPUT:
1243 RETVAL 1413 RETVAL
1244 1414
1245MODULE = BDB PACKAGE = BDB::Db 1415MODULE = BDB PACKAGE = BDB::Db
1246 1416
… …
1325 CODE: 1495 CODE:
1326 RETVAL = db->set_q_extentsize (db, extentsize); 1496 RETVAL = db->set_q_extentsize (db, extentsize);
1327 OUTPUT: 1497 OUTPUT:
1328 RETVAL 1498 RETVAL
1329 1499
1500DBC *
1501cursor (DB *db, DB_TXN_ornull *txn = 0, U32 flags = 0)
1502 CODE:
1503 errno = db->cursor (db, txn, &RETVAL, flags);
1504 if (errno)
1505 croak ("DB->cursor: %s", db_strerror (errno));
1506 OUTPUT:
1507 RETVAL
1508
1509
1330MODULE = BDB PACKAGE = BDB::Txn 1510MODULE = BDB PACKAGE = BDB::Txn
1331 1511
1332void 1512void
1333DESTROY (DB_TXN_ornull *txn) 1513DESTROY (DB_TXN_ornull *txn)
1334 CODE: 1514 CODE:
… …
1340 RETVAL = txn->set_timeout (txn, timeout * 1000000, flags); 1520 RETVAL = txn->set_timeout (txn, timeout * 1000000, flags);
1341 OUTPUT: 1521 OUTPUT:
1342 RETVAL 1522 RETVAL
1343 1523
1344 1524
1525MODULE = BDB PACKAGE = BDB::Cursor
1526
1527void
1528DESTROY (DBC_ornull *dbc)
1529 CODE:
1530 if (dbc)
1531 dbc->c_close (dbc);
1532

Diff Legend

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