private static unsafe string ReadGuid(Table.TableValueHolder entryHolder)
{
var guidPtr = entryHolder.Reader.Read((int)(LogHistoryColumn.Guid), out var size);
var guid = Encoding.UTF8.GetString(guidPtr, size);
return(guid);
}
private static unsafe string ReadType(Table.TableValueHolder entryHolder)
{
int size;
var typeString = entryHolder.Reader.Read((int)(LogHistoryColumn.Type), out size);
var type = Encoding.UTF8.GetString(typeString, size);
return(type);
}
private void DeleteFromTable(DocumentsOperationContext context, Table table, TableSchema.SchemaIndexDef pk, Func <Table.TableValueHolder, bool> shouldSkip = null)
{
Table.TableValueHolder tableValueHolder = null;
var tree = table.GetTree(pk);
var last = Slices.BeforeAllKeys;
while (true)
{
using (var it = tree.Iterate(true))
{
it.SetRequiredPrefix(last);
if (it.Seek(it.RequiredPrefix) == false)
{
return;
}
while (true)
{
long id = it.CreateReaderForCurrent().ReadLittleEndianInt64();
if (shouldSkip != null)
{
var ptr = table.DirectRead(id, out int size);
if (tableValueHolder == null)
{
tableValueHolder = new Table.TableValueHolder();
}
tableValueHolder.Reader = new TableValueReader(id, ptr, size);
if (shouldSkip.Invoke(tableValueHolder))
{
last = it.CurrentKey.Clone(context.Allocator);
if (it.MoveNext() == false)
{
return;
}
continue;
}
}
table.Delete(id);
break;
}
}
}
}
private NonPersistentDocumentFlags DeleteAttachmentConflicts(DocumentsOperationContext context, Slice lowerId,
BlittableJsonReaderObject document, Table.TableValueHolder before, string changeVector)
{
var dataPtr = before.Reader.Read((int)ConflictsTable.Data, out int size);
Debug.Assert(size >= 0);
if (size <= 0)
{
return(NonPersistentDocumentFlags.None);
}
Debug.Assert(document != null, "This is not a delete conflict so we should also provide the document.");
using (var conflictDocument = new BlittableJsonReaderObject(dataPtr, size, context))
{
_documentsStorage.AttachmentsStorage.DeleteAttachmentConflicts(context, lowerId, document, conflictDocument, changeVector);
}
return(NonPersistentDocumentFlags.ResolveAttachmentsConflict);
}
private static unsafe (string, BlittableJsonReaderObject) GetCurrentItem(Transaction tx, JsonOperationContext context, Table.TableValueHolder result)
{
var ptr = result.Reader.Read(2, out int size);
var doc = new BlittableJsonReaderObject(ptr, size, context);
var key = Encoding.UTF8.GetString(result.Reader.Read(1, out size), size);
Transaction.DebugDisposeReaderAfterTransaction(tx, doc);
return(key, doc);
}
private static ReplicationBatchItem CreateReplicationBatchItem(DocumentsOperationContext context, Table.TableValueHolder result)
{
var(doc, name) = ExtractDocIdAndName(context, result.Reader);
return(new ReplicationBatchItem
{
Type = ReplicationItemType.Counter,
Id = doc,
Etag = TableValueToEtag((int)CountersTable.Etag, ref result.Reader),
Name = name,
ChangeVector = TableValueToString(context, (int)CountersTable.ChangeVector, ref result.Reader),
Value = TableValueToLong((int)CountersTable.Value, ref result.Reader),
Collection = TableValueToId(context, (int)CountersTable.Collection, ref result.Reader),
TransactionMarker = TableValueToShort((int)CountersTable.TransactionMarker, nameof(ReplicationBatchItem.TransactionMarker), ref result.Reader),
});
}
private static unsafe long ReadIndex(Table.TableValueHolder entryHolder)
{
return(Bits.SwapBytes(*(long *)entryHolder.Reader.Read((int)(LogHistoryColumn.Index), out _)));
}
private static unsafe long ReadTerm(Table.TableValueHolder entryHolder)
{
return(*(long *)entryHolder.Reader.Read((int)(LogHistoryColumn.Term), out _));
}
private static unsafe HistoryStatus ReadState(Table.TableValueHolder entryHolder)
{
return(*(HistoryStatus *)entryHolder.Reader.Read((int)(LogHistoryColumn.State), out _));
}
private static unsafe DynamicJsonValue ReadHistoryLog(TransactionOperationContext context, Table.TableValueHolder entryHolder)
{
var djv = new DynamicJsonValue();
var ticks = Bits.SwapBytes(*(long *)entryHolder.Reader.Read((int)(LogHistoryColumn.Ticks), out _));
djv["Date"] = new DateTime(ticks);
int size;
djv[nameof(LogHistoryColumn.Guid)] = ReadGuid(entryHolder);
djv[nameof(LogHistoryColumn.Index)] = ReadIndex(entryHolder);
djv[nameof(LogHistoryColumn.Term)] = ReadTerm(entryHolder);
djv[nameof(LogHistoryColumn.CommittedTerm)] = ReadCommittedTerm(entryHolder);
djv[nameof(LogHistoryColumn.Type)] = ReadType(entryHolder);
djv[nameof(LogHistoryColumn.State)] = ReadState(entryHolder).ToString();
var resultPtr = entryHolder.Reader.Read((int)(LogHistoryColumn.Result), out size);
if (size > 0)
{
var blittableResult = new BlittableJsonReaderObject(resultPtr, size, context);
djv[nameof(LogHistoryColumn.Result)] = blittableResult.ToString();
blittableResult.Dispose();
}
else
{
djv[nameof(LogHistoryColumn.Result)] = null;
}
var exTypePtr = entryHolder.Reader.Read((int)(LogHistoryColumn.ExceptionType), out size);
djv[nameof(LogHistoryColumn.ExceptionType)] = size > 0 ? Encoding.UTF8.GetString(exTypePtr, size) : null;
var exMsg = entryHolder.Reader.Read((int)(LogHistoryColumn.ExceptionMessage), out size);
djv[nameof(LogHistoryColumn.ExceptionMessage)] = size > 0 ? Encoding.UTF8.GetString(exMsg, size) : null;
return(djv);
}
public static unsafe ReleaseMemory CloneTableValueReader(DocumentsOperationContext context, Table.TableValueHolder read)
{
var copyReadMemory = context.GetMemory(read.Reader.Size);
Memory.Copy(copyReadMemory.Address, read.Reader.Pointer, read.Reader.Size);
read.Reader = new TableValueReader(copyReadMemory.Address, read.Reader.Size);
return(new ReleaseMemory(context, copyReadMemory));
}
private static (string, BlittableJsonReaderObject) GetCurrentItem(Transaction tx, JsonOperationContext context, Table.TableValueHolder result)
{
var ptr = result.Reader.Read((int)ClusterStateMachine.CertificatesTable.Data, out int size);
var doc = new BlittableJsonReaderObject(ptr, size, context);
var key = Encoding.UTF8.GetString(result.Reader.Read((int)ClusterStateMachine.CertificatesTable.Thumbprint, out size), size);
Transaction.DebugDisposeReaderAfterTransaction(tx, doc);
return(key, doc);
}