public virtual AttributeValue ToMapAttributeValue(IPocoDynamo db, object oMap) { var map = oMap as IDictionary ?? oMap.ToObjectDictionary(); var meta = DynamoMetadata.GetType(oMap.GetType()); var to = new Dictionary <string, AttributeValue>(); foreach (var key in map.Keys) { var value = map[key]; if (value != null) { value = ApplyFieldBehavior(db, meta, meta?.GetField((string)key), oMap, value); } to[key.ToString()] = value != null ? ToAttributeValue(db, value.GetType(), GetFieldType(value.GetType()), value) : new AttributeValue { NULL = true }; } return(new AttributeValue { M = to, IsMSet = true }); }
public async Task <List <T> > GetItemsAsync <T>(IEnumerable <DynamoId> ids, CancellationToken token = default) { 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(await ConvertBatchGetItemResponseAsync <T>(table, getItems, token).ConfigAwait()); } 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 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 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 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>(); }
protected void OnVisitMemberType(Type modelType) { var tableDef = DynamoMetadata.TryGetTable(modelType); if (tableDef != null) { VisitedExpressionIsTable = true; } }
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 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 async Task DeleteRelatedItemsAsync <T>(object hash, IEnumerable <object> ranges, CancellationToken token = default) { 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"); } await DeleteItemsAsync <T>(ranges.Map(range => new DynamoId(hash, range)), token).ConfigAwait(); }
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 async Task <T> GetItemAsync <T>(object hash, object range, CancellationToken token = default) { var table = DynamoMetadata.GetTable <T>(); var request = new GetItemRequest { TableName = table.Name, Key = Converters.ToAttributeKeyValue(this, table, hash, range), ConsistentRead = ConsistentRead, }; return(await ConvertGetItemResponseAsync <T>(request, table, token).ConfigAwait()); }
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 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 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);
public async Task <T> UpdateItemNonDefaultsAsync <T>(T value, bool returnOld = false, CancellationToken token = default) { var table = DynamoMetadata.GetTable <T>(); var request = new UpdateItemRequest { TableName = table.Name, Key = Converters.ToAttributeKey(this, table, value), AttributeUpdates = Converters.ToNonDefaultAttributeValueUpdates(this, value, table), ReturnValues = returnOld ? ReturnValue.ALL_OLD : ReturnValue.NONE, }; var response = await ExecAsync(async() => await DynamoDb.UpdateItemAsync(request, token).ConfigAwait()).ConfigAwait(); if (response.Attributes.IsEmpty()) { return(default);
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 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 virtual object FromMapAttributeValue(Dictionary <string, AttributeValue> map, Type type) { var from = new Dictionary <string, object>(); var metaType = DynamoMetadata.GetType(type); if (metaType == null) { var toMap = (IDictionary)type.CreateInstance(); var genericDict = type.GetTypeWithGenericTypeDefinitionOf(typeof(IDictionary <,>)); if (genericDict != null) { var genericArgs = genericDict.GetGenericArguments(); var keyType = genericArgs[0]; var valueType = genericArgs[1]; foreach (var entry in map) { var key = ConvertValue(entry.Key, keyType); toMap[key] = FromAttributeValue(entry.Value, valueType); } return(toMap); } throw new ArgumentException("Unknown Map Type " + type.Name); } foreach (var field in metaType.Fields) { AttributeValue attrValue; if (!map.TryGetValue(field.Name, out attrValue)) { continue; } from[field.Name] = FromAttributeValue(attrValue, field.Type); } var to = from.FromObjectDictionary(type); return(to); }
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 async Task <T> PutItemAsync <T>(T value, bool returnOld = false, CancellationToken token = default) { 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 = await ExecAsync(async() => await DynamoDb.PutItemAsync(request, token).ConfigAwait()).ConfigAwait(); if (response.Attributes.IsEmpty()) { return(default(T)); } return(Converters.FromAttributeValues <T>(table, response.Attributes)); }
public T UpdateItemNonDefaults <T>(T value, bool returnOld = false) { var table = DynamoMetadata.GetTable <T>(); var request = new UpdateItemRequest { TableName = table.Name, Key = Converters.ToAttributeKey(this, table, value), AttributeUpdates = Converters.ToNonDefaultAttributeValueUpdates(this, value, table), ReturnValues = returnOld ? ReturnValue.ALL_OLD : ReturnValue.NONE, }; var response = Exec(() => DynamoDb.UpdateItem(request)); if (response.Attributes.IsEmpty()) { return(default(T)); } return(Converters.FromAttributeValues <T>(table, response.Attributes)); }
public virtual AttributeValue ToListAttributeValue(IPocoDynamo db, object oList) { var list = ((IEnumerable)oList).Map(x => x); if (list.Count <= 0) { return new AttributeValue { L = new List <AttributeValue>(), IsLSet = true } } ; var elType = list[0].GetType(); var elMeta = DynamoMetadata.GetType(elType); if (elMeta != null) { var autoIncrFields = elMeta.Fields.Where(x => x.IsAutoIncrement).ToList(); foreach (var field in autoIncrFields) { //Avoid N+1 by fetching a batch of ids var autoIds = db.Sequences.GetNextSequences(elMeta, list.Count); for (var i = 0; i < list.Count; i++) { var instance = list[i]; var value = field.GetValue(instance); if (IsNumberDefault(value)) { field.SetValue(instance, autoIds[i]); } } } } var values = list.Map(x => ToAttributeValue(db, x.GetType(), GetFieldType(x.GetType()), x)); return(new AttributeValue { L = values }); }
public async Task <List <T> > GetRelatedItemsAsync <T>(object hash, CancellationToken token = default) { 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) } } }; #if NET472 || NETCORE return(await QueryAsync(request, r => r.ConvertAll <T>(), token).ToListAsync(token)); #else return(await QueryAsync(request, r => r.ConvertAll <T>(), token).ConfigAwait()); #endif }
public static List <T> ConvertAll <T>(this QueryResponse response) { return(response.Items .Select(values => DynamoMetadata.GetType <T>().ConvertTo <T>(values)) .ToList()); }