sql/statement.cc

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