← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/blitzdb/blitzindex.cc

  • Committer: Olaf van der Spek
  • Date: 2011-02-12 18:24:24 UTC
  • mto: (2167.1.2 build) (2172.1.4 build)
  • mto: This revision was merged to the branch mainline in revision 2168.
  • Revision ID: olafvdspek@gmail.com-20110212182424-kgnm9osi7qo97at2
casts

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/blitzdb/blitzindex.cc
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2009 - 2010 Toru Maesaka
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include "config.h"
 
21
#include "ha_blitz.h"
 
22
 
 
23
/* Unlike the data dictionary, don't tune the btree by default
 
24
   since the default configuration satisfies BlitzDB's default
 
25
   performance requirements. Tuning parameters will be made dynamic
 
26
   in the upcoming releases. */
 
27
int BlitzTree::open(const char *path, const int key_num, int mode) {
 
28
  char buf[FN_REFLEN];
 
29
 
 
30
  if ((btree = tcbdbnew()) == NULL)
 
31
    return drizzled::HA_ERR_OUT_OF_MEM;
 
32
 
 
33
  if (!tcbdbsetmutex(btree)) {
 
34
    tcbdbdel(btree);
 
35
    return drizzled::HA_ERR_GENERIC;
 
36
  }
 
37
 
 
38
  if (blitz_estimated_rows != 0) {
 
39
    uint64_t tree_buckets = blitz_estimated_rows / 10;
 
40
    if (!tcbdbtune(btree, 0, 0, tree_buckets, -1, -1, 0)) {
 
41
      tcbdbdel(btree);
 
42
      return drizzled::HA_ERR_GENERIC;
 
43
    }
 
44
  }
 
45
 
 
46
  if (!tcbdbsetcmpfunc(btree, blitz_keycmp_cb, this)) {
 
47
    tcbdbdel(btree);
 
48
    return drizzled::HA_ERR_GENERIC;
 
49
  }
 
50
 
 
51
  snprintf(buf, FN_REFLEN, "%s_%02d%s", path, key_num, BLITZ_INDEX_EXT);
 
52
 
 
53
  if (!tcbdbopen(btree, buf, mode)) {
 
54
    tcbdbdel(btree);
 
55
    return drizzled::HA_ERR_CRASHED_ON_USAGE;
 
56
  }
 
57
 
 
58
  return 0;
 
59
}
 
60
 
 
61
/* Similar to UNIX touch(1) but generates a TCBDB file. */
 
62
int BlitzTree::create(const char *path, const int key_num) {
 
63
  int rv;
 
64
 
 
65
  if ((rv = this->open(path, key_num, (BDBOWRITER | BDBOCREAT))) != 0)
 
66
    return rv;
 
67
 
 
68
  if ((rv = this->close()) != 0)
 
69
    return rv;
 
70
 
 
71
  return rv;
 
72
}
 
73
 
 
74
int BlitzTree::drop(const char *path, const int key_num) {
 
75
  char buf[FN_REFLEN];
 
76
  snprintf(buf, FN_REFLEN, "%s_%02d%s", path, key_num, BLITZ_INDEX_EXT);
 
77
  return unlink(buf);
 
78
}
 
79
 
 
80
int BlitzTree::rename(const char *from, const char *to, const int key_num) {
 
81
  char from_buf[FN_REFLEN];
 
82
  char to_buf[FN_REFLEN];
 
83
 
 
84
  snprintf(from_buf, FN_REFLEN, "%s_%02d%s", from, key_num, BLITZ_INDEX_EXT);
 
85
  snprintf(to_buf, FN_REFLEN, "%s_%02d%s", to, key_num, BLITZ_INDEX_EXT);
 
86
 
 
87
  return drizzled::internal::my_rename(from_buf, to_buf, MYF(0));
 
88
}
 
89
 
 
90
int BlitzTree::close(void) {
 
91
  assert(btree);
 
92
 
 
93
  if (!tcbdbclose(btree)) {
 
94
    tcbdbdel(btree);
 
95
    return drizzled::HA_ERR_CRASHED_ON_USAGE;
 
96
  }
 
97
 
 
98
  tcbdbdel(btree);
 
99
  return 0;
 
100
}
 
101
 
 
102
bool BlitzTree::create_cursor(BlitzCursor *bc) {
 
103
  if (bc == NULL)
 
104
    return false;
 
105
 
 
106
  if ((bc->cursor = tcbdbcurnew(btree)) == NULL)
 
107
    return false;
 
108
 
 
109
  bc->tree = this;
 
110
  bc->active = true;
 
111
  bc->moved = false;
 
112
  return true;
 
113
}
 
114
 
 
115
void BlitzTree::destroy_cursor(BlitzCursor *bc) {
 
116
  if (bc == NULL)
 
117
    return;
 
118
 
 
119
  tcbdbcurdel(bc->cursor);
 
120
  return;
 
121
}
 
122
 
 
123
int BlitzTree::write(const char *key, const size_t klen) {
 
124
  return (tcbdbputdup(btree, key, klen, "", 0)) ? 0 : -1;
 
125
}
 
126
 
 
127
int BlitzTree::write_unique(const char *key, const size_t klen) {
 
128
  if (!tcbdbputkeep(btree, key, klen, "", 0)) {
 
129
    if (tcbdbecode(btree) == TCEKEEP) {
 
130
      errno = drizzled::HA_ERR_FOUND_DUPP_KEY;
 
131
      return drizzled::HA_ERR_FOUND_DUPP_KEY;
 
132
    }
 
133
  }
 
134
  return 0;
 
135
}
 
136
 
 
137
int BlitzTree::delete_key(const char *key, const int klen) {
 
138
  return (tcbdbout(btree, key, klen)) ? 0 : -1;
 
139
}
 
140
 
 
141
int BlitzTree::delete_all(void) {
 
142
  return (tcbdbvanish(btree)) ? 0 : -1;
 
143
}
 
144
 
 
145
uint64_t BlitzTree::records(void) {
 
146
  return tcbdbrnum(btree);
 
147
}