C# hbm2ddl.SchemaExport类代码示例

		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>();
        }

        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);
        }

 private SchemaExport CreateSchemaExport(Configuration config)
 {
     var result = new SchemaExport(config);
     if (!string.IsNullOrEmpty(this.delimiter)) result.SetDelimiter(this.delimiter);
     if (!string.IsNullOrEmpty(this.outputFile)) result.SetOutputFile(this.outputFile);
     return result;
 }

        public void CreateDB()
        {
            SchemaExport schemaExport = new SchemaExport(Common.GetNHibernateConnnectInfo());
            schemaExport.Execute(false, true, false);

            CreateBlog();
        }

 private static void ExportSchema(Configuration config)
 {
     var schema = new SchemaExport(config);
     // Auf false setzen, wenn kein neuer Account
     flushSchema = true;
     schema.Create(true, true);
 }

        /// <summary>
        /// Creata data base
        /// </summary>
        /// <returns><see cref="DataBase"/></returns>
        public DataBase Create()
        {
            var database = Connection.Database;

            Connection.ConnectionString = GetConnectionString();

            if (Dialect is MySQLDialect)
            {
                ExecuteCommand(string.Format("CREATE DATABASE IF NOT EXISTS {0};", database), Connection);
            }
            else if (Dialect is MsSql2000Dialect)
            {
                ExecuteCommand(string.Format("IF NOT(EXISTS(SELECT * FROM sys.sysdatabases where name='{0}')) BEGIN CREATE DATABASE {0}; END", database), Connection);
            }
            else if (Dialect is PostgreSQLDialect)
            {
                Connection.ChangeDatabase("postgres");

                ExecuteCommand(string.Format("CREATE DATABASE {0};", database), Connection);
            }

            Connection = ConnectionFactory.Factory(Configuration, Dialect);

            var schemaExport = new SchemaExport(SessionManager.Configuration);

            schemaExport.Create(false, true);

            return this;
        }

 public static IDbConnection BuildSchema(ISession Session, Configuration configuration)
 {
     var export = new SchemaExport(configuration);
     var connection = Session.Connection;
     export.Execute(true, true, false, connection, null);
     return connection;
 }

        public void SessionExtensions_Usage_WorkingIsCorrect()
        {
            var configuration = Fluently.Configure();
            configuration.InitializeFromConfigSqLiteInMemory(true);
            configuration.AddMappingsFromAssemblyOf<UserMap>();

            Configuration config = null;
            configuration.ExposeConfiguration(c => config = c);
            var factory = configuration.BuildSessionFactory();
            var session = factory.OpenSession();

            var export = new SchemaExport(config);
            export.Execute(false, true, false, session.Connection, null);

            Assert.IsNull(session.GetObject<User>(x => x.Name == "test"));

            session.Save(new User { Name = "test" });
            session.Flush();

            var user = session.GetObject<User>(x => x.Name == "test");
            Assert.IsNotNull(user);

            user.Name = "foo";
            session.Update(user);
            session.Flush();

            user = session.GetObject<User>(x => x.Name == "foo");
            Assert.IsNotNull(user);

            session.Delete(user);
            session.Flush();
            Assert.IsNull(session.GetObject<User>(x => x.Name == "foo"));
        }

        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>();
        }

        /// <summary>
        /// Creates new instance of <see cref="SQLiteInMemoryTestHelper"/> on top of supplied Configuration
        /// </summary>
        /// <param name="configuration"></param>
        public SQLiteInMemoryTestHelper(Configuration configuration)
        {
            _configuration = configuration;

            _sessionFactory = configuration.BuildSessionFactory();
            _schemaExport = new SchemaExport(_configuration);
        }

        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);
            }
        }

        private void BuildSchema(Configuration cfg)
        {
            var schemaExport = new SchemaExport(cfg);

            schemaExport.Drop(script: false, export: true);
            schemaExport.Create(script: false, export: true);
        }