public static ISession OpenSession()
{
var configuration = new Configuration();
var configurationPath = HttpContext.Current.Server.MapPath(@"~\Models\hibernate.cfg.xml");
configuration.Configure(configurationPath);
var bookConfigurationFile = HttpContext.Current.Server.MapPath(@"~\Models\Mapping\Book.hbm.xml");
configuration.AddFile(bookConfigurationFile);
ISessionFactory sessionFactory = configuration.BuildSessionFactory();
DatabaseMetadata meta = new DatabaseMetadata((DbConnection)sessionFactory.OpenSession().Connection, new NHibernate.Dialect.MsSql2008Dialect());
if (meta.IsTable("Book"))
{
Debug.WriteLine("Book ada");
}
else
{
Debug.WriteLine("Book tidak ada");
new SchemaUpdate(configuration).Execute(true, true);
}
return(sessionFactory.OpenSession());
}
public PgSQLConnectionImpl(
PgSQLConnectionVendorFunctionality vendorFunctionality,
PostgreSQLProtocol functionality,
DatabaseMetadata metaData
)
: base(vendorFunctionality, functionality, metaData)
{
}
private partial ILink <int?> OnTruncate(AbstractObjectName tableName)
{
//Verify the table name actually exists.
var table = DatabaseMetadata.GetTableOrView(tableName);
//In SQLite, a delete without a where clause is interpreted as a truncate if other conditions are met.
return(Sql("DELETE FROM " + table.Name.ToQuotedString() + ";").AsNonQuery());
}
public SQLConnectionImpl(
SQLConnectionVendorFunctionality vendorFunctionality,
TConnectionFunctionality connectionFunctionality,
DatabaseMetadata metaData
) : base(vendorFunctionality, connectionFunctionality)
{
this.DatabaseMetadata = ArgumentValidator.ValidateNotNull(nameof(metaData), metaData);
}
/// <summary>
/// Gets a table's row count.
/// </summary>
/// <param name="tableName">Name of the table.</param>
public ILink <long> GetTableApproximateCount(PostgreSqlObjectName tableName)
{
var table = DatabaseMetadata.GetTableOrView(tableName); //get the real name
var sql = @"SELECT tab.reltuples::BIGINT AS estimate FROM pg_class tab
INNER JOIN pg_namespace ns on ns.oid=tab.relnamespace
WHERE ns.nspname = @Schema AND tab.relname = @Name;";
return(Sql(sql, new { table.Name.Schema, table.Name.Name }).ToInt64());
}
public static bool UsesOldFictionSchema(DatabaseMetadata databaseMetadata)
{
Version metadataVersion = databaseMetadata.GetParsedVersion();
if (metadataVersion == null)
{
throw new Exception("Database metadata has an invalid version number.");
}
return(metadataVersion < new Version("1.4"));
}
public MultipleRowDbCommandBuilder <MySqlCommand, MySqlParameter> DeleteByKeyList <TKey>(MySqlObjectName tableName, IEnumerable <TKey> keys, DeleteOptions options = DeleteOptions.None)
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(DeleteByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key.");
}
var keyList = keys.AsList();
var columnMetadata = primaryKeys.Single();
string where;
if (keys.Count() > 1)
{
where = columnMetadata.SqlName + " IN (" + string.Join(", ", keyList.Select((s, i) => "@Param" + i)) + ")";
}
else
{
where = columnMetadata.SqlName + " = @Param0";
}
var parameters = new List <MySqlParameter>();
for (var i = 0; i < keyList.Count; i++)
{
var param = new MySqlParameter("@Param" + i, keyList[i]);
if (columnMetadata.DbType.HasValue)
{
param.MySqlDbType = columnMetadata.DbType.Value;
}
parameters.Add(param);
}
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(new MySqlDeleteMany(this, tableName, where, parameters, parameters.Count, options));
}
UpdateOptions effectiveOptions = UpdateOptions.SoftDelete;
if (!options.HasFlag(DeleteOptions.CheckRowsAffected))
{
effectiveOptions |= UpdateOptions.IgnoreRowsAffected;
}
if (options.HasFlag(DeleteOptions.UseKeyAttribute))
{
effectiveOptions |= UpdateOptions.UseKeyAttribute;
}
return(new MySqlUpdateMany(this, tableName, null, where, parameters, parameters.Count, effectiveOptions));
}
/// <summary>
/// Delete multiple records using a where expression.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="whereClause">The where clause.</param>
/// <param name="argumentValue">The argument value for the where clause.</param>
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteWithFilter(AbstractObjectName tableName, string whereClause, object argumentValue)
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteMany(tableName, whereClause, argumentValue));
}
return(OnUpdateMany(tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(whereClause, argumentValue));
}
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKeyList <T>(AbstractObjectName tableName, IEnumerable <T> keys)
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(GetByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key. Use DataSource.From instead.");
}
return(GetByKeyList <T>(tableName, primaryKeys.Single(), keys));
}
/// <summary>
/// Deletes multiple records using a where expression.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="whereClause">The where clause.</param>
public MultipleRowDbCommandBuilder <SQLiteCommand, SQLiteParameter> DeleteWithFilter(SQLiteObjectName tableName, string whereClause)
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(new SQLiteDeleteMany(this, tableName, whereClause, null));
}
return(new SQLiteUpdateMany(this, tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(whereClause, null));
}
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> GetByKeyList <T>(AbstractObjectName tableName, string keyColumn, IEnumerable <T> keys)
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).Columns.Where(c => c.SqlName.Equals(keyColumn, System.StringComparison.OrdinalIgnoreCase)).ToList();
if (primaryKeys.Count == 0)
{
throw new MappingException($"Cannot find a column named {keyColumn} on table {tableName}.");
}
return(GetByKeyList <T>(tableName, primaryKeys.Single(), keys));
}
/// <summary>
/// Delete multiple records using a filter object.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="filterValue">The filter value.</param>
/// <param name="filterOptions">The options.</param>
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> DeleteWithFilter(AbstractObjectName tableName, object filterValue, FilterOptions filterOptions = FilterOptions.None)
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteMany(tableName, filterValue, filterOptions));
}
return(OnUpdateMany(tableName, null, UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected).WithFilter(filterValue, filterOptions));
}
private static bool MergeDatabase(DatabaseModifierModel mergedDatabase,
List <DatabaseModifier> userConfigDatabases,
DatabaseMetadata defaultDatabaseSchema,
AppMetadata appMetadata)
{
var hasChange = false;
var userConfigDatabase = userConfigDatabases.FirstOrDefault(d => d.Name == mergedDatabase.Name);
if (defaultDatabaseSchema == null)
{
hasChange = true;
}
//Add new
if (userConfigDatabase == null)
{
userConfigDatabase = new DatabaseModifier {
Name = mergedDatabase.Name
};
userConfigDatabases.Add(userConfigDatabase);
}
//Apply changes
userConfigDatabase.TemplateId = mergedDatabase.TemplateId;
userConfigDatabase.BasedOn = mergedDatabase.UseTemplateId;
userConfigDatabase.Description = mergedDatabase.Description;
if (mergedDatabase.TemplateId != 0 ||
mergedDatabase.UseTemplateId != 0 ||
!String.IsNullOrEmpty(mergedDatabase.Description))
{
hasChange = true;
}
if (mergedDatabase.Schemas != null)
{
foreach (var mergedSchema in mergedDatabase.Schemas)
{
var defaultSchema = GetSchemaMetadata(defaultDatabaseSchema, appMetadata, mergedSchema.Name);
if (MergeSchema(mergedSchema, userConfigDatabase.Schemas, defaultSchema))
{
hasChange = true;
}
}
}
//If no change has been detected with the default config
if (!hasChange)
{
userConfigDatabases.Remove(userConfigDatabase);
}
return(hasChange);
}
public override bool IsTableInDatabase(Type type)
{
var name = type.Name;
using (var session = GetSessionFactory().OpenSession())
{
var meta = new DatabaseMetadata(session.Connection, new global::NHibernate.Dialect.MsSql2012Dialect());
//TABLE_NAME e.g. "hibernate_unique_key"
return(meta.IsTable(name));
}
}
public MongodbCollection(MongodbDatabase database, Type documentType, String collectionName)
{
if (collectionName == null) throw new ArgumentNullException("collectionName");
_database = database;
_documentType = documentType;
_collectionName = collectionName;
_metadata = _database.UniformDatabase.Metadata;
var mongoSettings = new MongoCollectionSettings {AssignIdOnInsert = false};
_collection = _database.Database.GetCollection(documentType, _collectionName, mongoSettings);
}
public SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter, TObject> GetByKey <TObject, TKey>(AbstractObjectName tableName, TKey key)
where TObject : class
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(GetByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key. Use DataSource.From instead.");
}
return(new SingleRowDbCommandBuilder <AbstractCommand, AbstractParameter, TObject>(OnGetByKey <TObject, TKey>(tableName, primaryKeys.Single(), key)));
}
static GraphqlController()
{
var dbContext = new MixCmsContext();
var tableNameLookup = new TableNameLookup();
var metaDatabase = new DatabaseMetadata(dbContext, tableNameLookup);
var schema = new Schema {
Query = new Mix.Cms.Api.GraphQL.Infrastructure.GraphQLQuery(dbContext, metaDatabase, tableNameLookup)
};
schema.Initialize();
graphQLSchema = schema;
}
MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter> IUpdateDeleteByKeyHelper <AbstractCommand, AbstractParameter, AbstractObjectName, AbstractDbType> .OnDeleteByKeyList <TKey>(AbstractObjectName tableName, IEnumerable <TKey> keys, DeleteOptions options)
{
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(DeleteByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key.");
}
var keyList = keys.AsList();
var columnMetadata = primaryKeys.Single();
string where;
if (keys.Count() > 1)
{
where = columnMetadata.SqlName + " IN (" + string.Join(", ", keyList.Select((s, i) => "?")) + ")";
}
else
{
where = columnMetadata.SqlName + " = ?";
}
var parameters = new List <OleDbParameter>();
for (var i = 0; i < keyList.Count; i++)
{
var param = new OleDbParameter("@Param" + i, keyList[i]);
if (columnMetadata.DbType.HasValue)
{
param.OleDbType = columnMetadata.DbType.Value;
}
parameters.Add(param);
}
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(new OleDbSqlServerDeleteSet(this, tableName, where, parameters, parameters.Count, options));
}
UpdateOptions effectiveOptions = UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected;
if (options.HasFlag(DeleteOptions.UseKeyAttribute))
{
effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute;
}
return(new OleDbSqlServerUpdateSet(this, tableName, null, where, parameters, parameters.Count, effectiveOptions));
}
/// <summary>
/// Gets a set of records by a key list.
/// </summary>
/// <typeparam name="TObject">The type of the returned object.</typeparam>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <param name="keys">The keys.</param>
public MultipleRowDbCommandBuilder <AbstractCommand, AbstractParameter, TObject> GetByKeyList <TObject, TKey>(IEnumerable <TKey> keys)
where TObject : class
{
var tableName = DatabaseObjectAsTableOrView <TObject>(OperationType.Select).Name;
var primaryKeys = DatabaseMetadata.GetTableOrView(tableName).PrimaryKeyColumns;
if (primaryKeys.Count != 1)
{
throw new MappingException($"{nameof(GetByKeyList)} operation isn't allowed on {tableName} because it doesn't have a single primary key. Use DataSource.From instead.");
}
return(OnGetByKeyList <TObject, TKey>(tableName, primaryKeys.Single(), keys));
}
private Boolean existeTablaMEFMaster(ISession sesion, String tabla)
{//JSA01
Boolean existeTabla = false;
Boolean continuar = true;
var a = sesion.GetSessionImplementation().Factory.OpenSession();
DatabaseMetadata meta = new DatabaseMetadata((DbConnection)a.Connection, new NHibernate.Dialect.MsSql2012Dialect());
if (meta.IsTable(tabla))
{
existeTabla = true;
}
return(existeTabla);
}
public static bool Migrate(LocalDatabase localDatabase, DatabaseMetadata databaseMetadata)
{
switch (databaseMetadata.Version)
{
case "0.7":
return(MigrateFrom_0_7(localDatabase, databaseMetadata));
case Constants.CURRENT_DATABASE_VERSION:
return(true);
default:
return(false);
}
}
public ValidationResult ValidateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)
{
_configuration.BuildMappings();
var mappings = _configuration.CreateMappings(_dialect);
var mapping = _configuration.BuildMapping();
var result = new ValidationResult();
try
{
var catalog = PropertiesHelper.GetString("default_catalog", _configuration.Properties, null);
var schema = PropertiesHelper.GetString("default_schema", _configuration.Properties, null);
foreach (var table in mappings.IterateTables)
{
if (!table.IsPhysicalTable || !Configuration.IncludeAction(table.SchemaActions, SchemaAction.Validate))
{
continue;
}
var tableMetadata = databaseMetadata.GetTableMetadata(table.Name, table.Schema ?? schema, table.Catalog ?? catalog, table.IsQuoted);
if (tableMetadata == null)
{
result.MissingTables.Add(table);
}
else
{
foreach (var column in table.ColumnIterator)
{
var columnMetadata = tableMetadata.GetColumnMetadata(column.Name);
if (columnMetadata == null)
{
result.AddMissingColumn(table, column);
}
if (!column.GetSqlType(dialect, mapping).ToLower().StartsWith(columnMetadata.TypeName.ToLower()))
{
result.AddInvalidColumn(table, column);
}
}
}
}
}
catch (Exception ex)
{
LogHelper.Error <SchemaChangeValidator>(ex.Message, ex);
result = new ValidationResult(ex);
}
return(result);
}
private static bool UpdateMetadata(LocalDatabase localDatabase, DatabaseMetadata databaseMetadata)
{
try
{
databaseMetadata.AppName = Constants.DATABASE_METADATA_APP_NAME;
databaseMetadata.Version = Constants.CURRENT_DATABASE_VERSION;
localDatabase.UpdateMetadata(databaseMetadata);
return(true);
}
catch (Exception exception)
{
Logger.Exception(exception);
return(false);
}
}
/// <summary>
/// Gets next usable ID for book entries table
/// </summary>
public static int NextID()
{
DatabaseMetadata m = App.LocalLibrary.Database.ReadMetadata();
if (m == null)
{
Logger.Error("Database does not contain METADATA collection and may be corrupt");
throw new IDNotFoundException("Metadata entry could not be found in database");
}
m.LastUsedID++;
App.LocalLibrary.Database.db.GetCollection <DatabaseMetadata>("METADATA").Update(m);
return(m.LastUsedID);
}
public Database(string DBFile)
{
Logger.Info("Connecting to database {}", DBFile);
db = new LiteDatabase(DBFile);
BOOKS = new ObservableCollection <BookEntry>(db.GetCollection <BookEntry>("BOOKS").FindAll());
if (!db.CollectionExists("METADATA"))
{
Logger.Info("Creating new METADATA collection in database");
DatabaseMetadata m = new DatabaseMetadata();
m.Id = 1;
m.Version = 1;
m.LastUsedID = 0;
db.GetCollection <DatabaseMetadata>("METADATA").Insert(m);
}
}
/// <summary>
/// Execute schema update script, determined by the Configuration object
/// used for creating the SessionFactory. A replacement for NHibernate's
/// SchemaUpdate class, for automatically executing schema update scripts
/// on application startup. Can also be invoked manually.
/// </summary>
/// <remarks>
/// Fetch the LocalSessionFactoryObject itself rather than the exposed
/// SessionFactory to be able to invoke this method, e.g. via
/// <code>LocalSessionFactoryObject lsfo = (LocalSessionFactoryObject) ctx.GetObject("mySessionFactory");</code>.
/// <p>
/// Uses the SessionFactory that this bean generates for accessing a ADO.NET
/// connection to perform the script.
/// </p>
/// </remarks>
public virtual void UpdateDatabaseSchema()
{
log.Info("Updating database schema for Hibernate SessionFactory");
HibernateTemplate hibernateTemplate = new HibernateTemplate(sessionFactory);
hibernateTemplate.TemplateFlushMode = TemplateFlushMode.Never;
hibernateTemplate.Execute(
new HibernateDelegate(delegate(ISession session)
{
IDbConnection con = session.Connection;
Dialect dialect = Dialect.GetDialect(Configuration.Properties);
DatabaseMetadata metadata = new DatabaseMetadata((DbConnection)con, dialect);
string[] sql = Configuration.GenerateSchemaUpdateScript(dialect, metadata);
ExecuteSchemaScript(con, sql);
return(null);
}));
}
/// <summary>
/// Delete an object model from the table indicated by the class's Table attribute.
/// </summary>
/// <typeparam name="TArgument"></typeparam>
/// <param name="argumentValue">The argument value.</param>
/// <param name="options">The delete options.</param>
/// <returns></returns>
public ObjectDbCommandBuilder <AbstractCommand, AbstractParameter, TArgument> Delete <TArgument>(TArgument argumentValue, DeleteOptions options = DeleteOptions.None) where TArgument : class
{
var table = DatabaseMetadata.GetTableOrViewFromClass <TArgument>();
if (!AuditRules.UseSoftDelete(table))
{
return(OnDeleteObject <TArgument>(table.Name, argumentValue, options));
}
UpdateOptions effectiveOptions = UpdateOptions.SoftDelete;
if (options.HasFlag(DeleteOptions.UseKeyAttribute))
{
effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute;
}
return(OnUpdateObject <TArgument>(table.Name, argumentValue, effectiveOptions));
}
public MongodbCollection(MongodbDatabase database, Type documentType, String collectionName)
{
if (collectionName == null)
{
throw new ArgumentNullException("collectionName");
}
_database = database;
_documentType = documentType;
_collectionName = collectionName;
_metadata = _database.UniformDatabase.Metadata;
var mongoSettings = new MongoCollectionSettings {
AssignIdOnInsert = false
};
_collection = _database.Database.GetCollection(documentType, _collectionName, mongoSettings);
}
public async Task GenerateCode(CodeGeneratorResult codeGeneratorResult)
{
DatabaseMetadata databaseMetaData = new DatabaseMetadata();
databaseMetaData = await GetDatabaseMetaDataAsync(codeGeneratorResult, databaseMetaData);
CodeProducerHelper.CodeGeneratorResult = codeGeneratorResult;
CodeProducerHelper.DatabaseMetadata = databaseMetaData;
var tasks = new List <Task>();
// Database related code.
if (databaseMetaData.DatabaseType == DatabaseType.MsSql || databaseMetaData.DatabaseType == DatabaseType.UnKnown)
{
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateSaveOrUpdateStoredProcedure(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateSqlRepository(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateStoredProcExecutionCode(); }));
}
else if (databaseMetaData.DatabaseType == DatabaseType.MySql)
{
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateMySqlSaveOrUpdateStoredProcedure(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenereateMySqlRepository(); }));
}
// c# code for both database.
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateWebApiController(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateTableServices(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateTableItem(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateNewInstance(); }));
tasks.Add(Task.Factory.StartNew(() => { CodeProducerHelper.GenerateAspMvcControllerClass(); }));
await Task.WhenAll(tasks);
var tableName = codeGeneratorResult.ModifiedTableName.ToStr(codeGeneratorResult.SelectedTable);
codeGeneratorResult = CodeProducerHelper.CodeGeneratorResult;
codeGeneratorResult.DatabaseMetadata = databaseMetaData;
codeGeneratorResult.UserMessage = tableName + " table codes are created. You made it dude, Congratulation :)";
codeGeneratorResult.UserMessageState = UserMessageState.Success;
}
/// <summary>
/// Creates a <see cref="SQLiteDeleteObject{TArgument}" /> used to perform a delete operation.
/// </summary>
/// <param name="tableName"></param>
/// <param name="argumentValue"></param>
/// <param name="options"></param>
/// <returns></returns>
public ObjectDbCommandBuilder <SQLiteCommand, SQLiteParameter, TArgument> Delete <TArgument>(SQLiteObjectName tableName, TArgument argumentValue, DeleteOptions options = DeleteOptions.None)
where TArgument : class
{
var table = DatabaseMetadata.GetTableOrView(tableName);
if (!AuditRules.UseSoftDelete(table))
{
return(new SQLiteDeleteObject <TArgument>(this, tableName, argumentValue, options));
}
UpdateOptions effectiveOptions = UpdateOptions.SoftDelete | UpdateOptions.IgnoreRowsAffected;
if (options.HasFlag(DeleteOptions.UseKeyAttribute))
{
effectiveOptions = effectiveOptions | UpdateOptions.UseKeyAttribute;
}
return(new SQLiteUpdateObject <TArgument>(this, tableName, argumentValue, effectiveOptions));
}
public DatabaseMetadata GetAllTables(String connectionString)
{
var result = new DatabaseMetadata();
SqlConnection con =
new SqlConnection(connectionString);
result.DatabaseType = DatabaseType.MsSql;
try
{
con.Open();
result.DatabaseName = con.Database;
DataTable tblDatabases =
con.GetSchema(
SqlClientMetaDataCollectionNames.Tables);
var list = new List <TableMetaData>();
foreach (DataRow rowDatabase in tblDatabases.Rows)
{
var i = new TableMetaData();
i.TableCatalog = rowDatabase["table_catalog"].ToStr();
i.TableSchema = rowDatabase["table_schema"].ToStr();
i.TableName = rowDatabase["table_name"].ToStr();
i.TableType = rowDatabase["table_type"].ToStr();
list.Add(i);
}
con.Close();
result.ConnectionString = connectionString;
result.Tables = list.OrderBy(t => t.TableName).ToList();
}
catch (Exception e)
{
}
return(result);
}
public ValidationResult Validate()
{
LogHelper.TraceIfEnabled<SchemaChangeValidator>("Running schema validator");
try
{
DatabaseMetadata databaseMetadata;
try
{
LogHelper.TraceIfEnabled<SchemaChangeValidator>("Fetching db metadata");
this._connectionHelper.Prepare();
databaseMetadata = new DatabaseMetadata(this._connectionHelper.Connection, this._dialect, false);
}
catch (Exception ex)
{
LogHelper.Error<SchemaChangeValidator>("Failed getting db metadata: " + ex.Message, ex);
throw;
}
return ValidateSchema(_dialect, databaseMetadata);
}
catch (Exception ex)
{
LogHelper.Error<SchemaChangeValidator>("Schema validation failed: " + ex.Message, ex);
throw;
}
finally
{
try
{
this._connectionHelper.Release();
}
catch (Exception ex)
{
LogHelper.Error<SchemaChangeValidator>("Error closing connection: " + ex.Message, ex);
}
}
}
public ValidationResult ValidateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)
{
_configuration.BuildMappings();
var mappings = _configuration.CreateMappings(_dialect);
var mapping = _configuration.BuildMapping();
var result = new ValidationResult();
try
{
var catalog = PropertiesHelper.GetString("default_catalog", _configuration.Properties, null);
var schema = PropertiesHelper.GetString("default_schema", _configuration.Properties, null);
foreach (var table in mappings.IterateTables)
{
if (!table.IsPhysicalTable || !Configuration.IncludeAction(table.SchemaActions, SchemaAction.Validate))
continue;
var tableMetadata = databaseMetadata.GetTableMetadata(table.Name, table.Schema ?? schema, table.Catalog ?? catalog, table.IsQuoted);
if (tableMetadata == null)
{
result.MissingTables.Add(table);
}
else
{
foreach (var column in table.ColumnIterator)
{
var columnMetadata = tableMetadata.GetColumnMetadata(column.Name);
if (columnMetadata == null)
{
result.AddMissingColumn(table, column);
}
if (!column.GetSqlType(dialect, mapping).ToLower().StartsWith(columnMetadata.TypeName.ToLower()))
{
result.AddInvalidColumn(table, column);
}
}
}
}
}
catch (Exception ex)
{
LogHelper.Error<SchemaChangeValidator>(ex.Message, ex);
result = new ValidationResult(ex);
}
return result;
}
/// <summary>
/// Execute the schema updates
/// </summary>
/// <param name="scriptAction">The action to write the each schema line.</param>
/// <param name="doUpdate">Commit the script to DB</param>
public void Execute(Action<string> scriptAction, bool doUpdate)
{
log.Info("Running hbm2ddl schema update");
var autoKeyWordsImport = PropertiesHelper.GetString(Environment.Hbm2ddlKeyWords, configuration.Properties, "not-defined");
autoKeyWordsImport = autoKeyWordsImport.ToLowerInvariant();
if (autoKeyWordsImport == Hbm2DDLKeyWords.AutoQuote)
{
SchemaMetadataUpdater.QuoteTableAndColumns(configuration);
}
IDbCommand stmt = null;
exceptions.Clear();
try
{
DatabaseMetadata meta;
try
{
log.Info("fetching database metadata");
connectionHelper.Prepare();
var connection = connectionHelper.Connection;
meta = new DatabaseMetadata(connection, dialect);
stmt = connection.CreateCommand();
}
catch (Exception sqlException)
{
exceptions.Add(sqlException);
log.Error("could not get database metadata", sqlException);
throw;
}
log.Info("updating schema");
var updateSQL = configuration.GenerateSchemaUpdateScript(dialect, meta);
var dialectScopes = new List<string>
{
typeof(MsSql2005Dialect).FullName,
typeof(MsSql2008Dialect).FullName,
typeof(MsSql2012Dialect).FullName,
};
for (var j = 0; j < updateSQL.Length; j++)
{
var sql = updateSQL[j];
if (dialectScopes.Contains(dialect.GetType().FullName))
{
sql = sql.Replace("primary key (Id)", "primary key nonclustered (Id)");
sql = sql.Replace("create index TimeoutEntity_EndpointIdx on TimeoutEntity (Time, Endpoint)", "create clustered index TimeoutEntity_EndpointIdx on TimeoutEntity (Endpoint, Time)");
}
var formatted = formatter.Format(sql);
try
{
if (scriptAction != null)
{
scriptAction(formatted);
}
if (doUpdate)
{
log.Debug(sql);
stmt.CommandText = sql;
stmt.ExecuteNonQuery();
}
}
catch (Exception e)
{
exceptions.Add(e);
log.Error("Unsuccessful: " + sql, e);
}
}
log.Info("schema update complete");
}
catch (Exception e)
{
exceptions.Add(e);
log.Error("could not complete schema update", e);
}
finally
{
try
{
if (stmt != null)
{
stmt.Dispose();
}
connectionHelper.Release();
}
catch (Exception e)
{
exceptions.Add(e);
log.Error("Error closing connection", e);
}
}
}
public MongodbBulkLoader(MongoDatabase mongoDatabase, DatabaseMetadata metadata)
{
_mongoDatabase = mongoDatabase;
_metadata = metadata;
}
public InMemoryCollection(DatabaseMetadata metadata)
{
_metadata = metadata;
}
