internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query,
QuerySession session)
{
if (_querySources.TryFind(query.GetType(), out var source))
{
return(source);
}
if (typeof(TOut).CanBeCastTo <Task>())
{
throw InvalidCompiledQueryException.ForCannotBeAsync(query.GetType());
}
var plan = QueryCompiler.BuildPlan(session, query, _store.Options);
var file = new CompiledQueryCodeFile(query.GetType(), _store, plan, _tracking);
var rules = _store.Options.CreateGenerationRules();
rules.ReferenceTypes(typeof(TDoc), typeof(TOut), query.GetType());
file.InitializeSynchronously(rules, _store, null);
source = file.Build(rules);
_querySources = _querySources.AddOrUpdate(query.GetType(), source);
return(source);
}
public void AppendServices(IServiceCollection services)
{
lock (_familyLock)
{
var(registry, scanners) = ScanningExploder.ExplodeSynchronously(services);
Scanners = Scanners.Union(scanners).ToArray();
registry
.Where(x => !x.ServiceType.HasAttribute <LamarIgnoreAttribute>())
.GroupBy(x => x.ServiceType)
.Each(group =>
{
if (_families.ContainsKey(group.Key))
{
var family = _families[group.Key];
if (family.Append(@group, DecoratorPolicies) == AppendState.NewDefault)
{
_byType = _byType.Remove(group.Key);
}
}
else
{
var family = buildFamilyForInstanceGroup(services, @group);
_families.Add(@group.Key, family);
}
});
buildOutMissingResolvers();
rebuildReferencedAssemblyArray();
}
}
public DocumentPersistence <T> StorageFor <T>()
{
if (_storage.TryFind(typeof(T), out var stored))
{
return(stored.As <DocumentPersistence <T> >());
}
var mapping = _options.Storage.FindMapping(typeof(T));
if (mapping is DocumentMapping m)
{
var builder = new DocumentPersistenceBuilder(m, _options);
var slot = builder.Generate <T>();
_storage = _storage.AddOrUpdate(typeof(T), slot);
return(slot);
}
if (mapping is SubClassMapping s)
{
var loader =
typeof(SubClassLoader <, ,>).CloseAndBuildAs <ISubClassLoader <T> >(mapping.Root.DocumentType, typeof(T),
mapping.IdType);
var slot = loader.BuildPersistence(this, s);
_storage = _storage.AddOrUpdate(typeof(T), slot);
return(slot);
}
throw new NotSupportedException("Unable to build document persistence handlers for " + mapping.DocumentType.FullNameInCode());
}
public void Append <T>(DocumentProvider <T> provider)
{
// This might cause Marten to re-check the database storage, but double dipping
// seems smarter than trying to be too clever and miss doing the check
_storage = _storage.Remove(typeof(T));
_inner.Append(provider);
}
public void Group()
{
lock (_groupingLock)
{
if (_hasGrouped)
{
return;
}
_calls.Where(x => TypeExtensions.IsConcrete(x.MessageType))
.GroupBy(x => x.MessageType)
.Select(group => new HandlerChain(@group))
.Each(chain =>
{
_chains = _chains.AddOrUpdate(chain.MessageType, chain);
});
_calls.Where(x => !TypeExtensions.IsConcrete(x.MessageType))
.Each(call =>
{
Chains
.Where(c => call.CouldHandleOtherMessageType(c.MessageType))
.Each(c => { c.AddAbstractedHandler(call); });
});
_hasGrouped = true;
}
}
private IAggregateFetchPlan <TDoc, TId> determineFetchPlan <TDoc, TId>() where TDoc : class
{
if (_fetchStrategies.TryFind(typeof(TDoc), out var stored))
{
return((IAggregateFetchPlan <TDoc, TId>)stored);
}
// All the IDocumentStorage types are codegen'd
// ReSharper disable once SuspiciousTypeConversion.Global
var documentProvider = _store.Options.Providers.StorageFor <TDoc>();
var storage = (IDocumentStorage <TDoc, TId>)documentProvider.IdentityMap;
IAggregateFetchPlan <TDoc, TId> plan;
if (_store.Options.Projections.DoesPersistAggregate(typeof(TDoc)))
{
plan = new FetchInlinedPlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage);
}
else
{
plan = new FetchLivePlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage);
}
_fetchStrategies = _fetchStrategies.AddOrUpdate(typeof(TDoc), plan);
return(plan);
}
/// Creates the branch node with known height
public Branch(int hash, K key, V value, ImHashMap <K, V> left, ImHashMap <K, V> right, int height)
: base(hash, key, value)
{
LeftNode = left;
RightNode = right;
BranchHeight = height;
}
public void AppendServices(IServiceCollection services)
{
lock (_familyLock)
{
applyScanners(services).Wait(TimeSpan.FromSeconds(2));
services
.Where(x => !x.ServiceType.HasAttribute <LamarIgnoreAttribute>())
.GroupBy(x => x.ServiceType)
.Each(group =>
{
if (_families.ContainsKey(group.Key))
{
var family = _families[group.Key];
if (family.Append(group) == AppendState.NewDefault)
{
_byType = _byType.Remove(group.Key);
}
}
else
{
var family = buildFamilyForInstanceGroup(services, @group);
_families.Add(@group.Key, family);
}
});
buildOutMissingResolvers();
rebuildReferencedAssemblyArray();
}
}
/// Creates branch with known heights of left and right
public Branch(int hash, K key, V value, int leftHeight, ImHashMap <K, V> left, int rightHeight, ImHashMap <K, V> right)
: base(hash, key, value)
{
LeftNode = left;
RightNode = right;
BranchHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
/// Creates the branch node with known height
internal ConflictsBranch(
int hash, K key, V value, KV <K, V>[] conflicts,
ImHashMap <K, V> left, ImHashMap <K, V> right, int height) :
base(hash, key, value, left, right, height)
{
Conflicts = conflicts;
}
public void Init()
{
var r = new Random(4);
_keys = new List <T>();
_immDict = ImmutableDictionary <T, int> .Empty;
_sasaTrie = Trie <T, int> .Empty;
_sGuh = ImmutableTrieDictionary.Create <T, int>();
_tvl = ImmutableTreeDictionary <T, int> .Empty;
_imToolsHashMap = ImHashMap <T, int> .Empty;
_apexHashMap = HashMap <T, int> .Empty;
for (int i = 0; i < Count; ++i)
{
var k = GenerateValue(r);
_immDict = _immDict.SetItem(k, i);
_sasaTrie = _sasaTrie.Add(k, i);
_sGuh = _sGuh.Add(k, i);
_tvl = _tvl.Add(k, i);
_imToolsHashMap = _imToolsHashMap.AddOrUpdate(k, i);
_apexHashMap = _apexHashMap.SetItem(k, i);
_keys.Add(k);
}
int n = _keys.Count;
while (n > 1)
{
n--;
int k = r.Next(n + 1);
var value = _keys[k];
_keys[k] = _keys[n];
_keys[n] = value;
}
}
public Cache(IDictionary <TKey, TValue> dictionary)
{
foreach (var pair in dictionary)
{
_values = _values.AddOrUpdate(pair.Key, pair.Value);
}
}
public DocumentProvider <T> StorageFor <T>() where T : notnull
{
var documentType = typeof(T);
if (_storage.TryFind(documentType, out var stored))
{
return(stored.As <DocumentProvider <T> >());
}
if (documentType == typeof(IEvent))
{
var slot = EventDocumentStorageGenerator.BuildProvider(_options);
_storage = _storage.AddOrUpdate(documentType, slot);
return(slot.As <DocumentProvider <T> >());
}
var mapping = _options.Storage.FindMapping(documentType);
switch (mapping)
{
case DocumentMapping m:
{
var builder = new DocumentPersistenceBuilder(m, _options);
var slot = builder.Generate <T>();
_storage = _storage.AddOrUpdate(documentType, slot);
return(slot);
}
case SubClassMapping s:
{
var loader =
typeof(SubClassLoader <, ,>).CloseAndBuildAs <ISubClassLoader <T> >(mapping.Root.DocumentType, documentType,
mapping.IdType);
var slot = loader.BuildPersistence(this, s);
_storage = _storage.AddOrUpdate(documentType, slot);
return(slot);
}
case EventMapping em:
{
var storage = (IDocumentStorage <T>)em;
var slot = new DocumentProvider <T> {
Lightweight = storage, IdentityMap = storage, DirtyTracking = storage, QueryOnly = storage
};
_storage = _storage.AddOrUpdate(documentType, slot);
return(slot);
}
default:
throw new NotSupportedException("Unable to build document persistence handlers for " + mapping.DocumentType.FullNameInCode());
}
}
public HandlerGraph()
{
// All of this is to seed the handler and its associated retry policies
// for scheduling outgoing messages
_handlers = _handlers.AddOrUpdate(typeof(Envelope), new ScheduledSendEnvelopeHandler());
GlobalPolicy <SagaFramePolicy>();
}
/// Creates branch with known height of right sub-tree
public Branch(int hash, K key, V value, ImHashMap <K, V> left, int rightHeight, ImHashMap <K, V> right)
: base(hash, key, value)
{
LeftNode = left;
RightNode = right;
var leftHeight = left == null ? 0 : left is Branch lb ? lb.BranchHeight : 1;
BranchHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
public void RouteToDestination(Envelope envelope)
{
if (!_destinations.TryFind(envelope.Destination, out var route))
{
route = DetermineDestinationRoute(envelope.Destination);
_destinations = _destinations.AddOrUpdate(envelope.Destination, route);
}
route.Configure(envelope);
}
public void Dispose()
{
foreach (var channel in _subscribers.Enumerate())
{
channel.Value.Dispose();
}
_subscribers = ImHashMap <Uri, ISubscriber> .Empty;
}
private ISendingAgent addQueue(IMessagingRoot root, ITransportRuntime runtime, LocalQueueSettings queue)
{
queue.Agent = buildAgent(queue, root);
_agents = _agents.AddOrUpdate(queue.Name, buildAgent(queue, root));
runtime.AddSendingAgent(buildAgent(queue, root));
runtime.AddSubscriber(queue);
return(queue.Agent);
}
public void Dispose()
{
foreach (var channel in _channels.Enumerate())
{
channel.Value.Dispose();
}
_channels = ImHashMap <Uri, IChannel> .Empty;
}
Task IGeneratesCode.AttachGeneratedTypes(GenerationRules rules, IServiceProvider services)
{
foreach (var chain in Chains)
{
var handler = chain.CreateHandler((IContainer)services);
_handlers = _handlers.Update(chain.MessageType, handler);
}
return(Task.CompletedTask);
}
/// <summary>
/// Register a database that will hold data for multiple conjoined tenants
/// </summary>
/// <param name="connectionString"></param>
/// <param name="databaseIdentifier">A descriptive name for this database. If omitted, this will be derived from the connection string</param>
/// <returns></returns>
public IDatabaseExpression AddMultipleTenantDatabase(string connectionString, string databaseIdentifier = null)
{
var builder = new NpgsqlConnectionStringBuilder(connectionString);
var identifier = databaseIdentifier ?? $"{builder.Database}@{builder.Host}";
var database = new MartenDatabase(Options, new ConnectionFactory(connectionString), identifier);
_databases = _databases.AddOrUpdate(identifier, database);
return(new DatabaseExpression(this, database));
}
public IntsAddBenchmark()
{
_numbers = new int[N];
for (int i = 0; i < _numbers.Length; i++)
{
_numbers[i] = _random.Next();
}
_sut = ImmutableDictionary <int, int> .Empty;
_sutBCL = ImmutableDictionaryBCL.Empty;
_sutIm = ImHashMap <int, int> .Empty;
}
public MessageRoute[] Route(Type messageType)
{
if (_routes.TryFind(messageType, out var routes))
{
return(routes);
}
routes = compileRoutes(messageType).ToArray();
_routes = _routes.AddOrUpdate(messageType, routes);
return(routes);
}
internal IEnumerable <Type> GetTypeDependencies(Type type)
{
if (_typeDependencies.TryFind(type, out var deps))
{
return(deps);
}
deps = determineTypeDependencies(type);
_typeDependencies = _typeDependencies.AddOrUpdate(type, deps);
return(deps);
}
public static Task <AssemblyTypes> ForAssembly(Assembly assembly)
{
if (_assemblies.TryFind(assembly, out var types))
{
return(types);
}
types = Task.Factory.StartNew(() => new AssemblyTypes(assembly));
_assemblies = _assemblies.AddOrUpdate(assembly, types);
return(types);
}
public async Task <MessageRoute[]> Route(Type messageType)
{
if (_routes.TryFind(messageType, out var routes))
{
return(routes);
}
routes = (await compileRoutes(messageType)).ToArray();
_routes = _routes.AddOrUpdate(messageType, routes);
return(routes);
}
public ReaderCollection <TReader> ReaderFor(string messageType)
{
if (_modelReaders.TryFind(messageType, out var reader))
{
return(reader);
}
var modelReader = compileReader(messageType);
_modelReaders = _modelReaders.AddOrUpdate(messageType, modelReader);
return(modelReader);
}
public WriterCollection <TWriter> WriterFor(Type messageType)
{
if (_modelWriters.TryFind(messageType, out var writer))
{
return(writer);
}
var modelWriter = compileWriter(messageType);
_modelWriters = _modelWriters.AddOrUpdate(messageType, modelWriter);
return(modelWriter);
}
public void AddSingleTenantDatabase(string connectionString, string tenantId)
{
var database = new MartenDatabase(Options, new ConnectionFactory(connectionString), tenantId);
_databases = _databases.AddOrUpdate(tenantId, database);
var expression = new DatabaseExpression(this, database).ForTenants(tenantId);
if (Default == null)
{
expression.AsDefault();
}
}
private void buildInitialSendingAgents(IMessagingRoot root)
{
foreach (var subscriberAddress in root.Settings.KnownSubscribers)
{
var transport = _transports[subscriberAddress.Uri.Scheme];
var agent = transport.BuildSendingAgent(subscriberAddress.Uri, root, _settings.Cancellation);
var channel = new Channel(_logger, subscriberAddress, transport.LocalReplyUri, agent);
_channels = _channels.AddOrUpdate(subscriberAddress.Uri, channel);
}
}
