public static WPostFile GetFileByChanbName(string name, DbConnection con) { WPostFile pf = null; using (DbCommand dc = DatabaseEngine.GenerateDbCommand(con)) { dc.CommandText = "SELECT ID, postID, md5, realname, size, extension, mimetype, dimension FROM files WHERE (chanbname = @chanbname)"; dc.Parameters.Add(DatabaseEngine.MakeParameter("@chanbname", name, DbType.String)); using (DbDataReader reader = dc.ExecuteReader()) { while (reader.Read()) { if (Convert.IsDBNull(reader[0])) { break; } pf = new WPostFile() { PostID = Convert.ToInt32(ReadParam(reader[1])), Hash = Convert.ToString(ReadParam(reader[2])), ChanbName = name, RealName = Convert.ToString(ReadParam(reader[3])), Size = Convert.ToInt32(ReadParam(reader[4])), Extension = Convert.ToString(ReadParam(reader[5])), MimeType = Convert.ToString(ReadParam(reader[6])), Dimensions = Convert.ToString(ReadParam(reader[7])), }; } } } return(pf); }
private static WPostFile[] GetPostFiles(int id, DbConnection connection) { List <WPostFile> li = new List <WPostFile>(); using (DbCommand dc = DatabaseEngine.GenerateDbCommand(connection)) { dc.CommandText = "SELECT ID, chanbname, realname, size, md5, extension, mimetype, dimension FROM files WHERE (postID = @postID)"; dc.Parameters.Add(DatabaseEngine.MakeParameter("@postID", id, DbType.Int32)); using (DbDataReader reader = dc.ExecuteReader()) { while (reader.Read()) { if (!Convert.IsDBNull(reader[0])) { li.Add(new WPostFile() { PostID = id, ChanbName = Convert.ToString(ReadParam(reader[1])), RealName = Convert.ToString(ReadParam(reader[2])), Size = Convert.ToInt32(ReadParam(reader[3])), Hash = Convert.ToString(ReadParam(reader[4])), Extension = Convert.ToString(ReadParam(reader[5])), MimeType = Convert.ToString(ReadParam(reader[6])), Dimensions = Convert.ToString(ReadParam(reader[7])) }); } } } } return(li.ToArray()); }
public static ThreadInfo GetThreadInfo(int id, DbConnection con) { using (DbCommand dc = DatabaseEngine.GenerateDbCommand(string.Format("SELECT ID, locked, mta FROM board WHERE (ID = {0})", id), con)) { ThreadInfo info = new ThreadInfo(); using (DbDataReader reader = dc.ExecuteReader()) { while (reader.Read()) { if (Convert.IsDBNull(reader[0])) { info.isGone = true; break; } else { info.isGone = false; info.isLocked = reader.GetBoolean(1); info.isArchived = reader.GetBoolean(2); } } } return(info); } }
public static bool CreateDatabase(DatabaseEngine database, DatabaseInfo databaseInfo) { switch (database) { case DatabaseEngine.MSSQL: break; case DatabaseEngine.MsSqlLocalStorage: break; case DatabaseEngine.MySql: break; case DatabaseEngine.PgSql: break; case DatabaseEngine.SqLite: string path = GlobalConfig.ContentRootPath; path = Path.Combine(path, "Data"); string dbFileName = Path.Combine(path, "NetCoreCMS.Database.SqLite.db"); using (var dbFile = File.Create(dbFileName)) { }; return(File.Exists(dbFileName)); } return(false); }
public static bool InitilizeDatabase(DatabaseEngine database, string connectionString) { var builder = new DbContextOptionsBuilder <NccDbContext>(); switch (database) { case DatabaseEngine.MSSQL: builder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); break; case DatabaseEngine.MsSqlLocalStorage: break; case DatabaseEngine.MySql: builder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); break; case DatabaseEngine.SqLite: builder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); break; case DatabaseEngine.PgSql: break; } //builder.UseSqlite(connectionString, options => options.MigrationsAssembly("NetCoreCMS.Framework")); var dbContext = new NccDbContext(builder.Options); dbContext.Database.Migrate(); return(dbContext.Database.EnsureCreated()); }
private IDbConnection GetConnection(DatabaseEngine providerType, string connectionString) { var provider = _connectionProviderFactory.GetInstance(providerType); var cn = provider.GetCustomConnection(connectionString); return(cn); }
public DatabaseConfiguration(DatabaseEngine databaseEngine, string masterString, bool debugFlag, string migrationsAssembly) { _databaseEngine = databaseEngine; _masterString = masterString; _debugFlag = debugFlag; _migrationsAssembly = migrationsAssembly; }
public DatabaseDriver() { this.DatabaseEngine = Config.GetDatabaseEngine(); DbConnectionStringBuilder Builder; if (this.DatabaseEngine == DatabaseEngine.Sqlite) { Builder = new SQLiteConnectionStringBuilder(); string FullPath = Path.Combine(Utils.AssemblyPath, Config.GetType <string>("Database", "Database") + ".sqlite3"); IsNewDatabase = !File.Exists(FullPath) || new FileInfo(FullPath).Length == 0; Builder.Add("Data Source", FullPath); Connection = new SQLiteConnection(Builder.ConnectionString); } else if (this.DatabaseEngine == DatabaseEngine.Mysql) { Builder = new MySqlConnectionStringBuilder(); Builder.Add("Server", Config.GetType <string>("Database", "Hostname")); Builder.Add("Port", Config.GetType <int>("Database", "Port")); Builder.Add("User ID", Config.GetType <string>("Database", "Username")); Builder.Add("Password", Config.GetType <string>("Database", "Password")); Builder.Add("Database", Config.GetType <string>("Database", "Database")); Connection = new MySqlConnection(Builder.ConnectionString); } else { throw new Exception("Invalid Database type."); } }
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName, IDictionary<string, string> properties) { UnitOfWorkTestContextDbStrategy strategy; switch (databaseEngine) { case DatabaseEngine.SQLite: strategy = new SQlLiteUnitOfWorkTestContextDbStrategy(); break; case DatabaseEngine.MsSqlCe: strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005: strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005Express: strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName); break; default: throw new ArgumentOutOfRangeException("databaseEngine"); } if (properties != null) foreach (KeyValuePair<string,string> property in properties) strategy.NHibernateProperties[property.Key] = property.Value; return strategy; }
/// <param name="dbConnectionInfo">The database name and server (optional)</param> /// <param name="databaseEngine">The database engine that tests should be performed against</param> /// <remarks> /// If <paramref name="dbConnectionInfo"/> is <see langword="null" /> or returns <see langword="null" /> /// or <see cref="string.Empty"/> for the <see cref="DbConnectionInfo.DatabaseName"/>, a database with a /// name derived from the other parameters supplied will be created. See /// <see cref="DeriveDatabaseNameFrom"/> /// <para> /// <paramref name="databaseEngine"/> largely determines the configuration of nhibernate. The argument /// supplied is used to pick from the predefined <see cref="NhCommonConfigurations"/> /// </para> /// </remarks> public NHibernateTestContextInitializer Using(DatabaseEngine databaseEngine, DbConnectionInfo dbConnectionInfo) { DatabaseEngine = databaseEngine; ConnectionInfo = dbConnectionInfo; return(this); }
protected virtual bool TryConnection() { try { if (!this.is_ready) { this.CurDBEngine = new DatabaseEngine(base.PrivateConfig.DatabaseType, base.PrivateConfig.DatabaseConnectionString); if (this.CurDBEngine.Connect()) { this.is_ready = true; } else { this.error_occured = true; base.ErrMsg = this.CurDBEngine.ErrorMessage; } } } catch (Exception exception) { this.error_occured = true; base.ErrMsg = exception.Message; } return(this.is_ready); }
public static void RegisterAuthServices(DatabaseEngine dbe) { switch (dbe) { case DatabaseEngine.MSSQL: GlobalConfig.Services.AddDbContext <NccDbContext>(options => options.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")) ); break; case DatabaseEngine.MsSqlLocalStorage: break; case DatabaseEngine.MySql: GlobalConfig.Services.AddDbContext <NccDbContext>(options => options.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")) ); break; case DatabaseEngine.SqLite: GlobalConfig.Services.AddDbContext <NccDbContext>(options => options.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")) ); break; case DatabaseEngine.PgSql: break; } GlobalConfig.Services.AddCustomizedIdentity(); }
public static void RegisterRepositories(this IServiceCollection services) { DatabaseEngine repositorytype = Enum.Parse <DatabaseEngine>(services.BuildServiceProvider().GetRequiredService <IOptions <InfrastructureSettings> >().Value.databaseEngine); switch (repositorytype) { case DatabaseEngine.EntityFrameworkSQLite: services.AddScoped <IShortUrlRepository, DbContextShortUrlRepository>(); services.AddScoped <IAdminRepository, DbContextAdminRepository>(); services.AddScoped <IStatRepository, DbContextStatRepository>(); services.AddScoped <IVisitorRepository, DbContextVisitorRepository>(); services.AddDbContext <CoreDbContext>(ServiceLifetime.Scoped); break; case DatabaseEngine.EntityFrameworkSQL: services.AddScoped <IShortUrlRepository, DbContextShortUrlRepository>(); services.AddScoped <IAdminRepository, DbContextAdminRepository>(); services.AddScoped <IStatRepository, DbContextStatRepository>(); services.AddScoped <IVisitorRepository, DbContextVisitorRepository>(); services.AddDbContext <CoreDbContext>(ServiceLifetime.Scoped); break; case DatabaseEngine.Dapper: services.AddScoped <IConnectionFactory, SQLConnectionFactory>(); services.AddScoped <IShortUrlRepository, SQLShortUrlRepository>(); services.AddScoped <IAdminRepository, SQLAdminRepository>(); services.AddScoped <IStatRepository, SQLStatRepository>(); services.AddScoped <IVisitorRepository, SQLVisitorRepository>(); break; } }
public DbCore(ref DatabaseEngine engine) { DbCommand command; String idx = null; if (engine != null) { _dbengine = engine; } else { throw(new ArgumentNullException("passed null engine param")); } // Create command object and create table command = engine.CreateCommand(); command.CommandText = "CREATE TABLE IF NOT EXISTS " + TableName; // TODO: Pull out remaining fields from the collectionbase, and run the SQL command.ExecuteNonQuery(); command = null; // do loop command.CommandText = "CREATE INDEX idx_" + idx + " ON " + TableName + " (" + idx + ");"; // }
public static NHibernateDbBuilder For(DatabaseEngine databaseEngine, DbConnectionInfo dbConnectionInfo, MappingInfo mappingInfo) { return(new NHibernateDbBuilder(DbMediaBuilder.For(databaseEngine, dbConnectionInfo), NHibernateConfigurator.Create(databaseEngine, dbConnectionInfo, mappingInfo))); }
public DatabaseConfiguration(DatabaseEngine databaseEngine, string connectionString, bool logging, string migrationsAssembly = "") { DatabaseEngine = databaseEngine; ConnectionString = connectionString; Logging = logging; MigrationsAssembly = migrationsAssembly; }
IDatabaseEngine OpenDatabase(string path, string user = null, bool useTransactions = true) { var databaseEngine = DatabaseEngine.CreateDatabaseEngine(path, user ?? Environment.UserName); databaseEngine.UseTransactions = useTransactions; return(databaseEngine); }
internal static DbContextOptions GetDbContextOptions() { DatabaseEngine dbe = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase); var optionBuilder = new DbContextOptionsBuilder <NccDbContext>(); switch (dbe) { case DatabaseEngine.MSSQL: optionBuilder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); return(optionBuilder.Options); break; case DatabaseEngine.MsSqlLocalStorage: break; case DatabaseEngine.MySql: optionBuilder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); return(optionBuilder.Options); break; case DatabaseEngine.PgSql: break; case DatabaseEngine.SqLite: optionBuilder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework")); return(optionBuilder.Options); } return(null); }
public void ExecuteDataScripts(DatabaseEngine engine) { if (engine != DatabaseEngine.SqlServer) return; //((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.CMS.Pages.Widgets.SqlScripts.newsletter.sql")); }
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName, IDictionary <string, string> properties) { UnitOfWorkTestContextDbStrategy strategy; switch (databaseEngine) { case DatabaseEngine.SQLite: strategy = new SQlLiteUnitOfWorkTestContextDbStrategy(); break; case DatabaseEngine.MsSqlCe: strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005: strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005Express: strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName); break; default: throw new ArgumentOutOfRangeException("databaseEngine"); } if (properties != null) { foreach (KeyValuePair <string, string> property in properties) { strategy.NHibernateProperties[property.Key] = property.Value; } } return(strategy); }
public async Task it_should_add_a_refresh_token(DatabaseEngine engine) { // Arrange await using var container = new DatabaseTestContainerBuilder().Build(engine); var configuration = new ConfigurationBuilder().For(container).Build(engine); var manager = new DatabaseManagerBuilder().With(configuration).Build(engine); var runner = new MigratorRunnerBuilder().With(configuration).Build(engine); var sut = new UserRepositoryBuilder().With(configuration).Build(engine); await container.StartAsync(); await manager.EnsureDatabaseCreated(); runner.MigrateUp(); const string username = "******"; var user = new UserBuilder().WithUserName(username).Build(); await sut.CreateAsync(user); // Act var persistedUser = await sut.FindByNameAsync(username); await sut.AssignRefreshToken("some_token", persistedUser !); // Assert var result = await sut.FindByNameAsync(username); result !.RefreshTokens.Should().ContainSingle("some_token"); }
/// <summary> /// Executes the code to be tested. /// </summary> protected override void Act() { var extensionConfigurationProviders = A.Fake <IEnumerable <ExtensionNHibernateConfigurationProvider> >(); var beforeBindMappingActivities = A.Fake <IEnumerable <INHibernateBeforeBindMappingActivity> >(); var authorizationStrategyConfigurators = A.Fake <IEnumerable <INHibernateFilterConfigurator> >(); var filterCriteriaApplicatorProvider = A.Fake <IFilterCriteriaApplicatorProvider>(); var configurationActivities = A.Fake <IEnumerable <INHibernateConfigurationActivity> >(); var connectionStringProvider = A.Fake <IOdsDatabaseConnectionStringProvider>(); var assembliesProvider = A.Fake <AssembliesProvider>(); DatabaseEngine engine = DatabaseEngine.SqlServer; var ormMappingFileDataProvider = new OrmMappingFileDataProvider(assembliesProvider, engine, OrmMappingFileConventions.OrmMappingAssembly); var nHibernateConfigurator = new NHibernateConfigurator(extensionConfigurationProviders, beforeBindMappingActivities, authorizationStrategyConfigurators, filterCriteriaApplicatorProvider, configurationActivities, ormMappingFileDataProvider, connectionStringProvider); _configuration = nHibernateConfigurator.Configure(); _persistentClasses = _configuration.ClassMappings .Where( m => m.Table.Name.Equals( CoreTableName, StringComparison.InvariantCultureIgnoreCase)) .ToList(); }
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName) { this.databaseEngine = databaseEngine; this.databaseName = databaseName; return(this); }
protected virtual bool TryConnection() { CloseConnections(); clsLog oLog = new clsLog(); try { if (!this.is_ready) { this.CurDBEngine = new DatabaseEngine(base.PrivateConfig.DatabaseType, base.PrivateConfig.DatabaseConnectionString); if (this.CurDBEngine.Connect()) { this.is_ready = true; oLog.WriteToDebugLogFile("Connected", "TryConnection"); } else { this.error_occured = true; base.ErrMsg = this.CurDBEngine.ErrorMessage; } } } catch (Exception exception) { this.error_occured = true; base.ErrMsg = exception.Message; } return(this.is_ready); }
public void Initialize() { databaseEngine = new DatabaseEngine { Database = Substitute.For <IDatabase>() }; }
public SessionConfig(TypeOfDatabase DatabaseType, string DatabaseConnectionString) : base(DatabaseType, DatabaseConnectionString) { this.current_user = null; this.CurDBEngine = null; this.CurDBEngine = new DatabaseEngine(DatabaseType, DatabaseConnectionString); this.CurDBEngine.Connect(); }
public override void Dispose() { clsLog oLog = new clsLog(); oLog.WriteToDebugLogFile("Starting Function", "Dispose"); if (this.is_detroyable) { oLog.WriteToDebugLogFile("Before Destroy", "Dispose"); if (this.IsReady) { oLog.WriteToDebugLogFile("Before Disconnect", "Dispose"); if (CurDBEngine != null) { this.CurDBEngine.Disconnect(); oLog.WriteToDebugLogFile("After Disconnect", "Dispose"); } else { oLog.WriteToDebugLogFile("DB Engine is Null", "Dispose"); } } this.CurDBEngine = null; this.CurSQLFactory = null; oLog.WriteToDebugLogFile("Ending Function", "Dispose"); } }
public async Task it_should_create_a_user(DatabaseEngine engine) { // Arrange await using var container = new DatabaseTestContainerBuilder().Build(engine); var configuration = new ConfigurationBuilder().For(container).Build(engine); var manager = new DatabaseManagerBuilder().With(configuration).Build(engine); var runner = new MigratorRunnerBuilder().With(configuration).Build(engine); var sut = new UserRepositoryBuilder().With(configuration).Build(engine); await container.StartAsync(); await manager.EnsureDatabaseCreated(); runner.MigrateUp(); // Act const string username = "******"; var user = new UserBuilder().WithUserName(username).Build(); await sut.CreateAsync(user); // Assert var result = await sut.FindByNameAsync(username); result.Should().BeEquivalentTo(user, opt => opt.Excluding(x => x.Id)); }
public ExtensionNHibernateConfigurationProvider(IDomainModelProvider domainModelProvider, IAssembliesProvider assembliesProvider, DatabaseEngine databaseEngine, string assemblyName) { _assembliesProvider = Preconditions.ThrowIfNull(assembliesProvider, nameof(assembliesProvider)); _databaseEngine = Preconditions.ThrowIfNull(databaseEngine, nameof(databaseEngine)); _domainModel = Preconditions.ThrowIfNull(domainModelProvider, nameof(domainModelProvider)).GetDomainModel(); _assemblyName = Preconditions.ThrowIfNull(assemblyName, nameof(assemblyName)); }
public static NHibernateConfigurator Create(DatabaseEngine databaseEngine, DbConnectionInfo dbConnectionInfo, MappingInfo mappingInfo) { IDictionary <string, string> properties = NhCommonConfigurations.For(databaseEngine, dbConnectionInfo, true); return(new NHibernateConfigurator(mappingInfo, properties)); }
public static void IntializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo) { InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, databaseName, mappingInfo); }
public TestcontainerDatabase Build(DatabaseEngine engine) { return(engine switch { DatabaseEngine.Postgres => CreatePostgresContainer(), DatabaseEngine.SqlServer => CreateMsSqlContainer(), _ => throw new ArgumentOutOfRangeException(nameof(engine), engine, $"Unknown engine {engine}") });
/// <summary> /// Initialize the persistence framework, build a session factory, and /// initialize the container. If <paramref name="rhinoContainerConfig"/> /// is <see langword="null" /> or <see cref="string.Empty">string.Empty</see> /// a <see cref="RhinoContainer">RhinoContainer</see> will not be initialized. /// </summary> /// <param name="framework">The persistence framework</param> /// <param name="rhinoContainerConfig">The configuration file to initialize a /// <see cref="RhinoContainer">RhinoContainer</see> or <see langword="null" />.</param> /// <param name="databaseName">Name of the database or <see langword="null" />.</param> /// <param name="databaseEngine">The database engine that tests should be performed against</param> /// <param name="mappingInfo">Information used to map classes to database tables and queries.</param> /// <remarks> /// If <paramref name="databaseName"/> is <see langword="null" /> or /// <see cref="string.Empty"/> a database with a name /// derived from the other parameters supplied will be created. See /// <see cref="NHibernateInitializer.DeriveDatabaseNameFrom(Assembly)"/> and <see cref="NHibernateInitializer.DeriveDatabaseNameFrom(DatabaseEngine, Assembly)"/> /// </remarks> public static void InitializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo) { NHibernateInitializer.Initialize(framework, mappingInfo).Using(databaseEngine, databaseName).AndIoC( rhinoContainerConfig); }
/// <summary> /// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다. /// </summary> /// <param name="containerConfigPath">Castle Windsor configuration file path</param> /// <param name="databaseEngine">Database 종류</param> /// <param name="databaseName">Database name</param> /// <param name="mappingInfo">Domain Model의 Mapping information</param> /// <param name="configAction">configuration 부가 작업</param> public static void InitializeNHibernateAndIoC(string containerConfigPath, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo, Action<NHibernate.Cfg.Configuration> configAction) { NHibernateInitializer.Initialize(mappingInfo, configAction) .Using(databaseEngine, databaseName) .AndIoC(containerConfigPath); }
public DatabaseInventory(ManagementConnectionProvider database, string schemaName) : base() { if (database == null) { throw new ArgumentNullException("database"); } targetEngine = database.Engine; this.schemaName = schemaName; XsltArgumentList arguments = CreateArguments(database); using (SqlCommand command = database.GetConnection().CreateCommand()) { command.Transaction = database.GetTransaction(); command.CommandType = CommandType.Text; command.Parameters.AddWithValue("@sSchema", schemaName); using (StringWriter writer = new StringWriter()) { userObjectList.Transform(new XDocument().CreateReader(), arguments, writer); command.CommandText = Regex.Replace(writer.ToString(), @"\s+", " "); // ReSharper disable AccessToDisposedClosure log.Trace(l => l(writer.ToString())); // ReSharper restore AccessToDisposedClosure } using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult)) { int definitionColumn = reader.GetOrdinal("xDefinition"); int nameColumn = reader.GetOrdinal("sName"); StringBuilder builder = new StringBuilder(65520); while (reader.Read()) { builder.Length = 0; using (StringWriter writer = new StringWriter(builder)) { SqlXml xml = reader.GetSqlXml(definitionColumn); scripter.Transform(xml.CreateReader(), arguments, writer); // ReSharper disable AccessToDisposedClosure log.Trace(l => l("Object name: {0}\n XML: {1}\n SQL: {2}", reader.GetString(nameColumn), xml.Value, writer)); // ReSharper restore AccessToDisposedClosure } try { try { using (StringReader scriptReader = new StringReader(builder.ToString())) { CreateStatement objectStatement = ProcessSingleScript(scriptReader, statement => { log.Error(l => l("Cannot process statement error: {0}", statement)); throw CreateException("Cannot process statement:", statement, TargetEngine); }).SingleOrDefault(statement => objectsToRename.Any(t => t.IsAssignableFrom(statement.GetType()))); if (objectStatement != null) { objectStatement.ObjectName = reader.GetString(nameColumn); } } } catch (ParseException ex) { ex.FileName = reader.GetString(nameColumn); throw; } } catch { Trace.WriteLine(builder.ToString()); throw; } } } } }
/// <summary> /// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다. /// </summary> /// <param name="containerConfigPath">Castle Windsor configuration file path</param> /// <param name="databaseEngine">Database 종류</param> /// <param name="databaseName">Database name</param> /// <param name="mappingInfo">Domain Model의 Mapping information</param> /// <param name="properties">NHibernate configuration 정보</param> public static void InitializeNHibernateAndIoC(string containerConfigPath, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo, IDictionary<string, string> properties) { NHibernateInitializer.Initialize(mappingInfo, null) .Using(databaseEngine, databaseName) .ConfiguredBy(properties) .AndIoC(containerConfigPath); }
public static string DeriveDatabaseNameFrom(DatabaseEngine databaseEngine, Assembly assembly) { if (databaseEngine == DatabaseEngine.SQLite) return UnitOfWorkTestContextDbStrategy.SQLiteDbName; else if (databaseEngine == DatabaseEngine.MsSqlCe) return "TempDB.sdf"; else // we want to have a test DB and a real db, and we really don't want to override on by mistake return DeriveDatabaseNameFrom(assembly) + "_Test"; }
public static void IntializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo, IDictionary<string, string> properties) { NHibernateInitializer.Initialize(framework, mappingInfo) .Using(databaseEngine, databaseName) .ConfiguredBy(properties) .AndIoC(rhinoContainerConfig); }
protected void VerifyCanCreateUnitOfWorkContextFor(PersistenceFramework framework, string rhinoContainerPath, DatabaseEngine databaseEngine, string databaseName) { int nextContextPosition = Contexts.Count; //creates the UnitOfWorkContext MappingInfo mappingInfo = MappingInfo.FromAssemblyContaining<AREntity>(); InitializeNHibernateAndIoC(framework, rhinoContainerPath, databaseEngine, databaseName, mappingInfo); UnitOfWorkTestContext context = Contexts[nextContextPosition]; Assert.AreEqual(framework, context.Framework); if (rhinoContainerPath != null) { Assert.AreEqual(rhinoContainerPath, context.RhinoContainerConfigPath); } else { Assert.IsEmpty(context.RhinoContainerConfigPath); } Assert.AreEqual(databaseEngine, context.DatabaseEngine); if (string.IsNullOrEmpty(databaseName)) { Assert.AreEqual( NHibernateInitializer.DeriveDatabaseNameFrom(databaseEngine, mappingInfo.MappingAssemblies[0]), context.DatabaseName); } else { Assert.AreEqual(databaseName, context.DatabaseName); } Assert.AreEqual(CurrentContext, context, "Context just built has been assigned to CurrentContext"); }
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName) { return For(databaseEngine, databaseName, null); }
/// <summary> /// 특정 Database System 종류에 대한 테스트용 DB 생성 및 UnitOfWork의 환경설정 정보를 제공하는 /// UnitOfWorkTestContextDbStrategy의 인스턴스를 빌드한다. /// </summary> /// <param name="databaseEngine">Database system 종류</param> /// <param name="databaseName">테스트용 Database name</param> /// <param name="properties">NHibernate configuration properties</param> /// <returns></returns> public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName, IDictionary<string, string> properties) { UnitOfWorkTestContextDbStrategy strategy; switch(databaseEngine) { case DatabaseEngine.SQLite: strategy = new SQLiteUnitOfWorkTestContextDbStrategy(); break; case DatabaseEngine.SQLiteForFile: strategy = new SQLiteForFileUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSqlCe: strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSqlCe40: strategy = new MsSqlCe40UnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005: strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MsSql2005Express: strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.OdpNet: strategy = new OdpNetUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.DevartOracle: strategy = new DevartOdpNetUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.MySql: strategy = new MySqlUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.PostgreSql: strategy = new PostgreSqlUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.Firebird: strategy = new FireBirdUnitOfWorkTestContextDbStrategy(databaseName); break; case DatabaseEngine.Cubrid: strategy = new CubridUnitOfWorkTestContextDbStrategy(databaseName); break; default: throw new NotSupportedException("currently not support a specified database engine=" + databaseEngine); } if(properties != null) foreach(var property in properties) strategy.NHibernateProperties[property.Key] = property.Value; return strategy; }
public bool SupportsDatabaseEngine(DatabaseEngine engine) { return engine == DatabaseEngine.SqlServer; }
public void DeleteDatabaseStructure(DatabaseEngine engine) { }
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName) { MappingContext.DatabaseEngine = databaseEngine; _databaseEngine = databaseEngine; _databaseName = databaseName; return this; }
public static string DeriveDatabaseNameFrom(DatabaseEngine databaseEngine, Assembly assembly) { string dbName; if(databaseEngine == DatabaseEngine.SQLite) dbName = UnitOfWorkTestContextDbStrategy.SQLiteDbName; //else if(databaseEngine == DatabaseEngine.MsSqlCe) // dbName = "TempDB.sdf"; else dbName = DeriveDatabaseNameFrom(assembly) + @"_Test"; if(IsDebugEnabled) log.Debug("Drived Database name is [{0}]", dbName); return dbName; }
internal static Exception CreateException(string message, SqlScriptableToken token, DatabaseEngine targetEngine) { StringWriter writer = new StringWriter(); writer.WriteLine(message); token.WriteTo(new SqlWriter(writer, targetEngine)); return new InvalidOperationException(writer.ToString()); }
public void ExecuteDataScripts(DatabaseEngine engine) { ((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.FileManager.DatabaseScripts.tables.sql")); ((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.FileManager.DatabaseScripts.procedures.sql")); }
public override bool DoesApplyToEngine(DatabaseEngine engine) { if (engine == DatabaseEngine.SqlAzure) { return false; } return base.DoesApplyToEngine(engine); }
public static void IntializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, MappingInfo mappingInfo) { InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, mappingInfo); }
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName) { this.databaseEngine = databaseEngine; this.databaseName = databaseName; return this; }
public ManagementConnectionProvider(SqlConnection connection, string schemaName) { if (connection == null) { throw new ArgumentNullException("connection"); } if (String.IsNullOrEmpty(schemaName)) { throw new ArgumentNullException("schemaName"); } this.schemaName = schemaName; if (connection.State == ConnectionState.Closed) { closeConnection = true; try { connection.Open(); } catch { connection.Dispose(); throw; } } this.connection = connection; using (SqlCommand cmd = connection.CreateCommand()) { cmd.CommandType = CommandType.Text; cmd.CommandText = "SELECT SERVERPROPERTY('productversion')"; engineVersion = new Version((string)cmd.ExecuteScalar()); cmd.CommandText = "SELECT SERVERPROPERTY('productlevel')"; engineLevel = (string)cmd.ExecuteScalar(); cmd.CommandText = "SELECT SERVERPROPERTY('edition')"; engineEdition = (string)cmd.ExecuteScalar(); if (engineEdition.IndexOf("Azure", StringComparison.OrdinalIgnoreCase) >= 0) { engine = DatabaseEngine.SqlAzure; } else { switch (engineVersion.Major) { case 9: engine = DatabaseEngine.SqlServer2005; break; case 10: engine = DatabaseEngine.SqlServer2008; break; case 11: engine = DatabaseEngine.SqlServer2012; break; default: engine = DatabaseEngine.Unknown; break; } } } log.DebugFormat("Detected server: {0}", engine); }
/// <summary> /// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다. /// </summary> /// <param name="containerConfigPath">Castle Windsor configuration file path</param> /// <param name="databaseEngine">Database 종류</param> /// <param name="mappingInfo">Domain Model의 Mapping information</param> /// <param name="configAction">부가적인 Configuration 관련 작업 (Listener 추가 등)</param> /// <param name="conventions">Fluent NHibernate의 명명규칙</param> public static void InitializeNHibernateAndIoC(string containerConfigPath, DatabaseEngine databaseEngine, MappingInfo mappingInfo, Action<NHibernate.Cfg.Configuration> configAction, params IConvention[] conventions) { NHibernateInitializer .Initialize(mappingInfo, configAction, conventions) .Using(databaseEngine, null) .AndIoC(containerConfigPath); }
public void ExecuteDataScripts(DatabaseEngine engine) { string sql = ResourceLoader.LoadTextResource("Sprocket.Web.CMS.Security.DatabaseScripts.sqlserver_data_001.sql"); ((SqlDatabase)Database.Main).ExecuteScript(sql); }
/// <summary> /// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다. /// </summary> /// <param name="containerConfigPath">Castle Windsor configuration file path</param> /// <param name="databaseEngine">Database 종류</param> /// <param name="databaseName">Database name</param> /// <param name="mappingInfo">Domain Model의 Mapping information</param> /// <param name="properties">NHibernate configuration 정보</param> /// <param name="configAction">NHIbernate configuration 을 추가해야 할 경우 (Listner 등)</param> /// <param name="conventions">Fluent NHibernate의 명명규칙</param> public static void InitializeNHibernateAndIoC(string containerConfigPath, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo, IDictionary<string, string> properties, Action<NHibernate.Cfg.Configuration> configAction, params IConvention[] conventions) { NHibernateInitializer .Initialize(mappingInfo, configAction, conventions) .Using(databaseEngine, databaseName) .ConfiguredBy(properties) .AndIoC(containerConfigPath); }
public void ExecuteDataScripts(DatabaseEngine engine) { ((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.Merchant.PayPal.Database.tables.sql")); ((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.Merchant.PayPal.Database.procs.sql")); }
protected void InitializeNHibernateAndIoC(string rhinoContainerPath, DatabaseEngine databaseEngine, string databaseName) { InitializeNHibernateAndIoC(FrameworkToTest, rhinoContainerPath, databaseEngine, databaseName, MappingInfo.FromAssemblyContaining<AREntity>()); }
/// <summary> /// Creates the physical database named <paramref name="databaseName"/>. /// </summary> /// <remarks> /// Use this method to create the physical database file. /// <para> /// For MsSqlCe this will create a database file in the file system /// named <paramref name="databaseName"/>.sdf /// </para> /// <para> /// For MsSql2005 this will create a database named <paramref /// name="databaseName"/> in the (local) instance of Sql Server 2005 on /// this machine /// </para> /// </remarks> public static void CreatePhysicalDatabaseMediaFor(DatabaseEngine databaseEngine, string databaseName) { For(databaseEngine, databaseName, null).CreateDatabaseMedia(); }
protected void VerifyCanCreateUnitOfWorkContextFor(string rhinoContainerPath, DatabaseEngine databaseEngine, string databaseName) { VerifyCanCreateUnitOfWorkContextFor(FrameworkToTest, rhinoContainerPath, databaseEngine, databaseName); }
public static void IntializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, string databaseName, MappingInfo mappingInfo, IDictionary<string, string> properties) { InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, databaseName, mappingInfo, properties); }
public virtual bool DoesApplyToEngine(DatabaseEngine engine) { return true; }