public override bool Open (String path) { var connectionString = new SqliteConnectionStringBuilder { DataSource = path, Version = 3, SyncMode = SynchronizationModes.Full }; var result = true; try { shouldCommit = false; Connection = new SqliteConnection (connectionString.ToString ()); Connection.Open(); } catch (Exception ex) { Log.E(Tag, "Error opening the Sqlite connection using connection String: {0}".Fmt(connectionString.ToString()), ex); result = false; } return result; }
public void SearchCustomer_SearchByJohn() { var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connection = new SqliteConnection(connectionStringBuilder.ToString()); var options = new DbContextOptionsBuilder <CustomerDBContext>() .UseSqlite(connection) .Options; using (var context = new CustomerDBContext(options)) { context.Database.OpenConnection(); context.Database.EnsureCreated(); context.Customers.AddRange(new[] { new Customer() { FirstName = "Syed", LastName = "Majeeduddin", DOB = DateTime.Now.AddYears(-25) }, new Customer() { FirstName = "John", LastName = "Syed", DOB = DateTime.Now.AddYears(-35) } }); context.SaveChanges(); var customerRepository = new CustomerRepository(context); // Act var customers = customerRepository.FindCustomerByName("Syed"); // Assert Assert.Equal(2, customers.Result.Count); } }
public FolderRepositoryTests() { var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connectionString = connectionStringBuilder.ToString(); var connection = new SqliteConnection(connectionString); DbContextOptions <ApplicationDbContext> options; var builder = new DbContextOptionsBuilder <ApplicationDbContext>(); builder.UseSqlite(connection); options = builder.Options; var context = new ApplicationDbContext(options); context.Database.OpenConnection(); context.Database.EnsureCreated(); // Add project for the folder to use var project = new Project { Name = "TestProject" }; context.Add(project); // Add test Folders var folders = Enumerable.Range(1, folderCount) .Select(i => new Folder { Id = i, ProjectID = project.Id, Name = $"Name{i}" }); context.AddRange(folders); int changed = context.SaveChanges(); _context = context; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddSampleData(); services.Configure <CookiePolicyOptions>(options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); var connectionString = Configuration.GetConnectionString("DefaultConnection"); var builder = new SqliteConnectionStringBuilder(connectionString); builder.DataSource = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, builder.DataSource)); connectionString = builder.ToString(); services.AddDbContext <ApplicationDbContext>(options => options.UseSqlite(connectionString) ); services.AddDefaultIdentity <IdentityUser>() .AddDefaultUI() .AddRoles <IdentityRole>() .AddEntityFrameworkStores <ApplicationDbContext>(); services.AddGraphity <AnimalContext>(options => { options.AddHasRolesAuthorisationPolicy("admin-policy", "admin"); options.AddHasRolesAuthorisationPolicy("user-policy", ""); options.ConfigureSet(ctx => ctx.Animals) .SetAuthorisationPolicy("admin-policy"); options.ConfigureSet(ctx => ctx.Countries) .SetAuthorisationPolicy("user-policy"); }); services.AddMvc(); }
public static TestBudget CreateBudget(BudgetBackends budgetBackend, Budget initialBudget = null) { TestBudget testBudget = null; if (budgetBackend == BudgetBackends.Memory) { testBudget = new TestBudget(); testBudget.DeviceID = Guid.NewGuid(); testBudget.EventStore = new TestEventStore(new MemoryEventStore()); testBudget.BudgetStore = new MemoryBudgetStore(testBudget.EventStore); } else if (budgetBackend == BudgetBackends.SQLite) { testBudget = new TestBudget(); testBudget.DeviceID = Guid.NewGuid(); SqliteConnectionStringBuilder builder = new SqliteConnectionStringBuilder(); builder.Mode = SqliteOpenMode.Memory; builder.Cache = SqliteCacheMode.Shared; builder.DataSource = "BudgetTests"; testBudget.BudgetStore = new SQLiteBudgetStore(testBudget.DeviceID, builder.ToString(), (es) => new TestEventStore(es)); testBudget.EventStore = testBudget.BudgetStore.EventStore as TestEventStore; } if (initialBudget == null) { initialBudget = InitializeBudget(); } testBudget.BudgetModel = BudgetModel.CreateNew(testBudget.DeviceID, testBudget.BudgetStore, initialBudget); testBudget.BudgetModel.SaveChanges(); testBudget.EventStore.TestEvents.Clear(); testBudget.TestEvents = testBudget.EventStore.TestEvents; testBudget.Budget = initialBudget; return(testBudget); }
static void Main(string[] args) { //Create Connection var cStrBuilder = new SqliteConnectionStringBuilder(); cStrBuilder.DataSource = "./myDb.db"; using (var Connection = new SqliteConnection(cStrBuilder.ConnectionString)){ //want to use using so it closes after it's done Connection.Open(); //create table var tableCmd = Connection.CreateCommand(); tableCmd.CommandText = "CREATE TABLE stores(name VARCHAR(50));"; tableCmd.ExecuteNonQuery(); //Insert Some Records using (var transaction = Connection.BeginTransaction()){ var insertCmd = Connection.CreateCommand(); insertCmd.CommandText = "INSERT INTO stores VALUES('chico books')"; insertCmd.ExecuteNonQuery(); insertCmd.CommandText = "INSERT INTO stores VALUES('Santa Cruz books')"; insertCmd.ExecuteNonQuery(); transaction.Commit(); } var selectCmd = Connection.CreateCommand(); selectCmd.CommandText = "SELECT * FROM stores"; using (var reader = selectCmd.ExecuteReader()){ while (reader.Read()) { var result = reader.GetString(0);// getting the first column data[0] Console.WriteLine(result); } } } // Insert records // Read Records }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // thanks to https://exceptionnotfound.net/setting-a-custom-default-page-in-asp-net-core-razor-pages/ services.AddMvc().AddRazorPagesOptions(options => { options.Conventions.AddPageRoute("/Home/Index", ""); }); //-------------------------------------------------------------------- //var connection = Configuration.GetConnectionString("DefaultConnection"); //Swapped over to sqlite in-memory database var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connectionString = connectionStringBuilder.ToString(); var connection = new SqliteConnection(connectionString); connection.Open(); //see https://github.com/aspnet/EntityFramework/issues/6968 services.AddDbContext <EfCoreContext>(options => options.UseSqlite(connection)); //-------------------------------------------------------------------- services.GenericServicesSimpleSetup <EfCoreContext>(Assembly.GetAssembly(typeof(BookListDto))); //This is the version you would use if you were registering multiple DbContext //services.ConfigureGenericServicesEntities(typeof(BookDbContext), typeof(OrderDbContext)) // .ScanAssemblesForDtos(Assembly.GetAssembly(typeof(BookListDto))) // .RegisterGenericServices(); //-------------------------------------------------------------------------------------------- //I removed the code below, as this was only needed for the hand-coded versions of the services ////Now I use AutoFac to do some of the more complex registering of services //var containerBuilder = new ContainerBuilder(); ////Now I use the ServiceLayer AutoFac module that registers all the other DI items, such as my biz logic //containerBuilder.RegisterModule(new ServiceLayerModule()); //containerBuilder.Populate(services); //var container = containerBuilder.Build(); //return new AutofacServiceProvider(container); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { //optionsBuilder.UseLoggerFactory(_loggerFactory) // .EnableSensitiveDataLogging(); if (string.IsNullOrEmpty(_ConnectionString)) { string currentPath = Utilities.OperatingDirectory; // allows the application to find the database file currentPath = !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? $"{Path.DirectorySeparatorChar}{currentPath}" : currentPath; var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = Path.Join(currentPath, "Database", "Database.db") }; var connectionString = connectionStringBuilder.ToString(); var connection = new SqliteConnection(connectionString); if (!optionsBuilder.IsConfigured) { optionsBuilder.UseSqlite(connection); } } else { switch (_provider) { default: case "mysql": optionsBuilder.UseMySql(_ConnectionString, _options => _options.EnableRetryOnFailure()); break; case "postgresql": optionsBuilder.UseNpgsql(_ConnectionString, _options => _options.EnableRetryOnFailure()); break; } } }
protected SqlHelper(String tableName) { Directory.CreateDirectory(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "SolderHelper")); String databaseName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "SolderHelper", "SolderHelper.db"); try { if (!File.Exists(databaseName)) { if (IsUnix()) { SqliteConnection.CreateFile(databaseName); } else { SQLiteConnection.CreateFile(databaseName); } } } catch (Exception) { // ignored } if (IsUnix()) { SqliteConnectionStringBuilder c = new SqliteConnectionStringBuilder { DataSource = databaseName }; ConnectionString = c.ConnectionString; } else { SQLiteConnectionStringBuilder c = new SQLiteConnectionStringBuilder { DataSource = databaseName }; ConnectionString = c.ConnectionString; } TableName = tableName; }
public SQLiteDbContextOptions(DbOptions dbOptions, DbModuleOptions options, ILoggerFactory loggerFactory, ILoginInfo loginInfo) : base(dbOptions, options, new SQLiteAdapter(dbOptions, options), loggerFactory, loginInfo) { SqlMapper.AddTypeHandler <Guid>(new GuidTypeHandler()); options.Version = dbOptions.Version; string dbFilePath = Path.Combine(AppContext.BaseDirectory, "Db"); if (DbOptions.Server.NotNull()) { dbFilePath = Path.GetFullPath(DbOptions.Server); } dbFilePath = Path.Combine(dbFilePath, options.Database); var connStrBuilder = new SqliteConnectionStringBuilder { DataSource = $"{dbFilePath}.db", Mode = SqliteOpenMode.ReadWriteCreate }; options.ConnectionString = connStrBuilder.ToString(); }
public void AddCustomer_ReturnsCustomerByName() { var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connection = new SqliteConnection(connectionStringBuilder.ToString()); var options = new DbContextOptionsBuilder <CustomerDBContext>() .UseSqlite(connection) .Options; using (var context = new CustomerDBContext(options)) { context.Database.OpenConnection(); context.Database.EnsureCreated(); context.Customers.AddRange(new[] { new Customer() { FirstName = "Syed", LastName = "Majeeduddin", DOB = DateTime.Now.AddYears(-25) } }); context.SaveChanges(); var customerRepository = new CustomerRepository(context); var dto = new CustomerDto() { FirstName = "Mathew", LastName = "Hayden", DateOfBirth = Convert.ToDateTime("1982/12/10") }; // Act var customer = customerRepository.AddCustomer(dto); // Assert Assert.Equal("Mathew", (customer.Result).FirstName); } }
static ConnectionFactories() { Factories.Add(new OrmConnectionFactory(new MySqlDialectProvider(), "server=localhost;user=root;password=depfac$2000;database=test")); Factories.Add(new OrmConnectionFactory(new MySqlConnectorDialectProvider(), "server=localhost;user=root;password=depfac$2000;database=test2")); Factories.Add(new OrmConnectionFactory(new SqlServerDialectProvider(), @"server=localhost;User id=sa;Password=depfac$2000;database=test")); Factories.Add(new OrmConnectionFactory(new PostgreSQLDialectProvider(), "server=localhost;user id=postgres;password=depfac$2000;database=test;Enlist=true")); var builder = new SqliteConnectionStringBuilder(); builder = new SqliteConnectionStringBuilder(); builder.DataSource = Path.Combine(Path.GetTempPath(), "test2.db"); builder.Mode = SqliteOpenMode.ReadWriteCreate; builder.Cache = SqliteCacheMode.Shared; Factories.Add(new OrmConnectionFactory(new SqliteDialectProvider(), builder.ToString())); Factories.Add(new OrmConnectionFactory(new SDSQLite.SqliteDialectProvider(), $"Data Source={Path.Combine(Path.GetTempPath(), "test.db")};foreign keys=true;Version=3;New=True;BinaryGUID=False")); }
public IActionResult DatosEnvioEnviar(Envio envio) { string userEmail = User.FindFirst(ClaimTypes.Name).Value; var connectionBuilder = new SqliteConnectionStringBuilder(); connectionBuilder.DataSource = "Proyecto.db"; using (var con = new SqliteConnection(connectionBuilder.ConnectionString)) { con.Open(); string query = "INSERT INTO DetallesPedido (direccion, contacto,latitud,longitud,comentario, userEmail) values('" + envio.Direccion + "', '" + envio.DatosContacto + "','" + envio.Latitud + "', '" + envio.Longitud + "','" + envio.Comentario + "','" + userEmail + "')"; var cmd = new SqliteCommand(query, con); cmd.ExecuteNonQuery(); string query2 = "select * from carrito where idUsuario =(select id from usuario where email =\'" + userEmail + "\')"; var cmd2 = new SqliteCommand(query2, con); var reader = cmd2.ExecuteReader(); while (reader.Read()) { string nombre = String.Format("{0}", reader["nombre"]); string idProducto = String.Format("{0}", reader["idProducto"]); int cantidad = Int32.Parse(String.Format("{0}", reader["cantidad"])); string email = userEmail; double precio = Double.Parse(String.Format("{0}", reader["precio"])); double total = cantidad * precio; string query3 = "insert into CarroPedido (nombre, idProducto,cantidad, userEmail,total) values('" + nombre + "', '" + idProducto + "', + '" + cantidad + "', '" + email + "', '" + total + "')"; var cmd3 = new SqliteCommand(query3, con); cmd3.ExecuteNonQuery(); } con.Close(); } return(RedirectToAction("DatosEnvio")); }
public void CreateTable(string command, string path) { var connectionStringBuilder = new SqliteConnectionStringBuilder(); //Use DB in project directory. If it does not exist, create it: connectionStringBuilder.DataSource = path; using (var connection = new SqliteConnection(connectionStringBuilder.ConnectionString)) { connection.Open(); //Create a table (drop if already exists first): var delTableCmd = connection.CreateCommand(); delTableCmd.CommandText = "DROP TABLE IF EXISTS favorite_beers"; delTableCmd.ExecuteNonQuery(); var createTableCmd = connection.CreateCommand(); createTableCmd.CommandText = "CREATE TABLE favorite_beers(name VARCHAR(50))"; createTableCmd.ExecuteNonQuery(); } }
public TestFixture() { _server = new TestServer(WebHost.CreateDefaultBuilder() .UseStartup <Startup>() .UseEnvironment("Development")); _client = _server.CreateClient(); var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connectionString = connectionStringBuilder.ToString(); var connection = new SqliteConnection(connectionString); var optionsBuilder = new DbContextOptionsBuilder <AppDbContext>(); optionsBuilder.UseSqlite(connection); _db = new AppDbContext(optionsBuilder.Options, true); _db.Database.OpenConnection(); _db.Database.EnsureCreated(); }
public async Task ToBeCreated() { var sb = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connection = new SqliteConnection(sb.ToString()); var options = new DbContextOptionsBuilder <LibraryContext>() .UseSqlite(connection) .Options; using (LibraryContext context = new LibraryContext(options)) { await context.Database.OpenConnectionAsync(); context.Database.EnsureCreated(); var repository = new BookRepository(context); await CreateFakeBookAsync(repository); Assert.NotNull(await repository.GetAllAsync()); } }
/// <inheritdoc /> public LocalFileSnapshotStoreTests() { _databaseName = $"{Guid.NewGuid():N}.db"; var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = _databaseName, Mode = SqliteOpenMode.ReadWriteCreate }; var provider = new ServiceCollection() .AddLogging() .AddDbContext <SqliteSnapshotContext>( builder => builder.EnableDetailedErrors() .EnableSensitiveDataLogging() .UseSqlite(connectionStringBuilder.ToString(), options => options.MigrationsAssembly("Bechtle.A365.ConfigService.Migrations"))) .BuildServiceProvider(); Store = new LocalFileSnapshotStore(provider.GetRequiredService <ILogger <LocalFileSnapshotStore> >(), provider.GetRequiredService <SqliteSnapshotContext>()); }
public async Task Dapper() { var builder = new SqliteConnectionStringBuilder(); builder.DataSource = ":memory:"; builder.Cache = SqliteCacheMode.Shared; var createTable = $"CREATE TABLE {nameof(Serialization)} ({nameof(Serialization.Number)} INTEGER)"; var insert = $"INSERT INTO {nameof(Serialization)} ({nameof(Serialization.Number)}) VALUES (5)"; var selectAll = $"SELECT * FROM {nameof(Serialization)}"; await using var connection = new SqliteConnection(builder.ConnectionString); await connection.OpenAsync(); await connection.ExecuteAsync(createTable); await connection.ExecuteAsync(insert); var materialized = await connection.QueryFirstAsync <Serialization>(selectAll); Assert.Equal(5, materialized.Number); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Set up Sqlite DB var builder = new SqliteConnectionStringBuilder() { DataSource = "Products.db", Mode = SqliteOpenMode.ReadWriteCreate, Cache = SqliteCacheMode.Default, }; var connection = new SqliteConnection(builder.ConnectionString); connection.Open(); connection.EnableExtensions(true); services.AddDbContext <ProductContext>(opt => opt.UseSqlite(connection)); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); // Set up dependency injection for controller's logger services.AddScoped <ILogger, Logger <ProductController> >(); }
private static ServiceProvider GetServiceProvider(LogLevel minimumLogLevel) { var serviceCollection = new ServiceCollection(); serviceCollection.AddLogging(lb => lb .AddProvider(new MinimalConsoleLoggerProvider()) .SetMinimumLevel(minimumLogLevel) .AddFilter("Microsoft.EntityFrameworkCore", LogLevel.Warning)); serviceCollection.AddTransient(sp => new EntityContextFactory(() => sp.GetRequiredService <IEntityContext>())); serviceCollection.AddDbContext <SqliteEntityContext>( (sp, ob) => { var settings = sp.GetRequiredService <IKrogerScrapeSettings>(); var builder = new SqliteConnectionStringBuilder(); builder.DataSource = settings.DatabasePath; ob.UseSqlite(builder.ConnectionString); }, contextLifetime: ServiceLifetime.Transient, optionsLifetime: ServiceLifetime.Transient); serviceCollection.AddTransient <IEntityContext>(sp => sp.GetRequiredService <SqliteEntityContext>()); serviceCollection.AddTransient <Deserializer>(); serviceCollection.AddTransient <EntityRepository>(); serviceCollection.AddTransient <KrogerClient>(); serviceCollection.AddTransient(sp => new KrogerClientFactory(() => sp.GetRequiredService <KrogerClient>())); serviceCollection.AddTransient <ScrapeCommandLogic>(); serviceCollection.AddTransient <StopOrphansCommandLogic>(); serviceCollection.AddTransient <JsonCommandLogic>(); serviceCollection.AddSingleton <KrogerScrapeSettingsFactory>(); serviceCollection.AddTransient(sp => sp.GetRequiredService <KrogerScrapeSettingsFactory>().Create()); serviceCollection.AddTransient <IKrogerClientSettings>(sp => sp.GetRequiredService <KrogerScrapeSettingsFactory>().Create()); return(serviceCollection.BuildServiceProvider()); }
private static string BuildDatabase(string dbFilename) { if (!File.Exists(dbFilename)) { File.WriteAllBytes(dbFilename, new byte[0]); } var connstr = new SqliteConnectionStringBuilder() { DataSource = dbFilename }.ToString(); SqliteConnection conn = new SqliteConnection(connstr); conn.Open(); long tableCount = 0; using (SqliteCommand cmd = new SqliteCommand("SELECT COUNT(1) FROM sqlite_master WHERE type='table';", conn)) { tableCount = (long)cmd.ExecuteScalar(); } if (tableCount == 0) { var assembly = typeof(Startup).Assembly; string sql; using (var sr = new StreamReader(assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().Single(f => f.EndsWith(".quartz.sql"))))) { sql = sr.ReadToEnd(); } //"quartz.sql"); Console.WriteLine(sql); using (var cmd = new SqliteCommand(sql, conn)) { cmd.ExecuteNonQuery(); } } conn.Close(); return(connstr); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public override bool Exists() { var connectionOptions = new SqliteConnectionStringBuilder(_connection.ConnectionString); if (connectionOptions.DataSource.Equals(":memory:", StringComparison.OrdinalIgnoreCase) || connectionOptions.Mode == SqliteOpenMode.Memory) { return(true); } using var readOnlyConnection = _connection.CreateReadOnlyConnection(); try { readOnlyConnection.Open(errorsExpected: true); } catch (SqliteException ex) when(ex.SqliteErrorCode == SQLITE_CANTOPEN) { return(false); } return(true); }
public void DeleteOsallistujaAsync(int varaus_id) { // SQLite-kannan tiedot var connectionStringBuilder = new SqliteConnectionStringBuilder(); connectionStringBuilder.DataSource = "./varaus.db"; // Avataan yhteys tietokantaan using (var connection = new SqliteConnection(connectionStringBuilder.ConnectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var deleteCommand = connection.CreateCommand(); deleteCommand.CommandText = "DELETE FROM koulutus_ilmoittautumiset WHERE varaus_id=" + varaus_id; deleteCommand.ExecuteNonQuery(); transaction.Commit(); } } }
public LingoesDict() { string FileName = @"dic/njcd.db"; var connectionString = new SqliteConnectionStringBuilder() { Cache = SqliteCacheMode.Shared, Mode = SqliteOpenMode.ReadOnly, DataSource = FileName, }.ToString(); using var connection = new SqliteConnection(connectionString); connection.Open(); var word = "私私私私私私私私私私"; var command = connection.CreateCommand(); command.CommandText = @" SELECT content FROM entry WHERE word = $word "; command.Parameters.AddWithValue("$word", word); using var raw = command.ExecuteReader(); raw.Read(); // 使用while 可以遍历行 if (raw[0] != null) { Console.WriteLine(raw[0]); ContentToObj(raw[0].ToString() !); } else { //没找到 } }
public override bool Open(String path) { var connectionString = new SqliteConnectionStringBuilder { DataSource = path, Version = 3, SyncMode = SynchronizationModes.Full }; var result = true; try { shouldCommit = false; Connection = new SqliteConnection(connectionString.ToString()); Connection.Open(); } catch (Exception ex) { Log.E(Tag, "Error opening the Sqlite connection using connection String: {0}".Fmt(connectionString.ToString()), ex); result = false; } return(result); }
public async Task <string> Download(string userId) { var dbFile = Path.GetTempFileName(); SqliteConnectionStringBuilder connectionStringBuilder = new SqliteConnectionStringBuilder(); connectionStringBuilder.DataSource = dbFile; using (SqliteConnection db = new SqliteConnection(connectionStringBuilder.ToString())) { await db.OpenAsync(); await InitSchema(db); await CopyCollectionsToClientData(userId, db); await CopyNotesToClientData(userId, db); await CopyCardsToClientData(userId, db); await CopyRevLogsToClientData(userId, db); await CopyGravesToClientData(userId, db); } return(dbFile); }
public void ApplySort_3Organizations_ReturnInExpectedOrder() { //Arrange var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:" }; var connection = new SqliteConnection(connectionStringBuilder.ToString()); var options = new DbContextOptionsBuilder <OrganizationsContext>() .UseLoggerFactory(new LoggerFactory( new[] { new LogToActionLoggerProvider((log => { _output.WriteLine(log); })) })) .UseSqlite(connection) .Options; var mappingConfig = TestHelpers.SetMapper(); IMapper mapper = mappingConfig.CreateMapper(); using (var context = new OrganizationsContext(options)) { context.Database.OpenConnection(); context.Database.EnsureCreated(); Helpers.TestHelpers.AddFiveOrganizations(context); var organizationResourceParameters = new OrganizationResourceParameters { OrderBy = "Name desc" }; Assert.Equal("Organization1", context.Organizations.First().Name); var orderedOrganizations = context.Organizations.ApplySort(organizationResourceParameters.OrderBy, _propertyMappingService.GetPropertyMapping <OrganizationDto, Organization>()); //Assert Assert.Equal("Organization2", orderedOrganizations.First().Name); Assert.Equal("Org1", orderedOrganizations.Last().Name); } }
public string DataCheck(string id, DataContext context) { // Check lims.db for task ID entry List <Entities.Task> task = context.Tasks.Where(t => t.id == id).ToList(); if (task.Count == 0) { return(String.Format("No task ID found with that id: {0}.", id)); } // Check lims_data.db for input and output data entries. var conStrBuilder = new SqliteConnectionStringBuilder(); conStrBuilder.DataSource = this.backupDB; using (var conn = new SqliteConnection(conStrBuilder.ConnectionString)) { conn.Open(); string inQuery = "SELECT COUNT(*) FROM InputData WHERE id=@id"; var inCmd = conn.CreateCommand(); inCmd.CommandText = inQuery; inCmd.Parameters.Add("@id", SqliteType.Text).Value = id; int inCount = Convert.ToInt32(inCmd.ExecuteScalar()); string outQuery = "SELECT COUNT(*) FROM OutputData WHERE id=@id"; var outCmd = conn.CreateCommand(); outCmd.CommandText = outQuery; outCmd.Parameters.Add("@id", SqliteType.Text).Value = id; int outCount = Convert.ToInt32(outCmd.ExecuteScalar()); inCmd.Dispose(); outCmd.Dispose(); conn.Close(); if (inCount == 0 || outCount == 0) { return(String.Format("Data for task ID: {0} is no longer backed up. Backup expired.", id)); } } return(""); }
public SyncSchemaFixture() { GC.Collect(); GC.WaitForPendingFinalizers(); var builder = new SqliteConnectionStringBuilder { DataSource = ClientSqliteFilePath }; this.ClientSqliteConnectionString = builder.ConnectionString; if (File.Exists(ClientSqliteFilePath)) { File.Delete(ClientSqliteFilePath); } var backup = Path.Combine(Directory.GetCurrentDirectory(), "Backup", "AdventureWorksLT2012.bak"); // create databases helperDb.RestoreDatabase(serverDbName, backup); helperDb.CreateDatabase(client1DbName); }
public string BuildConnectionString(INopConnectionStringInfo nopConnectionString) { if (nopConnectionString is null) { throw new ArgumentNullException(nameof(nopConnectionString)); } if (nopConnectionString.IntegratedSecurity) { throw new NopException("Data provider supports connection only with password"); } var builder = new SqliteConnectionStringBuilder { DataSource = CommonHelper.DefaultFileProvider.MapPath($"~/App_Data/{nopConnectionString.DatabaseName}.sqlite"), Password = nopConnectionString.Password, Mode = SqliteOpenMode.ReadWrite, Cache = SqliteCacheMode.Shared }; return(builder.ConnectionString); }
public AppDatabase ReadConnection(string connectionString, DatabaseProvider provider) { if (provider == DatabaseProvider.Other) { var sb = new SqliteConnectionStringBuilder(connectionString); return(new AppDatabase(sb.ConnectionString, provider)); } if (provider == DatabaseProvider.MsSql) { var sb = new SqlConnectionStringBuilder(connectionString); return(new AppDatabase(sb.DataSource, sb.InitialCatalog, sb.UserID, sb.Password, provider, 1433)); } if (provider == DatabaseProvider.MySql) { var sb = new MySqlConnectionStringBuilder(connectionString); return(new AppDatabase(sb.Server, sb.Database, sb.UserID, sb.Password, provider, sb.Port)); } return(null); }
protected override PSDriveInfo NewDrive(PSDriveInfo drive) { if( drive is SQLiteDrive ) { return drive; } var cs = drive.Root; if( String.IsNullOrEmpty( cs ) || ! cs.StartsWith("[") ) { if (String.IsNullOrEmpty(cs)) { var builder = new SqliteConnectionStringBuilder(); builder.DataSource = ":memory:"; cs = builder.ToString(); } drive = new PSDriveInfo( drive.Name, drive.Provider, "/", drive.Description, drive.Credential); } return new SQLiteDrive( drive, String.Format( "[{0}]", cs), DynamicParameters as DriveParams ); }