diff --git a/examples/index.html b/examples/index.html
index 205d2a06..7699fbd1 100644
--- a/examples/index.html
+++ b/examples/index.html
@@ -124,6 +124,127 @@ <h3>Output</h3>
   //default_filter: 'name',
   sort_filters: true,
 
+  sections: [
+    {
+      id: 'subquery-a',
+      label: 'Subquery A',
+      base_sql: 'SELECT a_id FROM section_a WHERE parent_id = 10 AND ',
+      filters: [
+        {
+          id: 'sqa_name',
+          label: {
+            en: 'Subquery A Name',
+            fr: 'Nom'
+          },
+          type: 'string',
+          optgroup: 'core',
+          default_value: 'Subquery Name',
+          size: 30,
+          unique: true
+        },
+        {
+          id: 'sqa_category',
+          label: 'Subquery A Category',
+          type: 'integer',
+          input: 'checkbox',
+          optgroup: 'core',
+          values: {
+            1: 'Books',
+            2: 'Movies',
+            3: 'Music',
+            4: 'Tools',
+            5: 'Goodies',
+            6: 'Clothes'
+          },
+          colors: {
+            1: 'foo',
+            2: 'warning',
+            5: 'success'
+          },
+          operators: ['in', 'not_in', 'equal', 'not_equal', 'is_null', 'is_not_null']
+        }
+      ]
+    },
+    {
+      id: 'subquery-b',
+      label: 'Subquery B',
+      filters: [
+        {
+          id: 'sqb_name',
+          label: {
+            en: 'Subquery B Name',
+            fr: 'Nom'
+          },
+          type: 'string',
+          optgroup: 'core',
+          default_value: 'Subquery Name',
+          size: 30,
+          unique: true
+        },
+        {
+          id: 'sqb_category',
+          label: 'Subquery B Category',
+          type: 'integer',
+          input: 'checkbox',
+          optgroup: 'core',
+          values: {
+            1: 'Books',
+            2: 'Movies',
+            3: 'Music',
+            4: 'Tools',
+            5: 'Goodies',
+            6: 'Clothes'
+          },
+          colors: {
+            1: 'foo',
+            2: 'warning',
+            5: 'success'
+          },
+          operators: ['in', 'not_in', 'equal', 'not_equal', 'is_null', 'is_not_null']
+        }
+      ]
+    },
+    {
+      id: 'subquery-c',
+      label: 'Subquery C',
+      filters: [
+        {
+          id: 'sqc_name',
+          label: {
+            en: 'Subquery C Name',
+            fr: 'Nom'
+          },
+          type: 'string',
+          optgroup: 'core',
+          default_value: 'Subquery Name',
+          size: 30,
+          unique: true
+        },
+        {
+          id: 'sqc_category',
+          label: 'Subquery C Category',
+          type: 'integer',
+          input: 'checkbox',
+          optgroup: 'core',
+          values: {
+            1: 'Books',
+            2: 'Movies',
+            3: 'Music',
+            4: 'Tools',
+            5: 'Goodies',
+            6: 'Clothes'
+          },
+          colors: {
+            1: 'foo',
+            2: 'warning',
+            5: 'success'
+          },
+          operators: ['in', 'not_in', 'equal', 'not_equal', 'is_null', 'is_not_null']
+        }
+      ]
+    }
+  ],
+
   optgroups: {
     core: {
       en: 'Core',
@@ -446,8 +567,7 @@ <h3>Output</h3>
 });
 
 // set rules
