public ORGRoleHelper(string string_2) { string item = ConfigurationManager.AppSettings["SYSPRIVDB"]; string[] strArrays = new string[] { "||" }; string[] strArrays1 = item.Split(strArrays, StringSplitOptions.RemoveEmptyEntries); if (!(strArrays1[0].ToLower() == "sqlserver" ? false : !(strArrays1[0].ToLower() == "sql"))) { this.dataProviderType_0 = DataProviderType.Sql; } else if (strArrays1[0].ToLower() == "oracle") { this.dataProviderType_0 = DataProviderType.Oracle; } else if (strArrays1[0].ToLower() == "oledb") { this.dataProviderType_0 = DataProviderType.OleDb; } else if (strArrays1[0].ToLower() == "odbc") { this.dataProviderType_0 = DataProviderType.Odbc; } else if (strArrays1[0].ToLower() == "access") { this.dataProviderType_0 = DataProviderType.Access; } this.string_1 = strArrays1[1]; this.string_0 = string_2; }
public ValidateConnectionView(string connectionString, DataProviderType dataProvider) { _connectionString = connectionString; _dataProvider = dataProvider; ViewModel = ServiceLocator.Current.GetService <ValidateConnectionViewModel>(); InitializeComponent(); Loaded += OnLoaded; }
public void CreateParameters(int count) { DataProviderType dataProvider = (DataProviderType)Enum.Parse(typeof(DataProviderType), DataProviderTypeString, true); parameters = new IDataParameter[count]; parameters = GetParameters(dataProvider, count); }
/// <summary> /// Gets data provider by specific type /// </summary> /// <param name="dataProviderType">Data provider type</param> /// <returns></returns> public static INopDataProvider GetDataProvider(DataProviderType dataProviderType) { return(dataProviderType switch { DataProviderType.SqlServer => new MsSqlNopDataProvider(), DataProviderType.MySql => new MySqlNopDataProvider(), DataProviderType.PostgreSQL => new PostgreSqlDataProvider(), _ => throw new NopException($"Not supported data provider name: '{dataProviderType}'"), });
public ApplicationContext(string connectionString, DataProviderType providerType) { _connectionString = connectionString; _providerType = providerType; if (Database.EnsureCreated()) { Database.Migrate(); } }
public DataManager(DataProviderType providerType, string connectionString) { strConnectionString = connectionString; dataProviderType = providerType; dbConnection = DBFactory.GetConnection(providerType); dbConnection.ConnectionString = connectionString; }
public static DataProviderType GetProviderType(DbProviderFactory providerFactory) { string name = providerFactory.GetType().Name; List <DataProviderType> providers = ((DataProviderType[])Enum.GetValues(typeof(DataProviderType))).ToList(); DataProviderType providerType = providers.SingleOrDefault(e => e.GetAttributeValue <ProviderAttribute>(p => p.FactoryType).ToString() .Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)[0] == name); return(providerType); }
/// <summary> /// Gets data provider by specific type /// </summary> /// <param name="dataProviderType">Data provider type</param> /// <returns></returns> public static IFAADDataProvider GetDataProvider(DataProviderType dataProviderType) { switch (dataProviderType) { case DataProviderType.SqlServer: return(new MsSqlFAADDataProvider()); default: throw new Exception($"Not supported data provider name: '{dataProviderType}'"); } }
public static void TestProvider(DataProviderType providerType) { DatabaseCore db = DatabaseCore.Create(providerType, @"Data Source=(localdb)\MSSQLLocalDB;Database=ZKTecoTime;User ID=manuel.ortiz;Password=1910Skynet;Pooling=true;Encrypt=False;TrustServerCertificate=False;Trusted_Connection=Yes;"); using (var cn = db.CreateOpenConnection()) { cn.Open(); cn.Close(); cn.Dispose(); } }
public ConfigSettings(string ConnectionString, string CommandText, DataProviderType DataStore) { _ConnectionString = ConnectionString; switch(DataStore) { case DataProviderType.Sql: _DBCommand = new SqlCommand(CommandText);break; case DataProviderType.OleDb: _DBCommand = new OleDbCommand(CommandText);break; case DataProviderType.Odbc: _DBCommand = new OdbcCommand(CommandText);break; } _DataStore = DataStore; }
public string Creator(DataProviderType providerType, string server, string username, string password, string database) { switch(providerType) { case DataProviderType.MSSQL: return "SERVER=" + server + ";DATABASE=" + database + ";UID=" + username + ";PWD=" + password + ";" ; case DataProviderType.MySql: return @"Data Source="+database+";Password="******";User ID="+username+";Location="+server+";"; default: return "Data Source=" + server + ";Initial Catalog=" + database + ";User Id=" + username + ";Password="******";" ; } }
public static void AddDataProvider(this IServiceCollection services, DataProviderType dataProvider) { if (dataProvider == DataProviderType.JsonFileStore) { services.AddScoped(typeof(IRepository <>), typeof(JsonFileRepository <>)); services.AddScoped <JsonFileContext>(); } else if (dataProvider == DataProviderType.MsSqlServer) { throw new NotImplementedException(); } }
public void CanBuildConnectionString(DataProviderType type) { if (!SetDataProviderType(type)) { return; } var dataProvider = GetService <INopDataProvider>(); var connStr = dataProvider.BuildConnectionString(new InstallModel { DatabaseName = "test_db", ServerName = "127.0.0.1", IntegratedSecurity = false, Username = "******", Password = "******" }); switch (type) { case DataProviderType.Unknown: connStr.Should() .Be(@$ "Data Source={CommonHelper.DefaultFileProvider.MapPath($" ~ / App_Data / ")}test_db.sqlite;Mode=ReadWrite;Cache=Shared;Password=passwd"); break; case DataProviderType.SqlServer: connStr.Should() .Be(@"Data Source=127.0.0.1;Initial Catalog=test_db;Integrated Security=False;Persist Security Info=False;User ID=test;Password=passwd;Trust Server Certificate=True"); break; case DataProviderType.MySql: connStr.Should() .Be(@"server=127.0.0.1;database=test_db;allowuservariables=True;user id=test;password=passwd"); break; case DataProviderType.PostgreSQL: connStr.Should() .Be(@"Host=127.0.0.1;Database=test_db;Username=test;Password=passwd"); break; } Assert.Throws <ArgumentNullException>(() => dataProvider.BuildConnectionString(null)); if (type == DataProviderType.SqlServer) { return; } Assert.Throws <NopException>(() => dataProvider.BuildConnectionString(new InstallModel() { IntegratedSecurity = true })); }
public DBConnectionPool(DataProviderType dbType, string connString, int poolSize) { m_PoolSize = poolSize; m_ConnectionString = connString; m_dbType = dbType; mConnPool = new Mutex(false, "DBConnPool"); dbConnPool = new DBConnection[m_PoolSize]; isConnFree = new bool[m_PoolSize]; //Initialize(dbType, connString); }
/// <summary> /// Gets the corresponding DataProvider of the type passed in. /// </summary> /// <param name="dataProviderType">The type of DataProvider requested.</param> /// <param name="connectionProperties">The string properties used to create a connection string.</param> /// <returns>DataProvider of corresponding type.</returns> public static DataProviderBase GetDataProvider(DataProviderType dataProviderType, params string[] connectionProperties) { switch (dataProviderType) { case DataProviderType.Sql: return new SqlDataProvider(connectionProperties); case DataProviderType.Sqlite: return new SqliteDataProvider(connectionProperties); default: throw new ArgumentException("Invalid DataProviderType"); } }
public static CommentStrategy GetStrategy(DataProviderType dataProviderType, string connection, Table table) { if (dataProviderType == DataProviderType.Oracle) { return(new CommentStrategyOracle(connection, table)); } else if (dataProviderType == DataProviderType.SqlClient) { return(new CommentStrategySQLServer(connection, table)); } return(new CommentStrategy(connection, table)); }
public static IDataProvider GetDataProvider(DataProviderType dataProviderType) { if (dataProviderType == DataProviderType.MSSql) { return(new MSSqlDataProvider()); } if (dataProviderType == DataProviderType.MySql) { return(new MySqlDataProvider()); } return(null); }
public static DataAccessLayerBaseClass GetDataAccessLayer(DataProviderType dataProviderType, string connectionString) { // construct specific data access provider class switch (dataProviderType) { case DataProviderType.Mysql: return(new MySqlDataAccessLayer(connectionString)); default: throw new ArgumentException("Invalid data access layer provider type."); } }
public override DALBaseClass GetDataAccessLayer(DataProviderType dataProviderType) { switch (dataProviderType) { case DataProviderType.MsSQL: return(new MsSqlDAL(Properties.Resources.MsSQLConnectionString)); case DataProviderType.MySQL: return(new MySqlDAL(Properties.Resources.MySQLConnectionString)); default: throw new ArgumentException("Invalid DAL provider type."); } }
public string Creator(DataProviderType providerType, string server, string username, string password, string database) { switch (providerType) { case DataProviderType.SqlClient: return("SERVER=" + server + ";DATABASE=" + database + ";UID=" + username + ";PWD=" + password + ";"); case DataProviderType.MySql: return(@"Data Source=" + database + ";Password="******";User ID=" + username + ";Location=" + server + ";"); default: return("Data Source=" + server + ";Initial Catalog=" + database + ";User Id=" + username + ";Password="******";"); } }
public static IDataProvider CreateDataProvider(DataProviderType type) { switch (type) { case DataProviderType.Mock: return(new MockDataProvider()); case DataProviderType.SqlServer: return(new SqlServerDataProvider()); default: return(new MockDataProvider()); } }
private void btnTestConnection_Click(object sender, EventArgs e) { DataProviderType oleDb = DataProviderType.OleDb; string str = ""; if (this.radioGroup1.SelectedIndex == 0) { str = this.SQLTemplete.Replace("#SERVER#", this.txtServer.Text) .Replace("#USER#", this.txtUser.Text) .Replace("#PASSWORD#", this.txtPassword.Text) .Replace("#DATABASE#", this.txtDatabase.Text); oleDb = DataProviderType.Sql; } else if (this.radioGroup1.SelectedIndex == 1) { str = this.OraceleTemplete.Replace("#SERVER#", this.txtServer.Text) .Replace("#USER#", this.txtUser.Text) .Replace("#PASSWORD#", this.txtPassword.Text); oleDb = DataProviderType.OleDb; } else { str = this.OLETemplete.Replace("#DATABASE#", this.txtServer.Text); } if (str != "") { DataAccessLayerBaseClass dataAccessLayer = DataAccessLayerFactory.GetDataAccessLayer(oleDb, str); try { try { if (dataAccessLayer.Open()) { MessageBox.Show("连接成功!"); dataAccessLayer.Close(); } } catch (Exception exception) { MessageBox.Show(exception.Message); } } finally { } } }
public static IDbConnection GetDbConnection(DataProviderType provider) { IDbConnection connection = null; switch (provider) { case DataProviderType.SqlServer: connection = new SqlConnection(ConfigurationManager.ConnectionStrings["RoomBookingConStr"].ConnectionString); break; case DataProviderType.Oracle: break; } return(connection); }
// SQL Server Connection String // "PERSIST SECURITY INFO=FALSE;INTEGRATED SECURITY=SSPI;DATA SOURCE=ASCLARITYDEV;INITIAL CATALOG=CLARITY;CONNECT TIMEOUT=6000" // OLE DB Connection String // "Provider=SQLOLEDB;Server=ASCLARITYDEV;Database=CLARITY;Integrated Security=SSPI" // ODBC Connection String // "Server=myServerAddress;Database=myDataBase;Trusted_Connection=True;" // "Driver={SQL Server Native Client 11.0};Server=ASCLARITYDEV;Database=CLARITY;Trusted_Connection=True;" #endregion /// <summary> /// Gets the connection string for the database and provider. The environment is inferred based on the machin name. /// If the machine is identified in Active Directory as belonging to the DEV_GROUP_NAME, then the connection string /// will be for DEV. All other machines will retrieve the production connection string unless overridden. /// </summary> /// <param name="database">string</param> /// <param name="dataProviderType">DataProviderType</param> /// <returns>string</returns> public static string GetConnectionString(string database, DataProviderType dataProviderType) { string machineName = System.Environment.MachineName; string connectionString = ""; if (GHCActiveDirectory.IsMemberOf(machineName, GHCActiveDirectory.PrincipalType.Machine, DEV_GROUP_NAME)) { connectionString = GetConnectionString(database, dataProviderType, DBEnvironment.DEV); } else { connectionString = GetConnectionString(database, dataProviderType, DBEnvironment.PROD); } return(connectionString); }
public static DbCommand GetCommand(DataProviderType providerType) { switch (providerType) { case DataProviderType.SQLSERVER: return(new SqlCommand()); case DataProviderType.OLEDB: return(new OleDbCommand()); case DataProviderType.ODBC: return(new OdbcCommand()); default: return(null); } }
public static bool SetDataProviderType(DataProviderType type) { var dataConfig = Singleton <DataConfig> .Instance ?? new DataConfig(); dataConfig.DataProvider = type; dataConfig.ConnectionString = string.Empty; try { switch (type) { case DataProviderType.SqlServer: dataConfig.ConnectionString = _resourceManager.GetString("sql server connection string"); break; case DataProviderType.MySql: dataConfig.ConnectionString = _resourceManager.GetString("MySql server connection string"); break; case DataProviderType.PostgreSQL: dataConfig.ConnectionString = _resourceManager.GetString("PostgreSql server connection string"); break; case DataProviderType.Unknown: dataConfig.ConnectionString = "Data Source=nopCommerceTest.sqlite;Mode=Memory;Cache=Shared"; break; } } catch (MissingManifestResourceException) { //ignore } Singleton <DataConfig> .Instance = dataConfig; var flag = !string.IsNullOrEmpty(dataConfig.ConnectionString); if (Singleton <AppSettings> .Instance == null) { return(flag); } Singleton <AppSettings> .Instance.Update(new List <IConfig> { Singleton <DataConfig> .Instance }); return(flag); }
public async Task CanGetTableIdentAsync(DataProviderType type) { if (!SetDataProviderType(type)) { return; } var dataProvider = GetService <INopDataProvider>(); var gdprConsent = new GdprConsent { DisplayOrder = 10, Message = "Test message 1" }; await dataProvider.TruncateAsync <GdprConsent>(true); dataProvider.GetTable <GdprConsent>().Count().Should().Be(0); var nextId = await dataProvider.GetTableIdentAsync <GdprConsent>(); nextId.Should().Be(type == DataProviderType.Unknown ? 0 : 1); dataProvider.InsertEntity(gdprConsent); nextId = await dataProvider.GetTableIdentAsync <GdprConsent>(); if (type == DataProviderType.SqlServer || type == DataProviderType.Unknown) { nextId.Should().Be(1); } else { nextId.Should().Be(2); } dataProvider.InsertEntity(gdprConsent); nextId = await dataProvider.GetTableIdentAsync <GdprConsent>(); if (type == DataProviderType.SqlServer || type == DataProviderType.Unknown) { nextId.Should().Be(2); } else { nextId.Should().Be(3); } await dataProvider.TruncateAsync <GdprConsent>(true); }
/// <summary> /// Directly gets the data access layer using the provided connection string. The environment and default database /// is overridden. /// </summary> /// <param name="connectionString">string</param> /// <param name="dataProviderType">DataProviderType</param> /// <returns></returns> public static GHCDataAccessLayer GetDataAccessLayer(string connectionString, DataProviderType dataProviderType) { switch (dataProviderType) { //case DataProviderType.OleDb: // return new OleDbDataAccessLayer(connectionString); //case DataProviderType.Odbc: // return new OdbcDataAccessLayer(connectionString); case DataProviderType.Sql: return(new SqlDataAccessLayer(connectionString)); default: throw new ArgumentException("Invalid data access layer provider type."); } }
public static DbDataAdapter GetDataAdapter(DataProviderType providerType) { switch (providerType) { case DataProviderType.SQLSERVER: return(new SqlDataAdapter()); case DataProviderType.OLEDB: return(new OleDbDataAdapter()); case DataProviderType.ODBC: return(new OdbcDataAdapter()); default: return(null); } }
public async Task CanTruncate(DataProviderType type) { if (!SetDataProviderType(type)) { return; } var gdprConsentRepository = GetService <IRepository <GdprConsent> >(); await gdprConsentRepository.InsertAsync(new List <GdprConsent> { new() { Message = "Test message 1" }, new() { Message = "Test message 2" }, new() { Message = "Test message 3" }, new() { Message = "Test message 4" }, new() { Message = "Test message 5" } });
public async Task CanLoadOriginalCopy(DataProviderType type) { if (!SetDataProviderType(type)) { return; } var productRepository = GetService <IRepository <Product> >(); var product = await productRepository.GetByIdAsync(1, _ => default); product.Name = "test name"; var productNew = await productRepository.GetByIdAsync(1, _ => default); var productOld = await productRepository.LoadOriginalCopyAsync(product); productOld.Name.Should().NotBeEquivalentTo(productNew.Name); }
public static DBConnection GetDataAccessLayer(DataProviderType dataProviderType) { switch (dataProviderType) { case DataProviderType.Oracle: return(new OracleDataBase()); case DataProviderType.Sql: return(new SqlDataBase()); case DataProviderType.OleDb: return(new OleDbDataBase()); default: throw new ArgumentException("Invalid DAL provider type."); } }
public override DBase GetDataAccessLayer(DataProviderType dataProviderType) { // construct specific data access provider class switch (dataProviderType) { case DataProviderType.SQLite: return(new SQLiteDAL()); case DataProviderType.MySQL: return(new MySqlDAL()); case DataProviderType.SQLServer: return(new SQLServerDAL()); default: throw new ArgumentException("Invalid data access layer provider type."); } }
public DataAccessProviderTypeFactory(string dataTypeName) { switch(dataTypeName.ToLower().Trim()) { case "sqlclient": _providerType = DataProviderType.MSSQL; break; case "mysql": _providerType = DataProviderType.MySql; break; case "access": _providerType = DataProviderType.Access; break; case "postgressql": _providerType = DataProviderType.PostgresSql; break; case "oracle": _providerType = DataProviderType.Oracle; break; } }
/// <summary> /// Constructs a data access layer data provider. /// </summary> public static BaseDataAccess GetDataAccessLayer(DataProviderType dataProviderType, string connectionString) { // construct specific data access provider class switch (dataProviderType) { case DataProviderType.Access: { //return new OleDbDataAccess(connectionString); throw new NotImplementedException("AccessData is currently not supported."); } case DataProviderType.OleDb: { //return new OleDbDataAccess(connectionString); throw new NotImplementedException("OleDbData is currently not supported."); } case DataProviderType.Odbc: { //return new OdbcDataAccess(connectionString); throw new NotImplementedException("OdbcData is currently not supported."); } case DataProviderType.Oracle: { //return new OracleDataAccessconnectionString); throw new NotImplementedException("OracleData is currently not supported."); } case DataProviderType.Sql: { return new SqlDataAccess(connectionString); } default: throw new ArgumentException("Invalid data access provider type."); } }
public DataAccessProviderInfo(DataProviderType providerType) { _ProviderType = providerType; }
public DataAccessProviderFactory(DataProviderType providerType) { _typeAccessProvider = new DataAccessProviderTypeFactory(providerType); }
public ConfigSettings(string ConnectionString, object CommandObject, DataProviderType DataStore) { _ConnectionString = ConnectionString; _DBCommand = CommandObject; _DataStore = DataStore; }
public DataAccessProviderTypeFactory(DataProviderType dataType) { _providerType = dataType; }
/// <summary> /// Constructs a data access layer based on caller specific data provider. /// Caller of this method must provide the database connection string through ConnectionString property. /// </summary> public static BaseDataAccess GetDataAccessLayer(DataProviderType dataProviderType) { return GetDataAccessLayer(dataProviderType, null); }