/// <summary>
/// Sets the LastEvaluatedKey property
/// </summary>
/// <param name="lastEvaluatedKey">The value to set for the LastEvaluatedKey property </param>
/// <returns>this instance</returns>
public ScanResult WithLastEvaluatedKey(Key lastEvaluatedKey)
{
this.lastEvaluatedKey = lastEvaluatedKey;
return this;
}
internal Key MakeKey(Primitive hashKey, Primitive rangeKey)
{
Key newKey = new Key();
newKey.HashKeyElement = hashKey.ConvertToAttributeValue();
if (HashKeyType != hashKey.Type)
throw new InvalidOperationException("Table schema hash key inconsistent with specified hash key value");
if ((rangeKey == null) == RangeKeyIsDefined)
{
throw new ArgumentException("Range Key does not match schema");
}
else
{
if (RangeKeyIsDefined)
{
newKey.RangeKeyElement = rangeKey.ConvertToAttributeValue();
if (RangeKeyType != rangeKey.Type)
throw new InvalidOperationException("Table schema range key inconsistent with specified range key value");
}
}
return newKey;
}
internal Document UpdateHelper(Document doc, Key key, UpdateItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new UpdateItemOperationConfig();
// If the keys have been changed, treat entire document as having changed
bool haveKeysChanged = HaveKeysChanged(doc);
bool updateChangedAttributesOnly = !haveKeysChanged;
var attributeUpdates = doc.ToAttributeUpdateMap(updateChangedAttributesOnly);
foreach (var keyName in this.keyNames)
{
attributeUpdates.Remove(keyName);
}
UpdateItemRequest req = new UpdateItemRequest
{
TableName = TableName,
Key = key,
AttributeUpdates = attributeUpdates.Count == 0 ?
new Dictionary<string,AttributeValueUpdate>() : attributeUpdates,
ReturnValues = EnumToStringMapper.Convert(currentConfig.ReturnValues)
};
req.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.Expected != null)
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
var resp = DDBClient.UpdateItem(req);
var returnedAttributes = resp.UpdateItemResult.Attributes;
doc.CommitChanges();
Document ret = null;
if (currentConfig.ReturnValues != ReturnValues.None)
{
ret = Document.FromAttributeMap(returnedAttributes);
}
return ret;
}
internal Document DeleteHelper(Key key, DeleteItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new DeleteItemOperationConfig();
var req = new DeleteItemRequest
{
TableName = TableName,
Key = key
};
req.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
req.ReturnValues = EnumToStringMapper.Convert(currentConfig.ReturnValues);
}
if (currentConfig.Expected != null)
{
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
}
var attributes = DDBClient.DeleteItem(req).DeleteItemResult.Attributes;
Document ret = null;
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
ret = Document.FromAttributeMap(attributes);
}
return ret;
}
internal Document GetItemHelper(Key key, GetItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new GetItemOperationConfig();
var request = new GetItemRequest
{
TableName = TableName,
Key = key,
ConsistentRead = currentConfig.ConsistentRead
};
request.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.AttributesToGet != null)
request.WithAttributesToGet(currentConfig.AttributesToGet);
var result = DDBClient.GetItem(request);
var attributeMap = result.GetItemResult.Item;
if (attributeMap == null)
return null;
return Document.FromAttributeMap(attributeMap);
}
/// <summary>
/// Sets the ExclusiveStartKey property
/// </summary>
/// <param name="exclusiveStartKey">The value to set for the ExclusiveStartKey property </param>
/// <returns>this instance</returns>
public ScanRequest WithExclusiveStartKey(Key exclusiveStartKey)
{
this.exclusiveStartKey = exclusiveStartKey;
return this;
}
/// <summary>
/// Sets the Key property
/// </summary>
/// <param name="key">The value to set for the Key property </param>
/// <returns>this instance</returns>
public DeleteRequest WithKey(Key key)
{
this.key = key;
return this;
}
/// <summary>
/// Sets the Key property
/// </summary>
/// <param name="key">The value to set for the Key property </param>
/// <returns>this instance</returns>
public GetItemRequest WithKey(Key key)
{
this.key = key;
return this;
}
private Document UpdateHelper(Document doc, Key key, UpdateItemOperationConfig config)
{
var currentConfig = config ?? new UpdateItemOperationConfig();
var attributeUpdates = doc.ToAttributeUpdateMap(true);
foreach (var keyName in this.keyNames)
{
if (keyName != null)
{
attributeUpdates.Remove(keyName);
}
}
UpdateItemRequest req = new UpdateItemRequest
{
TableName = TableName,
Key = key,
AttributeUpdates = attributeUpdates,
ReturnValues = EnumToStringMapper.Convert(currentConfig.ReturnValues)
};
req.BeforeRequestEvent += new RequestEventHandler(this.UserAgentRequestEventHandler);
if (currentConfig.Expected != null)
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
var resp = DDBClient.UpdateItem(req);
doc.CommitChanges();
Document ret = null;
if (currentConfig.ReturnValues != ReturnValues.None)
{
ret = Document.FromAttributeMap(resp.UpdateItemResult.Attributes);
}
return ret;
}
internal Document UpdateHelper(Document doc, Key key, UpdateItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new UpdateItemOperationConfig();
var attributeUpdates = doc.ToAttributeUpdateMap(true);
foreach (var keyName in this.keyNames)
{
attributeUpdates.Remove(keyName);
}
ReturnValues currentReturnValue = currentConfig.ReturnValues;
bool keysOnlyUpdate = attributeUpdates.Count == 0;
// If there are no non-key attributes, make an Update call with AllNewAttributes
// return value. If no attributes returned, the item doesn't exist yet, so
// make a Put call.
if (keysOnlyUpdate)
{
currentReturnValue = ReturnValues.AllNewAttributes;
}
UpdateItemRequest req = new UpdateItemRequest
{
TableName = TableName,
Key = key,
AttributeUpdates = attributeUpdates,
ReturnValues = EnumToStringMapper.Convert(currentReturnValue)
};
req.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.Expected != null)
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
var resp = DDBClient.UpdateItem(req);
var returnedAttributes = resp.UpdateItemResult.Attributes;
doc.CommitChanges();
if (keysOnlyUpdate)
{
if (returnedAttributes == null || returnedAttributes.Count == 0)
{
// if only keys were specified and no attributes are returned, we must issue a Put
return CallKeysOnlyPut(key, currentConfig, isAsync);
}
else
{
// update was called with AllNewAttributes, item exists
// return correct set of attributes
// [None] is handled at the end
// [AllNewAttributes, AllOldAttributes] are equivalent in this case, no-op
// [UpdatedNewAttributes, UpdatedOldAttributes] must return no attributes
switch (currentConfig.ReturnValues)
{
case ReturnValues.UpdatedNewAttributes:
case ReturnValues.UpdatedOldAttributes:
returnedAttributes = new Dictionary<string,AttributeValue>();
break;
}
}
}
Document ret = null;
if (currentConfig.ReturnValues != ReturnValues.None)
{
ret = Document.FromAttributeMap(returnedAttributes);
}
return ret;
}
internal void AddKey(Key key)
{
Keys.Add(key);
}
// Creates a PutItemOperationConfig for the keys-only Put operation
private PutItemOperationConfig CreateKeysOnlyPutConfig(Key key, UpdateItemOperationConfig config)
{
// configure the expected document
Document expected = new Document();
expected[this.HashKeyName] = null;
if (this.RangeKeyIsDefined)
{
expected[this.RangeKeyName] = null;
}
// create the PutItemOperationConfig
var putConfig = new PutItemOperationConfig
{
Expected = expected,
ReturnValues = ReturnValues.None
};
return putConfig;
}
// Creates a Document object that consists of the hash and potentially range keys
private Document CreateKeysOnlyDocument(Key key)
{
// create document to put
Document doc = new Document();
if (!doc.Contains(this.HashKeyName))
{
DynamoDBEntry hashKey = Document.AttributeValueToDynamoDBEntry(key.HashKeyElement);
if (hashKey == null) throw new InvalidOperationException("Cannot convert hash key attribute");
doc[this.HashKeyName] = hashKey;
}
if (this.RangeKeyIsDefined && !doc.Contains(this.RangeKeyName))
{
DynamoDBEntry rangeKey = Document.AttributeValueToDynamoDBEntry(key.RangeKeyElement);
if (rangeKey == null) throw new InvalidOperationException("Cannot convert range key attribute");
doc[this.RangeKeyName] = rangeKey;
}
return doc;
}
// calls Put, but returns like Update
private Document CallKeysOnlyPut(Key key, UpdateItemOperationConfig config, bool isAsync)
{
// configure the keys-only Document
Document doc = CreateKeysOnlyDocument(key);
// configure the put operation
PutItemOperationConfig putConfig = CreateKeysOnlyPutConfig(key, config);
// call put
PutItemHelper(doc, putConfig, isAsync);
/*
New item created, return Update-appropriate response.
For update, when no item exists:
[None] - returns null,
[AllOld, UpdatedNew, UpdatedOld] - return no attributes
[AllNew] - returns all attributes
*/
Document response;
switch (config.ReturnValues)
{
case ReturnValues.None:
response = null;
break;
case ReturnValues.AllNewAttributes:
response = doc;
break;
default:
response = new Document();
break;
}
return response;
}
/// <summary>
/// Sets the Key property
/// </summary>
/// <param name="key">The value to set for the Key property </param>
/// <returns>this instance</returns>
public UpdateItemRequest WithKey(Key key)
{
this.key = key;
return this;
}
/// <summary>
/// Sets the Key property
/// </summary>
/// <param name="key">The value to set for the Key property </param>
/// <returns>this instance</returns>
public GetItemRequest WithKey(Key key)
{
this.key = key;
return this;
}
