protected override void InternalStop(ServerProcess process) { base.InternalStop(process); if (_store != null) { _store.Dispose(); _store = null; } }
protected override void InternalStart(ServerProcess process) { base.InternalStart(process); if (!process.ServerSession.Server.IsEngine) { _store = new CatalogStore(); _store.StoreClassName = ((Server.Server)process.ServerSession.Server).GetCatalogStoreClassName(); _store.StoreConnectionString = ((Server.Server)process.ServerSession.Server).GetCatalogStoreConnectionString(); _store.Initialize(process.ServerSession.Server); } }
public void RunCatalogStoreTest(string connectionString, CatalogStore catalogStore = CatalogStore.InMemory) { try { DatabaseCatalogContext databaseCatalog = new DatabaseCatalogContext(); Stopwatch stopwatch = Stopwatch.StartNew(); databaseCatalog.LoadCatalog(connectionString, catalogStore); stopwatch.Stop(); Console.WriteLine("Loading: {0}", stopwatch.Elapsed.TotalSeconds); } catch (Exception e) { Console.WriteLine(e); throw; } }
public IActionResult Find(int id) => Ok(CatalogStore.Find(id));
public void LoadCatalog(string connectionString, CatalogStore catalogStore) { if (catalogStore == CatalogStore.File) { _connectionString = string.Format("DataSource=file:{0}.dacmodel;Cache=Shared", _connectionId); } else { _connectionString = string.Format("DataSource=file:{0}.dacmodel;Mode=Memory;Cache=Shared", _connectionId); } _sqliteConnection = new SqliteConnection(_connectionString); _sqliteConnection.Open(); using (SqliteCommand command = _sqliteConnection.CreateCommand()) { // Enable write-ahead logging to increase write performance by reducing amount of disk writes, // by combining writes at checkpoints, along with using sequential-only writes to populate the log. // Also, WAL allows for relaxed ("normal") "synchronous" mode, see below. command.CommandText = "pragma journal_mode=wal"; command.ExecuteNonQuery(); // Set "synchronous" mode to "normal" instead of default "full" to reduce the amount of buffer flushing syscalls, // significantly reducing both the blocked time and the amount of context switches. // When coupled with WAL, this (according to https://sqlite.org/pragma.html#pragma_synchronous and // https://www.sqlite.org/wal.html#performance_considerations) is unlikely to significantly affect durability, // while significantly increasing performance, because buffer flushing is done for each checkpoint, instead of each // transaction. While some writes can be lost, they are never reordered, and higher layers will recover from that. command.CommandText = "pragma synchronous=normal"; command.ExecuteNonQuery(); } this.InitializeSQLite(); // Takes about .15 seconds. We could pre-create the file. using (SqlConnection connection = new SqlConnection(connectionString)) { connection.Open(); _serverInfo = GetServerInfo(connection); if (_serverInfo.IsManagedInstance) { throw new NotSupportedException("Managed Instance is not supported."); } if (_serverInfo.IsAzure) { this.LoadAzure(connection); } else if (_serverInfo.Version.Major == 15) { this.LoadvNext(connection); } else if (_serverInfo.Version.Major == 14) { this.Load2017(connection); } else if (_serverInfo.Version.Major == 13) { this.Load2016(connection); } else if (_serverInfo.Version.Major == 12) { this.Load2014(connection); } else if (_serverInfo.Version.Major == 11) { this.Load2012(connection); } else if (_serverInfo.Version.Major == 10) { this.Load2008(connection); } else if (_serverInfo.Version.Major == 9) { this.Load2005(connection); } else { throw new NotSupportedException(string.Format("Server version {0} is not supported.", _serverInfo.Version)); } } }