Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Paws::DynamoDB::Query(User Contributed Perl DocumentatPaws::DynamoDB::Query(3)

NAME
       Paws::DynamoDB::Query - Arguments for method Query on Paws::DynamoDB

DESCRIPTION
       This class represents the parameters used for calling the method	Query
       on the Amazon DynamoDB service. Use the attributes of this class	as
       arguments to method Query.

       You shouln't make instances of this class. Each attribute should	be
       used as a named argument	in the call to Query.

       As an example:

	 $service_obj->Query(Att1 => $value1, Att2 => $value2, ...);

       Values for attributes that are native types (Int, String, Float,	etc)
       can passed as-is	(scalar	values). Values	for complex Types (objects)
       can be passed as	a HashRef. The keys and	values of the hashref will be
       used to instance	the underlying object.

ATTRIBUTES
   AttributesToGet => ArrayRef[Str]
       This is a legacy	parameter, for backward	compatibility. New
       applications should use ProjectionExpression instead. Do	not combine
       legacy parameters and expression	parameters in a	single API call;
       otherwise, DynamoDB will	return a ValidationException exception.

       This parameter allows you to retrieve attributes	of type	List or	Map;
       however,	it cannot retrieve individual elements within a	List or	a Map.

       The names of one	or more	attributes to retrieve.	If no attribute	names
       are provided, then all attributes will be returned. If any of the
       requested attributes are	not found, they	will not appear	in the result.

       Note that AttributesToGet has no	effect on provisioned throughput
       consumption. DynamoDB determines	capacity units consumed	based on item
       size, not on the	amount of data that is returned	to an application.

       You cannot use both AttributesToGet and Select together in a Query
       request,	unless the value for Select is "SPECIFIC_ATTRIBUTES". (This
       usage is	equivalent to specifying AttributesToGet without any value for
       Select.)

       If you query a local secondary index and	request	only attributes	that
       are projected into that index, the operation will read only the index
       and not the table. If any of the	requested attributes are not projected
       into the	local secondary	index, DynamoDB	will fetch each	of these
       attributes from the parent table. This extra fetching incurs additional
       throughput cost and latency.

       If you query a global secondary index, you can only request attributes
       that are	projected into the index. Global secondary index queries
       cannot fetch attributes from the	parent table.

   ConditionalOperator => Str
       This is a legacy	parameter, for backward	compatibility. New
       applications should use FilterExpression	instead. Do not	combine	legacy
       parameters and expression parameters in a single	API call; otherwise,
       DynamoDB	will return a ValidationException exception.

       A logical operator to apply to the conditions in	a QueryFilter map:

       o   "AND" - If all of the conditions evaluate to	true, then the entire
	   map evaluates to true.

       o   "OR"	- If at	least one of the conditions evaluate to	true, then the
	   entire map evaluates	to true.

       If you omit ConditionalOperator,	then "AND" is the default.

       The operation will succeed only if the entire map evaluates to true.

       This parameter does not support attributes of type List or Map.

   ConsistentRead => Bool
       Determines the read consistency model: If set to	"true",	then the
       operation uses strongly consistent reads; otherwise, the	operation uses
       eventually consistent reads.

       Strongly	consistent reads are not supported on global secondary
       indexes.	If you query a global secondary	index with ConsistentRead set
       to "true", you will receive a ValidationException.

   ExclusiveStartKey =>	Paws::DynamoDB::Key
       The primary key of the first item that this operation will evaluate.
       Use the value that was returned for LastEvaluatedKey in the previous
       operation.

       The data	type for ExclusiveStartKey must	be String, Number or Binary.
       No set data types are allowed.

   ExpressionAttributeNames => Paws::DynamoDB::ExpressionAttributeNameMap
       One or more substitution	tokens for attribute names in an expression.
       The following are some use cases	for using ExpressionAttributeNames:

       o   To access an	attribute whose	name conflicts with a DynamoDB
	   reserved word.

       o   To create a placeholder for repeating occurrences of	an attribute
	   name	in an expression.

       o   To prevent special characters in an attribute name from being
	   misinterpreted in an	expression.

       Use the name. For example, consider the following attribute name:

       o   "Percentile"

       The name	of this	attribute conflicts with a reserved word, so it	cannot
       be used directly	in an expression. (For the complete list of reserved
       words, see Reserved Words in the	Amazon DynamoDB	Developer Guide).  To
       work around this, you could specify the following for
       ExpressionAttributeNames:

       o   "{""

       You could then use this substitution in an expression, as in this
       example:

       o   ""

       Tokens that begin with the : character are expression attribute values,
       which are placeholders for the actual value at runtime.

       For more	information on expression attribute names, see Accessing Item
       Attributes in the Amazon	DynamoDB Developer Guide.

   ExpressionAttributeValues =>	Paws::DynamoDB::ExpressionAttributeValueMap
       One or more values that can be substituted in an	expression.

       Use the : (colon) character in an expression to dereference an
       attribute value.	For example, suppose that you wanted to	check whether
       the value of the	ProductStatus attribute	was one	of the following:

       "Available | Backordered	| Discontinued"

       You would first need to specify ExpressionAttributeValues as follows:

       "{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
       ":disc":{"S":"Discontinued"} }"

       You could then use these	values in an expression, such as this:

       "ProductStatus IN (:avail, :back, :disc)"

       For more	information on expression attribute values, see	Specifying
       Conditions in the Amazon	DynamoDB Developer Guide.

   FilterExpression => Str
       A string	that contains conditions that DynamoDB applies after the Query
       operation, but before the data is returned to you. Items	that do	not
       satisfy the FilterExpression criteria are not returned.

       A FilterExpression is applied after the items have already been read;
       the process of filtering	does not consume any additional	read capacity
       units.

       For more	information, see Filter	Expressions in the Amazon DynamoDB
       Developer Guide.

       FilterExpression	replaces the legacy QueryFilter	and
       ConditionalOperator parameters.

   IndexName =>	Str
       The name	of an index to query. This index can be	any local secondary
       index or	global secondary index on the table. Note that if you use the
       IndexName parameter, you	must also provide TableName.

   KeyConditionExpression => Str
       The condition that specifies the	key value(s) for items to be retrieved
       by the Query action.

       The condition must perform an equality test on a	single hash key	value.
       The condition can also perform one of several comparison	tests on a
       single range key	value. Query can use KeyConditionExpression to
       retrieve	one item with a	given hash and range key value,	or several
       items that have the same	hash key value but different range key values.

       The hash	key equality test is required, and must	be specified in	the
       following format:

       "hashAttributeName" = ":hashval"

       If you also want	to provide a range key condition, it must be combined
       using AND with the hash key condition. Following	is an example, using
       the = comparison	operator for the range key:

       "hashAttributeName" = ":hashval"	AND "rangeAttributeName" = ":rangeval"

       Valid comparisons for the range key condition are as follows:

       o   "rangeAttributeName"	= ":rangeval" -	true if	the range key is equal
	   to ":rangeval".

       o   "rangeAttributeName"	_ ":rangeval" -	true if	the range key is less
	   than	":rangeval".

       o   "rangeAttributeName"	_= ":rangeval" - true if the range key is less
	   than	or equal to ":rangeval".

       o   "rangeAttributeName"	_ ":rangeval" -	true if	the range key is
	   greater than	":rangeval".

       o   "rangeAttributeName"	_= ":rangeval" - true if the range key is
	   greater than	or equal to ":rangeval".

       o   "rangeAttributeName"	BETWEEN	":rangeval1" AND ":rangeval2" -	true
	   if the range	key is greater than or equal to	":rangeval1", and less
	   than	or equal to ":rangeval2".

       o   begins_with ("rangeAttributeName", ":rangeval") - true if the range
	   key begins with a particular	operand. (You cannot use this function
	   with	a range	key that is of type Number.) Note that the function
	   name	"begins_with" is case-sensitive.

       Use the ExpressionAttributeValues parameter to replace tokens such as
       ":hashval" and ":rangeval" with actual values at	runtime.

       You can optionally use the ExpressionAttributeNames parameter to
       replace the names of the	hash and range attributes with placeholder
       tokens. This option might be necessary if an attribute name conflicts
       with a DynamoDB reserved	word. For example, the following
       KeyConditionExpression parameter	causes an error	because	Size is	a
       reserved	word:

       o   "Size = :myval"

       To work around this, define a placeholder (such a " the attribute name
       Size. KeyConditionExpression then is as follows:"

       o   ""

       For a list of reserved words, see Reserved Words	in the Amazon DynamoDB
       Developer Guide.

       For more	information on ExpressionAttributeNames	and
       ExpressionAttributeValues, see Using Placeholders for Attribute Names
       and Values in the Amazon	DynamoDB Developer Guide.

       KeyConditionExpression replaces the legacy KeyConditions	parameter.

   KeyConditions => Paws::DynamoDB::KeyConditions
       This is a legacy	parameter, for backward	compatibility. New
       applications should use KeyConditionExpression instead. Do not combine
       legacy parameters and expression	parameters in a	single API call;
       otherwise, DynamoDB will	return a ValidationException exception.

       The selection criteria for the query. For a query on a table, you can
       have conditions only on the table primary key attributes. You must
       provide the hash	key attribute name and value as	an "EQ"	condition.
       You can optionally provide a second condition, referring	to the range
       key attribute.

       If you don't provide a range key	condition, all of the items that match
       the hash	key will be retrieved. If a FilterExpression or	QueryFilter is
       present,	it will	be applied after the items are retrieved.

       For a query on an index,	you can	have conditions	only on	the index key
       attributes. You must provide the	index hash attribute name and value as
       an "EQ" condition. You can optionally provide a second condition,
       referring to the	index key range	attribute.

       Each KeyConditions element consists of an attribute name	to compare,
       along with the following:

       o   AttributeValueList -	One or more values to evaluate against the
	   supplied attribute. The number of values in the list	depends	on the
	   ComparisonOperator being used.

	   For type Number, value comparisons are numeric.

	   String value	comparisons for	greater	than, equals, or less than are
	   based on ASCII character code values. For example, "a" is greater
	   than	"A", and "a" is	greater	than "B". For a	list of	code values,
	   see http://en.wikipedia.org/wiki/ASCII

	   For Binary, DynamoDB	treats each byte of the	binary data as
	   unsigned when it compares binary values.

       o   ComparisonOperator -	A comparator for evaluating attributes,	for
	   example, equals, greater than, less than, and so on.

	   For KeyConditions, only the following comparison operators are
	   supported:

	   "EQ | LE | LT | GE |	GT | BEGINS_WITH | BETWEEN"

	   The following are descriptions of these comparison operators.

	   o   "EQ" : Equal.

	       AttributeValueList can contain only one AttributeValue of type
	       String, Number, or Binary (not a	set type). If an item contains
	       an AttributeValue element of a different	type than the one
	       specified in the	request, the value does	not match. For
	       example,	"{"S":"6"}" does not equal "{"N":"6"}".	Also,
	       "{"N":"6"}" does	not equal "{"NS":["6", "2", "1"]}".

	   o   "LE" : Less than	or equal.

	       AttributeValueList can contain only one AttributeValue element
	       of type String, Number, or Binary (not a	set type). If an item
	       contains	an AttributeValue element of a different type than the
	       one provided in the request, the	value does not match. For
	       example,	"{"S":"6"}" does not equal "{"N":"6"}".	Also,
	       "{"N":"6"}" does	not compare to "{"NS":["6", "2", "1"]}".

	   o   "LT" : Less than.

	       AttributeValueList can contain only one AttributeValue of type
	       String, Number, or Binary (not a	set type). If an item contains
	       an AttributeValue element of a different	type than the one
	       provided	in the request,	the value does not match. For example,
	       "{"S":"6"}" does	not equal "{"N":"6"}". Also, "{"N":"6"}" does
	       not compare to "{"NS":["6", "2",	"1"]}".

	   o   "GE" : Greater than or equal.

	       AttributeValueList can contain only one AttributeValue element
	       of type String, Number, or Binary (not a	set type). If an item
	       contains	an AttributeValue element of a different type than the
	       one provided in the request, the	value does not match. For
	       example,	"{"S":"6"}" does not equal "{"N":"6"}".	Also,
	       "{"N":"6"}" does	not compare to "{"NS":["6", "2", "1"]}".

	   o   "GT" : Greater than.

	       AttributeValueList can contain only one AttributeValue element
	       of type String, Number, or Binary (not a	set type). If an item
	       contains	an AttributeValue element of a different type than the
	       one provided in the request, the	value does not match. For
	       example,	"{"S":"6"}" does not equal "{"N":"6"}".	Also,
	       "{"N":"6"}" does	not compare to "{"NS":["6", "2", "1"]}".

	   o   "BEGINS_WITH" : Checks for a prefix.

	       AttributeValueList can contain only one AttributeValue of type
	       String or Binary	(not a Number or a set type). The target
	       attribute of the	comparison must	be of type String or Binary
	       (not a Number or	a set type).

	   o   "BETWEEN" : Greater than	or equal to the	first value, and less
	       than or equal to	the second value.

	       AttributeValueList must contain two AttributeValue elements of
	       the same	type, either String, Number, or	Binary (not a set
	       type). A	target attribute matches if the	target value is
	       greater than, or	equal to, the first element and	less than, or
	       equal to, the second element.  If an item contains an
	       AttributeValue element of a different type than the one
	       provided	in the request,	the value does not match. For example,
	       "{"S":"6"}" does	not compare to "{"N":"6"}". Also, "{"N":"6"}"
	       does not	compare	to "{"NS":["6",	"2", "1"]}"

       For usage examples of AttributeValueList	and ComparisonOperator,	see
       Legacy Conditional Parameters in	the Amazon DynamoDB Developer Guide.

   Limit => Int
       The maximum number of items to evaluate (not necessarily	the number of
       matching	items).	If DynamoDB processes the number of items up to	the
       limit while processing the results, it stops the	operation and returns
       the matching values up to that point, and a key in LastEvaluatedKey to
       apply in	a subsequent operation,	so that	you can	pick up	where you left
       off. Also, if the processed data	set size exceeds 1 MB before DynamoDB
       reaches this limit, it stops the	operation and returns the matching
       values up to the	limit, and a key in LastEvaluatedKey to	apply in a
       subsequent operation to continue	the operation. For more	information,
       see Query and Scan in the Amazon	DynamoDB Developer Guide.

   ProjectionExpression	=> Str
       A string	that identifies	one or more attributes to retrieve from	the
       table. These attributes can include scalars, sets, or elements of a
       JSON document. The attributes in	the expression must be separated by
       commas.

       If no attribute names are specified, then all attributes	will be
       returned. If any	of the requested attributes are	not found, they	will
       not appear in the result.

       For more	information, see Accessing Item	Attributes in the Amazon
       DynamoDB	Developer Guide.

       ProjectionExpression replaces the legacy	AttributesToGet	parameter.

   QueryFilter => Paws::DynamoDB::FilterConditionMap
       This is a legacy	parameter, for backward	compatibility. New
       applications should use FilterExpression	instead. Do not	combine	legacy
       parameters and expression parameters in a single	API call; otherwise,
       DynamoDB	will return a ValidationException exception.

       A condition that	evaluates the query results after the items are	read
       and returns only	the desired values.

       This parameter does not support attributes of type List or Map.

       A QueryFilter is	applied	after the items	have already been read;	the
       process of filtering does not consume any additional read capacity
       units.

       If you provide more than	one condition in the QueryFilter map, then by
       default all of the conditions must evaluate to true. In other words,
       the conditions are ANDed	together. (You can use the ConditionalOperator
       parameter to OR the conditions instead. If you do this, then at least
       one of the conditions must evaluate to true, rather than	all of them.)

       Note that QueryFilter does not allow key	attributes. You	cannot define
       a filter	condition on a hash key	or range key.

       Each QueryFilter	element	consists of an attribute name to compare,
       along with the following:

       o   AttributeValueList -	One or more values to evaluate against the
	   supplied attribute. The number of values in the list	depends	on the
	   operator specified in ComparisonOperator.

	   For type Number, value comparisons are numeric.

	   String value	comparisons for	greater	than, equals, or less than are
	   based on ASCII character code values. For example, "a" is greater
	   than	"A", and "a" is	greater	than "B". For a	list of	code values,
	   see http://en.wikipedia.org/wiki/ASCII

	   For type Binary, DynamoDB treats each byte of the binary data as
	   unsigned when it compares binary values.

	   For information on specifying data types in JSON, see JSON Data
	   Format in the Amazon	DynamoDB Developer Guide.

       o   ComparisonOperator -	A comparator for evaluating attributes.	For
	   example, equals, greater than, less than, etc.

	   The following comparison operators are available:

	   "EQ | NE | LE | LT |	GE | GT	| NOT_NULL | NULL | CONTAINS |
	   NOT_CONTAINS	| BEGINS_WITH |	IN | BETWEEN"

	   For complete	descriptions of	all comparison operators, see the
	   Condition data type.

   ReturnConsumedCapacity => Str
   ScanIndexForward => Bool
       Specifies the order in which to return the query	results	- either
       ascending ("true") or descending	("false").

       Items with the same hash	key are	stored in sorted order by range	key
       .If the range key data type is Number, the results are stored in
       numeric order. For type String, the results are returned	in order of
       ASCII character code values. For	type Binary, DynamoDB treats each byte
       of the binary data as unsigned.

       If ScanIndexForward is "true", DynamoDB returns the results in order,
       by range	key. This is the default behavior.

       If ScanIndexForward is "false", DynamoDB	sorts the results in
       descending order	by range key, and then returns the results to the
       client.

   Select => Str
       The attributes to be returned in	the result. You	can retrieve all item
       attributes, specific item attributes, the count of matching items, or
       in the case of an index,	some or	all of the attributes projected	into
       the index.

       o   "ALL_ATTRIBUTES" - Returns all of the item attributes from the
	   specified table or index. If	you query a local secondary index,
	   then	for each matching item in the index DynamoDB will fetch	the
	   entire item from the	parent table. If the index is configured to
	   project all item attributes,	then all of the	data can be obtained
	   from	the local secondary index, and no fetching is required.

       o   "ALL_PROJECTED_ATTRIBUTES" -	Allowed	only when querying an index.
	   Retrieves all attributes that have been projected into the index.
	   If the index	is configured to project all attributes, this return
	   value is equivalent to specifying "ALL_ATTRIBUTES".

       o   "COUNT" - Returns the number	of matching items, rather than the
	   matching items themselves.

       o   "SPECIFIC_ATTRIBUTES" - Returns only	the attributes listed in
	   AttributesToGet. This return	value is equivalent to specifying
	   AttributesToGet without specifying any value	for Select.

	   If you query	a local	secondary index	and request only attributes
	   that	are projected into that	index, the operation will read only
	   the index and not the table.	If any of the requested	attributes are
	   not projected into the local	secondary index, DynamoDB will fetch
	   each	of these attributes from the parent table. This	extra fetching
	   incurs additional throughput	cost and latency.

	   If you query	a global secondary index, you can only request
	   attributes that are projected into the index. Global	secondary
	   index queries cannot	fetch attributes from the parent table.

       If neither Select nor AttributesToGet are specified, DynamoDB defaults
       to "ALL_ATTRIBUTES" when	accessing a table, and
       "ALL_PROJECTED_ATTRIBUTES" when accessing an index. You cannot use both
       Select and AttributesToGet together in a	single request,	unless the
       value for Select	is "SPECIFIC_ATTRIBUTES". (This	usage is equivalent to
       specifying AttributesToGet without any value for	Select.)

       If you use the ProjectionExpression parameter, then the value for
       Select can only be "SPECIFIC_ATTRIBUTES". Any other value for Select
       will return an error.

   REQUIRED TableName => Str
       The name	of the table containing	the requested items.

SEE ALSO
       This class forms	part of	Paws, documenting arguments for	method Query
       in Paws::DynamoDB

BUGS and CONTRIBUTIONS
       The source code is located here:	https://github.com/pplu/aws-sdk-perl

       Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues

POD ERRORS
       Hey! The	above document had some	coding errors, which are explained
       below:

       Around line 204:
	   Unterminated	B<...> sequence

       Around line 223:
	   Unterminated	C<...> sequence

       Around line 234:
	   Unterminated	C<...> sequence

       Around line 418:
	   Unterminated	C<...> sequence

       Around line 424:
	   Unterminated	C<...> sequence

perl v5.24.1			  2015-08-06	      Paws::DynamoDB::Query(3)

NAME | DESCRIPTION | ATTRIBUTES | SEE ALSO | BUGS and CONTRIBUTIONS | POD ERRORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Paws::DynamoDB::Query&sektion=3&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help