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