开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
DBTable.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：12k
源码类别：

模拟服务器

开发平台：

C/C++

DBTable.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "DBTable.h"
  3. #ifndef WIN32
  4. #include <sys/stat.h>
  5. #else
  6. #include <direct.h>
  7. #endif
  8. #include <stdio.h>
  9. #include <string.h>
  11. ZDBTable::ZDBTable(const char *path, const char *name) {
  12. #ifdef WIN32
  13. getcwd(env_path, MAX_TABLE_NAME);
  14. #else
  15. #endif
  16. strcat(env_path, "\");
  17. strcat(env_path, path);
  18. #ifdef WIN32
  19. int ret = mkdir(env_path);
  20. #else
  21.         int ret = mkdir(env_path, 0);
  22. #endif
  23. dbcp = NULL;//初始化游标（by Fellow）
  25. if(!db_env_create(&dbenv, 0)) {
  26. dbenv->set_errpfx(dbenv, "index_db");
  27. if(!dbenv->open(dbenv, env_path, DB_CREATE | DB_INIT_LOG | DB_INIT_LOCK | DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER, 0)) {
  28. index_number = 0;
  29. strcpy(table_name, name);
  30. return; //成功了
  31. }
  32. dbenv->close(dbenv, 0);
  33. }
  34. dbenv = NULL;
  35. }
  37. ZDBTable::~ZDBTable() {
  38. if(dbenv) dbenv->close(dbenv, 0);
  39. }
  41. int ZDBTable::addIndex(GetIndexFunc func, bool isUnique) {
  42. if(!dbenv) return -1;
  43. if(index_number + 1 >= MAX_INDEX) return index_number;
  44. get_index_funcs[index_number] = func;
  45. is_index_unique[index_number] = isUnique;
  46. return index_number++;
  47. }
  49. bool ZDBTable::open() {
  50. if(!dbenv) return false;
  51. char index_table_name[MAX_TABLE_NAME];
  52.     int index;
  53. int ret;
  54. if(!db_create(&primary_db, dbenv, 0)) {
  55. if(!primary_db->open(primary_db, NULL, table_name, NULL, DB_BTREE, DB_CREATE|DB_AUTO_COMMIT, 0664)) { //打开主数据库
  56. for(index = 0; index < index_number; index++) {
  57. sprintf(index_table_name, "%s.%d", table_name, index);
  58. if(!db_create(&index_db[index], dbenv, 0)) {
  59. if(!is_index_unique[index]) {
  60. if(index_db[index]->set_flags(index_db[index], DB_DUP | DB_DUPSORT)) break;
  61. }
  62. if(index_db[index]->open(index_db[index], NULL, index_table_name, NULL, DB_BTREE, DB_CREATE|DB_AUTO_COMMIT, 0664)) break;
  63. if(ret = primary_db->associate(primary_db, NULL, index_db[index], get_index_funcs[index], DB_AUTO_COMMIT)) {
  64. index_db[index]->close(index_db[index], 0);
  65. break;
  66. }
  67. }
  68. else break;
  69. }
  70. if(index == index_number) return true; //成功了
  71. else while(--index) (index_db[index])->close(index_db[index], 0); //出错，关闭前面的索引表
  72. primary_db->close(primary_db, 0);
  73. }
  74. }
  75. return false;
  76. }
  78. void ZDBTable::close() {
  79. if(!dbenv) return;
  80. primary_db->close(primary_db, 0);
  81. for(int index = 0; index < index_number; index++) index_db[index]->close(index_db[index], 0);
  82. }
  84. bool ZDBTable::commit() {
  85. /* if(!dbenv) return false;
  86. int ret;
  87. DB_TXN *tid;
  88. if((ret = dbenv->txn_begin(dbenv, NULL, &tid, 0)) != 0) return false;
  89. if((ret = primary_db->sync(primary_db, 0)) == 0) {
  90. ret = tid->commit(tid, 0);
  91. if(!ret) return true;
  92. }
  93. else {
  94. tid->abort(tid);
  95. return false;
  96. }*/
  97. return true;
  98. }
  100. bool ZDBTable::add(const char *key_ptr, int key_size, const char *data_ptr, int data_size) {
  101. DBT data, key;
  102. memset(&key, 0, sizeof(DBT));
  103. memset(&data, 0, sizeof(DBT));
  104. key.data = (void *)key_ptr;
  105. key.size = key_size;
  106. data.data = (void *)data_ptr;
  107. data.size = data_size;
  109. if(!primary_db->put(primary_db, NULL, &key, &data, DB_AUTO_COMMIT)) {
  110. return true;
  111. }
  112. return false;
  113. }
  115. bool ZDBTable::remove(const char *key_ptr, int key_size, int index) {
  116. DBT data, key;
  117. memset(&key, 0, sizeof(DBT));
  118. memset(&data, 0, sizeof(DBT));
  119. key.data = (void *)key_ptr;
  120. key.size = key_size;
  121. if(!primary_db->del(primary_db, NULL, &key, DB_AUTO_COMMIT)) {
  122. return true;
  123. }
  124. return false;
  125. }
  127. char *ZDBTable::_search(bool bKey, const char *key_ptr, int key_size, int &size, int index) {
  128. dbcp = NULL;
  129. DBT key, data, pkey;
  130. if(index < -1 || index >= index_number) return NULL;
  131. memset(&key, 0, sizeof(key));
  132. memset(&data, 0, sizeof(data));
  133. memset(&pkey, 0, sizeof(pkey));
  134. key.data = (void *)key_ptr;
  135. key.size = key_size;
  136. if(index == -1) { //主键搜索
  137. if(primary_db->get(primary_db, NULL, &key, &data, 0)) return NULL;
  138. }
  139. else if(is_index_unique[index]) { //没有重复索引
  140. if(bKey) {
  141. if(index_db[index]->pget(index_db[index], NULL, &key, &pkey, &data, 0)) return NULL;
  142. }
  143. else {
  144. if(index_db[index]->get(index_db[index], NULL, &key, &data, 0)) return NULL;
  145. }
  146. }
  147. else { //打开游标
  148. if(index_db[index]->cursor(index_db[index], NULL, &dbcp, 0)) {
  149. dbcp = NULL;
  150. return NULL;
  151. }
  152. if(bKey) {
  153. if(dbcp->c_pget(dbcp, &key, &pkey, &data, DB_SET)) {
  154. dbcp->c_close(dbcp);
  155. dbcp = NULL;
  156. return NULL;
  157. }
  158. }
  159. else {
  160. if(dbcp->c_get(dbcp, &key, &data, DB_SET)) {
  161. dbcp->c_close(dbcp);
  162. dbcp = NULL;
  163. return NULL;
  164. }
  165. }
  167. }
  168. char *result;
  169. if(bKey) {
  170. result = new char[pkey.size];
  171. memmove(result, pkey.data, pkey.size);
  172. size = pkey.size;
  173. }
  174. else {
  175. result = new char[data.size];
  176. memmove(result, data.data, data.size);
  177. size = data.size;
  178. }
  179. return result;
  180. }
  182. char *ZDBTable::_next(bool bKey, int &size) {
  183. if(!dbcp) return NULL;
  184. DBT key, data, pkey;
  185. memset(&key, 0, sizeof(key));
  186. memset(&data, 0, sizeof(data));
  187. memset(&pkey, 0, sizeof(pkey));
  188. if(bKey) {
  189. if(dbcp->c_pget(dbcp, &key, &pkey, &data, DB_NEXT_DUP)) {
  190. dbcp->c_close(dbcp);
  191. dbcp = NULL;
  192. return NULL;
  193. }
  194. }
  195. else {
  196. if(dbcp->c_get(dbcp, &key, &data, DB_NEXT_DUP)) {
  197. dbcp->c_close(dbcp);
  198. dbcp = NULL;
  199. return NULL;
  200. }
  201. }
  202. char *result;
  203. if(bKey) {
  204. result = new char[pkey.size];
  205. memmove(result, pkey.data, pkey.size);
  206. size = pkey.size;
  207. }
  208. else {
  209. result = new char[data.size];
  210. memmove(result, data.data, data.size);
  211. size = data.size;
  212. }
  213. return result;
  214. }
  216. char *ZDBTable::GetRecord(int &size, CursorPointer cpMode, int index )
  217. {//取得按游标某一个数据
  218. if(!dbcp)
  219. {//如果数据库指针没有初始化，先初始化dbcp
  220. if(index_db[index]->cursor(index_db[index], NULL, &dbcp, 0))
  221. {//初始化dbcp失败
  222. dbcp = NULL;
  223. return NULL;
  224. }
  225. }
  226. DBT key, data, pkey;
  227. memset(&key, 0, sizeof(key));
  228. memset(&data, 0, sizeof(data));
  229. memset(&pkey, 0, sizeof(pkey));
  231. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  232. dbcp->c_close(dbcp);
  233. dbcp = NULL;
  234. return NULL;
  235. }
  237. char *result;
  238. result = new char[data.size];
  239. memmove(result, data.data, data.size);
  240. size = data.size;
  242. return result;
  243. }
  246. char *ZDBTable::GetRecord_key(int &size, CursorPointer cpMode, int index )
  247. {
  248. if(!dbcp)
  249. {//如果数据库指针没有初始化，先初始化dbcp
  250. if(index_db[index]->cursor(index_db[index], NULL, &dbcp, 0))
  251. {//初始化dbcp失败
  252. dbcp = NULL;
  253. return NULL;
  254. }
  255. }
  256. DBT key, data, pkey;
  257. memset(&key, 0, sizeof(key));
  258. memset(&data, 0, sizeof(data));
  259. memset(&pkey, 0, sizeof(pkey));
  261. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  262. dbcp->c_close(dbcp);
  263. dbcp = NULL;
  264. return NULL;
  265. }
  267. char *result;
  268. result = new char[key.size];
  269. memmove(result, key.data, key.size);
  270. size = key.size;
  272. return result;
  273. }
  275. bool ZDBTable::GetRecordEx(char* aBuffer, int &size,
  276.    char* aKeyBuffer, int &keysize,
  277.    CursorPointer cpMode, int index)
  278. {//取得按游标某一个数据(新版函数)
  279. if(!dbcp)
  280. {//如果数据库指针没有初始化，先初始化dbcp
  281. if(index_db[index]->cursor(index_db[index], NULL, &dbcp, 0))
  282. {//初始化dbcp失败
  283. dbcp = NULL;
  284. return false;
  285. }
  286. }
  287. DBT key, data, pkey;
  288. memset(&key, 0, sizeof(key));
  289. memset(&data, 0, sizeof(data));
  290. memset(&pkey, 0, sizeof(pkey));
  292. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  293. dbcp->c_close(dbcp);
  294. dbcp = NULL;
  295. return false;
  296. }
  298. memmove(aBuffer, data.data, data.size);
  299. size = data.size;
  301. memmove(aKeyBuffer, key.data, key.size);
  302. keysize = key.size;
  304. return true;
  305. }
  307. CDBTableReadOnly::CDBTableReadOnly(const char *path, const char *name) {
  308. #ifdef WIN32
  309. getcwd(env_path, MAX_TABLE_NAME);
  310. #else
  311. #endif
  312. strcat(env_path, "\");
  313. strcat(env_path, path);
  314. #ifdef WIN32
  315. int ret = mkdir(env_path);
  316. #else
  317.         int ret = mkdir(env_path, 0);
  318. #endif
  319. dbcp = NULL;//初始化游标（by Fellow）
  321. if(!db_env_create(&dbenv, 0)) {
  322. dbenv->set_errpfx(dbenv, "index_db");
  323. if(!dbenv->open(dbenv, env_path, DB_USE_ENVIRON | DB_INIT_MPOOL, 0)) {
  324. strcpy(table_name, name);
  325. return; //成功了
  326. }
  327. dbenv->close(dbenv, 0);
  328. }
  329. dbenv = NULL;
  330. }
  332. CDBTableReadOnly::~CDBTableReadOnly() {
  333. if(dbenv) dbenv->close(dbenv, 0);
  334. }
  336. bool CDBTableReadOnly::open() {
  337. if(!dbenv) return false;
  338. if(!db_create(&primary_db, dbenv, 0)) {
  339. if(!primary_db->open(primary_db, NULL, table_name, NULL, DB_BTREE, DB_RDONLY, 0664)) { //打开主数据库
  340. return true;
  341. }
  342. }
  343. return false;
  344. }
  346. void CDBTableReadOnly::close() {
  347. if(!dbenv) return;
  348. primary_db->close(primary_db, 0);
  349. }
  351. char *CDBTableReadOnly::_search(bool bKey, const char *key_ptr, int key_size, int &size) {
  352. dbcp = NULL;
  353. DBT key, data, pkey;
  354. memset(&key, 0, sizeof(key));
  355. memset(&data, 0, sizeof(data));
  356. memset(&pkey, 0, sizeof(pkey));
  357. key.data = (void *)key_ptr;
  358. key.size = key_size;
  359. if(primary_db->get(primary_db, NULL, &key, &data, 0)) return NULL;
  361. char *result;
  362. if(bKey) {
  363. result = new char[pkey.size];
  364. memmove(result, pkey.data, pkey.size);
  365. size = pkey.size;
  366. }
  367. else {
  368. result = new char[data.size];
  369. memmove(result, data.data, data.size);
  370. size = data.size;
  371. }
  372. return result;
  373. }
  375. char *CDBTableReadOnly::_next(bool bKey, int &size) {
  376. if(!dbcp) return NULL;
  377. DBT key, data, pkey;
  378. memset(&key, 0, sizeof(key));
  379. memset(&data, 0, sizeof(data));
  380. memset(&pkey, 0, sizeof(pkey));
  381. if(bKey) {
  382. if(dbcp->c_pget(dbcp, &key, &pkey, &data, DB_NEXT_DUP)) {
  383. dbcp->c_close(dbcp);
  384. dbcp = NULL;
  385. return NULL;
  386. }
  387. }
  388. else {
  389. if(dbcp->c_get(dbcp, &key, &data, DB_NEXT_DUP)) {
  390. dbcp->c_close(dbcp);
  391. dbcp = NULL;
  392. return NULL;
  393. }
  394. }
  395. char *result;
  396. if(bKey) {
  397. result = new char[pkey.size];
  398. memmove(result, pkey.data, pkey.size);
  399. size = pkey.size;
  400. }
  401. else {
  402. result = new char[data.size];
  403. memmove(result, data.data, data.size);
  404. size = data.size;
  405. }
  406. return result;
  407. }
  409. char *CDBTableReadOnly::GetRecord(int &size, CursorPointer cpMode)
  410. {
  411. if(!dbcp)
  412. {//如果数据库指针没有初始化，先初始化dbcp
  413. if(primary_db->cursor(primary_db, NULL, &dbcp, 0))
  414. {//初始化dbcp失败
  415. dbcp = NULL;
  416. return NULL;
  417. }
  418. }
  419. DBT key, data, pkey;
  420. memset(&key, 0, sizeof(key));
  421. memset(&data, 0, sizeof(data));
  422. memset(&pkey, 0, sizeof(pkey));
  424. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  425. dbcp->c_close(dbcp);
  426. dbcp = NULL;
  427. return NULL;
  428. }
  430. char *result;
  431. result = new char[data.size];
  432. memmove(result, data.data, data.size);
  433. size = data.size;
  435. return result;
  436. }
  438. char *CDBTableReadOnly::GetRecord_key(int &size, CursorPointer cpMode)
  439. {
  440. if(!dbcp)
  441. {//如果数据库指针没有初始化，先初始化dbcp
  442. if(primary_db->cursor(primary_db, NULL, &dbcp, 0))
  443. {//初始化dbcp失败
  444. dbcp = NULL;
  445. return NULL;
  446. }
  447. }
  448. DBT key, data, pkey;
  449. memset(&key, 0, sizeof(key));
  450. memset(&data, 0, sizeof(data));
  451. memset(&pkey, 0, sizeof(pkey));
  453. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  454. dbcp->c_close(dbcp);
  455. dbcp = NULL;
  456. return NULL;
  457. }
  459. char *result;
  460. result = new char[key.size];
  461. memmove(result, key.data, key.size);
  462. size = key.size;
  464. return result;
  465. }
  467. bool CDBTableReadOnly::GetRecordEx(char* aBuffer, int &size,
  468.    char* aKeyBuffer, int &keysize,
  469.    CursorPointer cpMode)
  470. {//取得按游标某一个数据(新版函数)
  471. if(!dbcp)
  472. {//如果数据库指针没有初始化，先初始化dbcp
  473. if(primary_db->cursor(primary_db, NULL, &dbcp, 0))
  474. {//初始化dbcp失败
  475. dbcp = NULL;
  476. return false;
  477. }
  478. }
  479. DBT key, data, pkey;
  480. memset(&key, 0, sizeof(key));
  481. memset(&data, 0, sizeof(data));
  482. memset(&pkey, 0, sizeof(pkey));
  484. if(dbcp->c_get(dbcp, &key, &data, cpMode)) {
  485. dbcp->c_close(dbcp);
  486. dbcp = NULL;
  487. return false;
  488. }
  490. memmove(aBuffer, data.data, data.size);
  491. size = data.size;
  493. memmove(aKeyBuffer, key.data, key.size);
  494. keysize = key.size;
  496. return true;
  497. }