storage/src/mozStorageStatement.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Oracle Corporation code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  *  Oracle Corporation
  20  * Portions created by the Initial Developer are Copyright (C) 2004
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Vladimir Vukicevic <vladimir.vukicevic@oracle.com>
  25  *   Shawn Wilsher <me@shawnwilsher.com>
  26  *   John Zhang <jzhang@aptana.com>
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either the GNU General Public License Version 2 or later (the "GPL"), or
  30  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  * ***** END LICENSE BLOCK ***** */
  41
  42 #include <limits.h>
  43 #include <stdio.h>
  44
  45 #include "nsError.h"
  46 #include "nsMemory.h"
  47 #include "nsThreadUtils.h"
  48 #include "nsIClassInfoImpl.h"
  49 #include "nsIProgrammingLanguage.h"
  50 #include "Variant.h"
  51
  52 #include "mozIStorageError.h"
  53
  54 #include "mozStorageBindingParams.h"
  55 #include "mozStorageConnection.h"
  56 #include "mozStorageStatementJSHelper.h"
  57 #include "mozStoragePrivateHelpers.h"
  58 #include "mozStorageStatementParams.h"
  59 #include "mozStorageStatementRow.h"
  60 #include "mozStorageStatement.h"
  61
  62 #include "prlog.h"
  63
  64 #include "mozilla/FunctionTimer.h"
  65
  66 #ifdef PR_LOGGING
  67 extern PRLogModuleInfo* gStorageLog;
  68 #endif
  69
  70 namespace mozilla {
  71 namespace storage {
  72
  73 ////////////////////////////////////////////////////////////////////////////////
  74 //// nsIClassInfo
  75
  76 NS_IMPL_CI_INTERFACE_GETTER5(
  77   Statement,
  78   mozIStorageStatement,
  79   mozIStorageBaseStatement,
  80   mozIStorageBindingParams,
  81   mozIStorageValueArray,
  82   mozilla::storage::StorageBaseStatementInternal
  83 )
  84
  85 class StatementClassInfo : public nsIClassInfo
  86 {
  87 public:
  88   NS_DECL_ISUPPORTS
  89
  90   NS_IMETHODIMP
  91   GetInterfaces(PRUint32 *_count, nsIID ***_array)
  92   {
  93     return NS_CI_INTERFACE_GETTER_NAME(Statement)(_count, _array);
  94   }
  95
  96   NS_IMETHODIMP
  97   GetHelperForLanguage(PRUint32 aLanguage, nsISupports **_helper)
  98   {
  99     if (aLanguage == nsIProgrammingLanguage::JAVASCRIPT) {
 100       static StatementJSHelper sJSHelper;
 101       *_helper = &sJSHelper;
 102       return NS_OK;
 103     }
 104
 105     *_helper = nsnull;
 106     return NS_OK;
 107   }
 108
 109   NS_IMETHODIMP
 110   GetContractID(char **_contractID)
 111   {
 112     *_contractID = nsnull;
 113     return NS_OK;
 114   }
 115
 116   NS_IMETHODIMP
 117   GetClassDescription(char **_desc)
 118   {
 119     *_desc = nsnull;
 120     return NS_OK;
 121   }
 122
 123   NS_IMETHODIMP
 124   GetClassID(nsCID **_id)
 125   {
 126     *_id = nsnull;
 127     return NS_OK;
 128   }
 129
 130   NS_IMETHODIMP
 131   GetImplementationLanguage(PRUint32 *_language)
 132   {
 133     *_language = nsIProgrammingLanguage::CPLUSPLUS;
 134     return NS_OK;
 135   }
 136
 137   NS_IMETHODIMP
 138   GetFlags(PRUint32 *_flags)
 139   {
 140     *_flags = nsnull;
 141     return NS_OK;
 142   }
 143
 144   NS_IMETHODIMP
 145   GetClassIDNoAlloc(nsCID *_cid)
 146   {
 147     return NS_ERROR_NOT_AVAILABLE;
 148   }
 149 };
 150
 151 NS_IMETHODIMP_(nsrefcnt) StatementClassInfo::AddRef() { return 2; }
 152 NS_IMETHODIMP_(nsrefcnt) StatementClassInfo::Release() { return 1; }
 153 NS_IMPL_QUERY_INTERFACE1(StatementClassInfo, nsIClassInfo)
 154
 155 static StatementClassInfo sStatementClassInfo;
 156
 157 ////////////////////////////////////////////////////////////////////////////////
 158 //// Statement
 159
 160 Statement::Statement()
 161 : StorageBaseStatementInternal()
 162 , mDBStatement(NULL)
 163 , mColumnNames()
 164 , mExecuting(false)
 165 {
 166 }
 167
 168 nsresult
 169 Statement::initialize(Connection *aDBConnection,
 170                       const nsACString &aSQLStatement)
 171 {
 172   NS_ASSERTION(aDBConnection, "No database connection given!");
 173   NS_ASSERTION(!mDBStatement, "Statement already initialized!");
 174
 175   sqlite3 *db = aDBConnection->GetNativeConnection();
 176   NS_ASSERTION(db, "We should never be called with a null sqlite3 database!");
 177
 178   int srv = prepareStmt(db, PromiseFlatCString(aSQLStatement), &mDBStatement);
 179   if (srv != SQLITE_OK) {
 180 #ifdef PR_LOGGING
 181       PR_LOG(gStorageLog, PR_LOG_ERROR,
 182              ("Sqlite statement prepare error: %d '%s'", srv,
 183               ::sqlite3_errmsg(db)));
 184       PR_LOG(gStorageLog, PR_LOG_ERROR,
 185              ("Statement was: '%s'", PromiseFlatCString(aSQLStatement).get()));
 186 #endif
 187       return NS_ERROR_FAILURE;
 188     }
 189
 190 #ifdef PR_LOGGING
 191   PR_LOG(gStorageLog, PR_LOG_NOTICE, ("Initialized statement '%s' (0x%p)",
 192                                       PromiseFlatCString(aSQLStatement).get(),
 193                                       mDBStatement));
 194 #endif
 195
 196   mDBConnection = aDBConnection;
 197   mParamCount = ::sqlite3_bind_parameter_count(mDBStatement);
 198   mResultColumnCount = ::sqlite3_column_count(mDBStatement);
 199   mColumnNames.Clear();
 200
 201   for (PRUint32 i = 0; i < mResultColumnCount; i++) {
 202       const char *name = ::sqlite3_column_name(mDBStatement, i);
 203       (void)mColumnNames.AppendElement(nsDependentCString(name));
 204   }
 205
 206 #ifdef DEBUG
 207   // We want to try and test for LIKE and that consumers are using
 208   // escapeStringForLIKE instead of just trusting user input.  The idea to
 209   // check to see if they are binding a parameter after like instead of just
 210   // using a string.  We only do this in debug builds because it's expensive!
 211   const nsCaseInsensitiveCStringComparator c;
 212   nsACString::const_iterator start, end, e;
 213   aSQLStatement.BeginReading(start);
 214   aSQLStatement.EndReading(end);
 215   e = end;
 216   while (::FindInReadable(NS_LITERAL_CSTRING(" LIKE"), start, e, c)) {
 217     // We have a LIKE in here, so we perform our tests
 218     // FindInReadable moves the iterator, so we have to get a new one for
 219     // each test we perform.
 220     nsACString::const_iterator s1, s2, s3;
 221     s1 = s2 = s3 = start;
 222
 223     if (!(::FindInReadable(NS_LITERAL_CSTRING(" LIKE ?"), s1, end, c) ||
 224           ::FindInReadable(NS_LITERAL_CSTRING(" LIKE :"), s2, end, c) ||
 225           ::FindInReadable(NS_LITERAL_CSTRING(" LIKE @"), s3, end, c))) {
 226       // At this point, we didn't find a LIKE statement followed by ?, :,
 227       // or @, all of which are valid characters for binding a parameter.
 228       // We will warn the consumer that they may not be safely using LIKE.
 229       NS_WARNING("Unsafe use of LIKE detected!  Please ensure that you "
 230                  "are using mozIStorageStatement::escapeStringForLIKE "
 231                  "and that you are binding that result to the statement "
 232                  "to prevent SQL injection attacks.");
 233     }
 234
 235     // resetting start and e
 236     start = e;
 237     e = end;
 238   }
 239 #endif
 240
 241   return NS_OK;
 242 }
 243
 244 mozIStorageBindingParams *
 245 Statement::getParams()
 246 {
 247   nsresult rv;
 248
 249   // If we do not have an array object yet, make it.
 250   if (!mParamsArray) {
 251     nsCOMPtr<mozIStorageBindingParamsArray> array;
 252     rv = NewBindingParamsArray(getter_AddRefs(array));
 253     NS_ENSURE_SUCCESS(rv, nsnull);
 254
 255     mParamsArray = static_cast<BindingParamsArray *>(array.get());
 256   }
 257
 258   // If there isn't already any rows added, we'll have to add one to use.
 259   if (mParamsArray->length() == 0) {
 260     nsRefPtr<BindingParams> params(new BindingParams(mParamsArray, this));
 261     NS_ENSURE_TRUE(params, nsnull);
 262
 263     rv = mParamsArray->AddParams(params);
 264     NS_ENSURE_SUCCESS(rv, nsnull);
 265
 266     // We have to unlock our params because AddParams locks them.  This is safe
 267     // because no reference to the params object was, or ever will be given out.
 268     params->unlock(this);
 269
 270     // We also want to lock our array at this point - we don't want anything to
 271     // be added to it.  Nothing has, or will ever get a reference to it, but we
 272     // will get additional safety checks via assertions by doing this.
 273     mParamsArray->lock();
 274   }
 275
 276   return *mParamsArray->begin();
 277 }
 278
 279 Statement::~Statement()
 280 {
 281   (void)internalFinalize(true);
 282 }
 283
 284 ////////////////////////////////////////////////////////////////////////////////
 285 //// nsISupports
 286
 287 NS_IMPL_THREADSAFE_ADDREF(Statement)
 288 NS_IMPL_THREADSAFE_RELEASE(Statement)
 289
 290 NS_INTERFACE_MAP_BEGIN(Statement)
 291   NS_INTERFACE_MAP_ENTRY(mozIStorageStatement)
 292   NS_INTERFACE_MAP_ENTRY(mozIStorageBaseStatement)
 293   NS_INTERFACE_MAP_ENTRY(mozIStorageBindingParams)
 294   NS_INTERFACE_MAP_ENTRY(mozIStorageValueArray)
 295   NS_INTERFACE_MAP_ENTRY(mozilla::storage::StorageBaseStatementInternal)
 296   if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {
 297     foundInterface = static_cast<nsIClassInfo *>(&sStatementClassInfo);
 298   }
 299   else
 300   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageStatement)
 301 NS_INTERFACE_MAP_END
 302
 303
 304 ////////////////////////////////////////////////////////////////////////////////
 305 //// StorageBaseStatementInternal
 306
 307 Connection *
 308 Statement::getOwner()
 309 {
 310   return mDBConnection;
 311 }
 312
 313 int
 314 Statement::getAsyncStatement(sqlite3_stmt **_stmt)
 315 {
 316   // If we have no statement, we shouldn't be calling this method!
 317   NS_ASSERTION(mDBStatement != NULL, "We have no statement to clone!");
 318
 319   // If we do not yet have a cached async statement, clone our statement now.
 320   if (!mAsyncStatement) {
 321     nsDependentCString sql(::sqlite3_sql(mDBStatement));
 322     int rc = prepareStmt(mDBConnection->GetNativeConnection(), sql,
 323                      &mAsyncStatement);
 324     if (rc != SQLITE_OK) {
 325       *_stmt = nsnull;
 326       return rc;
 327     }
 328
 329 #ifdef PR_LOGGING
 330     PR_LOG(gStorageLog, PR_LOG_NOTICE,
 331            ("Cloned statement 0x%p to 0x%p", mDBStatement, mAsyncStatement));
 332 #endif
 333   }
 334
 335   *_stmt = mAsyncStatement;
 336   return SQLITE_OK;
 337 }
 338
 339 nsresult
 340 Statement::getAsynchronousStatementData(StatementData &_data)
 341 {
 342   if (!mDBStatement)
 343     return NS_ERROR_UNEXPECTED;
 344
 345   sqlite3_stmt *stmt;
 346   int rc = getAsyncStatement(&stmt);
 347   if (rc != SQLITE_OK)
 348     return convertResultCode(rc);
 349
 350   _data = StatementData(stmt, bindingParamsArray(), this);
 351
 352   return NS_OK;
 353 }
 354
 355 already_AddRefed<mozIStorageBindingParams>
 356 Statement::newBindingParams(mozIStorageBindingParamsArray *aOwner)
 357 {
 358   nsCOMPtr<mozIStorageBindingParams> params = new BindingParams(aOwner, this);
 359   return params.forget();
 360 }
 361
 362
 363 ////////////////////////////////////////////////////////////////////////////////
 364 //// mozIStorageStatement
 365
 366 // proxy to StorageBaseStatementInternal using its define helper.
 367 MIXIN_IMPL_STORAGEBASESTATEMENTINTERNAL(Statement, (void)0;)
 368
 369 NS_IMETHODIMP
 370 Statement::Clone(mozIStorageStatement **_statement)
 371 {
 372   nsRefPtr<Statement> statement(new Statement());
 373   NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
 374
 375   nsCAutoString sql(::sqlite3_sql(mDBStatement));
 376   nsresult rv = statement->initialize(mDBConnection, sql);
 377   NS_ENSURE_SUCCESS(rv, rv);
 378
 379   statement.forget(_statement);
 380   return NS_OK;
 381 }
 382
 383 NS_IMETHODIMP
 384 Statement::Finalize()
 385 {
 386   return internalFinalize(false);
 387 }
 388
 389 nsresult
 390 Statement::internalFinalize(bool aDestructing)
 391 {
 392   if (!mDBStatement)
 393     return NS_OK;
 394
 395 #ifdef PR_LOGGING
 396   PR_LOG(gStorageLog, PR_LOG_NOTICE, ("Finalizing statement '%s'",
 397                                       ::sqlite3_sql(mDBStatement)));
 398 #endif
 399
 400   int srv = ::sqlite3_finalize(mDBStatement);
 401   mDBStatement = NULL;
 402
 403   if (mAsyncStatement) {
 404     // If the destructor called us, there are no pending async statements (they
 405     // hold a reference to us) and we can/must just kill the statement directly.
 406     if (aDestructing)
 407       destructorAsyncFinalize();
 408     else
 409       asyncFinalize();
 410   }
 411
 412   // We are considered dead at this point, so any wrappers for row or params
 413   // need to lose their reference to us.
 414   if (mStatementParamsHolder) {
 415     nsCOMPtr<nsIXPConnectWrappedNative> wrapper =
 416         do_QueryInterface(mStatementParamsHolder);
 417     nsCOMPtr<mozIStorageStatementParams> iParams =
 418         do_QueryWrappedNative(wrapper);
 419     StatementParams *params = static_cast<StatementParams *>(iParams.get());
 420     params->mStatement = nsnull;
 421     mStatementParamsHolder = nsnull;
 422   }
 423
 424   if (mStatementRowHolder) {
 425     nsCOMPtr<nsIXPConnectWrappedNative> wrapper =
 426         do_QueryInterface(mStatementRowHolder);
 427     nsCOMPtr<mozIStorageStatementRow> iRow =
 428         do_QueryWrappedNative(wrapper);
 429     StatementRow *row = static_cast<StatementRow *>(iRow.get());
 430     row->mStatement = nsnull;
 431     mStatementRowHolder = nsnull;
 432   }
 433
 434   return convertResultCode(srv);
 435 }
 436
 437 NS_IMETHODIMP
 438 Statement::GetParameterCount(PRUint32 *_parameterCount)
 439 {
 440   if (!mDBStatement)
 441     return NS_ERROR_NOT_INITIALIZED;
 442
 443   *_parameterCount = mParamCount;
 444   return NS_OK;
 445 }
 446
 447 NS_IMETHODIMP
 448 Statement::GetParameterName(PRUint32 aParamIndex,
 449                             nsACString &_name)
 450 {
 451   if (!mDBStatement)
 452     return NS_ERROR_NOT_INITIALIZED;
 453   ENSURE_INDEX_VALUE(aParamIndex, mParamCount);
 454
 455   const char *name = ::sqlite3_bind_parameter_name(mDBStatement,
 456                                                    aParamIndex + 1);
 457   if (name == NULL) {
 458     // this thing had no name, so fake one
 459     nsCAutoString name(":");
 460     name.AppendInt(aParamIndex);
 461     _name.Assign(name);
 462   }
 463   else {
 464     _name.Assign(nsDependentCString(name));
 465   }
 466
 467   return NS_OK;
 468 }
 469
 470 NS_IMETHODIMP
 471 Statement::GetParameterIndex(const nsACString &aName,
 472                              PRUint32 *_index)
 473 {
 474   if (!mDBStatement)
 475     return NS_ERROR_NOT_INITIALIZED;
 476
 477   // We do not accept any forms of names other than ":name", but we need to add
 478   // the colon for SQLite.
 479   nsCAutoString name(":");
 480   name.Append(aName);
 481   int ind = ::sqlite3_bind_parameter_index(mDBStatement,
 482                                            PromiseFlatCString(name).get());
 483   if (ind  == 0) // Named parameter not found.
 484     return NS_ERROR_INVALID_ARG;
 485
 486   *_index = ind - 1; // SQLite indexes are 1-based, we are 0-based.
 487
 488   return NS_OK;
 489 }
 490
 491 NS_IMETHODIMP
 492 Statement::GetColumnCount(PRUint32 *_columnCount)
 493 {
 494   if (!mDBStatement)
 495     return NS_ERROR_NOT_INITIALIZED;
 496
 497   *_columnCount = mResultColumnCount;
 498   return NS_OK;
 499 }
 500
 501 NS_IMETHODIMP
 502 Statement::GetColumnName(PRUint32 aColumnIndex,
 503                          nsACString &_name)
 504 {
 505   if (!mDBStatement)
 506     return NS_ERROR_NOT_INITIALIZED;
 507   ENSURE_INDEX_VALUE(aColumnIndex, mResultColumnCount);
 508
 509   const char *cname = ::sqlite3_column_name(mDBStatement, aColumnIndex);
 510   _name.Assign(nsDependentCString(cname));
 511
 512   return NS_OK;
 513 }
 514
 515 NS_IMETHODIMP
 516 Statement::GetColumnIndex(const nsACString &aName,
 517                           PRUint32 *_index)
 518 {
 519   if (!mDBStatement)
 520       return NS_ERROR_NOT_INITIALIZED;
 521
 522   // Surprisingly enough, SQLite doesn't provide an API for this.  We have to
 523   // determine it ourselves sadly.
 524   for (PRUint32 i = 0; i < mResultColumnCount; i++) {
 525     if (mColumnNames[i].Equals(aName)) {
 526       *_index = i;
 527       return NS_OK;
 528     }
 529   }
 530
 531   return NS_ERROR_INVALID_ARG;
 532 }
 533
 534 NS_IMETHODIMP
 535 Statement::Reset()
 536 {
 537   if (!mDBStatement)
 538     return NS_ERROR_NOT_INITIALIZED;
 539
 540 #ifdef DEBUG
 541   PR_LOG(gStorageLog, PR_LOG_DEBUG, ("Resetting statement: '%s'",
 542                                      ::sqlite3_sql(mDBStatement)));
 543
 544   checkAndLogStatementPerformance(mDBStatement);
 545 #endif
 546
 547   mParamsArray = nsnull;
 548   (void)sqlite3_reset(mDBStatement);
 549   (void)sqlite3_clear_bindings(mDBStatement);
 550
 551   mExecuting = false;
 552
 553   return NS_OK;
 554 }
 555
 556 NS_IMETHODIMP
 557 Statement::BindParameters(mozIStorageBindingParamsArray *aParameters)
 558 {
 559   if (!mDBStatement)
 560     return NS_ERROR_NOT_INITIALIZED;
 561
 562   BindingParamsArray *array = static_cast<BindingParamsArray *>(aParameters);
 563   if (array->getOwner() != this)
 564     return NS_ERROR_UNEXPECTED;
 565
 566   if (array->length() == 0)
 567     return NS_ERROR_UNEXPECTED;
 568
 569   mParamsArray = array;
 570   mParamsArray->lock();
 571
 572   return NS_OK;
 573 }
 574
 575 NS_IMETHODIMP
 576 Statement::Execute()
 577 {
 578   if (!mDBStatement)
 579     return NS_ERROR_NOT_INITIALIZED;
 580
 581   PRBool ret;
 582   nsresult rv = ExecuteStep(&ret);
 583   nsresult rv2 = Reset();
 584
 585   return NS_FAILED(rv) ? rv : rv2;
 586 }
 587
 588 NS_IMETHODIMP
 589 Statement::ExecuteStep(PRBool *_moreResults)
 590 {
 591   if (!mDBStatement)
 592     return NS_ERROR_NOT_INITIALIZED;
 593
 594   NS_TIME_FUNCTION_MIN_FMT(5, "mozIStorageStatement::ExecuteStep(%s) (0x%p)",
 595                            mDBConnection->getFilename().get(), mDBStatement);
 596
 597   // Bind any parameters first before executing.
 598   if (mParamsArray) {
 599     // If we have more than one row of parameters to bind, they shouldn't be
 600     // calling this method (and instead use executeAsync).
 601     if (mParamsArray->length() != 1)
 602       return NS_ERROR_UNEXPECTED;
 603
 604     BindingParamsArray::iterator row = mParamsArray->begin();
 605     nsCOMPtr<IStorageBindingParamsInternal> bindingInternal =
 606       do_QueryInterface(*row);
 607     nsCOMPtr<mozIStorageError> error = bindingInternal->bind(mDBStatement);
 608     if (error) {
 609       PRInt32 srv;
 610       (void)error->GetResult(&srv);
 611       return convertResultCode(srv);
 612     }
 613
 614     // We have bound, so now we can clear our array.
 615     mParamsArray = nsnull;
 616   }
 617   int srv = stepStmt(mDBStatement);
 618
 619 #ifdef PR_LOGGING
 620   if (srv != SQLITE_ROW && srv != SQLITE_DONE) {
 621       nsCAutoString errStr;
 622       (void)mDBConnection->GetLastErrorString(errStr);
 623       PR_LOG(gStorageLog, PR_LOG_DEBUG,
 624              ("Statement::ExecuteStep error: %s", errStr.get()));
 625   }
 626 #endif
 627
 628   // SQLITE_ROW and SQLITE_DONE are non-errors
 629   if (srv == SQLITE_ROW) {
 630     // we got a row back
 631     mExecuting = true;
 632     *_moreResults = PR_TRUE;
 633     return NS_OK;
 634   }
 635   else if (srv == SQLITE_DONE) {
 636     // statement is done (no row returned)
 637     mExecuting = false;
 638     *_moreResults = PR_FALSE;
 639     return NS_OK;
 640   }
 641   else if (srv == SQLITE_BUSY || srv == SQLITE_MISUSE) {
 642     mExecuting = PR_FALSE;
 643   }
 644   else if (mExecuting) {
 645 #ifdef PR_LOGGING
 646     PR_LOG(gStorageLog, PR_LOG_ERROR,
 647            ("SQLite error after mExecuting was true!"));
 648 #endif
 649     mExecuting = PR_FALSE;
 650   }
 651
 652   return convertResultCode(srv);
 653 }
 654
 655 NS_IMETHODIMP
 656 Statement::GetState(PRInt32 *_state)
 657 {
 658   if (!mDBStatement)
 659     *_state = MOZ_STORAGE_STATEMENT_INVALID;
 660   else if (mExecuting)
 661     *_state = MOZ_STORAGE_STATEMENT_EXECUTING;
 662   else
 663     *_state = MOZ_STORAGE_STATEMENT_READY;
 664
 665   return NS_OK;
 666 }
 667
 668 NS_IMETHODIMP
 669 Statement::GetColumnDecltype(PRUint32 aParamIndex,
 670                              nsACString &_declType)
 671 {
 672   if (!mDBStatement)
 673     return NS_ERROR_NOT_INITIALIZED;
 674
 675   ENSURE_INDEX_VALUE(aParamIndex, mResultColumnCount);
 676
 677   _declType.Assign(::sqlite3_column_decltype(mDBStatement, aParamIndex));
 678   return NS_OK;
 679 }
 680
 681 ////////////////////////////////////////////////////////////////////////////////
 682 //// mozIStorageValueArray (now part of mozIStorageStatement too)
 683
 684 NS_IMETHODIMP
 685 Statement::GetNumEntries(PRUint32 *_length)
 686 {
 687   *_length = mResultColumnCount;
 688   return NS_OK;
 689 }
 690
 691 NS_IMETHODIMP
 692 Statement::GetTypeOfIndex(PRUint32 aIndex,
 693                           PRInt32 *_type)
 694 {
 695   if (!mDBStatement)
 696     return NS_ERROR_NOT_INITIALIZED;
 697
 698   ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
 699
 700   if (!mExecuting)
 701     return NS_ERROR_UNEXPECTED;
 702
 703   int t = ::sqlite3_column_type(mDBStatement, aIndex);
 704   switch (t) {
 705     case SQLITE_INTEGER:
 706       *_type = mozIStorageStatement::VALUE_TYPE_INTEGER;
 707       break;
 708     case SQLITE_FLOAT:
 709       *_type = mozIStorageStatement::VALUE_TYPE_FLOAT;
 710       break;
 711     case SQLITE_TEXT:
 712       *_type = mozIStorageStatement::VALUE_TYPE_TEXT;
 713       break;
 714     case SQLITE_BLOB:
 715       *_type = mozIStorageStatement::VALUE_TYPE_BLOB;
 716       break;
 717     case SQLITE_NULL:
 718       *_type = mozIStorageStatement::VALUE_TYPE_NULL;
 719       break;
 720     default:
 721       return NS_ERROR_FAILURE;
 722   }
 723
 724   return NS_OK;
 725 }
 726
 727 NS_IMETHODIMP
 728 Statement::GetInt32(PRUint32 aIndex,
 729                     PRInt32 *_value)
 730 {
 731   if (!mDBStatement)
 732     return NS_ERROR_NOT_INITIALIZED;
 733
 734   ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
 735
 736   if (!mExecuting)
 737     return NS_ERROR_UNEXPECTED;
 738
 739   *_value = ::sqlite3_column_int(mDBStatement, aIndex);
 740   return NS_OK;
 741 }
 742
 743 NS_IMETHODIMP
 744 Statement::GetInt64(PRUint32 aIndex,
 745                     PRInt64 *_value)
 746 {
 747   if (!mDBStatement)
 748     return NS_ERROR_NOT_INITIALIZED;
 749
 750   ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
 751
 752   if (!mExecuting)
 753     return NS_ERROR_UNEXPECTED;
 754
 755   *_value = ::sqlite3_column_int64(mDBStatement, aIndex);
 756
 757   return NS_OK;
 758 }
 759
 760 NS_IMETHODIMP
 761 Statement::GetDouble(PRUint32 aIndex,
 762                      double *_value)
 763 {
 764   if (!mDBStatement)
 765     return NS_ERROR_NOT_INITIALIZED;
 766
 767   ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
 768
 769   if (!mExecuting)
 770     return NS_ERROR_UNEXPECTED;
 771
 772   *_value = ::sqlite3_column_double(mDBStatement, aIndex);
 773
 774   return NS_OK;
 775 }
 776
 777 NS_IMETHODIMP
 778 Statement::GetUTF8String(PRUint32 aIndex,
 779                          nsACString &_value)
 780 {
 781   // Get type of Index will check aIndex for us, so we don't have to.
 782   PRInt32 type;
 783   nsresult rv = GetTypeOfIndex(aIndex, &type);
 784   NS_ENSURE_SUCCESS(rv, rv);
 785   if (type == mozIStorageStatement::VALUE_TYPE_NULL) {
 786     // NULL columns should have IsVoid set to distinguish them from the empty
 787     // string.
 788     _value.Truncate(0);
 789     _value.SetIsVoid(PR_TRUE);
 790   }
 791   else {
 792     const char *value =
 793       reinterpret_cast<const char *>(::sqlite3_column_text(mDBStatement,
 794                                                            aIndex));
 795     _value.Assign(value, ::sqlite3_column_bytes(mDBStatement, aIndex));
 796   }
 797   return NS_OK;
 798 }
 799
 800 NS_IMETHODIMP
 801 Statement::GetString(PRUint32 aIndex,
 802                      nsAString &_value)
 803 {
 804   // Get type of Index will check aIndex for us, so we don't have to.
 805   PRInt32 type;
 806   nsresult rv = GetTypeOfIndex(aIndex, &type);
 807   NS_ENSURE_SUCCESS(rv, rv);
 808   if (type == mozIStorageStatement::VALUE_TYPE_NULL) {
 809     // NULL columns should have IsVoid set to distinguish them from the empty
 810     // string.
 811     _value.Truncate(0);
 812     _value.SetIsVoid(PR_TRUE);
 813   } else {
 814     const PRUnichar *value =
 815       static_cast<const PRUnichar *>(::sqlite3_column_text16(mDBStatement,
 816                                                              aIndex));
 817     _value.Assign(value, ::sqlite3_column_bytes16(mDBStatement, aIndex) / 2);
 818   }
 819   return NS_OK;
 820 }
 821
 822 NS_IMETHODIMP
 823 Statement::GetBlob(PRUint32 aIndex,
 824                    PRUint32 *_size,
 825                    PRUint8 **_blob)
 826 {
 827   if (!mDBStatement)
 828     return NS_ERROR_NOT_INITIALIZED;
 829
 830   ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
 831
 832   if (!mExecuting)
 833      return NS_ERROR_UNEXPECTED;
 834
 835   int size = ::sqlite3_column_bytes(mDBStatement, aIndex);
 836   void *blob = nsnull;
 837   if (size) {
 838     blob = nsMemory::Clone(::sqlite3_column_blob(mDBStatement, aIndex), size);
 839     NS_ENSURE_TRUE(blob, NS_ERROR_OUT_OF_MEMORY);
 840   }
 841
 842   *_blob = static_cast<PRUint8 *>(blob);
 843   *_size = size;
 844   return NS_OK;
 845 }
 846
 847 NS_IMETHODIMP
 848 Statement::GetSharedUTF8String(PRUint32 aIndex,
 849                                PRUint32 *_length,
 850                                const char **_value)
 851 {
 852   if (_length)
 853     *_length = ::sqlite3_column_bytes(mDBStatement, aIndex);
 854
 855   *_value = reinterpret_cast<const char *>(::sqlite3_column_text(mDBStatement,
 856                                                                  aIndex));
 857   return NS_OK;
 858 }
 859
 860 NS_IMETHODIMP
 861 Statement::GetSharedString(PRUint32 aIndex,
 862                            PRUint32 *_length,
 863                            const PRUnichar **_value)
 864 {
 865   if (_length)
 866     *_length = ::sqlite3_column_bytes16(mDBStatement, aIndex);
 867
 868   *_value = static_cast<const PRUnichar *>(::sqlite3_column_text16(mDBStatement,
 869                                                                    aIndex));
 870   return NS_OK;
 871 }
 872
 873 NS_IMETHODIMP
 874 Statement::GetSharedBlob(PRUint32 aIndex,
 875                          PRUint32 *_size,
 876                          const PRUint8 **_blob)
 877 {
 878   *_size = ::sqlite3_column_bytes(mDBStatement, aIndex);
 879   *_blob = static_cast<const PRUint8 *>(::sqlite3_column_blob(mDBStatement,
 880                                                               aIndex));
 881   return NS_OK;
 882 }
 883
 884 NS_IMETHODIMP
 885 Statement::GetIsNull(PRUint32 aIndex,
 886                      PRBool *_isNull)
 887 {
 888   // Get type of Index will check aIndex for us, so we don't have to.
 889   PRInt32 type;
 890   nsresult rv = GetTypeOfIndex(aIndex, &type);
 891   NS_ENSURE_SUCCESS(rv, rv);
 892   *_isNull = (type == mozIStorageStatement::VALUE_TYPE_NULL);
 893   return NS_OK;
 894 }
 895
 896 ////////////////////////////////////////////////////////////////////////////////
 897 //// mozIStorageBindingParams
 898
 899 BOILERPLATE_BIND_PROXIES(
 900   Statement,
 901   if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
 902 )
 903
 904 } // namespace storage
 905 } // namespace mozilla