public List <T> GetItems <T>(IEnumerable <DynamoId> ids)
{
var to = new List <T>();
var table = DynamoMetadata.GetTable <T>();
var remainingIds = ids.ToList();
while (remainingIds.Count > 0)
{
var batchSize = Math.Min(remainingIds.Count, MaxReadBatchSize);
var nextBatch = remainingIds.GetRange(0, batchSize);
remainingIds.RemoveRange(0, batchSize);
var getItems = new KeysAndAttributes
{
ConsistentRead = ConsistentRead,
};
nextBatch.Each(id =>
getItems.Keys.Add(Converters.ToAttributeKeyValue(this, table, id)));
to.AddRange(ConvertBatchGetItemResponse <T>(table, getItems));
}
return(to);
}
public void PutItems <T>(IEnumerable <T> items)
{
var table = DynamoMetadata.GetTable <T>();
var remaining = items.ToList();
PopulateMissingHashes(table, remaining);
while (remaining.Count > 0)
{
var batchSize = Math.Min(remaining.Count, MaxWriteBatchSize);
var nextBatch = remaining.GetRange(0, batchSize);
remaining.RemoveRange(0, batchSize);
var putItems = nextBatch.Map(x => new WriteRequest(
new PutRequest(Converters.ToAttributeValues(this, x, table))));
var request = new BatchWriteItemRequest(new Dictionary <string, List <WriteRequest> > {
{ table.Name, putItems }
});
var response = Exec(() => DynamoDb.BatchWriteItem(request));
var i = 0;
while (response.UnprocessedItems.Count > 0)
{
response = Exec(() => DynamoDb.BatchWriteItem(new BatchWriteItemRequest(response.UnprocessedItems)));
if (response.UnprocessedItems.Count > 0)
{
i.SleepBackOffMultiplier();
}
}
}
}
public long DescribeItemCount <T>()
{
var table = DynamoMetadata.GetTable <T>();
var response = Exec(() => DynamoDb.DescribeTable(new DescribeTableRequest(table.Name)));
return(response.Table.ItemCount);
}
public long Increment <T>(object hash, string fieldName, long amount = 1)
{
var type = DynamoMetadata.GetType <T>();
var request = new UpdateItemRequest
{
TableName = type.Name,
Key = Converters.ToAttributeKeyValue(this, type.HashKey, hash),
AttributeUpdates = new Dictionary <string, AttributeValueUpdate> {
{
fieldName,
new AttributeValueUpdate {
Action = AttributeAction.ADD,
Value = new AttributeValue {
N = amount.ToString()
}
}
}
},
ReturnValues = ReturnValue.ALL_NEW,
};
var response = DynamoDb.UpdateItem(request);
return(response.Attributes.Count > 0
? Convert.ToInt64(response.Attributes[fieldName].N)
: 0);
}
public long ScanItemCount <T>()
{
var table = DynamoMetadata.GetTable <T>();
var request = new ScanRequest(table.Name);
var response = Scan(request, r => new[] { r.Count });
return(response.Sum());
}
public void UpdateItem <T>(DynamoUpdateItem update)
{
var table = DynamoMetadata.GetTable <T>();
var request = new UpdateItemRequest
{
TableName = table.Name,
Key = Converters.ToAttributeKeyValue(this, table, update.Hash, update.Range),
AttributeUpdates = new Dictionary <string, AttributeValueUpdate>(),
ReturnValues = ReturnValue.NONE,
};
if (update.Put != null)
{
foreach (var entry in update.Put)
{
var field = table.GetField(entry.Key);
if (field == null)
{
continue;
}
request.AttributeUpdates[field.Name] = new AttributeValueUpdate(
Converters.ToAttributeValue(this, field.Type, field.DbType, entry.Value), DynamoAttributeAction.Put);
}
}
if (update.Add != null)
{
foreach (var entry in update.Add)
{
var field = table.GetField(entry.Key);
if (field == null)
{
continue;
}
request.AttributeUpdates[field.Name] = new AttributeValueUpdate(
Converters.ToAttributeValue(this, field.Type, field.DbType, entry.Value), DynamoAttributeAction.Add);
}
}
if (update.Delete != null)
{
foreach (var key in update.Delete)
{
var field = table.GetField(key);
if (field == null)
{
continue;
}
request.AttributeUpdates[field.Name] = new AttributeValueUpdate(null, DynamoAttributeAction.Delete);
}
}
Exec(() => DynamoDb.UpdateItem(request));
}
public PocoDynamoExpression(Type type)
{
Type = type;
Table = DynamoMetadata.GetType(type);
ParamPrefix = "p";
Params = new Dictionary <string, object>();
ReferencedFields = new List <string>();
Aliases = new Dictionary <string, string>();
}
public IEnumerable <T> ScanAll <T>()
{
var type = DynamoMetadata.GetType <T>();
var request = new ScanRequest
{
Limit = PagingLimit,
TableName = type.Name,
};
return(Scan(request, r => r.ConvertAll <T>()));
}
public void DeleteRelatedItems <T>(object hash, IEnumerable <object> ranges)
{
var table = DynamoMetadata.GetTable <T>();
if (table.HashKey == null || table.RangeKey == null)
{
throw new ArgumentException($"Related table '{typeof(T).Name}' needs both a HashKey and RangeKey");
}
DeleteItems <T>(ranges.Map(range => new DynamoId(hash, range)));
}
public T GetItem <T>(object hash, object range)
{
var table = DynamoMetadata.GetTable <T>();
var request = new GetItemRequest
{
TableName = table.Name,
Key = Converters.ToAttributeKeyValue(this, table, hash, range),
ConsistentRead = ConsistentRead,
};
return(ConvertGetItemResponse <T>(request, table));
}
public void PutRelatedItem <T>(object hash, T item)
{
var table = DynamoMetadata.GetTable <T>();
if (table.HashKey == null || table.RangeKey == null)
{
throw new ArgumentException($"Related table '{typeof(T).Name}' needs both a HashKey and RangeKey");
}
table.HashKey.SetValue(item, hash);
PutItem(item);
}
public void PutRelatedItems <T>(object hash, IEnumerable <T> items)
{
var table = DynamoMetadata.GetTable <T>();
if (table.HashKey == null || table.RangeKey == null)
{
throw new ArgumentException($"Related table '{typeof(T).Name}' needs both a HashKey and RangeKey");
}
var related = items.ToList();
related.Each(x => table.HashKey.SetValue(x, hash));
PutItems(related);
}
public QueryExpression <T> QueryComposite <T>(Expression <Func <T, bool> > keyExpression)
{
var table = DynamoMetadata.GetTable <T>();
var q = new QueryExpression <T>(this)
{
TableName = table.Name,
Limit = PagingLimit,
ConsistentRead = false,
ScanIndexForward = this.ScanIndexForward,
};
q.KeyCondition(keyExpression);
return(q);
}
public static DynamoMetadataType GetIndexTable(this Type indexType)
{
var genericIndex = indexType.GetTypeWithGenericInterfaceOf(typeof(IDynamoIndex <>));
if (genericIndex == null)
{
return(null);
}
var tableType = genericIndex.GetGenericArguments().FirstOrDefault();
return(tableType != null
? DynamoMetadata.GetTable(tableType)
: null);
}
public T DeleteByItem <T>(T item)
{
var table = DynamoMetadata.GetTable <T>();
string hashKey = table.HashKey.Name;
object hashValue = typeof(T).GetProperty(hashKey).GetValue(item, null);
if (table.RangeKey != null)
{
string rangeKey = table.RangeKey.Name;
object rangeValue = typeof(T).GetProperty(rangeKey).GetValue(item, null);
return(DeleteItem <T>(hashValue, rangeValue));
}
else
{
return(DeleteItem <T>(hashValue));
}
}
public void DeleteItems <T>(IEnumerable <DynamoId> ids)
{
var table = DynamoMetadata.GetTable <T>();
var remainingIds = ids.ToList();
while (remainingIds.Count > 0)
{
var batchSize = Math.Min(remainingIds.Count, MaxWriteBatchSize);
var nextBatch = remainingIds.GetRange(0, batchSize);
remainingIds.RemoveRange(0, batchSize);
var deleteItems = nextBatch.Map(id => new WriteRequest(
new DeleteRequest(Converters.ToAttributeKeyValue(this, table, id))));
ExecBatchWriteItemResponse <T>(table, deleteItems);
}
}
public Table GetTableSchema(Type type)
{
var table = DynamoMetadata.GetTable(type);
return(Exec(() =>
{
try
{
Table.TryLoadTable(DynamoDb, table.Name, out var awsTable);
return awsTable;
}
catch (ResourceNotFoundException)
{
return null;
}
}, throwNotFoundExceptions));
}
public IEnumerable <T> GetRelatedItems <T>(object hash)
{
var table = DynamoMetadata.GetTable <T>();
var argType = hash.GetType();
var dbType = Converters.GetFieldType(argType);
var request = new QueryRequest(table.Name)
{
Limit = PagingLimit,
KeyConditionExpression = $"{table.HashKey.Name} = :k1",
ExpressionAttributeValues = new Dictionary <string, AttributeValue> {
{ ":k1", Converters.ToAttributeValue(this, argType, dbType, hash) }
}
};
return(Query(request, r => r.ConvertAll <T>()));
}
public T GetItem <T>(object hash)
{
var table = DynamoMetadata.GetTable <T>();
var rangeKey = table.RangeKey;
if (rangeKey != null)
{
return(GetItemFromQuery <T>(table.Name, table.HashKey.Name, hash));
}
var request = new GetItemRequest
{
TableName = table.Name,
Key = Converters.ToAttributeKeyValue(this, table.HashKey, hash),
ConsistentRead = ConsistentRead
};
return(ConvertGetItemResponse <T>(request, table));
}
public T PutItem <T>(T value, bool returnOld = false)
{
var table = DynamoMetadata.GetTable <T>();
var request = new PutItemRequest
{
TableName = table.Name,
Item = Converters.ToAttributeValues(this, value, table),
ReturnValues = returnOld ? ReturnValue.ALL_OLD : ReturnValue.NONE,
};
var response = Exec(() => DynamoDb.PutItem(request));
if (response.Attributes.IsEmpty())
{
return(default(T));
}
return(Converters.FromAttributeValues <T>(table, response.Attributes));
}
public T DeleteItem <T>(object hash, object range, ReturnItem returnItem = ReturnItem.None)
{
var table = DynamoMetadata.GetTable <T>();
var request = new DeleteItemRequest
{
TableName = table.Name,
Key = Converters.ToAttributeKeyValue(this, table, hash, range),
ReturnValues = returnItem.ToReturnValue(),
};
var response = Exec(() => DynamoDb.DeleteItem(request));
if (response.Attributes.IsEmpty())
{
return(default(T));
}
return(Converters.FromAttributeValues <T>(table, response.Attributes));
}
public Task InitSchemaAsync()
{
return(CreateMissingTablesAsync(DynamoMetadata.GetTables()));
}
public static IPocoDynamo RegisterTable <T>(this IPocoDynamo db)
{
DynamoMetadata.RegisterTable(typeof(T));
return(db);
}
public void InitSchema()
{
CreateMissingTables(DynamoMetadata.GetTables());
}
public static IPocoDynamo RegisterTable(this IPocoDynamo db, Type tableType)
{
DynamoMetadata.RegisterTable(tableType);
return(db);
}
public static IPocoDynamo RegisterTables(this IPocoDynamo db, IEnumerable <Type> tableTypes)
{
DynamoMetadata.RegisterTables(tableTypes);
return(db);
}
public DynamoMetadataType GetTableMetadata(Type table)
{
return(DynamoMetadata.TryGetTable(table) ?? DynamoMetadata.RegisterTable(table));
}
public UpdateExpression <T> UpdateExpression <T>(object hash, object range = null)
{
return(new UpdateExpression <T>(this, DynamoMetadata.GetTable <T>(), hash, range));
}
public static List <T> ConvertAll <T>(this QueryResponse response)
{
return(response.Items
.Select(values => DynamoMetadata.GetType <T>().ConvertTo <T>(values))
.ToList());
}