/// <summary> /// Get fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="propertyNames">Property names</param> /// <returns>Return properties relation entity fields</returns> public static List <EntityField> GetFields(DatabaseServerType serverType, Type entityType, IEnumerable <string> propertyNames) { if (propertyNames.IsNullOrEmpty()) { return(new List <EntityField>(0)); } var propertyFields = propertyNames.Select <string, EntityField>(p => p).ToList(); var key = serverType.GetDatabaseServerEntityFormatKey(entityType); if (string.IsNullOrWhiteSpace(key)) { return(propertyFields); } DatabaseServerEntityFields.TryGetValue(key, out var allFields); if (allFields.IsNullOrEmpty()) { ConfigureEntity(key, entityType); DatabaseServerEntityFields.TryGetValue(key, out allFields); if (allFields.IsNullOrEmpty()) { return(propertyFields); } } for (var p = 0; p < propertyFields.Count; p++) { var propertyField = propertyFields[p]; if (allFields.TryGetValue(propertyField.PropertyName, out var nowField) && nowField != null) { propertyFields[p] = nowField; } } return(propertyFields); }
/// <summary> /// Get query fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="query">Query object</param> /// <returns>Return entity fields</returns> public static List <EntityField> GetQueryFields(DatabaseServerType serverType, Type entityType, IQuery query) { string key = serverType.GetDatabaseServerEntityFormatKey(entityType); if (string.IsNullOrWhiteSpace(key)) { return(new List <EntityField>(0)); } DatabaseServerEntityQueryFields.TryGetValue(key, out var fields); if (fields.IsNullOrEmpty()) { ConfigureEntity(key, entityType); DatabaseServerEntityQueryFields.TryGetValue(key, out fields); } if (fields.IsNullOrEmpty()) { throw new Exception("empty fields"); } if (query.QueryFields.IsNullOrEmpty() && query.NotQueryFields.IsNullOrEmpty()) { return(fields); } var queryFields = query.GetActuallyQueryFields(entityType, true, true); return(fields.Intersect(queryFields).ToList()); }
/// <summary> /// Get fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="propertyNames">Property names</param> /// <returns>Return properties relation entity fields</returns> internal static IEnumerable <EntityField> GetFields(DatabaseServerType serverType, Type entityType, IEnumerable <string> propertyNames) { if (propertyNames.IsNullOrEmpty()) { return(Array.Empty <EntityField>()); } var allFields = EntityManager.GetEntityConfiguration(entityType)?.AllFields; if (allFields.IsNullOrEmpty()) { return(Array.Empty <EntityField>()); } DatabaseServerEntityFields.TryGetValue(serverType.GetDatabaseServerEntityFormatKey(entityType), out var entityServerFields); List <EntityField> resultFields = new List <EntityField>(); foreach (var propertyName in propertyNames) { if (string.IsNullOrWhiteSpace(propertyName)) { continue; } EntityField propertyField = null; entityServerFields?.TryGetValue(propertyName, out propertyField); if (propertyField == null) { allFields.TryGetValue(propertyName, out propertyField); } if (propertyField != null) { resultFields.Add(propertyField); } } return(resultFields); }
public async Task CreateDatabaseAsync(CloudProvider provider, string infrastructureName, DatabaseServerType dbType, string name, Dictionary <string, string> options) { var parentDirectory = Helpers.Helpers.GetParentDirectory(); var providerName = Helpers.Helpers.GetProviderName(provider); var infrastructurePath = $"{parentDirectory}/{providerName}/{infrastructureName}"; var fileName = $"{infrastructurePath}/Databases/{name}.json"; if (!Directory.Exists(infrastructurePath)) { throw new Exception("Infrastructure does not exist"); } else { if (File.Exists(fileName)) { throw new Exception("File exists with the same name"); } else { using (FileStream fs = File.Create(fileName, 1024)) { byte[] info = new UTF8Encoding(true).GetBytes(Helpers.Helpers.ConvertDictionaryToJson(options)); await fs.WriteAsync(info, 0, info.Length); } } } }
/// <summary> /// Configure database engine /// </summary> /// <param name="serverType">Database server type</param> /// <param name="databaseEngine">Database engine</param> public static void ConfigureDatabaseEngine(DatabaseServerType serverType, IDatabaseEngine databaseEngine) { if (databaseEngine == null) { return; } DatabaseEngines[serverType] = databaseEngine; }
/// <summary> /// Configure entity object name /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="objectName">Object name</param> internal static void ConfigureEntityObjectName(DatabaseServerType serverType, Type entityType, string objectName) { if (entityType == null || string.IsNullOrWhiteSpace(objectName)) { return; } DatabaseServerEntityObjectNames[serverType.GetDatabaseServerEntityFormatKey(entityType)] = objectName; }
/// <summary> /// Configure batch execute /// </summary> /// <param name="serverType">Database server type</param> /// <param name="batchExecuteConfig">Batch execute configuration</param> internal static void ConfigureBatchExecute(DatabaseServerType serverType, BatchExecuteConfiguration batchExecuteConfig) { if (batchExecuteConfig == null) { return; } DatabaseServerExecuteConfigurations[serverType] = batchExecuteConfig; }
/// <summary> /// Generate servertype&entit format key /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return database server entity format key</returns> static string GenerateDatabaseServerEntityFormatKey(DatabaseServerType serverType, Type entityType) { if (entityType == null) { throw new EZNEWException("EntityType is null"); } return(GenerateDatabaseServerEntityFormatKey(serverType, entityType.GUID)); }
/// <summary> /// Get servertype&entity format key /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return database server entity format key</returns> internal static string GetDatabaseServerEntityFormatKey(DatabaseServerType serverType, Type entityType) { if (entityType == null) { return(string.Empty); } return(GetDatabaseServerEntityFormatKey(serverType, entityType.GUID)); }
/// <summary> /// Get data isolation level /// </summary> /// <param name="serverType">Database server type</param> /// <returns>Return data isolation level</returns> internal static DataIsolationLevel?GetDataIsolationLevel(DatabaseServerType serverType) { if (DatabaseServerDataIsolationLevels.ContainsKey(serverType)) { return(DatabaseServerDataIsolationLevels[serverType]); } return(null); }
/// <summary> /// Configure database provider /// </summary> /// <param name="serverType">Database server type</param> /// <param name="databaseProvider">Database provider</param> internal static void ConfigureDatabaseProvider(DatabaseServerType serverType, IDatabaseProvider databaseProvider) { if (databaseProvider == null) { return; } DatabaseProviders[serverType] = databaseProvider; InitDatabaseAllEntityConfiguration(serverType); }
/// <summary> /// Get field /// </summary> /// <param name="serverType">Database server type</param> /// <param name="query">Query object</param> /// <param name="propertyName">Property name</param> /// <returns>Return property relation entity field</returns> public static EntityField GetField(DatabaseServerType serverType, IQuery query, string propertyName) { var entityType = query?.GetEntityType(); if (query == null || entityType == null) { return(propertyName); } return(GetField(serverType, entityType, propertyName)); }
/// <summary> /// Get edit fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return entity edit fields</returns> internal static IEnumerable <EntityField> GetEditFields(DatabaseServerType serverType, Type entityType) { string formatKey = GetDatabaseServerEntityFormatKey(serverType, entityType); if (DatabaseServerEntityEditFields.TryGetValue(formatKey, out var editFields)) { return(editFields); } return(EntityManager.GetEntityConfiguration(entityType)?.EditFields ?? new List <EntityField>(0)); }
/// <summary> /// Get query fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="query">Query object</param> /// <param name="forceMustFields">Whether return the must query fields</param> /// <returns>Return entity fields</returns> internal static IEnumerable <EntityField> GetQueryFields(DatabaseServerType serverType, Type entityType, IQuery query, bool forceMustFields) { var queryFieldsWithSign = query.GetActuallyQueryFieldsWithSign(entityType, forceMustFields); if (queryFieldsWithSign.Item1) { return(GetAllQueryFields(serverType, entityType)); } return(GetFields(serverType, entityType, queryFieldsWithSign.Item2)); }
/// <summary> /// Get all query fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return all query fields</returns> internal static IEnumerable <EntityField> GetAllQueryFields(DatabaseServerType serverType, Type entityType) { var formatKey = GetDatabaseServerEntityFormatKey(serverType, entityType); if (!DatabaseServerEntityQueryFields.TryGetValue(formatKey, out var queryFields) || queryFields.IsNullOrEmpty()) { queryFields = EntityManager.GetEntityConfiguration(entityType)?.QueryEntityFields; } return(queryFields); }
/// <summary> /// Get query object name /// </summary> /// <param name="serverType">Database server type</param> /// <param name="query">Query object</param> /// <returns>Return query relation entity object name</returns> public static string GetQueryRelationObjectName(DatabaseServerType serverType, IQuery query) { var entityType = query?.GetEntityType(); if (query == null || entityType == null) { return(string.Empty); } return(GetEntityObjectName(serverType, entityType)); }
/// <summary> /// Get entity object name /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="defaultName">Default name</param> /// <returns>Return Entity object name</returns> internal static string GetEntityObjectName(DatabaseServerType serverType, Type entityType, string defaultName = "") { DatabaseServerEntityObjectNames.TryGetValue(GetDatabaseServerEntityFormatKey(serverType, entityType), out var objectName); if (!string.IsNullOrWhiteSpace(objectName)) { return(objectName); } objectName = EntityManager.GetEntityObjectName(entityType); return(string.IsNullOrWhiteSpace(objectName) ? defaultName : objectName); }
/// <summary> /// Configure entity fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="fields">Fields</param> /// <param name="cover">Whether conver current fields</param> public static void ConfigureEntityFields(DatabaseServerType serverType, Type entityType, IEnumerable <EntityField> fields, bool cover = true) { if (entityType == null) { return; } var key = serverType.GetDatabaseServerEntityFormatKey(entityType); ConfigureEntityFields(key, entityType, fields, cover); }
/// <summary> /// Configure entity object name /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="objectName">Object name</param> /// <param name="cover">Whether cover current object name</param> public static void ConfigureEntityObjectName(DatabaseServerType serverType, Type entityType, string objectName, bool cover = true) { if (entityType == null) { return; } var key = serverType.GetDatabaseServerEntityFormatKey(entityType); ConfigureEntityObjectName(key, objectName, cover); }
/// <summary> /// Init database all entity configuration /// </summary> /// <param name="serverType">Server type</param> static void InitDatabaseAllEntityConfiguration(DatabaseServerType serverType) { if (DatabaseServerEntityQueryFields.Any(c => c.Key.StartsWith(((int)serverType).ToString()))) { return; } foreach (var configItem in Entity.EntityConfigurations) { InitDatabaseEntityConfiguration(serverType, configItem.Key); } }
/// <summary> /// Configure server type entity /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="entityConfiguration">Entity configuration</param> static void ConfigureDatabaseServerEntity(DatabaseServerType serverType, Type entityType, DataEntityConfiguration entityConfiguration) { if (entityConfiguration == null) { return; } //Configure object name ConfigureEntityObjectName(serverType, entityType, entityConfiguration.TableName); //Configure fields ConfigureEntityFields(serverType, entityType, entityConfiguration.Fields); }
/// <summary> /// Init database entity configuration /// </summary> /// <param name="serverType">Server type</param> /// <param name="entityTypeId">Entity type</param> static void InitDatabaseEntityConfiguration(DatabaseServerType serverType, Guid entityTypeId) { var entityConfig = EntityManager.GetEntityConfiguration(entityTypeId); if (entityConfig == null) { return; } var formatKey = GetDatabaseServerEntityFormatKey(serverType, entityTypeId); if (!DatabaseServerEntityFields.TryGetValue(formatKey, out var serverEntityFields) || serverEntityFields.IsNullOrEmpty()) { return; } //Query fields var queryFields = new List <EntityField>(entityConfig.QueryFields.Count); foreach (var field in entityConfig.QueryFields) { if (serverEntityFields.TryGetValue(field, out var serverField) && serverField != null) { if (serverField.IsDisableQuery) { continue; } queryFields.Add(serverField); } else { queryFields.Add(field); } } DatabaseServerEntityQueryFields[formatKey] = queryFields; //Edit fields var editFields = new List <EntityField>(entityConfig.EditFields.Count); foreach (var field in entityConfig.EditFields) { if (serverEntityFields.TryGetValue(field.PropertyName, out var serverField) && serverField != null) { if (serverField.IsDisableEdit) { continue; } editFields.Add(serverField); } else { editFields.Add(field); } } DatabaseServerEntityEditFields[formatKey] = editFields; }
public static IDbServerFactory CreateDbServerFactory(DatabaseServerType serverType) { switch (serverType) { case DatabaseServerType.Undefined: throw new ArgumentException("Cannot create an IDbServerFactory for DatabaseServerType." + serverType.ToString()); case DatabaseServerType.SqlServer: return new SqlServerDbServerFactory(DatabaseServerType.SqlServer); //case DatabaseServerType.Informix: // return new DbServerFactoryInformix(DatabaseServerType.Informix); default: throw new NotImplementedException("Implementation missing for enumerated type DatabaseServerType." + serverType.ToString()); } }
private static string GetConnectionString(DatabaseServerType dbType) { switch (dbType) { case DatabaseServerType.SqlServer: return(ConfigurationManager.ConnectionStrings["TestDb"].ConnectionString); case DatabaseServerType.MySql: return(ConfigurationManager.ConnectionStrings["MysqlBooks"].ConnectionString); default: throw new InvalidOperationException(); } }
private static DbConnection CreateConnection(DatabaseServerType dbType, string connectionString) { switch (dbType) { case DatabaseServerType.SqlServer: return(new SqlConnection(connectionString)); case DatabaseServerType.MySql: return(new MySqlConnection(connectionString)); default: throw new InvalidOperationException(); } }
}//end CreateDatabaseManager() public static IDatabaseManager CreateDatabaseManager(DatabaseServerType databaseServerType, IConfiguration configuration) { switch (databaseServerType) { case DatabaseServerType.MSSQL: return(new MSSQLManager(configuration)); case DatabaseServerType.MariaDB: return(new MariaDBManager(configuration)); default: return(null); } }//end CreateDatabaseManager()
/// <summary> /// Get edit fields /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return entity edit fields</returns> public static List <EntityField> GetEditFields(DatabaseServerType serverType, Type entityType) { string key = serverType.GetDatabaseServerEntityFormatKey(entityType); if (string.IsNullOrWhiteSpace(key)) { return(new List <EntityField>(0)); } DatabaseServerEntityEditFields.TryGetValue(key, out var fields); if (fields.IsNullOrEmpty()) { ConfigureEntity(key, entityType); DatabaseServerEntityEditFields.TryGetValue(key, out fields); } return(fields ?? new List <EntityField>(0)); }
private static DbCommand CreateCommand(DatabaseServerType dbType, string query, DbConnection conn) { switch (dbType) { case DatabaseServerType.SqlServer: // Необходимо преобразовывать типы соединений, // потому что команды работают только с одним соединением. Note: Abstract Factory в помощь return(new SqlCommand(query, conn as SqlConnection)); case DatabaseServerType.MySql: return(new MySqlCommand(query, conn as MySqlConnection)); default: throw new InvalidOperationException(); } }
/// <summary> /// Get field /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="propertyName">Property name</param> /// <returns>Return property relation entity field</returns> internal static EntityField GetField(DatabaseServerType serverType, Type entityType, string propertyName) { if (string.IsNullOrWhiteSpace(propertyName)) { return(null); } EntityField field = null; DatabaseServerEntityFields.TryGetValue(GetDatabaseServerEntityFormatKey(serverType, entityType), out var entityServerFields); entityServerFields?.TryGetValue(propertyName, out field); if (field == null) { EntityManager.GetEntityField(entityType, propertyName); } return(field ?? propertyName); }
/// <summary> /// Get entity object name /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <param name="defaultName">Default name</param> /// <returns>Return Entity object name</returns> public static string GetEntityObjectName(DatabaseServerType serverType, Type entityType, string defaultName = "") { string key = serverType.GetDatabaseServerEntityFormatKey(entityType); if (string.IsNullOrWhiteSpace(key)) { return(defaultName); } DatabaseServerEntityObjectNames.TryGetValue(key, out var cacheObjectName); if (string.IsNullOrWhiteSpace(cacheObjectName)) { ConfigureEntity(key, entityType); DatabaseServerEntityObjectNames.TryGetValue(key, out cacheObjectName); cacheObjectName = string.IsNullOrWhiteSpace(cacheObjectName) ? defaultName : cacheObjectName; } return(cacheObjectName ?? string.Empty); }
/// <summary> /// Get default field /// </summary> /// <param name="serverType">Database server type</param> /// <param name="entityType">Entity type</param> /// <returns>Return default field</returns> internal static EntityField GetDefaultField(DatabaseServerType serverType, Type entityType) { var entityConfig = EntityManager.GetEntityConfiguration(entityType); var primaryKeys = entityConfig?.PrimaryKeys; if (primaryKeys.IsNullOrEmpty()) { primaryKeys = entityConfig?.QueryFields; } if (primaryKeys.IsNullOrEmpty()) { return(null); } var defaultField = primaryKeys[0]; return(GetField(serverType, entityType, defaultField)); }
public static AbstractMetadataReader GetReader(DatabaseServerType serverType, string connectionStr) { switch (serverType) { case DatabaseServerType.Oracle: return new OracleMetadataReader(connectionStr); case DatabaseServerType.SqlServer: return new SqlServerMetadataReader(connectionStr); case DatabaseServerType.MySQL: return new MysqlMetadataReader(connectionStr); case DatabaseServerType.SQLite: return new SqliteMetadataReader(connectionStr); case DatabaseServerType.Sybase: return new SybaseMetadataReader(connectionStr); case DatabaseServerType.Ingres: return new IngresMetadataReader(connectionStr); default: return new NpgsqlMetadataReader(connectionStr); } }
public void LoadConfiguration(DataConnectionDialog dialog, DatabaseServerType serverType) { this._dataSources = new Dictionary<string, DataSource>(); this._dataProviders = new Dictionary<string, DataProvider>(); switch (serverType) { case DatabaseServerType.Oracle: dialog.DataSources.Add(DataSource.OracleDataSource); dialog.UnspecifiedDataSource.Providers.Add(DataProvider.OracleDataProvider); this._dataSources.Add(DataSource.OracleDataSource.Name, DataSource.OracleDataSource); this._dataProviders.Add(DataProvider.OracleDataProvider.Name, DataProvider.OracleDataProvider); break; case DatabaseServerType.SqlServer: dialog.DataSources.Add(DataSource.SqlDataSource); this._dataSources.Add(DataSource.SqlDataSource.Name, DataSource.SqlDataSource); this._dataProviders.Add(DataProvider.SqlDataProvider.Name, DataProvider.SqlDataProvider); break; default: dialog.UnspecifiedDataSource.Providers.Add(DataProvider.OleDBDataProvider); this._dataProviders.Add(DataProvider.OleDBDataProvider.Name, DataProvider.OleDBDataProvider); dialog.DataSources.Add(dialog.UnspecifiedDataSource); this._dataSources.Add(dialog.UnspecifiedDataSource.DisplayName, dialog.UnspecifiedDataSource); break; } DataSource ds = null; string dsName = this.GetSelectedSource(); if (!String.IsNullOrEmpty(dsName) && this._dataSources.TryGetValue(dsName, out ds)) { dialog.SelectedDataSource = ds; } DataProvider dp = null; string dpName = this.GetSelectedProvider(); if (!String.IsNullOrEmpty(dpName) && this._dataProviders.TryGetValue(dpName, out dp)) { dialog.SelectedDataProvider = dp; } }
public Type MapFromDBType(DatabaseServerType serverType, string dataType, int? dataLength, int? dataPrecision, int? dataScale, bool isPrimaryKey) { switch (serverType) { case DatabaseServerType.SqlServer: return MapFromSqlServerDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); case DatabaseServerType.Oracle: return MapFromOracleDBType(dataType, dataLength, dataPrecision, dataScale); case DatabaseServerType.MySQL: return MapFromMySqlDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); case DatabaseServerType.PostgreSQL: return MapFromPostgreDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); case DatabaseServerType.Sybase: return MapFromSqlServerDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); case DatabaseServerType.Ingres: return MapFromIngresDbType(dataType, dataLength, dataPrecision, dataScale); case DatabaseServerType.CUBRID: return MapFromCUBRIDDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); } return MapFromDBType(dataType, dataLength, dataPrecision, dataScale, isPrimaryKey); }
private Connection CreateNewConnection(DatabaseServerType serverType = DatabaseServerType.SqlServer) { // Default connection settings. var connectionString = GetDefaultConnectionStringForServerType(serverType); return new Connection { Id = Guid.NewGuid(), Name = "New Connection", ConnectionString = connectionString, Type = serverType }; }
public SqlServerDbServerFactory(DatabaseServerType serverType) { if (serverType != this.ServerType) throw new ArgumentException("ServerType" + serverType.ToString() + " is wrong for this class.", "serverType"); }
private string GetDefaultConnectionStringForServerType(DatabaseServerType serverType) { switch (serverType) { case DatabaseServerType.Oracle: return StringConstants.ORACLE_CONN_STR_TEMPLATE; case DatabaseServerType.SqlServer: return StringConstants.SQL_CONN_STR_TEMPLATE; case DatabaseServerType.MySQL: return StringConstants.MYSQL_CONN_STR_TEMPLATE; case DatabaseServerType.SQLite: return StringConstants.SQLITE_CONN_STR_TEMPLATE; case DatabaseServerType.Sybase: return StringConstants.SYBASE_CONN_STR_TEMPLATE; case DatabaseServerType.Ingres: return StringConstants.INGRES_CONN_STR_TEMPLATE; case DatabaseServerType.CUBRID: return StringConstants.CUBRID_CONN_STR_TEMPLATE; default: return StringConstants.POSTGRESQL_CONN_STR_TEMPLATE; } }