/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "sqlite3.h"

#include "jsfriendapi.h"

#include "nsPrintfCString.h"

#include "nsString.h"

#include "nsError.h"

#include "mozilla/Mutex.h"

#include "mozilla/CondVar.h"

#include "nsQueryObject.h"

#include "nsThreadUtils.h"

#include "nsJSUtils.h"

#include "Variant.h"

#include "mozStoragePrivateHelpers.h"

#include "mozIStorageStatement.h"

#include "mozIStorageCompletionCallback.h"

#include "mozIStorageBindingParams.h"

#include "mozilla/Logging.h"

extern mozilla::LazyLogModule gStorageLog;

namespace mozilla {

namespace storage {

nsresult

convertResultCode(int aSQLiteResultCode)

{

  // Drop off the extended result bits of the result code.

  int rc = aSQLiteResultCode & 0xFF;

  switch (rc) {

    case SQLITE_OK:

    case SQLITE_ROW:

    case SQLITE_DONE:

      return NS_OK;

    case SQLITE_CORRUPT:

    case SQLITE_NOTADB:

      return NS_ERROR_FILE_CORRUPTED;

    case SQLITE_PERM:

    case SQLITE_CANTOPEN:

      return NS_ERROR_FILE_ACCESS_DENIED;

    case SQLITE_BUSY:

      return NS_ERROR_STORAGE_BUSY;

    case SQLITE_LOCKED:

      return NS_ERROR_FILE_IS_LOCKED;

    case SQLITE_READONLY:

      return NS_ERROR_FILE_READ_ONLY;

    case SQLITE_IOERR:

      return NS_ERROR_STORAGE_IOERR;

    case SQLITE_FULL:

    case SQLITE_TOOBIG:

      return NS_ERROR_FILE_NO_DEVICE_SPACE;

    case SQLITE_NOMEM:

      return NS_ERROR_OUT_OF_MEMORY;

    case SQLITE_MISUSE:

      return NS_ERROR_UNEXPECTED;

    case SQLITE_ABORT:

    case SQLITE_INTERRUPT:

      return NS_ERROR_ABORT;

    case SQLITE_CONSTRAINT:

      return NS_ERROR_STORAGE_CONSTRAINT;

  }

  // generic error

#ifdef DEBUG

  nsAutoCString message;

  message.AppendLiteral("SQLite returned error code ");

  message.AppendInt(rc);

  message.AppendLiteral(" , Storage will convert it to NS_ERROR_FAILURE");

  NS_WARNING_ASSERTION(rc == SQLITE_ERROR, message.get());

#endif

  return NS_ERROR_FAILURE;

}

void

checkAndLogStatementPerformance(sqlite3_stmt *aStatement)

{

  // Check to see if the query performed sorting operations or not.  If it

  // did, it may need to be optimized!

  int count = ::sqlite3_stmt_status(aStatement, SQLITE_STMTSTATUS_SORT, 1);

  if (count <= 0)

    return;

  const char *sql = ::sqlite3_sql(aStatement);

  // Check to see if this is marked to not warn

  if (::strstr(sql, "/* do not warn (bug "))

    return;

  // CREATE INDEX always sorts (sorting is a necessary step in creating

  // an index).  So ignore the warning there.

  if (::strstr(sql, "CREATE INDEX") || ::strstr(sql, "CREATE UNIQUE INDEX"))

    return;

  nsAutoCString message("Suboptimal indexes for the SQL statement ");

#ifdef MOZ_STORAGE_SORTWARNING_SQL_DUMP

  message.Append('`');

  message.Append(sql);

  message.AppendLiteral("` [");

  message.AppendInt(count);

  message.AppendLiteral(" sort operation(s)]");

#else

  nsPrintfCString address("0x%p", aStatement);

  message.Append(address);

#endif

  message.AppendLiteral(" (http://mzl.la/1FuID0j).");

  NS_WARNING(message.get());

}

nsIVariant *

convertJSValToVariant(

  JSContext *aCtx,

  const JS::Value& aValue)

{

  if (aValue.isInt32())

    return new IntegerVariant(aValue.toInt32());

  if (aValue.isDouble())

    return new FloatVariant(aValue.toDouble());

  if (aValue.isString()) {

    nsAutoJSString value;

    if (!value.init(aCtx, aValue.toString()))

        return nullptr;

    return new TextVariant(value);

  }

  if (aValue.isBoolean())

    return new IntegerVariant(aValue.isTrue() ? 1 : 0);

  if (aValue.isNull())

    return new NullVariant();

  if (aValue.isObject()) {

    JS::Rooted<JSObject*> obj(aCtx, &aValue.toObject());

    // We only support Date instances, all others fail.

    bool valid;

    if (!js::DateIsValid(aCtx, obj, &valid) || !valid)

      return nullptr;

    double msecd;

    if (!js::DateGetMsecSinceEpoch(aCtx, obj, &msecd))

      return nullptr;

    msecd *= 1000.0;

    int64_t msec = msecd;

    return new IntegerVariant(msec);

  }

  return nullptr;

}

Variant_base *

convertVariantToStorageVariant(nsIVariant* aVariant)

{

  RefPtr<Variant_base> variant = do_QueryObject(aVariant);

  if (variant) {

    // JS helpers already convert the JS representation to a Storage Variant,

    // in such a case there's nothing left to do here, so just pass-through.

    return variant;

  }

  if (!aVariant)

    return new NullVariant();

  uint16_t dataType;

  nsresult rv = aVariant->GetDataType(&dataType);

  NS_ENSURE_SUCCESS(rv, nullptr);

  switch (dataType) {

    case nsIDataType::VTYPE_BOOL:

    case nsIDataType::VTYPE_INT8:

    case nsIDataType::VTYPE_INT16:

    case nsIDataType::VTYPE_INT32:

    case nsIDataType::VTYPE_UINT8:

    case nsIDataType::VTYPE_UINT16:

    case nsIDataType::VTYPE_UINT32:

    case nsIDataType::VTYPE_INT64:

    case nsIDataType::VTYPE_UINT64: {

      int64_t v;

      rv = aVariant->GetAsInt64(&v);

      NS_ENSURE_SUCCESS(rv, nullptr);

      return new IntegerVariant(v);

    }

    case nsIDataType::VTYPE_FLOAT:

    case nsIDataType::VTYPE_DOUBLE: {

      double v;

      rv = aVariant->GetAsDouble(&v);

      NS_ENSURE_SUCCESS(rv, nullptr);

      return new FloatVariant(v);

    }

    case nsIDataType::VTYPE_CHAR:

    case nsIDataType::VTYPE_CHAR_STR:

    case nsIDataType::VTYPE_STRING_SIZE_IS:

    case nsIDataType::VTYPE_UTF8STRING:

    case nsIDataType::VTYPE_CSTRING: {

      nsCString v;

      rv = aVariant->GetAsAUTF8String(v);

      NS_ENSURE_SUCCESS(rv, nullptr);

      return new UTF8TextVariant(v);

    }

    case nsIDataType::VTYPE_WCHAR:

    case nsIDataType::VTYPE_DOMSTRING:

    case nsIDataType::VTYPE_WCHAR_STR:

    case nsIDataType::VTYPE_WSTRING_SIZE_IS:

    case nsIDataType::VTYPE_ASTRING: {

      nsString v;

      rv = aVariant->GetAsAString(v);

      NS_ENSURE_SUCCESS(rv, nullptr);

      return new TextVariant(v);

    }

    case nsIDataType::VTYPE_ARRAY: {

      uint16_t type;

      nsIID iid;

      uint32_t len;

      void *rawArray;

      // Note this copies the array data.

      rv = aVariant->GetAsArray(&type, &iid, &len, &rawArray);

      NS_ENSURE_SUCCESS(rv, nullptr);

      if (type == nsIDataType::VTYPE_UINT8) {

        std::pair<uint8_t *, int> v(static_cast<uint8_t *>(rawArray), len);

        // Take ownership of the data avoiding a further copy.

        return new AdoptedBlobVariant(v);

      }

      MOZ_FALLTHROUGH;

    }

    case nsIDataType::VTYPE_EMPTY:

    case nsIDataType::VTYPE_EMPTY_ARRAY:

    case nsIDataType::VTYPE_VOID:

      return new NullVariant();

    case nsIDataType::VTYPE_ID:

    case nsIDataType::VTYPE_INTERFACE:

    case nsIDataType::VTYPE_INTERFACE_IS:

    default:

      NS_WARNING("Unsupported variant type");

      return nullptr;

  }

  return nullptr;

}

namespace {

class CallbackEvent : public Runnable

{

public:

  explicit CallbackEvent(mozIStorageCompletionCallback* aCallback)

    : Runnable("storage::CallbackEvent")

    , mCallback(aCallback)

  {

  }

  NS_IMETHOD Run() override

  {

    (void)mCallback->Complete(NS_OK, nullptr);

    return NS_OK;

  }

private:

  nsCOMPtr<mozIStorageCompletionCallback> mCallback;

};

} // namespace

already_AddRefed<nsIRunnable>

newCompletionEvent(mozIStorageCompletionCallback *aCallback)

{

  NS_ASSERTION(aCallback, "Passing a null callback is a no-no!");

  nsCOMPtr<nsIRunnable> event = new CallbackEvent(aCallback);

  return event.forget();

}

} // namespace storage

} // namespace mozilla