-$('.set').on('click', function() {
-  $('#builder').queryBuilder('setRules', {
+var json_rules = {
     condition: 'AND',
     flags: {
       condition_readonly: true
@@ -463,6 +583,21 @@ <h3>Output</h3>
       data: {
         unit: '€'
       }
+    }, {
+      section: 'subquery-a',
+      exists: 'EXISTS',
+      group: {
+        condition: 'AND',
+        rules: [{
+          id: 'sqa-name',
+          operator: 'equal',
+          value: 'Name Within Subquery A'
+        }, {
+          id: 'sqa-category',
+          operator: 'in',
+          value: [2,3]
+        }]
+      }
     }, {
       id: 'state',
       operator: 'equal',
@@ -489,7 +624,10 @@ <h3>Output</h3>
     }, {
         empty: true
     }]
-  });
+  };
+
+$('.set').on('click', function() {
+  $('#builder').queryBuilder('setRules', json_rules);
 });
 
 // set rules from MongoDB
diff --git a/src/core.js b/src/core.js
index 33138413..0359c407 100644
--- a/src/core.js
+++ b/src/core.js
@@ -9,6 +9,7 @@ QueryBuilder.prototype.init = function($el, options) {
     this.settings = $.extendext(true, 'replace', {}, QueryBuilder.DEFAULTS, options);
     this.model = new Model();
     this.status = {
+        section_id: 0,
         group_id: 0,
         rule_id: 0,
         generated_id: false,
@@ -28,6 +29,7 @@ QueryBuilder.prototype.init = function($el, options) {
 
     // SETTINGS SHORTCUTS
     this.filters = this.settings.filters;
+    this.sections = this.settings.sections;
     this.icons = this.settings.icons;
     this.operators = this.settings.operators;
     this.templates = this.settings.templates;
@@ -60,7 +62,13 @@ QueryBuilder.prototype.init = function($el, options) {
     this.$el.addClass('query-builder form-inline');
 
     this.filters = this.checkFilters(this.filters);
+    this.sections = this.checkSections(this.sections);
     this.operators = this.checkOperators(this.operators);
+
+    if (this.sections.length > 0) {
+        this.settings.has_sections = true;
+    }
+
     this.bindEvents();
     this.initPlugins();
 
@@ -79,19 +87,20 @@ QueryBuilder.prototype.init = function($el, options) {
  * Checks the configuration of each filter
  * @throws ConfigError
  */
-QueryBuilder.prototype.checkFilters = function(filters) {
+QueryBuilder.prototype.checkFilters = function(filters, section) {
     var definedFilters = [];
+    var sectiontag = function(i) { if (section) { return ' [section: {' + i + '}]'; } };
 
     if (!filters || filters.length === 0) {
-        Utils.error('Config', 'Missing filters list');
+        Utils.error('Config', 'Missing filters list' + sectiontag(0), section);
     }
 
     filters.forEach(function(filter, i) {
         if (!filter.id) {
-            Utils.error('Config', 'Missing filter {0} id', i);
+            Utils.error('Config', 'Missing filter {0} id' + sectiontag(1), i, section);
         }
         if (definedFilters.indexOf(filter.id) != -1) {
-            Utils.error('Config', 'Filter "{0}" already defined', filter.id);
+            Utils.error('Config', 'Filter "{0}" already defined' + sectiontag(1), filter.id, section);
         }
         definedFilters.push(filter.id);
 
@@ -99,20 +108,20 @@ QueryBuilder.prototype.checkFilters = function(filters) {
             filter.type = 'string';
         }
         else if (!QueryBuilder.types[filter.type]) {
-            Utils.error('Config', 'Invalid type "{0}"', filter.type);
+            Utils.error('Config', 'Invalid type "{0}"' + sectiontag(1), filter.type, section);
         }
 
         if (!filter.input) {
             filter.input = 'text';
         }
         else if (typeof filter.input != 'function' && QueryBuilder.inputs.indexOf(filter.input) == -1) {
-            Utils.error('Config', 'Invalid input "{0}"', filter.input);
+            Utils.error('Config', 'Invalid input "{0}"' + sectiontag(1), filter.input, section);
         }
 
         if (filter.operators) {
             filter.operators.forEach(function(operator) {
                 if (typeof operator != 'string') {
-                    Utils.error('Config', 'Filter operators must be global operators types (string)');
+                    Utils.error('Config', 'Filter operators must be global operators types (string)' + sectiontag(0), section);
                 }
             });
         }
@@ -139,7 +148,7 @@ QueryBuilder.prototype.checkFilters = function(filters) {
         switch (filter.input) {
             case 'radio': case 'checkbox':
                 if (!filter.values || filter.values.length < 1) {
-                    Utils.error('Config', 'Missing filter "{0}" values', filter.id);
+                    Utils.error('Config', 'Missing filter "{0}" values' + sectiontag(1), filter.id, section);
                 }
                 break;
 
@@ -150,7 +159,7 @@ QueryBuilder.prototype.checkFilters = function(filters) {
                     }
                     Utils.iterateOptions(filter.values, function(key) {
                         if (key == filter.placeholder_value) {
-                            Utils.error('Config', 'Placeholder of filter "{0}" overlaps with one of its values', filter.id);
+                            Utils.error('Config', 'Placeholder of filter "{0}" overlaps with one of its values' + sectiontag(1), filter.id, section);
                         }
                     });
                 }
@@ -177,6 +186,32 @@ QueryBuilder.prototype.checkFilters = function(filters) {
     return filters;
 };
 
+/**
+ * Checks the configuration of each section
+ * @throws ConfigError
+ */
+QueryBuilder.prototype.checkSections = function(sections) {
+    if (!this.settings.allow_sections) {
+        return [];
+    }
+
+    var definedSections = [];
+
+    sections.forEach(function(section, i) {
+        if (!section.id) {
+            Utils.error('Config', 'Missing section {0} id', i);
+        }
+        if (definedSections.indexOf(section.id) != -1) {
+            Utils.error('Config', 'Section "{0}" already defined', section.id);
+        }
+        sections[i].filters = this.checkFilters(sections[i].filters, sections[i].id);
+        definedSections.push(section.id);
+    }, this);
+
+    return sections;
+};
+
+
 /**
  * Checks the configuration of each operator
  * @throws ConfigError
@@ -248,7 +283,8 @@ QueryBuilder.prototype.bindEvents = function() {
     // rule filter change
     this.$el.on('change.queryBuilder', Selectors.rule_filter, function() {
         var $rule = $(this).closest(Selectors.rule_container);
-        Model($rule).filter = self.getFilterById($(this).val());
+        var m = Model($rule);
+        m.filter = self.getFilterById($(this).val(), m.section_type_id);
     });
 
     // rule operator change
@@ -283,6 +319,37 @@ QueryBuilder.prototype.bindEvents = function() {
         });
     }
 
+    if (this.settings.allow_sections && this.settings.has_sections) {
+        // section exists change
+        this.$el.on('change.queryBuilder', Selectors.section_exists_flag, function() {
+            if ($(this).is(':checked')) {
+                var $section = $(this).closest(Selectors.section_container);
+                Model($section).exists = $(this).val();
+            }
+        });
+
+        // section type change
+        this.$el.on('change.queryBuilder', Selectors.rule_stype, function() {
+            var sid = $(this).val();
+            var $section = $(this).closest(Selectors.section_container);
+            var model = Model($section);
+            model.type_id = sid;
+            self.refreshSection(model);
+        });
+
+        // add section button
+        this.$el.on('click.queryBuilder', Selectors.add_section, function() {
+            var $group = $(this).closest(Selectors.group_container);
+            self.addSection(Model($group));
+        });
+
+        // delete section button
+        this.$el.on('click.queryBuilder', Selectors.delete_section, function() {
+            var $section = $(this).closest(Selectors.section_container);
+            self.deleteSection(Model($section));
+        });
+    }
+
     // model events
     this.model.on({
         'drop': function(e, node) {
@@ -298,6 +365,10 @@ QueryBuilder.prototype.bindEvents = function() {
             }
             self.refreshGroupsConditions();
         },
+        'set': function(e, node) {
+            node.parent.$el.find('>' + Selectors.section_body).empty().append(node.$el);
+            self.updateSectionExistsFlag(node.parent);
+        },
         'move': function(e, node, group, index) {
             node.$el.detach();
 
@@ -331,9 +402,13 @@ QueryBuilder.prototype.bindEvents = function() {
                     case 'value':
                         self.updateRuleValue(node);
                         break;
+
+                    case 'section_type_id':
+                        self.updateRuleSectionTypeId(node);
+                        break;
                 }
             }
-            else {
+            else if (node instanceof Group) {
                 switch (field) {
                     case 'error':
                         self.displayError(node);
@@ -346,6 +421,29 @@ QueryBuilder.prototype.bindEvents = function() {
                     case 'condition':
                         self.updateGroupCondition(node);
                         break;
+
+                    case 'section_type_id':
+                        self.updateGroupSectionTypeId(node);
+                        break;
+                }
+            }
+            else if (node instanceof Section) {
+                switch (field) {
+                    case 'error':
+                        self.displayError(node);
+                        break;
+
+                    case 'type_id':
+                        self.updateSectionTypeId(node);
+                        break;
+
+                    case 'exists':
+                        self.updateSectionExistsFlag(node);
+                        break;
+
+                    case 'flags':
+                        self.applySectionFlags(node);
+                        break;
                 }
             }
         }
@@ -402,8 +500,17 @@ QueryBuilder.prototype.addGroup = function(parent, addRule, data, flags) {
     }
 
     var group_id = this.nextGroupId();
-    var $group = $(this.getGroupTemplate(group_id, level));
-    var model = parent.addGroup($group);
+    var section_root = parent instanceof Section;
+    var stype = section_root ? parent.type_id : parent.section_type_id;
+    var in_section = section_root || stype !== undefined;
+    var $group = $(this.getGroupTemplate(group_id, level, stype, in_section, section_root));
+    var model = null;
+    if (parent instanceof Section) {
+        model = parent.setGroup($group);
+    }
+    else {
+        model = parent.addGroup($group);
+    }
 
     model.data = data;
     model.flags = $.extend({}, this.settings.default_group_flags, flags);
@@ -440,6 +547,8 @@ QueryBuilder.prototype.deleteGroup = function(group) {
         del&= this.deleteRule(rule);
     }, function(group) {
         del&= this.deleteGroup(group);
+    }, function(section) {
+        del&= this.deleteSection(section);
     }, this);
 
     if (del) {
@@ -476,10 +585,168 @@ QueryBuilder.prototype.refreshGroupsConditions = function() {
 
         group.each(function(rule) {}, function(group) {
             walk(group);
+        }, function(section) {
+            if (section.group) {
+                walk(section.group);
+            }
         }, this);
     }(this.model.root));
 };
 
+/**
+ * Add a new section
+ * @param parent {Group}
+ * @param addRule {bool,optional} add a default empty rule
+ * @param data {mixed,optional} section custom data
+ * @param flags {object,optional} flags to apply to the section
+ * @return section {Section}
+ */
+QueryBuilder.prototype.addSection = function(parent, addRule, data, flags) {
+    addRule = (addRule === undefined || addRule === true);
+
+    var level = parent.level + 1;
+
+    var e = this.trigger('beforeAddSection', parent, addRule, level);
+    if (e.isDefaultPrevented()) {
+        return null;
+    }
+
+    var section_id = this.nextSectionId();
+    var $section = $(this.getSectionTemplate(section_id, level));
+    var model = parent.addSection($section);
+
+    model.data = data;
+    model.flags = $.extend({}, this.settings.default_section_flags, flags);
+
+    this.trigger('afterAddSection', model);
+
+    model.exists = this.settings.default_exists;
+
+    this.createSectionTypes(model);
+
+    if (addRule && this.settings.default_section) {
+        model.type_id = this.settings.default_section;
+        this.addGroup(model, true);
+    }
+
+    return model;
+};
+
+/**
+ * Tries to delete a section. The section is not deleted if at least one rule is no_delete.
+ * @param section {Section}
+ * @return {boolean} true if the section has been deleted
+ */
+QueryBuilder.prototype.deleteSection = function(section) {
+    var e = this.trigger('beforeDeleteSection', section);
+    if (e.isDefaultPrevented()) {
+        return false;
+    }
+
+    if (section.group) {
+        if (!this.deleteGroup(section.group)) {
+            return false;
+        }
+    }
+
+    section.drop();
+    this.trigger('afterDeleteSection');
+
+    return true;
+};
+
+/**
+ * Changes the type setting of a section
+ * @param section {Section}
+ */
+QueryBuilder.prototype.updateSectionTypeId = function(section) {
+    section.$el.find(Selectors.rule_stype).val(section.type_id ? section.type_id : '-1');
+    section.$el.attr('data-stype', section.type_id);
+    this.trigger('afterUpdateSectionTypeId', section);
+};
+
+/**
+ * Changes the section type setting of a group
+ * @param section {Section}
+ */
+QueryBuilder.prototype.updateGroupSectionTypeId = function(group) {
+    group.$el.attr('data-stype', group.section_type_id);
+    this.trigger('afterUpdateGroupSectionTypeId', group);
+};
+
+/**
+ * Changes the section type setting of a rule
+ * @param section {Section}
+ */
+QueryBuilder.prototype.updateRuleSectionTypeId = function(rule) {
+    rule.$el.attr('data-stype', rule.section_type_id);
+    this.trigger('afterUpdateRuleSectionTypeId', rule);
+};
+
+/**
+ * Changes the exists setting of a section
+ * @param section {Section}
+ */
+QueryBuilder.prototype.updateSectionExistsFlag = function(section) {
+    section.$el.find('>' + Selectors.section_exists_flag).each(function() {
+        var $this = $(this);
+        $this.prop('checked', $this.val() === section.exists);
+        $this.parent().toggleClass('active', $this.val() === section.exists);
+    });
+
+    this.trigger('afterUpdateSectionExistsFlag', section);
+};
+
+/**
+ * Create the type <select> for a section
+ * @param section {Section}
+ */
+QueryBuilder.prototype.createSectionTypes = function(section) {
+    var stypes = this.change('getSectionTypes', this.sections, section);
+    var $stypesSelect = $(this.getSectionTypeSelect(section, stypes));
+
+    section.$el.find(Selectors.stype_container).html($stypesSelect);
+
+    this.trigger('afterCreateSectionStypes', section);
+};
+
+/**
+ * Refreshes a section after a type change
+ * @param section {Section}
+ */
+QueryBuilder.prototype.refreshSection = function(model) {
+
+    if (model.type_id && model.type_id != '-1') {
+        // Clear out the section if there's any group or rule that don't belong
+        var ok = true;
+        model.$el.find(Selectors.group_container).each(function() {
+            var group = Model($(this));
+            if (group.section_type_id != model.type_id) {
+                ok = false;
+            }
+        });
+        if (ok) {
+            model.$el.find(Selectors.rule_container).each(function() {
+                var rule = Model($(this));
+                if (rule.section_type_id != model.type_id) {
+                    ok = false;
+                }
+            });
+        }
+        if (!ok) {
+            model.empty();
+        }
+        if (!model.group) {
+            var group = this.addGroup(model, true);
+        }
+    }
+    else {
+        model.empty();
+    }
+
+    this.trigger('afterRefreshSection', model);
+};
+
 /**
  * Add a new rule
  * @param parent {Group}
@@ -494,7 +761,7 @@ QueryBuilder.prototype.addRule = function(parent, data, flags) {
     }
 
     var rule_id = this.nextRuleId();
-    var $rule = $(this.getRuleTemplate(rule_id));
+    var $rule = $(this.getRuleTemplate(rule_id, parent.section_type_id));
     var model = parent.addRule($rule);
 
     if (data !== undefined) {
@@ -507,11 +774,20 @@ QueryBuilder.prototype.addRule = function(parent, data, flags) {
 
     this.createRuleFilters(model);
 
-    if (this.settings.default_filter || !this.settings.display_empty_filter) {
-        model.filter = this.change('getDefaultFilter',
-            this.getFilterById(this.settings.default_filter || this.filters[0].id),
-            model
-        );
+    if (model.section_type_id) {
+        var s = this.getSectionById(model.section_type_id);
+        if (s.default_filter || !this.settings.display_empty_filter) {
+            var d = s.default_filter || s.filters[0].id;
+            model.filter = this.change('getDefaultFilter', this.getFilterById(d, s.id), model);
+        }
+    }
+    else {
+        if (this.settings.default_filter || !this.settings.display_empty_filter) {
+            model.filter = this.change('getDefaultFilter',
+                this.getFilterById(this.settings.default_filter || this.filters[0].id),
+                model
+            );
+        }
     }
 
     return model;
@@ -544,7 +820,19 @@ QueryBuilder.prototype.deleteRule = function(rule) {
  * @param rule {Rule}
  */
 QueryBuilder.prototype.createRuleFilters = function(rule) {
-    var filters = this.change('getRuleFilters', this.filters, rule);
+    var filters = [];
+    if (rule.section_type_id) {
+        var section = this.getSectionById(rule.section_type_id);
+        if (section) {
+            filters = this.change('getRuleFilters', section.filters, rule);
+        }
+        else {
+            filters = this.change('getRuleFilters', [], rule);
+        }
+    }
+    else {
+        filters = this.change('getRuleFilters', this.filters, rule);
+    }
     var $filterSelect = $(this.getRuleFilterSelect(rule, filters));
 
     rule.$el.find(Selectors.filter_container).html($filterSelect);
@@ -563,7 +851,7 @@ QueryBuilder.prototype.createRuleOperators = function(rule) {
         return;
     }
 
-    var operators = this.getOperators(rule.filter);
+    var operators = this.getOperators(rule.filter, rule.section_type_id);
     var $operatorSelect = $(this.getRuleOperatorSelect(rule, operators));
 
     $operatorContainer.html($operatorSelect);
@@ -730,6 +1018,33 @@ QueryBuilder.prototype.applyGroupFlags = function(group) {
     this.trigger('afterApplyGroupFlags', group);
 };
 
+/**
+ * Change section properties depending on flags.
+ * @param section {Section}
+ */
+QueryBuilder.prototype.applySectionFlags = function(section) {
+    var flags = section.flags;
+
+    if (flags.exists_readonly) {
+        section.$el.find('>' + Selectors.section_exists_flag).prop('disabled', true)
+            .parent().addClass('readonly');
+    }
+    if (flags.no_add_rule) {
+        section.$el.find(Selectors.add_rule).remove();
+    }
+    if (flags.no_add_group) {
+        section.$el.find(Selectors.add_group).remove();
+    }
+    if (flags.no_delete) {
+        section.$el.find(Selectors.delete_section).remove();
+    }
+    this.trigger('afterApplySectionFlags', section);
+
+    if (section.group) {
+        this.applyGroupFlags(section.group);
+    }
+};
+
 /**
  * Clear all errors markers
  * @param node {Node,optional} default is root Group
@@ -748,6 +1063,10 @@ QueryBuilder.prototype.clearErrors = function(node) {
             rule.error = null;
         }, function(group) {
             this.clearErrors(group);
+        }, function(section) {
+            if (section.group) {
+                this.clearErrors(section.group);
+            }
         }, this);
     }
 };
diff --git a/src/data.js b/src/data.js
index 6cb5a28e..47eb0003 100644
--- a/src/data.js
+++ b/src/data.js
@@ -212,14 +212,42 @@ QueryBuilder.prototype.nextRuleId = function() {
     return this.status.id + '_rule_' + (this.status.rule_id++);
 };
 
+/**
+ * Returns an incremented section ID
+ * @return {string}
+ */
+QueryBuilder.prototype.nextSectionId = function() {
+    return this.status.id + '_section_' + (this.status.section_id++);
+};
+
+/**
+ * Returns a particular section by its id
+ * @throws UndefinedSectionError
+ * @param sectionId {string}
+ * @return {object|null}
+ */
+QueryBuilder.prototype.getSectionById = function(id) {
+    if (id == '-1') {
+        return null;
+    }
+
+    for (var i = 0, l = this.sections.length; i < l; i++) {
+        if (this.sections[i].id == id) {
+            return this.sections[i];
+        }
+    }
+
+    Utils.error('UndefinedSection', 'Undefined section "{0}"', id);
+};
+
 /**
  * Returns the operators for a filter
  * @param filter {string|object} (filter id name or filter object)
  * @return {object[]}
  */
-QueryBuilder.prototype.getOperators = function(filter) {
+QueryBuilder.prototype.getOperators = function(filter, sectionId) {
     if (typeof filter == 'string') {
-        filter = this.getFilterById(filter);
+        filter = this.getFilterById(filter, sectionId);
     }
 
     var result = [];
@@ -253,16 +281,25 @@ QueryBuilder.prototype.getOperators = function(filter) {
  * Returns a particular filter by its id
  * @throws UndefinedFilterError
  * @param filterId {string}
+ * @param sectionId {string|null}
  * @return {object|null}
  */
-QueryBuilder.prototype.getFilterById = function(id) {
+QueryBuilder.prototype.getFilterById = function(id, sectionId) {
     if (id == '-1') {
         return null;
     }
 
-    for (var i = 0, l = this.filters.length; i < l; i++) {
-        if (this.filters[i].id == id) {
-            return this.filters[i];
+    var filters = [];
+    if (sectionId) {
+        var s = this.getSectionById(sectionId);
+        filters = s ? s.filters : [];
+    }
+    else {
+        filters = this.filters;
+    }
+    for (var i = 0, l = filters.length; i < l; i++) {
+        if (filters[i].id == id) {
+            return filters[i];
         }
     }
 
@@ -499,6 +536,51 @@ QueryBuilder.prototype.getGroupFlags = function(flags, all) {
     }
 };
 
+/**
+ * Clean section flags.
+ * @param section {object}
+ * @return {object}
+ */
+QueryBuilder.prototype.parseSectionFlags = function(section) {
+    var flags = $.extend({}, this.settings.default_section_flags);
+
+    if (section.readonly) {
+        $.extend(flags, {
+            exists_readonly: true,
+            no_add_rule: true,
+            no_add_group: true,
+            no_delete: true
+        });
+    }
+
+    if (section.flags) {
+        $.extend(flags, section.flags);
+    }
+
+    return this.change('parseSectionFlags', flags, section);
+};
+
+/**
+ * Get a copy of flags of a section.
+ * @param {object} flags
+ * @param {boolean} all - true to return all flags, false to return only changes from default
+ * @returns {object}
+ */
+QueryBuilder.prototype.getSectionFlags = function(flags, all) {
+    if (all) {
+        return $.extend({}, flags);
+    }
+    else {
+        var ret = {};
+        $.each(this.settings.default_section_flags, function(key, value) {
+            if (flags[key] !== value) {
+                ret[key] = flags[key];
+            }
+        });
+        return ret;
+    }
+};
+
 /**
  * Translate a label
  * @param label {string|object}
diff --git a/src/defaults.js b/src/defaults.js
index fffde6f5..b73d5ca6 100644
--- a/src/defaults.js
+++ b/src/defaults.js
@@ -28,6 +28,7 @@ QueryBuilder.inputs = [
 QueryBuilder.modifiable_options = [
     'display_errors',
     'allow_groups',
+    'allow_sections',
     'allow_empty',
     'default_condition',
     'default_filter'
@@ -37,22 +38,30 @@ QueryBuilder.modifiable_options = [
  * CSS selectors for common components
  */
 var Selectors = QueryBuilder.selectors = {
+    section_container:    '.rules-section-container',
     group_container:      '.rules-group-container',
     rule_container:       '.rule-container',
+    stype_container:      '.rule-stype-container',
     filter_container:     '.rule-filter-container',
     operator_container:   '.rule-operator-container',
     value_container:      '.rule-value-container',
     error_container:      '.error-container',
     condition_container:  '.rules-group-header .group-conditions',
+    exists_container:     '.rules-section-header .section-exists-options',
 
-    rule_header:          '.rule-header',
+    section_header:       '.rules-section-header',
     group_header:         '.rules-group-header',
+    rule_header:          '.rule-header',
+    section_actions:      '.section-actions',
     group_actions:        '.group-actions',
     rule_actions:         '.rule-actions',
 
+    section_body:         '.rules-section-body',
     rules_list:           '.rules-group-body>.rules-list',
 
+    section_exists_flag:  '.rules-section-header [name$=_exists]',
     group_condition:      '.rules-group-header [name$=_cond]',
+    rule_stype:           '.rule-stype-container [name$=_section_type]',
     rule_filter:          '.rule-filter-container [name$=_filter]',
     rule_operator:        '.rule-operator-container [name$=_operator]',
     rule_value:           '.rule-value-container [name*=_value_]',
@@ -60,7 +69,9 @@ var Selectors = QueryBuilder.selectors = {
     add_rule:             '[data-add=rule]',
     delete_rule:          '[data-delete=rule]',
     add_group:            '[data-add=group]',
-    delete_group:         '[data-delete=group]'
+    delete_group:         '[data-delete=group]',
+    add_section:          '[data-add=section]',
+    delete_section:       '[data-delete=section]'
 };
 
 /**
@@ -104,6 +115,7 @@ QueryBuilder.OPERATORS = {
  */
 QueryBuilder.DEFAULTS = {
     filters: [],
+    sections: [],
     plugins: [],
 
     sort_filters: false,
@@ -112,9 +124,15 @@ QueryBuilder.DEFAULTS = {
     allow_empty: false,
     conditions: ['AND', 'OR'],
     default_condition: 'AND',
+    allow_sections: true,
+    has_sections: false,
+    default_section: null,
+    exist_options: ['EXISTS', 'DOES NOT EXIST'],
+    default_exists: 'EXISTS',
     inputs_separator: ' , ',
     select_placeholder: '------',
     display_empty_filter: true,
+    display_empty_stype_filter: true,
     default_filter: null,
     optgroups: {},
 
@@ -132,7 +150,16 @@ QueryBuilder.DEFAULTS = {
         no_delete: false
     },
 
+    default_section_flags: {
+        exists_readonly: false,
+        no_add_rule: false,
+        no_add_group: false,
+        no_delete: false
+    },
+
     templates: {
+        section: null,
+        stypeSelect: null,
         group: null,
         rule: null,
         filterSelect: null,
@@ -166,10 +193,12 @@ QueryBuilder.DEFAULTS = {
     ],
 
     icons: {
-        add_group:    'glyphicon glyphicon-plus-sign',
-        add_rule:     'glyphicon glyphicon-plus',
-        remove_group: 'glyphicon glyphicon-remove',
-        remove_rule:  'glyphicon glyphicon-remove',
-        error:        'glyphicon glyphicon-warning-sign'
+        add_section:    'glyphicon glyphicon-plus-sign',
+        add_group:      'glyphicon glyphicon-plus-sign',
+        add_rule:       'glyphicon glyphicon-plus',
+        remove_section: 'glyphicon glyphicon-remove',
+        remove_group:   'glyphicon glyphicon-remove',
+        remove_rule:    'glyphicon glyphicon-remove',
+        error:          'glyphicon glyphicon-warning-sign'
     }
 };
diff --git a/src/i18n/en.json b/src/i18n/en.json
index b5828139..ff0e3260 100644
--- a/src/i18n/en.json
+++ b/src/i18n/en.json
@@ -4,14 +4,21 @@
 
   "add_rule": "Add rule",
   "add_group": "Add group",
+  "add_section": "Add section",
   "delete_rule": "Delete",
   "delete_group": "Delete",
+  "delete_section": "Delete",
 
   "conditions": {
     "AND": "AND",
     "OR": "OR"
   },
 
+  "exist_options": {
+    "EXISTS": "EXISTS",
+    "NOT EXISTS": "DOES NOT EXIST"
+  },
+
   "operators": {
     "equal": "equal",
     "not_equal": "not equal",
@@ -37,6 +44,7 @@
 
   "errors": {
     "no_filter": "No filter selected",
+    "no_type": "No section type selected",
     "empty_group": "The group is empty",
     "radio_empty": "No value selected",
     "checkbox_empty": "No value selected",
@@ -58,4 +66,4 @@
     "boolean_not_valid": "Not a boolean",
     "operator_not_multiple": "Operator {0} cannot accept multiple values"
   }
-}
\ No newline at end of file
+}
diff --git a/src/model.js b/src/model.js
index 39db5988..afccbeb4 100644
--- a/src/model.js
+++ b/src/model.js
@@ -147,7 +147,7 @@ Node.prototype.getPos = function() {
 Node.prototype.drop = function() {
     var model = this.model;
 
-    if (!this.isRoot()) {
+    if (!this.isRoot() && this.parent instanceof Group) {
         this.parent._removeNode(this);
     }
 
@@ -221,7 +221,7 @@ Node.prototype._move = function(group, index) {
 // GROUP CLASS
 // ===============================
 /**
- * @param {Group}
+ * @param {Group|Section}
  * @param {jQuery}
  */
 var Group = function(parent, $el) {
@@ -232,6 +232,7 @@ var Group = function(parent, $el) {
     Node.call(this, parent, $el);
 
     this.rules = [];
+    this.__.section_type_id = null;
     this.__.condition = null;
 };
 
@@ -248,6 +249,8 @@ Group.prototype.empty = function() {
         rule.drop();
     }, function(group) {
         group.drop();
+    }, function(section) {
+        section.drop();
     });
 };
 
@@ -281,6 +284,9 @@ Group.prototype._appendNode = function(node, index, trigger) {
 
     this.rules.splice(index, 0, node);
     node.parent = this;
+    if (!(node instanceof Section)) {
+        node.section_type_id = this.section_type_id;
+    }
 
     if (trigger && this.model !== null) {
         this.model.trigger('add', node, index);
@@ -309,6 +315,16 @@ Group.prototype.addRule = function($el, index) {
     return this._appendNode(new Rule(this, $el), index, true);
 };
 
+/**
+ * Add a Section by jQuery element at specified index
+ * @param {jQuery}
+ * @param {int,optional}
+ * @return {Section} the inserted section
+ */
+Group.prototype.addSection = function($el, index) {
+    return this._appendNode(new Section(this, $el), index, true);
+};
+
 /**
  * Delete a specific Node
  * @param {Node}
@@ -338,11 +354,13 @@ Group.prototype.getNodePos = function(node) {
  * @param {boolean,optional} iterate in reverse order, required if you delete nodes
  * @param {function} callback for Rules
  * @param {function,optional} callback for Groups
+ * @param {function,optional} callback for Sections
  * @return {boolean}
  */
-Group.prototype.each = function(reverse, cbRule, cbGroup, context) {
+Group.prototype.each = function(reverse, cbRule, cbGroup, cbSection, context) {
     if (typeof reverse == 'function') {
-        context = cbGroup;
+        context = cbSection;
+        cbSection = cbGroup;
         cbGroup = cbRule;
         cbRule = reverse;
         reverse = false;
@@ -361,6 +379,11 @@ Group.prototype.each = function(reverse, cbRule, cbGroup, context) {
                 stop = cbGroup.call(context, this.rules[i]) === false;
             }
         }
+        else if (this.rules[i] instanceof Section) {
+            if (cbSection !== undefined) {
+                stop = cbSection.call(context, this.rules[i]) === false;
+            }
+        }
         else {
             stop = cbRule.call(context, this.rules[i]) === false;
         }
@@ -392,6 +415,13 @@ Group.prototype.contains = function(node, deep) {
             return true;
         }, function(group) {
             return !group.contains(node, true);
+        }, function(section) {
+            if (section.group) {
+                return !section.group.contains(node, true);
+            }
+            else {
+                return true;
+            }
         });
     }
 };
@@ -410,6 +440,7 @@ var Rule = function(parent, $el) {
 
     Node.call(this, parent, $el);
 
+    this.__.section_type_id = null;
     this.__.filter = null;
     this.__.operator = null;
     this.__.flags = {};
@@ -421,8 +452,68 @@ Rule.prototype.constructor = Rule;
 
 Model.defineModelProperties(Rule, ['filter', 'operator', 'value']);
 
+// Section CLASS
+// ===============================
+/**
+ * @param {Section}
+ * @param {jQuery}
+ */
+var Section = function(parent, $el) {
+    if (!(this instanceof Section)) {
+        return new Section(parent, $el);
+    }
+
+    Node.call(this, parent, $el);
+
+    this.group = null;
+    this.__.type_id = null;
+    this.__.exists = null;
+};
+
+Section.prototype = Object.create(Node.prototype);
+Section.prototype.constructor = Section;
+
+Model.defineModelProperties(Section, ['type_id', 'exists']);
+
+/**
+ * Set the root group of the section by jQuery element
+ * @param {jQuery}
+ * @return {Group} the new root group
+ */
+Section.prototype.setGroup = function($el) {
+    this.group = new Group(this, $el);
+    this.group.parent = this;
+    this.group.section_type_id = this.type_id;
+    if (this.model !== null) {
+        this.model.trigger('set', this.group);
+    }
+    return this.group;
+};
+
+/**
+ * Clear out all rules
+ */
+Section.prototype.empty = function() {
+    if (this.group) {
+        this.group.drop();
+    }
+    this.group = null;
+};
+
+/**
+ * Delete self
+ */
+Section.prototype.drop = function() {
+    if (this.group) {
+        this.group.drop();
+    }
+    Node.prototype.drop.call(this);
+};
+
 
 // EXPORT
 // ===============================
 QueryBuilder.Group = Group;
 QueryBuilder.Rule = Rule;
+QueryBuilder.Section = Section;
+
diff --git a/src/plugins/bt-tooltip-errors/plugin.js b/src/plugins/bt-tooltip-errors/plugin.js
index 0d97c0b9..3a305859 100644
--- a/src/plugins/bt-tooltip-errors/plugin.js
+++ b/src/plugins/bt-tooltip-errors/plugin.js
@@ -14,7 +14,7 @@ QueryBuilder.define('bt-tooltip-errors', function(options) {
     var self = this;
 
     // add BT Tooltip data
-    this.on('getRuleTemplate.filter getGroupTemplate.filter', function(h) {
+    this.on('getRuleTemplate.filter getGroupTemplate.filter getSectionTemplate.filter', function(h) {
         var $h = $(h.value);
         $h.find(Selectors.error_container).attr('data-toggle', 'tooltip');
         h.value = $h.prop('outerHTML');
diff --git a/src/plugins/change-filters/plugin.js b/src/plugins/change-filters/plugin.js
index 27aa6881..c61c3829 100644
--- a/src/plugins/change-filters/plugin.js
+++ b/src/plugins/change-filters/plugin.js
@@ -9,17 +9,19 @@ QueryBuilder.extend({
      * @throws ChangeFilterError
      * @param {boolean,optional} delete rules using old filters
      * @param {object[]} new filters
+     * @param {string,optional} set these new filters for a particular section
      */
-    setFilters: function(delete_orphans, filters) {
+    setFilters: function(delete_orphans, filters, section_id) {
         var self = this;
 
-        if (filters === undefined) {
+        if (Object.prototype.toString.call(delete_orphans) === '[object Array]') {
+            section_id = filters;
             filters = delete_orphans;
             delete_orphans = false;
         }
 
-        filters = this.checkFilters(filters);
-        filters = this.change('setFilters', filters);
+        filters = this.checkFilters(filters, section_id);
+        filters = this.change('setFilters', filters, section_id);
 
         var filtersIds = filters.map(function(filter) {
             return filter.id;
@@ -30,7 +32,10 @@ QueryBuilder.extend({
             (function checkOrphans(node) {
                 node.each(
                     function(rule) {
-                        if (rule.filter && filtersIds.indexOf(rule.filter.id) === -1) {
+                        if (section_id !== rule.section_type_id) {
+                            // ignore
+                        }
+                        else if (rule.filter && filtersIds.indexOf(rule.filter.id) === -1) {
                             Utils.error('ChangeFilter', 'A rule is using filter "{0}"', rule.filter.id);
                         }
                     },
@@ -40,13 +45,30 @@ QueryBuilder.extend({
         }
 
         // replace filters
-        this.filters = filters;
+        if (section_id === undefined) {
+            this.filters = filters;
+        }
+        else {
+            var found = false;
+            for (var i = 0; i < this.sections.length; i++) {
+                if (this.sections[i].id === section_id) {
+                    this.sections[i].filters = filters;
+                    found = true;
+                }
+            }
+            if (!found) {
+                Utils.error('ChangeFilter', 'Unknown section "{0}"', section_id);
+            }
+        }
 
         // apply on existing DOM
         (function updateBuilder(node) {
             node.each(true,
               function(rule) {
-                  if (rule.filter && filtersIds.indexOf(rule.filter.id) === -1) {
+                  if (section_id !== rule.section_type_id) {
+                      // ignore
+                  }
+                  else if (rule.filter && filtersIds.indexOf(rule.filter.id) === -1) {
                       rule.drop();
                   }
                   else {
@@ -56,7 +78,12 @@ QueryBuilder.extend({
                       self.trigger('afterUpdateRuleFilter', rule);
                   }
               },
-              updateBuilder
+              updateBuilder,
+              function(section) {
+                  if (section.group) {
+                      updateBuilder(section.group);
+                  }
+              }
             );
         }(this.model.root));
 
@@ -80,15 +107,16 @@ QueryBuilder.extend({
             }
         }
 
-        this.trigger('afterSetFilters', filters);
+        this.trigger('afterSetFilters', filters, section_id);
     },
 
     /**
      * Adds a new filter to the builder
      * @param {object|object[]} the new filter
      * @param {mixed,optional} numeric index or '#start' or '#end'
+     * @param {string,optional} add these new filters for a particular section
      */
-    addFilter: function(new_filters, position) {
+    addFilter: function(new_filters, position, section_id) {
         if (position === undefined || position == '#end') {
             position = this.filters.length;
         }
@@ -100,7 +128,22 @@ QueryBuilder.extend({
             new_filters = [new_filters];
         }
 
-        var filters = $.extend(true, [], this.filters);
+        var filters = [];
+        if (section_id === undefined) {
+            filters = $.extend(true, [], this.filters);
+        }
+        else {
+            var found = false;
+            for (var i = 0; i < this.sections.length; i++) {
+                if (this.sections[i].id === section_id) {
+                    filters = $.extend(true, [], this.sections[i].filters);
+                    found = true;
+                }
+            }
+            if (!found) {
+                Utils.error('ChangeFilter', 'Unknown section "{0}"', section_id);
+            }
+        }
 
         // numeric position
         if (parseInt(position) == position) {
@@ -108,7 +151,7 @@ QueryBuilder.extend({
         }
         else {
             // after filter by its id
-            if (this.filters.some(function(filter, index) {
+            if (filters.some(function(filter, index) {
                 if (filter.id == position) {
                     position = index + 1;
                     return true;
@@ -122,16 +165,33 @@ QueryBuilder.extend({
             }
         }
 
-        this.setFilters(filters);
+        this.setFilters(filters, section_id);
     },
 
     /**
      * Removes a filter from the builder
      * @param {string|string[]} the filter id
      * @param {boolean,optional} delete rules using old filters
+     * @param {string,optional} remove these filters from a particular section
      */
-    removeFilter: function(filter_ids, delete_orphans) {
-        var filters = $.extend(true, [], this.filters);
+    removeFilter: function(filter_ids, delete_orphans, section_id) {
+        var filters = [];
+        if (section_id === undefined) {
+            filters = $.extend(true, [], this.filters);
+        }
+        else {
+            var found = false;
+            for (var i = 0; i < this.sections.length; i++) {
+                if (this.sections[i].id === section_id) {
+                    filters = $.extend(true, [], this.sections[i].filters);
+                    found = true;
+                }
+            }
+            if (!found) {
+                Utils.error('ChangeFilter', 'Unknown section "{0}"', section_id);
+            }
+        }
+
         if (typeof filter_ids === 'string') {
             filter_ids = [filter_ids];
         }
@@ -140,6 +200,6 @@ QueryBuilder.extend({
             return filter_ids.indexOf(filter.id) === -1;
         });
 
-        this.setFilters(delete_orphans, filters);
+        this.setFilters(delete_orphans, filters, section_id);
     }
 });
diff --git a/src/plugins/invert/plugin.js b/src/plugins/invert/plugin.js
index a4818e3e..e8ad8d9c 100644
--- a/src/plugins/invert/plugin.js
+++ b/src/plugins/invert/plugin.js
@@ -30,6 +30,11 @@ QueryBuilder.defaults({
     conditionOpposites: {
         'AND': 'OR',
         'OR': 'AND'
+    },
+
+    existsOpposites: {
+        'EXISTS': 'DOES NOT EXIST',
+        'DOES NOT EXIST': 'EXISTS'
     }
 });
 
@@ -115,6 +120,8 @@ QueryBuilder.extend({
                     }
                 }, function(group) {
                     this.invert(group, tempOpts);
+                }, function(section) {
+                    this.invert(section, tempOpts);
                 }, this);
             }
         }
@@ -133,6 +140,21 @@ QueryBuilder.extend({
                 }
             }
         }
+        else if (node instanceof Section) {
+            // invert exists setting
+            if (this.settings.existsOpposites[node.exists]) {
+                node.exists = this.settings.existsOpposites[node.exists];
+            }
+            else if (!options.silent_fail) {
+                Utils.error('InvertExists', 'Unknown inverse of exists "{0}"', node.exists);
+            }
+
+            // recursive call
+            if (options.recursive && node.group) {
+                var sectOpts = $.extend({}, options, { trigger: false });
+                this.invert(node.group, sectOpts);
+            }
+        }
 
         if (options.trigger) {
             this.trigger('afterInvert', node, options);
diff --git a/src/plugins/mongodb-support/plugin.js b/src/plugins/mongodb-support/plugin.js
index bf98ab4e..df3cd901 100644
--- a/src/plugins/mongodb-support/plugin.js
+++ b/src/plugins/mongodb-support/plugin.js
@@ -83,7 +83,7 @@ QueryBuilder.defaults({
 QueryBuilder.extend({
     /**
      * Get rules as MongoDB query
-     * @throws UndefinedMongoConditionError, UndefinedMongoOperatorError
+     * @throws UndefinedMongoConditionError, UndefinedMongoBehavior, UndefinedMongoOperatorError
      * @param data {object} (optional) rules
      * @return {object}
      */
@@ -110,6 +110,9 @@ QueryBuilder.extend({
                 if (rule.rules && rule.rules.length > 0) {
                     parts.push(parse(rule));
                 }
+                else if (rule.section) {
+                    Utils.error('UndefinedMongoBehavior', 'Sections are not currently supported for MongoDB queries');
+                }
                 else {
                     var mdb = self.settings.mongoOperators[rule.operator];
                     var ope = self.getOperatorByType(rule.operator);
diff --git a/src/plugins/sortable/plugin.js b/src/plugins/sortable/plugin.js
index 6b2818ea..bcd3d6ec 100644
--- a/src/plugins/sortable/plugin.js
+++ b/src/plugins/sortable/plugin.js
@@ -3,7 +3,6 @@
  * Enables drag & drop sort of rules.
  */
 
-Selectors.rule_and_group_containers = Selectors.rule_container + ', ' + Selectors.group_container;
 Selectors.drag_handle = '.drag-handle';
 
 QueryBuilder.define('sortable', function(options) {
@@ -21,10 +20,26 @@ QueryBuilder.define('sortable', function(options) {
     var ghost;
     var src;
 
+    var acceptable = function(node) {
+        if (node instanceof Section) {
+            return Selectors.rule_container + '[data-stype="' + node.type_id + '"], ' +
+                Selectors.group_container + '[data-stype="' + node.type_id + '"]';
+        }
+        else if (node.section_type_id !== undefined) {
+            return Selectors.rule_container + '[data-stype="' + node.section_type_id + '"], ' +
+                Selectors.group_container + '[data-stype="' + node.section_type_id + '"]';
+        }
+        else {
+            return Selectors.rule_container + '[data-stype=""], ' +
+                Selectors.group_container + '[data-stype=""], ' +
+                Selectors.section_container;
+        }
+    };
+
     /**
      * Init drag and drop
      */
-    this.on('afterAddRule afterAddGroup', function(e, node) {
+    this.on('afterAddRule afterAddGroup afterAddSection', function(e, node) {
         if (node == placeholder) {
             return;
         }
@@ -76,16 +91,18 @@ QueryBuilder.define('sortable', function(options) {
         /**
          * Configure drop on groups and rules
          */
-        interact(node.$el[0])
-            .dropzone({
-                accept: Selectors.rule_and_group_containers,
-                ondragenter: function(event) {
-                    moveSortableToTarget(placeholder, $(event.target));
-                },
-                ondrop: function(event) {
-                    moveSortableToTarget(src, $(event.target));
-                }
-            });
+        if (!(node instanceof Section)) {
+            interact(node.$el[0])
+                .dropzone({
+                    accept: acceptable(node),
+                    ondragenter: function(event) {
+                        moveSortableToTarget(placeholder, $(event.target));
+                    },
+                    ondrop: function(event) {
+                        moveSortableToTarget(src, $(event.target));
+                    }
+                });
+        }
 
         /**
          * Configure drop on group headers
@@ -93,7 +110,7 @@ QueryBuilder.define('sortable', function(options) {
         if (node instanceof Group) {
             interact(node.$el.find(Selectors.group_header)[0])
                 .dropzone({
-                    accept: Selectors.rule_and_group_containers,
+                    accept: acceptable(node),
                     ondragenter: function(event) {
                         moveSortableToTarget(placeholder, $(event.target));
                     },
@@ -107,7 +124,7 @@ QueryBuilder.define('sortable', function(options) {
     /**
      * Detach interactables
      */
-    this.on('beforeDeleteRule beforeDeleteGroup', function(e, node) {
+    this.on('beforeDeleteRule beforeDeleteGroup beforeDeleteSection', function(e, node) {
         if (!e.isDefaultPrevented()) {
             interact(node.$el[0]).unset();
 
@@ -147,11 +164,26 @@ QueryBuilder.define('sortable', function(options) {
         }
     });
 
+    /**
+     * Remove drag handle from non-sortable sections
+     */
+    this.on('parseSectionFlags.filter', function(flags) {
+        if (flags.value.no_sortable === undefined) {
+            flags.value.no_sortable = options.default_no_sortable;
+        }
+    });
+
+    this.on('afterApplySectionFlags', function(e, group) {
+        if (group.flags.no_sortable) {
+            group.$el.find('.drag-handle').remove();
+        }
+    });
+
     /**
      * Modify templates
      */
-    this.on('getGroupTemplate.filter', function(h, level) {
-        if (level > 1) {
+    this.on('getGroupTemplate.filter', function(h, level, in_section, section_root) {
+        if (level > 1 && !section_root) {
             var $h = $(h.value);
             $h.find(Selectors.condition_container).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
             h.value = $h.prop('outerHTML');
@@ -163,6 +195,12 @@ QueryBuilder.define('sortable', function(options) {
         $h.find(Selectors.rule_header).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
         h.value = $h.prop('outerHTML');
     });
+
+    this.on('getSectionTemplate.filter', function(h) {
+        var $h = $(h.value);
+        $h.find(Selectors.exists_container).after('<div class="drag-handle"><i class="' + options.icon + '"></i></div>');
+        h.value = $h.prop('outerHTML');
+    });
 }, {
     default_no_sortable: false,
     icon: 'glyphicon glyphicon-sort'
diff --git a/src/plugins/sql-support/plugin.js b/src/plugins/sql-support/plugin.js
index 6413cf39..aee5feb4 100644
--- a/src/plugins/sql-support/plugin.js
+++ b/src/plugins/sql-support/plugin.js
@@ -247,6 +247,11 @@ QueryBuilder.extend({
                 if (rule.rules && rule.rules.length > 0) {
                     parts.push('(' + nl + parse(rule) + nl + ')' + nl);
                 }
+                else if (rule.section) {
+                    var info = self.getSectionById(rule.section);
+                    var base_sql = 'SELECT * FROM ' + rule.section + ' WHERE ';
+                    parts.push('( ' + rule.exists + ' ( ' + base_sql + parse(rule.group) + ' ) )');
+                }
                 else {
                     var sql = self.settings.sqlOperators[rule.operator];
                     var ope = self.getOperatorByType(rule.operator);
@@ -381,6 +386,12 @@ QueryBuilder.extend({
                 return;
             }
 
+            // a plugin returned a section
+            if ('section' in data && 'exists' in data && 'group' in data) {
+                curr.rules.push(data);
+                return;
+            }
+
             // a plugin returned a rule
             if ('id' in data && 'operator' in data && 'value' in data) {
                 curr.rules.push(data);
@@ -388,12 +399,12 @@ QueryBuilder.extend({
             }
 
             // data must be a SQL parser node
-            if (!('left' in data) || !('right' in data) || !('operation' in data)) {
+            if ((!('operator' in data) && !('operand' in data)) && (!('operation' in data) || !('left' in data) || !('right' in data))) {
                 Utils.error('SQLParse', 'Unable to parse WHERE clause');
             }
 
             // it's a node
-            if (['AND', 'OR'].indexOf(data.operation.toUpperCase()) !== -1) {
+            if (('operation') in data && ['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()) {
                     var group = self.change('sqlToGroup', {
@@ -415,6 +426,45 @@ QueryBuilder.extend({
                 curr = next;
                 flatten(data.right, i);
             }
+            // it's a subquery
+            else if (('operator') in data && ['EXISTS', 'NOT EXISTS'].indexOf(data.operator.toUpperCase()) !== -1) {
+                // find the section name
+                if (!('select' in data.operand) || !('source' in data.operand.select) || !('name' in data.operand.select.source) || !('value' in data.operand.select.source.name)) {
+                    Utils.error('SQLParse', 'Unable to parse subquery: missing table name');
+                }
+                var section = self.change('sqlToSection', {
+                    section: data.operand.select.source.name.value,
+                    exists: data.operator.toUpperCase()
+                }, data);
+
+                // find the where clause
+                if (!('where' in data.operand.select) || !('conditions' in data.operand.select.where)) {
+                    Utils.error('SQLParse', 'Unable to parse subquery: no where clause found');
+                }
+
+                // allow plugins to manually parse or handle special cases
+                var sdata = self.change('parseSQLNode', data.operand.select.where.conditions);
+
+                // a plugin returned a group
+                if ('rules' in sdata && 'condition' in sdata) {
+                    section.group = sdata;
+                }
+                // create root group for section
+                else {
+                    var sgroup = self.change('sqlToGroup', {
+                        condition: self.settings.default_condition,
+                        rules: []
+                    }, sdata);
+                    section.group = sgroup;
+                }
+
+                // push the section
+                curr.rules.push(section);
+                curr = section.group;
+
+                // parse each part of the group
+                flatten(sdata);
+            }
             // it's a leaf
             else {
                 if ($.isPlainObject(data.right.value)) {
diff --git a/src/plugins/unique-filter/plugin.js b/src/plugins/unique-filter/plugin.js
index aee31b7c..855def62 100644
--- a/src/plugins/unique-filter/plugin.js
+++ b/src/plugins/unique-filter/plugin.js
@@ -5,6 +5,7 @@
 
 QueryBuilder.define('unique-filter', function() {
     this.status.used_filters = {};
+    this.status.used_filters_by_section = {};
 
     this.on('afterUpdateRuleFilter', this.updateDisabledFilters);
     this.on('afterDeleteRule', this.updateDisabledFilters);
@@ -21,9 +22,29 @@ QueryBuilder.define('unique-filter', function() {
 
         self.updateDisabledFilters();
 
-        if (e.value.id in self.status.used_filters) {
-            var found = self.filters.some(function(filter) {
-                if (!(filter.id in self.status.used_filters) || self.status.used_filters[filter.id].length > 0 && self.status.used_filters[filter.id].indexOf(model.parent) === -1) {
+        var used = [];
+        var available = [];
+        if (model.section_type_id === undefined) {
+            used = self.status.used_filters;
+            available = self.filters;
+        }
+        else {
+            var s = self.getSectionById(model.section_type_id);
+            if (s === undefined) {
+                Utils.error('UniqueFilter', 'Unknown section "${0}"', model.section_type_id);
+                e.value = undefined;
+                return;
+            }
+            if (self.status.used_filters_by_section[s.id] === undefined) {
+                self.status.used_filters_by_section[s.id] = {};
+            }
+            used = self.status.used_filters_by_section[s.id];
+            available = s.filters;
+        }
+
+        if (e.value.id in used) {
+            var found = available.some(function(filter) {
+                if (!(filter.id in used) || used[filter.id].length > 0 && used[filter.id].indexOf(model.parent) === -1) {
                     e.value = filter;
                     return true;
                 }
@@ -55,15 +76,32 @@ QueryBuilder.extend({
         (function walk(group) {
             group.each(function(rule) {
                 if (rule.filter && rule.filter.unique) {
-                    if (!self.status.used_filters[rule.filter.id]) {
-                        self.status.used_filters[rule.filter.id] = [];
+                    if (rule.section_type_id) {
+                        if (!self.status.used_filters_by_section[rule.section_type_id]) {
+                            self.status.used_filters_by_section[rule.section_type_id] = {};
+                        }
+                        if (!self.status.used_filters_by_section[rule.section_type_id][rule.filter.id]) {
+                            self.status.used_filters_by_section[rule.section_type_id][rule.filter.id] = [];
+                        }
+                        if (rule.filter.unique == 'group') {
+                            self.status.used_filters_by_section[rule.section_type_id][rule.filter.id].push(rule.parent);
+                        }
                     }
-                    if (rule.filter.unique == 'group') {
-                        self.status.used_filters[rule.filter.id].push(rule.parent);
+                    else {
+                        if (!self.status.used_filters[rule.filter.id]) {
+                            self.status.used_filters[rule.filter.id] = [];
+                        }
+                        if (rule.filter.unique == 'group') {
+                            self.status.used_filters[rule.filter.id].push(rule.parent);
+                        }
                     }
                 }
             }, function(group) {
                 walk(group);
+            }, function(section) {
+                if (section.group) {
+                    walk(section.group);
+                }
             });
         }(self.model.root));
 
@@ -78,6 +116,7 @@ QueryBuilder.extend({
         var self = e ? e.builder : this;
 
         self.status.used_filters = {};
+        self.status.used_filters_by_section = {};
 
         self.applyDisabledFilters(e);
     },
@@ -93,7 +132,7 @@ QueryBuilder.extend({
         self.$el.find(Selectors.filter_container + ' option').prop('disabled', false);
 
         // disable some
-        $.each(self.status.used_filters, function(filterId, groups) {
+        var disableSome = function(filterId, groups) {
             if (groups.length === 0) {
                 self.$el.find(Selectors.filter_container + ' option[value="' + filterId + '"]:not(:selected)').prop('disabled', true);
             }
@@ -104,6 +143,10 @@ QueryBuilder.extend({
                     });
                 });
             }
+        };
+        $.each(self.status.used_filters, disableSome);
+        $.each(self.status.used_filters_by_section, function(section_id, filters) {
+            $.each(filters, disableSome);
         });
 
         // update Selectpicker
diff --git a/src/public.js b/src/public.js
index 9c503043..d432cd49 100644
--- a/src/public.js
+++ b/src/public.js
@@ -39,6 +39,7 @@ QueryBuilder.prototype.reset = function() {
 QueryBuilder.prototype.clear = function() {
     this.status.group_id = 0;
     this.status.rule_id = 0;
+    this.status.section_id = 0;
 
     if (this.model.root) {
         this.model.root.drop();
@@ -109,6 +110,18 @@ QueryBuilder.prototype.validate = function() {
             else {
                 errors++;
             }
+        }, function(section) {
+            if (!section.type_id || section.type_id == '-1' || !section.group) {
+                self.triggerValidationError(section, 'no_type', null);
+                errors++;
+                return;
+            }
+            if (parse(section.group)) {
+                done++;
+            }
+            else {
+                errors++;
+            }
         });
 
         if (errors > 0) {
@@ -190,7 +203,27 @@ QueryBuilder.prototype.getRules = function(options) {
 
         }, function(model) {
             groupData.rules.push(parse(model));
-        }, this);
+        }, function(model) {
+            var sectionData = {
+                section: model.type_id,
+                exists: model.exists
+            };
+            if (model.group) {
+                sectionData.group = parse(model.group);
+            }
+            else {
+                sectionData.group = null;
+            }
+
+            if (options.get_flags) {
+                var flags = self.getRuleFlags(model.flags, options.get_flags === 'all');
+                if (!$.isEmptyObject(flags)) {
+                    sectionData.flags = flags;
+                }
+            }
+
+            groupData.rules.push(sectionData);
+        });
 
         return self.change('groupToJson', groupData, group);
 
@@ -240,7 +273,31 @@ QueryBuilder.prototype.setRules = function(data) {
         data.rules.forEach(function(item) {
             var model;
 
-            if (item.rules !== undefined) {
+            if (item.section !== undefined) {
+                if (!self.settings.allow_sections || !self.settings.has_sections) {
+                    self.reset();
+                    Utils.error('RulesParse', 'No sections are allowed');
+                }
+                else {
+                    var section = self.addSection(group, false, item.data, self.parseSectionFlags(item));
+                    if (section === null) {
+                        return;
+                    }
+                    section.type_id = item.section;
+                    if (item.exists === undefined) {
+                        item.exists = self.settings.default_exists;
+                    }
+                    section.exists = item.exists;
+                    if (item.group !== undefined) {
+                        var gmodel = self.addGroup(section, false, item.group.data, self.parseGroupFlags(item.group));
+                        if (gmodel === null) {
+                            return;
+                        }
+                        add(item.group, gmodel);
+                    }
+                }
+            }
+            else if (item.rules !== undefined) {
                 if (self.settings.allow_groups !== -1 && self.settings.allow_groups < group.level) {
                     self.reset();
                     Utils.error('RulesParse', 'No more than {0} groups are allowed', self.settings.allow_groups);
@@ -270,7 +327,7 @@ QueryBuilder.prototype.setRules = function(data) {
                 }
 
                 if (!item.empty) {
-                    model.filter = self.getFilterById(item.id);
+                    model.filter = self.getFilterById(item.id, group.section_type_id);
                     model.operator = self.getOperatorByType(item.operator);
 
                     if (model.operator.nb_inputs !== 0 && item.value !== undefined) {
diff --git a/src/scss/dark.scss b/src/scss/dark.scss
index 02e50e56..b9b11bad 100644
--- a/src/scss/dark.scss
+++ b/src/scss/dark.scss
@@ -3,6 +3,9 @@ $theme-name: dark;
 $group-background-color: rgba(50, 70, 80, .5);
 $group-border-color: #00164A;
 
+$section-background-color: rgba(100, 120, 130, .5);
+$section-border-color: #181E21;
+
 $rule-background-color: rgba(40, 40, 40, .9);
 $rule-border-color: #111;
 
diff --git a/src/scss/default.scss b/src/scss/default.scss
index ceebadd7..a0a5289e 100644
--- a/src/scss/default.scss
+++ b/src/scss/default.scss
@@ -10,6 +10,12 @@ $group-border-color: #DCC896 !default;
 $group-border: 1px solid $group-border-color !default;
 $group-padding: 10px !default;
 
+// sections
+$section-background-color: rgba(196, 173, 237, .5) !default;
+$section-border-color: #AD92DB !default;
+$section-border: 1px solid $section-border-color !default;
+$section-padding: 10px !default;
+
 // rules
 $rule-background-color: rgba(255, 255, 255, .9) !default;
 $rule-border-color: #EEE !default;
@@ -115,6 +121,31 @@ $ticks-position: 5px, 10px !default;
     }
   }
 
+  // SECTIONS
+  .rules-section-container {
+    @extend %base-container;
+
+    padding: $section-padding;
+    padding-bottom: #{$section-padding - $item-vertical-spacing};
+    border: $section-border;
+    background: $section-background-color;
+  }
+
+  .rules-section-header {
+    margin-bottom: $section-padding;
+
+    .section-exists-options {
+      .btn.readonly:not(.active),
+      input[name$=_exists] {
+        display: none;
+      }
+
+      .btn.readonly {
+        border-radius: 3px;
+      }
+    }
+  }
+
   // ERRORS
   .error-container {
     @extend %rule-component;
diff --git a/src/template.js b/src/template.js
index 3a2756e4..68f314a6 100644
--- a/src/template.js
+++ b/src/template.js
@@ -1,5 +1,5 @@
 QueryBuilder.templates.group = '\
-<dl id="{{= it.group_id }}" class="rules-group-container"> \
+<dl id="{{= it.group_id }}" class="rules-group-container" data-stype="{{= it.section_type || "" }}"> \
   <dt class="rules-group-header"> \
     <div class="btn-group pull-right group-actions"> \
       <button type="button" class="btn btn-xs btn-success" data-add="rule"> \
@@ -10,7 +10,12 @@ QueryBuilder.templates.group = '\
           <i class="{{= it.icons.add_group }}"></i> {{= it.lang.add_group }} \
         </button> \
       {{?}} \
-      {{? it.level>1 }} \
+      {{? it.settings.allow_sections && it.settings.has_sections && !it.in_section }} \
+        <button type="button" class="btn btn-xs btn-success" data-add="section"> \
+          <i class="{{= it.icons.add_section }}"></i> {{= it.lang.add_section }} \
+        </button> \
+      {{?}} \
+      {{? it.level>1 && !it.section_root }} \
         <button type="button" class="btn btn-xs btn-danger" data-delete="group"> \
           <i class="{{= it.icons.remove_group }}"></i> {{= it.lang.delete_group }} \
         </button> \
@@ -32,8 +37,42 @@ QueryBuilder.templates.group = '\
   </dd> \
 </dl>';
 
+QueryBuilder.templates.section = '\
+<dl id="{{= it.section_id }}" class="rules-section-container" data-stype=""> \
+  <dt class="rules-section-header"> \
+    <div class="btn-section pull-right section-actions"> \
+      <button type="button" class="btn btn-xs btn-danger" data-delete="section"> \
+        <i class="{{= it.icons.remove_section }}"></i> {{= it.lang.delete_section }} \
+      </button> \
+    </div> \
+    <div class="btn-group section-exists-options"> \
+      {{~ it.exist_options: option }} \
+        <label class="btn btn-xs btn-primary"> \
+          <input type="radio" name="{{= it.section_id }}_exists" value="{{= option }}"> {{= it.lang.exist_options[option] || option }} \
+        </label> \
+      {{~}} \
+    </div> \
+    {{? it.settings.display_errors }} \
+      <div class="error-container"><i class="{{= it.icons.error }}"></i></div> \
+    {{?}} \
+  </dt> \
+  <div class="rule-stype-container"></div> \
+  <dd class="rules-section-body"> \
+  </dd> \
+</dl>';
+
+QueryBuilder.templates.stypeSelect = '\
+<select class="form-control" name="{{= it.section.id }}_section_type"> \
+  {{? it.settings.display_empty_stype_filter }} \
+    <option value="-1">{{= it.settings.select_placeholder }}</option> \
+  {{?}} \
+  {{~ it.stypes: stype }} \
+    <option value="{{= stype.id }}">{{= it.translate(stype.label) }}</option> \
+  {{~}} \
+</select>';
+
 QueryBuilder.templates.rule = '\
-<li id="{{= it.rule_id }}" class="rule-container"> \
+<li id="{{= it.rule_id }}" class="rule-container" data-stype="{{= it.section_type || "" }}"> \
   <div class="rule-header"> \
     <div class="btn-group pull-right rule-actions"> \
       <button type="button" class="btn btn-xs btn-danger" data-delete="rule"> \
@@ -91,37 +130,85 @@ QueryBuilder.templates.operatorSelect = '\
  * Returns group HTML
  * @param group_id {string}
  * @param level {int}
+ * @param section_type {string}
+ * @param in_section {bool}
+ * @param section_root {bool}
  * @return {string}
  */
-QueryBuilder.prototype.getGroupTemplate = function(group_id, level) {
+QueryBuilder.prototype.getGroupTemplate = function(group_id, level, section_type, in_section, section_root) {
     var h = this.templates.group({
         builder: this,
         group_id: group_id,
         level: level,
+        section_type: section_type,
+        in_section: in_section,
+        section_root: section_root,
         conditions: this.settings.conditions,
         icons: this.icons,
         lang: this.lang,
         settings: this.settings
     });
 
-    return this.change('getGroupTemplate', h, level);
+    return this.change('getGroupTemplate', h, level, section_type, in_section, section_root);
 };
 
 /**
  * Returns rule HTML
  * @param rule_id {string}
+ * @param section_type {string}
  * @return {string}
  */
-QueryBuilder.prototype.getRuleTemplate = function(rule_id) {
+QueryBuilder.prototype.getRuleTemplate = function(rule_id, section_type) {
     var h = this.templates.rule({
         builder: this,
         rule_id: rule_id,
+        section_type: section_type,
         icons: this.icons,
         lang: this.lang,
         settings: this.settings
     });
 
-    return this.change('getRuleTemplate', h);
+    return this.change('getRuleTemplate', h, section_type);
+};
+
+/**
+ * Returns section HTML
+ * @param section_id {string}
+ * @param level {int}
+ * @return {string}
+ */
+QueryBuilder.prototype.getSectionTemplate = function(section_id, level) {
+    var h = this.templates.section({
+        builder: this,
+        section_id: section_id,
+        level: level,
+        exist_options: this.settings.exist_options,
+        icons: this.icons,
+        lang: this.lang,
+        settings: this.settings
+    });
+
+    return this.change('getSectionTemplate', h);
+};
+
+/**
+ * Returns section type <select> HTML
+ * @param section {Section}
+ * @param stypes {array}
+ * @return {string}
+ */
+QueryBuilder.prototype.getSectionTypeSelect = function(section, stypes) {
+    var h = this.templates.stypeSelect({
+        builder: this,
+        section: section,
+        stypes: stypes,
+        icons: this.icons,
+        lang: this.lang,
+        settings: this.settings,
+        translate: this.translateLabel
+    });
+
+    return this.change('getSectionTypeSelect', h, section);
 };
 
 /**
diff --git a/tests/common.js b/tests/common.js
index 26111ecb..3712ecc9 100644
--- a/tests/common.js
+++ b/tests/common.js
@@ -294,6 +294,58 @@ var basic_filters = [{
     }
 }];
 
+var basic_sections = [{
+    id: 'partner',
+    label: 'Partner',
+    filters: [{
+        id: 'name',
+        label: 'Partner Name',
+        type: 'string'
+    }, {
+        id: 'status',
+        label: 'Partnership Status',
+        type: 'string',
+        input: 'select',
+        multiple: true,
+        values: {
+            'ac': 'Active',
+            'in': 'Inactive',
+            'tr': 'Terminated'
+        }
+    }]
+}, {
+    id: 'related',
+    label: 'Releated Products',
+    filters: [{
+        id: 'name',
+        label: 'Name',
+        type: 'string'
+    }, {
+        id: 'price',
+        label: 'Price',
+        type: 'double',
+        validation: {
+            min: 0,
+            step: 0.01
+        }
+    }, {
+        id: 'category',
+        label: 'Category',
+        type: 'string',
+        input: 'select',
+        multiple: true,
+        values: {
+            'bk': 'Books',
+            'mo': 'Movies',
+            'mu': 'Music',
+            'to': 'Tools',
+            'go': 'Goodies',
+            'cl': 'Clothes'
+        },
+        operators: ['in', 'not_in', 'equal', 'not_equal', 'is_null', 'is_not_null']
+    }]
+}];
+
 var basic_rules = {
     condition: 'AND',
     rules: [{
@@ -321,3 +373,29 @@ var basic_rules = {
         }]
     }]
 };
+
+var section_rules = {
+    condition: 'AND',
+    rules: [{
+        id: 'price',
+        field: 'price',
+        operator: 'less',
+        value: 10.25
+    }, {
+        section: 'partner',
+        group: {
+            condition: 'AND',
+            rules: [{
+                id: 'name',
+                field: 'name',
+                operator: 'begins_with',
+                value: 'Best'
+            }, {
+                id: 'status',
+                field: 'status',
+                operator: 'in',
+                value: [ 'ac', 'in' ]
+            }]
+        }
+    }]
+};
diff --git a/tests/index.html b/tests/index.html
index 4c395d25..1e891678 100644
--- a/tests/index.html
+++ b/tests/index.html
@@ -62,6 +62,7 @@
 <script src="../tests/plugins.mongo-support.module.js"></script>
 <script src="../tests/plugins.not-group.module.js"></script>
 <script src="../tests/plugins.sql-support.module.js"></script>
+<script src="../tests/sections.module.js"></script>
 <script src="../tests/utils.module.js"></script>
 <!-- /qunit:modules -->
 </head>
diff --git a/tests/plugins.module.js b/tests/plugins.module.js
index 110c1baf..4b12ac63 100644
--- a/tests/plugins.module.js
+++ b/tests/plugins.module.js
@@ -77,7 +77,8 @@ $(function(){
         $b.queryBuilder({
             plugins: ['unique-filter'],
             filters: unique_filters,
-            rules: basic_rules
+            rules: basic_rules,
+            default_filter: 'id'
         });
 
         assert.ok(
@@ -93,6 +94,115 @@ $(function(){
             !$('select[name=builder_rule_3_filter] option[value=price]').is(':disabled'),
             '"Price" filter should be disabled in his group only'
         );
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=rule]').trigger('click');
+
+        assert.ok(
+             $('select[name=builder_rule_4_filter] option[value=id]').is(':disabled') &&
+            !$('select[name=builder_rule_4_filter] option[value=id]').is(':selected'),
+            '"Identifier" filter should be disabled and not selected'
+        );
+
+        $b.queryBuilder('destroy');
+
+        var unique_sections = $.extend(true, [], basic_sections);
+        unique_sections[0].default_filter = 'name'; // partner -> name is the default
+        unique_sections[0].filters[0].unique = true; // partner -> name
+        unique_sections[1].filters[1].unique = 'group'; // related -> price
+
+        var unique_rules = {
+            condition: 'AND',
+            rules: [{
+                id: 'price',
+                field: 'price',
+                operator: 'less',
+                value: 10.25
+            }, {
+                section: 'partner',
+                group: {
+                    condition: 'OR',
+                    rules: [{
+                        condition: 'AND',
+                        rules: [{
+                            id: 'name',
+                            field: 'name',
+                            operator: 'begins_with',
+                            value: 'Best'
+                        }, {
+                            id: 'status',
+                            field: 'status',
+                            operator: 'equal',
+                            value: 'ac'
+                        }]
+                    }, {
+                        condition: 'AND',
+                        rules: [{
+                            id: 'name',
+                            field: 'name',
+                            operator: 'begins_with',
+                            value: 'Worst'
+                        }, {
+                            id: 'status',
+                            field: 'status',
+                            operator: 'in',
+                            value: [ 'in', 'tr' ]
+                        }]
+                    }]
+                }
+            }, {
+                section: 'related',
+                group: {
+                    condition: 'OR',
+                    rules: [{
+                        id: 'category',
+                        field: 'category',
+                        operator: 'in',
+                        value: [ 'bk', 'mo', 'mu' ]
+                    },{
+                        condition: 'AND',
+                        rules: [{
+                            id: 'category',
+                            field: 'category',
+                            operator: 'equal',
+                            value: 'cl'
+                        }, {
+                            id: 'price',
+                            field: 'price',
+                            operator: 'greater',
+                            value: 10.00
+                        }]
+                    }]
+                }
+            }]
+        };
+
+        $b.queryBuilder({
+            plugins: ['unique-filter'],
+            filters: basic_filters,
+            sections: unique_sections,
+            rules: unique_rules
+        });
+
+        assert.ok(
+            $('#builder_section_0 select[name=builder_rule_2_filter] option[value=name]').is(':disabled') &&
+            $('#builder_section_0 select[name=builder_rule_4_filter] option[value=name]').is(':disabled'),
+            '"Name" filter in "partner" section should be disabled everywhere'
+        );
+
+        assert.ok(
+            !$('#builder_section_1 select[name=builder_rule_5_filter] option[value=price]').is(':disabled') &&
+             $('#builder_section_1 select[name=builder_rule_6_filter] option[value=price]').is(':disabled'),
+            '"Price" filter in "related" section should be disabled in his group only'
+        );
+
+        $('#builder_group_1>.rules-group-header>.group-actions [data-add=rule]').trigger('click');
+
+        assert.ok(
+             $('select[name=builder_rule_8_filter] option[value=name]').is(':disabled') &&
+            !$('select[name=builder_rule_8_filter] option[value=name]').is(':selected'),
+            '"Name" filter in "partner" section should be disabled and not selected'
+        );
+
     });
 
     /**
@@ -138,26 +248,63 @@ $(function(){
             },
             'Should have inverted all conditions and operators'
         );
+
+        $b.queryBuilder('destroy');
+
+        $b.queryBuilder({
+            plugins: ['invert'],
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: section_rules
+        });
+
+        $b.queryBuilder('invert');
+
+        assert.rulesMatch(
+            $b.queryBuilder('getRules'),
+            {
+                condition: 'OR',
+                rules: [{
+                    id: 'price',
+                    field: 'price',
+                    operator: 'greater_or_equal',
+                    value: 10.25
+                }, {
+                    section: 'partner',
+                    exists: 'NOT EXISTS',
+                    group: {
+                        condition: 'OR',
+                        rules: [{
+                            id: 'name',
+                            field: 'name',
+                            operator: 'not_begins_with',
+                            value: 'Best'
+                        }, {
+                            id: 'status',
+                            field: 'status',
+                            operator: 'not_in',
+                            value: [ 'ac', 'in' ]
+                        }]
+                    }
+                }]
+            },
+            'Should have inverted all exist checks, conditions, and operators'
+        );
     });
 
     /**
      * Test change filters
      */
     QUnit.test('change-filters', function(assert) {
-        var filter_a = {
-            id: 'a',
-            type: 'string'
-        };
+        var filter_a = { id: 'a', type: 'string' };
+        var filter_b = { id: 'b', type: 'string' };
+        var filter_c = { id: 'c', type: 'string' };
+        var filter_d = { id: 'd', type: 'string' };
+        var filter_e = { id: 'e', type: 'string' };
+        var filter_f = { id: 'f', type: 'string' };
 
-        var filter_b = {
-            id: 'b',
-            type: 'string'
-        };
-
-        var filter_c = {
-            id: 'c',
-            type: 'string'
-        };
+        var section_a = { id: 'a', label: 'sec a', filters: [filter_d ] };
+        var section_b = { id: 'b', label: 'sec b', filters: [filter_e ] };
 
         var rule_a = {
             id: 'a',
@@ -165,7 +312,6 @@ $(function(){
             operator: 'equal',
             value: 'foo'
         };
-
         var rule_b = {
             id: 'b',
             field: 'b',
@@ -175,6 +321,7 @@ $(function(){
 
         $b.queryBuilder({
             filters: [filter_a, filter_b],
+            sections: [section_a, section_b],
             rules: [rule_a, rule_b]
         });
 
@@ -209,5 +356,25 @@ $(function(){
             ['-1', filter_c.id, filter_a.id, filter_b.id],
             'Should have added filter "a" after "c"'
         );
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+        $('[name=builder_section_0_section_type]').val('a').trigger('change');
+
+        $b.queryBuilder('addFilter', filter_f, 0, 'a');
+
+        assert.optionsMatch(
+            $('#builder_rule_2 [name$=_filter] option'),
+            ['-1', filter_f.id, filter_d.id],
+            'Should have added filter "f" at begining for section "a"'
+        );
+
+        $b.queryBuilder('removeFilter', 'd', false, 'a');
+
+        assert.optionsMatch(
+            $('#builder_rule_2 [name$=_filter] option'),
+            ['-1', filter_f.id],
+            'Should have removed filter "d" for section "a"'
+        );
+
     });
 });
diff --git a/tests/plugins.mongo-support.module.js b/tests/plugins.mongo-support.module.js
index 68e4a329..e57e939e 100644
--- a/tests/plugins.mongo-support.module.js
+++ b/tests/plugins.mongo-support.module.js
@@ -39,6 +39,20 @@ $(function(){
         );
     });
 
+    QUnit.test('Sections not allowed', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: section_rules
+        });
+
+        assert.throws(
+            function(){ $b.queryBuilder('getMongo'); },
+            /Sections are not currently supported for MongoDB queries/,
+            'Should throw "Not supported" error'
+        );
+    });
+
     QUnit.test('All operators', function(assert) {
         $b.queryBuilder({
             filters: basic_filters,
diff --git a/tests/plugins.sql-support.module.js b/tests/plugins.sql-support.module.js
index 6dc82cfe..2d0d938d 100644
--- a/tests/plugins.sql-support.module.js
+++ b/tests/plugins.sql-support.module.js
@@ -269,6 +269,42 @@ $(function () {
         );
     });
 
+    QUnit.test('Get SQL with subqueries', function (assert) {
+
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: section_rules
+        });
+
+        assert.deepEqual(
+            $b.queryBuilder('getSQL', false),
+            section_rules_sql,
+            'Should create SQL query with sections'
+        );
+    });
+
+    QUnit.test('Set from SQL with subqueries', function (assert) {
+
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections
+        });
+
+        $b.queryBuilder('setRulesFromSQL', section_rules_sql);
+
+        var result = $b.queryBuilder('getRules');
+        assert.rulesMatch(
+            result,
+            section_rules,
+            'Should parse SQL with rules that include sections'
+        );
+        assert.rulesMatch(
+            result.rules[1].group.rules,
+            section_rules.rules[1].group.rules,
+            'Should parse SQL with rules that include sections'
+        );
+    });
 
     var basic_rules_sql_raw = {
         sql: 'price < 10.25 AND name IS NULL AND ( category IN(\'mo\', \'mu\') OR id != \'1234-azer-5678\' ) '
@@ -309,6 +345,33 @@ $(function () {
         }
     };
 
+    var section_rules_sql = {
+        sql: 'name IS NOT NULL AND ( EXISTS ( SELECT * FROM partner WHERE name LIKE(\'%foo%\') AND status NOT IN(\'in\', \'tr\') ) )'
+    };
+
+    var section_rules = {
+        condition: 'AND',
+        rules: [{
+            id: 'name',
+            operator: 'is_not_null',
+        },{
+            section: 'partner',
+            exists: 'EXISTS',
+            group: {
+                condition: 'AND',
+                rules: [{
+                    id: 'name',
+                    operator: 'contains',
+                    value: 'foo'
+                }, {
+                    id: 'status',
+                    operator: 'not_in',
+                    value: ['in', 'tr']
+                }]
+            }
+        }]
+    };
+
     var all_operators_rules = {
         condition: 'AND',
         rules: [{
diff --git a/tests/sections.module.js b/tests/sections.module.js
new file mode 100644
index 00000000..914da33f
--- /dev/null
+++ b/tests/sections.module.js
@@ -0,0 +1,745 @@
+$(function(){
+    var $b = $('#builder');
+
+    QUnit.module('sections', {
+        afterEach: function() {
+            $b.queryBuilder('destroy');
+        }
+    });
+
+    /**
+     * Disallow sections
+     */
+    QUnit.test('Disallow sections', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            allow_sections: false,
+            sections: basic_sections
+        });
+
+        assert.equal(
+            $('#builder_group_0 .rules-group-header .group-actions button[data-add="section"]').length,
+            0,
+            'Should not have the add section button'
+        );
+    });
+
+    /**
+     * Allow sections
+     */
+    QUnit.test('Allow sections', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections
+        });
+
+        assert.equal(
+            $('#builder_group_0 .rules-group-header .group-actions button[data-add="section"]').length,
+            1,
+            'Should have the add section button'
+        );
+
+        $b.queryBuilder('destroy');
+
+        $b.queryBuilder({
+            allow_sections: false,
+            filters: basic_filters,
+            sections: basic_sections
+        });
+
+        assert.equal(
+            $('#builder_group_0 .rules-group-header .group-actions button[data-add="section"]').length,
+            0,
+            'Should not have the add section button'
+        );
+    });
+
+    /**
+     * Test invalid sections
+     */
+    QUnit.test('Invalid sections', function(assert) {
+        assert.initError($b,
+            {sections: [{}],
+            filters: basic_filters},
+            /Missing section 0 id/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'foo', filters: basic_filters},
+                {id: 'foo', filters: basic_filters}
+            ],
+            filters: basic_filters},
+            /Section "foo" already defined/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'foo'}
+            ],
+            filters: basic_filters},
+            /Missing filters list \[section: foo\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'foo', filters: [{}]}
+            ],
+            filters: basic_filters},
+            /Missing filter 0 id \[section: foo\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id: 'foo'},
+                    {id: 'foo'}
+                ]}
+            ],
+            filters: basic_filters},
+            /Filter "foo" already defined \[section: baz\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id: 'foo', type: 'bar'}
+                ]}
+            ],
+            filters: basic_filters},
+            /Invalid type "bar" \[section: baz\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id: 'foo', input: 'bar'}
+                ]}
+            ],
+            filters: basic_filters},
+            /Invalid input "bar" \[section: baz\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id: 'foo', input: 'radio'}
+                ]}
+            ],
+            filters: basic_filters},
+            /Missing filter "foo" values \[section: baz\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id:'foo', input: 'select', values:[1,2,3], placeholder: 1, placeholder_value: 1}
+                ]}
+            ],
+            filters: basic_filters},
+            /Placeholder of filter "foo" overlaps with one of its values \[section: baz\]/
+        );
+
+        assert.initError($b,
+            {sections: [
+                {id: 'baz', filters: [
+                    {id: 'foo', operators: ['equal',
+                        {type: 'geo', nb_inputs: 3, multiple: false, apply_to: ['string'] }
+                    ]}
+                ]}
+            ],
+            filters: basic_filters},
+            /Filter operators must be global operators types \(string\) \[section: baz\]/
+        );
+    });
+
+    /**
+     * Test setRules and getRules with sections
+     */
+    QUnit.test('Set/get rules with sections', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: section_rules
+        });
+
+        assert.rulesMatch(
+            $b.queryBuilder('getRules', { get_flags: true }),
+            section_rules,
+            'Should return object with rules for sections'
+        );
+    });
+
+    /**
+     * Test default section
+     */
+    QUnit.test('Default section', function(assert) {
+        $b.queryBuilder({
+            default_section: 'related',
+            sections: basic_sections,
+            filters: basic_filters
+        });
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+
+        assert.equal(
+            $('[name=builder_section_0_section_type] [value="-1"]').length,
+            1,
+            'Should have the placeholder section type'
+        );
+
+        assert.equal(
+            $('[name=builder_section_0_section_type]').val(),
+            'related',
+            'Sould have used "related" as default section type'
+        );
+
+        $b.queryBuilder('destroy');
+
+        $b.queryBuilder({
+            display_empty_stype_filter: false,
+            sections: basic_sections,
+            filters: basic_filters
+        });
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+
+        assert.equal(
+            $('[name=builder_section_0_section_type] [value="-1"]').length,
+            0,
+            'Should not have the placeholder section type'
+        );
+
+        assert.equal(
+            $('[name=builder_section_0_section_type]').val(),
+            'partner',
+            'Sould have used the first section as default one'
+        );
+    });
+
+    /**
+     * Test UI events
+     */
+    QUnit.test('UI events', function(assert) {
+        $b.queryBuilder({
+            sections: basic_sections,
+            filters: basic_filters
+        });
+
+        // set the top-level rule
+        $('[name=builder_rule_0_filter]').val('name').trigger('change');
+        $('[name=builder_rule_0_operator]').val('not_equal').trigger('change');
+        $('[name=builder_rule_0_value_0]').val('foo').trigger('change');
+
+        // add a section
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+
+        // set the first rule in the section
+        $('[name=builder_section_0_section_type]').val('partner').trigger('change');
+        $('[name=builder_rule_1_filter]').val('name').trigger('change');
+        $('[name=builder_rule_1_operator]').val('begins_with').trigger('change');
+        $('[name=builder_rule_1_value_0]').val('bar').trigger('change');
+
+        // add a second rule to the section and set it
+        $('#builder_section_0 #builder_group_1>.rules-group-header>.group-actions [data-add=rule]').trigger('click');
+        $('[name=builder_rule_2_filter]').val('status').trigger('change');
+        $('[name=builder_rule_2_operator]').val('is_null').trigger('change');
+
+        // set the section group to "or"
+        $('#builder_section_0 #builder_group_1>.rules-group-header>.group-conditions [value=OR]').trigger('click');
+
+        // set the section exists to "does not exist"
+        $('#builder_section_0>.rules-section-header>.section-exists-options [value="DOES NOT EXIST"]').trigger('click');
+
+        // add a section rule and delete it
+        $('#builder_section_0 #builder_group_1>.rules-group-header>.group-actions [data-add=rule]').trigger('click');
+        $('#builder_section_0 #builder_rule_3 [data-delete=rule]').trigger('click');
+
+        // add a section group and delete it
+        $('#builder_section_0 #builder_group_1>.rules-group-header>.group-actions [data-add=group]').trigger('click');
+        $('#builder_section_0 #builder_group_2 [data-delete=group]').trigger('click');
+
+        // add a section and delete it
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+        $('#builder_section_1 [data-delete=section]').trigger('click');
+
+        var generated = $b.queryBuilder('getRules');
+        var expected = {
+            condition: 'AND',
+            rules: [{
+                id: 'name',
+                operator: 'not_equal',
+                value: 'foo'
+            }, {
+                section: 'partner',
+                exists: 'DOES NOT EXIST',
+                group: {
+                    condition: 'OR',
+                    rules: [{
+                        id: 'name',
+                        operator: 'begins_with',
+                        value: 'bar'
+                    },{
+                        id: 'status',
+                        operator: 'is_null'
+                    }]
+                }
+            }]
+        };
+
+        assert.rulesMatch(
+            generated,
+            expected,
+            'Should return correct rules after UI events'
+        );
+        assert.rulesMatch(
+            generated.rules != undefined && generated.rules[1] != undefined ? generated.rules[1].group : 'missing',
+            expected.rules[1].group,
+            'Should return correct section group after UI events'
+        );
+
+        // change the section type and set the first rule
+        $('[name=builder_section_0_section_type]').val('related').trigger('change');
+        $('[name=builder_rule_5_filter]').val('name').trigger('change');
+        $('[name=builder_rule_5_operator]').val('begins_with').trigger('change');
+        $('[name=builder_rule_5_value_0]').val('bar').trigger('change');
+
+        // confirm that the old section rules are gone and the new one is in place
+        var generated = $b.queryBuilder('getRules');
+        var expected = {
+            condition: 'AND',
+            rules: [{
+                id: 'name',
+                operator: 'not_equal',
+                value: 'foo'
+            }, {
+                section: 'related',
+                exists: 'DOES NOT EXIST',
+                group: {
+                    condition: 'AND',
+                    rules: [{
+                        id: 'name',
+                        operator: 'begins_with',
+                        value: 'bar'
+                    }]
+                }
+            }]
+        };
+
+        assert.rulesMatch(
+            generated,
+            expected,
+            'Should return correct rules after UI events'
+        );
+        assert.rulesMatch(
+            generated.rules != undefined && generated.rules[1] != undefined ? generated.rules[1].group : 'missing',
+            expected.rules[1].group,
+            'Should return correct section group after UI events'
+        );
+
+    });
+
+    /**
+     * Test filter.operators within sections
+     */
+    QUnit.test('Change operators within sections', function(assert) {
+        $b.queryBuilder({
+            filters: [{
+                id: 'name',
+                type: 'string'
+            }],
+            sections: [{
+                id: 'test',
+                filters: [{
+                    id: 'name',
+                    type: 'string'
+                }, {
+                    id: 'price',
+                    type: 'double'
+                }, {
+                    id: 'release',
+                    type: 'date',
+                    operators: ['before', 'equal', 'after']
+                }]
+            }],
+            rules: {
+                condition: 'AND',
+                rules: [{
+                    section: 'test',
+                    exists: 'EXISTS',
+                    group: {
+                        condition: 'AND',
+                        rules: [{
+                            id: 'name',
+                            operator: 'equal',
+                            value: 'foo'
+                        }, {
+                            id: 'price',
+                            operator: 'less',
+                            value: 10
+                        }, {
+                            id: 'release',
+                            operator: 'before',
+                            value: '1995-5-1'
+                        }]
+                    }
+                }]
+            },
+            operators: [
+                {type: 'equal',     nb_inputs: 1,    apply_to: ['string']},
+                {type: 'not_equal', nb_inputs: 1,    apply_to: ['string']},
+                {type: 'less',      nb_inputs: 1,    apply_to: ['number']},
+                {type: 'greater',   nb_inputs: 1,    apply_to: ['number']},
+                {type: 'before',    nb_inputs: 1,    apply_to: ['datetime']},
+                {type: 'after',     nb_inputs: 1,    apply_to: ['datetime']}
+            ]
+        });
+
+        assert.optionsMatch(
+            $('#builder_rule_0 [name$=_operator] option'),
+            ['equal', 'not_equal'],
+            '"name" filter should have "equal" & "not_equal" operators'
+        );
+
+        assert.optionsMatch(
+            $('#builder_rule_1 [name$=_operator] option'),
+            ['less', 'greater'],
+            '"price" filter should have "less" & "greater" operators'
+        );
+
+        assert.optionsMatch(
+            $('#builder_rule_2 [name$=_operator] option'),
+            ['before', 'equal', 'after'],
+            '"release" filter should have "before" & "equal" & "after" operators'
+        );
+    });
+
+    /**
+     * Test custom conditions within sections
+     */
+    QUnit.test('Change conditions within sections', function(assert) {
+        var rules = {
+            condition: 'NAND',
+            rules: [{
+                section: 'partner',
+                exists: 'EXISTS',
+                group: {
+                    condition: 'NAND',
+                    rules: [{
+                        id: 'name',
+                        operator: 'equal',
+                        value: 'foo'
+                    }, {
+                        condition: 'XOR',
+                        rules: [{
+                            id: 'name',
+                            operator: 'equal',
+                            value: 'bar'
+                        }]
+                    }]
+                }
+            }]
+        };
+
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: rules,
+            conditions: ['NAND', 'XOR'],
+            default_condition: 'NAND'
+        });
+
+        assert.rulesMatch(
+            $b.queryBuilder('getRules'),
+            rules,
+            'Should return correct rules'
+        );
+
+        assert.optionsMatch(
+            $('#builder_group_0 > .rules-group-header [name$=_cond]'),
+            ['NAND', 'XOR'],
+            'Available onditions should be NAND & XOR'
+        );
+
+        assert.equal(
+            $('#builder_group_2 [name$=_cond]:checked').val(),
+            'XOR',
+            'The second group should have "XOR" condition selected'
+        );
+    });
+
+    /**
+     * Test readonly
+     */
+    QUnit.test('Readonly within sections', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            rules: {
+                condition: 'AND',
+                flags: {
+                    condition_readonly: true
+                },
+                rules: [{
+                    section: 'partner',
+                    exists: 'EXISTS',
+                    flags: {
+                        exists_readonly: true
+                    },
+                    group: {
+                        condition: 'AND',
+                        flags: {
+                            condition_readonly: true
+                        },
+                        rules: [{
+                            id: 'name',
+                            operator: 'not_equal',
+                            value: 'foo',
+                            flags: {
+                                no_delete: true
+                            }
+                        }, {
+                            condition: 'OR',
+                            rules: [{
+                                id: 'status',
+                                operator: 'not_equal',
+                                value: 'ac',
+                                readonly: true
+                            }]
+                        }, {
+                            condition: 'AND',
+                            readonly: true,
+                            rules: [{
+                                id: 'name',
+                                operator: 'not_equal',
+                                value: 'bar'
+                            }]
+                        }]
+                    }
+                }]
+            }
+        });
+
+        assert.equal(
+            $('#builder_section_0 #builder_group_1>.rules-group-header input:not(:disabled)').length, 0,
+            'Should disable group condition radio buttons'
+        );
+
+        assert.equal(
+            $('#builder_section_0>.rules-section-header input:not(:disabled)').length, 0,
+            'Should disable section exists radio buttons'
+        );
+
+        assert.equal(
+            $('#builder_section_0 #builder_rule_0 [data-delete=rule]').length, 0,
+            'Should hide delete button of "no_delete" rule'
+        );
+
+        assert.equal(
+            $('#builder_section_0 #builder_rule_0').find('input:disabled, select:disabled').length, 0,
+            'Should not disable inputs of "no_delete" rule'
+        );
+
+        assert.equal(
+            $('#builder_section_0 #builder_rule_1 [data-delete=rule]').length, 0,
+            'Should hide delete button of "readonly" rule'
+        );
+
+        assert.equal(
+            $('#builder_section_0 #builder_rule_1').find('input:disabled, select:disabled').length, 3,
+            'Should disable inputs of "readonly" rule'
+        );
+
+        assert.equal(
+            $('#builder_section_0 #builder_group_3').find('[data-delete=group], [data-add=rule], [data-add=group]').length, 0,
+            'Should hide all buttons of "readonly" group'
+        );
+
+        $('#builder_section_0 #builder_group_2 [data-delete=group]').click();
+
+        assert.rulesMatch(
+            $b.queryBuilder('getRules'),
+            {
+                condition: 'AND',
+                rules: [{
+                    section: 'partner',
+                    exists: 'EXISTS',
+                    group: {
+                        condition: 'AND',
+                        rules: [{
+                            condition: 'AND',
+                            rules: [{
+                                id: 'name',
+                                operator: 'not_equal',
+                                value: 'foo'
+                            }, {
+                                condition: 'OR',
+                                rules: [{
+                                    id: 'status',
+                                    operator: 'not_equal',
+                                    value: 'ac'
+                                }]
+                            }, {
+                                condition: 'AND',
+                                rules: [{
+                                    id: 'name',
+                                    operator: 'not_equal',
+                                    value: 'bar'
+                                }]
+                            }]
+                        }]
+                    }
+                }]
+            },
+            'Should not delete group with readonly rule'
+        );
+    });
+
+    /**
+     * Test groups limit within section
+     */
+    QUnit.test('No groups allowed, other than the section group', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: basic_sections,
+            allow_groups: false
+        });
+
+        assert.ok(
+            $('#builder_group_0 [data-add=group]').length == 0,
+            'Should not contain group add button'
+        );
+
+        assert.throws(
+            function(){ $b.queryBuilder('setRules', {
+                condition: 'AND',
+                rules: [{
+                    id: 'price',
+                    field: 'price',
+                    operator: 'less',
+                    value: 10.25
+                }, {
+                    section: 'partner',
+                    group: {
+                        condition: 'AND',
+                        rules: [{
+                            id: 'name',
+                            field: 'name',
+                            operator: 'begins_with',
+                            value: 'Best'
+                        }, {
+                            condition: 'OR',
+                            rules: [{
+                                id: 'status',
+                                field: 'status',
+                                operator: 'equal',
+                                value: 'ac'
+                            },{
+                                id: 'status',
+                                field: 'status',
+                                operator: 'not_equal',
+                                value: 'iv'
+                            }]
+                        }]
+                    }
+                }]
+            }); },
+            /No more than 0 groups are allowed/,
+            'Should throw "No more than 0 groups are allowed" error'
+        );
+    });
+
+    /**
+     * Test filters ordering in sections
+     */
+    QUnit.test('Sort filters in sections', function(assert) {
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: [{
+                id: 'partner',
+                label: 'Partner',
+                filters: [{
+                    id: '3',
+                    label: {
+                        fr: 'ccc',
+                        en: 'Ccc'
+                    }
+                }, {
+                    id: '1',
+                    label: 'AAA'
+                }, {
+                    id: '5',
+                    label: 'eee'
+                }, {
+                    id: '2',
+                    label: 'bbb'
+                }, {
+                    id: '4',
+                    label: {
+                        fr: 'ddd',
+                        en: 'Ddd'
+                    }
+                }]
+            }],
+            sort_filters: true,
+            lang_code: 'fr'
+        });
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+        $('[name=builder_section_0_section_type]').val('partner').trigger('change');
+
+        var options = [];
+        $('[name=builder_rule_1_filter]>*').each(function() {
+            options.push($(this).val());
+        });
+
+        assert.deepEqual(
+            options,
+            ['-1', '1', '2', '3', '4', '5'],
+            'Filters should be sorted by alphabetical order'
+        );
+
+        $b.queryBuilder('destroy');
+
+        $b.queryBuilder({
+            filters: basic_filters,
+            sections: [{
+                id: 'partner',
+                label: 'Partner',
+                filters: [{
+                    id: '3',
+                    label: 'ccc'
+                }, {
+                    id: '1',
+                    label: 'AAA'
+                }, {
+                    id: '5',
+                    label: 'eee'
+                }, {
+                    id: '2',
+                    label: 'bbb'
+                }, {
+                    id: '4',
+                    label: 'ddd'
+                }]
+            }],
+            sort_filters: function(a, b) {
+                return parseInt(b.id) - parseInt(a.id);
+            }
+        });
+
+        $('#builder_group_0>.rules-group-header>.group-actions [data-add=section]').trigger('click');
+        $('[name=builder_section_0_section_type]').val('partner').trigger('change');
+
+        options = [];
+        $('[name=builder_rule_1_filter]>*').each(function() {
+            options.push($(this).val());
+        });
+
+        assert.deepEqual(
+            options,
+            ['-1', '5', '4', '3', '2', '1'],
+            'Filters should be sorted by custom order'
+        );
+    });
+});