summaryrefslogtreecommitdiff
path: root/platform/default/sqlite3.hpp
blob: 82e3ceff6dd2b7600a7ab16678fe6fd7c87e9e16 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#pragma once

#include <string>
#include <vector>
#include <stdexcept>
#include <chrono>
#include <memory>

namespace mapbox {
namespace sqlite {

enum OpenFlag : int {
    ReadOnly = 0x00000001,
    ReadWrite = 0x00000002,
    Create = 0x00000004,
    NoMutex = 0x00008000,
    FullMutex = 0x00010000,
    SharedCache = 0x00020000,
    PrivateCache = 0x00040000,
};

struct Exception : std::runtime_error {
    enum Code : int {
        OK = 0,
        CANTOPEN = 14,
        NOTADB = 26
    };

    Exception(int err, const char *msg) : std::runtime_error(msg), code(err) {}
    Exception(int err, const std::string& msg) : std::runtime_error(msg), code(err) {}
    const int code = OK;
};

class DatabaseImpl;
class Statement;
class StatementImpl;

class Database {
private:
    Database(const Database &) = delete;
    Database &operator=(const Database &) = delete;

public:
    Database(const std::string &filename, int flags = 0);
    Database(Database &&);
    ~Database();
    Database &operator=(Database &&);

    void setBusyTimeout(std::chrono::milliseconds);
    void exec(const std::string &sql);
    Statement prepare(const char *query);

private:
    std::unique_ptr<DatabaseImpl> impl;

    friend class Statement;
};

class Statement {
private:
    Statement(const Statement &) = delete;
    Statement &operator=(const Statement &) = delete;

public:
    Statement(Database *db, const char *sql);
    Statement(Statement &&);
    ~Statement();
    Statement &operator=(Statement &&);

    template <typename T> void bind(int offset, T value);

    // Text
    void bind(int offset, const char *, std::size_t length, bool retain = true);
    void bind(int offset, const std::string&, bool retain = true);

    // Blob
    void bindBlob(int offset, const void *, std::size_t length, bool retain = true);
    void bindBlob(int offset, const std::vector<uint8_t>&, bool retain = true);

    template <typename T> T get(int offset);

    bool run();
    void reset();
    void clearBindings();

    int64_t lastInsertRowId() const;
    uint64_t changes() const;

private:
    std::unique_ptr<StatementImpl> impl;
};

class Transaction {
private:
    Transaction(const Transaction&) = delete;
    Transaction(Transaction&&) = delete;
    Transaction& operator=(const Transaction&) = delete;

public:
    enum Mode {
        Deferred,
        Immediate,
        Exclusive
    };

    Transaction(Database&, Mode = Deferred);
    ~Transaction();

    void commit();
    void rollback();

private:
    Database& db;
    bool needRollback = true;
};

}
}