/sqlite3cc

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

« back to all changes in this revision

Viewing changes to src/query.cc

  • Committer: edam
  • Date: 2012-01-23 13:51:26 UTC
  • Revision ID: edam@waxworlds.org-20120123135126-7gohm0mv9qwismla
typo

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/query.cc
22
22
 
23
23
#include <sqlite3cc/query.h>
24
24
#include <sqlite3cc/row.h>
25
 
#include <sqlite3cc/database.h>
 
25
#include <sqlite3cc/connection.h>
26
26
#include <assert.h>
27
27
 
28
28
 
29
29
sqlite::query::query(
30
 
        database &database,
 
30
        connection &connection,
31
31
        const std::string &sql )
32
32
        :
33
 
        basic_statement( database, sql ),
34
 
        _next_row( 0 )
 
33
        basic_statement( connection, sql ),
 
34
        _next_row_number( 0 )
35
35
{
36
36
        assert( sqlite3_column_count( _handle ) > 0 );
37
37
}
38
38
 
39
39
 
40
40
sqlite::query::query(
41
 
        database &database )
 
41
        connection &connection )
42
42
        :
43
 
        basic_statement( database ),
44
 
        _next_row( 0 )
 
43
        basic_statement( connection ),
 
44
        _next_row_number( 0 )
45
45
{
46
46
}
47
47
 
49
49
int sqlite::query::prepare(
50
50
        const std::string &sql )
51
51
{
52
 
        _next_row = 0;
 
52
        _next_row_number = 0;
53
53
        int code = basic_statement::prepare( sql );
54
54
        assert( code != SQLITE_OK || sqlite3_column_count( _handle ) > 0 );
55
55
        return code;
56
56
}
57
57
 
58
58
 
 
59
int sqlite::query::reset()
 
60
{
 
61
        _next_row_number = 0;
 
62
        return basic_statement::reset();
 
63
}
 
64
 
 
65
 
59
66
sqlite::row sqlite::query::step()
60
67
{
61
 
        database::database_mutex_guard lock( _database );
 
68
        connection::mutex_guard lock( _connection );
62
69
 
63
70
        int code = basic_statement::step();
64
71
        if( code == SQLITE_DONE ) return row();
65
 
        if( code == SQLITE_ROW ) return row( _handle, _next_row++ );
 
72
        if( code == SQLITE_ROW ) return row( _handle, _next_row_number++ );
66
73
 
67
 
        throw sqlite_error( _database, code );
 
74
        throw sqlite_error( _connection, code );
68
75
}
69
76
 
70
77
 
83
90
}
84
91
 
85
92
 
 
93
unsigned long long sqlite::query::num_results()
 
94
{
 
95
        reset();
 
96
        unsigned long long count = 0;
 
97
        while( step() ) count++;
 
98
        reset();
 
99
        return count;
 
100
}
 
101
 
 
102
 
86
103
sqlite::query::iterator::iterator(
87
104
        sqlite::query &query,
88
 
        bool valid )
 
105
        bool step )
89
106
        :
90
107
        _query( query )
91
108
{
92
 
        if( valid )
93
 
                increment();
94
 
        else
95
 
                _valid = false;
 
109
        if( step ) increment();
96
110
}
97
111
 
98
112
 
99
113
sqlite::row sqlite::query::iterator::dereference() const
100
114
{
101
 
        return sqlite::row( _query._handle, _query._next_row++ );
 
115
        return _row;
102
116
}
103
117
 
104
118
 
105
119
void sqlite::query::iterator::increment()
106
120
{
107
 
        _valid = _query.step();
 
121
        _row = _query.step();
108
122
}
109
123
 
110
124
 
112
126
        sqlite::query::iterator const &other )
113
127
        const
114
128
{
115
 
        return _valid == other._valid;
 
129
        return _row == other._row;
116
130
}
117
131
 
118
132
 
119
133
sqlite::query::iterator sqlite::query::begin()
120
134
{
 
135
        reset();
121
136
        return sqlite::query::iterator( *this, true );
122
137
}
123
138