full text compound indexes

Author: dplewis

spec/ParseQuery.FullTextSearch.spec.js

@@ -31,7 +31,8 @@ const fullTextHelper = () => {
     const request = {
       method: "POST",
       body: {
-        subject: subjects[i]
+        subject: subjects[i],
+        comment: subjects[i],
       },
       path: "/1/classes/TestObject"
     };
@@ -280,42 +281,69 @@ describe('Parse.Query Full Text Search testing', () => {
 });
 
 describe_only_db('mongo')('Parse.Query Full Text Search testing', () => {
-  it('fullTextSearch: $search, only one text index', (done) => {
-    return reconfigureServer({
-      appId: 'test',
-      restAPIKey: 'test',
-      publicServerURL: 'http://localhost:8378/1',
-      databaseAdapter: new MongoStorageAdapter({ uri: mongoURI })
+  it('fullTextSearch: does not create text index if compound index exist', (done) => {
+    fullTextHelper().then(() => {
+      return databaseAdapter.dropAllIndexes('TestObject');
     }).then(() => {
-      return rp.post({
-        url: 'http://localhost:8378/1/batch',
-        body: {
-          requests: [
-            {
-              method: "POST",
-              body: {
-                subject: "coffee is java"
-              },
-              path: "/1/classes/TestObject"
-            },
-            {
-              method: "POST",
-              body: {
-                subject: "java is coffee"
-              },
-              path: "/1/classes/TestObject"
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(1);
+      return databaseAdapter.createIndex('TestObject', {subject: 'text', comment: 'text'});
+    }).then(() => {
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(2);
+      const where = {
+        subject: {
+          $text: {
+            $search: {
+              $term: 'coffee'
             }
-          ]
-        },
-        json: true,
+          }
+        }
+      };
+      return rp.post({
+        url: 'http://localhost:8378/1/classes/TestObject',
+        json: { where, '_method': 'GET' },
         headers: {
           'X-Parse-Application-Id': 'test',
           'X-Parse-REST-API-Key': 'test'
         }
       });
+    }).then((resp) => {
+      expect(resp.results.length).toEqual(3);
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(2);
+      done();
+    }).catch(done.fail);
+  });
+
+  it('fullTextSearch: does not create text index if schema compound index exist', (done) => {
+    fullTextHelper().then(() => {
+      return databaseAdapter.dropAllIndexes('TestObject');
     }).then(() => {
-      return databaseAdapter.createIndex('TestObject', {random: 'text'});
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(1);
+      return rp.put({
+        url: 'http://localhost:8378/1/schemas/TestObject',
+        json: true,
+        headers: {
+          'X-Parse-Application-Id': 'test',
+          'X-Parse-REST-API-Key': 'test',
+          'X-Parse-Master-Key': 'test',
+        },
+        body: {
+          indexes: {
+            text_test: { subject: 'text', comment: 'text'},
+          },
+        },
+      });
     }).then(() => {
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(2);
       const where = {
         subject: {
           $text: {
@@ -334,12 +362,12 @@ describe_only_db('mongo')('Parse.Query Full Text Search testing', () => {
         }
       });
     }).then((resp) => {
-      fail(`Should not be more than one text index: ${JSON.stringify(resp)}`);
-      done();
-    }).catch((err) => {
-      expect(err.error.code).toEqual(Parse.Error.INTERNAL_SERVER_ERROR);
+      expect(resp.results.length).toEqual(3);
+      return databaseAdapter.getIndexes('TestObject');
+    }).then((indexes) => {
+      expect(indexes.length).toEqual(2);
       done();
-    });
+    }).catch(done.fail);
   });
 
   it('fullTextSearch: $diacriticSensitive - false', (done) => {

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -401,7 +401,7 @@ export class MongoStorageAdapter {
     }, {});
 
     readPreference = this._parseReadPreference(readPreference);
-    return this.createTextIndexesIfNeeded(className, query)
+    return this.createTextIndexesIfNeeded(className, query, schema)
       .then(() => this._adaptiveCollection(className))
       .then(collection => collection.find(mongoWhere, {
         skip,
@@ -503,20 +503,27 @@ export class MongoStorageAdapter {
     return Promise.resolve();
   }
 
-  createTextIndexesIfNeeded(className, query) {
+  createTextIndexesIfNeeded(className, query, schema) {
     for(const fieldName in query) {
       if (!query[fieldName] || !query[fieldName].$text) {
         continue;
       }
-      const index = {
-        [fieldName]: 'text'
+      const existingIndexes = schema.indexes;
+      for (const key in existingIndexes) {
+        const index = existingIndexes[key];
+        if (index.hasOwnProperty(fieldName)) {
+          return Promise.resolve();
+        }
+      }
+      const indexName = `${fieldName}_text`;
+      const textIndex = {
+        [indexName]: { [fieldName]: 'text' }
       };
-      return this.createIndex(className, index)
+      return this.setIndexes(className, textIndex, existingIndexes, schema.fields)
         .catch((error) => {
-          if (error.code === 85) {
-            throw new Parse.Error(
-              Parse.Error.INTERNAL_SERVER_ERROR,
-              'Only one text index is supported, please delete all text indexes to use new field.');
+          if (error.code === 85) { // Index exist with different options
+            return this.getIndexes(className)
+              .then((indexes) => this.setIndexes(className, {}, indexes, schema.fields));
           }
           throw error;
         });
@@ -533,6 +540,11 @@ export class MongoStorageAdapter {
     return this._adaptiveCollection(className)
       .then(collection => collection._mongoCollection.dropIndex(index));
   }
+
+  dropAllIndexes(className) {
+    return this._adaptiveCollection(className)
+      .then(collection => collection._mongoCollection.dropIndexes());
+  }
 }
 
 export default MongoStorageAdapter;

src/Adapters/Storage/Postgres/PostgresStorageAdapter.js

@@ -1457,29 +1457,23 @@ export class PostgresStorageAdapter {
     return conn.tx(t => {
       const batch = [];
       indexes.forEach((index) => {
-        const pattern = Object.keys(index.key).map((key) => `"${key}"`);
-        const qs = t.none(`CREATE INDEX ${index.name} ON "${className}" (${pattern.join(',')})`);
+        const fieldNames = Object.keys(index.key);
+        const pattern = fieldNames.map((key, index) => `$${index + 3}:name`);
+        const qs = t.none(`CREATE INDEX $1:name ON $2:name (${pattern.join(',')})`, [index.name, className, ...fieldNames]);
         batch.push(qs);
       });
       return t.batch(batch);
-    })
+    });
   }
 
   dropIndexes(className, indexes, conn) {
     conn = conn || this._client;
-    return conn.tx(t => {
-      const batch = [];
-      indexes.forEach((index) => {
-        const qs = t.none(`DROP INDEX ${index}`);
-        batch.push(qs);
-      });
-      return t.batch(batch);
-    })
+    return conn.tx(t => t.batch(indexes.map(i => t.none('DROP INDEX $1:name', i))));
   }
 
   getIndexes(className) {
-    const qs = `SELECT * FROM pg_indexes WHERE tablename = '${className}'`;
-    return this._client.any(qs, []);
+    const qs = 'SELECT * FROM pg_indexes WHERE tablename = ${className}';
+    return this._client.any(qs, {className});
   }
 }