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   nsDependentString path(
 178       reinterpret_cast<const char16_t*>(::sqlite3_value_text16(aArgv[0])));
 179
 180   nsresult rv = cursor->Init(path);
 181   NS_ENSURE_SUCCESS(rv, SQLITE_ERROR);
 182
 183   return SQLITE_OK;
 184 }
 185
 186 int Next(sqlite3_vtab_cursor* aCursor) {
 187   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 188
 189   nsresult rv = cursor->NextFile();
 190   NS_ENSURE_SUCCESS(rv, SQLITE_ERROR);
 191
 192   return SQLITE_OK;
 193 }
 194
 195 int Eof(sqlite3_vtab_cursor* aCursor) {
 196   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 197   return cursor->CurrentFileName().IsVoid() ? 1 : 0;
 198 }
 199
 200 int Column(sqlite3_vtab_cursor* aCursor, sqlite3_context* aContext,
 201            int aColumnIndex) {
 202   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 203
 204   switch (aColumnIndex) {
 205     // name
 206     case 0: {
 207       const nsString& name = cursor->CurrentFileName();
 208       sqlite3_result_text16(aContext, name.get(),
 209                             name.Length() * sizeof(char16_t), SQLITE_TRANSIENT);
 210       break;
 211     }
 212
 213     // path
 214     case 1: {
 215       const nsString& path = cursor->DirectoryPath();
 216       sqlite3_result_text16(aContext, path.get(),
 217                             path.Length() * sizeof(char16_t), SQLITE_TRANSIENT);
 218       break;
 219     }
 220     default:
 221       MOZ_ASSERT_UNREACHABLE("Unsupported column!");
 222   }
 223
 224   return SQLITE_OK;
 225 }
 226
 227 int RowId(sqlite3_vtab_cursor* aCursor, sqlite3_int64* aRowid) {
 228   VirtualTableCursor* cursor = reinterpret_cast<VirtualTableCursor*>(aCursor);
 229
 230   *aRowid = cursor->RowId();
 231
 232   return SQLITE_OK;
 233 }
 234
 235 }  // namespace
 236
 237 namespace mozilla {
 238 namespace storage {
 239
 240 int RegisterFileSystemModule(sqlite3* aDB, const char* aName) {
 241   static sqlite3_module module = {
 242       1,       Connect, Connect, BestIndex, Disconnect, Disconnect, Open,
 243       Close,   Filter,  Next,    Eof,       Column,     RowId,      nullptr,
 244       nullptr, nullptr, nullptr, nullptr,   nullptr,    nullptr};
 245
 246   return sqlite3_create_module(aDB, aName, &module, nullptr);
 247 }
 248
 249 }  // namespace storage
 250 }  // namespace mozilla