Skip to content

Commit 859c4f2

Browse files
guycipherguycipher
authored
Merge pull request #14 from tidesdb/better_error_handling
better error handling implementation
2 parents 764a5e3 + 011113f commit 859c4f2

File tree

3 files changed

+172
-35
lines changed

3 files changed

+172
-35
lines changed

‎test/tests.cpp

Lines changed: 25 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -34,30 +34,33 @@ TEST(TidesDB, Open_and_Close)
3434
TidesDB::DB db;
3535
EXPECT_EQ(db.Open("tmp"), 0);
3636
EXPECT_EQ(db.Close(), 0);
37+
_tidesdb_remove_directory("tmp");
3738
}
3839
TEST(TidesDB, Create_and_Drop_Column_Family)
3940
{
4041
TidesDB::DB db;
4142
EXPECT_EQ(db.Open("tmp"), 0);
4243
EXPECT_EQ(db.CreateColumnFamily(column_name, flush_threshold, max_level, probability,
43-
bloom_filter, compression_algo, compressed, memtable_ds),
44+
compressed, compression_algo, bloom_filter, memtable_ds),
4445
0);
4546
EXPECT_EQ(db.DropColumnFamily(column_name), 0);
4647
EXPECT_EQ(db.Close(), 0);
48+
_tidesdb_remove_directory("tmp");
4749
}
4850

4951
TEST(TidesDB, Create_and_Column_Family_and_Put)
5052
{
5153
TidesDB::DB db;
5254
EXPECT_EQ(db.Open("tmp"), 0);
5355
EXPECT_EQ(db.CreateColumnFamily(column_name, flush_threshold, max_level, probability,
54-
bloom_filter, compression_algo, compressed, memtable_ds),
56+
compressed, compression_algo, bloom_filter, memtable_ds),
5557
0);
5658
const std::vector<uint8_t> key = {'k', 'e', 'y'};
5759
const std::vector<uint8_t> value = {'v', 'a', 'l', 'u', 'e'};
5860
EXPECT_EQ(db.Put(column_name, &key, &value, std::chrono::seconds(-1)), 0);
5961
EXPECT_EQ(db.DropColumnFamily(column_name), 0);
6062
EXPECT_EQ(db.Close(), 0);
63+
_tidesdb_remove_directory("tmp");
6164
}
6265

6366
TEST(TidesDB, Put_and_Get)
@@ -66,7 +69,7 @@ TEST(TidesDB, Put_and_Get)
6669
std::vector<uint8_t> got_value;
6770
EXPECT_EQ(db.Open("tmp"), 0);
6871
EXPECT_EQ(db.CreateColumnFamily(column_name, flush_threshold, max_level, probability,
69-
bloom_filter, compression_algo, compressed, memtable_ds),
72+
compressed, compression_algo, bloom_filter, memtable_ds),
7073
0);
7174

7275
const std::vector<uint8_t> key = {'k', 'e', 'y'};
@@ -77,21 +80,38 @@ TEST(TidesDB, Put_and_Get)
7780
std::string(value.begin(), value.end()));
7881
EXPECT_EQ(db.DropColumnFamily(column_name), 0);
7982
EXPECT_EQ(db.Close(), 0);
83+
_tidesdb_remove_directory("tmp");
8084
}
8185

8286
TEST(TidesDB, Put_and_Delete)
8387
{
8488
TidesDB::DB db;
8589
std::vector<uint8_t> got_value;
90+
8691
EXPECT_EQ(db.Open("tmp"), 0);
8792
EXPECT_EQ(db.CreateColumnFamily(column_name, flush_threshold, max_level, probability,
88-
bloom_filter, compression_algo, compressed, memtable_ds),
93+
compressed, compression_algo, true, memtable_ds),
8994
0);
9095
const std::vector<uint8_t> key = {'k', 'e', 'y'};
9196
const std::vector<uint8_t> value = {'v', 'a', 'l', 'u', 'e'};
9297
EXPECT_EQ(db.Put(column_name, &key, &value, std::chrono::seconds(-1)), 0);
9398
EXPECT_EQ(db.Delete(column_name, &key), 0);
94-
EXPECT_NE(db.Get(column_name, &key, &got_value), 0);
99+
100+
try
101+
{
102+
db.Get(column_name, &key, &got_value);
103+
FAIL() << "Expected std::runtime_error";
104+
}
105+
catch (const std::runtime_error& e)
106+
{
107+
EXPECT_STREQ(e.what(), "Error 22: Key not found.\n");
108+
}
109+
catch (...)
110+
{
111+
FAIL() << "Expected std::runtime_error";
112+
}
113+
95114
EXPECT_EQ(db.DropColumnFamily(column_name), 0);
96115
EXPECT_EQ(db.Close(), 0);
116+
_tidesdb_remove_directory("tmp");
97117
}

‎tidesdb.cpp

Lines changed: 144 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -18,16 +18,6 @@
1818
*/
1919
#include "tidesdb.hpp"
2020

