jquery_query_builder-rails 0.4.0 → 0.5.0

data/vendor/assets/javascripts/i18n/query-builder.ua.js

@@ -1,8 +1,8 @@
 /*!
- * jQuery QueryBuilder 2.4.4
+ * jQuery QueryBuilder 2.5.2
  * Locale: Ukrainian (ua)
  * Author: Megaplan, mborisv <bm@megaplan.ru>
- * Licensed under MIT (http://opensource.org/licenses/MIT)
+ * Licensed under MIT (https://opensource.org/licenses/MIT)
  */
 
 (function(root, factory) {

data/vendor/assets/javascripts/i18n/query-builder.zh-CN.js

@@ -1,8 +1,8 @@
 /*!
- * jQuery QueryBuilder 2.4.4
+ * jQuery QueryBuilder 2.5.2
  * Locale: Simplified Chinese (zh_CN)
  * Author: shadowwind, shatteredwindgo@gmail.com
- * Licensed under MIT (http://opensource.org/licenses/MIT)
+ * Licensed under MIT (https://opensource.org/licenses/MIT)
  */
 
 (function(root, factory) {

data/vendor/assets/javascripts/query-builder.js

@@ -1,7 +1,7 @@
 /*!
- * jQuery QueryBuilder 2.4.4
- * Copyright 2014-2017 Damien "Mistic" Sorel (http://www.strangeplanet.fr)
- * Licensed under MIT (http://opensource.org/licenses/MIT)
+ * jQuery QueryBuilder 2.5.2
+ * Copyright 2014-2018 Damien "Mistic" Sorel (http://www.strangeplanet.fr)
+ * Licensed under MIT (https://opensource.org/licenses/MIT)
  */
 (function(root, factory) {
     if (typeof define == 'function' && define.amd) {
@@ -32,7 +32,6 @@
  * @param {jQuery} $el
  * @param {object} options - see {@link http://querybuilder.js.org/#options}
  * @constructor
- * @fires QueryBuilder.afterInit
  */
 var QueryBuilder = function($el, options) {
     $el[0].queryBuilder = this;
@@ -159,21 +158,6 @@ var QueryBuilder = function($el, options) {
     this.operators = this.checkOperators(this.operators);
     this.bindEvents();
     this.initPlugins();
-
-    /**
-     * When the initilization is done, just before creating the root group
-     * @event afterInit
-     * @memberof QueryBuilder
-     */
-    this.trigger('afterInit');
-
-    if (options.rules) {
-        this.setRules(options.rules);
-        delete this.settings.rules;
-    }
-    else {
-        this.setRoot(true);
-    }
 };
 
 $.extend(QueryBuilder.prototype, /** @lends QueryBuilder.prototype */ {
@@ -415,7 +399,8 @@ QueryBuilder.DEFAULTS = {
         group: null,
         rule: null,
         filterSelect: null,
-        operatorSelect: null
+        operatorSelect: null,
+        ruleValueSelect: null
     },
 
     lang_code: 'en',
@@ -570,6 +555,29 @@ QueryBuilder.prototype.getPluginOptions = function(name, property) {
 };
 
 
+/**
+ * Final initialisation of the builder
+ * @param {object} [rules]
+ * @fires QueryBuilder.afterInit
+ * @private
+ */
+QueryBuilder.prototype.init = function(rules) {
+    /**
+     * When the initilization is done, just before creating the root group
+     * @event afterInit
+     * @memberof QueryBuilder
+     */
+    this.trigger('afterInit');
+
+    if (rules) {
+        this.setRules(rules);
+        delete this.settings.rules;
+    }
+    else {
+        this.setRoot(true);
+    }
+};
+
 /**
  * Checks the configuration of each filter
  * @param {QueryBuilder.Filter[]} filters
@@ -642,12 +650,40 @@ QueryBuilder.prototype.checkFilters = function(filters) {
                 break;
 
             case 'select':
+                var cleanValues = [];
+                filter.has_optgroup = false;
+
+                Utils.iterateOptions(filter.values, function(value, label, optgroup) {
+                    cleanValues.push({
+                        value: value,
+                        label: label,
+                        optgroup: optgroup || null
+                    });
+
+                    if (optgroup) {
+                        filter.has_optgroup = true;
+
+                        // register optgroup if needed
+                        if (!this.settings.optgroups[optgroup]) {
+                            this.settings.optgroups[optgroup] = optgroup;
+                        }
+                    }
+                }.bind(this));
+
+                if (filter.has_optgroup) {
+                    filter.values = Utils.groupSort(cleanValues, 'optgroup');
+                }
+                else {
+                    filter.values = cleanValues;
+                }
+
                 if (filter.placeholder) {
                     if (filter.placeholder_value === undefined) {
                         filter.placeholder_value = -1;
                     }
-                    Utils.iterateOptions(filter.values, function(key) {
-                        if (key == filter.placeholder_value) {
+
+                    filter.values.forEach(function(entry) {
+                        if (entry.value == filter.placeholder_value) {
                             Utils.error('Config', 'Placeholder of filter "{0}" overlaps with one of its values', filter.id);
                         }
                     });
@@ -831,7 +867,7 @@ QueryBuilder.prototype.bindEvents = function() {
                         break;
 
                     case 'value':
-                        self.updateRuleValue(node);
+                        self.updateRuleValue(node, oldValue);
                         break;
                 }
             }
@@ -846,7 +882,7 @@ QueryBuilder.prototype.bindEvents = function() {
                         break;
 
                     case 'condition':
-                        self.updateGroupCondition(node);
+                        self.updateGroupCondition(node, oldValue);
                         break;
                 }
             }
@@ -873,12 +909,11 @@ QueryBuilder.prototype.setRoot = function(addRule, data, flags) {
     this.model.root.model = this.model;
 
     this.model.root.data = data;
-    this.model.root.__.flags = $.extend({}, this.settings.default_group_flags, flags);
+    this.model.root.flags = $.extend({}, this.settings.default_group_flags, flags);
+    this.model.root.condition = this.settings.default_condition;
 
     this.trigger('afterAddGroup', this.model.root);
 
-    this.model.root.condition = this.settings.default_condition;
-
     if (addRule) {
         this.addRule(this.model.root);
     }
@@ -919,7 +954,8 @@ QueryBuilder.prototype.addGroup = function(parent, addRule, data, flags) {
     var model = parent.addGroup($group);
 
     model.data = data;
-    model.__.flags = $.extend({}, this.settings.default_group_flags, flags);
+    model.flags = $.extend({}, this.settings.default_group_flags, flags);
+    model.condition = this.settings.default_condition;
 
     /**
      * Just after adding a group
@@ -929,7 +965,12 @@ QueryBuilder.prototype.addGroup = function(parent, addRule, data, flags) {
      */
     this.trigger('afterAddGroup', model);
 
-    model.condition = this.settings.default_condition;
+    /**
+     * After any change in the rules
+     * @event rulesChanged
+     * @memberof QueryBuilder
+     */
+    this.trigger('rulesChanged');
 
     if (addRule) {
         this.addRule(model);
@@ -978,6 +1019,8 @@ QueryBuilder.prototype.deleteGroup = function(group) {
          * @memberof QueryBuilder
          */
         this.trigger('afterDeleteGroup');
+
+        this.trigger('rulesChanged');
     }
 
     return del;
@@ -986,10 +1029,11 @@ QueryBuilder.prototype.deleteGroup = function(group) {
 /**
  * Performs actions when a group's condition changes
  * @param {Group} group
+ * @param {object} previousCondition
  * @fires QueryBuilder.afterUpdateGroupCondition
  * @private
  */
-QueryBuilder.prototype.updateGroupCondition = function(group) {
+QueryBuilder.prototype.updateGroupCondition = function(group, previousCondition) {
     group.$el.find('>' + QueryBuilder.selectors.group_condition).each(function() {
         var $this = $(this);
         $this.prop('checked', $this.val() === group.condition);
@@ -1001,8 +1045,11 @@ QueryBuilder.prototype.updateGroupCondition = function(group) {
      * @event afterUpdateGroupCondition
      * @memberof QueryBuilder
      * @param {Group} group
+     * @param {object} previousCondition
      */
-    this.trigger('afterUpdateGroupCondition', group);
+    this.trigger('afterUpdateGroupCondition', group, previousCondition);
+
+    this.trigger('rulesChanged');
 };
 
 /**
@@ -1048,11 +1095,8 @@ QueryBuilder.prototype.addRule = function(parent, data, flags) {
     var $rule = $(this.getRuleTemplate(rule_id));
     var model = parent.addRule($rule);
 
-    if (data !== undefined) {
-        model.data = data;
-    }
-
-    model.__.flags = $.extend({}, this.settings.default_rule_flags, flags);
+    model.data = data;
+    model.flags = $.extend({}, this.settings.default_rule_flags, flags);
 
     /**
      * Just after adding a rule
@@ -1062,6 +1106,8 @@ QueryBuilder.prototype.addRule = function(parent, data, flags) {
      */
     this.trigger('afterAddRule', model);
 
+    this.trigger('rulesChanged');
+
     this.createRuleFilters(model);
 
     if (this.settings.default_filter || !this.settings.display_empty_filter) {
@@ -1114,6 +1160,8 @@ QueryBuilder.prototype.deleteRule = function(rule) {
      */
     this.trigger('afterDeleteRule');
 
+    this.trigger('rulesChanged');
+
     return true;
 };
 
@@ -1145,6 +1193,8 @@ QueryBuilder.prototype.createRuleFilters = function(rule) {
      * @param {Rule} rule
      */
     this.trigger('afterCreateRuleFilters', rule);
+
+    this.applyRuleFlags(rule);
 };
 
 /**
@@ -1166,7 +1216,14 @@ QueryBuilder.prototype.createRuleOperators = function(rule) {
     $operatorContainer.html($operatorSelect);
 
     // set the operator without triggering update event
-    rule.__.operator = operators[0];
+    if (rule.filter.default_operator) {
+        rule.__.operator = this.getOperatorByType(rule.filter.default_operator);
+    }
+    else {
+        rule.__.operator = operators[0];
+    }
+
+    rule.$el.find(QueryBuilder.selectors.rule_operator).val(rule.operator.type);
 
     /**
      * After creating the dropdown for operators
@@ -1176,6 +1233,8 @@ QueryBuilder.prototype.createRuleOperators = function(rule) {
      * @param {QueryBuilder.Operator[]} operators - allowed operators for this rule
      */
     this.trigger('afterCreateRuleOperators', rule, operators);
+
+    this.applyRuleFlags(rule);
 };
 
 /**
@@ -1204,10 +1263,10 @@ QueryBuilder.prototype.createRuleInput = function(rule) {
         $inputs = $inputs.add($ruleInput);
     }
 
-    $valueContainer.show();
+    $valueContainer.css('display', '');
 
     $inputs.on('change ' + (filter.input_event || ''), function() {
-        if (!this._updating_input) {
+        if (!rule._updating_input) {
             rule._updating_value = true;
             rule.value = self.getRuleInputValue(rule);
             rule._updating_value = false;
@@ -1234,6 +1293,8 @@ QueryBuilder.prototype.createRuleInput = function(rule) {
         rule.value = self.getRuleInputValue(rule);
         rule._updating_value = false;
     }
+
+    this.applyRuleFlags(rule);
 };
 
 /**
@@ -1259,8 +1320,11 @@ QueryBuilder.prototype.updateRuleFilter = function(rule, previousFilter) {
      * @event afterUpdateRuleFilter
      * @memberof QueryBuilder
      * @param {Rule} rule
+     * @param {object} previousFilter
      */
-    this.trigger('afterUpdateRuleFilter', rule);
+    this.trigger('afterUpdateRuleFilter', rule, previousFilter);
+
+    this.trigger('rulesChanged');
 };
 
 /**
@@ -1279,7 +1343,7 @@ QueryBuilder.prototype.updateRuleOperator = function(rule, previousOperator) {
         rule.__.value = undefined;
     }
     else {
-        $valueContainer.show();
+        $valueContainer.css('display', '');
 
         if ($valueContainer.is(':empty') || !previousOperator ||
             rule.operator.nb_inputs !== previousOperator.nb_inputs ||
@@ -1291,6 +1355,9 @@ QueryBuilder.prototype.updateRuleOperator = function(rule, previousOperator) {
 
     if (rule.operator) {
         rule.$el.find(QueryBuilder.selectors.rule_operator).val(rule.operator.type);
+
+        // refresh value if the format changed for this operator
+        rule.__.value = this.getRuleInputValue(rule);
     }
 
     /**
@@ -1298,19 +1365,21 @@ QueryBuilder.prototype.updateRuleOperator = function(rule, previousOperator) {
      * @event afterUpdateRuleOperator
      * @memberof QueryBuilder
      * @param {Rule} rule
+     * @param {object} previousOperator
      */
-    this.trigger('afterUpdateRuleOperator', rule);
+    this.trigger('afterUpdateRuleOperator', rule, previousOperator);
 
-    this.updateRuleValue(rule);
+    this.trigger('rulesChanged');
 };
 
 /**
  * Performs actions when rule's value changes
  * @param {Rule} rule
+ * @param {object} previousValue
  * @fires QueryBuilder.afterUpdateRuleValue
  * @private
  */
-QueryBuilder.prototype.updateRuleValue = function(rule) {
+QueryBuilder.prototype.updateRuleValue = function(rule, previousValue) {
     if (!rule._updating_value) {
         this.setRuleInputValue(rule, rule.value);
     }
@@ -1320,8 +1389,11 @@ QueryBuilder.prototype.updateRuleValue = function(rule) {
      * @event afterUpdateRuleValue
      * @memberof QueryBuilder
      * @param {Rule} rule
+     * @param {*} previousValue
      */
-    this.trigger('afterUpdateRuleValue', rule);
+    this.trigger('afterUpdateRuleValue', rule, previousValue);
+
+    this.trigger('rulesChanged');
 };
 
 /**
@@ -1334,15 +1406,10 @@ QueryBuilder.prototype.applyRuleFlags = function(rule) {
     var flags = rule.flags;
     var Selectors = QueryBuilder.selectors;
 
-    if (flags.filter_readonly) {
-        rule.$el.find(Selectors.rule_filter).prop('disabled', true);
-    }
-    if (flags.operator_readonly) {
-        rule.$el.find(Selectors.rule_operator).prop('disabled', true);
-    }
-    if (flags.value_readonly) {
-        rule.$el.find(Selectors.rule_value).prop('disabled', true);
-    }
+    rule.$el.find(Selectors.rule_filter).prop('disabled', flags.filter_readonly);
+    rule.$el.find(Selectors.rule_operator).prop('disabled', flags.operator_readonly);
+    rule.$el.find(Selectors.rule_value).prop('disabled', flags.value_readonly);
+
     if (flags.no_delete) {
         rule.$el.find(Selectors.delete_rule).remove();
     }
@@ -1366,10 +1433,9 @@ QueryBuilder.prototype.applyGroupFlags = function(group) {
     var flags = group.flags;
     var Selectors = QueryBuilder.selectors;
 
-    if (flags.condition_readonly) {
-        group.$el.find('>' + Selectors.group_condition).prop('disabled', true)
-            .parent().addClass('readonly');
-    }
+    group.$el.find('>' + Selectors.group_condition).prop('disabled', flags.condition_readonly)
+        .parent().toggleClass('readonly', flags.condition_readonly);
+
     if (flags.no_add_rule) {
         group.$el.find(Selectors.add_rule).remove();
     }
@@ -1520,6 +1586,10 @@ QueryBuilder.prototype.reset = function() {
 
     this.model.root.empty();
 
+    this.model.root.data = undefined;
+    this.model.root.flags = $.extend({}, this.settings.default_group_flags);
+    this.model.root.condition = this.settings.default_condition;
+
     this.addRule(this.model.root);
 
     /**
@@ -1528,6 +1598,8 @@ QueryBuilder.prototype.reset = function() {
      * @memberof QueryBuilder
      */
     this.trigger('afterReset');
+
+    this.trigger('rulesChanged');
 };
 
 /**
@@ -1560,6 +1632,8 @@ QueryBuilder.prototype.clear = function() {
      * @memberof QueryBuilder
      */
     this.trigger('afterClear');
+
+    this.trigger('rulesChanged');
 };
 
 /**
@@ -1818,7 +1892,6 @@ QueryBuilder.prototype.setRules = function(data, options) {
 
     this.clear();
     this.setRoot(false, data.data, this.parseGroupFlags(data));
-    this.applyGroupFlags(this.model.root);
 
     /**
      * Modifies data before the {@link QueryBuilder#setRules} method
@@ -1861,8 +1934,6 @@ QueryBuilder.prototype.setRules = function(data, options) {
                         return;
                     }
 
-                    self.applyGroupFlags(model);
-
                     add(item, model);
                 }
             }
@@ -1884,21 +1955,24 @@ QueryBuilder.prototype.setRules = function(data, options) {
 
                 if (!item.empty) {
                     model.filter = self.getFilterById(item.id, !options.allow_invalid);
+                }
 
-                    if (model.filter) {
-                        model.operator = self.getOperatorByType(item.operator, !options.allow_invalid);
+                if (model.filter) {
+                    model.operator = self.getOperatorByType(item.operator, !options.allow_invalid);
 
-                        if (!model.operator) {
-                            model.operator = self.getOperators(model.filter)[0];
-                        }
-
-                        if (model.operator && model.operator.nb_inputs !== 0 && item.value !== undefined) {
-                            model.value = item.value;
-                        }
+                    if (!model.operator) {
+                        model.operator = self.getOperators(model.filter)[0];
                     }
                 }
 
-                self.applyRuleFlags(model);
+                if (model.operator && model.operator.nb_inputs !== 0) {
+                    if (item.value !== undefined) {
+                        model.value = item.value;
+                    }
+                    else if (model.filter.default_value !== undefined) {
+                        model.value = model.filter.default_value;
+                    }
+                }
 
                 /**
                  * Modifies the Rule object generated from the JSON
@@ -2160,6 +2234,29 @@ QueryBuilder.prototype._validateValue = function(rule, value) {
         }
     }
 
+    if ((rule.operator.type === 'between' || rule.operator.type === 'not_between') && value.length === 2) {
+        switch (QueryBuilder.types[filter.type]) {
+            case 'number':
+                if (value[0] > value[1]) {
+                    result = ['number_between_invalid', value[0], value[1]];
+                }
+                break;
+
+            case 'datetime':
+                // we need MomentJS
+                if (validation.format) {
+                    if (!('moment' in window)) {
+                        Utils.error('MissingLibrary', 'MomentJS is required for Date/Time validation. Get it here http://momentjs.com');
+                    }
+
+                    if (moment(value[0], validation.format).isAfter(moment(value[1], validation.format))) {
+                        result = ['datetime_between_invalid', value[0], value[1]];
+                    }
+                }
+                break;
+        }
+    }
+
     return result;
 };
 
@@ -2333,11 +2430,20 @@ QueryBuilder.prototype.getRuleInputValue = function(rule) {
             }
         }
 
-        if (operator.multiple && filter.value_separator) {
-            value = value.map(function(val) {
-                return val.split(filter.value_separator);
-            });
-        }
+        value = value.map(function(val) {
+            if (operator.multiple && filter.value_separator && typeof val == 'string') {
+                val = val.split(filter.value_separator);
+            }
+
+            if ($.isArray(val)) {
+                return val.map(function(subval) {
+                    return Utils.changeType(subval, filter.type);
+                });
+            }
+            else {
+                return Utils.changeType(val, filter.type);
+            }
+        });
 
         if (operator.nb_inputs === 1) {
             value = value[0];
@@ -2374,7 +2480,7 @@ QueryBuilder.prototype.setRuleInputValue = function(rule, value) {
         return;
     }
 
-    this._updating_input = true;
+    rule._updating_input = true;
 
     if (filter.valueSetter) {
         filter.valueSetter.call(this, rule, value);
@@ -2415,7 +2521,7 @@ QueryBuilder.prototype.setRuleInputValue = function(rule, value) {
         }
     }
 
-    this._updating_input = false;
+    rule._updating_input = false;
 };
 
 /**
@@ -2577,8 +2683,8 @@ QueryBuilder.prototype.getValidationMessage = function(validation, type, def) {
 
 
 QueryBuilder.templates.group = '\
-<dl id="{{= it.group_id }}" class="rules-group-container"> \
-  <dt class="rules-group-header"> \
+<div id="{{= it.group_id }}" class="rules-group-container"> \
+  <div class="rules-group-header"> \
     <div class="btn-group pull-right group-actions"> \
       <button type="button" class="btn btn-xs btn-success" data-add="rule"> \
         <i class="{{= it.icons.add_rule }}"></i> {{= it.translate("add_rule") }} \
@@ -2604,14 +2710,14 @@ QueryBuilder.templates.group = '\
     {{? it.settings.display_errors }} \
       <div class="error-container"><i class="{{= it.icons.error }}"></i></div> \
     {{?}} \
-  </dt> \
-  <dd class=rules-group-body> \
-    <ul class=rules-list></ul> \
-  </dd> \
-</dl>';
+  </div> \
+  <div class=rules-group-body> \
+    <div class=rules-list></div> \
+  </div> \
+</div>';
 
 QueryBuilder.templates.rule = '\
-<li id="{{= it.rule_id }}" class="rule-container"> \
+<div id="{{= it.rule_id }}" class="rule-container"> \
   <div class="rule-header"> \
     <div class="btn-group pull-right rule-actions"> \
       <button type="button" class="btn btn-xs btn-danger" data-delete="rule"> \
@@ -2625,7 +2731,7 @@ QueryBuilder.templates.rule = '\
   <div class="rule-filter-container"></div> \
   <div class="rule-operator-container"></div> \
   <div class="rule-value-container"></div> \
-</li>';
+</div>';
 
 QueryBuilder.templates.filterSelect = '\
 {{ var optgroup = null; }} \
@@ -2640,7 +2746,7 @@ QueryBuilder.templates.filterSelect = '\
         <optgroup label="{{= it.translate(it.settings.optgroups[optgroup]) }}"> \
       {{?}} \
     {{?}} \
-    <option value="{{= filter.id }}">{{= it.translate(filter.label) }}</option> \
+    <option value="{{= filter.id }}" {{? filter.icon}}data-icon="{{= filter.icon}}"{{?}}>{{= it.translate(filter.label) }}</option> \
   {{~}} \
   {{? optgroup !== null }}</optgroup>{{?}} \
 </select>';
@@ -2660,7 +2766,25 @@ QueryBuilder.templates.operatorSelect = '\
         <optgroup label="{{= it.translate(it.settings.optgroups[optgroup]) }}"> \
       {{?}} \
     {{?}} \
-    <option value="{{= operator.type }}">{{= it.translate("operators", operator.type) }}</option> \
+    <option value="{{= operator.type }}" {{? operator.icon}}data-icon="{{= operator.icon}}"{{?}}>{{= it.translate("operators", operator.type) }}</option> \
+  {{~}} \
+  {{? optgroup !== null }}</optgroup>{{?}} \
+</select>';
+
+QueryBuilder.templates.ruleValueSelect = '\
+{{ var optgroup = null; }} \
+<select class="form-control" name="{{= it.name }}" {{? it.rule.filter.multiple }}multiple{{?}}> \
+  {{? it.rule.filter.placeholder }} \
+    <option value="{{= it.rule.filter.placeholder_value }}" disabled selected>{{= it.rule.filter.placeholder }}</option> \
+  {{?}} \
+  {{~ it.rule.filter.values: entry }} \
+    {{? optgroup !== entry.optgroup }} \
+      {{? optgroup !== null }}</optgroup>{{?}} \
+      {{? (optgroup = entry.optgroup) !== null }} \
+        <optgroup label="{{= it.translate(it.settings.optgroups[optgroup]) }}"> \
+      {{?}} \
+    {{?}} \
+    <option value="{{= entry.value }}">{{= entry.label }}</option> \
   {{~}} \
   {{? optgroup !== null }}</optgroup>{{?}} \
 </select>';
@@ -2741,7 +2865,7 @@ QueryBuilder.prototype.getRuleFilterSelect = function(rule, filters) {
 
     /**
      * Modifies the raw HTML of the rule's filter dropdown
-     * @event changer:getRuleFilterTemplate
+     * @event changer:getRuleFilterSelect
      * @memberof QueryBuilder
      * @param {string} html
      * @param {Rule} rule
@@ -2771,7 +2895,7 @@ QueryBuilder.prototype.getRuleOperatorSelect = function(rule, operators) {
 
     /**
      * Modifies the raw HTML of the rule's operator dropdown
-     * @event changer:getRuleOperatorTemplate
+     * @event changer:getRuleOperatorSelect
      * @memberof QueryBuilder
      * @param {string} html
      * @param {Rule} rule
@@ -2781,6 +2905,36 @@ QueryBuilder.prototype.getRuleOperatorSelect = function(rule, operators) {
     return this.change('getRuleOperatorSelect', h, rule, operators);
 };
 
+/**
+ * Returns the rule's value select HTML
+ * @param {string} name
+ * @param {Rule} rule
+ * @returns {string}
+ * @fires QueryBuilder.changer:getRuleValueSelect
+ * @private
+ */
+QueryBuilder.prototype.getRuleValueSelect = function(name, rule) {
+    var h = this.templates.ruleValueSelect({
+        builder: this,
+        name: name,
+        rule: rule,
+        icons: this.icons,
+        settings: this.settings,
+        translate: this.translate.bind(this)
+    });
+
+    /**
+     * Modifies the raw HTML of the rule's value dropdown (in case of a "select filter)
+     * @event changer:getRuleValueSelect
+     * @memberof QueryBuilder
+     * @param {string} html
+     * @param [string} name
+     * @param {Rule} rule
+     * @returns {string}
+     */
+    return this.change('getRuleValueSelect', h, name, rule);
+};
+
 /**
  * Returns the rule's value HTML
  * @param {Rule} rule
@@ -2809,14 +2963,7 @@ QueryBuilder.prototype.getRuleInput = function(rule, value_id) {
                 break;
 
             case 'select':
-                h += '<select class="form-control" name="' + name + '"' + (filter.multiple ? ' multiple' : '') + '>';
-                if (filter.placeholder) {
-                    h += '<option value="' + filter.placeholder_value + '" disabled selected>' + filter.placeholder + '</option>';
-                }
-                Utils.iterateOptions(filter.values, function(key, val) {
-                    h += '<option value="' + key + '">' + val + '</option> ';
-                });
-                h += '</select>';
+                h = this.getRuleValueSelect(name, rule);
                 break;
 
             case 'textarea':
@@ -2878,10 +3025,11 @@ QueryBuilder.utils = Utils;
  * @callback Utils#OptionsIteratee
  * @param {string} key
  * @param {string} value
+ * @param {string} [optgroup]
  */
 
 /**
- * Iterates over radio/checkbox/selection options, it accept three formats
+ * Iterates over radio/checkbox/selection options, it accept four formats
  *
  * @example
  * // array of values
@@ -2892,6 +3040,9 @@ QueryBuilder.utils = Utils;
  * @example
  * // array of 1-element maps
  * options = [{1: 'one'}, {2: 'two'}, {3: 'three'}]
+ * @example
+ * // array of elements
+ * options = [{value: 1, label: 'one', optgroup: 'group'}, {value: 2, label: 'two'}]
  *
  * @param {object|array} options
  * @param {Utils#OptionsIteratee} tpl
@@ -2900,12 +3051,18 @@ Utils.iterateOptions = function(options, tpl) {
     if (options) {
         if ($.isArray(options)) {
             options.forEach(function(entry) {
-                // array of one-element maps
                 if ($.isPlainObject(entry)) {
-                    $.each(entry, function(key, val) {
-                        tpl(key, val);
-                        return false; // break after first entry
-                    });
+                    // array of elements
+                    if ('value' in entry) {
+                        tpl(entry.value, entry.label || entry.value, entry.optgroup);
+                    }
+                    // array of one-element maps
+                    else {
+                        $.each(entry, function(key, val) {
+                            tpl(key, val);
+                            return false; // break after first entry
+                        });
+                    }
                 }
                 // array of values
                 else {
@@ -2967,19 +3124,32 @@ Utils.error = function() {
  * Changes the type of a value to int, float or bool
  * @param {*} value
  * @param {string} type - 'integer', 'double', 'boolean' or anything else (passthrough)
- * @param {boolean} [boolAsInt=false] - return 0 or 1 for booleans
  * @returns {*}
  */
-Utils.changeType = function(value, type, boolAsInt) {
+Utils.changeType = function(value, type) {
+    if (value === '' || value === undefined) {
+        return undefined;
+    }
+
     switch (type) {
         // @formatter:off
-    case 'integer': return parseInt(value);
-    case 'double': return parseFloat(value);
-    case 'boolean':
-        var bool = value.trim().toLowerCase() === 'true' || value.trim() === '1' || value === 1;
-        return boolAsInt ? (bool ? 1 : 0) : bool;
-    default: return value;
-    // @formatter:on
+        case 'integer':
+            if (typeof value === 'string' && !/^-?\d+$/.test(value)) {
+                return value;
+            }
+            return parseInt(value);
+        case 'double':
+            if (typeof value === 'string' && !/^-?\d+\.?\d*$/.test(value)) {
+                return value;
+            }
+            return parseFloat(value);
+        case 'boolean':
+            if (typeof value === 'string' && !/^(0|1|true|false){1}$/i.test(value)) {
+                return value;
+            }
+            return value === true || value === 1 || value.toLowerCase() === 'true' || value === '1';
+        default: return value;
+        // @formatter:on
     }
 };
 
@@ -2997,12 +3167,12 @@ Utils.escapeString = function(value) {
         .replace(/[\0\n\r\b\\\'\"]/g, function(s) {
             switch (s) {
                 // @formatter:off
-            case '\0': return '\\0';
-            case '\n': return '\\n';
-            case '\r': return '\\r';
-            case '\b': return '\\b';
-            default:   return '\\' + s;
-            // @formatter:off
+                case '\0': return '\\0';
+                case '\n': return '\\n';
+                case '\r': return '\\r';
+                case '\b': return '\\b';
+                default:   return '\\' + s;
+                // @formatter:off
             }
         })
         // uglify compliant
@@ -3689,7 +3859,9 @@ $.fn.queryBuilder = function(option) {
         return this;
     }
     if (!data) {
-        this.data('queryBuilder', new QueryBuilder(this, options));
+        var builder = new QueryBuilder(this, options);
+        this.data('queryBuilder', builder);
+        builder.init(options.rules);
     }
     if (typeof option == 'string') {
         return data[option].apply(data, Array.prototype.slice.call(arguments, 1));
@@ -3926,6 +4098,8 @@ QueryBuilder.extend(/** @lends module:plugins.ChangeFilters.prototype */ {
                 function(rule) {
                     if (rule.filter && filtersIds.indexOf(rule.filter.id) === -1) {
                         rule.drop();
+
+                        self.trigger('rulesChanged');
                     }
                     else {
                         self.createRuleFilters(rule);
@@ -4036,6 +4210,50 @@ QueryBuilder.extend(/** @lends module:plugins.ChangeFilters.prototype */ {
 });
 
 
+/**
+ * @class ChosenSelectpicker
+ * @memberof module:plugins
+ * @descriptioon Applies chosen-js Select on filters and operators combo-boxes.
+ * @param {object} [options] Supports all the options for chosen
+ * @throws MissingLibraryError
+ */
+QueryBuilder.define('chosen-selectpicker', function(options) {
+
+    if (!$.fn.chosen) {
+        Utils.error('MissingLibrary', 'chosen is required to use "chosen-selectpicker" plugin. Get it here: https://github.com/harvesthq/chosen');
+    }
+
+    if (this.settings.plugins['bt-selectpicker']) {
+        Utils.error('Conflict', 'bt-selectpicker is already selected as the dropdown plugin. Please remove chosen-selectpicker from the plugin list');
+    }
+
+    var Selectors = QueryBuilder.selectors;
+
+    // init selectpicker
+    this.on('afterCreateRuleFilters', function(e, rule) {
+        rule.$el.find(Selectors.rule_filter).removeClass('form-control').chosen(options);
+    });
+
+    this.on('afterCreateRuleOperators', function(e, rule) {
+        rule.$el.find(Selectors.rule_operator).removeClass('form-control').chosen(options);
+    });
+
+    // update selectpicker on change
+    this.on('afterUpdateRuleFilter', function(e, rule) {
+        rule.$el.find(Selectors.rule_filter).trigger('chosen:updated');
+    });
+
+    this.on('afterUpdateRuleOperator', function(e, rule) {
+        rule.$el.find(Selectors.rule_operator).trigger('chosen:updated');
+    });
+
+    this.on('beforeDeleteRule', function(e, rule) {
+        rule.$el.find(Selectors.rule_filter).chosen('destroy');
+        rule.$el.find(Selectors.rule_operator).chosen('destroy');
+    });
+});
+
+
 /**
  * @class FilterDescription
  * @memberof module:plugins
@@ -4061,7 +4279,7 @@ QueryBuilder.define('filter-description', function(options) {
                     $p.appendTo(rule.$el);
                 }
                 else {
-                    $p.show();
+                    $p.css('display', '');
                 }
 
                 $p.html('<i class="' + options.icon + '"></i> ' + description);
@@ -4101,7 +4319,7 @@ QueryBuilder.define('filter-description', function(options) {
                     });
                 }
                 else {
-                    $b.show();
+                    $b.css('display', '');
                 }
 
                 $b.data('bs.popover').options.content = description;
@@ -4134,6 +4352,9 @@ QueryBuilder.define('filter-description', function(options) {
                         bootbox.alert($b.data('description'));
                     });
                 }
+                else {
+                    $b.css('display', '');
+                }
 
                 $b.data('description', description);
             }
@@ -4197,25 +4418,36 @@ QueryBuilder.define('invert', function(options) {
     });
 
     // Modify templates
-    this.on('getGroupTemplate.filter', function(h, level) {
-        var $h = $(h.value);
-        $h.find(Selectors.condition_container).after('<button type="button" class="btn btn-xs btn-default" data-invert="group"><i class="' + options.icon + '"></i> ' + self.translate('invert') + '</button>');
-        h.value = $h.prop('outerHTML');
-    });
-
-    if (options.display_rules_button && options.invert_rules) {
-        this.on('getRuleTemplate.filter', function(h) {
+    if (!options.disable_template) {
+        this.on('getGroupTemplate.filter', function(h) {
             var $h = $(h.value);
-            $h.find(Selectors.rule_actions).prepend('<button type="button" class="btn btn-xs btn-default" data-invert="rule"><i class="' + options.icon + '"></i> ' + self.translate('invert') + '</button>');
+            $h.find(Selectors.condition_container).after(
+                '<button type="button" class="btn btn-xs btn-default" data-invert="group">' +
+                '<i class="' + options.icon + '"></i> ' + self.translate('invert') +
+                '</button>'
+            );
             h.value = $h.prop('outerHTML');
         });
+
+        if (options.display_rules_button && options.invert_rules) {
+            this.on('getRuleTemplate.filter', function(h) {
+                var $h = $(h.value);
+                $h.find(Selectors.rule_actions).prepend(
+                    '<button type="button" class="btn btn-xs btn-default" data-invert="rule">' +
+                    '<i class="' + options.icon + '"></i> ' + self.translate('invert') +
+                    '</button>'
+                );
+                h.value = $h.prop('outerHTML');
+            });
+        }
     }
 }, {
     icon: 'glyphicon glyphicon-random',
     recursive: true,
     invert_rules: true,
     display_rules_button: false,
-    silent_fail: false
+    silent_fail: false,
+    disable_template: false
 });
 
 QueryBuilder.defaults({
@@ -4315,6 +4547,8 @@ QueryBuilder.extend(/** @lends module:plugins.Invert.prototype */ {
              * @param {object} options
              */
             this.trigger('afterInvert', node, options);
+
+            this.trigger('rulesChanged');
         }
     }
 });
@@ -4353,17 +4587,17 @@ QueryBuilder.defaults({
     },
 
     mongoRuleOperators: {
-        $ne: function(v) {
-            v = v.$ne;
+        $eq: function(v) {
             return {
                 'val': v,
-                'op': v === null ? 'is_not_null' : (v === '' ? 'is_not_empty' : 'not_equal')
+                'op': v === null ? 'is_null' : (v === '' ? 'is_empty' : 'equal')
             };
         },
-        eq: function(v) {
+        $ne: function(v) {
+            v = v.$ne;
             return {
                 'val': v,
-                'op': v === null ? 'is_null' : (v === '' ? 'is_empty' : 'equal')
+                'op': v === null ? 'is_not_null' : (v === '' ? 'is_not_empty' : 'not_equal')
             };
         },
         $regex: function(v) {
@@ -4427,6 +4661,10 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
     getMongo: function(data) {
         data = (data === undefined) ? this.getRules() : data;
 
+        if (!data) {
+            return null;
+        }
+
         var self = this;
 
         return (function parse(group) {
@@ -4450,7 +4688,6 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                 else {
                     var mdb = self.settings.mongoOperators[rule.operator];
                     var ope = self.getOperatorByType(rule.operator);
-                    var values = [];
 
                     if (mdb === undefined) {
                         Utils.error('UndefinedMongoOperator', 'Unknown MongoDB operation for operator "{0}"', rule.operator);
@@ -4460,10 +4697,6 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                         if (!(rule.value instanceof Array)) {
                             rule.value = [rule.value];
                         }
-
-                        rule.value.forEach(function(v) {
-                            values.push(Utils.changeType(v, rule.type, false));
-                        });
                     }
 
                     /**
@@ -4477,7 +4710,7 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                     var field = self.change('getMongoDBField', rule.field, rule);
 
                     var ruleExpression = {};
-                    ruleExpression[field] = mdb.call(self, values);
+                    ruleExpression[field] = mdb.call(self, rule.value);
 
                     /**
                      * Modifies the MongoDB expression generated for a rul
@@ -4489,7 +4722,7 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                      * @param {function} valueWrapper - function that takes the value and adds the operator
                      * @returns {object}
                      */
-                    parts.push(self.change('ruleToMongo', ruleExpression, rule, values, mdb));
+                    parts.push(self.change('ruleToMongo', ruleExpression, rule, rule.value, mdb));
                 }
             });
 
@@ -4547,7 +4780,7 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
             };
         }
 
-        var key = andOr(query);
+        var key = self.getMongoCondition(query);
         if (!key) {
             Utils.error('MongoParse', 'Invalid MongoDB query format');
         }
@@ -4572,7 +4805,7 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                     return;
                 }
 
-                var key = andOr(data);
+                var key = self.getMongoCondition(data);
                 if (key) {
                     parts.push(parse(data, key));
                 }
@@ -4580,7 +4813,7 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
                     var field = Object.keys(data)[0];
                     var value = data[field];
 
-                    var operator = determineMongoOperator(value, field);
+                    var operator = self.getMongoOperator(value);
                     if (operator === undefined) {
                         Utils.error('MongoParse', 'Invalid MongoDB query format');
                     }
@@ -4667,61 +4900,53 @@ QueryBuilder.extend(/** @lends module:plugins.MongoDbSupport.prototype */ {
         }
 
         return id;
-    }
-});
-
-/**
- * Finds which operator is used in a MongoDB sub-object
- * @memberof module:plugins.MongoDbSupport
- * @param {*} value
- * @returns {string|undefined}
- * @private
- */
-function determineMongoOperator(value) {
-    if (value !== null && typeof value == 'object') {
-        var subkeys = Object.keys(value);
+    },
 
-        if (subkeys.length === 1) {
-            return subkeys[0];
-        }
-        else {
-            if (value.$gte !== undefined && value.$lte !== undefined) {
+    /**
+     * Finds which operator is used in a MongoDB sub-object
+     * @param {*} data
+     * @returns {string|undefined}
+     * @private
+     */
+    getMongoOperator: function(data) {
+        if (data !== null && typeof data === 'object') {
+            if (data.$gte !== undefined && data.$lte !== undefined) {
                 return 'between';
             }
-            if (value.$lt !== undefined && value.$gt !== undefined) {
+            if (data.$lt !== undefined && data.$gt !== undefined) {
                 return 'not_between';
             }
-            else if (value.$regex !== undefined) { // optional $options
-                return '$regex';
-            }
-            else {
-                return;
+
+            var knownKeys = Object.keys(data).filter(function(key) {
+                return !!this.settings.mongoRuleOperators[key];
+            }.bind(this));
+
+            if (knownKeys.length === 1) {
+                return knownKeys[0];
             }
         }
-    }
-    else {
-        return 'eq';
-    }
-}
+        else {
+            return '$eq';
+        }
+    },
 
-/**
- * Returns the key corresponding to "$or" or "$and"
- * @memberof module:plugins.MongoDbSupport
- * @param {object} data
- * @returns {string}
- * @private
- */
-function andOr(data) {
-    var keys = Object.keys(data);
 
-    for (var i = 0, l = keys.length; i < l; i++) {
-        if (keys[i].toLowerCase() == '$or' || keys[i].toLowerCase() == '$and') {
-            return keys[i];
+    /**
+     * Returns the key corresponding to "$or" or "$and"
+     * @param {object} data
+     * @returns {string|undefined}
+     * @private
+     */
+    getMongoCondition: function(data) {
+        var keys = Object.keys(data);
+
+        for (var i = 0, l = keys.length; i < l; i++) {
+            if (keys[i].toLowerCase() === '$or' || keys[i].toLowerCase() === '$and') {
+                return keys[i];
+            }
         }
     }
-
-    return undefined;
-}
+});
 
 
 /**
@@ -4756,15 +4981,17 @@ QueryBuilder.define('not-group', function(options) {
     });
 
     // Modify templates
-    this.on('getGroupTemplate.filter', function(h, level) {
-        var $h = $(h.value);
-        $h.find(QueryBuilder.selectors.condition_container).prepend(
-            '<button type="button" class="btn btn-xs btn-default" data-not="group">' +
-            '<i class="' + options.icon_unchecked + '"></i> ' + self.translate('NOT') +
-            '</button>'
-        );
-        h.value = $h.prop('outerHTML');
-    });
+    if (!options.disable_template) {
+        this.on('getGroupTemplate.filter', function(h) {
+            var $h = $(h.value);
+            $h.find(QueryBuilder.selectors.condition_container).prepend(
+                '<button type="button" class="btn btn-xs btn-default" data-not="group">' +
+                '<i class="' + options.icon_unchecked + '"></i> ' + self.translate('NOT') +
+                '</button>'
+            );
+            h.value = $h.prop('outerHTML');
+        });
+    }
 
     // Export "not" to JSON
     this.on('groupToJson.filter', function(e, group) {
@@ -4787,10 +5014,27 @@ QueryBuilder.define('not-group', function(options) {
     this.on('parseSQLNode.filter', function(e) {
         if (e.value.name && e.value.name.toUpperCase() == 'NOT') {
             e.value = e.value.arguments.value[0];
+
+            // if the there is no sub-group, create one
+            if (['AND', 'OR'].indexOf(e.value.operation.toUpperCase()) === -1) {
+                e.value = new SQLParser.nodes.Op(
+                    self.settings.default_condition,
+                    e.value,
+                    null
+                );
+            }
+
             e.value.not = true;
         }
     });
 
+    // Request to create sub-group if the "not" flag is set
+    this.on('sqlGroupsDistinct.filter', function(e, group, data, i) {
+        if (data.not && i > 0) {
+            e.value = true;
+        }
+    });
+
     // Read "not" from parsed SQL
     this.on('sqlToGroup.filter', function(e, data) {
         e.value.not = !!data.not;
@@ -4820,7 +5064,8 @@ QueryBuilder.define('not-group', function(options) {
     });
 }, {
     icon_unchecked: 'glyphicon glyphicon-unchecked',
-    icon_checked: 'glyphicon glyphicon-check'
+    icon_checked: 'glyphicon glyphicon-check',
+    disable_template: false
 });
 
 /**
@@ -4854,6 +5099,8 @@ QueryBuilder.extend(/** @lends module:plugins.NotGroup.prototype */ {
          * @param {Group} group
          */
         this.trigger('afterUpdateGroupNot', group);
+
+        this.trigger('rulesChanged');
     }
 });
 
@@ -4887,6 +5134,7 @@ QueryBuilder.define('sortable', function(options) {
     var placeholder;
     var ghost;
     var src;
+    var moved;
 
     // Init drag and drop
     this.on('afterAddRule afterAddGroup', function(e, node) {
@@ -4907,9 +5155,11 @@ QueryBuilder.define('sortable', function(options) {
         // Configure drag
         if (!node.flags.no_sortable) {
             interact(node.$el[0])
-                .allowFrom(QueryBuilder.selectors.drag_handle)
                 .draggable({
+                    allowFrom: QueryBuilder.selectors.drag_handle,
                     onstart: function(event) {
+                        moved = false;
+
                         // get model of dragged element
                         src = self.getModel(event.target);
 
@@ -4933,7 +5183,13 @@ QueryBuilder.define('sortable', function(options) {
                         ghost[0].style.top = event.clientY - 15 + 'px';
                         ghost[0].style.left = event.clientX - 15 + 'px';
                     },
-                    onend: function() {
+                    onend: function(event) {
+                        // starting from Interact 1.3.3, onend is called before ondrop
+                        if (event.dropzone) {
+                            moveSortableToTarget(src, $(event.relatedTarget), self);
+                            moved = true;
+                        }
+
                         // remove ghost
                         ghost.remove();
                         ghost = undefined;
@@ -4943,7 +5199,7 @@ QueryBuilder.define('sortable', function(options) {
                         placeholder = undefined;
 
                         // show element
-                        src.$el.show();
+                        src.$el.css('display', '');
 
                         /**
                          * After a node has been moved with {@link module:plugins.Sortable}
@@ -4952,6 +5208,8 @@ QueryBuilder.define('sortable', function(options) {
                          * @param {Node} node
                          */
                         self.trigger('afterMove', src);
+
+                        self.trigger('rulesChanged');
                     }
                 });
         }
@@ -4965,7 +5223,9 @@ QueryBuilder.define('sortable', function(options) {
                         moveSortableToTarget(placeholder, $(event.target), self);
                     },
                     ondrop: function(event) {
-                        moveSortableToTarget(src, $(event.target), self);
+                        if (!moved) {
+                            moveSortableToTarget(src, $(event.target), self);
+                        }
                     }
                 });
 
@@ -4978,7 +5238,9 @@ QueryBuilder.define('sortable', function(options) {
                             moveSortableToTarget(placeholder, $(event.target), self);
                         },
                         ondrop: function(event) {
-                            moveSortableToTarget(src, $(event.target), self);
+                            if (!moved) {
+                                moveSortableToTarget(src, $(event.target), self);
+                            }
                         }
                     });
             }
@@ -5004,23 +5266,26 @@ QueryBuilder.define('sortable', function(options) {
     });
 
     // Modify templates
-    this.on('getGroupTemplate.filter', function(h, level) {
-        if (level > 1) {
+    if (!options.disable_template) {
+        this.on('getGroupTemplate.filter', function(h, level) {
+            if (level > 1) {
+                var $h = $(h.value);
+                $h.find(QueryBuilder.selectors.condition_container).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
+                h.value = $h.prop('outerHTML');
+            }
+        });
+
+        this.on('getRuleTemplate.filter', function(h) {
             var $h = $(h.value);
-            $h.find(QueryBuilder.selectors.condition_container).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
+            $h.find(QueryBuilder.selectors.rule_header).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
             h.value = $h.prop('outerHTML');
-        }
-    });
-
-    this.on('getRuleTemplate.filter', function(h) {
-        var $h = $(h.value);
-        $h.find(QueryBuilder.selectors.rule_header).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
-        h.value = $h.prop('outerHTML');
-    });
+        });
+    }
 }, {
     inherit_no_sortable: true,
     inherit_no_drop: true,
-    icon: 'glyphicon glyphicon-sort'
+    icon: 'glyphicon glyphicon-sort',
+    disable_template: false
 });
 
 QueryBuilder.selectors.rule_and_group_containers = QueryBuilder.selectors.rule_container + ', ' + QueryBuilder.selectors.group_container;
@@ -5333,10 +5598,17 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
      */
     getSQL: function(stmt, nl, data) {
         data = (data === undefined) ? this.getRules() : data;
+
+        if (!data) {
+            return null;
+        }
+
         nl = !!nl ? '\n' : ' ';
         var boolean_as_integer = this.getPluginOptions('sql-support', 'boolean_as_integer');
 
-        if (stmt === true) stmt = 'question_mark';
+        if (stmt === true) {
+            stmt = 'question_mark';
+        }
         if (typeof stmt == 'string') {
             var config = getStmtConfig(stmt);
             stmt = this.settings.sqlStatements[config[1]](config[2]);
@@ -5381,10 +5653,10 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
                                 value += sql.sep;
                             }
 
-                            if (rule.type == 'integer' || rule.type == 'double' || rule.type == 'boolean') {
-                                v = Utils.changeType(v, rule.type, boolean_as_integer);
+                            if (rule.type == 'boolean' && boolean_as_integer) {
+                                v = v ? 1 : 0;
                             }
-                            else if (!stmt) {
+                            else if (!stmt && rule.type !== 'integer' && rule.type !== 'double' && rule.type !== 'boolean') {
                                 v = Utils.escapeString(v);
                             }
 
@@ -5406,7 +5678,9 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
                     }
 
                     var sqlFn = function(v) {
-                        return sql.op.replace(/\?/, v);
+                        return sql.op.replace('?', function() {
+                            return v;
+                        });
                     };
 
                     /**
@@ -5535,6 +5809,10 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
         var curr = out;
 
         (function flatten(data, i) {
+            if (data === null) {
+                return;
+            }
+
             // allow plugins to manually parse or handle special cases
             data = self.change('parseSQLNode', data);
 
@@ -5558,7 +5836,20 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
             // it's a node
             if (['AND', 'OR'].indexOf(data.operation.toUpperCase()) !== -1) {
                 // create a sub-group if the condition is not the same and it's not the first level
-                if (i > 0 && curr.condition != data.operation.toUpperCase()) {
+
+                /**
+                 * Given an existing group and an AST node, determines if a sub-group must be created
+                 * @event changer:sqlGroupsDistinct
+                 * @memberof module:plugins.SqlSupport
+                 * @param {boolean} create - true by default if the group condition is different
+                 * @param {object} group
+                 * @param {object} AST
+                 * @param {int} current group level
+                 * @returns {boolean}
+                 */
+                var createGroup = self.change('sqlGroupsDistinct', i > 0 && curr.condition != data.operation.toUpperCase(), curr, data, i);
+
+                if (createGroup) {
                     /**
                      * Modifies the group generated from the SQL expression (this is called before the group is filled with rules)
                      * @event changer:sqlToGroup
@@ -5681,7 +5972,7 @@ QueryBuilder.extend(/** @lends module:plugins.SqlSupport.prototype */ {
      */
     getSQLFieldID: function(field, value) {
         var matchingFilters = this.filters.filter(function(filter) {
-            return filter.field === field;
+            return filter.field.toLowerCase() === field.toLowerCase();
         });
 
         var id;
@@ -5835,10 +6126,10 @@ QueryBuilder.extend(/** @lends module:plugins.UniqueFilter.prototype */ {
 
 
 /*!
- * jQuery QueryBuilder 2.4.4
+ * jQuery QueryBuilder 2.5.2
  * Locale: English (en)
  * Author: Damien "Mistic" Sorel, http://www.strangeplanet.fr
- * Licensed under MIT (http://opensource.org/licenses/MIT)
+ * Licensed under MIT (https://opensource.org/licenses/MIT)
  */
 
 QueryBuilder.regional['en'] = {
@@ -5890,10 +6181,12 @@ QueryBuilder.regional['en'] = {
     "number_exceed_min": "Must be greater than {0}",
     "number_exceed_max": "Must be lower than {0}",
     "number_wrong_step": "Must be a multiple of {0}",
+    "number_between_invalid": "Invalid values, {0} is greater than {1}",
     "datetime_empty": "Empty value",
     "datetime_invalid": "Invalid date format ({0})",
     "datetime_exceed_min": "Must be after {0}",
     "datetime_exceed_max": "Must be before {0}",
+    "datetime_between_invalid": "Invalid values, {0} is greater than {1}",
     "boolean_not_valid": "Not a boolean",
     "operator_not_multiple": "Operator \"{1}\" cannot accept multiple values"
   },