C# SchemaExport.SetOutputFile方法代码示例

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

        /// <summary>Changes the raw NHibernate config.</summary>
        /// <param name="config">The configuration to change.</param>
        public void ChangeRawConfig(Configuration config)
        {
            var schemaExport = new SchemaExport(config);
            var path = string.Empty;
            if (_outputSql)
            {
                path = Path.Combine(Path.GetTempPath(), "NHibernate SQL");
                Directory.CreateDirectory(path);
                schemaExport.SetOutputFile(Path.Combine(path, "drop.sql"));
            }

            schemaExport.Drop(false, true);
            if (_outputSql)
                schemaExport.SetOutputFile(Path.Combine(path, "create.sql"));
            schemaExport.Create(false, true);
        }

 static void CreateSchema()
 {
     SchemaExport export = new SchemaExport(m_NHConfiguration);
     export.SetDelimiter(";");
     export.SetOutputFile(@"db.sql").Execute(false, false, false);
     Console.WriteLine("Schema Exported");
 }

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

 /// <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()
 {
     var nhConfig = new ConfigurationBuilder().Build();
     var schemaExport = new SchemaExport(nhConfig);
     schemaExport
         .SetOutputFile(@"db.sql")
         .Execute(false, false, false);
 }

 public static void createDatabase()
 {
     var nhconfig = new Configuration().Configure();
     var sessionFactory = nhconfig.BuildSessionFactory();
     var schemaExport = new SchemaExport(nhconfig);
     schemaExport.SetOutputFile(@"concepts.sql")
         .Execute(true, true, false);
     Console.WriteLine("I created your database");
 }

 public void TestGenerationOfSchema()
 {
     Configuration configuration = new Configuration();
     configuration.Configure();
     configuration.AddAssembly(typeof(State).Assembly);
     SchemaExport schemaExport = new SchemaExport(configuration);
     schemaExport.SetOutputFile("schema.sql");
     schemaExport.Execute(false, true, false);
 }

        public void Create_Database()
        {
            Configuration config = sessionBuilder.GetConfiguration();

            var exporter = new SchemaExport(config);

            exporter.SetOutputFile(@"C:\temp\GroopSchema.ddl");
            exporter.Create(true, false);
        }

        private void DropAndRecreateSchema()
        {
            SchemaExport schemaExport = new SchemaExport(this.configuration);

            schemaExport.SetOutputFile(@"..\..\nhibernate-schema.txt");

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

 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 Generate()
 {
     var databaseSchemaFileName = GetDatabaseSchemaFileName();
     File.Delete(databaseSchemaFileName);
     var nHibernateConfigurator = GetNhibernateConfigurator();
     var schemaExport = new SchemaExport(nHibernateConfigurator.GetConfiguration());
     schemaExport.SetOutputFile(databaseSchemaFileName);
     schemaExport.Create(true, false);
     if (!File.Exists(databaseSchemaFileName) || new FileInfo(databaseSchemaFileName).Length == 0) throw new Exception("Error generating database schema");
 }

        public void Should_save_schema_to_file()
        {
            var cfg = new Configuration();
            cfg.Configure();
            cfg.AddAssembly(typeof(Product).Assembly);

            var schemaExport = new SchemaExport(cfg);
            schemaExport.SetOutputFile("../../GeneratedSchema/schema.sql");
            schemaExport.Create(true, true);
        }

        static void Main(string[] args)
        {
            var nhConfig = new Configuration().Configure();
              var sessionFactory = nhConfig.BuildSessionFactory();

              var schemaExport = new SchemaExport(nhConfig);
              schemaExport
            .SetOutputFile(@"db.sql")
            .Execute(false, false, false);
        }