Select the passed +attributes+ from the table, subject to the
        restrictions provided by the other methods in this class.

        ex)

        >>> Repo("foos").select("name", "id")
        SELECT foos.name, foos.id FROM foos
968911
def select(self, *attributes):
        
        namespaced_attributes = [
            "{table}.{attr}".format(table=self.table_name, attr=attr)
            for attr in attributes
        ]
        cmd = ('select {attrs} from {table} '
               '{join_clause}{where_clause}{order_clause}'
               '{group_clause}{having_clause}{limit_clause}').format(
            table=self.table_name,
            attrs=", ".join(namespaced_attributes),
            where_clause=self.where_clause,
            join_clause=self.join_clause,
            order_clause=self.order_clause,
            group_clause=self.group_clause,
            having_clause=self.having_clause,
            limit_clause=self.limit_clause,
        ).rstrip()
        return Repo.db.execute(cmd, self.where_values + self.having_values + \
                               self.limit_value)
792150
async def select(**data):
    

    try:
        select_data = clickhouse_queries.select_from_table(table=data['table'], query=data['query'], fields=data['fields'])
        return str(select_data)

    except ServerException as e:
        exception_code = int(str(e)[5:8].strip())

        if exception_code == 60:
            return 'Table does not exists'
        elif exception_code == 50:
            return 'Invalid params'
840127
def selectcontains(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.contains,
                    complement=complement)
753390
def get_select_sql(self):
        
        if self.table:
            return '{0}.{1}'.format(self.table.get_identifier(), self.name)
        return '{0}'.format(self.name)
389179
def set_select(self, selector, updates):
        ''' 

        '''
        for obj in self.select(selector):
            for key, val in updates.items():
                setattr(obj, key, val)
548508
def select(table, key='default'):
    
    database = choice(__db[key + '.slave'])
    return database.select(table)
617298
def _select_property(self, line):
        """"""
        g = self.current['graph']
        if not line:
            out = g.all_properties
            using_pattern = False
        else:
            using_pattern = True
            if line.isdigit():
                line = int(line)
            out = g.get_property(line)
        if out:
            if type(out) == type([]):
                choice = self._selectFromList(out, using_pattern, "property")
                if choice:
                    self.currentEntity = {'name': choice.locale or choice.uri,
                                          'object': choice, 'type': 'property'}

            else:
                self.currentEntity = {'name': out.locale or out.uri,
                                      'object': out, 'type': 'property'}

            # ..finally:
            if self.currentEntity:
                self._print_entity_intro(entity=self.currentEntity)
        else:
            print("not found")
506210
public function select($table, $fields = "*", $where = ' ', $order = '', $limit = null, $offset = null, $array = array (), $fetchMode)
    {
        // TODO: Implement select() method.
    }
438161
def select_from_table(fields, table, query):
    

    select_data = client.execute(f"SELECT {fields} FROM {table} {query}", with_column_types=True)

    keys = [i[0] for i in select_data[1]]

    result = []

    for i in range(len(select_data[0])):
        tmp = []

        for j in range(len(keys)):
            tmp.append(str(select_data[0][i][j]))

        result.append(dict(list(zip(keys, tmp))))

    # for i in range(len(select_data[0])):
    #     result.append(dict(list(zip(keys, select_data[0][i]))))

    return result
592537
@NonNull
  public static SelectFrom selectFrom(@NonNull String table) {
    return selectFrom(CqlIdentifier.fromCql(table));
  }
304124
def select(self, columns=(), by=(), where=(), **kwds):
        
        return self._seu('select', columns, by, where, kwds)
402938
private Select selectFrom(TableDDL tableDDL) {
        return QueryBuilder.select()
                .column(tableDDL.getRowKeyColumnName())     // ROW_KEY_RESULT_SET_COLUMN
                .column(tableDDL.getChangeIdColumnName())   // CHANGE_ID_RESULT_SET_COLUMN
                .column(tableDDL.getValueColumnName())      // VALUE_RESULT_SET_COLUMN
                .from(tableDDL.getTableMetadata());
    }
1009518
def _handle_select(self, parts, result_metadata=None):
        """"""
        self.rowcount = -1
        if result_metadata is not None:
            # Select was prepared and we can use the already received metadata
            self.description, self._column_types = self._handle_result_metadata(result_metadata)

        for part in parts:
            if part.kind == part_kinds.RESULTSETID:
                self._resultset_id = part.value
            elif part.kind == part_kinds.RESULTSETMETADATA:
                self.description, self._column_types = self._handle_result_metadata(part)
            elif part.kind == part_kinds.RESULTSET:
                self._buffer = part.unpack_rows(self._column_types, self.connection)
                self._received_last_resultset_part = part.attribute & 1
                self._executed = True
            elif part.kind in (part_kinds.STATEMENTCONTEXT, part_kinds.TRANSACTIONFLAGS, part_kinds.PARAMETERMETADATA):
                pass
            else:
                raise InterfaceError("Prepared select statement response, unexpected part kind %d." % part.kind)
1094833
def select(self, condition):
        
        return self.__class__([p for p in self if condition(p)])
944239
def select(table, cols="*", where=(), group="", order=(), limit=(), **kwargs):
    """"""
    where = dict(where, **kwargs).items()
    sql, args = makeSQL("SELECT", table, cols, where, group, order, limit)
    return execute(sql, args)
327034
protected InternalQName[] getSelectProperties() throws RepositoryException
   {
      // get select properties
      List<InternalQName> selectProps = new ArrayList<InternalQName>();
      selectProps.addAll(Arrays.asList(root.getSelectProperties()));
      if (selectProps.size() == 0)
      {
         // use node type constraint
         LocationStepQueryNode[] steps = root.getLocationNode().getPathSteps();
         final InternalQName[] ntName = new InternalQName[1];
         steps[steps.length - 1].acceptOperands(new DefaultQueryNodeVisitor()
         {

            public Object visit(AndQueryNode node, Object data) throws RepositoryException
            {
               return node.acceptOperands(this, data);
            }

            public Object visit(NodeTypeQueryNode node, Object data)
            {
               ntName[0] = node.getValue();
               return data;
            }
         }, null);
         if (ntName[0] == null)
         {
            ntName[0] = Constants.NT_BASE;
         }
         NodeTypeData nt = session.getWorkspace().getNodeTypesHolder().getNodeType(ntName[0]);
         PropertyDefinitionData[] propDefs = nt.getDeclaredPropertyDefinitions();

         for (int i = 0; i < propDefs.length; i++)
         {
            PropertyDefinitionData propDef = propDefs[i];
            if (!propDef.isResidualSet() && !propDef.isMultiple())
            {
               selectProps.add(propDef.getName());
            }
         }
      }

      // add jcr:path and jcr:score if not selected already
      if (!selectProps.contains(Constants.JCR_PATH))
      {
         selectProps.add(Constants.JCR_PATH);
      }
      if (!selectProps.contains(Constants.JCR_SCORE))
      {
         selectProps.add(Constants.JCR_SCORE);
      }

      return (InternalQName[])selectProps.toArray(new InternalQName[selectProps.size()]);
   }
19090
def pick(self, selector, entity_set, min_quantity=None):
        
        if isinstance(selector, int):
            for e in entity_set:
                if e.id == selector:
                    return set((e,))
        else:
            if selector.lower() in ('self', 'me', 'myself'):
                return set((self.entity,))

            return set(
                e for e in entity_set
                if (e.is_('Named') and selector.lower() in e.Named.name.lower())
                and not e.is_(Invisible)
                and (not min_quantity or min_quantity == 1 or (e.is_(Stackable) and e.Stackable.quantity >= min_quantity))
            )