public static bool GetCloneFactory(this IDbConnection connection, string replaceDatabase, out DbProviderFactory factory, out string cloneConnectString)
{
factory = connection.GetDbFactory();
cloneConnectString = connection.ConnectionString;
if (factory == null)
return false;
if (!string.IsNullOrEmpty(replaceDatabase))
{
var csb = factory.CreateConnectionStringBuilder();
if (csb != null)
{
csb.ConnectionString = connection.ConnectionString;
if (csb.ContainsKey("Data Source"))
{
// SQL-Server, keep Data Source, but change initial catalog
if (csb.ContainsKey("Initial Catalog"))
csb["Initial Catalog"] = replaceDatabase;
else
{
// SQL CE
string directory = Path.GetDirectoryName(csb["Data Source"].ToString());
csb["Data Source"] = Path.Combine(directory, replaceDatabase + ".sdf");
}
}
if (csb.ContainsKey("database"))
{
csb["database"] = replaceDatabase;
}
cloneConnectString = csb.ConnectionString;
}
}
return true;
}
/// <summary>
/// Ham nay de mo ket noi den database
/// </summary>
/// <param name="ServerName"></param>
/// <param name="DatabaseName"></param>
/// <param name="UserId"></param>
/// <param name="Password"></param>
/// <returns></returns>
public static bool DB_OpenConnection(string ServerName, string DatabaseName, string UserId, string Password)
{
DbProviderFactory = System.Data.SqlClient.SqlClientFactory.Instance;
DbConnectionStringBuilder DbConnectionStringBuilder = DbProviderFactory.CreateConnectionStringBuilder();
DbConnectionStringBuilder.Add("Data Source", ServerName);
DbConnectionStringBuilder.Add("User ID", UserId);
DbConnectionStringBuilder.Add("Password", Password);
DbConnectionStringBuilder.Add("Initial Catalog", DatabaseName);
bool IsConnected;
try
{
if (DbConnection == null)
{
DbConnection = DbProviderFactory.CreateConnection();
}
if (DbConnection.State != ConnectionState.Open)
{
DbConnection.ConnectionString = DbConnectionStringBuilder.ConnectionString;
DbConnection.Open();
}
IsConnected = true;
}
catch
{
IsConnected = false;
}
return(IsConnected);
}
public ConnectDialog()
{
InitializeComponent();
factory = DbProviderFactories.GetFactory("MySql.Data.MySqlClient");
if (factory == null)
throw new Exception("MySql Data Provider is not correctly registered");
connectionStringBuilder = factory.CreateConnectionStringBuilder();
connectionProperties.SelectedObject = connectionStringBuilder;
}
private void db_connect(string dbfilename)
{
//if (System.IO.File.Exists(dbfilename)) System.IO.File.Delete(dbfilename);
makeProvider();
_dbfact = DbProviderFactories.GetFactory("System.Data.SQLite");
_dbcon = _dbfact.CreateConnection();
_dbcon.ConnectionString = "Data Source=" + dbfilename + ";Pooling=true;FailIfMissing=false";
_dbconstring = _dbfact.CreateConnectionStringBuilder();
_dbconstring.ConnectionString = "Data Source=" + dbfilename + ";Pooling=true;FailIfMissing=false";
_dbcon.Open();
}
private DbConfiguration(
string providerName
, string name
, string connectionString
, DbProviderFactory dbProviderFactory)
{
DbProviderName = providerName;
Name = name;
DbProviderFactory = dbProviderFactory;
ConnectionString = connectionString;
SetMappingConversion(MappingConversion.Default);
properties = new Dictionary<string, string>();
switch (providerName)
{
case DbProviderNames.SQLite:
connectionCreator = () => new DbConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString, IsFileDatabase = true };
break;
case DbProviderNames.Oledb:
case DbProviderNames.SqlCe35:
case DbProviderNames.SqlCe40:
connectionCreator = () => new DbConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString, IsFileDatabase = true };
break;
case DbProviderNames.SqlServer:
var builder = DbProviderFactory.CreateConnectionStringBuilder();
builder.ConnectionString = connectionString;
builder["MultipleActiveResultSets"] = true;
connectionCreator = () => new DbConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
case DbProviderNames.Oracle_ODP:
connectionCreator = () => new ODPConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
case DbProviderNames.Oracle_Managed_ODP:
connectionCreator = () =>new ManagedODPConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
case DbProviderNames.NLite_Data_Oracle:
(DbProviderFactory as OracleClientFactory).Init(ConnectionString);
connectionCreator = () => new ManagedODPConnectionWrapper(this, DbProviderFactory.CreateConnection());
break;
default:
connectionCreator = () => new DbConnectionWrapper(this, DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
}
if (ConfigurationManager.ConnectionStrings.Count == 1)
MakeDefault();
}
public static bool GetCloneFactory(this IDbConnection connection, string replaceDatabase, out DbProviderFactory factory, out string cloneConnectString)
{
factory = connection.GetDbFactory();
cloneConnectString = connection.ConnectionString;
if (factory == null)
return false;
if (!string.IsNullOrEmpty(replaceDatabase))
{
var csb = factory.CreateConnectionStringBuilder();
if (csb != null)
{
csb.ConnectionString = connection.ConnectionString;
if (csb.ContainsKey("Data Source"))
{
// SQL-Server, keep Data Source, but change initial catalog
if (csb.ContainsKey("Initial Catalog"))
csb["Initial Catalog"] = replaceDatabase;
else
{
// SQL CE
string directory = Path.GetDirectoryName(csb["Data Source"].ToString());
csb["Data Source"] = Path.Combine(directory, replaceDatabase + ".sdf");
}
}
if (csb.ContainsKey("database"))
{
csb["database"] = replaceDatabase;
}
// SQLite
if (csb.ContainsKey("fulluri"))
{
// Typical SQLite connection string using URI format:
// fulluri="file:///C:/ProgramData/Team%20MediaPortal/MP2-Server/Database/Datastore.s3db?cache=shared";version=3;binaryguid=True;default timeout=30000;cache size=65536;journal mode=Wal;pooling=False;synchronous=Normal;foreign keys=True
csb["fulluri"] = REGEX_SQLITE_REPLACE.Replace(csb["fulluri"].ToString(), "$1" + replaceDatabase + "$3");
}
cloneConnectString = csb.ConnectionString;
}
}
return true;
}
private DbConfiguration(
string providerName
, string name
, string connectionString
, DbProviderFactory dbProviderFactory)
{
DbProviderName = providerName;
Name = name;
DbProviderFactory = dbProviderFactory;
ConnectionString = connectionString;
SetMappingConversion(MappingConversion.Default);
switch (providerName)
{
case DbProviderNames.SQLite:
connectionCreator = () => new SQLiteConnectionWrapper(this,DbProviderFactory.CreateConnection()) { ConnectionString = connectionString, IsFileDatabase = true };
break;
case DbProviderNames.Oledb:
case DbProviderNames.SqlCe35:
case DbProviderNames.SqlCe40:
connectionCreator = () => new DbConnectionWrapper(this,DbProviderFactory.CreateConnection()) { ConnectionString = connectionString, IsFileDatabase = true };
break;
case DbProviderNames.SqlServer:
var builder = DbProviderFactory.CreateConnectionStringBuilder();
builder.ConnectionString = connectionString;
builder["MultipleActiveResultSets"] = true;
connectionCreator = () => new DbConnectionWrapper(this,DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
case DbProviderNames.Oracle_ODP:
connectionCreator = () => new ODPConnectionWrapper(this,DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
default:
connectionCreator = () => new DbConnectionWrapper(this,DbProviderFactory.CreateConnection()) { ConnectionString = connectionString };
break;
}
}
private static void PopulateSqlServer2000(DbConnection conn, DbProviderFactory factory, DbConfiguration cfg)
{
if (factory is System.Data.SqlClient.SqlClientFactory)
{
var connectionStringBuilder = factory.CreateConnectionStringBuilder();
connectionStringBuilder.ConnectionString = cfg.ConnectionString;
connectionStringBuilder["Database"] = "master";
var state = conn.State;
if (state != ConnectionState.Open)
conn.Open();
var serverVersion = conn.ServerVersion;
if (state != ConnectionState.Open)
conn.Close();
var version = int.Parse(serverVersion.Substring(0, 2));
if (version < 9)
InitMsSql2000(cfg);
}
}
public static void init(Dictionary<String, String> properties, int maxThreads)
{
sessions = new ConcurrentDictionary<SqlSession, String>(maxThreads, maxThreads);
// don't use the NuoDb provider that is installed on the system, use the one we
// pick from the NuGet repository
//dataSource = DbProviderFactories.GetFactory(properties["dotnet.driver"]);
dataSource = new NuoDbProviderFactory();
DbConnectionStringBuilder connectionStringBuilder = dataSource.CreateConnectionStringBuilder();
connectionStringBuilder.Add("User", properties["user"]);
connectionStringBuilder.Add("Password", properties["password"]);
connectionStringBuilder.Add("Server", properties["url.server"]);
connectionStringBuilder.Add("Database", properties["url.database"]);
connectionStringBuilder.Add("Schema", properties["defaultSchema"]);
connectionStringBuilder.Add("Pooling", "True");
connectionStringBuilder.Add("MaxLifetime", properties["maxAge"]);
if (maxThreads > 100)
{
connectionStringBuilder.Add("MaxConnections", String.Format("{0}", maxThreads));
}
// process any options
String options = properties["url.options"];
if (options.StartsWith("?")) options = options.Substring(1);
String[] optlist = options.Split("&".ToCharArray());
foreach (String opt in optlist)
{
String[] keyval = opt.Split("=".ToCharArray());
if (keyval.Length == 2) connectionStringBuilder.Add(keyval[0], keyval[1]);
else if (keyval.Length == 1) connectionStringBuilder.Add(keyval[0], "true");
}
String isolation = properties["default.isolation"];
if (isolation == null || isolation.Length == 0) isolation = "CONSISTENT_READ";
switch (isolation)
{
case "READ_COMMITTED":
//updateIsolation = Connection.TRANSACTION_READ_COMMITTED;
updateIsolation = IsolationLevel.ReadCommitted;
break;
case "SERIALIZABLE":
//updateIsolation = Connection.TRANSACTION_SERIALIZABLE;
updateIsolation = IsolationLevel.Serializable;
break;
case "CONSISTENT_READ":
//updateIsolation = TransactionIsolation.TRANSACTION_CONSISTENT_READ;
updateIsolation = IsolationLevel.Unspecified;
break;
case "WRITE_COMMITTED":
//updateIsolation = TransactionIsolation.TRANSACTION_WRITE_COMMITTED;
updateIsolation = IsolationLevel.Unspecified;
break;
}
updateConnectionString = connectionStringBuilder.ConnectionString;
// make this one READ_ONLY
connectionStringBuilder.Add("IsolationLevel", "ReadCommitted");
queryConnectionString = connectionStringBuilder.ConnectionString;
}
/// <summary>
///
/// </summary>
/// <param name="dataSource"></param>
/// <param name="providerFactory"></param>
/// <returns></returns>
private static string CreateConnectionString(RdlDataSource dataSource, DbProviderFactory providerFactory)
{
var genericConnectionStringBuilder = providerFactory.CreateConnectionStringBuilder();
Debug.Assert(genericConnectionStringBuilder != null, "genericConnectionStringBuilder != null");
genericConnectionStringBuilder.ConnectionString = dataSource.ConnectionProperties.ConnectString;
var sqlConnectionStringBuilder = genericConnectionStringBuilder as SqlConnectionStringBuilder;
if (sqlConnectionStringBuilder != null)
{
bool integratedSecurity;
if (Boolean.TryParse(dataSource.ConnectionProperties.IntegratedSecurity, out integratedSecurity) &&
integratedSecurity)
{
sqlConnectionStringBuilder.IntegratedSecurity = true;
sqlConnectionStringBuilder.UserID = String.Empty;
sqlConnectionStringBuilder.Password = String.Empty;
}
}
return genericConnectionStringBuilder.ConnectionString;
}
