__parseComparisons__(comparisons, Model) {

    Model = Model || this.Model;

    let comparators = this.db.adapter.comparators;
    let columnLookup = Model.columnLookup();

    return Object.keys(comparisons)
      .map(comparison => {

        let column = comparison.split('__');
        let rel = null;
        let joinName;

        let comparator = column.pop();
        if (!comparators[comparator]) {
          column.push(comparator);
          comparator = 'is';
        }

        if (column.length > 1) {
          joinName = column.slice(0, column.length - 1).join('__');
          rel = Model.relationship(joinName);
          column = column.slice(column.length - 1);
        }

        let table = null;
        let joined = false;
        let joins = null;

        if (rel) {

          // if it's not found, return null...
          if (!rel.getModel().hasColumn(column[0])) {
            return null;
          }

          table = rel.getModel().table();
          joined = true;
          joins = rel.joins('w');

        }

        let columnName = column[0];

        // block out bad column names
        if (!rel && !Model.hasColumn(columnName)) {
          return null;
        }

        let value = comparisons[comparison];
        let valueFunction = null;
        let valueColumnNames = null;

        if (typeof value === 'function') {
          valueFunction = value;
          valueColumnNames = utilities.getFunctionParameters(valueFunction);
          value = null;
        } else if (comparator === 'is') {
          if (value === null) {
            comparator = 'is_null';
          } else if (value === true) {
            comparator = 'is_true';
          } else if (value === false) {
            comparator = 'is_false';
          }
        } else if (comparator === 'not') {
          if (value === null) {
            comparator = 'not_null';
          } else if (value === true) {
            comparator = 'not_true';
          } else if (value === false) {
            comparator = 'not_false';
          }
        }

        return {
          table: table,
          alias: joinName,
          columnName: columnName,
          comparator: comparator,
          value: value,
          valueFunction: valueFunction,
          valueColumnNames: valueColumnNames,
          joined: joined,
          joins: joins
        };

      })
      .filter(v => {
        return !!v;
      });

  }
When using Composer#where, format all provided comparisons
@param {Object} comparisons Comparisons object. {age__lte: 27}, for example.
@param {Nodal.Model} Model the model to use as the basis for comparison. Default to current model.
@return {Array}
@private