private void findCurrentEventLogPositions() { using (var conn = _tenant.OpenConnection()) { var cmd = new NpgsqlCommand($"select name, last_seq_id from {_store.Events.ProgressionTable}"); using (var reader = conn.ExecuteReader(cmd)) { while (reader.Read()) { var name = reader.GetFieldValue <string>(0); var lastEncountered = reader.GetFieldValue <long>(1); var track = _tracks.Values.FirstOrDefault(x => x.ProgressionName == name); if (track != null) { track.LastEncountered = lastEncountered; } } } } foreach (var track in _tracks.Values) { Logger.DeterminedStartingPosition(track); } }
public void All <T>(string transformName) { var transform = _tenant.TransformFor(transformName); var mapping = _tenant.MappingFor(typeof(T)); var cmd = CommandBuilder.BuildCommand(sql => { writeBasicSql(sql, mapping, transform); var where = mapping.ToQueryableDocument().DefaultWhereFragment(); if (where != null) { sql.Append(" where "); where.Apply(sql); } }); using (var conn = _tenant.OpenConnection()) { conn.Execute(cmd, c => { c.ExecuteNonQuery(); }); } }
public void DeleteAllDocuments() { var dbObjects = new DbObjects(_tenant, _options.Storage); using (var conn = _tenant.OpenConnection(CommandRunnerMode.Transactional)) { dbObjects.DocumentTables().Each(tableName => { var sql = "truncate {0} cascade".ToFormat(tableName); conn.Execute(sql); }); conn.Commit(); } }
private static IManagedConnection buildManagedConnection(SessionOptions options, ITenant tenant, CommandRunnerMode commandRunnerMode) { // Hate crap like this, but if we don't control the transation, use External to direct // IManagedConnection not to call commit or rollback if (!options.OwnsTransactionLifecycle && commandRunnerMode != CommandRunnerMode.ReadOnly) { commandRunnerMode = CommandRunnerMode.External; } if (options.Transaction != null) { options.Connection = options.Transaction.Connection; } if (options.Connection == null) { return(tenant.OpenConnection(commandRunnerMode, options.IsolationLevel, options.Timeout)); } else { return(new ManagedConnection(options, commandRunnerMode)); } }
public void DeleteAllEventData() { using var connection = _tenant.OpenConnection(CommandRunnerMode.Transactional); var deleteEventDataSql = toDeleteEventDataSql(); connection.Execute(deleteEventDataSql); connection.Commit(); }
public async Task <HighWaterStatistics> DetectInSafeZone(DateTimeOffset safeTimestamp, CancellationToken token) { await using var conn = _tenant.OpenConnection(); var statistics = await loadCurrentStatistics(conn, token); _safeTimestamp.Value = safeTimestamp; using (var reader = await conn.ExecuteReaderAsync(_findSafeSequence, token)) { if (await reader.ReadAsync(token)) { statistics.SafeStartMark = await reader.GetFieldValueAsync <long>(0, token); } } await calculateHighWaterMark(token, statistics, conn); return(statistics); }
public void CompletelyRemoveAll() { var dbObjects = new DbObjects(_tenant, _options.Storage); using (var connection = _tenant.OpenConnection(CommandRunnerMode.Transactional)) { var schemaTables = dbObjects.SchemaTables(); schemaTables .Each(tableName => { connection.Execute($"DROP TABLE IF EXISTS {tableName} CASCADE;"); }); var allSchemas = new object[] { _options.Storage.AllSchemaNames() }; var drops = connection.GetStringList(DropAllFunctionSql, allSchemas) .Concat(connection.GetStringList(DropAllSequencesSql, allSchemas)); drops.Each(drop => connection.Execute(drop)); connection.Commit(); _tenant.ResetSchemaExistenceChecks(); } }
private static IManagedConnection buildManagedConnection(SessionOptions options, ITenant tenant, CommandRunnerMode commandRunnerMode) { // TODO -- this is all spaghetti code. Make this some kind of more intelligent state machine // w/ the logic encapsulated into SessionOptions // Hate crap like this, but if we don't control the transation, use External to direct // IManagedConnection not to call commit or rollback if (!options.OwnsTransactionLifecycle && commandRunnerMode != CommandRunnerMode.ReadOnly) { commandRunnerMode = CommandRunnerMode.External; } if (options.Connection != null || options.Transaction != null) { options.OwnsConnection = false; } if (options.Transaction != null) { options.Connection = options.Transaction.Connection; } #if NET46 || NETSTANDARD2_0 if (options.Connection == null && options.DotNetTransaction != null) { var connection = tenant.CreateConnection(); connection.Open(); options.OwnsConnection = true; options.Connection = connection; } if (options.DotNetTransaction != null) { options.Connection.EnlistTransaction(options.DotNetTransaction); options.OwnsTransactionLifecycle = false; } #endif if (options.Connection == null) { return(tenant.OpenConnection(commandRunnerMode, options.IsolationLevel, options.Timeout)); } else { return(new ManagedConnection(options, commandRunnerMode)); } }
public void Generate(StoreOptions options, string[] schemaNames) { if (schemaNames == null) { throw new ArgumentNullException(nameof(schemaNames)); } var sql = GenerateScript(options, schemaNames); if (sql != null) { using (var runner = _tenant.OpenConnection()) { runner.Execute(sql); } } }
private static IManagedConnection buildManagedConnection(SessionOptions options, ITenant tenant, CommandRunnerMode commandRunnerMode) { // Hate crap like this, but if we don't control the transation, use External to direct // IManagedConnection not to call commit or rollback if (!options.OwnsTransactionLifecycle && commandRunnerMode != CommandRunnerMode.ReadOnly) { commandRunnerMode = CommandRunnerMode.External; } if (options.Transaction != null) { options.Connection = options.Transaction.Connection; } #if NET46 || NETSTANDARD2_0 if (options.Connection == null && options.DotNetTransaction != null) { var connection = tenant.CreateConnection(); connection.Open(); options.Connection = connection; } if (options.DotNetTransaction != null) { options.Connection.EnlistTransaction(options.DotNetTransaction); options.OwnsTransactionLifecycle = false; } #endif if (options.Connection == null) { return(tenant.OpenConnection(commandRunnerMode, options.IsolationLevel, options.Timeout)); } else { return(new ManagedConnection(options, commandRunnerMode)); } }
private async Task clearExistingState(CancellationToken token) { _logger.ClearingExistingState(this); var types = _projection.ProjectedTypes(); using (var conn = _tenant.OpenConnection()) { foreach (var type in types) { var tableName = _tenant.MappingFor(type).TableName; var sql = $"delete from {_store.Events.DatabaseSchemaName}.mt_event_progression where name = :name;truncate {tableName} cascade"; var cmd = new NpgsqlCommand(sql).With("name", _projection.GetEventProgressionName(type)); await conn.ExecuteAsync(cmd, token); } } LastEncountered = 0; }
private async Task clearExistingState(CancellationToken token) { _logger.ClearingExistingState(this); var tableName = _tenant.MappingFor(_projection.Produces).Table; var sql = $"delete from {_store.Events.DatabaseSchemaName}.mt_event_progression where name = :name;truncate {tableName} cascade"; using (var conn = _tenant.OpenConnection()) { await conn.ExecuteAsync(async (cmd, tkn) => { await cmd.Sql(sql) .With("name", _projection.Produces.FullName) .ExecuteNonQueryAsync(tkn) .ConfigureAwait(false); }, token).ConfigureAwait(false); } LastEncountered = 0; }
public ProjectionDocumentSession(DocumentStore store, ITenant tenant, ISessionWorkTracker workTracker) : base( store, new SessionOptions { Tracking = DocumentTracking.None }, tenant.OpenConnection(), tenant, workTracker) { }
public IManagedConnection OpenConnection(CommandRunnerMode mode = CommandRunnerMode.AutoCommit, IsolationLevel isolationLevel = IsolationLevel.ReadCommitted, int?timeout = null) { return(_inner.OpenConnection(mode, isolationLevel, timeout)); }