db_rename.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_rename.c,v 11.203 2002/08/07 16:16:47 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc/db_shash.h"
  18. #include "dbinc/db_am.h"
  19. #include "dbinc/fop.h"
  20. #include "dbinc/lock.h"
  21. #include "dbinc/log.h"
  22. static int __db_subdb_rename __P(( DB *, DB_TXN *,
  23. const char *, const char *, const char *));
  24. /*
  25.  * __dbenv_dbrename
  26.  * Rename method for DB_ENV.
  27.  *
  28.  * PUBLIC: int __dbenv_dbrename __P((DB_ENV *, DB_TXN *,
  29.  * PUBLIC:     const char *, const char *, const char *, u_int32_t));
  30.  */
  31. int
  32. __dbenv_dbrename(dbenv, txn, name, subdb, newname, flags)
  33. DB_ENV *dbenv;
  34. DB_TXN *txn;
  35. const char *name, *subdb, *newname;
  36. u_int32_t flags;
  37. {
  38. DB *dbp;
  39. int ret, t_ret, txn_local;
  40. txn_local = 0;
  41. PANIC_CHECK(dbenv);
  42. ENV_ILLEGAL_BEFORE_OPEN(dbenv, "DB_ENV->dbrename");
  43. /* Validate arguments. */
  44. if ((ret = __db_fchk(dbenv, "DB->rename", flags, DB_AUTO_COMMIT)) != 0)
  45. return (ret);
  46. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  47. return (ret);
  48. /*
  49.  * Create local transaction as necessary, check for consistent
  50.  * transaction usage.
  51.  */
  52. if (IS_AUTO_COMMIT(dbenv, txn, flags)) {
  53. if ((ret = __db_txn_auto(dbp, &txn)) != 0)
  54. return (ret);
  55. txn_local = 1;
  56. } else
  57. if (txn != NULL && !TXN_ON(dbenv))
  58. return (__db_not_txn_env(dbenv));
  59. ret = __db_rename_i(dbp, txn, name, subdb, newname);
  60. /* Commit for DB_AUTO_COMMIT. */
  61. if (txn_local) {
  62. if (ret == 0)
  63. ret = txn->commit(txn, 0);
  64. else
  65. if ((t_ret = txn->abort(txn)) != 0)
  66. ret = __db_panic(dbenv, t_ret);
  67. /*
  68.  * We created the DBP here and when we committed/aborted,
  69.  * we release all the tranasctional locks, which includes
  70.  * the handle lock; mark the handle cleared explicitly.
  71.  */
  72. LOCK_INIT(dbp->handle_lock);
  73. dbp->lid = DB_LOCK_INVALIDID;
  74. }
  75. /*
  76.  * We never opened this dbp for real, so don't call the transactional
  77.  * version of DB->close, and use NOSYNC to avoid calling into mpool.
  78.  */
  79. if ((t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
  80. ret = t_ret;
  81. return (ret);
  82. }
  83. /*
  84.  * __db_rename
  85.  * Rename method for DB.
  86.  *
  87.  * PUBLIC: int __db_rename __P((DB *,
  88.  * PUBLIC:     const char *, const char *, const char *, u_int32_t));
  89.  */
  90. int
  91. __db_rename(dbp, name, subdb, newname, flags)
  92. DB *dbp;
  93. const char *name, *subdb, *newname;
  94. u_int32_t flags;
  95. {
  96. DB_ENV *dbenv;
  97. int ret, t_ret;
  98. dbenv = dbp->dbenv;
  99. PANIC_CHECK(dbenv);
  100. /*
  101.  * Validate arguments, continuing to destroy the handle on failure.
  102.  *
  103.  * Cannot use DB_ILLEGAL_AFTER_OPEN directly because it returns.
  104.  *
  105.  * !!!
  106.  * We have a serious problem if we're here with a handle used to open
  107.  * a database -- we'll destroy the handle, and the application won't
  108.  * ever be able to close the database.
  109.  */
  110. if (F_ISSET(dbp, DB_AM_OPEN_CALLED)) {
  111. ret = __db_mi_open(dbenv, "DB->rename", 1);
  112. goto err;
  113. }
  114. /* Validate arguments. */
  115. if ((ret = __db_fchk(dbenv, "DB->rename", flags, 0)) != 0)
  116. goto err;
  117. /* Check for consistent transaction usage. */
  118. if ((ret = __db_check_txn(dbp, NULL, DB_LOCK_INVALIDID, 0)) != 0)
  119. goto err;
  120. /* Rename the file. */
  121. ret = __db_rename_i(dbp, NULL, name, subdb, newname);
  122. /*
  123.  * We never opened this dbp for real, use NOSYNC to avoid calling into
  124.  * mpool.
  125.  */
  126. err: if ((t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
  127. ret = t_ret;
  128. return (ret);
  129. }
  130. /*
  131.  * __db_rename_i
  132.  * Internal rename method for DB.
  133.  *
  134.  * PUBLIC: int __db_rename_i __P((DB *,
  135.  * PUBLIC:      DB_TXN *, const char *, const char *, const char *));
  136.  */
  137. int
  138. __db_rename_i(dbp, txn, name, subdb, newname)
  139. DB *dbp;
  140. DB_TXN *txn;
  141. const char *name, *subdb, *newname;
  142. {
  143. DB_ENV *dbenv;
  144. int ret;
  145. char *real_name;
  146. dbenv = dbp->dbenv;
  147. real_name = NULL;
  148. DB_TEST_RECOVERY(dbp, DB_TEST_PREDESTROY, ret, name);
  149. if (subdb != NULL) {
  150. ret = __db_subdb_rename(dbp, txn, name, subdb, newname);
  151. goto err;
  152. }
  153. /* From here on down, this pertains to files. */
  154. /* Find the real name of the file. */
  155. if ((ret = __db_appname(dbenv,
  156.     DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
  157. goto err;
  158. if ((ret = __fop_remove_setup(dbp, txn, real_name, 0)) != 0)
  159. goto err;
  160. if (dbp->db_am_rename != NULL &&
  161.     (ret = dbp->db_am_rename(dbp, txn, name, subdb, newname)) != 0)
  162. goto err;
  163. /*
  164.  * The transactional case and non-transactional case are
  165.  * quite different.  In the non-transactional case, we simply
  166.  * do the rename.  In the transactional case, since we need
  167.  * the ability to back out and maintain locking, we have to
  168.  * create a temporary object as a placeholder.  This is all
  169.  * taken care of in the fop layer.
  170.  */
  171. if (txn != NULL) {
  172. if ((ret = __fop_dummy(dbp, txn, name, newname, 0)) != 0)
  173. goto err;
  174. } else {
  175. if ((ret = __fop_dbrename(dbp, name, newname)) != 0)
  176. goto err;
  177. }
  178. /*
  179.  * I am pretty sure that we haven't gotten a dbreg id, so calling
  180.  * dbreg_filelist_update is not necessary.
  181.  */
  182. DB_ASSERT(dbp->log_filename == NULL ||
  183.     dbp->log_filename->id == DB_LOGFILEID_INVALID);
  184. DB_TEST_RECOVERY(dbp, DB_TEST_POSTDESTROY, ret, newname);
  185. DB_TEST_RECOVERY_LABEL
  186. err:
  187. if (real_name != NULL)
  188. __os_free(dbenv, real_name);
  189. return (ret);
  190. }
  191. /*
  192.  * __db_subdb_rename --
  193.  * Rename a subdatabase.
  194.  */
  195. static int
  196. __db_subdb_rename(dbp, txn, name, subdb, newname)
  197. DB *dbp;
  198. DB_TXN *txn;
  199. const char *name, *subdb, *newname;
  200. {
  201. DB *mdbp;
  202. DB_ENV *dbenv;
  203. PAGE *meta;
  204. int ret, t_ret;
  205. mdbp = NULL;
  206. meta = NULL;
  207. dbenv = dbp->dbenv;
  208. /*
  209.  * We have not opened this dbp so it isn't marked as a subdb,
  210.  * but it ought to be.
  211.  */
  212. F_SET(dbp, DB_AM_SUBDB);
  213. /*
  214.  * Rename the entry in the main database.  We need to first
  215.  * get the meta-data page number (via MU_OPEN) so that we can
  216.  * read the meta-data page and obtain a handle lock.  Once we've
  217.  * done that, we can proceed to do the rename in the master.
  218.  */
  219. if ((ret = __db_master_open(dbp, txn, name, 0, 0, &mdbp)) != 0)
  220. goto err;
  221. if ((ret = __db_master_update(mdbp, dbp, txn, subdb, dbp->type,
  222.     MU_OPEN, NULL, 0)) != 0)
  223. goto err;
  224. if ((ret = mdbp->mpf->get(mdbp->mpf, &dbp->meta_pgno, 0, &meta)) != 0)
  225. goto err;
  226. memcpy(&dbp->fileid, ((DBMETA *)meta)->uid, DB_FILE_ID_LEN);
  227. if ((ret = __fop_lock_handle(dbenv,
  228.     dbp, mdbp->lid, DB_LOCK_WRITE, NULL, 0)) != 0)
  229. goto err;
  230. ret = mdbp->mpf->put(mdbp->mpf, meta, 0);
  231. meta = NULL;
  232. if (ret != 0)
  233. goto err;
  234. if ((ret = __db_master_update(mdbp, dbp, txn,
  235.     subdb, dbp->type, MU_RENAME, newname, 0)) != 0)
  236. goto err;
  237. DB_TEST_RECOVERY(dbp, DB_TEST_POSTDESTROY, ret, name);
  238. DB_TEST_RECOVERY_LABEL
  239. err:
  240. if (meta != NULL &&
  241.     (t_ret = mdbp->mpf->put(mdbp->mpf, meta, 0)) != 0 && ret == 0)
  242. ret = t_ret;
  243. if (mdbp != NULL &&
  244.     (t_ret = __db_close_i(mdbp, txn, 0)) != 0 && ret == 0)
  245. ret = t_ret;
  246. return (ret);
  247. }