Override SELECT and EXAMINE to add
516182
function(prevHandler, connection, parsed, data, callback) {
            if (hasCondstoreOption(parsed.attributes && parsed.attributes[1], parsed.attributes, 1)) {
                connection.sessionCondstore = true;
            } else if ('sessionCondstore' in connection) {
                connection.sessionCondstore = false;
            }
            prevHandler(connection, parsed, data, callback);
        }
1257655
function checkSelectPropTypes(inst, props) {
  var owner = inst._currentElement._owner;
  LinkedValueUtils.checkPropTypes('select', props, owner);

  if (props.valueLink !== undefined && !didWarnValueLink) {
     false ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;
    didWarnValueLink = true;
  }

  for (var i = 0; i < valuePropNames.length; i++) {
    var propName = valuePropNames[i];
    if (props[propName] == null) {
      continue;
    }
    var isArray = Array.isArray(props[propName]);
    if (props.multiple && !isArray) {
       false ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
    } else if (!props.multiple && isArray) {
       false ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
    }
  }
}
1113706
function _getSelected(select) {
    const arr = [];

    _slice.call(select.options).map((el) => {
        if (el.selected) {
            arr.push(el.value);
        }
    });

    return arr;
}
258732
function select (args) {
    if (this.typecheck) t.typecheck('select', [args]);
    if ('string'===typeof args) args = [args];
    return 'select '+args.join();
}
758865
function select (index) {
    // force form to update state for validation
    $mdUtil.nextTick(function () {
      getDisplayValue(ctrl.matches[ index ]).then(function (val) {
        var ngModel = elements.$.input.controller('ngModel');
        $mdLiveAnnouncer.announce(val + ' ' + ctrl.selectedMessage, 'assertive');
        ngModel.$setViewValue(val);
        ngModel.$render();
      }).finally(function () {
        $scope.selectedItem = ctrl.matches[ index ];
        setLoading(false);
      });
    }, false);
  }
62026
def selecttrue(table, field, complement=False):
    """"""

    return select(table, field, lambda v: bool(v), complement=complement)
1087185
def select(&predicate)
      filter("select") do |yielder|
        each do |element|
          yielder.call(element) if yield(element)
        end
      end
    end
448442
def visit_select(self, select, asfrom=False, parens=True,
                     fromhints=None,
                     compound_index=0,
                     nested_join_translation=False,
                     select_wraps_for=None,
                     **kwargs):
        jsn = {'command': 'advanced/search', 'type': 'select'}
        needs_nested_translation = \
            select.use_labels and \
            not nested_join_translation and \
            not self.stack and \
            not self.dialect.supports_right_nested_joins

        if needs_nested_translation:
            transformed_select = self._transform_select_for_nested_joins(
                select)
            text = self.visit_select(
                transformed_select, asfrom=asfrom, parens=parens,
                fromhints=fromhints,
                compound_index=compound_index,
                nested_join_translation=True, **kwargs
            )

        toplevel = not self.stack
        entry = self._default_stack_entry if toplevel else self.stack[-1]

        populate_result_map = toplevel or \
                              (
                                  compound_index == 0 and entry.get(
                                      'need_result_map_for_compound', False)
                              ) or entry.get('need_result_map_for_nested',
                                             False)

        # this was first proposed as part of #3372; however, it is not
        # reached in current tests and could possibly be an assertion
        # instead.
        if not populate_result_map and 'add_to_result_map' in kwargs:
            del kwargs['add_to_result_map']

        if needs_nested_translation:
            if populate_result_map:
                self._transform_result_map_for_nested_joins(
                    select, transformed_select)
            return jsn

        froms = self._setup_select_stack(select, entry, asfrom)

        column_clause_args = kwargs.copy()
        column_clause_args.update({
            'within_label_clause': False,
            'within_columns_clause': False
        })

        if select._hints:
            hint_text, byfrom = self._setup_select_hints(select)
            if hint_text:
                text += hint_text + " "
        else:
            byfrom = None


        
        if select._distinct:
            jsn['distinct'] = True

        # the actual list of columns to print in the SELECT column list.
        inner_columns = [
            c for c in [
                self._label_select_column(
                    select,
                    column,
                    populate_result_map, asfrom,
                    column_clause_args,
                    name=name)
                for name, column in select._columns_plus_names
                ]
            if c is not None
            ]

        if populate_result_map and select_wraps_for is not None:
            # if this select is a compiler-generated wrapper,
            # rewrite the targeted columns in the result map
            wrapped_inner_columns = set(select_wraps_for.inner_columns)
            translate = dict(
                (outer, inner.pop()) for outer, inner in [
                    (
                        outer,
                        outer.proxy_set.intersection(wrapped_inner_columns))
                    for outer in select.inner_columns
                    ] if inner
            )
            self._result_columns = [
                (key, name, tuple(translate.get(o, o) for o in obj), type_)
                for key, name, obj, type_ in self._result_columns
                ]

        jsn = self._compose_select_body(
            jsn, select, inner_columns, froms, byfrom, kwargs)

        if select._statement_hints:
            per_dialect = [
                ht for (dialect_name, ht)
                in select._statement_hints
                if dialect_name in ('*', self.dialect.name)
                ]
            if per_dialect:
                text += " " + self.get_statement_hint_text(per_dialect)

        if self.ctes and self._is_toplevel_select(select):
            text = self._render_cte_clause() + text

        if select._suffixes:
            text += " " + self._generate_prefixes(
                select, select._suffixes, **kwargs)

        self.stack.pop(-1)

        if asfrom and parens:
            return jsn  # "(" + text + ")"
        else:
            return jsn
