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