/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: edam
  • Date: 2010-07-29 06:28:53 UTC
  • Revision ID: edam@waxworlds.org-20100729062853-4i2fec52m86mh724
- made basic_statement::step() protected, for use by query and command only
- moved basic_statement::operator<<() to command and query instead; one needs to accept sqlite::exec, the other doesn't
- added tests for query::operator<<()
- added code to invlaidate in-progress queries during any transaction rollbacks (currently segfaults in basic_statement::finalize())
- added new sqlite_error constructor that obtains a full error message
- implemented database::database_mutex_guard class
- swapped command's step mutex in favour of the database mutex

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
1
- add columns() to row that returns a boost::tuple of various types so multple
 
2
        columns can be fetched at once (look in to using BOOST_PP_ITERATE macro)
 
3
 
 
4
- make basic_statement and database keep a shared pointer to the database handle
 
5
        so the classes can be made copyable. The wrappers around the handle
 
6
        (implemented in sqlite::detail) can clean them up after use. This will also
 
7
        make the implementation of rows (to get round the forced non-dependency of
 
8
        rows on querys) a little easier to swallow.
 
9
        - A similar wrapper should be created for statement handles, making
 
10
                basic_statements, querys and commands copyable. Could weak_ptrs to these
 
11
                also be used in the database's list active querys?
 
12
 
 
13
- fix to force the finalisation of queries in progress for transactions causes
 
14
        errors; queries are now finalised twice, the second from basic_statement's
 
15
        dtor, which causes a segfault. We could:
 
16
        - keep a list of force-finalised sqlite3_stmt pointers in the database which
 
17
                we use to check queries against before finalising them to make sure we
 
18
                don't finalise them a second time
 
19
                - an efficient implementation, but not very OO
 
20
        - keep a map of active queries in the database (using the sqlite3_stmt
 
21
                pointer as the key), so that we can obtain the query and tell it to
 
22
                finalise its self
 
23
                - this seems like a messy and complicated implementation
 
24
 
 
25
- turn on extended errcodes in open() and handle them in sqlite_error
 
26
 
 
27
- use sqlite3_db_mutex() to provide extended error information during
 
28
        sqlite_error construction. The genreeal procedure would be to lock the db
 
29
        mutex, perform some sqlite3 command, check the error code, throw an
 
30
        sqlite_error (whilst obtaining extended error info) and then unlock the db
 
31
        mutex. Two options:
 
32
        - a macro would be simple
35
33
        - 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
 
 
 
34
                template params) may be overkill
 
35
 
 
36
- expand sqlite_error - perhaps use boost::system_error (see
 
37
        boost/asio/error.hpp for an example of extending system_error)
 
38
 
 
39
- see if we can #include "sqlite.h" in to a namespace.
55
40
        Pros:
56
 
         - we better encapsulate the library
57
 
         - we can reuse "sqlite3" as a namespace
 
41
                we better encapsulate the library
 
42
                we can reuse "sqlite3" as a namespace
58
43
        Cons:
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
 
44
                makes access to real sqlite stuff awkward to sqlite3cc users, but does
 
45
                        this matter? they can't access database._handle anyway!
 
46
                potential incompatibility when linking to libraries that also link
 
47
                        against sqlite
 
48
 
 
49
- query::prepare() isn't being called during construction (form
 
50
        basic_statement's constructor)