/sqlite3cc

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

« back to all changes in this revision

Viewing changes to include/sqlite3cc/basic_statement.h

  • Committer: edam
  • Date: 2010-07-27 15:46:42 UTC
  • Revision ID: edam@waxworlds.org-20100727154642-1uxrjkpxhp7xl6hq
- moved null_t, exec_t and set_index_t to detail namespace so only their extern instantiations are in the main namespace
- added immediate transation

Show diffs side-by-side

added added

removed removed

34
34
{
35
35
 
36
36
 
37
 
class connection;
 
37
class database;
38
38
class row;
39
39
namespace detail {
40
40
        struct null_t;
43
43
}
44
44
 
45
45
 
46
 
namespace detail
47
 
{
48
 
 
49
 
 
50
46
/**
51
47
 * The statement class represents an SQL statement. It is the base class for
52
48
 * both the command and the query classes, which should be used for those
61
57
protected:
62
58
 
63
59
        /**
64
 
         * Constructor that provides a connection upon which to act and the SQL
 
60
         * Constructor that provides a database upon which to act and the SQL
65
61
         * statement.
66
 
         * @param connection a reference to a connection
 
62
         * @param database a reference to a database
67
63
         * @param sql an SQL statement in UTF-8
68
64
         */
69
65
        explicit basic_statement(
70
 
                connection &connection,
 
66
                database &database,
71
67
                const std::string &sql );
72
68
 
73
69
        /**
74
 
         * Constructor that provides a connection upon which to act.
75
 
         * @param connection a reference to a connection
 
70
         * Constructor that provides a database upon which to act.
 
71
         * @param database a reference to a database
 
72
         * @param sql an SQL statement in UTF-8
76
73
         */
77
74
        explicit basic_statement(
78
 
                connection &connection );
 
75
                database &database );
79
76
 
80
77
        virtual ~basic_statement();
81
78
 
98
95
         * @returns an sqlite error code
99
96
         * @see sqlite3_reset()
100
97
         */
101
 
        virtual int reset();
 
98
        int reset();
102
99
 
103
100
        /**
104
101
         * Clears the values bound to a statement to NULL.
130
127
        /**
131
128
         * Bind a string value to the SQL statement via it's index where the value
132
129
         * of that string will not change for the duration of the statement. This is
133
 
         * more optimal because sqlite will not have to take it's own copy of the
 
130
         * more optimal because sqlite will not have to make it's own copy of the
134
131
         * data.
135
132
         * @param index the index of the parameter to bind to
136
133
         * @param value the invariant string value
137
 
         * @param value_length the length of the string including zero-terminator
138
134
         * @returns an sqlite error code
139
135
         * @see sqlite3_bind_text()
140
136
         */
146
142
        /**
147
143
         * Bind a string value to the SQL statement via it's index where the value
148
144
         * of that string will not change for the duration of the statement. This is
149
 
         * more optimal  because sqlite will not have to take it's own copy of the
 
145
         * more optimal  because sqlite will not have to make it's own copy of the
150
146
         * data.
151
147
         * @param index the index of the parameter to bind to
152
148
         * @param value the invariant string value
160
156
        /**
161
157
         * Bind a string value to the SQL statement via it's index where the value
162
158
         * of that string will not change for the duration of the statement. This is
163
 
         * more optimal because sqlite will not have to take it's own copy of the
 
159
         * more optimal because sqlite will not have to make it's own copy of the
164
160
         * data.
165
161
         * @param index the index of the parameter to bind to
166
162
         * @param value the invariant string value
201
197
        /**
202
198
         * Bind a string value to the SQL statement via a named parameter where the
203
199
         * string value will not change for the duration of the statement. This
204
 
         * prevents sqlite from taking its own copy of the string.
 
200
         * prevents a copy of the string being taken.
205
201
         * @param name the named parameter to bind to
206
202
         * @param value the invariant string value
207
 
         * @param value_length the length of the string including zero-terminator
208
203
         * @returns an sqlite error code
209
204
         * @see sqlite3_bind_text()
210
205
         */
250
245
 
251
246
        /**
252
247
         * Stream operator is used to bind values to parameters automatically, in
253
 
         * ascending order. In addition, the null and set_index() auto-binding
254
 
         * manipulators can be used.
 
248
         * ascending order. In addition, the null, set_index() and execute auto-
 
249
         * binding manipulators can be used.
255
250
         * @param value a value to bind
256
251
         */
257
252
        template< class T >
258
253
        basic_statement &operator <<(
259
254
                const T &value )
260
255
        {
261
 
                int code = bind( _bind_index, value );
262
 
                if( code != SQLITE_OK ) throw sqlite_error( _connection, code );
 
256
                int error_code = bind( _bind_index, value );
 
257
                if( error_code != SQLITE_OK ) throw sqlite_error( error_code );
263
258
                _bind_index++;
264
259
                return *this;
265
260
        }
278
273
        int finalize();
279
274
 
280
275
        /**
 
276
         * Step through one execution cycle of the SQL statement. If this is an SQL
 
277
         * statement that doesn't return any rows, only one cycle is required,
 
278
         * otherwise, each cycle will return another row
 
279
         * @return an sqlite error code
 
280
         * @see sqlite3_step()
 
281
         */
 
282
        int step();
 
283
 
 
284
        /**
281
285
         * Get the index number of a named parameter
282
286
         * @param parameter name
283
287
         * @return index of named parameter
285
289
        int bind_parameter_index(
286
290
                const std::string &name );
287
291
 
288
 
        /**
289
 
         * Perform a step
290
 
         * @return sqlite error code
291
 
         * @see sqlite3_step()
292
 
         */
293
 
        int step();
294
 
 
295
 
        /** the connection upon which to act */
296
 
        connection &_connection;
 
292
        /** the database upon which to act */
 
293
        database &_database;
297
294
 
298
295
        /** the statement handle */
299
296
        sqlite3_stmt *_handle;
300
297
 
 
298
private:
 
299
 
301
300
        /** index used when auto-binding */
302
301
        unsigned int _bind_index;
303
302
 
304
303
};
305
304
 
306
305
 
307
 
// template specialisations for basic_statement::operator <<()
 
306
// template specialisations for statement::operator <<()
308
307
template< >
309
308
basic_statement &basic_statement::operator << < detail::null_t >(
310
309
        const detail::null_t & );
311
310
template< >
 
311
basic_statement &basic_statement::operator << < detail::exec_t >(
 
312
        const detail::exec_t & );
 
313
template< >
312
314
basic_statement &basic_statement::operator << < detail::set_index_t >(
313
315
        const detail::set_index_t &t );
314
316
 
315
317
 
316
 
} // namespace detail
317
 
 
318
 
 
319
318
} // namespace sqlite
320
319
 
321
320