Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "sql/statement.h" |
| 6 | |
| 7 | #include "base/logging.h" |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 8 | #include "base/strings/string_util.h" |
| 9 | #include "base/strings/utf_string_conversions.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 10 | #include "third_party/sqlite/sqlite3.h" |
| 11 | |
| 12 | namespace sql { |
| 13 | |
| 14 | // This empty constructor initializes our reference with an empty one so that |
| 15 | // we don't have to NULL-check the ref_ to see if the statement is valid: we |
| 16 | // only have to check the ref's validity bit. |
| 17 | Statement::Statement() |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 18 | : ref_(new Connection::StatementRef(NULL, NULL, false)), |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 19 | stepped_(false), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 20 | succeeded_(false) { |
| 21 | } |
| 22 | |
| 23 | Statement::Statement(scoped_refptr<Connection::StatementRef> ref) |
| 24 | : ref_(ref), |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 25 | stepped_(false), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 26 | succeeded_(false) { |
| 27 | } |
| 28 | |
| 29 | Statement::~Statement() { |
| 30 | // Free the resources associated with this statement. We assume there's only |
| 31 | // one statement active for a given sqlite3_stmt at any time, so this won't |
| 32 | // mess with anything. |
| 33 | Reset(true); |
| 34 | } |
| 35 | |
| 36 | void Statement::Assign(scoped_refptr<Connection::StatementRef> ref) { |
| 37 | Reset(true); |
| 38 | ref_ = ref; |
| 39 | } |
| 40 | |
| 41 | void Statement::Clear() { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 42 | Assign(new Connection::StatementRef(NULL, NULL, false)); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 43 | succeeded_ = false; |
| 44 | } |
| 45 | |
| 46 | bool Statement::CheckValid() const { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 47 | // Allow operations to fail silently if a statement was invalidated |
| 48 | // because the database was closed by an error handler. |
| 49 | DLOG_IF(FATAL, !ref_->was_valid()) |
| 50 | << "Cannot call mutating statements on an invalid statement."; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 51 | return is_valid(); |
| 52 | } |
| 53 | |
| 54 | bool Statement::Run() { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 55 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 56 | ref_->AssertIOAllowed(); |
| 57 | if (!CheckValid()) |
| 58 | return false; |
| 59 | |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 60 | stepped_ = true; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 61 | return CheckError(sqlite3_step(ref_->stmt())) == SQLITE_DONE; |
| 62 | } |
| 63 | |
| 64 | bool Statement::Step() { |
| 65 | ref_->AssertIOAllowed(); |
| 66 | if (!CheckValid()) |
| 67 | return false; |
| 68 | |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 69 | stepped_ = true; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 70 | return CheckError(sqlite3_step(ref_->stmt())) == SQLITE_ROW; |
| 71 | } |
| 72 | |
| 73 | void Statement::Reset(bool clear_bound_vars) { |
| 74 | ref_->AssertIOAllowed(); |
| 75 | if (is_valid()) { |
| 76 | // We don't call CheckError() here because sqlite3_reset() returns |
| 77 | // the last error that Step() caused thereby generating a second |
| 78 | // spurious error callback. |
| 79 | if (clear_bound_vars) |
| 80 | sqlite3_clear_bindings(ref_->stmt()); |
| 81 | sqlite3_reset(ref_->stmt()); |
| 82 | } |
| 83 | |
| 84 | succeeded_ = false; |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 85 | stepped_ = false; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | bool Statement::Succeeded() const { |
| 89 | if (!is_valid()) |
| 90 | return false; |
| 91 | |
| 92 | return succeeded_; |
| 93 | } |
| 94 | |
| 95 | bool Statement::BindNull(int col) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 96 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 97 | if (!is_valid()) |
| 98 | return false; |
| 99 | |
| 100 | return CheckOk(sqlite3_bind_null(ref_->stmt(), col + 1)); |
| 101 | } |
| 102 | |
| 103 | bool Statement::BindBool(int col, bool val) { |
| 104 | return BindInt(col, val ? 1 : 0); |
| 105 | } |
| 106 | |
| 107 | bool Statement::BindInt(int col, int val) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 108 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 109 | if (!is_valid()) |
| 110 | return false; |
| 111 | |
| 112 | return CheckOk(sqlite3_bind_int(ref_->stmt(), col + 1, val)); |
| 113 | } |
| 114 | |
| 115 | bool Statement::BindInt64(int col, int64 val) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 116 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 117 | if (!is_valid()) |
| 118 | return false; |
| 119 | |
| 120 | return CheckOk(sqlite3_bind_int64(ref_->stmt(), col + 1, val)); |
| 121 | } |
| 122 | |
| 123 | bool Statement::BindDouble(int col, double val) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 124 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 125 | if (!is_valid()) |
| 126 | return false; |
| 127 | |
| 128 | return CheckOk(sqlite3_bind_double(ref_->stmt(), col + 1, val)); |
| 129 | } |
| 130 | |
| 131 | bool Statement::BindCString(int col, const char* val) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 132 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 133 | if (!is_valid()) |
| 134 | return false; |
| 135 | |
| 136 | return CheckOk( |
| 137 | sqlite3_bind_text(ref_->stmt(), col + 1, val, -1, SQLITE_TRANSIENT)); |
| 138 | } |
| 139 | |
| 140 | bool Statement::BindString(int col, const std::string& val) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 141 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 142 | if (!is_valid()) |
| 143 | return false; |
| 144 | |
| 145 | return CheckOk(sqlite3_bind_text(ref_->stmt(), |
| 146 | col + 1, |
| 147 | val.data(), |
| 148 | val.size(), |
| 149 | SQLITE_TRANSIENT)); |
| 150 | } |
| 151 | |
| 152 | bool Statement::BindString16(int col, const string16& value) { |
| 153 | return BindString(col, UTF16ToUTF8(value)); |
| 154 | } |
| 155 | |
| 156 | bool Statement::BindBlob(int col, const void* val, int val_len) { |
Torne (Richard Coles) | 1e9bf3e | 2013-10-31 11:16:26 +0000 | [diff] [blame] | 157 | DCHECK(!stepped_); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 158 | if (!is_valid()) |
| 159 | return false; |
| 160 | |
| 161 | return CheckOk( |
| 162 | sqlite3_bind_blob(ref_->stmt(), col + 1, val, val_len, SQLITE_TRANSIENT)); |
| 163 | } |
| 164 | |
| 165 | int Statement::ColumnCount() const { |
| 166 | if (!is_valid()) |
| 167 | return 0; |
| 168 | |
| 169 | return sqlite3_column_count(ref_->stmt()); |
| 170 | } |
| 171 | |
| 172 | ColType Statement::ColumnType(int col) const { |
| 173 | // Verify that our enum matches sqlite's values. |
| 174 | COMPILE_ASSERT(COLUMN_TYPE_INTEGER == SQLITE_INTEGER, integer_no_match); |
| 175 | COMPILE_ASSERT(COLUMN_TYPE_FLOAT == SQLITE_FLOAT, float_no_match); |
| 176 | COMPILE_ASSERT(COLUMN_TYPE_TEXT == SQLITE_TEXT, integer_no_match); |
| 177 | COMPILE_ASSERT(COLUMN_TYPE_BLOB == SQLITE_BLOB, blob_no_match); |
| 178 | COMPILE_ASSERT(COLUMN_TYPE_NULL == SQLITE_NULL, null_no_match); |
| 179 | |
| 180 | return static_cast<ColType>(sqlite3_column_type(ref_->stmt(), col)); |
| 181 | } |
| 182 | |
| 183 | ColType Statement::DeclaredColumnType(int col) const { |
| 184 | std::string column_type(sqlite3_column_decltype(ref_->stmt(), col)); |
| 185 | StringToLowerASCII(&column_type); |
| 186 | |
| 187 | if (column_type == "integer") |
| 188 | return COLUMN_TYPE_INTEGER; |
| 189 | else if (column_type == "float") |
| 190 | return COLUMN_TYPE_FLOAT; |
| 191 | else if (column_type == "text") |
| 192 | return COLUMN_TYPE_TEXT; |
| 193 | else if (column_type == "blob") |
| 194 | return COLUMN_TYPE_BLOB; |
| 195 | |
| 196 | return COLUMN_TYPE_NULL; |
| 197 | } |
| 198 | |
| 199 | bool Statement::ColumnBool(int col) const { |
| 200 | return !!ColumnInt(col); |
| 201 | } |
| 202 | |
| 203 | int Statement::ColumnInt(int col) const { |
| 204 | if (!CheckValid()) |
| 205 | return 0; |
| 206 | |
| 207 | return sqlite3_column_int(ref_->stmt(), col); |
| 208 | } |
| 209 | |
| 210 | int64 Statement::ColumnInt64(int col) const { |
| 211 | if (!CheckValid()) |
| 212 | return 0; |
| 213 | |
| 214 | return sqlite3_column_int64(ref_->stmt(), col); |
| 215 | } |
| 216 | |
| 217 | double Statement::ColumnDouble(int col) const { |
| 218 | if (!CheckValid()) |
| 219 | return 0; |
| 220 | |
| 221 | return sqlite3_column_double(ref_->stmt(), col); |
| 222 | } |
| 223 | |
| 224 | std::string Statement::ColumnString(int col) const { |
| 225 | if (!CheckValid()) |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 226 | return std::string(); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 227 | |
| 228 | const char* str = reinterpret_cast<const char*>( |
| 229 | sqlite3_column_text(ref_->stmt(), col)); |
| 230 | int len = sqlite3_column_bytes(ref_->stmt(), col); |
| 231 | |
| 232 | std::string result; |
| 233 | if (str && len > 0) |
| 234 | result.assign(str, len); |
| 235 | return result; |
| 236 | } |
| 237 | |
| 238 | string16 Statement::ColumnString16(int col) const { |
| 239 | if (!CheckValid()) |
| 240 | return string16(); |
| 241 | |
| 242 | std::string s = ColumnString(col); |
| 243 | return !s.empty() ? UTF8ToUTF16(s) : string16(); |
| 244 | } |
| 245 | |
| 246 | int Statement::ColumnByteLength(int col) const { |
| 247 | if (!CheckValid()) |
| 248 | return 0; |
| 249 | |
| 250 | return sqlite3_column_bytes(ref_->stmt(), col); |
| 251 | } |
| 252 | |
| 253 | const void* Statement::ColumnBlob(int col) const { |
| 254 | if (!CheckValid()) |
| 255 | return NULL; |
| 256 | |
| 257 | return sqlite3_column_blob(ref_->stmt(), col); |
| 258 | } |
| 259 | |
| 260 | bool Statement::ColumnBlobAsString(int col, std::string* blob) { |
| 261 | if (!CheckValid()) |
| 262 | return false; |
| 263 | |
| 264 | const void* p = ColumnBlob(col); |
| 265 | size_t len = ColumnByteLength(col); |
| 266 | blob->resize(len); |
| 267 | if (blob->size() != len) { |
| 268 | return false; |
| 269 | } |
| 270 | blob->assign(reinterpret_cast<const char*>(p), len); |
| 271 | return true; |
| 272 | } |
| 273 | |
| 274 | bool Statement::ColumnBlobAsString16(int col, string16* val) const { |
| 275 | if (!CheckValid()) |
| 276 | return false; |
| 277 | |
| 278 | const void* data = ColumnBlob(col); |
| 279 | size_t len = ColumnByteLength(col) / sizeof(char16); |
| 280 | val->resize(len); |
| 281 | if (val->size() != len) |
| 282 | return false; |
| 283 | val->assign(reinterpret_cast<const char16*>(data), len); |
| 284 | return true; |
| 285 | } |
| 286 | |
| 287 | bool Statement::ColumnBlobAsVector(int col, std::vector<char>* val) const { |
| 288 | val->clear(); |
| 289 | |
| 290 | if (!CheckValid()) |
| 291 | return false; |
| 292 | |
| 293 | const void* data = sqlite3_column_blob(ref_->stmt(), col); |
| 294 | int len = sqlite3_column_bytes(ref_->stmt(), col); |
| 295 | if (data && len > 0) { |
| 296 | val->resize(len); |
| 297 | memcpy(&(*val)[0], data, len); |
| 298 | } |
| 299 | return true; |
| 300 | } |
| 301 | |
| 302 | bool Statement::ColumnBlobAsVector( |
| 303 | int col, |
| 304 | std::vector<unsigned char>* val) const { |
| 305 | return ColumnBlobAsVector(col, reinterpret_cast< std::vector<char>* >(val)); |
| 306 | } |
| 307 | |
| 308 | const char* Statement::GetSQLStatement() { |
| 309 | return sqlite3_sql(ref_->stmt()); |
| 310 | } |
| 311 | |
| 312 | bool Statement::CheckOk(int err) const { |
| 313 | // Binding to a non-existent variable is evidence of a serious error. |
| 314 | // TODO(gbillock,shess): make this invalidate the statement so it |
| 315 | // can't wreak havoc. |
| 316 | if (err == SQLITE_RANGE) |
| 317 | DLOG(FATAL) << "Bind value out of range"; |
| 318 | return err == SQLITE_OK; |
| 319 | } |
| 320 | |
| 321 | int Statement::CheckError(int err) { |
| 322 | // Please don't add DCHECKs here, OnSqliteError() already has them. |
| 323 | succeeded_ = (err == SQLITE_OK || err == SQLITE_ROW || err == SQLITE_DONE); |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 324 | if (!succeeded_ && ref_.get() && ref_->connection()) |
Torne (Richard Coles) | 4e180b6 | 2013-10-18 15:46:22 +0100 | [diff] [blame] | 325 | return ref_->connection()->OnSqliteError(err, this, NULL); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 326 | return err; |
| 327 | } |
| 328 | |
| 329 | } // namespace sql |