storage/FileSystemModule.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  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "FileSystemModule.h"
   8
   9 #include "sqlite3.h"
  10 #include "nsString.h"
  11 #include "nsIDirectoryEnumerator.h"
  12 #include "nsIFile.h"
  13
  14 namespace {
  15
  16 struct VirtualTableCursorBase {
  17   VirtualTableCursorBase() { memset(&mBase, 0, sizeof(mBase)); }
  18
  19   sqlite3_vtab_cursor mBase;
  20 };
  21
  22 struct VirtualTableCursor : public VirtualTableCursorBase {
  23  public:
  24   VirtualTableCursor() : mRowId(-1) { mCurrentFileName.SetIsVoid(true); }
  25
  26   const nsString& DirectoryPath() const { return mDirectoryPath; }
  27
  28   const nsString& CurrentFileName() const { return mCurrentFileName; }
  29
  30   int64_t RowId() const { return mRowId; }
  31
  32   nsresult Init(const nsAString& aPath);
  33   nsresult NextFile();
  34
  35  private:
  36   nsCOMPtr<nsIDirectoryEnumerator> mEntries;
  37
  38   nsString mDirectoryPath;
  39   nsString mCurrentFileName;
  40
  41   int64_t mRowId;
  42 };
  43
  44 nsresult VirtualTableCursor::Init(const nsAString& aPath) {
  45   nsCOMPtr<nsIFile> directory = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);
  46   NS_ENSURE_TRUE(directory, NS_ERROR_FAILURE);
  47
  48   nsresult rv = directory->InitWithPath(aPath);
  49   NS_ENSURE_SUCCESS(rv, rv);
  50
  51   rv = directory->GetPath(mDirectoryPath);
  52   NS_ENSURE_SUCCESS(rv, rv);
  53
  54   rv = directory->GetDirectoryEntries(getter_AddRefs(mEntries));
  55   NS_ENSURE_SUCCESS(rv, rv);
  56
  57   rv = NextFile();
  58   NS_ENSURE_SUCCESS(rv, rv);
  59
  60   return NS_OK;
  61 }
  62
  63 nsresult VirtualTableCursor::NextFile() {
  64   bool hasMore;
  65   nsresult rv = mEntries->HasMoreElements(&hasMore);
  66   NS_ENSURE_SUCCESS(rv, rv);
  67
  68   if (!hasMore) {
  69     mCurrentFileName.SetIsVoid(true);
  70     return NS_OK;
  71   }
  72
  73   nsCOMPtr<nsISupports> entry;
  74   rv = mEntries->GetNext(getter_AddRefs(entry));
  75   NS_ENSURE_SUCCESS(rv, rv);
  76
  77   nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
  78   NS_ENSURE_TRUE(file, NS_ERROR_FAILURE);
  79
  80   rv = file->GetLeafName(mCurrentFileName);
  81   NS_ENSURE_SUCCESS(rv, rv);
  82
  83   mRowId++;
  84
  85   return NS_OK;
  86 }
  87
  88 int Connect(sqlite3* aDB, void* aAux, int aArgc, const char* const* aArgv,
  89             sqlite3_vtab** aVtab, char** aErr) {
  90   static const char virtualTableSchema[] =
  91       "CREATE TABLE fs ("
  92       "name TEXT, "
  93       "path TEXT"
  94       ")";
  95
  96   int rc = sqlite3_declare_vtab(aDB, virtualTableSchema);
  97   if (rc != SQLITE_OK) {
  98     return rc;
  99   }
 100
 101   sqlite3_vtab* vt = new sqlite3_vtab();
 102   memset(vt, 0, sizeof(*vt));
 103
 104   *aVtab = vt;
 105
 106   return SQLITE_OK;
 107 }
 108
 109 int Disconnect(sqlite3_vtab* aVtab) {
 110   delete aVtab;
 111
 112   return SQLITE_OK;
 113 }
 114
 115 int BestIndex(sqlite3_vtab* aVtab, sqlite3_index_info* aInfo) {
 116   // Here we specify what index constraints we want to handle. That is, there
 117   // might be some columns with particular constraints in which we can help
 118   // SQLite narrow down the result set.
 119   //
 120   // For example, take the "path = x" where x is a directory. In this case,
 121   // we can narrow our search to just this directory instead of the entire file
 122   // system. This can be a significant optimization. So, we want to handle that
 123   // constraint. To do so, we would look for two specific input conditions:
 124   //
 125   // 1. aInfo->aConstraint[i].iColumn == 1
 126   // 2. aInfo->aConstraint[i].op == SQLITE_INDEX_CONSTRAINT_EQ
 127   //
 128   // The first states that the path column is being used in one of the input
 129   // constraints and the second states that the constraint involves the equal
 130   // operator.
 131   //
 132   // An even more specific search would be for name='xxx', in which case we
 133   // can limit the search to a single file, if it exists.
 134   //
 135   // What we have to do here is look for all of our index searches and select
 136   // the narrowest. We can only pick one, so obviously we want the one that
 137   // is the most specific, which leads to the smallest result set.
 138
 139   for (int i = 0; i < aInfo->nConstraint; i++) {
 140     if (aInfo->aConstraint[i].iColumn == 1 && aInfo->aConstraint[i].usable) {
 141       if (aInfo->aConstraint[i].op & SQLITE_INDEX_CONSTRAINT_EQ) {
 142         aInfo->aConstraintUsage[i].argvIndex = 1;
 143       }
 144       break;
 145     }
 146
 147     // TODO: handle single files (constrained also by the name column)
 148   }
 149
 150   return SQLITE_OK;
 151 }
 152
 153 int Open(sqlite3_vtab* aVtab, sqlite3_vtab_cursor** aCursor) {
 154   VirtualTableCursor* cursor = new VirtualTableCursor();
 155
 156   *aCursor = reinterpret_cast<sqlite3_vtab_cursor*>(cursor);
 157
 158   return SQLITE_OK;
 159 }
 160
 161 int Close(sqlite3_vtab_cursor* aCursor) {
 162   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 163
 164   delete cursor;
 165
 166   return SQLITE_OK;
 167 }
 168
 169 int Filter(sqlite3_vtab_cursor* aCursor, int aIdxNum, const char* aIdxStr,
 170            int aArgc, sqlite3_value** aArgv) {
 171   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 172
 173   if (aArgc <= 0) {
 174     return SQLITE_OK;
 175   }
 176
 177   const char16_t* value =
 178       static_cast<const char16_t*>(::sqlite3_value_text16(aArgv[0]));
 179
 180   nsDependentString path(value,
 181                          ::sqlite3_value_bytes16(aArgv[0]) / sizeof(char16_t));
 182
 183   nsresult rv = cursor->Init(path);
 184   NS_ENSURE_SUCCESS(rv, SQLITE_ERROR);
 185
 186   return SQLITE_OK;
 187 }
 188
 189 int Next(sqlite3_vtab_cursor* aCursor) {
 190   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 191
 192   nsresult rv = cursor->NextFile();
 193   NS_ENSURE_SUCCESS(rv, SQLITE_ERROR);
 194
 195   return SQLITE_OK;
 196 }
 197
 198 int Eof(sqlite3_vtab_cursor* aCursor) {
 199   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 200   return cursor->CurrentFileName().IsVoid() ? 1 : 0;
 201 }
 202
 203 int Column(sqlite3_vtab_cursor* aCursor, sqlite3_context* aContext,
 204            int aColumnIndex) {
 205   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 206
 207   switch (aColumnIndex) {
 208     // name
 209     case 0: {
 210       const nsString& name = cursor->CurrentFileName();
 211       sqlite3_result_text16(aContext, name.get(),
 212                             name.Length() * sizeof(char16_t), SQLITE_TRANSIENT);
 213       break;
 214     }
 215
 216     // path
 217     case 1: {
 218       const nsString& path = cursor->DirectoryPath();
 219       sqlite3_result_text16(aContext, path.get(),
 220                             path.Length() * sizeof(char16_t), SQLITE_TRANSIENT);
 221       break;
 222     }
 223     default:
 224       MOZ_ASSERT_UNREACHABLE("Unsupported column!");
 225   }
 226
 227   return SQLITE_OK;
 228 }
 229
 230 int RowId(sqlite3_vtab_cursor* aCursor, sqlite3_int64* aRowid) {
 231   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 232
 233   *aRowid = cursor->RowId();
 234
 235   return SQLITE_OK;
 236 }
 237
 238 }  // namespace
 239
 240 namespace mozilla {
 241 namespace storage {
 242
 243 int RegisterFileSystemModule(sqlite3* aDB, const char* aName) {
 244   static sqlite3_module module = {
 245       1,       Connect, Connect, BestIndex, Disconnect, Disconnect, Open,
 246       Close,   Filter,  Next,    Eof,       Column,     RowId,      nullptr,
 247       nullptr, nullptr, nullptr, nullptr,   nullptr,    nullptr};
 248
 249   return sqlite3_create_module(aDB, aName, &module, nullptr);
 250 }
 251
 252 }  // namespace storage
 253 }  // namespace mozilla