/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: Tim Marston
  • Date: 2014-01-03 12:50:37 UTC
  • Revision ID: tim@ed.am-20140103125037-3apzzac1zym0jnxl
fixed building of test program with boost libraries

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/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