public MysqlMetadataReader(string connectionStr) { this._connectionString = connectionStr; DbConnectionStringBuilder connStr = new DbConnectionStringBuilder(); connStr.ConnectionString = _connectionString; DatabaseName = connStr["Database"] as String; }
public static ProviderBuilder GetInstance(DbConnectionStringBuilder connectionstringbuilder) { if (connectionstringbuilder is SqlConnectionStringBuilder) return new SqlProvider(connectionstringbuilder); else if (connectionstringbuilder is MySqlConnectionStringBuilder) return new MysqlProvider(connectionstringbuilder); return null; }
// <Snippet1> static void Main() { DbConnectionStringBuilder builder = new DbConnectionStringBuilder(); builder.ConnectionString = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Demo.mdb;" + "Jet OLEDB:System Database=system.mdw;"; // Try to remove an existing item. TryRemove(builder, "Provider"); // Try to remove a nonexistent item. TryRemove(builder, "User ID"); // Try to remove an existing item, // demonstrating that the search isn't // case sensitive. TryRemove(builder, "DATA SOURCE"); Console.ReadLine(); }
private void OpenCommand_Executed(object sender, ExecutedRoutedEventArgs e) { SaveFieldsToSettings(); DbConnectionStringBuilder connectionStringBuilder = new DbConnectionStringBuilder(); connectionStringBuilder.ConnectionString = ConnectionStringTextBox.Text; SqlConnection sqlConnection = new SqlConnection(connectionStringBuilder.ConnectionString); AuditUpdateParameters parameters = new AuditUpdateParameters { AlwaysRecreateFramework = AlwaysRecreateCheckBox.IsChecked ?? false, AuditingDatabaseConnection = sqlConnection, AuditingFileGroup = AuditingFileGroupTextBox.Text, AuditingSchema = AuditingSchemaTextBox.Text, AuditTableFormat = AuditTableFormatTextBox.Text, AutoDeployToDatabase = AutomaticallyDeployCheckBox.IsChecked ?? false, DatabaseName = sqlConnection.Database, OutputPath = new DirectoryInfo(OutputPathTextBox.Text), RemoveAll = RemoveAllCheckBox.IsChecked ?? false, TrackByPrimaryKeys = MatchByPrimaryKeysCheckBox.IsChecked ?? false, GenerateBaseline = GenerateBaselineCheckBox.IsChecked ?? false }; parameters.ColumnsNotAudited.AddRange(new[] { "", "" }); parameters.ExecuteGrantees.AddRange(ExecuteGranteesTextBox.Text.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); parameters.SchemasToAudit.AddRange(SchemasToAuditTextBox.Text.Trim().Split('\n', ' ')); parameters.TablesNotAudited.AddRange(TablesNotAuditedTextBox.Text.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); parameters.ColumnsNotAudited.AddRange(ColumnsNotAuditedTextBox.Text.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); Generator generator = new Generator(); string sql = generator.GenerateAuditingFrameworkUpdateSql(parameters); SqlWindow sqlWindow = new SqlWindow(); sqlWindow.SqlText = sql; sqlWindow.ShowDialog(); }
private static DbConnectionStringBuilder GetConnectionStringBuilder(LastDirectConnectionString connectionString) { if (connectionString.IsODBC) { return(new OdbcConnectionStringBuilder(connectionString.ConnectionString)); } DbConnectionStringBuilder builder; QuerySource dbType; if (Enum.TryParse(connectionString.DataBaseType, out dbType)) { switch (dbType) { case QuerySource.MSSQL: builder = new SqlConnectionStringBuilder(); break; case QuerySource.SQLite: // ODBC connection string builder is used // for SQLite internal connection // since it handles special connection string adequately builder = new OdbcConnectionStringBuilder(); break; default: builder = new DbConnectionStringBuilder(); break; } } else { builder = new DbConnectionStringBuilder(); } builder.ConnectionString = connectionString.ConnectionString; return(builder); }
private void ResetMSSQLCatalog() { DbConnectionStringBuilder LBuilder = new DbConnectionStringBuilder(); LBuilder.ConnectionString = TestConfiguration.CatalogStoreConnectionString; string LDatabaseName = null; if (LBuilder.ContainsKey("Initial Catalog")) { LDatabaseName = (string)LBuilder["Initial Catalog"]; LBuilder["Initial Catalog"] = "master"; } else if (LBuilder.ContainsKey("Database")) { LDatabaseName = (string)LBuilder["Database"]; LBuilder["Database"] = "master"; } if (!String.IsNullOrEmpty(LDatabaseName)) { if (!Parser.IsValidIdentifier(LDatabaseName)) { throw new ArgumentException("Database name specified in store connection string is not a valid identifier."); } using (SqlConnection LConnection = new SqlConnection(LBuilder.ConnectionString)) { LConnection.Open(); using (SqlCommand LCommand = LConnection.CreateCommand()) { LCommand.CommandType = CommandType.Text; LCommand.CommandText = String.Format("if exists (select * from sysdatabases where name = '{0}') drop database {0}", LDatabaseName); LCommand.ExecuteNonQuery(); } } } }
/// <summary> /// 数据库连接测试 /// </summary> public virtual void TestDbConnection() { if (string.IsNullOrEmpty(_connectionStrings)) { throw new Exception("请填写数据库连接字符串!"); } var dbFactory = DbProviderFactories.GetFactory("System.Data.SqlClient"); DbConnectionStringBuilder connectionStringBuilder = dbFactory.CreateConnectionStringBuilder(); IDbConnection conn = dbFactory.CreateConnection(); if (connectionStringBuilder == null || conn == null) { throw new Exception("数据库连接提供程序未实现!"); } try { connectionStringBuilder.ConnectionString = _connectionStrings; } catch (Exception ex) { throw new Exception("数据库连接字符串格式不正确!异常: " + ex.Message); } try { using (conn) { conn.ConnectionString = connectionStringBuilder.ConnectionString; conn.Open(); } } catch (Exception ex) { throw new Exception("连接测试失败!异常: " + ex.Message); } }
private static void Main() { string connectionString = "Server=main-database-1.postgres.database.azure.com;" + "Database=r51;" + "Port=5432;" + "User Id=database_admin@main-database-1;" + "Password=osj29209gf1-bkhE;" + "Ssl Mode=Require;"; var conStrBuilder = new DbConnectionStringBuilder { { "Server", "main-database-1.postgres.database.azure.com" }, { "Database", "main-database-1" }, { "Port", 5432 }, { "User Id", "database_admin@main-database-1" }, { "Password", "osj29209gf1-bkhE" }, { "Ssl Mode", "Require" } }; Console.WriteLine(connectionString); Console.WriteLine(conStrBuilder.ToString()); // DbContextOptionsBuilder<ApplicationDbContext> builder = new DbContextOptionsBuilder<ApplicationDbContext>(); // builder.UseNpgsql(connectionString); // ApplicationDbContext dbContext = new ApplicationDbContext(builder.Options); // dbContext.Accounts.Add(new Account() // { // Username = "******", // ServiceId = "asofjbna'sbnj", // RegistrationDateTime = DateTime.Now // }); // dbContext.SaveChanges(); // int count = dbContext.Accounts.Count(); // Console.WriteLine(count); // // Console.WriteLine("end"); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req) { try { // Issue a query against Cosmos that forces a native assembly to load. string cosmosConnection = _config.GetConnectionString("CosmosDB"); var builder = new DbConnectionStringBuilder() { ConnectionString = cosmosConnection }; builder.TryGetValue("AccountEndpoint", out object dbUri); builder.TryGetValue("AccountKey", out object dbKey); var client = new DocumentClient(new Uri(dbUri.ToString()), dbKey.ToString()); Uri collUri = UriFactory.CreateDocumentCollectionUri("ItemDb", "ItemCollection"); var options = new FeedOptions { EnableCrossPartitionQuery = true }; IDocumentQuery <Document> documentQuery = client.CreateDocumentQuery <Document>(collUri, "SELECT * FROM c WHERE STARTSWITH(c.id, @PartitionLeasePrefix)", options).AsDocumentQuery <Document>(); await documentQuery.ExecuteNextAsync(); } catch (Exception ex) { return(new ObjectResult(ex.ToString()) { StatusCode = 500 }); } return(new OkResult()); }
public static string GetConnectionString(string connectionStringName) { if (string.IsNullOrEmpty(connectionStringName) == true) { try { connectionStringName = GetAppSetting("DefaultDatabase", ""); } catch (Exception) { return(""); } } else { DbConnectionStringBuilder connectionStringBuilder = new DbConnectionStringBuilder(); try { connectionStringBuilder.ConnectionString = connectionStringName; return(connectionStringName); } catch { // Will go to next try catch } } try { return(ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString); } catch (Exception) { return(""); } }
/// <summary> /// Sets the specified keyword's value to the specified <see cref="string"/> value in the specified <see cref="DbConnectionStringBuilder"/>. /// </summary> /// <param name="value">The <see cref="DbConnectionStringBuilder"/> to set the keyword value for.</param> /// <param name="keyword">The keyword to set the value for.</param> /// <param name="keywordValue">The value to set the keyword to.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="value"/> is <see langword="null"/>. /// </exception> private static void SetKeywordValueAsString(this DbConnectionStringBuilder value, string keyword, string keywordValue) { if (value == null) { throw new ArgumentNullException(nameof(value)); } // N.B. Keywords are used here rather than the strongly-typed derived classes // of DbConnectionStringBuilder. This is so that custom derived classes can be // used and also so that both of the following entity connection string builders // can be used without using reflection and hard-coded type names: // 1) System.Data.EntityClient.EntityClientConnectionStringBuilder (System.Data.Entity.dll) // 2) System.Data.Entity.Core.EntityClient.EntityClientConnectionStringBuilder (EntityFramework.dll) object providerConnectionStringAsObject; if (value.TryGetValue(ProviderConnectionStringKeywordName, out providerConnectionStringAsObject)) { string providerConnectionString = providerConnectionStringAsObject as string; if (!string.IsNullOrEmpty(providerConnectionString)) { // Build a connection string from the provider connection string DbConnectionStringBuilder builder = new DbConnectionStringBuilder() { ConnectionString = providerConnectionString, }; // Set the keyword value in the Provider Connection String and replace // the initial Provider Connection String with the updated one builder[keyword] = keywordValue; value[ProviderConnectionStringKeywordName] = builder.ConnectionString; } } else { value[keyword] = keywordValue; } }
private static string ParseConnectionString(string connectionString, ref string providerName) { if (string.IsNullOrEmpty(connectionString)) { return(connectionString); } var builder = new DbConnectionStringBuilder { ConnectionString = connectionString }; // Replace data directory placeholder const string attachDbFileNameKey = "AttachDbFileName"; const string dataDirectoryPlaceholder = "|DataDirectory|"; if (builder.TryGetValue(attachDbFileNameKey, out var attachDbFileNameValue) && attachDbFileNameValue is string attachDbFileName && attachDbFileName.Contains(dataDirectoryPlaceholder)) { var dataDirectory = AppDomain.CurrentDomain.GetData("DataDirectory")?.ToString(); if (!string.IsNullOrEmpty(dataDirectory)) { builder[attachDbFileNameKey] = attachDbFileName.Replace(dataDirectoryPlaceholder, dataDirectory); // Mutate the existing connection string (note: the builder also lowercases the properties) connectionString = builder.ToString(); } } // Also parse provider name now we already have a builder if (string.IsNullOrEmpty(providerName)) { providerName = ParseProviderName(builder); } return(connectionString); }
/// <summary> /// Gets the connection by connection string. /// </summary> /// <param name="connectionString">The name or connection string.</param> /// <returns></returns> /// <remarks>Based on: http://stackoverflow.com/a/185571/201019. </remarks> private static DbConnection GetConnectionByConnectionString(string connectionString) { string providerName = null; var csb = new DbConnectionStringBuilder { ConnectionString = connectionString }; if (csb.ContainsKey("provider")) { providerName = csb["provider"].ToString(); } else { var css = ConfigurationManager .ConnectionStrings .Cast <ConnectionStringSettings>() .FirstOrDefault(x => x.ConnectionString == connectionString); if (css != null) { providerName = css.ProviderName; } } if (providerName != null) { var providerExists = DbProviderFactories .GetFactoryClasses() .Rows.Cast <DataRow>() .Any(r => r[2].Equals(providerName)); if (providerExists) { var factory = DbProviderFactories.GetFactory(providerName); return(factory.CreateConnection()); } } return(null); }
public IDbConnection Get(string connectionString) { var csb = new DbConnectionStringBuilder(); csb.ConnectionString = connectionString; string providerName = string.Empty; if (csb.ContainsKey("pbix")) { providerName = "Microsoft.AnalysisServices.AdomdClient"; var connectionStringBuilder = GetPowerBiDesktopConnectionStringBuilder(); connectionStringBuilder.Build(csb["pbix"].ToString()); connectionString = connectionStringBuilder.GetConnectionString(); } if (csb.ContainsKey("Provider")) { providerName = InterpretProviderName(csb["Provider"].ToString()); } if (string.IsNullOrEmpty(providerName) && csb.ContainsKey("Driver")) { providerName = "System.Data.Odbc"; } if (string.IsNullOrEmpty(providerName)) { providerName = "System.Data.SqlClient"; } if (string.IsNullOrEmpty(providerName)) { throw new ArgumentException(string.Format("No provider found for connectionString '{0}'", connectionString)); } return(Get(providerName, connectionString)); }
// <Snippet1> static void Main() { DbConnectionStringBuilder builder1 = new DbConnectionStringBuilder(); builder1.ConnectionString = "Value1=SomeValue;Value2=20;Value3=30;Value4=40"; Console.WriteLine("builder1 = " + builder1.ConnectionString); DbConnectionStringBuilder builder2 = new DbConnectionStringBuilder(); builder2.ConnectionString = "value2=20;value3=30;VALUE4=40;Value1=SomeValue"; Console.WriteLine("builder2 = " + builder2.ConnectionString); DbConnectionStringBuilder builder3 = new DbConnectionStringBuilder(); builder3.ConnectionString = "value2=20;value3=30;VALUE4=40;Value1=SOMEVALUE"; Console.WriteLine("builder3 = " + builder3.ConnectionString); // builder1 and builder2 contain the same // keys and values, in different order, and the // keys are not consistently cased. They are equivalent. Console.WriteLine("builder1.EquivalentTo(builder2) = " + builder1.EquivalentTo(builder2).ToString()); // builder2 and builder3 contain the same key/value pairs in the // the same order, but the value casing is different, so they're // not equivalent. Console.WriteLine("builder2.EquivalentTo(builder3) = " + builder2.EquivalentTo(builder3).ToString()); Console.WriteLine("Press Enter to continue."); Console.ReadLine(); }
public static DatabaseProviders DetectProviderFromConnectionString(string connString) { var builder = new DbConnectionStringBuilder { ConnectionString = connString }; var allKeys = builder.Keys.Cast <string>(); var mySql = new[] { "Server", "Database", "Uid", "Pwd" }; if (mySql.All(x => allKeys.InvariantContains(x))) { return(DatabaseProviders.MySql); } if (allKeys.InvariantContains("Data Source") //this dictionary is case insensitive && builder["Data source"].ToString().InvariantContains(".sdf")) { return(DatabaseProviders.SqlServerCE); } return(DatabaseProviders.SqlServer); }
public static string GetUserId(this DbConnectionStringBuilder builder, DataAccessProviderType?providerType = null) { if (IsOleDb(builder)) { return(builder.TryGetValue("User ID", out var value) ? (string)value : null); } if (providerType == DataAccessProviderType.Odbc || IsOdbc(builder)) { return(builder.TryGetValue("UID", out var value) ? (string)value : null); } return(builder.TryGetValue("User ID", out var oleDbValue) ? (string)oleDbValue : builder.TryGetValue("UID", out var odbcValue) ? (string)odbcValue : null); }
public bool RespondsWithinTime(DbConnectionStringBuilder builder, int timeoutInSeconds, out Exception exception) { try { var copyBuilder = GetConnectionStringBuilder(builder.ConnectionString); copyBuilder[ConnectionTimeoutKeyName] = timeoutInSeconds; using (var con = GetConnection(copyBuilder)) { con.Open(); con.Close(); exception = null; return(true); } } catch (Exception e) { exception = e; return(false); } }
public void Open(string filename) { string databasefile = filename; bool newdatabase = false; if (!File.Exists(databasefile)) { newdatabase = true; } StringBuilder b = new StringBuilder(); DbConnectionStringBuilder.AppendKeyValuePair(b, "Data Source", databasefile); DbConnectionStringBuilder.AppendKeyValuePair(b, "Version", "3"); DbConnectionStringBuilder.AppendKeyValuePair(b, "New", "True"); DbConnectionStringBuilder.AppendKeyValuePair(b, "Compress", "True"); DbConnectionStringBuilder.AppendKeyValuePair(b, "Journal Mode", "Off"); sqliteConn = new SQLiteConnection(b.ToString()); sqliteConn.Open(); if (newdatabase) { CreateTables(); } }
// Awesome SQL CE 4 speed improvement by Erik Ejskov Jensen - SQL CE 4 MVP // It's not an issue with SQL CE 4 that we never close the connection public static SqlCeConnection Open(string connectionString) { var connectionStringBuilder = new DbConnectionStringBuilder(); try { connectionStringBuilder.ConnectionString = connectionString; } catch (Exception ex) { throw new ArgumentException("Bad connection string.", "connectionString", ex); } connectionStringBuilder.Remove("datalayer"); // SQL CE 4 performs better when there's always a connection open in the background ensureOpenBackgroundConnection(connectionStringBuilder.ConnectionString); SqlCeConnection conn = new SqlCeConnection(connectionStringBuilder.ConnectionString); conn.Open(); return(conn); }
/// <summary> /// Generate connection string with the given properties /// </summary> /// <param name="connectionDto">Connection details</param> /// <returns>Connection string of the database</returns> private static string GenerateConnectionString(ConnectionDto connectionDto) { DbConnectionStringBuilder connectionBuilder = null; string connectionString = string.Empty; connectionBuilder = new MySqlConnectionStringBuilder(); if (connectionBuilder != null) { // Populate connection builder with connection properties foreach (KeyValuePair <string, string> property in connectionDto.Properties) { if (connectionBuilder.ContainsKey(property.Key) && !string.IsNullOrEmpty(property.Value)) { connectionBuilder.Add(property.Key, property.Value); } } connectionString = connectionBuilder.ConnectionString; connectionDto.ConnectionString = connectionString; } return(connectionString); }
/// <summary> /// To get the connection of the database (using Non_PCROnBoard). /// </summary> /// <returns></returns> public static DbConnection GetMasterConnection() { DbConnectionStringBuilder csb; var entityCnxStringBuilder = new EntityConnectionStringBuilder { ProviderConnectionString = new SqlConnectionStringBuilder(System.Configuration.ConfigurationManager .ConnectionStrings["PCROnBoardUMS"].ConnectionString).ConnectionString }; entityCnxStringBuilder.Provider = "System.Data.SqlClient"; var sqlCnxStringBuilder = new SqlConnectionStringBuilder(entityCnxStringBuilder.ProviderConnectionString); csb = new DbConnectionStringBuilder { ConnectionString = sqlCnxStringBuilder.ConnectionString }; string providerName = "System.Data.SqlClient"; var factory = DbProviderFactories.GetFactory(providerName); var dbConnection = factory.CreateConnection(); dbConnection.ConnectionString = csb.ConnectionString; return(dbConnection); }
private bool CheckFields() { DbConnectionStringBuilder csb = new DbConnectionStringBuilder(); if (!CString.IsValid()) { _status.Text = "Bad connection string"; return(false); } if (_tableName.Text == String.Empty || _tableName.Text.Contains(' ')) { _status.Text = "Bad destination table name"; return(false); } if (!_table.Columns.Contains(_primaryKey.Text)) { _status.Text = "Bad primary key"; return(false); } return(true); }
// <Snippet1> static void Main() { DbConnectionStringBuilder builder = new DbConnectionStringBuilder(); builder.Add("Provider", "Provider=Microsoft.Jet.OLEDB.4.0"); builder.Add("Data Source", "C:\\ThisExcelWorkbook.xls"); builder.Add("Extended Properties", "Excel 8.0;HDR=Yes;IMEX=1"); // Displays the values in the DbConnectionStringBuilder. Console.WriteLine("Contents of the DbConnectionStringBuilder:"); Console.WriteLine(builder.ConnectionString); // Searches for a key. if (builder.ContainsKey("Data Source")) { Console.WriteLine("The collection contains the key \"Data Source\"."); } else { Console.WriteLine("The collection does not contain the key \"Data Source\"."); } Console.ReadLine(); }
private static DbConnectionStringBuilder CreateConnectionString(DbProviderFactory providerFactory, string dataSource, string database, string user, string password) { DbConnectionStringBuilder connectionStringBuilder = providerFactory.CreateConnectionStringBuilder(); connectionStringBuilder = providerFactory.CreateConnectionStringBuilder(); connectionStringBuilder["Data Source"] = dataSource; if (!string.IsNullOrEmpty(database)) { connectionStringBuilder["Initial Catalog"] = database; } if (string.IsNullOrEmpty(user)) { connectionStringBuilder["Integrated Security"] = "SSPI"; } else { connectionStringBuilder["User ID"] = user; connectionStringBuilder["Password"] = password; } return(connectionStringBuilder); }
public void Initialize(string connectionString, Action <QueueLengthEntry[], EndpointToQueueMapping> storeDto) { var builder = new DbConnectionStringBuilder { ConnectionString = connectionString }; if (builder.ContainsKey("AccessKeyId") || builder.ContainsKey("SecretAccessKey")) { // if the user provided the access key and secret access key they should always be loaded from environment credentials clientFactory = () => new AmazonSQSClient(new EnvironmentVariablesAWSCredentials()); } else { //See https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html#creds-assign Logger.Info("BasicAWSCredentials have not been supplied in the connection string. Attempting to use existing environment or IAM role credentials."); } if (builder.TryGetValue("QueueNamePrefix", out var prefix)) { queueNamePrefix = (string)prefix; } store = storeDto; }
private static DbConnectionStringBuilder GetBuilder(string serverNameOrConnectionString) { DbConnectionStringBuilder csb = new DbConnectionStringBuilder(); try { csb.ConnectionString = serverNameOrConnectionString; } catch (ArgumentException ex) { } if (!csb.ContainsKey("Provider")) { csb.Add(ProviderKey, "MSOLAP"); } if (!csb.ContainsAny("Data Source", "DataSource")) { csb.Add(DataSourceKey, serverNameOrConnectionString); } return(csb); }
public string ToString(bool commandLine) { if (commandLine) { string targets = string.Join(" ", Targets.Select(t => t.Name == t.Schema ? t.Name : t.Name + ":" + t.Schema).ToArray()); DbConnectionStringBuilder csb = new DbConnectionStringBuilder(); csb.ConnectionString = Provider.ConnectionString; csb.Add("Provider", Provider.Name); string batch = BatchSize != DefaultBatchSize ? " batch:" + BatchSize : ""; string cmdLine = string.Format("{7} source:\"{0}\" target:\"{1}\"{2}{3}{4}{5} {6}", Source, csb.ConnectionString, batch, Indices ? " indices" : "", FullText ? " fulltext" : "", Split ? " split" : "", targets, Path.GetFileName(Assembly.GetExecutingAssembly().Location)); return(cmdLine); } else { return (string.Format("Source : {0}\r\nTarget : {1}\r\nOptions : {2}", Source, Target, Options)); } }
private async Task <DocumentClient> InitializeDocumentClientAsync() { var builder = new DbConnectionStringBuilder(); builder.ConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(CosmosDBConfiguration.AzureWebJobsCosmosDBConnectionStringName); var serviceUri = new Uri(builder["AccountEndpoint"].ToString()); var client = new DocumentClient(serviceUri, builder["AccountKey"].ToString()); var database = new Database() { Id = DatabaseName }; await client.CreateDatabaseIfNotExistsAsync(database); var collection = new DocumentCollection() { Id = CollectionName }; await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseName), collection); return(client); }
private void ConfigureBinaryGuid(IDictionary <string, string> settings) { // We can use a SQLite specific setting to force it, but in common cases it // should be detected automatically from the connection string below. settings.TryGetValue(Cfg.Environment.SqliteBinaryGuid, out var strBinaryGuid); if (string.IsNullOrWhiteSpace(strBinaryGuid)) { string connectionString = Cfg.Environment.GetConfiguredConnectionString(settings); if (!string.IsNullOrWhiteSpace(connectionString)) { var builder = new DbConnectionStringBuilder { ConnectionString = connectionString }; strBinaryGuid = GetConnectionStringProperty(builder, "BinaryGuid"); } } // Note that "BinaryGuid=false" is supported by System.Data.SQLite but not Microsoft.Data.Sqlite. _binaryGuid = string.IsNullOrWhiteSpace(strBinaryGuid) || bool.Parse(strBinaryGuid); }
public static OdbcConnection CreateOdbcConnextion() { DbConnectionStringBuilder connectionString = new DbConnectionStringBuilder(); connectionString.Add("Dsn", ""); connectionString.Add("Driver", "{SAGE Gestion commerciale 100}"); ConnexionSaveLoad settings = new ConnexionSaveLoad(); if (settings.isSettings()) { settings.Load(); connectionString.Add("Dsn", settings.configurationConnexion.ODBC.DNS); connectionString.Add("uid", settings.configurationConnexion.ODBC.USER); connectionString.Add("pwd", settings.configurationConnexion.ODBC.PWD); //connectionString__ = @"Data Source=" + directory_db + ";uid="+ settings.configurationConnexion.ODBC.USER + ";pwd="+ settings.configurationConnexion.ODBC.PWD + ";"; } return(new OdbcConnection(connectionString.ConnectionString)); //return new OdbcConnection(connectionString__); }
public virtual ElasticsearchClientOption Execute(string connectionString) { var tokens = new DbConnectionStringBuilder() { ConnectionString = connectionString }; var option = new ElasticsearchClientOption(connectionString) { Hostname = tokens.TryGet(Hostname, out string host) ? host : throw new ArgumentException("Hostname is mandatory for an Elasticsearch connection string"), Port = tokens.Get(Port, 9200) }; if (tokens.TryGet(Username, out string username) ^ tokens.TryGet(Password, out string password)) { throw new ArgumentException("username and password must be both filled or none of them must be filled"); } option.Username = username; option.Password = password; return(option); } }
public static Dictionary<string, string> splitConnectionString(string connectionString) { Dictionary<string, string> dt = new Dictionary<string, string>(); DbConnectionStringBuilder builder = new DbConnectionStringBuilder(); builder.ConnectionString = connectionString; foreach (string key in builder.Keys) { dt.Add((string)key, (string)(builder[key])); } return dt; }
public MysqlProvider(DbConnectionStringBuilder connectionstringbuilder) : base(connectionstringbuilder) { }