21-
#define ERR_HANDLER() \
22-
if (err) \
23-
{ \
24-
std::cout << err->message << std::endl; \
25-
int err_code = err->code; \
26-
tidesdb_err_free(err); \
27-
return err_code; \
28-
} \
29-
return 0;
30-
3121
namespace TidesDB
3222
{
3323

@@ -39,13 +29,27 @@ DB::DB(void)
3929
int DB::Open(const std::string &dir_name)
4030
{
4131
tidesdb_err_t *err = tidesdb_open(dir_name.c_str(), &this->tdb);
42-
ERR_HANDLER()
32+
if (err)
33+
{
34+
std::string error_message = err->message;
35+
int error_code = err->code;
36+
tidesdb_err_free(err);
37+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
38+
}
39+
return 0;
4340
}
4441

4542
int DB::Close() const
4643
{
4744
tidesdb_err_t *err = tidesdb_close(this->tdb);
48-
ERR_HANDLER()
45+
if (err)
46+
{
47+
std::string error_message = err->message;
48+
int error_code = err->code;
49+
tidesdb_err_free(err);
50+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
51+
}
52+
return 0;
4953
}
5054

5155
int DB::CreateColumnFamily(const std::string &column_family_name, int flush_threshold,
@@ -56,13 +60,27 @@ int DB::CreateColumnFamily(const std::string &column_family_name, int flush_thre
5660
tidesdb_err_t *err = tidesdb_create_column_family(
5761
this->tdb, column_family_name.c_str(), flush_threshold, max_level, probability, compressed,
5862
compress_algo, bloom_filter, memtable_ds);
59-
ERR_HANDLER()
63+
if (err)
64+
{
65+
std::string error_message = err->message;
66+
int error_code = err->code;
67+
tidesdb_err_free(err);
68+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
69+
}
70+
return 0;
6071
}
6172

6273
int DB::DropColumnFamily(const std::string &column_family_name) const
6374
{
6475
tidesdb_err_t *err = tidesdb_drop_column_family(this->tdb, column_family_name.c_str());
65-
ERR_HANDLER()
76+
if (err)
77+
{
78+
std::string error_message = err->message;
79+
int error_code = err->code;
80+
tidesdb_err_free(err);
81+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
82+
}
83+
return 0;
6684
}
6785

6886
int DB::Put(const std::string &column_family_name, const std::vector<uint8_t> *key,
@@ -73,7 +91,14 @@ int DB::Put(const std::string &column_family_name, const std::vector<uint8_t> *k
7391
time_t ttl_time = ttl.count();
7492
tidesdb_err_t *err = tidesdb_put(this->tdb, column_family_name.c_str(), key->data(), key_size,
7593
value->data(), value_size, ttl_time);
76-
ERR_HANDLER()
94+
if (err)
95+
{
96+
std::string error_message = err->message;
97+
int error_code = err->code;
98+
tidesdb_err_free(err);
99+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
100+
}
101+
return 0;
77102
}
78103

79104
int DB::Get(const std::string &column_family_name, const std::vector<uint8_t> *key,
@@ -89,22 +114,43 @@ int DB::Get(const std::string &column_family_name, const std::vector<uint8_t> *k
89114
value->assign(value_data, value_data + value_size);
90115
free(value_data);
91116
}
92-
ERR_HANDLER()
117+
if (err)
118+
{
119+
std::string error_message = err->message;
120+
int error_code = err->code;
121+
tidesdb_err_free(err);
122+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
123+
}
124+
return 0;
93125
}
94126

95127
int DB::Delete(const std::string &column_family_name, const std::vector<uint8_t> *key) const
96128
{
97129
size_t key_size = key->size();
98130
tidesdb_err_t *err =
99131
tidesdb_delete(this->tdb, column_family_name.c_str(), key->data(), key_size);
100-
ERR_HANDLER()
132+
if (err)
133+
{
134+
std::string error_message = err->message;
135+
int error_code = err->code;
136+
tidesdb_err_free(err);
137+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
138+
}
139+
return 0;
101140
}
102141

103142
int DB::CompactSSTables(const std::string &column_family_name, int max_threads) const
104143
{
105144
tidesdb_err_t *err =
106145
tidesdb_compact_sstables(this->tdb, column_family_name.c_str(), max_threads);
107-
ERR_HANDLER()
146+
if (err)
147+
{
148+
std::string error_message = err->message;
149+
int error_code = err->code;
150+
tidesdb_err_free(err);
151+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
152+
}
153+
return 0;
108154
}
109155

110156
int DB::StartBackgroundPartialMerges(const std::string &column_family_name,
@@ -118,7 +164,14 @@ int DB::StartBackgroundPartialMerges(const std::string &column_family_name,
118164

119165
tidesdb_err_t *err = tidesdb_start_background_partial_merge(
120166
this->tdb, column_family_name.c_str(), static_cast<int>(duration), min_sstables);
121-
ERR_HANDLER()
167+
if (err)
168+
{
169+
std::string error_message = err->message;
170+
int error_code = err->code;
171+
tidesdb_err_free(err);
172+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
173+
}
174+
return 0;
122175
}
123176

124177
Txn::Txn(DB *db)
@@ -138,7 +191,14 @@ Txn::~Txn()
138191
int Txn::Begin()
139192
{
140193
tidesdb_err_t *err = tidesdb_txn_begin(this->tdb, &this->txn, nullptr);
141-
ERR_HANDLER()
194+
if (err)
195+
{
196+
std::string error_message = err->message;
197+
int error_code = err->code;
198+
tidesdb_err_free(err);
199+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
200+
}
201+
return 0;
142202
}
143203

144204
int Txn::Put(const std::vector<uint8_t> *key, const std::vector<uint8_t> *value,
@@ -147,25 +207,53 @@ int Txn::Put(const std::vector<uint8_t> *key, const std::vector<uint8_t> *value,
147207
auto ttl_time = std::chrono::duration_cast<std::chrono::seconds>(ttl).count();
148208
tidesdb_err_t *err = tidesdb_txn_put(this->txn, key->data(), size_t(key->size()), value->data(),
149209
size_t(value->size()), ttl_time);
150-
ERR_HANDLER()
210+
if (err)
211+
{
212+
std::string error_message = err->message;
213+
int error_code = err->code;
214+
tidesdb_err_free(err);
215+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
216+
}
217+
return 0;
151218
}
152219

153220
int Txn::Delete(const std::vector<uint8_t> *key) const
154221
{
155222
tidesdb_err_t *err = tidesdb_txn_delete(this->txn, key->data(), size_t(key->size()));
156-
ERR_HANDLER()
223+
if (err)
224+
{
225+
std::string error_message = err->message;
226+
int error_code = err->code;
227+
tidesdb_err_free(err);
228+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
229+
}
230+
return 0;
157231
}
158232

159233
int Txn::Commit() const
160234
{
161235
tidesdb_err_t *err = tidesdb_txn_commit(this->txn);
162-
ERR_HANDLER()
236+
if (err)
237+
{
238+
std::string error_message = err->message;
239+
int error_code = err->code;
240+
tidesdb_err_free(err);
241+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
242+
}
243+
return 0;
163244
}
164245

165246
int Txn::Rollback() const
166247
{
167248
tidesdb_err_t *err = tidesdb_txn_rollback(this->txn);
168-
ERR_HANDLER()
249+
if (err)
250+
{
251+
std::string error_message = err->message;
252+
int error_code = err->code;
253+
tidesdb_err_free(err);
254+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
255+
}
256+
return 0;
169257
}
170258

171259
Cursor::Cursor(DB *db, std::string column_family_name)
@@ -178,7 +266,14 @@ Cursor::Cursor(DB *db, std::string column_family_name)
178266
int Cursor::Init()
179267
{
180268
tidesdb_err_t *err = tidesdb_cursor_init(tdb, this->column_family_name.c_str(), &this->cursor);
181-
ERR_HANDLER()
269+
if (err)
270+
{
271+
std::string error_message = err->message;
272+
int error_code = err->code;
273+
tidesdb_err_free(err);
274+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
275+
}
276+
return 0;
182277
}
183278

184279
Cursor::~Cursor()
@@ -193,13 +288,27 @@ Cursor::~Cursor()
193288
int Cursor::Next() const
194289
{
195290
tidesdb_err_t *err = tidesdb_cursor_next(this->cursor);
196-
ERR_HANDLER()
291+
if (err)
292+
{
293+
std::string error_message = err->message;
294+
int error_code = err->code;
295+
tidesdb_err_free(err);
296+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
297+
}
298+
return 0;
197299
}
198300

199301
int Cursor::Prev() const
200302
{
201303
tidesdb_err_t *err = tidesdb_cursor_prev(this->cursor);
202-
ERR_HANDLER()
304+
if (err)
305+
{
306+
std::string error_message = err->message;
307+
int error_code = err->code;
308+
tidesdb_err_free(err);
309+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
310+
}
311+
return 0;
203312
}
204313

205314
int Cursor::Get(std::vector<uint8_t> &key, std::vector<uint8_t> &value)
@@ -210,7 +319,14 @@ int Cursor::Get(std::vector<uint8_t> &key, std::vector<uint8_t> &value)
210319
uint8_t *value_data = value.data();
211320
tidesdb_err_t *err =
212321
tidesdb_cursor_get(this->cursor, &key_data, &key_size, &value_data, &value_size);
213-
ERR_HANDLER()
322+
if (err)
323+
{
324+
std::string error_message = err->message;
325+
int error_code = err->code;
326+
tidesdb_err_free(err);
327+
throw std::runtime_error("Error " + std::to_string(error_code) + ": " + error_message);
328+
}
329+
return 0;
214330
}
215331

216332
tidesdb_t *DB::GetTidesDB() const

‎tidesdb.hpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,11 +18,12 @@
1818
*/
1919

2020
#pragma once
21+
#include <tidesdb/tidesdb.h>
22+
23+
#include <chrono>
2124
#include <iostream>
2225
#include <utility>
23-
#include <chrono>
2426
#include <vector>
25-
#include <tidesdb/tidesdb.h>
2627

2728
/*
2829
* TidesDB Namespace

0 commit comments

Comments
 (0)