Returns the select properties for this query.

@return array of select property names.
@throws RepositoryException
if an error occurs.
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()]);
   }
387342
public function getPropertiesNames() {
		$propertiesList = [];
		
		foreach($this->_data as $item) {
			$propertiesList += array_keys($item);
		}
		
		return $propertiesList;
	}
573004
public function select(): array
	{
		$sql  = $this->query->getPrefix();
		$sql .= $this->setOperations($this->query->getSetOperations());
		$sql .= $this->query->isDistinct() ? 'SELECT DISTINCT ' : 'SELECT ';
		$sql .= $this->columns($this->query->getColumns(), true);
		$sql .= $this->from($this->query->getTable());
		$sql .= $this->joins($this->query->getJoins());
		$sql .= $this->wheres($this->query->getWheres());
		$sql .= $this->groupings($this->query->getGroupings());
		$sql .= $this->havings($this->query->getHavings());
		$sql .= $this->orderings($this->query->getOrderings());
		$sql .= $this->limit($this->query->getLimit());
		$sql .= $this->offset($this->query->getOffset());
		$sql .= $this->lock($this->query->getLock());

		return ['sql' => $sql, 'params' => $this->params];
	}
486486
public function getColumns()
	{
		$columns = $this->builder()->queryWithBinding(Expressions::getColumns($this->tableName))->get()->all();

		$_columns = [];

		foreach($columns as $column) {
			$_columns[] = Repository::getPlatformColumn($column);
		}

		return $_columns;
	}
608880
private function getAllProperties()
    {
        $allProperties = get_object_vars($this);
        $properties = array();
        foreach ($allProperties as $fullName => $value) {
            $fullNameComponents = explode("\0", $fullName);
            $propertyName = array_pop($fullNameComponents);
            if ($propertyName && isset($value)) {
                $properties[ $propertyName ] = $value;
            }
        }
        
        return $properties;
    }
251048
public List<Long> selectPostIds(EnumSet<Post.Type> types) throws SQLException {

      if(types == null || types.isEmpty()) {
         return selectPostIds();
      }

      List<Long> ids = Lists.newArrayListWithExpectedSize(4096);
      Connection conn = null;
      Statement stmt = null;
      ResultSet rs = null;

      String typesIn = inJoiner.join(types.stream().map(t -> String.format("'%s'", t.toString())).collect(Collectors.toSet()));

      try {
         conn = connectionSupplier.getConnection();
         stmt = conn.createStatement();
         rs = stmt.executeQuery(String.format(selectAllPostIdsTypeSQL, typesIn));
         while(rs.next()) {
            ids.add(rs.getLong(1));
         }
      } finally {
         SQLUtil.closeQuietly(conn, stmt, rs);
      }
      return ids;
   }
1292801
public Collection<Select> getAllSelects()
    {
        final List<Select> ret = new ArrayList<>(this.selects);
        ret.addAll(this.instSelects.values());
        return Collections.unmodifiableCollection(ret);
    }
1190068
public function find(Repository $repository = null): array
    {
        if (!$repository && !($repository = $this->repository)) {
            throw new \RuntimeException('The current Query object is not tied to any Repository');
        }

        return $repository->find($this->compileParameters());
    }
180325
public Collection<String> getPropertyNames() throws RepositoryException
   {

      HashSet<String> props = new HashSet<String>();
      for (HierarchicalProperty p : properties)
      {
         props.add(p.getStringName());
      }
      return props;

      // PropertyIterator iter = node.getProperties();
      // ArrayList<String> props = new ArrayList<String>();
      // while (iter.hasNext()) {
      // String name = iter.nextProperty().getName();
      // if (!"jcr:primaryType".equals(name) && !"jcr:mixinTypes".equals(name)
      // && !"jcr:data".equals(name) && !"jcr:uuid".equals(name))
      // props.add(name);
      // }
      // return props;
   }
