/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 14:34:45 UTC
  • Revision ID: edam@waxworlds.org-20120123143445-s2v4v90nycmfm6bv
fixed up tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/query.cc
1
1
/*
2
2
 * query.cc
3
3
 *
4
 
 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>
 
4
 * Copyright (C) 2009 Tim Marston <tim@ed.am>
5
5
 *
6
6
 * This file is part of sqlite3cc (hereafter referred to as "this program").
7
 
 * See http://www.waxworlds.org/edam/software/sqlite3cc for more information.
8
 
 *
9
 
 * This program is free software: you can redistribute it and/or modify
10
 
 * it under the terms of the GNU Lesser General Public License as published
11
 
 * by the Free Software Foundation, either version 3 of the License, or
12
 
 * (at your option) any later version.
13
 
 *
14
 
 * This program is distributed in the hope that it will be useful,
15
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 * GNU Lesser General Public License for more details.
 
7
 * See http://ed.am/dev/sqlite3cc for more information.
 
8
 *
 
9
 * This program is free software: you can redistribute it and/or modify it under
 
10
 * the terms of the GNU Lesser General Public License as published by the Free
 
11
 * Software Foundation, either version 3 of the License, or (at your option) any
 
12
 * later version.
 
13
 *
 
14
 * This program is distributed in the hope that it will be useful, but WITHOUT
 
15
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
16
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 
17
 * details.
18
18
 *
19
19
 * You should have received a copy of the GNU Lesser General Public License
20
20
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
22
 
23
23
#include <sqlite3cc/query.h>
24
24
#include <sqlite3cc/row.h>
25
 
#include <sqlite3cc/manipulator.h>
26
 
#include <sqlite3cc/database.h>
 
25
#include <sqlite3cc/connection.h>
27
26
#include <assert.h>
28
27
 
29
28
 
30
29
sqlite::query::query(
31
 
        database &database,
 
30
        connection &connection,
32
31
        const std::string &sql )
33
32
        :
34
 
        basic_statement( database, sql ),
35
 
        _next_row( 0 )
 
33
        basic_statement( connection, sql ),
 
34
        _next_row_number( 0 )
36
35
{
37
36
        assert( sqlite3_column_count( _handle ) > 0 );
38
37
}
39
38
 
40
39
 
41
40
sqlite::query::query(
42
 
        database &database )
 
41
        connection &connection )
43
42
        :
44
 
        basic_statement( database ),
45
 
        _next_row( 0 )
 
43
        basic_statement( connection ),
 
44
        _next_row_number( 0 )
46
45
{
47
46
}
48
47
 
50
49
int sqlite::query::prepare(
51
50
        const std::string &sql )
52
51
{
53
 
        _next_row = 0;
 
52
        _next_row_number = 0;
54
53
        int code = basic_statement::prepare( sql );
55
54
        assert( code != SQLITE_OK || sqlite3_column_count( _handle ) > 0 );
56
55
        return code;
57
56
}
58
57
 
59
58
 
 
59
int sqlite::query::reset()
 
60
{
 
61
        _next_row_number = 0;
 
62
        return basic_statement::reset();
 
63
}
 
64
 
 
65
 
60
66
sqlite::row sqlite::query::step()
61
67
{
62
 
        database::database_mutex_guard lock( _database );
 
68
        connection::mutex_guard lock( _connection );
63
69
 
64
70
        int code = basic_statement::step();
65
71
        if( code == SQLITE_DONE ) return row();
66
 
        if( code == SQLITE_ROW ) return row( _handle, _next_row++ );
 
72
        if( code == SQLITE_ROW ) return row( _handle, _next_row_number++ );
67
73
 
68
 
        throw sqlite_error( _database, code );
 
74
        throw sqlite_error( _connection, code );
69
75
}
70
76
 
71
77
 
84
90
}
85
91
 
86
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
 
87
103
sqlite::query::iterator::iterator(
88
104
        sqlite::query &query,
89
 
        bool valid )
 
105
        bool step )
90
106
        :
91
107
        _query( query )
92
108
{
93
 
        if( valid )
94
 
                increment();
95
 
        else
96
 
                _valid = false;
 
109
        if( step ) increment();
97
110
}
98
111
 
99
112
 
100
113
sqlite::row sqlite::query::iterator::dereference() const
101
114
{
102
 
        return sqlite::row( _query._handle, _query._next_row++ );
 
115
        return _row;
103
116
}
104
117
 
105
118
 
106
119
void sqlite::query::iterator::increment()
107
120
{
108
 
        _valid = _query.step();
 
121
        _row = _query.step();
109
122
}
110
123
 
111
124
 
113
126
        sqlite::query::iterator const &other )
114
127
        const
115
128
{
116
 
        return _valid == other._valid;
 
129
        return _row == other._row;
117
130
}
118
131
 
119
132
 
120
133
sqlite::query::iterator sqlite::query::begin()
121
134
{
 
135
        reset();
122
136
        return sqlite::query::iterator( *this, true );
123
137
}
124
138
 
128
142
        return sqlite::query::iterator( *this, false );
129
143
}
130
144
 
131
 
 
132
 
template< >
133
 
sqlite::query &sqlite::query::operator <<
134
 
        < sqlite::detail::null_t >(
135
 
        const sqlite::detail::null_t & )
136
 
{
137
 
        int code = bind_null( _bind_index );
138
 
        if( code != SQLITE_OK ) throw sqlite_error( _database, code );
139
 
        _bind_index++;
140
 
        return *this;
141
 
}
142
 
 
143
 
 
144
 
template< >
145
 
sqlite::query &sqlite::query::operator <<
146
 
        < sqlite::detail::set_index_t >(
147
 
        const sqlite::detail::set_index_t &t )
148
 
{
149
 
        _bind_index = t._index;
150
 
        return *this;
151
 
}