Retrieve the value of a key
@param string $key
@param array $query the extra query params
@return array
@throws KeyNotFoundException
351874
public function getNode($key, array $query = array())
    {
        try {
            $response = $this->guzzleclient->get(
                $this->buildKeyUri($key),
                array(
                    'query' => $query
                )
            );
        } catch (BadResponseException $e) {
            $response = $e->getResponse();
        }
        $body = json_decode($response->getBody(), true);
        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new RuntimeException('Unable to parse response body into JSON: ' . json_last_error());
        }
        if (isset($body['errorCode'])) {
            throw new KeyNotFoundException($body['message'], $body['errorCode']);
        }
        return $body['node'];
    }
31545
public function get($key){
		$mc=$this->getMemcache();
		if(empty($mc))return NULL;
		$this->queries_get_count++;
		return $mc->get($key);
		}
581397
public function get($key) {
        try {
            $result = $this->getRedis()->get($key);
            if ($result === false) {
                throw new KeyNotFoundException();
            }
            return $result;
        } catch (RedisException $ex) {
            throw new ConnectException();
        }
    }
949283
protected function filterNonSearchableParameters(array $query) {
        $nonSearchableParameterNames = [$this->getQueryModeParameterName()];

        if (property_exists($this, 'withParameterName')) {
            $nonSearchableParameterNames[] = $this->withParameterName;
        }

        if (property_exists($this, 'sortParameterName')) {
            $nonSearchableParameterNames[] = $this->sortParameterName;
        }

        return array_except($query, $nonSearchableParameterNames);
    }
394055
protected function getValueFromRelationQuery($query)
    {
        // Prevent looking up connected model when foreign keys are NULL to prevent query errors.

        /** @var MorphTo $query */
        $typeName = $query->getMorphType();
        $keyName  = $query->getForeignKey();

        if ( ! $this->model->{$typeName} || ! $this->model->{$keyName}) {
            return null;
        }

        $query = $this->prepareRelationQuery($query);

        return $this->getValueFromModel(
            $query->first()
        );
    }
916828
public static function get($key)
    {
        exception_if(!array_has(self::$links, $key), LinkKeyNotFoundException::class, $key);

        return array_get(self::$links, $key);
    }
282870
public function decode($query): array
    {
        foreach (explode("&", $query) as $keyValuePair) {
            list($key, $value) = $this->decodePair($keyValuePair);
            $this->values->addValue($key, $value);
        }
        return $this->values->getValues();
    }
881567
public function resolve($query)
    {
        $queryClassName = self::findBaseName($query);
    
        if ($query instanceof ICommand) {
            
            if (isset($this->commandHandlers[$queryClassName])) {
                return $this->commandHandlers[$queryClassName];
            }
            
            throw new HandlerNotFoundException($queryClassName);
        }
        
        // if its not a command, then it must be a query
        if (isset($this->queryHandlers[$queryClassName])) {
            return $this->queryHandlers[$queryClassName];
        }
        
        throw new HandlerNotFoundException($queryClassName);
    }
775153
protected function getValue($key, array $array = array())
    {
        $keys = $this->parseKey($key);

        while (count($keys) > 0 and !is_null($array)) {
            $key = array_shift($keys);
            $array = isset($array[$key]) ? $array[$key] : null;
        }

        return $array;
    }
976794
public function get($key)
    {
        expect_type($key, 'string');

        $value = DotKey::on($this)->get($key);

        if (!isset($value)) {
            throw new NotFoundException("Config setting '$key' not found");
        }

        return $value;
    }
775498
public function scopeKey(Illuminate\Database\Query\Builder $query, $key)
    {
        return $query->whereKey($key);
    }
1164199
protected function getQueryString($query)
    {
        $wrapper = ($query instanceof AbstractQuery) ? array('query' => $query->toArray()) : $query->toArray();

        return json_encode($wrapper);
    }
1348107
public function query($key, $value = null)
    {
        $query = array();

        parse_str(
            $this->server()->get('QUERY_STRING'),
            $query
        );

        if (is_array($key)) {
            $query = array_merge($query, $key);
        } else {
            $query[$key] = $value;
        }

        $request_uri = $this->uri();

        if (strpos($request_uri, '?') !== false) {
            $request_uri = strstr($request_uri, '?', true);
        }

        return $request_uri . (!empty($query) ? '?' . http_build_query($query) : null);
    }
668612
public function getArray($query)
    {
        $this->statement = $this->db->query($query);
        if ($this->statement) {
            return $this->statement->fetch(\PDO::FETCH_ASSOC);
        }
        return false;
    }
39216
public function getParameter($key)
    {
        $query = $this->getQuery();

        return isset($query[$key]) ? $query[$key] : null;
    }
541803
public function getValue($key){
        
        if(!array_key_exists($key, $this->values)){
            throw new DbManagementException(DbManagementException::UNEXISTING_KEY);
        }
        return $this->values[$val];
    }
385206
public function buildQuery($query)
    {
        $q = $this->request->getQuery();

        foreach ($query as $key => $value)
        {
            $q[$key] = $value;
        }
    }