public string Create() { var schemaExport = new SchemaExport(configuration); databaseProvider.CreateIfNotExists(); var stringBuilder = new StringBuilder(); schemaExport.Create(x => stringBuilder.Append(x), false); var statement = stringBuilder.ToString(); statement = string.IsNullOrWhiteSpace(statement) ? null : statement; if (!databaseProvider.Exists()) { databaseProvider.Create(); schemaExport.Execute(false, true, false); } else { try { new SchemaValidator(configuration).Validate(); } catch { schemaExport.Execute(false, true, false); } } return statement; }
public DatabaseRegistry() { var nHibernateConfiguration = new EmployeeApplicationNHibernateConfiguration(); //string connectionString = ConfigurationManager.ConnectionStrings["EmployeeApplicationContext"].ConnectionString; ISessionFactory sessionFactory = Fluently .Configure() .Database(SQLiteConfiguration.Standard.UsingFile(@"sqlite.db")) //.Database(MsSqlConfiguration.MsSql2008.ConnectionString(connectionString)) .Mappings(m => m.AutoMappings .Add(AutoMap.AssemblyOf<Employee>(nHibernateConfiguration)) ) .ExposeConfiguration(cfg => { var schemaExport = new SchemaExport(cfg); schemaExport.Drop(true, true); schemaExport.Create(true, true); }) .BuildSessionFactory(); For<ISessionFactory>().Singleton().Use(sessionFactory); For<ISession>().HybridHttpOrThreadLocalScoped().Use(ctx => ctx.GetInstance<ISessionFactory>().OpenSession()); //TODO: Handle Tansactions For Application //For<IUnitOfWork>().CacheBy(new HybridLifecycle()).Use<UnitOfWork>(); }
private void btnGenerateDBScript_Click(object sender, RoutedEventArgs e) { Assembly assembly = Assembly.LoadFrom(txtFileName.Text); IPersistenceConfigurer databaseConfig = null; string fileName = "Domain Database Script - {0}.sql"; if (rdbSqlServer.IsChecked != null) if (rdbSqlServer.IsChecked.Value) { databaseConfig = MsSqlConfiguration.MsSql2005; fileName = string.Format(fileName, "Sql Server 2005"); } else if (rdbOracle.IsChecked != null) if (rdbOracle.IsChecked.Value) { databaseConfig = OracleDataClientConfiguration.Oracle9; fileName = string.Format(fileName, "Oracle 9g"); } Fluently.Configure() .Mappings(m => m.FluentMappings.AddFromAssembly(assembly)) .Database(databaseConfig)//.ConnectionString("Data Source=.\\SQLEXPRESS;Initial Catalog=master;Integrated Security=True")) .ExposeConfiguration(config => { SchemaExport se = new SchemaExport(config); se.SetOutputFile(fileName); se.Create(false, false); MessageBox.Show(string.Format("Script successful created! See the '{0}' file.", fileName)); }).BuildConfiguration(); }
private void BuildSchema(Configuration config) { SchemaExport schema = new SchemaExport(config); schema.Drop(this._criaScript, this._exportaScriptBD); schema.Create(this._criaScript, this._exportaScriptBD); config.SetInterceptor(new SqlStatementInterceptor()); }
/// <summary> /// Initiate NHibernate Manager /// </summary> /// <param name="connect">NHibernate dialect, driver and connection string separated by ';'</param> /// <param name="store">Name of the store</param> public NHibernateManager(string connect, string store) { try { ParseConnectionString(connect); //To create sql file uncomment code below and write the name of the file SchemaExport exp = new SchemaExport(configuration); exp.SetOutputFile("db_creation.sql"); exp.Create(false, true); sessionFactory = configuration.BuildSessionFactory(); } catch (MappingException mapE) { if (mapE.InnerException != null) Console.WriteLine("[NHIBERNATE]: Mapping not valid: {0}, {1}, {2}", mapE.Message, mapE.StackTrace, mapE.InnerException.ToString()); else m_log.ErrorFormat("[NHIBERNATE]: Mapping not valid: {0}, {1}", mapE.Message, mapE.StackTrace); } catch (HibernateException hibE) { Console.WriteLine("[NHIBERNATE]: HibernateException: {0}, {1}", hibE.Message, hibE.StackTrace); } catch (TypeInitializationException tiE) { Console.WriteLine("[NHIBERNATE]: TypeInitializationException: {0}, {1}", tiE.Message, tiE.StackTrace); } }
protected void Application_Start() { new Configurator().StartServer<Configurator>(); var cfg = Simply.Do.GetNHibernateConfig(); var check = new SchemaValidator(cfg); try { check.Validate(); } catch { var exp = new SchemaExport(Simply.Do.GetNHibernateConfig()); exp.Drop(true, true); exp.Create(true, true); using (Simply.Do.EnterContext()) { UserSample.Init(); GroupSample.Init(); } } RegisterRoutes(RouteTable.Routes); }
public void can_create_schema() { Configuration cfg = new NHibernate.Cfg.Configuration(); SchemaExport exporter = new SchemaExport(cfg.Configure()); exporter.Create(true, true); exporter.Execute(false, true, false, true); }
public static void CreateDb() { var config = new Configuration().Configure(GetPath() + "\\nhibernate.cfg.xml"); var schemaExport = new SchemaExport(config); schemaExport.Drop(true, false); schemaExport.Create(true, true); }
static void Main() { Console.WriteLine("App started"); var configuration = new Configuration().Configure(); configuration.AddAssembly(typeof(Program).Assembly); var schemaExport = new SchemaExport(configuration); schemaExport.Create(true, true); Console.WriteLine(); Console.WriteLine("Database created"); using (var sessionFactory = configuration.BuildSessionFactory()) { //var postId = SavePost(sessionFactory); //GetPost(sessionFactory, postId); InsertData(sessionFactory); //// Enable profiling //XmlConfigurator.Configure(); NHibernateProfiler.Initialize(); RunQueries(sessionFactory); } Console.WriteLine(); Console.WriteLine("Press any key to quit the application"); Console.ReadLine(); }
public HelloWorldStructureMapRegistry() { IncludeRegistry<ProAceCoreRegistry>(); var sessionFactory = Fluently.Configure() .Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey("HelloWorld")).ShowSql()) .Mappings(m => { m.FluentMappings.AddFromAssemblyOf<MapMarker>(); m.FluentMappings.Conventions.AddFromAssemblyOf<CollectionAccessConvention>(); }) .ExposeConfiguration(cfg => { var schemaExport = new SchemaExport(cfg); schemaExport.Drop(true, true); schemaExport.Create(true, true); For<NHibernate.Cfg.Configuration>().Use(cfg); }) .BuildSessionFactory(); For<ISessionFactory>() .Singleton() .Use(sessionFactory); For<ISession>() .Use(ctx => ctx.GetInstance<ISessionFactory>().OpenSession()); For<IUserRepository>().Use<UserRepository>(); }
public void CriarSchema() { // Apenas no Init da Aplicação var config = new Configuration(); config.DataBaseIntegration(c => { c.Dialect<MsSql2012Dialect>(); c.ConnectionStringName = "ExemploNH"; c.LogFormattedSql = true; c.LogSqlInConsole = true; c.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote; }); var modelMapper = new ModelMapper(); modelMapper.AddMappings(typeof (ProdutoMap).Assembly.GetExportedTypes()); config.AddDeserializedMapping(modelMapper.CompileMappingForAllExplicitlyAddedEntities(), "Domain"); ISessionFactory sessionFactory = config.BuildSessionFactory(); // NOTE: Estudar framework FluentMigration var schemaExport = new SchemaExport(config); schemaExport.Create(true, true); }
private static ISessionFactory BuildTestSessionFactory() { var testDatabaseConnectionString = "LocalDB"; var config = DatabaseConfiguration.Configure(testDatabaseConnectionString); /* * Need to comment these out when not needed because session factory can only be created once. * Database schemas need to be created BEFORE NHibernate schema export. * This needs to be run only once. */ /* var fac = DatabaseConfiguration.BuildSessionFactory(config); CreateSchemas(fac);*/ // Drop old database if any, create new schema config.ExposeConfiguration(cfg => { var export = new SchemaExport(cfg); //export.SetOutputFile(@"C:\Temp\vdb.sql"); export.Drop(false, true); export.Create(false, true); }); var fac = DatabaseConfiguration.BuildSessionFactory(config); FinishDatabaseConfig(fac); return fac; }
protected virtual Configuration FluentlyConfigureSqlite(SqliteDatabase database) { var filePath = database.FilePath; SQLiteConfiguration liteConfiguration = SQLiteConfiguration.Standard .UsingFile(filePath) .ProxyFactoryFactory(typeof(ProxyFactoryFactory)); var fluentConfig = Fluently .Configure() .Database(liteConfiguration) .Mappings(m => m.FluentMappings.AddFromAssembly(GetType().Assembly)) // Install the database if it doesn't exist .ExposeConfiguration(config => { if (File.Exists(filePath)) return; SchemaExport export = new SchemaExport(config); export.Drop(false, true); export.Create(false, true); }) .BuildConfiguration(); AddProperties(fluentConfig); return fluentConfig; }
public NHibernateRegistry() { Configuration cfg = Fluently.Configure() .Database(SQLiteConfiguration.Standard.UsingFile("database.db")) .Mappings(m => m.AutoMappings .Add(AutoMap .AssemblyOf<ProductDetailViewModel>() .Conventions .Add(new ClassConvention()))) .BuildConfiguration(); cfg.SetProperty(Environment.ProxyFactoryFactoryClass, typeof (ProxyFactoryFactory).AssemblyQualifiedName); cfg.SetProperty(Environment.ConnectionDriver, typeof (SQLite20Driver).AssemblyQualifiedName); var export = new SchemaExport(cfg); export.Drop(true,true); export.Create(true,true); ISessionFactory sessionFactory = cfg.BuildSessionFactory(); ForRequestedType<Configuration>().AsSingletons() .TheDefault.IsThis(cfg); ForRequestedType<ISessionFactory>().AsSingletons() .TheDefault.IsThis(sessionFactory); ForRequestedType<ISession>().CacheBy(InstanceScope.Hybrid) .TheDefault.Is.ConstructedBy(ctx => ctx.GetInstance<ISessionFactory>().OpenSession()); ForRequestedType<IUnitOfWork>().CacheBy(InstanceScope.Hybrid) .TheDefaultIsConcreteType<UnitOfWork>(); ForRequestedType<IDatabaseBuilder>() .TheDefaultIsConcreteType<DatabaseBuilder>(); }
private void BuildSchema(Configuration cfg) { var schemaExport = new SchemaExport(cfg); schemaExport.Drop(script: false, export: true); schemaExport.Create(script: false, export: true); }
/// <summary> /// Builds the database schema. /// </summary> /// <param name="config">Configuration containing the database schema that needs to be built.</param> public void BuildSchema(Configuration config) { // Build the schema. var createSchemaSql = new StringWriter(); var schemaExport = new SchemaExport(config); // Drop the existing schema. schemaExport.Drop(true, true); // Print the Sql that will be used to build the schema. schemaExport.Create(createSchemaSql, false); Debug.Print(createSchemaSql.ToString()); // Create the schema. schemaExport.Create(false, true); }
public static void GenerateSchema(Configuration configuration) { //SchemaExport creates the database schema as defined in the mappings files. There must already be a database as defined in the App.Config file. SchemaExport schemaExport = new SchemaExport(configuration); schemaExport.Create(true, true); }
public void First_we_need_a_schema_to_test() { var schemaExport = new SchemaExport(_cfg); schemaExport.Drop(true, true); schemaExport.Create(true, true); try { using (IUnitOfWork work = UnitOfWork.Start()) using (ITransaction transaction = work.BeginTransaction(IsolationLevel.Serializable)) { using (var repository = new NHibernateRepository()) { repository.Save(new TestSaga(_sagaId) { Name = "Joe" }); repository.Save(new TestSaga(CombGuid.Generate()) { Name = "Chris" }); work.Flush(); transaction.Commit(); } } } finally { UnitOfWork.Finish(); } }
public static ISessionFactory GetSessionFactory(SqlConnect sqlConnectProvider) { ISessionFactory factory = null; if (_cacheSessionFactory.TryGetValue(sqlConnectProvider.Name, out factory)) return factory; lock (_lockObj) { if (_cacheSessionFactory.TryGetValue(sqlConnectProvider.Name, out factory)) return factory; FluentConfiguration config = Fluently.Configure(); SetDefaultConfig(config); // if (conn.ProviderName.IndexOf("System.Data.SqlClient", StringComparison.OrdinalIgnoreCase) > -1) BuildMsSqlDatabase(config, sqlConnectProvider.ConnectionString); config.ExposeConfiguration(cfg => { cfg.SetProperty("command_timeout", "120"); var export = new SchemaExport(cfg).SetOutputFile(Path.Combine(PathHelper.AppDataPath, "myDDL.sql")); export.Create(true, false); }); factory= config.BuildSessionFactory(); _cacheSessionFactory[sqlConnectProvider.Name]=factory; } return factory; }
//�������ݿ� public static void CreateDataBase(string AssemblyName) { cfg = new Configuration(); cfg.AddAssembly(AssemblyName); SchemaExport sch = new SchemaExport(cfg); sch.Create(true, true); }
private static void BuildSchema() { NHibernate.Cfg.Configuration cfg = NHibernateConfigurator.Configuration; var schemaExport = new SchemaExport(cfg); schemaExport.Create(false, true); // A new session is created implicitly to run the create scripts. But this new session is not the context session }
private static void ExportSchema(Configuration config) { var schema = new SchemaExport(config); // Auf false setzen, wenn kein neuer Account flushSchema = true; schema.Create(true, true); }
private static void BuildDatabase(ISessionBuilder builder) { Configuration config = builder.GetConfiguration(); var export = new SchemaExport(config); export.Drop(false, false); export.Create(true, true); }
static void Main(string[] args) { var nhConfig = new Configuration().Configure(); var sessionFactory = nhConfig.BuildSessionFactory(); var schemaExport = new SchemaExport(nhConfig); schemaExport.Create(false, true); }
/// <summary> /// Generate the database schema, apply it to the database and save the DDL used into a file. /// </summary> public static void CreateDatabase() { Configuration configuration = new Configuration(); configuration.Configure(); SchemaExport schemaExport = new SchemaExport(configuration); schemaExport.SetOutputFile("SQLite database schema.ddl"); schemaExport.Create(true, true); }
public void CreateSchema(bool outputToConsole) { if (config == null) throw new Exception("You must CreateSessionFactory before attempting to CreateSchema."); var export = new SchemaExport(config); export.Drop(outputToConsole, true); export.Create(outputToConsole, true); }
public void CreateSchemas(bool script, bool export) { foreach (PersistenceUnit pu in PersistenceUnitRepo.Instance.PersistenceUnits) { SchemaExport se = new SchemaExport(pu.NHConfiguration); se.Create(script, export); } }
public ActionResult InstallDb() { var config = MvcApplication.Config; var schemaExport = new SchemaExport(config.BuildConfiguration()); schemaExport.Create(true, true); return Content("Install table successfully"); }
protected virtual void ExportDatabaseSchema() { NHibernate.Cfg.Configuration[] cfgs = container.ResolveAll<NHibernate.Cfg.Configuration>(); foreach (var cfg in cfgs) { var export = new SchemaExport(cfg); export.Create(false, true); } }
/// <summary> /// Creates database schema based on mappings /// </summary> public static void CreateDatabaseSchema() { var schemaExport = new SchemaExport(Configuration); schemaExport.Drop(false, true); schemaExport.Create(false, true); // Excute custom sql which is not generated by NHibernate ExecuteCustomSql(); }
protected void Page_Load(object sender, EventArgs e) { var command = Convert.ToString(Request["command"]); if (command == "setup") { var schema = new NHibernate.Tool.hbm2ddl.SchemaExport(Hb8Factory.Configuration); schema.Create(false, true); } }
internal static string ExportReadModelSchema(ReadModelConnectionString connectionString) { SchemaExport schema = new NHibernate.Tool.hbm2ddl.SchemaExport(buildConfig(connectionString)); StringBuilder data = new StringBuilder(); schema.Create((a) => { data.AppendLine(a); }, false); return(data.ToString()); }
internal static void CreateReadModelSchema(ReadModelConnectionString connectionString) { bool schemaCreated = false; if (!schemaCreated) { SchemaExport schema = new NHibernate.Tool.hbm2ddl.SchemaExport(buildConfig(connectionString)); schema.Create(true, true); schemaCreated = true; } }
protected void Page_Load(object sender, EventArgs e) { var command = Convert.ToString(RequestUrl["command"]); if (command == "setup") { var schema = new NHibernate.Tool.hbm2ddl.SchemaExport(Hb8Factory.Configuration); schema.Create(false, true); } Response.Redirect("~/Pages/Management/UsersList.aspx"); }
public static void CreatSchema(string OutputFile, string ConnString) { FNHMVC.Data.Infrastructure.ConnectionHelper.GetConfiguration(ConnString).ExposeConfiguration(cfg => { var schemaExport = new NHibernate.Tool.hbm2ddl.SchemaExport(cfg); if (!string.IsNullOrEmpty(OutputFile)) { schemaExport.SetOutputFile(OutputFile); } schemaExport.Drop(false, true); schemaExport.Create(false, true); }).BuildConfiguration(); }
public void GenerateDatabase() { SchemaExport schemaExport = new NHibernate.Tool.hbm2ddl.SchemaExport(LocalSessionFactoryObject.Configuration); schemaExport.Create(true, true); }