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