protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WritePropertyName("RequestItems");
writer.WriteStartObject();
foreach (var item in _request.RequestItems !)
{
WriteTableNameAsKey(writer, _tableNamePrefix, item.Key);
writer.WriteStartArray();
for (var i = 0; i < item.Value.Count; i++)
{
var operation = item.Value[i];
if (operation.DeleteRequest != null)
{
writer.WriteStartObject();
writer.WritePropertyName("DeleteRequest");
writer.WriteStartObject();
writer.WritePropertyName("Key");
writer.WriteAttributesDictionary(operation.DeleteRequest.Key);
writer.WriteEndObject();
writer.WriteEndObject();
}
else if (operation.PutRequest != null)
{
writer.WriteStartObject();
writer.WritePropertyName("PutRequest");
writer.WriteStartObject();
writer.WritePropertyName("Item");
await writer.WriteAttributesDictionaryAsync(ddbWriter.BufferWriter, operation.PutRequest.Item).ConfigureAwait(false);
writer.WriteEndObject();
writer.WriteEndObject();
}
}
writer.WriteEndArray();
}
writer.WriteEndObject();
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
if (_request.ReturnItemCollectionMetrics != ReturnItemCollectionMetrics.None)
{
writer.WriteReturnItemCollectionMetrics(_request.ReturnItemCollectionMetrics);
}
writer.WriteEndObject();
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
WritePrimaryKey(in ddbWriter);
writer.WriteTableName(_tablePrefix, Request.TableName);
if (Request.ConsistentRead)
{
writer.WriteBoolean("ConsistentRead", true);
}
if (Request.ExpressionAttributeNames?.Count > 0)
{
writer.WriteExpressionAttributeNames(Request.ExpressionAttributeNames);
}
if (Request.ProjectionExpression != null)
{
writer.WriteString("ProjectionExpression", Request.ProjectionExpression);
}
if (Request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(Request.ReturnConsumedCapacity);
}
writer.WriteEndObject();
return(default);
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WriteTableName(_tablePrefix, _tableName);
writer.WriteEndObject();
return(default);
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
ddbWriter.JsonWriter.WriteStartObject();
ddbWriter.JsonWriter.WritePropertyName("RequestItems");
ddbWriter.JsonWriter.WriteStartObject();
var operationsCount = 0;
(DdbClassInfo ClassInfo, IBatchWriteBuilder Builder)[] sortedBuilders = ArrayPool <(DdbClassInfo ClassInfo, IBatchWriteBuilder Builder)> .Shared.Rent(OperationsLimit);
public static void WriteEntity(this DdbWriter writer, DdbClassInfo entityClassInfo, object entity)
{
writer.JsonWriter.WriteStartObject();
foreach (var property in entityClassInfo.Properties)
{
property.Write(entity, writer);
}
writer.JsonWriter.WriteEndObject();
}
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WritePropertyName("RequestItems");
writer.WriteStartObject();
foreach (var item in _request.RequestItems !)
{
WriteTableNameAsKey(writer, _tableNamePrefix, item.Key);
writer.WriteStartObject();
writer.WritePropertyName("Keys");
writer.WriteStartArray();
foreach (var primaryKey in item.Value.Keys !)
{
writer.WriteAttributesDictionary(primaryKey);
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
writer.WriteEndArray();
if (item.Value.ProjectionExpression != null)
{
writer.WriteString("ProjectionExpression", item.Value.ProjectionExpression);
}
if (item.Value.ExpressionAttributeNames?.Count > 0)
{
writer.WriteExpressionAttributeNames(item.Value.ExpressionAttributeNames);
}
if (item.Value.ConsistentRead)
{
writer.WriteBoolean("ConsistentRead", item.Value.ConsistentRead);
}
writer.WriteEndObject();
}
writer.WriteEndObject();
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
writer.WriteEndObject();
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
BuilderNode?currentNode = _node;
var wereExpressionsWritten = false;
var writeState = 0;
while (currentNode != null)
{
switch (currentNode.Type)
{
case BuilderNodeType.KeyExpression:
case BuilderNodeType.FilterExpression:
case BuilderNodeType.ProjectedAttributes:
{
if (wereExpressionsWritten)
{
break;
}
WriteExpressions(in ddbWriter, currentNode);
wereExpressionsWritten = true;
break;
}
case BuilderNodeType.TableName:
((TableNameNode)currentNode).WriteTableName(in ddbWriter, ref writeState, _context.Config.TableNamePrefix);
break;
default:
{
currentNode.WriteValue(in ddbWriter, ref writeState);
break;
}
}
currentNode = currentNode.Next;
}
if (!writeState.IsBitSet(NodeBits.TableName))
{
writer.WriteTableName(_context.Config.TableNamePrefix,
_tableName ?? throw new DdbException("Table name has to be specified either using the DynamoDbTable attribute or WithTableName extension method."));
}
writer.WriteEndObject();
return(default);
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var writeState = 0;
if (_node != null)
{
FilterBase? filterExpression = null;
BuilderNode?projectedAttributesStart = null;
foreach (var node in _node)
{
switch (node.Type)
{
case BuilderNodeType.FilterExpression:
filterExpression ??= ((FilterExpressionNode)node).Value;
break;
case BuilderNodeType.ProjectedAttributes:
projectedAttributesStart ??= node;
break;
case BuilderNodeType.TableName:
((TableNameNode)node).WriteTableName(in ddbWriter, ref writeState, _context.Config.TableNamePrefix);
break;
default:
node.WriteValue(in ddbWriter, ref writeState);
break;
}
}
if (filterExpression != null || projectedAttributesStart != null)
{
WriteExpressions(in ddbWriter, filterExpression, projectedAttributesStart);
}
}
if (!writeState.IsBitSet(NodeBits.TableName))
{
writer.WriteTableName(_context.Config.TableNamePrefix,
_tableName ?? throw new DdbException("Table name has to be specified either using the DynamoDbTable attribute or WithTableName extension method."));
}
writer.WriteEndObject();
return(default);
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
writer.WritePropertyName("TransactItems");
writer.WriteStartArray();
foreach (var transactItem in _request.TransactItems)
{
writer.WriteStartObject();
writer.WritePropertyName("Get");
writer.WriteStartObject();
if (transactItem.ExpressionAttributeNames != null)
{
writer.WriteExpressionAttributeNames(transactItem.ExpressionAttributeNames);
}
if (transactItem.ProjectionExpression != null)
{
writer.WriteString("ProjectionExpression", transactItem.ProjectionExpression);
}
writer.WriteTableName(_tableNamePrefix, transactItem.TableName);
writer.WritePrimaryKey(transactItem.Key !);
writer.WriteEndObject();
writer.WriteEndObject();
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
public static async ValueTask WriteEntityAsync(this DdbWriter writer, DdbClassInfo entityClassInfo, object entity)
{
writer.JsonWriter.WriteStartObject();
foreach (var property in entityClassInfo.Properties)
{
property.Write(entity, writer);
if (writer.ShouldFlush)
{
await writer.FlushAsync().ConfigureAwait(false);
}
}
writer.JsonWriter.WriteEndObject();
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
WritePrimaryKey(writer);
writer.WriteTableName(_tablePrefix, _request.TableName);
if (_request.ConditionExpression != null)
{
writer.WriteString("ConditionExpression", _request.ConditionExpression);
}
if (_request.ExpressionAttributeNames?.Count > 0)
{
writer.WriteExpressionAttributeNames(_request.ExpressionAttributeNames);
}
if (_request.ExpressionAttributeValues?.Count > 0)
{
writer.WriteExpressionAttributeValues(_request.ExpressionAttributeValues);
}
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
if (_request.ReturnItemCollectionMetrics != ReturnItemCollectionMetrics.None)
{
WriteReturnItemCollectionMetrics(writer);
}
if (_request.ReturnValues != ReturnValues.None)
{
WriteReturnValues(writer);
}
if (_request.UpdateExpression != null)
{
writer.WriteString("UpdateExpression", _request.UpdateExpression);
}
writer.WriteEndObject();
return(default);
public static void WritePaginationToken(this DdbWriter writer, string paginationToken)
{
writer.JsonWriter.WritePropertyName("ExclusiveStartKey");
writer.JsonWriter.WriteNullValue();
// Flush to make sure our changes don't overlap with pending changes
writer.JsonWriter.Flush();
// Dirty hack until System.Text.Json supports writing raw json
writer.BufferWriter.Advance(-4);
var bytesSize = Encoding.UTF8.GetByteCount(paginationToken);
var bytesWritten = Encoding.UTF8.GetBytes(paginationToken, writer.BufferWriter.GetSpan(bytesSize));
writer.BufferWriter.Advance(bytesWritten);
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
ddbWriter.JsonWriter.WriteStartObject();
var writeState = 0;
WriteUpdateItem(in ddbWriter, ref writeState);
if (!writeState.IsBitSet(NodeBits.TableName))
{
ddbWriter.JsonWriter.WriteTableName(_context.Config.TableNamePrefix, _classInfo.TableName !);
}
ddbWriter.JsonWriter.WriteEndObject();
return(new ValueTask());
}
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var writeState = 0;
var itemsProcessed = false;
foreach (var node in _node)
{
if (node.Type != BuilderNodeType.BatchItems)
{
node.WriteValue(in ddbWriter, ref writeState);
continue;
}
if (itemsProcessed)
{
continue;
}
writer.WritePropertyName("TransactItems");
writer.WriteStartArray();
var itemsNode = (BatchItemsNode <ITransactGetItemRequestBuilder>)node;
using var itemsEnumerator = itemsNode.Value.GetEnumerator();
DdbExpressionVisitor?visitor = null;
while (WriteGetItems(in ddbWriter, ref visitor, itemsEnumerator))
{
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
writer.WriteEndArray();
itemsProcessed = true;
}
writer.WriteEndObject();
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var writeState = 0;
foreach (var node in _node)
{
switch (node.Type)
{
case BuilderNodeType.PrimaryKey:
((PrimaryKeyNodeBase)node).Write(in ddbWriter, _classInfo, ref writeState);
break;
case BuilderNodeType.Condition:
if (writeState.IsBitSet(NodeBits.Condition))
{
break;
}
ddbWriter.WriteConditionExpression(((ConditionNode)node).Value, _context.Config.Metadata);
writeState = writeState.SetBit(NodeBits.Condition);
break;
case BuilderNodeType.TableName:
((TableNameNode)node).WriteTableName(in ddbWriter, ref writeState, _context.Config.TableNamePrefix);
break;
default:
node.WriteValue(in ddbWriter, ref writeState);
break;
}
}
if (!writeState.IsBitSet(NodeBits.TableName))
{
writer.WriteTableName(_context.Config.TableNamePrefix, _classInfo.TableName !);
}
writer.WriteEndObject();
return(default);
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WritePropertyName("Item");
await WriteItemAsync(ddbWriter).ConfigureAwait(false);
writer.WriteTableName(_tablePrefix, Request.TableName);
if (Request.ConditionExpression != null)
{
writer.WriteString("ConditionExpression", Request.ConditionExpression);
}
if (Request.ExpressionAttributeNames?.Count > 0)
{
writer.WriteExpressionAttributeNames(Request.ExpressionAttributeNames);
}
if (Request.ExpressionAttributeValues?.Count > 0)
{
writer.WriteExpressionAttributeValues(Request.ExpressionAttributeValues);
}
if (Request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(Request.ReturnConsumedCapacity);
}
if (Request.ReturnItemCollectionMetrics != ReturnItemCollectionMetrics.None)
{
writer.WriteReturnItemCollectionMetrics(Request.ReturnItemCollectionMetrics);
}
if (Request.ReturnValues != ReturnValues.None)
{
writer.WriteReturnValues(Request.ReturnValues);
}
writer.WriteEndObject();
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var classInfo = _context.Config.Metadata.GetOrAddClassInfo <TEntity>();
writer.WriteTableName(_context.Config.TableNamePrefix, classInfo.TableName !);
writer.WritePropertyName("Key");
writer.WriteStartObject();
writer.WritePropertyName(classInfo.PartitionKey !.AttributeName);
classInfo.PartitionKey !.ConverterBase.Write(in ddbWriter, _pk);
writer.WriteEndObject();
writer.WriteEndObject();
return(new ValueTask());
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext?context)
{
if (_pooledContentStream?.Length > 0)
{
await _pooledContentStream.CopyToAsync(stream).ConfigureAwait(false);
return;
}
// Pooled buffer may seems redundant while reviewing current method, but when passed to json writer it completely changes the write logic.
// Instead of reallocating new in-memory arrays when json size grows and Flush is not called explicitly - it now uses pooled buffer.
// With proper flushing logic amount of buffer growths/copies should be zero and amount of memory allocations should be zero as well.
using var bufferWriter = new PooledByteBufferWriter(stream);
await using var writer = new Utf8JsonWriter(bufferWriter, JsonWriterOptions);
var ddbWriter = new DdbWriter(writer, bufferWriter);
await WriteDataAsync(ddbWriter).ConfigureAwait(false);
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
ddbWriter.JsonWriter.WriteStartObject();
var classInfo = _context.Config.Metadata.GetOrAddClassInfo <TEntity>();
ddbWriter.JsonWriter.WriteTableName(_context.Config.TableNamePrefix, classInfo.TableName !);
ddbWriter.JsonWriter.WritePropertyName("Key");
ddbWriter.JsonWriter.WriteStartObject();
classInfo.PartitionKey !.Write(_entity, in ddbWriter);
classInfo.SortKey?.Write(_entity, in ddbWriter);
ddbWriter.JsonWriter.WriteEndObject();
WriteUpdateItem(in ddbWriter, classInfo);
ddbWriter.JsonWriter.WriteEndObject();
return(new ValueTask());
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var classInfo = _config.Metadata.GetOrAddClassInfo <TEntity>();
writer.WriteTableName(_config.TableNamePrefix, classInfo.TableName !);
writer.WritePropertyName("Key");
writer.WriteStartObject();
classInfo.PartitionKey !.Write(_entity, in ddbWriter);
classInfo.SortKey?.Write(_entity, in ddbWriter);
writer.WriteEndObject();
if (classInfo.Version != null)
{
var isVersionNull = classInfo.Version.IsNull(_entity);
writer.WriteString("ConditionExpression", isVersionNull ? "attribute_not_exists(#version)" : "#version = :version");
writer.WritePropertyName("ExpressionAttributeNames");
writer.WriteStartObject();
writer.WriteString("#version", classInfo.Version.AttributeName);
writer.WriteEndObject();
if (!isVersionNull)
{
writer.WritePropertyName("ExpressionAttributeValues");
writer.WriteStartObject();
writer.WritePropertyName(":version");
classInfo.Version.WriteValue(_entity, in ddbWriter);
writer.WriteEndObject();
}
}
writer.WriteEndObject();
return(default);
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WritePropertyName("RequestItems");
writer.WriteStartObject();
if (_node is BatchItemsNode <IBatchGetItemBuilder> rawItemsNode)
{
await WriteItems(ddbWriter, rawItemsNode).ConfigureAwait(false);
}
else
{
var tablesNode = (BatchItemsNode <IBatchGetTableBuilder>)_node;
await WriteTables(ddbWriter, tablesNode).ConfigureAwait(false);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
var currentNode = _node;
var writeState = 0;
string?tableName = null;
while (currentNode != null)
{
switch (currentNode.Type)
{
case BuilderNodeType.Item:
{
if (writeState.IsBitSet(NodeBits.Item))
{
break;
}
var itemNode = ((ItemNode)currentNode);
tableName = itemNode.EntityClassInfo.TableName;
writer.WritePropertyName("Item");
await ddbWriter.WriteEntityAsync(itemNode.EntityClassInfo, itemNode.Value).ConfigureAwait(false);
writeState = writeState.SetBit(NodeBits.Item);
break;
}
case BuilderNodeType.Condition:
{
if (writeState.IsBitSet(NodeBits.Condition))
{
break;
}
ddbWriter.WriteConditionExpression(((ConditionNode)currentNode).Value, _context.Config.Metadata);
writeState = writeState.SetBit(NodeBits.Condition);
break;
}
case BuilderNodeType.TableName:
((TableNameNode)currentNode).WriteTableName(in ddbWriter, ref writeState, _context.Config.TableNamePrefix);
break;
default:
{
currentNode.WriteValue(in ddbWriter, ref writeState);
break;
}
}
currentNode = currentNode.Next;
}
if (!writeState.IsBitSet(NodeBits.TableName) && tableName != null)
{
writer.WriteTableName(_context.Config.TableNamePrefix, tableName);
}
writer.WriteEndObject();
}
protected override async ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
if (_request.ReturnItemCollectionMetrics != ReturnItemCollectionMetrics.None)
{
writer.WriteReturnItemCollectionMetrics(_request.ReturnItemCollectionMetrics);
}
if (_request.ClientRequestToken != null)
{
writer.WriteString("ClientRequestToken", _request.ClientRequestToken);
}
writer.WritePropertyName("TransactItems");
writer.WriteStartArray();
foreach (var transactItem in _request.TransactItems)
{
writer.WriteStartObject();
if (transactItem.ConditionCheck != null)
{
WriteConditionCheck(writer, transactItem.ConditionCheck);
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
if (transactItem.Delete != null)
{
WriteDelete(writer, transactItem.Delete);
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
if (transactItem.Put != null)
{
writer.WritePropertyName("Put");
writer.WriteStartObject();
writer.WriteTableName(_tablePrefix, transactItem.Put.TableName);
if (transactItem.Put.ConditionExpression != null)
{
writer.WriteString("ConditionExpression", transactItem.Put.ConditionExpression);
}
if (transactItem.Put.ExpressionAttributeNames != null)
{
writer.WriteExpressionAttributeNames(transactItem.Put.ExpressionAttributeNames);
}
if (transactItem.Put.ExpressionAttributeValues != null)
{
writer.WriteExpressionAttributeValues(transactItem.Put.ExpressionAttributeValues);
}
if (transactItem.Put.ReturnValuesOnConditionCheckFailure != ReturnValuesOnConditionCheckFailure.None)
{
writer.WriteReturnValuesOnConditionCheckFailure(transactItem.Put.ReturnValuesOnConditionCheckFailure);
}
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
writer.WritePropertyName("Item");
await writer.WriteAttributesDictionaryAsync(ddbWriter.BufferWriter, transactItem.Put.Item !).ConfigureAwait(false);
writer.WriteEndObject();
}
if (transactItem.Update != null)
{
WriteUpdate(writer, transactItem.Update);
if (ddbWriter.ShouldFlush)
{
await ddbWriter.FlushAsync().ConfigureAwait(false);
}
}
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
}
public static ValueTask WriteEntityAsync(this DdbWriter writer, object entity,
DynamoDbContextMetadata metadata) => WriteEntityAsync(writer, metadata.GetOrAddClassInfo(entity.GetType()), entity);
protected override ValueTask WriteItemAsync(DdbWriter writer) => writer.JsonWriter.WriteAttributesDictionaryAsync(writer.BufferWriter, Request.Item !);
private async Task WriteItems(DdbWriter ddbWriter, BatchItemsNode <IBatchGetItemBuilder> itemsNode)
{
var writer = ddbWriter.JsonWriter;
var operationsCount = 0;
(DdbClassInfo ClassInfo, IBatchGetItemBuilder Builder)[] sortedBuilders = ArrayPool <(DdbClassInfo ClassInfo, IBatchGetItemBuilder Builder)> .Shared.Rent(OperationsLimit);
protected override ValueTask WriteDataAsync(DdbWriter writer)
{
writer.JsonWriter.WriteStartObject();
var writeState = 0;
var projectionWritten = false;
foreach (var node in _node)
{
switch (node.Type)
{
case BuilderNodeType.PrimaryKey:
((PrimaryKeyNodeBase)node).Write(in writer, _classInfo, ref writeState);
break;
case BuilderNodeType.ProjectedAttributes:
if (projectionWritten)
{
break;
}
// ReSharper disable once StackAllocInsideLoop
var builder = new NoAllocStringBuilder(stackalloc char[NoAllocStringBuilder.MaxStackAllocSize], true);
try
{
var visitor = new DdbExpressionVisitor(_context.Config.Metadata);
writer.JsonWriter.WriteProjectedAttributes(node, ref builder, visitor, _context.Config.Metadata);
if (visitor.CachedAttributeNames.Count > 0)
{
writer.JsonWriter.WriteExpressionAttributeNames(ref builder, visitor.CachedAttributeNames);
}
projectionWritten = true;
}
finally
{
builder.Dispose();
}
break;
case BuilderNodeType.TableName:
((TableNameNode)node).WriteTableName(in writer, ref writeState, _context.Config.TableNamePrefix);
break;
default:
node.WriteValue(in writer, ref writeState);
break;
}
}
if (!writeState.IsBitSet(NodeBits.TableName))
{
writer.JsonWriter.WriteTableName(_context.Config.TableNamePrefix, _classInfo.TableName !);
}
writer.JsonWriter.WriteEndObject();
return(new ValueTask());
}
protected override ValueTask WriteDataAsync(DdbWriter ddbWriter)
{
var writer = ddbWriter.JsonWriter;
writer.WriteStartObject();
writer.WriteTableName(_tablePrefix, _request.TableName);
if (_request.IndexName != null)
{
writer.WriteString("IndexName", _request.IndexName);
}
if (_request.FilterExpression != null)
{
writer.WriteString("FilterExpression", _request.FilterExpression);
}
if (_request.ExpressionAttributeNames?.Count > 0)
{
writer.WriteExpressionAttributeNames(_request.ExpressionAttributeNames);
}
if (_request.ExpressionAttributeValues?.Count > 0)
{
writer.WriteExpressionAttributeValues(_request.ExpressionAttributeValues);
}
if (_request.Limit.HasValue)
{
writer.WriteNumber("Limit", _request.Limit.Value);
}
if (_request.ProjectionExpression != null)
{
writer.WriteString("ProjectionExpression", _request.ProjectionExpression);
}
else if (_request.Select.HasValue)
{
WriteSelect(writer, _request.Select.Value);
}
if (_request.ReturnConsumedCapacity != ReturnConsumedCapacity.None)
{
writer.WriteReturnConsumedCapacity(_request.ReturnConsumedCapacity);
}
if (_request.ExclusiveStartKey != null)
{
WriteExclusiveStartKey(writer, _request.ExclusiveStartKey);
}
if (_request.ConsistentRead)
{
writer.WriteBoolean("ConsistentRead", true);
}
if (_request.Segment.HasValue)
{
writer.WriteNumber("Segment", _request.Segment.Value);
}
if (_request.TotalSegments.HasValue)
{
writer.WriteNumber("TotalSegments", _request.TotalSegments.Value);
}
writer.WriteEndObject();
return(default);
/// <summary> /// When implementation suspects that amount of bytes written is close to 16KB, it should call <see cref="PooledByteBufferWriter.ShouldWrite"/> and in case of true result - call <see cref="PooledByteBufferWriter.WriteToStreamAsync"/>. <br/><br/> /// Keep in mind that <see cref="ValueTask"/> calls have a certain overhead, so we only want keep asynchronous writes for request content builders. <br/> /// Write implementations of <see cref="IAttributeValue"/> continue to be synchronous and in general are not expected to produce JSON bigger than 16KB. /// </summary> protected abstract ValueTask WriteDataAsync(DdbWriter writer);
protected abstract ValueTask WriteItemAsync(DdbWriter writer);
