PHP DynamoDbClient::getItem方法代码示例

 /**
  * {@inheritDoc}
  */
 public function exists($entityClass, $primaryKey, array $commandOptions = array())
 {
     $entity = $this->initEntity($entityClass, $primaryKey);
     $commandOptions = array('ConsistentRead' => $this->consistentRead, 'TableName' => $this->getEntityTable($entity), 'Key' => $this->formatKeyCondition($entity), 'ReturnConsumedCapacity' => $this->returnConsumedCapacity);
     $model = $this->dynamoDb->getItem($commandOptions);
     return isset($model['Item']);
 }

 /**
  * Retrieve single result using hash_key and range_key
  *
  * @param  string $hash_key_value
  * @param  string $range_key_value
  * @param  array  $options
  *
  * @return \Kettle\ORM instance of the ORM sub class
  */
 public function findOne($hash_key_value, $range_key_value = null, array $options = array())
 {
     $conditions = array($this->_hash_key => $hash_key_value);
     if ($range_key_value) {
         if (!$this->_range_key) {
             throw new \Exception("Range key is not defined.");
         }
         $conditions[$this->_range_key] = $range_key_value;
     }
     $key = $this->_formatAttributes($conditions);
     $args = array('TableName' => $this->_table_name, 'Key' => $key, 'ConsistentRead' => $this->_consistent_read, 'ReturnConsumedCapacity' => 'TOTAL');
     // Merge $options to $args
     $option_names = array('AttributesToGet', 'ReturnConsumedCapacity');
     foreach ($option_names as $option_name) {
         if (isset($options[$option_name])) {
             $args[$option_name] = $options[$option_name];
         }
     }
     $item = self::$_client->getItem($args);
     self::_logQuery('getItem', $args, $item);
     if (!is_array($item['Item'])) {
         return null;
     }
     $result = $this->_formatResult($item['Item']);
     $class_name = get_called_class();
     $instance = self::factory($class_name);
     $instance->hydrate($result);
     return $instance;
 }

 /**
  * Get an item via the get_item call
  * @param string $table The item table
  * @param mixed $hash The primary hash key
  * @param mixed|null $range The primary range key
  * @param Context\Get|null $context The call context
  * @return Item|null
  */
 public function get($table, $hash, $range = null, Context\Get $context = null)
 {
     if (null !== $this->logger) {
         $this->log('Get on table ' . $table);
     }
     // Primary key
     $hash = new Attribute($hash);
     $parameters = array('TableName' => $table, 'Key' => array('HashKeyElement' => $hash->getForDynamoDB()));
     // Range key
     if (null !== $range) {
         $range = new Attribute($range);
         $parameters['Key']['RangeKeyElement'] = $range->getForDynamoDB();
     }
     if (null !== $context) {
         $parameters += $context->getForDynamoDB();
     }
     if (null !== $this->logger) {
         $this->log('Get request paramaters : ' . print_r($parameters, true), Logger::DEBUG);
     }
     $response = $this->connector->getItem($parameters);
     if (null !== $this->logger) {
         $this->log('Get request response : ' . print_r($response, true), Logger::DEBUG);
     }
     $this->addConsumedReadUnits($table, floatval($response['ConsumedCapacityUnits']));
     if (isset($response['Item'])) {
         $item = new Item($table);
         $item->populateFromDynamoDB($response['Item']);
         return $item;
     } else {
         if (null !== $this->logger) {
             $this->log('Didn\'t find item');
         }
         return null;
     }
 }

 /**
  * Get Item data
  *
  * @param $id
  * @return array|bool|stdClass
  */
 public function getData($id)
 {
     if (empty($this->table)) {
         return false;
     }
     /**
      * Get item
      */
     $result = $this->client->getItem(['TableName' => $this->table, 'Key' => ['id' => ['S' => $id]]]);
     /**
      * Un Marshal Item
      */
     $marshaler = new Marshaler();
     $data = $marshaler->unmarshalItem($result['Item']);
     return $data;
 }

 /**
  * Returns the value associated with field in the hash stored at key
  * 
  * @param string $key
  *            The desired key to get a hash value from
  * @param string $field
  *            The name of the hash field to get
  * @return mixed The value stored at the specified hash field
  */
 public function hGet($key, $field)
 {
     $result = $this->client->getItem(array('TableName' => $this->tableName, 'Key' => array(self::SIMPLE_KEY_NAME => array('S' => $key)), 'ConsistentRead' => true, 'AttributesToGet' => array(self::HPREFIX . $field)));
     if (isset($result['Item'][self::HPREFIX . $field])) {
         return base64_decode($result['Item'][self::HPREFIX . $field]['B']);
     } else {
         return false;
     }
 }

 public function testDeleteRecord()
 {
     $seed = $this->seed();
     $seedId = array_get($seed, 'id.S');
     $this->testModel->find($seedId)->delete();
     $query = ['TableName' => $this->testModel->getTable(), 'Key' => ['id' => ['S' => $seedId]]];
     $record = $this->dynamoDbClient->getItem($query)->toArray();
     $this->assertArrayNotHasKey('Item', $record);
 }

 /**
  * @param $key
  ** get and getValue methods return false on non existent key* get and getValue methods return false on non existent key
  * @return int|string|bool
  */
 public function getValue($key)
 {
     $response = $this->dynamoDbClient->getItem(['TableName' => $this->tableName, 'Key' => [$this->attribute => [$this->getVariableType($key) => (string) $key]]]);
     if ($response->hasKey('Item')) {
         $array = $response['Item']['status'];
         $value = reset($array);
         $key = key($array);
         return $this->getCastedResponse($key, $value);
     } else {
         return false;
     }
 }

 public function testGetItem()
 {
     try {
         $result = self::$client->getItem(['TableName' => self::$tableName, 'ConsistentRead' => true, 'Key' => ['id' => ['S' => $this->message->get('id')->toString()]]]);
     } catch (\Exception $e) {
         $this->fail($e->getMessage());
         return;
     }
     $this->assertSame($result['Item']['id']['S'], $this->message->get('id')->toString());
     $message = $this->marshaler->unmarshal($result['Item']);
     foreach ($this->message->schema()->getFields() as $field) {
         $expected = $this->message->get($field->getName());
         $actual = $message->get($field->getName());
         if ($field->isASet()) {
             sort($expected);
             sort($actual);
         }
         $this->assertSame(json_encode($expected), json_encode($actual));
     }
     //echo json_encode($message, JSON_PRETTY_PRINT);
 }

 public function get(array $keys, $is_consistent_read = false)
 {
     $keyItem = DynamoDbItem::createFromArray($keys, $this->attributeTypes);
     $requestArgs = ["TableName" => $this->tableName, "Key" => $keyItem->getData()];
     if ($is_consistent_read) {
         $requestArgs["ConsistentRead"] = true;
     }
     $result = $this->dbClient->getItem($requestArgs);
     if ($result['Item']) {
         $item = DynamoDbItem::createFromTypedArray((array) $result['Item']);
         return $item->toArray();
     } else {
         return null;
     }
 }

 /**
  * @depends testCreatesTable
  */
 public function testAddsGetsAndDeletesItems()
 {
     $attributes = $this->client->formatAttributes(array('foo' => 'Test', 'bar' => 10, 'baz' => 'abc'));
     self::log('Adding an item to the table: ' . var_export($attributes, true));
     $result = $this->client->putItem(array('TableName' => $this->table, 'Item' => $attributes));
     $this->assertTrue(isset($result['ConsumedCapacityUnits']));
     self::log('Getting the item');
     // Get the item using the formatAttributes helper
     $result = $this->client->getItem(array('TableName' => $this->table, 'Key' => $this->client->formatAttributes(array('HashKeyElement' => 'Test', 'RangeKeyElement' => 10)), 'ConsistentRead' => true));
     $this->assertEquals('Test', $result['Item']['foo']['S']);
     $this->assertEquals(10, $result['Item']['bar']['N']);
     $this->assertEquals('abc', $result['Item']['baz']['S']);
     self::log('Deleting the item');
     $result = $this->client->deleteItem(array('TableName' => $this->table, 'Key' => $this->client->formatAttributes(array('HashKeyElement' => 'Test', 'RangeKeyElement' => 10))));
     $this->assertTrue(isset($result['ConsumedCapacityUnits']));
 }

 /**
  * The GetItem operation returns a set of attributes for the item with the given primary key.
  * If there is no matching item, GetItem does not return any data.
  *
  * @param string  $tableName              The name of the table containing the requested item.
  * @param array   $key                    Associative array of <AttributeName> keys mapping to (associative-array) values.
  * @param array   $attributesToGet        The names of one or more attributes to retrieve. If no attribute names are specified, then all attributes will be returned.
  * @param boolean $consistentRead         If set to true, then the operation uses strongly consistent reads; otherwise, eventually consistent reads are used.
  * @param string  $returnConsumedCapacity Sets consumed capacity return mode.
  *
  * @return Guzzle\Service\Resource\Model
  *
  * @see http://docs.aws.amazon.com/aws-sdk-php/latest/class-Aws.DynamoDb.DynamoDbClient.html#_getItem
  */
 public function getItem($tableName, array $key, array $attributesToGet = null, $consistentRead = false, $returnConsumedCapacity = self::CAPACITY_NONE)
 {
     $args = ['TableName' => $tableName, 'Key' => $key, 'ConsistentRead' => $consistentRead, 'ReturnConsumedCapacity' => $returnConsumedCapacity];
     if ($attributesToGet !== null) {
         $args['AttributesToGet'] = $attributesToGet;
     }
     // Try to load from cache is a cacheService is available
     if ($this->cacheService !== null) {
         $cacheKey = $this->generateCacheKey($args);
         if ($this->cacheService->has($cacheKey)) {
             return unserialize($this->cacheService->get($cacheKey));
         }
     }
     // Sends getItem command to AWS
     $result = $this->client->getItem($args);
     // Saves to cache
     if ($this->cacheService !== null) {
         $this->cacheService->set($cacheKey, serialize($result), $this->requestTtl);
     }
     return $result;
 }

 public function getData($id)
 {
     $r = $this->dynamoDb->getItem(array('ConsistentRead' => true, 'TableName' => $this->tableName, 'Key' => array('id' => array('S' => (string) $id))));
     return $r['Item'];
 }