public FLSequentialWorkflow() { _timeUnit = TimeUnit.Day; _urgentTime = 0; _expTime = 0; _orgKind = "0"; _connectionType = DbConnectionType.SqlClient; //_keys = new KeyItems(this, typeof(KeyItem)); }
/// <summary> /// 获取数据库连接(读写分离) /// </summary> /// <param name="connectionType">读写分离</param> /// <returns></returns> public static IDbConnection CetDbConnection(DbConnectionType connectionType) { if (connectionType == DbConnectionType.Write) { return(GetInstance.GetWriteDbConnection()); } else { return(GetInstance.GetReadDbConnection()); } }
public static IDbConnection createConnection(DbConnectionType dbConnType) { switch (dbConnType) { case DbConnectionType.Oracle: return new OracleDbConnection(); case DbConnectionType.MySql: return new MySqlDbConnection(); case DbConnectionType.MsSql: return new MsSqlDbConnection(); } return null; }
public static T CreateDbContext <T>(DbConnectionType connectionType, string connectionString) where T : DbContext { switch (connectionType) { case DbConnectionType.MySql: var mysql_connection = new MySqlConnection(connectionString); return((T)Activator.CreateInstance(typeof(T), new object[] { mysql_connection, true })); case DbConnectionType.SqLite: var sqlite_connection = new SQLiteConnection(connectionString); sqlite_connection.Open(); return((T)Activator.CreateInstance(typeof(T), new object[] { sqlite_connection, true })); default: return(null); } }
/////////////////////////////////////////////////////////////////////// public static ReturnCode CreateDbConnection( Interpreter interpreter, DbConnectionType dbConnectionType, string connectionString, string typeFullName, string typeName, ValueFlags valueFlags, ref IDbConnection connection, ref Result error ) { return(CreateDbConnection(interpreter, dbConnectionType, connectionString, typeFullName, typeName, valueFlags, GetOtherDbConnectionTypeNames(true, false), GetOtherDbConnectionTypeNames(false, false), ref connection, ref error)); }
public static DbConnection Create(String connection, DbConnectionType type = DbConnectionType.MySQL) { DbConnection cn = type switch { DbConnectionType.MySQL => new MySqlConnection(connection), DbConnectionType.SQLite => new SqliteConnection(connection), _ => throw new ArgumentException(nameof(type)) }; try { cn.Open(); } catch (Exception) { return(null); } return(cn); }
/// <summary> /// /// </summary> /// <param name="alias"></param> /// <param name="dbConnectionType"></param> /// <param name="b"></param> /// <returns></returns> private static string GetConnectionString(string alias, out DbConnectionType dbConnectionType, bool b) { alias = b ? GetSplitSysDB(alias) : alias; String xmlName = SystemFile.DBFile; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(xmlName); XmlNode node = xmlDoc.FirstChild.FirstChild.SelectSingleNode(alias); string DbString = ""; string Pwd = ""; if (node != null) { DbString = node.Attributes["String"].Value.Trim(); Pwd = GetPwdString(node.Attributes["Password"].Value.Trim()); } if (DbString.Length > 0 && Pwd.Length > 0 && Pwd != string.Empty) { if (DbString[DbString.Length - 1] != ';') DbString = DbString + ";Password="******"Password="******"1"; if (node != null) { value = node.Attributes["Type"].Value; if (value == "1") { dbConnectionType = DbConnectionType.SqlClient; } else if (value == "2") { dbConnectionType = DbConnectionType.OleDb; } else if (value == "3") { dbConnectionType = DbConnectionType.OracleClient; } else if (value == "4") { dbConnectionType = DbConnectionType.Odbc; } else if (value == "5") { dbConnectionType = DbConnectionType.MySQL; } else if (value == "6") { dbConnectionType = DbConnectionType.Informix; } else { dbConnectionType = DbConnectionType.SqlClient; } } else { dbConnectionType = DbConnectionType.SqlClient; } return DbString; }
/// <summary> /// Loads a config file into a XMLDocument and populates a DBConnectionTypes collection of the /// database connection details found in the config file. /// </summary> /// <param name="config">The name (and path) of a config file containing <connection> elements</param> /// <returns>A Collection of Connection Types</returns> private DbConnectionTypes LoadConfig ( string config ) { try { this.ReadXml(config); DbConnectionTypes connectionTypes = new DbConnectionTypes(); DataRow connectionsRow = this.Tables["connections"].Rows[0]; // Read the available connections from the connections collection // -------------------------------------------------------------- foreach (DataRow connectionRow in connectionsRow.GetChildRows("connections_connection")) { DbConnectionType connectionType = new DbConnectionType(); connectionType.Name = connectionRow["name"].ToString(); connectionType.DbTypeName = connectionRow["type"].ToString(); connectionType.InternalProviderName = connectionRow["internalProvider"].ToString(); // Read the Settings for this connection type // -------------------------------------------------------------- foreach (DataRow settingsRow in connectionRow.GetChildRows("connection_settings")) { if (settingsRow.Table.Columns.Contains("file")) { connectionType.SupportsFile = GetSettingState(settingsRow["file"].ToString(),false); connectionType.PromptFile = GetSettingValue(settingsRow["file"].ToString()); } if (settingsRow.Table.Columns.Contains("server")) { connectionType.SupportsServer = GetSettingState(settingsRow["server"].ToString(),true); connectionType.PromptServer = GetSettingValue(settingsRow["server"].ToString()); } if (settingsRow.Table.Columns.Contains("name")) { connectionType.SupportsName = GetSettingState(settingsRow["name"].ToString(),true); connectionType.PromptName = GetSettingValue(settingsRow["name"].ToString()); } if (settingsRow.Table.Columns.Contains("userid")) { connectionType.SupportsUserID = GetSettingState(settingsRow["userid"].ToString(),true); connectionType.PromptUserID = GetSettingValue(settingsRow["userid"].ToString()); } if (settingsRow.Table.Columns.Contains("password")) { connectionType.SupportsPassword = GetSettingState(settingsRow["password"].ToString(),true); connectionType.PromptPassword = GetSettingValue(settingsRow["password"].ToString()); } if (settingsRow.Table.Columns.Contains("filter")) { connectionType.SupportsFilter = GetSettingState(settingsRow["filter"].ToString(),false); connectionType.PromptFilter = GetSettingValue(settingsRow["filter"].ToString()); } } // Read each of the Providers Details // -------------------------------------------------------------- foreach (DataRow providersRow in connectionRow.GetChildRows("connection_providers")) { foreach (DataRow providerRow in providersRow.GetChildRows("providers_provider")) { DbConnectionProvider connectionProvider = new DbConnectionProvider(); connectionProvider.Name = providerRow["name"].ToString(); connectionProvider.ProviderTypeName = providerRow["type"].ToString(); connectionProvider.Parent = connectionType; connectionProvider.Template = Regex.Replace(providerRow["provider_Text"].ToString(), @"[\r\t\n]", ""); if (providerRow.Table.Columns.Contains("allowEmptyParameters")) connectionProvider.AllowEmptyParameters = GetSettingState(providerRow["allowEmptyParameters"].ToString(), true); if (providerRow.Table.Columns.Contains("enabled")) connectionProvider.Enabled = GetSettingState(providerRow["enabled"].ToString(),true); if (providerRow.Table.Columns.Contains("fileMask")) connectionProvider.FileMask = providerRow["fileMask"].ToString(); connectionType.Providers.Add(connectionProvider); } } connectionTypes.Add(connectionType); } return connectionTypes; } catch (Exception ex) { throw new ApplicationException(String.Format("Could not reference the ProviderConfig.xml configuration file: {0}\n{1}", config, ex.Message)); } }
public DatabasePokayoke(string name, string connectionString, DbConnectionType dbType) : base() { _connectionString = connectionString; _dbType = dbType; Title = string.Format("{0} Database Available", name); }
public DatabasePokayoke(string connectionString, DbConnectionType dbType) : base() { _connectionString = connectionString; _dbType = dbType; Title = string.Format("{0} Available", DatabaseCatalog.Name(connectionString)); }
public DbConnectionProvider( string name, string type, string template, DbConnectionType parent) { Name = name; Template = template; ProviderTypeName = type; Parent = parent; }
/////////////////////////////////////////////////////////////////////// public static ReturnCode CreateDbConnection( Interpreter interpreter, DbConnectionType dbConnectionType, string connectionString, string typeFullName, string typeName, ValueFlags valueFlags, DbConnectionTypeStringDictionary dbConnectionTypeFullNames, DbConnectionTypeStringDictionary dbConnectionTypeNames, ref IDbConnection connection, ref Result error ) { try { switch (dbConnectionType) { case DbConnectionType.None: { // // NOTE: The caller explicitly requested an invalid // database connection; therefore, return one. // connection = null; return(ReturnCode.Ok); } case DbConnectionType.Odbc: { connection = new OdbcConnection(connectionString); return(ReturnCode.Ok); } case DbConnectionType.OleDb: { connection = new OleDbConnection(connectionString); return(ReturnCode.Ok); } case DbConnectionType.Sql: { connection = new SqlConnection(connectionString); return(ReturnCode.Ok); } case DbConnectionType.Other: { return(CreateOtherDbConnection( interpreter, dbConnectionType, connectionString, typeFullName, typeName, valueFlags, ref connection, ref error)); } default: { // // NOTE: Lookup the type name and/or full name and // then go to the "other" case (for database // connection types that are not "built-in"). // bool found = false; if ((dbConnectionTypeFullNames != null) && dbConnectionTypeFullNames.TryGetValue( dbConnectionType, out typeFullName)) { found = true; } if ((dbConnectionTypeNames != null) && dbConnectionTypeNames.TryGetValue( dbConnectionType, out typeName)) { found = true; } if (found) { goto case DbConnectionType.Other; } error = String.Format( "unsupported database connection type \"{0}\"", dbConnectionType); break; } } } catch (Exception e) { error = e; } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// private static ReturnCode CreateOtherDbConnection( Interpreter interpreter, DbConnectionType dbConnectionType, string connectionString, string typeFullName, string typeName, ValueFlags valueFlags, ref IDbConnection connection, ref Result error ) { if (interpreter == null) { error = "invalid interpreter"; return(ReturnCode.Error); } if (String.IsNullOrEmpty(typeFullName) && String.IsNullOrEmpty(typeName)) { error = String.Format( "invalid type name for database connection type \"{0}\"", dbConnectionType); return(ReturnCode.Error); } ResultList errors = null; foreach (string thisTypeName in new string[] { typeFullName, typeName }) { if (!String.IsNullOrEmpty(thisTypeName)) { try { Type type = null; if (Value.GetType( interpreter, thisTypeName, null, interpreter.GetAppDomain(), valueFlags, interpreter.CultureInfo, ref type, ref errors) == ReturnCode.Ok) { connection = (IDbConnection)Activator.CreateInstance( type, new object[] { connectionString }); return(ReturnCode.Ok); } } catch (Exception e) { if (errors == null) { errors = new ResultList(); } errors.Add(e); } } } error = errors; return(ReturnCode.Error); }
//DbConnectionType is a custom enum public MultiSqlCommand(DbConnectionType connType, DbConnection conn) {
public bool Equals(GenericDbConnectionInfo?other) => other != null && DbConnectionType.Equals(other.DbConnectionType) && DataReaderType.Equals(other.DataReaderType);