Java TableDescription类代码示例

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@RequestMapping("/describe/{table}")
public
@ResponseBody
TableDescription definition(@PathVariable String table) {
    TableDescription description = null;

    try {
        if (!names.isEmpty()) {
            description = amazonDynamoDBClient.describeTable(table).getTable();
        }
    } catch (AmazonClientException ex) {
        LOGGER.error(ex.getMessage());
    }

    return description;
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCreateTableWithWait() throws Exception {
    // Create fake responses from AWS. First response is still creating the table, second response the table
    // has become active.
    TableDescription creatingDescription = constructTableDescription(TableStatus.CREATING);
    TableDescription createdDescription = constructTableDescription(TableStatus.ACTIVE);
    CreateTableResult mockCreateResult = new CreateTableResult().withTableDescription(creatingDescription);
    DescribeTableResult mockDescribeResultCreating = new DescribeTableResult().withTable(creatingDescription);
    DescribeTableResult mockDescribeResultCreated = new DescribeTableResult().withTable(createdDescription);

    // Create the table.
    CreateTableRequest expectedRequest = dynamoDB.constructCreateTableRequest();
    when(mockDynamoDBClient.createTable(expectedRequest)).thenReturn(mockCreateResult);
    when(mockDynamoDBClient.describeTable(tableName)).thenReturn(mockDescribeResultCreating, mockDescribeResultCreated);
    assertEquals(dynamoDB.create(), TEST_ARN);

    verify(mockDynamoDBClient, times(1)).createTable(expectedRequest);
    verify(mockDynamoDBClient, times(2)).describeTable(tableName);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
private static Task<TableDescription> waitForActiveTableStatus(final DynamoDBConnection dynamoDBConnection, final String tableName)
{
    try
    {
        for (int i = 0; i < WAITING_FOR_ACTIVE_TABLE_STATUS_MAX_ATTEMPTS; i++)
        {
            final DescribeTableResult describe = dynamoDBConnection.getDynamoClient().describeTable(tableName);
            if (describe.getTable().getTableStatus().equals(TableStatus.ACTIVE.name()))
            {
                return Task.fromValue(describe.getTable());
            }

            Thread.sleep(WAITING_FOR_ACTIVE_TABLE_STATUS_RETRY_DELAY_MILLIS);
        }

    }
    catch (InterruptedException e)
    {
        throw new UncheckedException(e);
    }

    throw new UncheckedException("Hit max retry attempts while waiting for table to become active: " + tableName);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
private void setTableProperties(JobConf jobConf, String tableName, Double writeRatio) {
  jobConf.set(DynamoDBConstants.OUTPUT_TABLE_NAME, tableName);
  jobConf.set(DynamoDBConstants.INPUT_TABLE_NAME, tableName);
  jobConf.set(DynamoDBConstants.TABLE_NAME, tableName);

  DynamoDBClient client = new DynamoDBClient(jobConf);
  TableDescription description = client.describeTable(tableName);

  Long readThroughput = description.getProvisionedThroughput().getReadCapacityUnits();
  Long writeThroughput = description.getProvisionedThroughput().getWriteCapacityUnits();

  jobConf.set(DynamoDBConstants.READ_THROUGHPUT, readThroughput.toString());
  jobConf.set(DynamoDBConstants.WRITE_THROUGHPUT, writeThroughput.toString());

  log.info("Read throughput:       " + readThroughput);
  log.info("Write throughput:      " + writeThroughput);

  // Optional properties
  if (writeRatio != null) {
    jobConf.set(DynamoDBConstants.THROUGHPUT_WRITE_PERCENT, writeRatio.toString());
    log.info("Throughput write ratio: " + writeRatio);
  }
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Override
public void preCreateTable(Table table) throws MetaException {
  DynamoDBClient client = createDynamoDBClient(table);
  try {

    boolean isExternal = MetaStoreUtils.isExternalTable(table);

    if (!isExternal) {
      throw new MetaException("Only EXTERNAL tables are supported for DynamoDB.");
    }

    String tableName = HiveDynamoDBUtil.getDynamoDBTableName(table.getParameters()
        .get(DynamoDBConstants.TABLE_NAME), table.getTableName());
    TableDescription tableDescription = client.describeTable(tableName);

    checkTableStatus(tableDescription);
    checkTableSchemaMapping(tableDescription, table);
    checkTableSchemaType(tableDescription, table);
  } finally {
    client.close();
  }
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
void checkTableSchemaMapping(TableDescription tableDescription, Table table) throws
    MetaException {
  String mapping = table.getParameters().get(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING);
  Map<String, String> columnMapping = HiveDynamoDBUtil.getHiveToDynamoDBSchemaMapping(mapping);

  List<FieldSchema> tableSchema = table.getSd().getCols();
  for (FieldSchema fieldSchema : tableSchema) {
    if (HiveDynamoDBTypeFactory.isHiveDynamoDBItemMapType(fieldSchema.getType())) {
      // We don't need column mapping as this column contains full
      // DynamoDB row
      continue;
    }

    String fieldSchemaName = fieldSchema.getName().toLowerCase();
    if (columnMapping.containsKey(fieldSchemaName)) {
      if (columnMapping.get(fieldSchemaName).isEmpty()) {
        throw new MetaException("Invalid column mapping for column: " + fieldSchemaName);
      }
    } else {
      throw new MetaException("Could not find column mapping for column: " + fieldSchemaName);
    }
  }
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
void checkTableSchemaType(TableDescription tableDescription, Table table) throws MetaException {
  List<FieldSchema> tableSchema = table.getSd().getCols();

  for (FieldSchema fieldSchema : tableSchema) {
    for (AttributeDefinition definition : tableDescription.getAttributeDefinitions()) {
      validateKeySchema(definition.getAttributeName(), definition.getAttributeType(),
          fieldSchema);
    }

    // Check for each field type
    if (HiveDynamoDBTypeFactory.getTypeObjectFromHiveType(fieldSchema.getType()) == null) {
      throw new MetaException("The hive type " + fieldSchema.getType() + " is not supported in "
          + "DynamoDB");
    }
  }
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCheckTableSchemaMappingMissingColumn() throws MetaException {
  TableDescription description = getHashRangeTable();

  Table table = new Table();
  Map<String, String> parameters = Maps.newHashMap();
  parameters.put(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING, "col1:dynamo_col1$,hashKey:hashKey");
  table.setParameters(parameters);
  StorageDescriptor sd = new StorageDescriptor();
  List<FieldSchema> cols = Lists.newArrayList();
  cols.add(new FieldSchema("col1", "string", ""));
  cols.add(new FieldSchema("col2", "tinyint", ""));
  cols.add(new FieldSchema("col3", "map<string,string>", ""));
  cols.add(new FieldSchema("hashMap", "string", ""));
  sd.setCols(cols);
  table.setSd(sd);

  exceptionRule.expect(MetaException.class);
  exceptionRule.expectMessage("Could not find column mapping for column: col2");
  storageHandler.checkTableSchemaMapping(description, table);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCheckTableSchemaMappingValid() throws MetaException {
  TableDescription description = getHashRangeTable();

  Table table = new Table();
  Map<String, String> parameters = Maps.newHashMap();
  parameters.put(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING, "col1:dynamo_col1$," +
      "col2:dynamo_col2#,hashKey:hashKey");
  table.setParameters(parameters);
  StorageDescriptor sd = new StorageDescriptor();
  List<FieldSchema> cols = Lists.newArrayList();
  cols.add(new FieldSchema("col1", "string", ""));
  cols.add(new FieldSchema("col2", "bigint", ""));
  cols.add(new FieldSchema("hashKey", "string", ""));
  sd.setCols(cols);
  table.setSd(sd);
  storageHandler.checkTableSchemaMapping(description, table);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCheckTableSchemaTypeInvalidType() throws MetaException {
  TableDescription description = getHashRangeTable();

  Table table = new Table();
  Map<String, String> parameters = Maps.newHashMap();
  parameters.put(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING, "col1:dynamo_col1$," +
      "col2:dynamo_col2#,hashKey:hashKey");
  table.setParameters(parameters);
  StorageDescriptor sd = new StorageDescriptor();
  List<FieldSchema> cols = Lists.newArrayList();
  cols.add(new FieldSchema("col1", "string", ""));
  cols.add(new FieldSchema("col2", "tinyint", ""));
  cols.add(new FieldSchema("hashKey", "string", ""));
  sd.setCols(cols);
  table.setSd(sd);

  exceptionRule.expect(MetaException.class);
  exceptionRule.expectMessage("The hive type tinyint is not supported in DynamoDB");
  storageHandler.checkTableSchemaType(description, table);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCheckTableSchemaTypeInvalidHashKeyType() throws MetaException {
  TableDescription description = getHashRangeTable();

  Table table = new Table();
  Map<String, String> parameters = Maps.newHashMap();
  parameters.put(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING, "col1:dynamo_col1$," +
      "col2:dynamo_col2#,hashKey:hashKey");
  table.setParameters(parameters);
  StorageDescriptor sd = new StorageDescriptor();
  List<FieldSchema> cols = Lists.newArrayList();
  cols.add(new FieldSchema("col1", "string", ""));
  cols.add(new FieldSchema("col2", "bigint", ""));
  cols.add(new FieldSchema("hashKey", "map<string,string>", ""));
  sd.setCols(cols);
  table.setSd(sd);

  exceptionRule.expect(MetaException.class);
  exceptionRule.expectMessage("The key element hashKey does not match type. DynamoDB Type: S " +
      "Hive type: " + "map<string,string>");
  storageHandler.checkTableSchemaType(description, table);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Test
public void testCheckTableSchemaTypeValid() throws MetaException {
  TableDescription description = getHashRangeTable();

  Table table = new Table();
  Map<String, String> parameters = Maps.newHashMap();
  parameters.put(DynamoDBConstants.DYNAMODB_COLUMN_MAPPING, "col1:dynamo_col1$," +
      "col2:dynamo_col2#,hashKey:hashKey");
  table.setParameters(parameters);
  StorageDescriptor sd = new StorageDescriptor();
  List<FieldSchema> cols = Lists.newArrayList();
  cols.add(new FieldSchema("col1", "string", ""));
  cols.add(new FieldSchema("col2", "bigint", ""));
  cols.add(new FieldSchema("hashKey", "string", ""));
  sd.setCols(cols);
  table.setSd(sd);
  // This check is expected to pass for the given input
  storageHandler.checkTableSchemaType(description, table);
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
public TableDescription describeTable(String tableName) {
  final DescribeTableRequest describeTablesRequest = new DescribeTableRequest()
      .withTableName(tableName);
  try {
    RetryResult<DescribeTableResult> describeResult = getRetryDriver().runWithRetry(
        new Callable<DescribeTableResult>() {
          @Override
          public DescribeTableResult call() {
            DescribeTableResult result = dynamoDB.describeTable(describeTablesRequest);
            log.info("Describe table output: " + result);
            return result;
          }
        }, null, null);
    return describeResult.result.getTable();
  } catch (Exception e) {
    throw new RuntimeException("Could not lookup table " + tableName + " in DynamoDB.", e);
  }
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
@Before
public void setup() {
  when(dynamoDBClient.describeTable(TABLE_NAME)).thenReturn(new TableDescription()
      .withProvisionedThroughput(new ProvisionedThroughputDescription().withWriteCapacityUnits
          (WRITE_CAPACITY_UNITS)));

  JobConf jobConf = new JobConf();
  jobConf.setNumMapTasks(TOTAL_MAP_TASKS);
  jobConf.set("mapreduce.task.attempt.id", "attempt_m_1");
  jobConf.set(DynamoDBConstants.THROUGHPUT_WRITE_PERCENT, String.valueOf
      (THROUGHPUT_WRITE_PERCENT));
  when(jobClient.getConf()).thenReturn(jobConf);

  writeIopsCalculator = new WriteIopsCalculator(jobClient, dynamoDBClient, TABLE_NAME) {
    @Override
    int calculateMaxMapTasks(int totalMapTasks) {
      return MAX_CONCURRENT_MAP_TASKS;
    }
  };
}
 

import com.amazonaws.services.dynamodbv2.model.TableDescription; //导入依赖的package包/类
private TableDescription getTableDescription(String hashType, String rangeType) {
  List<KeySchemaElement> keySchema = new ArrayList<>();
  List<AttributeDefinition> definitions = new ArrayList<>();

  keySchema.add(new KeySchemaElement().withAttributeName("hashKey").withKeyType(KeyType.HASH));
  definitions.add(new AttributeDefinition().withAttributeName("hashKey").withAttributeType
      (hashType));

  if (rangeType != null) {
    keySchema.add(new KeySchemaElement().withAttributeName("rangeKey").withKeyType(KeyType
        .RANGE));
    definitions.add(new AttributeDefinition().withAttributeName("rangeKey").withAttributeType
        (rangeType));
  }

  TableDescription description = new TableDescription().withKeySchema(keySchema)
      .withAttributeDefinitions(definitions).withProvisionedThroughput(new
          ProvisionedThroughputDescription().withReadCapacityUnits(1000L)
          .withWriteCapacityUnits(1000L));
  return description;
}