/sqlite3cc

To get this branch, use:
bzr branch http://bzr.ed.am/sqlite3cc

« back to all changes in this revision

Viewing changes to TODO

  • Committer: Tim Marston
  • Date: 2014-01-03 12:17:03 UTC
  • Revision ID: tim@ed.am-20140103121703-afwyh7wifde5kidm
added description of return parameter to header

Show diffs side-by-side

added added

removed removed

Lines of Context:
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(
11
 
- turn on extended errcodes in open() and handle them in sqlite_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)
14
 
- see if we can #include "sqlite.h" in to a namespace.
 
1
 
 
2
IMMEDIATE ISSUES
 
3
 
 
4
 - look in to making query and command's _handle a shared_ptr, so that query
 
5
   and command classes can be copied.
 
6
 
 
7
 - rename _bind_index and _column_index to _next_*
 
8
 
 
9
 - change the transaction_guard interface so you can dereference it to get to
 
10
   its transaction and the transactions take care of not rolling back or
 
11
   committing when they already have done (as well as resetting in-progress
 
12
   queries).
 
13
 
 
14
 - turn on extended errcodes in open() and handle them in sqlite_error
 
15
 
 
16
 - query::prepare() isn't being called during construction (from
 
17
   basic_statement's constructor)
 
18
 
 
19
 - add columns() to row that returns a boost::tuple of various types so multple
 
20
   columns can be fetched at once (look in to using BOOST_PP_ITERATE macro)
 
21
 
 
22
 - add a row::column() that can take a column name. This is nexessary when
 
23
   doing a "SELECT *" and you don't know the column indicies. To implement
 
24
   this, the first time it is called, a column-name-to-index lookup would have
 
25
   to be built. This should be done in the query, not the row. This means that
 
26
   the row will have to know it's query (currently is copies its _handle) to be
 
27
   able to call column_index() on it. Is this a problem?
 
28
 
 
29
 - use sqlite3_db_mutex() to provide extended error information during
 
30
   sqlite_error construction. The general procedure would be to lock the db
 
31
   mutex, perform some sqlite3 command, check the error code, throw an
 
32
   sqlite_error (whilst obtaining extended error info) and then unlock the db
 
33
   mutex. Two options:
 
34
        - a macro would be simple
 
35
        - a templated safe-calling object (passing the comman's arg types as
 
36
      template params) may be overkill
 
37
 
 
38
 
 
39
LONGER TERM IDEAS
 
40
 
 
41
 - make basic_statement and database keep a shared pointer to the database
 
42
   handle so the classes can be made copyable. The wrappers around the handle
 
43
   (implemented in sqlite::detail) can clean them up after use. This will also
 
44
   make the implementation of rows (to get round the forced non-dependency of
 
45
   rows on querys) a little easier to swallow.
 
46
    - A similar wrapper should be created for statement handles, making
 
47
      basic_statements, querys and commands copyable. Could weak_ptrs to these
 
48
      also be used in the database's list active querys?
 
49
 
 
50
 - expand sqlite_error - perhaps use boost::system_error (see
 
51
   boost/asio/error.hpp for an example of extending system_error)
 
52
 
 
53
 - see if we can #include "sqlite.h" in to a namespace.
 
54
 
15
55
        Pros:
16
 
                we better encapsulate the library
17
 
                we can reuse "sqlite3" as a namespace
 
56
         - we better encapsulate the library
 
57
         - we can reuse "sqlite3" as a namespace
18
58
        Cons:
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
22
 
- query::prepare() isn't being called during construction (form
23
 
        basic_statement's constructor)
 
59
         - makes access to real sqlite stuff awkward to sqlite3cc users, but does
 
60
       this matter? they can't access database._handle anyway!
 
61
     - potential incompatibility when linking to libraries that also link
 
62
       against sqlite