840127
def selectcontains(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.contains,
                    complement=complement)
736060
def _set_add_options(cls, checked_codes, options):
        """"""
        checked_codes |= cls._expand_error_codes(options.add_select)
        checked_codes -= cls._expand_error_codes(options.add_ignore)
1326827
def as_select(self, _items=None, **kwargs):
        
        attrs = self.extra.copy()
        attrs.update(kwargs)
        attrs['name'] = self.name
        if not self.optional:
            attrs['required'] = True
        html = [u'<select %s>' % get_html_attrs(attrs)]
        values = [self.to_string(**attrs)] or []
        items = _items or self.items

        for item in items:
            if isinstance(item, list):
                html.extend(self._render_optgroup(item, values))
            else:
                html.append(self._render_option(item, values))
        html.append(u'</select>')

        return Markup('\n'.join(html))
1132457
public function addSelect($select)
    {
        if (null === $select) {
            return $this;
        }
        if (is_array($select)) {
            $t = [];
            foreach ($select as $field => $alias) {
                if (is_int($field)) {
                    $alias = $this->quoteColumnName($alias);
                    array_push($t, "{$alias}");
                } else {
                    $field = $this->quoteColumnName($field);
                    $alias = $this->quoteColumnName($alias);
                    array_push($t, "{$field} AS {$alias}");
                }
            }
            $select = implode(',', $t);
        }
        if (isset($this->query['select']) && !empty($this->query['select'])) {
            $select = "{$this->query['select']},{$select}";
        }
        $this->query['select'] = $select;
        return $this;
    }
1245154
def select(method, choices = nil, options = {}, html_options = {}, &block)
      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
      return super if bootstrap.disabled

      add_css_class!(html_options, "custom-select") if bootstrap.custom_control

      draw_form_group(bootstrap, method, html_options) do
        super(method, choices, options, html_options, &block)
      end
    end
1324110
def append(self, item, select=False):
        
        if item in self:
            raise ValueError("item %s already in list" % item)
        modeliter = self.model.append((item,))
        self._id_to_iter[id(item)] = modeliter
        if select:
            self.selected_item = item
        self.emit('item-added', item)
509219
def complete_opt_allow_select_scan(self, text, *_):
        
        return [t for t in ("true", "false", "yes", "no") if t.startswith(text.lower())]
1166630
function() {
    // Save on blur for multi-select
    if(this.multiple) {
        Ev.addListener(this.dropdown, "blur", function(v){
            // Save on change
            this.save();
        }, this, true);
    }
    // Save on change for single-select
    else {
        Ev.addListener(this.dropdown, "change", function(v){
            // Save on change
            this.save();
        }, this, true);
    }
}
781513
private void addInstSelect(final Select _select, final AbstractDataElement<?> _element, final Object _attrOrClass,
                               final Type _currentType)
        throws CacheReloadException
    {
        if (StringUtils.isNotEmpty(_element.getPath()) && !this.instSelects.containsKey(_element.getPath())) {
            final Select instSelect = Select.get();
            for (final AbstractElement<?> selectTmp : _select.getElements()) {
                if (!selectTmp.equals(_element)) {
                    if (selectTmp instanceof LinktoElement) {
                        instSelect.addElement(new LinktoElement().setAttribute(((LinktoElement) selectTmp)
                                        .getAttribute()));
                    } else if (selectTmp instanceof LinkfromElement) {
                        instSelect.addElement(new LinkfromElement().setAttribute(((LinkfromElement) selectTmp)
                                        .getAttribute()).setStartType(((LinkfromElement) selectTmp).getStartType()));
                    } else if (selectTmp instanceof ClassElement) {
                        instSelect.addElement(new ClassElement()
                                        .setClassification(((ClassElement) selectTmp).getClassification())
                                        .setType(((ClassElement) selectTmp).getType()));
                    } else if (selectTmp instanceof AttributeSetElement) {
                        instSelect.addElement(new AttributeSetElement()
                                        .setAttributeSet(((AttributeSetElement) selectTmp).getAttributeSet())
                                        .setType(((ClassElement) selectTmp).getType()));
                    }
                }
            }
            if (_element instanceof LinkfromElement) {
                instSelect.addElement(new LinkfromElement().setAttribute((Attribute) _attrOrClass).setStartType(
                                _currentType));
                instSelect.addElement(new InstanceElement(((Attribute) _attrOrClass).getParent()));
            } else if (_element instanceof LinktoElement) {
                instSelect.addElement(new LinktoElement().setAttribute((Attribute) _attrOrClass));
                instSelect.addElement(new InstanceElement(_currentType));
            } else if (_element instanceof ClassElement) {
                instSelect.addElement(new ClassElement().setClassification((Classification) _attrOrClass)
                                .setType(_currentType));
                instSelect.addElement(new InstanceElement((Type) _attrOrClass));
            } else if (_element instanceof AttributeSetElement) {
                instSelect.addElement(new AttributeSetElement().setAttributeSet((AttributeSet) _attrOrClass)
                                .setType(_currentType));
                instSelect.addElement(new InstanceElement((Type) _attrOrClass));
            }
            this.instSelects.put(_element.getPath(), instSelect);
        }
    }