blob: e487e6bf298bdf25f50102ba2d15c138fdceb1b0 (
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
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// file : odb/sqlite/connection.hxx
// author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
#ifndef ODB_SQLITE_CONNECTION_HXX
#define ODB_SQLITE_CONNECTION_HXX
#include <odb/pre.hxx>
#include <sqlite3.h>
#include <memory> // std::auto_ptr
#include <odb/forward.hxx>
#include <odb/connection.hxx>
#include <odb/details/mutex.hxx>
#include <odb/details/condition.hxx>
#include <odb/details/shared-ptr.hxx>
#include <odb/sqlite/version.hxx>
#include <odb/sqlite/forward.hxx>
#include <odb/sqlite/transaction-impl.hxx>
#include <odb/sqlite/details/export.hxx>
namespace odb
{
namespace sqlite
{
class statement;
class statement_cache;
class connection;
typedef details::shared_ptr<connection> connection_ptr;
class LIBODB_SQLITE_EXPORT connection: public odb::connection
{
public:
typedef sqlite::statement_cache statement_cache_type;
typedef sqlite::database database_type;
virtual
~connection ();
connection (database_type&, int extra_flags = 0);
connection (database_type&, sqlite3* handle);
database_type&
database ()
{
return db_;
}
public:
virtual transaction_impl*
begin ();
transaction_impl*
begin_immediate ();
transaction_impl*
begin_exclusive ();
public:
using odb::connection::execute;
virtual unsigned long long
execute (const char* statement, std::size_t length);
public:
sqlite3*
handle ()
{
return handle_;
}
statement_cache_type&
statement_cache ()
{
return *statement_cache_;
}
// Wait for the locks to be released via unlock notification. Can
// be called after getting SQLITE_LOCKED_SHAREDCACHE.
//
void
wait ();
public:
// Reset active and finalize uncached statements.
//
void
clear ();
private:
connection (const connection&);
connection& operator= (const connection&);
private:
void
init ();
private:
database_type& db_;
sqlite3* handle_;
// Unlock notification machinery.
//
private:
bool unlocked_;
details::mutex unlock_mutex_;
details::condition unlock_cond_;
friend void
connection_unlock_callback (void**, int);
// Linked list of active and uncached statements currently associated
// with this connection.
//
private:
friend class statement;
statement* statements_;
std::auto_ptr<statement_cache_type> statement_cache_;
};
}
}
#include <odb/post.hxx>
#endif // ODB_SQLITE_CONNECTION_HXX
|