574974
public PropertyData[] getAggregatedPropertyStates(NodeData nodeState) throws RepositoryException
   {
      if (nodeState.getPrimaryTypeName().equals(nodeTypeName))
      {
         List<PropertyData> propStates = new ArrayList<PropertyData>();
         for (int i = 0; i < propertyIncludes.length; i++)
         {
            propStates.addAll(Arrays.asList(propertyIncludes[i].resolvePropertyStates(nodeState)));
         }
         if (propStates.size() > 0)
         {
            return (PropertyData[])propStates.toArray(new PropertyData[propStates.size()]);
         }
      }
      return null;
   }
916098
final private function getSqlKeyValues() {
		
		// force to array
		$propertyNames = (array)$this->keyProperties;

		// list to return
		$values = array();

		foreach ($propertyNames as $name) {
			$values[] = $this->{$name};
		}

		return $values;

	}
516163
public List<PropertyImpl> getReferences(String identifier) throws RepositoryException
   {
      List<PropertyData> refDatas = transactionableManager.getReferencesData(identifier, true);
      List<PropertyImpl> refs = new ArrayList<PropertyImpl>(refDatas.size());
      for (int i = 0, length = refDatas.size(); i < length; i++)
      {
         PropertyData data = refDatas.get(i);
         ItemState state = changesLog.getItemState(data.getIdentifier());
         if (state != null)
         {
            if (state.isDeleted())
            {
               // if the Property was deleted skip it for now
               continue;
            }

            // otherwise use transient data
            data = (PropertyData)state.getData();
         }

         NodeData parent = (NodeData)getItemData(data.getParentIdentifier());
         // if parent exists check for read permissions, otherwise the parent was deleted in another session.
         if (parent != null)
         {
            // skip not permitted
            if (accessManager.hasPermission(parent.getACL(), new String[]{PermissionType.READ}, session.getUserState()
               .getIdentity()))
            {
               PropertyImpl item = (PropertyImpl)readItem(data, parent, true, false);

               refs.add(item);
               session.getActionHandler().postRead(item);
            }
         }
      }
      return refs;
   }
1271645
public List<?> getOptions() {
		if (getLookupTable() == null) {
			SelectionModel model = getComponentModel();
			return model.getOptions();
		} else {
			return APPLICATION_LOOKUP_TABLE.getTable(getLookupTable());
		}
	}
572291
public String[] getMixinTypeNames() throws RepositoryException
   {
      NodeType[] mixinTypes = getMixinNodeTypes();
      String[] mtNames = new String[mixinTypes.length];
      for (int i = 0; i < mtNames.length; i++)
      {
         mtNames[i] = mixinTypes[i].getName();
      }

      return mtNames;
   }
692920
public static List<FieldDefinition> getKeys(final String repositoryName) {
        final List<RepositoryDefinition> repositoryDefs = getRepositoryDefinitions();
        for (final RepositoryDefinition repositoryDefinition : repositoryDefs) {
            if (StringUtils.equals(repositoryName, repositoryDefinition.getName())) {
                return repositoryDefinition.getKeys();
            }
        }

        return null;
    }
974799
public function getProperties()
    {
        $propertyList = (new PropertyListFactory())->create();
        foreach ($this->item->getProperties() as $propertyName => $propertyValues) {
            $propertyList[$propertyName] = array_map([$this, 'getPropertyValue'], $propertyValues);
        }

        return $propertyList;
    }
192682
@SuppressWarnings("squid:S1168")
    public String[] selectOptions() {
        if (isNotPresentSelect()) {
            return null;    // returning an empty array could be confused with no options available
        }
        WebElement webElement = element.getWebElement();
        Select dropdown = new Select(webElement);
        List<WebElement> options = dropdown.getOptions();
        String[] stringOptions = new String[options.size()];
        for (int i = 0; i < options.size(); i++) {
            stringOptions[i] = options.get(i).getText();
        }
        return stringOptions;
    }