public static SessionOptions ForDatabase(IMartenDatabase @database)
{
return(new SessionOptions
{
Tenant = new Tenant(Tenancy.DefaultTenantId, @database), AllowAnyTenant = true, OwnsConnection = true, OwnsTransactionLifecycle = true, Tracking = DocumentTracking.None
});
}
public async ValueTask <EventRangeGroup> GroupEvents(DocumentStore store, IMartenDatabase database, EventRange range,
CancellationToken cancellationToken)
{
var groups = await GroupEventRange(store, database, range, cancellationToken).ConfigureAwait(false);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
internal IEnumerable <IFeatureSchema> AllActiveFeatures(IMartenDatabase database)
{
yield return(SystemFunctions);
var mappings = _documentMappings.Value
.Enumerate().Select(x => x.Value)
.OrderBy(x => x.DocumentType.Name)
.TopologicalSort(m => m.ReferencedTypes()
.Select(MappingFor));
foreach (var mapping in mappings)
{
yield return(mapping.Schema);
}
if (SequenceIsRequired())
{
yield return(database.Sequences);
}
if (_options.Events.As <EventGraph>().IsActive(_options))
{
yield return(_options.EventGraph);
}
var custom = _features.Values
.Where(x => x.GetType().Assembly != GetType().Assembly).ToArray();
foreach (var featureSchema in custom)
{
yield return(featureSchema);
}
}
public override async ValueTask SkipEventSequence(long eventSequence, IMartenDatabase database)
{
reset();
Range.SkipEventSequence(eventSequence);
Groups = await _runtime.GroupEventRange(_store, database, Range, Cancellation).ConfigureAwait(false);
}
public Publisher(IDocumentStore store, IMartenDatabase database, StatusBoard board)
{
_store = store;
_database = database;
_board = board;
var storeName = store.GetType() == typeof(DocumentStore) ? "Marten" : store.GetType().NameInCode();
_name = $"{storeName}:{_database.Identifier}";
}
public TenantedEventRangeGroup(IDocumentStore store, IMartenDatabase daemonDatabase, IProjection projection,
EventRange range,
CancellationToken shardCancellation) : base(range, shardCancellation)
{
_store = (DocumentStore)store;
_daemonDatabase = daemonDatabase;
_projection = projection ?? throw new ArgumentNullException(nameof(projection));
buildGroups();
}
public HiloSequence(IMartenDatabase database, StoreOptions options, string entityName, HiloSettings settings)
{
_database = database;
_options = options;
_entityName = entityName;
CurrentHi = -1;
CurrentLo = 1;
MaxLo = settings.MaxLo;
_settings = settings;
}
public async Task ApplySkipAsync(SkipEvent skip, IMartenDatabase database)
{
if (Group != null)
{
await Group.SkipEventSequence(skip.Event.Sequence, database).ConfigureAwait(false);
// You have to reset the CancellationToken for the group
Group.Reset();
Cancellation = Group.Cancellation;
}
// Basically saying that the attempts start over when we skip
Attempts = 0;
Delay = default;
}
public void TruncateDocumentStorage(IMartenDatabase database)
{
try
{
var sql = "truncate {0} cascade".ToFormat(TableName.QualifiedName);
database.RunSql(sql);
}
catch (PostgresException e)
{
if (!e.Message.Contains("does not exist"))
{
throw;
}
}
}
public async Task TruncateDocumentStorageAsync(IMartenDatabase database)
{
var sql = "truncate {0} cascade".ToFormat(TableName.QualifiedName);
try
{
await database.RunSqlAsync(sql).ConfigureAwait(false);
}
catch (PostgresException e)
{
if (!e.Message.Contains("does not exist"))
{
throw;
}
}
}
public EventFetcher(IDocumentStore store, IMartenDatabase database, ISqlFragment[] filters)
{
_store = store;
_database = database;
_filters = filters;
using var session = querySession();
_storage = session.EventStorage();
var schemaName = store.Options.Events.DatabaseSchemaName;
var builder = new CommandBuilder();
builder.Append($"select {_storage.SelectFields().Select(x => "d." + x).Join(", ")}, s.type as stream_type");
builder.Append($" from {schemaName}.mt_events as d inner join {schemaName}.mt_streams as s on d.stream_id = s.id");
if (_store.Options.Events.TenancyStyle == TenancyStyle.Conjoined)
{
builder.Append(" and d.tenant_id = s.tenant_id");
}
var parameters = builder.AppendWithParameters($" where d.seq_id > ? and d.seq_id <= ?");
_floor = parameters[0];
_ceiling = parameters[1];
_floor.NpgsqlDbType = _ceiling.NpgsqlDbType = NpgsqlDbType.Bigint;
foreach (var filter in filters)
{
builder.Append(" and ");
filter.Apply(builder);
}
builder.Append(" order by d.seq_id");
_command = builder.Compile();
_aggregateIndex = _storage.SelectFields().Length;
}
public override ValueTask SkipEventSequence(long eventSequence, IMartenDatabase database)
{
Range.SkipEventSequence(eventSequence);
Groups.Clear();
buildGroups();
return(default);
public async ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, TId> > > GroupEventRange(DocumentStore store,
IMartenDatabase database, EventRange range, CancellationToken cancellation)
{
await using var session = store.OpenSession(SessionOptions.ForDatabase(database));
return(await Slicer.SliceAsyncEvents(session, range.Events).ConfigureAwait(false));
}
public EventFetcherException(ShardName name, IMartenDatabase martenDatabase, Exception innerException) : base($"Failure while trying to load events for projection shard '{name}@{martenDatabase.Identifier}'", innerException)
{
}
protected override ValueTask <EventRangeGroup> groupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
_runtime ??= BuildRuntime(store);
return(_runtime.GroupEvents(store, daemonDatabase, range, cancellationToken));
}
async ValueTask <EventRangeGroup> IAggregationRuntime.GroupEvents(DocumentStore store, IMartenDatabase database, EventRange range,
CancellationToken cancellationToken)
{
using var session = store.OpenSession(SessionOptions.ForDatabase(database));
var groups = await Slicer.SliceAsyncEvents(session, range.Events).ConfigureAwait(false);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public abstract TId AssignIdentity(T document, string tenantId, IMartenDatabase database);
public Task TruncateDocumentStorageAsync(IMartenDatabase database)
{
return(database.RunSqlAsync(
$"delete from {_parent.TableName.QualifiedName} where {SchemaConstants.DocumentTypeColumn} = '{_mapping.Alias}'"));
}
public StorageCheckingProviderGraph(IMartenDatabase tenant, IProviderGraph inner)
{
Tenant = tenant;
_inner = inner;
}
public override ValueTask SkipEventSequence(long eventSequence, IMartenDatabase database)
{
throw new NotSupportedException();
}
public void TruncateDocumentStorage(IMartenDatabase database)
{
database.RunSql($"truncate table {Events.DatabaseSchemaName}.mt_streams cascade");
}
public HotColdCoordinator(IMartenDatabase database, DaemonSettings settings, ILogger logger)
{
_settings = settings;
_logger = logger;
_database = database;
}
public AutoOpenSingleQueryRunner(IMartenDatabase database)
{
_database = database;
}
public ValueTask <EventRangeGroup> GroupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
return(new ValueTask <EventRangeGroup>(new TenantedEventRangeGroup(store, daemonDatabase, _projection, range, cancellationToken)));
}
public abstract ValueTask SkipEventSequence(long eventSequence, IMartenDatabase database);
public void TruncateDocumentStorage(IMartenDatabase database)
{
var sql = "truncate {0} cascade".ToFormat(TableName.QualifiedName);
database.RunSql(sql);
}
protected override ValueTask <EventRangeGroup> groupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
return(new ValueTask <EventRangeGroup>(new TenantedEventRangeGroup(store, daemonDatabase, _generatedProjection.Value, range, cancellationToken)));
}
public Task TruncateDocumentStorageAsync(IMartenDatabase database)
{
var sql = "truncate {0} cascade".ToFormat(TableName.QualifiedName);
return(database.RunSqlAsync(sql));
}
public Task TruncateDocumentStorageAsync(IMartenDatabase database)
{
return(database.RunSqlAsync($"truncate table {Events.DatabaseSchemaName}.mt_streams cascade"));
}
public void TruncateDocumentStorage(IMartenDatabase database)
{
database.RunSql(
$"delete from {_parent.TableName.QualifiedName} where {SchemaConstants.DocumentTypeColumn} = '{_mapping.Alias}'");
}
