1
- fix to force the finalisation of queries in progress for transactions causes
2
errors; queries are now finalised twice, the second from basic_statement's
3
dtor, which causes a segfault. We could:
4
- keep a set of force-finalised sqlite3_stmt pointers in the database which
5
we use to check queries against before finalising them to make sure we
6
don't finalise them a second time
7
- an efficient implementation, but not very OO
8
- keep a map of active queries in the database (using the sqlite3_stmt
9
pointer as the key), so that we can obtain the query and tell it to
11
- this seems like a messy and complicated implementation
12
- would be improved by having a wrapper around the query handle
1
- add columns() to row that returns a boost::tuple of various types so multple columns can be fetched at once
2
- look in to using BOOST_PP_ITERATE macro
3
- make basic_statement and database keep a shared pointer to the database handle so the classes can be made copyable. Also:
4
- the wrappers around the handle can clean them up after use
5
- the actual wrappers wround the handles can be made in sqlite::detail
6
- this will also make the implementation od rows (to get round the forced non-dependency of rows on querys) a little easier to swallow.
7
- committing a transaction during a query (i.e., when sqlite3_step() has returned SQLITE_ROW) causes an error. To counter this:
8
- need to check it's not fixed in latest sqlite; write test program
9
- calling query.reset() before the commit fixes the issue
10
- will need to keep a list of querys that need resetting in the database :o(
14
11
- turn on extended errcodes in open() and handle them in sqlite_error
16
- make basic_statement and database keep a shared pointer to the database handle
17
so the classes can be made copyable. The wrappers around the handle
18
(implemented in sqlite::detail) can clean them up after use. This will also
19
make the implementation of rows (to get round the forced non-dependency of
20
rows on querys) a little easier to swallow.
21
- A similar wrapper should be created for statement handles, making
22
basic_statements, querys and commands copyable. Could weak_ptrs to these
23
also be used in the database's list active querys?
25
- add columns() to row that returns a boost::tuple of various types so multple
26
columns can be fetched at once (look in to using BOOST_PP_ITERATE macro)
28
- use sqlite3_db_mutex() to provide extended error information during
29
sqlite_error construction. The genreeal procedure would be to lock the db
30
mutex, perform some sqlite3 command, check the error code, throw an
31
sqlite_error (whilst obtaining extended error info) and then unlock the db
33
- a macro would be simple
34
- a templated safe-calling object (passing the comman's arg types as
35
template params) may be overkill
37
- expand sqlite_error - perhaps use boost::system_error (see
38
boost/asio/error.hpp for an example of extending system_error)
12
- use sqlite3_db_mutex() to provide extended error information during sqlite_error construction - see sqlite::query::step() for example
13
- expand sqlite_error - perhaps use boost::system_error (see boost/asio/error.hpp for an example of extending system_error)
40
14
- see if we can #include "sqlite.h" in to a namespace.
42
16
we better encapsulate the library
43
17
we can reuse "sqlite3" as a namespace
45
makes access to real sqlite stuff awkward to sqlite3cc users, but does
46
this matter? they can't access database._handle anyway!
47
potential incompatibility when linking to libraries that also link
19
makes access to real sqlite stuff awkward to sqlite3cc users, but does this matter? they can't access database._handle anyway!
20
potential incompatibility when linking to libraries that also link against sqlite
21
- fix step() inconsistency - query::step() returns a row, whereas basic_statement::step() and command::step() return an int return code
50
22
- query::prepare() isn't being called during construction (form
51
23
basic_statement's constructor)
added
removed
TODO
