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)
{
}
