需要具有不同属性的各种查询类型的应用程序可以在执行这些详细查询时使用单个或多个全局二级索引.
例如 : 一个跟踪用户，登录状态和登录时间的系统.上一个示例的增长减慢了对其数据的查询.
全局二级索引通过组织选择来加速查询表中的属性.它们在排序数据时使用主键，并且不需要键表属性或与表相同的键模式.
所有全局二级索引必须包含一个分区键，可以选择a排序键.索引键架构可以与表不同，索引键属性可以使用任何顶级字符串，数字或二进制表属性.
在投影中，您可以使用其他表属性但是，查询不会从父表中检索.
预测包含从表复制到辅助索引的属性集.使用表分区键和排序键始终会发生投影.在查询中，投影允许DynamoDB访问投影的任何属性;它们基本上作为自己的表存在.
在创建二级索引时，必须指定投影的属性. DynamoDB提供了三种执行此任务的方法 :
KEYS_ONLY : 所有索引项都包含表分区和排序键值以及索引键值.这会创建最小的索引.
INCLUDE : 它包括KEYS_ONLY属性和指定的非键属性.
ALL : 它包括所有源表属性，创建最大可能的索引.
注意将属性投影到全局二级索引中的权衡，吞吐量和存储成本.
考虑以下几点;
如果您只需要访问一些低延迟的属性，只投影您需要的属性.这样可以降低存储和写入成本.
如果应用程序经常访问某些非关键属性，请对其进行投影，因为与扫描消耗相比，存储成本较低./p>
您可以投影经常访问的大量属性，但这会带来很高的存储成本.
将KEYS_ONLY用于不频繁的表查询和频繁的写入/更新.这可以控制大小，但仍然可以提供良好的查询性能.
您可以利用查询来访问索引中的单个或多个项目.您必须指定索引和表名，所需属性和条件;可以选择以升序或降序返回结果.
您还可以利用扫描来获取所有索引数据.它需要表和索引名称.您可以使用过滤器表达式来检索特定数据.
DynamoDB会自动对索引及其父表执行同步.对项目的每个修改操作都会导致异步更新，但是，应用程序不会直接写入索引.
您需要了解DynamoDB维护对索引的影响.在创建索引时，您可以指定键属性和数据类型，这意味着在写入时，这些数据类型必须与键架构数据类型匹配.
在项目创建或删除时，索引更新为然而，最终一致的方式是，数据的更新在几分之一秒内传播(除非发生某种类型的系统故障).您必须在申请中考虑此延迟.
全球二级索引中的吞吐量注意事项 : 多个全局二级索引会影响吞吐量索引创建需要与表分开存在的容量单位规范，导致操作消耗索引容量单位而不是表单位.
如果查询或写入超出预配置吞吐量，这可能导致限制.使用 DescribeTable 查看吞吐量设置.
读取容量 : 全局二级索引提供最终一致性.在查询中，DynamoDB执行与用于表的计算相同的提供计算，使用索引条目大小而不是项大小的区别.查询返回的限制仍为1MB，其中包括每个返回项的属性名称大小和值.
执行写入操作时，受影响的索引会占用写入单位.写吞吐量成本是表写入中消耗的写入容量单位和索引更新中消耗的单位之和.成功的写入操作需要足够的容量，否则会导致限制.
写入成本仍取决于某些因素，其中一些因素如下:
定义索引属性的新项目或定义未定义索引属性的项目更新使用单个写入操作将项目添加到索引.
更新索引键属性值更新使用两次写入删除项目并写入新项目.
表格写入触发删除索引属性使用单个写入来擦除索引中的旧项目投影.
在更新之前和之后索引中缺少的项目操作使用无写入.
更新仅更改索引键架构中的预计属性值，而不更改索引键属性值，使用一次写入更新预计值属性到索引中.
所有这些因素都可以项目大小小于或等于1KB.
在项目写入时，DynamoDB会自动复制正确的一组属性必须存在的任何索引的属性.这会通过为表项存储和属性存储收费来影响您的帐户.使用的空间来自这些数量的总和 :
表主键的字节大小
索引键属性的字节大小
预计属性的字节大小
每个索引项100字节开销
您可以通过估算平均项目大小并乘以具有全局二级索引键属性的表项数量来估算存储需求.
DynamoDB不会为未定义属性定义为索引分区或排序键的表项写入项数据.
创建一个使用 CreateTable 操作与 GlobalSecondaryIndexes 参数配对的具有全局二级索引的表.您必须指定一个属性作为索引分区键，或者使用另一个属性作为索引排序键.所有索引键属性必须是字符串，数字或二进制标量.您还必须提供吞吐量设置，包括 ReadCapacityUnits 和 WriteCapacityUnits .
使用 UpdateTable 添加全局再次使用GlobalSecondaryIndexes参数对现有表的二级索引.
在此操作中，您必须提供以下输入;
索引名称
密钥架构
预计属性
吞吐量设置
通过添加全局二级索引，由于项目量，预计属性量，写入容量和写入活动，大型表可能需要相当长的时间.使用 CloudWatch 指标来监控流程.
使用 DescribeTable 获取全局二级索引的状态信息.它返回四个 IndexStatus 中的一个用于GlobalSecondaryIndexes :
创建 : 它表示索引的构建阶段及其不可用性.
ACTIVE : 它表示准备使用的准备情况.
更新 : 它表示吞吐量设置的更新状态.
DELETING : 它表示索引的删除状态及其永久不可用.
在加载期间更新全局二级索引配置吞吐量设置/回填阶段(DynamoDB将属性写入索引并跟踪添加/删除/更新的项目).使用 UpdateTable 执行此操作.
您应该记住，在回填阶段您无法添加/删除其他索引.
使用UpdateTable删除全局二级索引.它允许每个操作只删除一个索引，但是，您可以同时运行多个操作，最多五个.删除过程不会影响父表的读/写活动，但在操作完成之前不能添加/删除其他索引.
通过CreateTable创建一个带索引的表.只需为请求信息创建一个DynamoDB类实例，一个 CreateTableRequest 类实例，并将请求对象传递给CreateTable方法.
以下程序是一个简短的例子 :
DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient (
new ProfileCredentialsProvider()));
// Attributes
ArrayList<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("City")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Date")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Wind")
.withAttributeType("N"));
// Key schema of the table
ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add(new KeySchemaElement()
.withAttributeName("City")
.withKeyType(KeyType.HASH)); //Partition key
tableKeySchema.add(new KeySchemaElement()
.withAttributeName("Date")
.withKeyType(KeyType.RANGE)); //Sort key
// Wind index
GlobalSecondaryIndex windIndex = new GlobalSecondaryIndex()
.withIndexName("WindIndex")
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits((long) 10)
.withWriteCapacityUnits((long) 1))
.withProjection(new Projection().withProjectionType(ProjectionType.ALL));
ArrayList<KeySchemaElement> indexKeySchema = new ArrayList<KeySchemaElement>();
indexKeySchema.add(new KeySchemaElement()
.withAttributeName("Date")
.withKeyType(KeyType.HASH)); //Partition key
indexKeySchema.add(new KeySchemaElement()
.withAttributeName("Wind")
.withKeyType(KeyType.RANGE)); //Sort key
windIndex.setKeySchema(indexKeySchema);
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName("ClimateInfo")
.withProvisionedThroughput(new ProvisionedThroughput()
.withReadCapacityUnits((long) 5)
.withWriteCapacityUnits((long) 1))
.withAttributeDefinitions(attributeDefinitions)
.withKeySchema(tableKeySchema)
.withGlobalSecondaryIndexes(windIndex);
Table table = dynamoDB.createTable(createTableRequest);
System.out.println(table.getDescription());使用 DescribeTable 检索索引信息.首先，创建一个DynamoDB类实例.然后创建一个Table类实例来定位索引.最后，将表传递给describe方法.
这是一个简短的例子 :
DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient (
new ProfileCredentialsProvider()));
Table table = dynamoDB.getTable("ClimateInfo");
TableDescription tableDesc = table.describe();
Iterator<GlobalSecondaryIndexDescription> gsiIter =
tableDesc.getGlobalSecondaryIndexes().iterator();
while (gsiIter.hasNext()) {
GlobalSecondaryIndexDescription gsiDesc = gsiIter.next();
System.out.println("Index data " + gsiDesc.getIndexName() + ":");
Iterator<KeySchemaElement> kse7Iter = gsiDesc.getKeySchema().iterator();
while (kseIter.hasNext()) {
KeySchemaElement kse = kseIter.next();
System.out.printf("\t%s: %s\n", kse.getAttributeName(), kse.getKeyType());
}
Projection projection = gsiDesc.getProjection();
System.out.println("\tProjection type: " + projection.getProjectionType());
if (projection.getProjectionType().toString().equals("INCLUDE")) {
System.out.println("\t\tNon-key projected attributes: "
+ projection.getNonKeyAttributes());
}
}使用Query执行索引查询和表查询一样.只需创建一个DynamoDB类实例，一个目标索引的Table类实例，一个特定索引的Index类实例，并将索引和查询对象传递给查询方法.
查看以下代码以了解更好 :
DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient (
new ProfileCredentialsProvider()));
Table table = dynamoDB.getTable("ClimateInfo");
Index index = table.getIndex("WindIndex");
QuerySpec spec = new QuerySpec()
.withKeyConditionExpression("#d = :v_date and Wind = :v_wind")
.withNameMap(new NameMap()
.with("#d", "Date"))
.withValueMap(new ValueMap()
.withString(":v_date","2016-05-15")
.withNumber(":v_wind",0));
ItemCollection<QueryOutcome> items = index.query(spec);
Iterator<Item> iter = items.iterator();
while (iter.hasNext()) {
System.out.println(iter.next().toJSONPretty());
}以下程序是更好理解和减去的更大范例;
注意 : 以下程序可以假定先前创建的数据源.在尝试执行之前，获取支持库并创建必要的数据源(具有所需特征的表或其他引用的源).
此示例还使用Eclipse IDE，AWS凭证文件和Eclipse AWS Java项目中的AWS Toolkit.
import java.util.ArrayList;
import java.util.Iterator;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.GlobalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
public class GlobalSecondaryIndexSample {
static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient (
new ProfileCredentialsProvider()));
public static String tableName = "Bugs";
public static void main(String[] args) throws Exception {
createTable();
queryIndex("CreationDateIndex");
queryIndex("NameIndex");
queryIndex("DueDateIndex");
}
public static void createTable() {
// Attributes
ArrayList<AttributeDefinition> attributeDefinitions = new
ArrayList<AttributeDefinition>();
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("BugID")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("Name")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("CreationDate")
.withAttributeType("S"));
attributeDefinitions.add(new AttributeDefinition()
.withAttributeName("DueDate")
.withAttributeType("S"));
// Table Key schema
ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>();
tableKeySchema.add (new KeySchemaElement()
.withAttributeName("BugID")
.withKeyType(KeyType.HASH)); //Partition key
tableKeySchema.add (new KeySchemaElement()
.withAttributeName("Name")
.withKeyType(KeyType.RANGE)); //Sort key
// Indexes' initial provisioned throughput
ProvisionedThroughput ptIndex = new ProvisionedThroughput()
.withReadCapacityUnits(1L)
.withWriteCapacityUnits(1L);
// CreationDateIndex
GlobalSecondaryIndex creationDateIndex = new GlobalSecondaryIndex()
.withIndexName("CreationDateIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new KeySchemaElement()
.withAttributeName("CreationDate")
.withKeyType(KeyType.HASH), //Partition key
new KeySchemaElement()
.withAttributeName("BugID")
.withKeyType(KeyType.RANGE)) //Sort key
.withProjection(new Projection()
.withProjectionType("INCLUDE")
.withNonKeyAttributes("Description", "Status"));
// NameIndex
GlobalSecondaryIndex nameIndex = new GlobalSecondaryIndex()
.withIndexName("NameIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new KeySchemaElement()
.withAttributeName("Name")
.withKeyType(KeyType.HASH), //Partition key
new KeySchemaElement()
.withAttributeName("BugID")
.withKeyType(KeyType.RANGE)) //Sort key
.withProjection(new Projection()
.withProjectionType("KEYS_ONLY"));
// DueDateIndex
GlobalSecondaryIndex dueDateIndex = new GlobalSecondaryIndex()
.withIndexName("DueDateIndex")
.withProvisionedThroughput(ptIndex)
.withKeySchema(new KeySchemaElement()
.withAttributeName("DueDate")
.withKeyType(KeyType.HASH)) //Partition key
.withProjection(new Projection()
.withProjectionType("ALL"));
CreateTableRequest createTableRequest = new CreateTableRequest()
.withTableName(tableName)
.withProvisionedThroughput( new ProvisionedThroughput()
.withReadCapacityUnits( (long) 1)
.withWriteCapacityUnits( (long) 1))
.withAttributeDefinitions(attributeDefinitions)
.withKeySchema(tableKeySchema)
.withGlobalSecondaryIndexes(creationDateIndex, nameIndex, dueDateIndex);
System.out.println("Creating " + tableName + "...");
dynamoDB.createTable(createTableRequest);
// Pause for active table state
System.out.println("Waiting for ACTIVE state of " + tableName);
try {
Table table = dynamoDB.getTable(tableName);
table.waitForActive();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void queryIndex(String indexName) {
Table table = dynamoDB.getTable(tableName);
System.out.println
("\n*****************************************************\n");
System.out.print("Querying index " + indexName + "...");
Index index = table.getIndex(indexName);
ItemCollection<QueryOutcome> items = null;
QuerySpec querySpec = new QuerySpec();
if (indexName == "CreationDateIndex") {
System.out.println("Issues filed on 2016-05-22");
querySpec.withKeyConditionExpression("CreationDate = :v_date and begins_with
(BugID, :v_bug)")
.withValueMap(new ValueMap()
.withString(":v_date","2016-05-22")
.withString(":v_bug","A-"));
items = index.query(querySpec);
} else if (indexName == "NameIndex") {
System.out.println("Compile error");
querySpec.withKeyConditionExpression("Name = :v_name and begins_with
(BugID, :v_bug)")
.withValueMap(new ValueMap()
.withString(":v_name","Compile error")
.withString(":v_bug","A-"));
items = index.query(querySpec);
} else if (indexName == "DueDateIndex") {
System.out.println("Items due on 2016-10-15");
querySpec.withKeyConditionExpression("DueDate = :v_date")
.withValueMap(new ValueMap()
.withString(":v_date","2016-10-15"));
items = index.query(querySpec);
} else {
System.out.println("\nInvalid index name");
return;
}
Iterator<Item> iterator = items.iterator();
System.out.println("Query: getting result...");
while (iterator.hasNext()) {
System.out.println(iterator.next().toJSONPretty());
}
}
}
