db_remove.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2001-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: db_remove.c,v 11.203 2002/08/19 18:34:18 margo Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #endif
  14. #include "db_int.h"
  15. #include "dbinc/db_page.h"
  16. #include "dbinc/fop.h"
  17. #include "dbinc/btree.h"
  18. #include "dbinc/hash.h"
  19. #include "dbinc/db_shash.h"
  20. #include "dbinc/lock.h"
  21. static int __db_subdb_remove __P((DB *, DB_TXN *, const char *, const char *));
  22. static int __db_dbtxn_remove __P((DB *, DB_TXN *, const char *));
  23. /*
  24.  * __dbenv_dbremove
  25.  * Remove method for DB_ENV.
  26.  *
  27.  * PUBLIC: int __dbenv_dbremove __P((DB_ENV *,
  28.  * PUBLIC:     DB_TXN *, const char *, const char *, u_int32_t));
  29.  */
  30. int
  31. __dbenv_dbremove(dbenv, txn, name, subdb, flags)
  32. DB_ENV *dbenv;
  33. DB_TXN *txn;
  34. const char *name, *subdb;
  35. u_int32_t flags;
  36. {
  37. DB *dbp;
  38. int ret, t_ret, txn_local;
  39. txn_local = 0;
  40. PANIC_CHECK(dbenv);
  41. ENV_ILLEGAL_BEFORE_OPEN(dbenv, "DB_ENV->dbremove");
  42. /* Validate arguments. */
  43. if ((ret = __db_fchk(dbenv, "DB->remove", flags, DB_AUTO_COMMIT)) != 0)
  44. return (ret);
  45. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  46. return (ret);
  47. /*
  48.  * Create local transaction as necessary, check for consistent
  49.  * transaction usage.
  50.  */
  51. if (IS_AUTO_COMMIT(dbenv, txn, flags)) {
  52. if ((ret = __db_txn_auto(dbp, &txn)) != 0)
  53. return (ret);
  54. txn_local = 1;
  55. } else
  56. if (txn != NULL && !TXN_ON(dbenv))
  57. return (__db_not_txn_env(dbenv));
  58. ret = __db_remove_i(dbp, txn, name, subdb);
  59. /* Commit for DB_AUTO_COMMIT. */
  60. if (txn_local) {
  61. if (ret == 0)
  62. ret = txn->commit(txn, 0);
  63. else
  64. if ((t_ret = txn->abort(txn)) != 0)
  65. ret = __db_panic(dbenv, t_ret);
  66. /*
  67.  * We created the DBP here and when we committed/aborted,
  68.  * we release all the tranasctional locks, which includes
  69.  * the handle lock; mark the handle cleared explicitly.
  70.  */
  71. LOCK_INIT(dbp->handle_lock);
  72. dbp->lid = DB_LOCK_INVALIDID;
  73. }
  74. /*
  75.  * We never opened this dbp for real, so don't call the transactional
  76.  * version of DB->close, and use NOSYNC to avoid calling into mpool.
  77.  */
  78. if ((t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
  79. ret = t_ret;
  80. return (ret);
  81. }
  82. /*
  83.  * __db_remove
  84.  * Remove method for DB.
  85.  *
  86.  * PUBLIC: int __db_remove __P((DB *, const char *, const char *, u_int32_t));
  87.  */
  88. int
  89. __db_remove(dbp, name, subdb, flags)
  90. DB *dbp;
  91. const char *name, *subdb;
  92. u_int32_t flags;
  93. {
  94. DB_ENV *dbenv;
  95. int ret, t_ret;
  96. dbenv = dbp->dbenv;
  97. PANIC_CHECK(dbenv);
  98. /*
  99.  * Validate arguments, continuing to destroy the handle on failure.
  100.  *
  101.  * Cannot use DB_ILLEGAL_AFTER_OPEN directly because it returns.
  102.  *
  103.  * !!!
  104.  * We have a serious problem if we're here with a handle used to open
  105.  * a database -- we'll destroy the handle, and the application won't
  106.  * ever be able to close the database.
  107.  */
  108. if (F_ISSET(dbp, DB_AM_OPEN_CALLED)) {
  109. ret = __db_mi_open(dbenv, "DB->remove", 1);
  110. goto err;
  111. }
  112. /* Validate arguments. */
  113. if ((ret = __db_fchk(dbenv, "DB->remove", flags, 0)) != 0)
  114. goto err;
  115. /* Check for consistent transaction usage. */
  116. if ((ret = __db_check_txn(dbp, NULL, DB_LOCK_INVALIDID, 0)) != 0)
  117. goto err;
  118. /* Remove the file. */
  119. ret = __db_remove_i(dbp, NULL, name, subdb);
  120. /*
  121.  * We never opened this dbp for real, use NOSYNC to avoid calling into
  122.  * mpool.
  123.  */
  124. err: if ((t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
  125. ret = t_ret;
  126. return (ret);
  127. }
  128. /*
  129.  * __db_remove_i
  130.  * Internal remove method for DB.
  131.  *
  132.  * PUBLIC: int __db_remove_i __P((DB *, DB_TXN *, const char *, const char *));
  133.  */
  134. int
  135. __db_remove_i(dbp, txn, name, subdb)
  136. DB *dbp;
  137. DB_TXN *txn;
  138. const char *name, *subdb;
  139. {
  140. DB_ENV *dbenv;
  141. DB_LSN newlsn;
  142. int ret;
  143. char *real_name;
  144. dbenv = dbp->dbenv;
  145. real_name = NULL;
  146. /* Handle subdatabase removes separately. */
  147. if (subdb != NULL)
  148. return (__db_subdb_remove(dbp, txn, name, subdb));
  149. /* Handle transactional file removes separately. */
  150. if (txn != NULL)
  151. return (__db_dbtxn_remove(dbp, txn, name));
  152. /*
  153.  * The remaining case is a non-transactional file remove.
  154.  *
  155.  * Find the real name of the file.
  156.  */
  157. if ((ret = __db_appname(dbenv,
  158.     DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
  159. return (ret);
  160. if ((ret = __fop_remove_setup(dbp, NULL, real_name, 0)) != 0)
  161. goto err;
  162. if (dbp->db_am_remove != NULL &&
  163.     (ret = dbp->db_am_remove(dbp, NULL, name, subdb, &newlsn)) != 0)
  164. goto err;
  165. ret = __fop_remove(dbenv, NULL, dbp->fileid, name, DB_APP_DATA);
  166. err:
  167. if (real_name != NULL)
  168. __os_free(dbenv, real_name);
  169. return (ret);
  170. }
  171. /*
  172.  * __db_subdb_remove --
  173.  * Remove a subdatabase.
  174.  */
  175. static int
  176. __db_subdb_remove(dbp, txn, name, subdb)
  177. DB *dbp;
  178. DB_TXN *txn;
  179. const char *name, *subdb;
  180. {
  181. DB *mdbp, *sdbp;
  182. int ret, t_ret;
  183. mdbp = sdbp = NULL;
  184. /* Open the subdatabase. */
  185. if ((ret = db_create(&sdbp, dbp->dbenv, 0)) != 0)
  186. goto err;
  187. if ((ret = __db_open(sdbp,
  188.     txn, name, subdb, DB_UNKNOWN, DB_WRITEOPEN, 0)) != 0)
  189. goto err;
  190. DB_TEST_RECOVERY(sdbp, DB_TEST_PREDESTROY, ret, name);
  191. /* Free up the pages in the subdatabase. */
  192. switch (sdbp->type) {
  193. case DB_BTREE:
  194. case DB_RECNO:
  195. if ((ret = __bam_reclaim(sdbp, txn)) != 0)
  196. goto err;
  197. break;
  198. case DB_HASH:
  199. if ((ret = __ham_reclaim(sdbp, txn)) != 0)
  200. goto err;
  201. break;
  202. default:
  203. ret = __db_unknown_type(
  204.     sdbp->dbenv, "__db_subdb_remove", sdbp->type);
  205. goto err;
  206. }
  207. /*
  208.  * Remove the entry from the main database and free the subdatabase
  209.  * metadata page.
  210.  */
  211. if ((ret = __db_master_open(sdbp, txn, name, 0, 0, &mdbp)) != 0)
  212. goto err;
  213. if ((ret = __db_master_update(
  214.     mdbp, sdbp, txn, subdb, sdbp->type, MU_REMOVE, NULL, 0)) != 0)
  215. goto err;
  216. DB_TEST_RECOVERY(sdbp, DB_TEST_POSTDESTROY, ret, name);
  217. DB_TEST_RECOVERY_LABEL
  218. err:
  219. /* Close the main and subdatabases. */
  220. if ((t_ret = __db_close_i(sdbp, txn, 0)) != 0 && ret == 0)
  221. ret = t_ret;
  222. if (mdbp != NULL &&
  223.     (t_ret = __db_close_i(mdbp, txn, 0)) != 0 && ret == 0)
  224. ret = t_ret;
  225. return (ret);
  226. }
  227. static int
  228. __db_dbtxn_remove(dbp, txn, name)
  229. DB *dbp;
  230. DB_TXN *txn;
  231. const char *name;
  232. {
  233. DB_ENV *dbenv;
  234. DB_LSN newlsn;
  235. int ret;
  236. char *tmpname;
  237. dbenv = dbp->dbenv;
  238. tmpname = NULL;
  239. /*
  240.  * This is a transactional rename, so we have to keep the name
  241.  * of the file locked until the transaction commits.  As a result,
  242.  * we implement remove by renaming the file to some other name
  243.  * (which creates a dummy named file as a placeholder for the
  244.  * file being rename/dremoved) and then deleting that file as
  245.  * a delayed remove at commit.
  246.  */
  247. if ((ret = __db_backup_name(dbenv, name, txn, &tmpname)) != 0)
  248. return (ret);
  249. DB_TEST_RECOVERY(dbp, DB_TEST_PREDESTROY, ret, name);
  250. if ((ret = __db_rename_i(dbp, txn, name, NULL, tmpname)) != 0)
  251. goto err;
  252. /* The internal removes will also translate into delayed removes. */
  253. if (dbp->db_am_remove != NULL &&
  254.     (ret = dbp->db_am_remove(dbp, txn, tmpname, NULL, &newlsn)) != 0)
  255. goto err;
  256. ret = __fop_remove(dbenv, txn, dbp->fileid, tmpname, DB_APP_DATA);
  257. DB_TEST_RECOVERY(dbp, DB_TEST_POSTDESTROY, ret, name);
  258. err:
  259. DB_TEST_RECOVERY_LABEL
  260. if (tmpname != NULL)
  261. __os_free(dbenv, tmpname);
  262. return (ret);
  263. }