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 void CreateSchema(bool recreate)
{
if (_sessionFactory == null)
_sessionFactory = CreateSessionFactory();
var schemaExport = new SchemaExport(_configuration);
if (recreate)
schemaExport.Execute(false, true, true);
schemaExport.Execute(false, true, false);
}
public void CanCreate_FromScratch()
{
SchemaExport schemaCreator = new SchemaExport(CreateConfiguration(xml1));
schemaCreator.Execute((s) =>
{
Debug.WriteLine(" === Create === ");
Debug.WriteLine(s);
}, true, false);
schemaCreator.Execute((s) =>
{
Debug.WriteLine(" === Drop === ");
Debug.WriteLine(s);
}, true, true);
}
public static void CreateDatabase()
{
CopyBlankDatabase();
var export = new SchemaExport(NHibernateHelper.Configuration);
export.Execute(true, true, false);
}
protected void Application_Start()
{
HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();
var configuration = GlobalConfiguration.Configuration;
var builder = new ContainerBuilder();
builder.ConfigureWebApi(configuration);
builder.RegisterControllers(typeof(MvcApplication).Assembly);
builder.Register(c => CreateSessionFactory()).As<ISessionFactory>().SingleInstance();
builder.Register(c =>
{
var sf = c.Resolve<ISessionFactory>();
var session = sf.OpenSession();
var export = new SchemaExport(SavedConfig);
export.Execute(true, true, false, session.Connection, null);
return session;
}
).As<ISession>().SingleInstance();
builder.RegisterType<UnitOfWork>().InstancePerHttpRequest();
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
var resolver = new AutofacWebApiDependencyResolver(container);
configuration.ServiceResolver.SetResolver(resolver);
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
BundleTable.Bundles.RegisterTemplateBundles();
}
public void Execute(Action<ISession> action)
{
var cfg = new SQLiteConfiguration()
.InMemory()
.ShowSql()
.ConfigureProperties(new Configuration());
// UGLY HACK
var nhVersion = typeof(Configuration).Assembly.GetName().Version;
if (!nhVersion.ToString().StartsWith("2.0."))
{
cfg.SetProperty("proxyfactory.factory_class",
"NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle");
}
PersistenceModel.Configure(cfg);
var sessionFactory = cfg.BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (var tx = session.BeginTransaction())
{
SchemaExport export = new SchemaExport(cfg);
export.Execute(true, true, false, false, session.Connection, null);
tx.Commit();
}
using (var tx = session.BeginTransaction())
{
action(session);
tx.Commit();
}
}
}
public void CreateDB()
{
SchemaExport schemaExport = new SchemaExport(Common.GetNHibernateConnnectInfo());
schemaExport.Execute(false, true, false);
CreateBlog();
}
private void buildSchema()
{
var cfg = NHibernateSessionProvider.Configuration;
var schemaExport = new SchemaExport(cfg);
//schemaExport.Create(false, true);
schemaExport.Execute(false, true, false, Session.Connection, null);
}
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 NewsManagementInMemoryDatabaseFactory(ProvideInMemoryNewsManagementSessionFactoryInitialisation provideSessionFactoryInitialisation)
: base(provideSessionFactoryInitialisation)
{
provideSessionFactoryInitialisation.InitialiseSessionFactory();
SchemaExport export = new SchemaExport(provideSessionFactoryInitialisation.Configuration);
export.Execute(true, true, false, Session.Connection, null);
}
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);
}
private static void Main(string[] args)
{
XmlConfigurator.Configure();
var log = LogManager.GetLogger(typeof (Program));
SetupNHibernateValidator();
var nhibernateConfig = new Configuration().Configure();
nhibernateConfig.Initialize();
ISessionFactory sessionFactory = nhibernateConfig.BuildSessionFactory();
var schemaExport = new SchemaExport(nhibernateConfig);
schemaExport.Execute(false, true, false);
var junk = new Product
{
Name = "Spiffy Junk",
Description = string.Empty,
UnitPrice = -1M
};
var ve = Environment.SharedEngineProvider.GetEngine();
var invalidValues = ve.Validate(junk);
foreach (var invalidValue in invalidValues)
log.InfoFormat("{0} {1}",
invalidValue.PropertyName,
invalidValue.Message);
}
public void Create_a_database_schema_creation_script()
{
var export = new SchemaExport(_cfg);
var sb = new StringBuilder();
TextWriter output = new StringWriter(sb);
export.Execute(true, false, false, false, null, output);
}
static void Main(string[] args)
{
//var assemblyNames = ConfigurationManager.AppSettings["nhibernate.assemblies"];
//if (assemblyNames.IsNullOrEmpty())
// throw new ConfigurationErrorsException("value required for nhibernate.assemblies, comma seperated list of assemblies");
//var config = new NHibernate.Cfg.Configuration();
//config.Configure();
//foreach (MappingAssembly assembly in TitanConfiguration.Instance.MappingAssemblies)
// config.AddAssembly(assembly.Name);
TitanFramework.Data.NHib.NHibernateHelper.InitialIze();
var config = TitanFramework.Data.NHib.NHibernateHelper.Configuration;
var rebuildDatabase = ConfigurationManager.AppSettings["nhibernate.rebuilddatabase"];
if (TitanFramework.Extensions.StringExtensions.IsNullOrEmpty(rebuildDatabase))
throw new ConfigurationErrorsException("value required for nhibernate.assemblies, comma seperated list of assemblies");
switch (rebuildDatabase.ToLower())
{
case "rebuild":
var schemaExport = new SchemaExport(config);
schemaExport.Drop(false, true);
schemaExport.Execute(true, false, false);
break;
case "update":
var schemaUpdate = new SchemaUpdate(config);
schemaUpdate.Execute(true, true);
break;
}
}
public SqlLiteBuilder()
{
var showSql = GetShowSql();
var configuration = new Configuration()
.Proxy(p => p.ProxyFactoryFactory<DefaultProxyFactoryFactory>())
.DataBaseIntegration(db =>
{
db.Dialect<SQLiteDialect>();
db.Driver<SQLite20Driver>();
db.ConnectionString = "data source=:memory:";
})
.SetProperty(Environment.ReleaseConnections, "on_close")
.SetProperty(Environment.ShowSql, showSql)
.AddAssembly(Assembly.GetCallingAssembly());
_sessionFactory = Fluently.Configure(configuration)
.Mappings(mappings => mappings.FluentMappings.AddFromAssemblyOf<SqlLiteBuilder>())
.BuildSessionFactory();
_session = _sessionFactory.OpenSession();
var textWriter = GetTextWriter();
var schemaExport = new SchemaExport(configuration);
schemaExport.Execute(false, true, false, _session.Connection, textWriter);
}
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;
}
private static void AssertThatCheckOnTableExistenceIsCorrect(Configuration configuration)
{
var su = new SchemaExport(configuration);
var sb = new StringBuilder(500);
su.Execute(x => sb.AppendLine(x), false, false);
string script = sb.ToString();
Assert.That(script, Is.StringContaining("if exists (select 1 from sys.objects where object_id = OBJECT_ID(N'dbo.[Aclasses_Id_FK]') AND parent_object_id = OBJECT_ID('dbo.Aclass'))"));
}
public void DropDatabase()
{
Setup();
var session = _configuration.BuildSessionFactory().OpenSession();
var export = new SchemaExport(_configuration);
export.Execute(true, false, true, session.Connection, null);
export.Drop(false, true);
}
protected void ButtonInstall_Click(object sender, EventArgs e)
{
Configuration cfg = new Configuration();
cfg.Configure();
cfg.BuildSessionFactory();
SchemaExport ex = new SchemaExport(cfg);
ex.Execute(true, true, false);
}
private static void AssertThatCheckOnTableExistenceIsCorrect(Configuration configuration)
{
var su = new SchemaExport(configuration);
var sb = new StringBuilder(500);
su.Execute(x => sb.AppendLine(x), false, false);
string script = sb.ToString();
Assert.That(script, Text.Contains("if exists (select * from dbo.sysobjects where id = object_id(N'nhibernate.dbo.Aclass') and OBJECTPROPERTY(id, N'IsUserTable') = 1)"));
}
public static void ResetDB()
{
if (nhibernateCfg != null)
{
var schemaExport = new SchemaExport(nhibernateCfg);
schemaExport.Execute(false, true, false);
}
}
public void GenerateSchemaFromConfig()
{
var cfg = new Configuration();
cfg.Configure();
cfg.AddAssembly(typeof(Job).Assembly);
var schema = new SchemaExport(cfg);
schema.Execute(false, true, false);
}
public void Can_generate_schema()
{
var cfg = new Configuration();
cfg.Configure();
cfg.AddAssembly(typeof(HashStore).Assembly);
SchemaExport schema = new SchemaExport(cfg);
schema.Execute(false, true, false);
}
public static ISession OpenSession()
{
ISession session = SessionFactory.OpenSession();
var export = new SchemaExport(Configuration);
export.Execute(false, true, false, session.Connection, null);
return session;
}
public override void BuildSchema()
{
var session = this.Session;
if (session != null)
{
var export = new SchemaExport(this.CreateSessionFactory(this.DefaultFactoryKey).Item2);
export.Execute(true, true, false, session.Connection, null);
}
}
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 NHCD27_Long_Type_Is_Mapped_To_Real_DataType()
{
var script = string.Empty;
var exporter = new SchemaExport(base.Configuration);
exporter.Execute(s => script = s, false, false);
Assert.That(script, Is.Not.Empty);
Assert.That(script.Contains("ModuleValue REAL"), Is.True, "Long dataType is mapped to REAL");
}
public void ExportDatabaseSchema(string nHibernateConfig)
{
var cfg = generateConfiguration(nHibernateConfig);
var export = new SchemaExport(cfg);
TextWriter output = new StringWriter(new StringBuilder());
//export.Execute(true, true, false);
export.Execute(true, true, false, NHibernateSession.Current.Connection, output);
}
public void NHCD25_Supporting_Counter_DataType_For_Identity_Column()
{
var script = string.Empty;
var exporter = new SchemaExport(base.Configuration);
exporter.Execute(s => script = s, false, false);
Assert.That(script, Is.Not.Empty);
Assert.That(script.Contains("ModuleId COUNTER"), Is.True, "DataType of ModuleId (PK) is of type COUNTER");
}
public string ExportSchema()
{
var sqlBuilder = new StringBuilder();
var types = (from type in TypeEnumerator.Types
where typeof(Entity).IsAssignableFrom(type) &&
type != typeof(Entity)
select type);
Configure(types, "");
var export = new NHibernate.Tool.hbm2ddl.SchemaExport(Configuration);
export.Execute(s => sqlBuilder.AppendLine(s + ";"), false, false);
return(sqlBuilder.ToString());
}
public void TestInitizlize()
{
var config = new Configuration();
config.DataBaseIntegration(
db =>
{
db.Dialect<SQLiteDialect>();
db.Driver<SQLite20Driver>();
db.ConnectionString = ConnectionString;
db.LogSqlInConsole = false;
db.LogFormattedSql = true;
db.AutoCommentSql = true;
}
);
config.SetProperty(Environment.CurrentSessionContextClass, "thread_static");
var mapper = new ModelMapper();
mapper.WithMappings(config);
ContextSessionFactory = config.BuildSessionFactory();
ContextSession = ContextSessionFactory.OpenSession();
var schemaExport = new SchemaExport(config);
schemaExport.Execute(false, true, false, ContextSession.Connection, TextWriter.Null);
Context();
BecauseOf();
}
