Query where "field" == nil

cbaker6 · January 3, 2022, 4:00am

@jayson there’s a PR that will be released in the Swift SDK 3.0.0 that may better address your needs. The details are in the link:

github.com/parse-community/Parse-Swift

feat: Add isNull QueryConstraint and set/foreset null operations

parse-community:main ← cbaker6:null

opened 08:58PM - 02 Jan 22 UTC

cbaker6

+334 -49

### New Pull Request Checklist  - [x] I am not disclosing a [vulnerability](https://github.com/parse-community/Parse-Swift/security/policy). - [x] I am creating this PR in reference to an [issue](https://github.com/parse-community/Parse-Swift/issues?q=is%3Aissue). ### Issue Description - The SDK currently doesn't have the ability to query for `null` or to set a value to `null` on the server. - When the same constraint is added for a query, encoding can be slower since the constraints are saved in array leaving the encoder to encode the same constraint multiple times for no reason. Related issue: #n/a ### Approach - Add the `isNull` and `isNotNull` query constraints along with the ability to set a field to `null` on the server when using operations. **Note** that this is different from querying for `doesNotExist` or using the `Unset` operation which produces `(undefined)` on the server (MongoDB and Postgres) and dashboard. Setting a value to `null` on a Parse Server using MongoDB produces `(null)`. The results from using the `isNull` `QueryConstraint` will yield values that are either `(null)` or `(undefined)`. Using the `doesNotExist` `QueryConstraint` yields results that are only `(undefined)`. Conversely, similar behavior is added for `isNotNull` and `exists`. For Postgres, this doesn't matter, and the counterparts mentioned above produce the same results. For both MongoDB and Postgres, it recommended to setup your databases and query in a way that is efficient for your particular index's and setup. - Improve `QueryWhere` by making at a `Set` of `QueryConstraint`'s instead of any array. This dedupes the same constraint when encoding the query, improving the encoding speed. ### TODOs before merging  - [x] Add tests - [x] Remove `throw` from operation methods which don't need to be thrown - [x] Add entry to changelog - [x] Add changes to documentation (guides, repository pages, in-code descriptions)

Note that for QueryConstraint there are two added counterparts for exist and doesNotExist, isNotNull, and isNull. For Mongo users these constraints yield different results as isNull in your original question will get you your expected results, displayUtil == undefined || displayUtil == null. Using doesNotExist will only get you displayUtil == undefined. This becomes important based on if you set values to undefined or null on your server. If you are using Postgres, this doesn’t matter is much as $exist is treated as NOT NULL and there’s no difference between null or undefined.

I suspect this should also help address any performance issues @lsmilek1 brought up with performance and indexes mentioned in Query where "field" == nil - #6 by lsmilek1 as isNull and isNotNull should allow you take advantage of indexing on MongoDB (I’m guessing). I’m not a Mongo expert, so @Manuel feel free to chime in if my comments about Mongo performance is true or not. I don’t know how the other SDKs handle querying for null (or if they have the feature at all), so I’m not sure how you take advantage of this in Cloud Code, though looking at the JS query constraints may provide some insight:

github.com

parse-community/Parse-SDK-JS/blob/d084ac9be058d9b13f8ac2bbf04615f76dc2800d/src/ParseQuery.js#L1208-L1243


      
          /**
           * Adds a constraint to the query that requires a particular key's value to
           * be equal to the provided value.
           *
           * @param {string} key The key to check.
           * @param value The value that the Parse.Object must contain.
           * @returns {Parse.Query} Returns the query, so you can chain this call.
           */
          equalTo(key: string | { [key: string]: any }, value: ?mixed): ParseQuery {
            if (key && typeof key === 'object') {
              Object.entries(key).forEach(([k, val]) => this.equalTo(k, val));
              return this;
            }
            if (typeof value === 'undefined') {
              return this.doesNotExist(key);
            }
          
            this._where[key] = encode(value, false, true);
            return this;
          }

This file has been truncated. show original

The Swift SDK will have this available on the main branch shortly and then in 3.0.0 sometime this month. You can point your SPM to the main branch in the mean time.