public ColumnCollection GetColumns(Table table)
{
if (_connection.State == ConnectionState.Closed)
{
_connection.Open();
}
if (Server.ProviderType != DataProviderType.Oracle)
{
_connection.ChangeDatabase(table.ParentDatabase.Name);
}
DataSet ds = ColumnSchema(table, _dataAccessProvider, _connection);
foreach (DataRow row in ds.Tables[0].Rows)
{
Column column = CreateColumn(row);
column.SetParentTable(table);
foreach (Key key in table.Keys)
{
if (key.IsPrimary)
{
if (key.ColumnName == column.Name)
{
column.IsPrimaryKey = true;
continue;
}
}
}
_Columns.Add(column);
}
_connection.Close();
return(_Columns);
}
public override void Init(int flowCount, long flowRecordCount)
{
scimore = new ScimoreEmbedded();
scimore.MaxConnections = flowCount;
string dataBaseName = "test";
string dbInstanceName = String.Format(DataDirectory, "Database.scimore");
scimore.Create(dbInstanceName);
scimore.OpenInProcess(dbInstanceName);
connections = new IDbConnection[flowCount];
commands = new IDbCommand[flowCount];
IDbConnection connection = GetConnection();
connection.ExecuteNonQuery(String.Format("CREATE DATABASE {0}", dataBaseName));
connection.ChangeDatabase(dataBaseName);
connection.ExecuteNonQuery(String.Format("DROP TABLE IF EXISTS {0};", CollectionName));
connection.ExecuteNonQuery(CreateTableQuery(CollectionName));
connections[0] = connection;
commands[0] = CreateCommand(connection);
for (int i = 1; i < flowCount; i++)
{
connection = GetConnection();
connection.ChangeDatabase(dataBaseName);
connections[i] = GetConnection();
commands[i] = CreateCommand(connection);
}
}
protected internal TableCollection GetTables(Database database)
{
TableCollection tables = new TableCollection();
DataAccessProviderFactory dataAccessProviderFactory = new DataAccessProviderFactory(Server.ProviderType);
IDbConnection connection = dataAccessProviderFactory.CreateConnection(Server.ConnectionString);
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
connection.ChangeDatabase(database.Name);
DataSet ds;
if (Server.ProviderType != DataProviderType.Oracle)
{
connection.ChangeDatabase(database.Name);
ds = TableSchema(dataAccessProviderFactory, connection);
}
else
{
ds = TableSchema(dataAccessProviderFactory, connection, database);
}
connection.Close();
/* Changed by Ferhat */
if (ds.Tables.Count > 0)
{
foreach (DataRow row in ds.Tables[0].Rows)
{
tables.Add(CreateTable(database, row));
}
}
return(tables);
}
public static void Init(IDbConnection connection)
{
try
{
connection.Open();
connection.Execute("CREATE DATABASE IF NOT EXISTS MakeMagic;");
connection.ChangeDatabase("MakeMagic");
connection.Execute(@"
CREATE TABLE IF NOT EXISTS Characters(
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(128) NOT NULL,
role VARCHAR(16) NOT NULL,
school VARCHAR(128) NOT NULL,
house VARCHAR(32) NOT NULL,
patronus VARCHAR(16) NOT NULL,
PRIMARY KEY(id)); ");
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
private static void ExecuteUseStatement(this IDbConnection connection, string command)
{
var buffer = command.Remove(0, 3).TrimStart();
var databaseName = Regex.Split(buffer, @"[\s;]+")[0].TrimStart('[').TrimEnd(']');
connection.ChangeDatabase(databaseName);
}
private void ExecutePostDeploymentScript(string databaseName, DacPackage dacPackage)
{
databaseName = databaseName ?? dacPackage.Name;
using (IDbConnection connection = _connectionFactory())
{
try
{
connection.ChangeDatabase(databaseName);
}
catch
{
_logAction(
"Could not change connection to database " +
databaseName +
" before post-deployment script. Database may not yet exist.");
}
// Execute the DAC post-deployment script.
if (dacPackage.PostDeploymentScript != null)
{
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = new StreamReader(dacPackage.PostDeploymentScript).ReadToEnd();
command.CommandText = command.CommandText.Replace("\nGO", "");
command.ExecuteNonQuery();
}
}
}
}
/// <summary>
/// Dapper原生方法
/// </summary>
/// <param name="dataBaseName"></param>
public static void ChangeDatabase(string dataBaseName, string connectionSettingName = null)
{
using (IDbConnection _conn = DapperConnectionFactory.CreateConnection(connectionSettingName))
{
_conn.ChangeDatabase(dataBaseName);
}
}
static public IDbConnection CreateConnection(Root dbRoot, string database)
{
IDbConnection cn = PostgreSQLDatabases.CreateConnection(dbRoot.ConnectionString);
cn.Open();
cn.ChangeDatabase(database);
return(cn);
}
public void ChangeDatabase(string databaseName)
{
AssertOpen();
database = databaseName;
connection.ChangeDatabase(databaseName);
}
///// <summary>
///// The ExecuteAsync
///// </summary>
/////
//public void RebuildAllIndex()
//{
// var databases = _dbConnection.Query<string>(string.Format(Constants.DataBaseListQueryByPrefix, _appConfig.DbPrefix)).AsList();
// var str = new StringBuilder();
// foreach (string table in from db in databases
// let tables = _dbConnection.Query<string>(string.Format(Constants.ALL_TABLES, db)).AsList()
// from string table in tables
// select table)
// {
// if (_dbConnection.State == ConnectionState.Closed)
// {
// _dbConnection.Open();
// }
// str.AppendLine(string.Format(Constants.REBUILD_SCRIPT, table));
// str.AppendLine("GO");
// }
// var cmd = str.ToString();
// _dbConnection.Execute(cmd, commandTimeout: 0);
//}
public void ShrinkDataBases()
{
if (_dbConnection.State == ConnectionState.Closed)
{
_dbConnection.Open();
}
var databases = _dbConnection.Query <string>(string.Format(Constants.DataBaseListQueryByPrefix, _appConfig.DbPrefix)).AsList();
databases.ForEach(db =>
{
_dbConnection.ChangeDatabase(db);
var file = _dbConnection.Query <Database_Files>(Constants.SQL_CHECK_FILE).FirstOrDefault(f => f.Name.Contains("_log"))?.Name;
if (string.IsNullOrEmpty(file))
{
_dbConnection.Execute(string.Format(Constants.SHRINK_DB, db, file));
}
});
}
private void ChangeDatabaseIfNeeded(IDbConnection dbConn)
{
if (string.Equals(ConnectionParameter.Database, dbConn.Database, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
dbConn.ChangeDatabase(ConnectionParameter.Database);
}
/// <summary>
/// Returns a list of database names.
/// </summary>
/// <param name="connection">A database connection to a server containing geodatabases.</param>
/// <returns></returns>
public static List<string> GetDatabaseNames(IDbConnection connection)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
// Store the initial connection state. If the connection is already open we will leave it open instead of closing it.
var initConnectionState = connection.State;
// Store the initial database in case we need to change it.
string originalDatabase = connection.Database;
List<string> output = null;
try
{
// Open the connection if it is not already open.
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
// We need to use the "master" database.
if (string.Compare(connection.Database, "master", true) != 0)
{
Trace.WriteLine(string.Format("Changing database from {0} to master...", connection.Database));
connection.ChangeDatabase("master");
}
// Create the command to select the list of databases.
var cmd = connection.CreateCommand();
cmd.CommandText = Resources.ListDatabases;
// Initialize the list of database names.
output = new List<string>();
// Execute the command and store the database names that are returned.
using (var reader = cmd.ExecuteReader(CommandBehavior.Default))
{
while (reader.Read())
{
string s = reader.GetString(0);
output.Add(s);
}
}
}
finally
{
// Close the connection ONLY if it was not already opened when we started.
if (connection != null && initConnectionState != ConnectionState.Open)
{
connection.Close();
}
}
return output;
}
/// <summary>Changes the current database for an open Connection object.</summary>
/// <param name="databaseName">The name of the database to use in place of the current database. </param>
public void ChangeDatabase(string databaseName)
{
if (connection == null)
{
throw new ObjectDisposedException("SqlConnection");
}
connection.ChangeDatabase(databaseName);
Database = databaseName;
LastUsed = DateTime.UtcNow;
}
public void ChangeDatabase()
{
string databaseName = "databaseName";
_innerConnectionMock.Expect(mock => mock.ChangeDatabase(databaseName));
_mockRepository.ReplayAll();
_connection.ChangeDatabase(databaseName);
_mockRepository.VerifyAll();
}
private static OrmLiteConnectionFactory ConfigureDatabase()
{
string connectionString = System.Configuration.ConfigurationManager.
ConnectionStrings["MsSql"].ConnectionString;
OrmLiteConnectionFactory dbFactory = new OrmLiteConnectionFactory(connectionString,
new SqlServer2012OrmLiteDialectProvider());
IDbConnection dbConnection = dbFactory.Open();
dbConnection.ChangeDatabase("master");
int result =
dbConnection.SqlScalar <int>($"SELECT COUNT(*)FROM [master].sys.databases WHERE name = N'{DB_NAME}'");
if (result == 0)
{
Debug.WriteLine($"Database [{DB_NAME}] not found. Creating database...");
dbConnection.ExecuteSql($"CREATE DATABASE [{DB_NAME}]");
}
dbConnection.ChangeDatabase(DB_NAME);
dbConnection.Close();
return(dbFactory);
}
public SqlTransaction()
{
IDatabaseBackend db = Database.Backend;
conn = db.CreateConnection();
conn.Open();
if (db.MultipleSchema)
{
conn.ChangeDatabase(Server.Config.MySQLDatabaseName);
}
transaction = conn.BeginTransaction();
}
public void Execute(string query, string connString, bool createDB = false)
{
using (IDbConnection conn = CreateConnection(connString)) {
conn.Open();
if (!createDB && MultipleSchema)
{
conn.ChangeDatabase(Server.MySQLDatabaseName);
}
using (IDbCommand cmd = CreateCommand(query, conn)) {
FillParams(cmd);
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
/// <summary> Executes an SQL command that does not return any results. </summary>
public void Execute(string sql, object[] parameters, bool createDB)
{
using (IDbConnection conn = CreateConnection()) {
conn.Open();
if (!createDB && MultipleSchema)
{
conn.ChangeDatabase(Server.Config.MySQLDatabaseName);
}
using (IDbCommand cmd = CreateCommand(sql, conn)) {
FillParams(cmd, parameters);
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
public void Fill(string query, string connString, DataTable toReturn)
{
using (IDbConnection conn = CreateConnection(connString)) {
conn.Open();
if (MultipleSchema)
{
conn.ChangeDatabase(Server.MySQLDatabaseName);
}
using (DbDataAdapter da = CreateDataAdapter(query, conn)) {
FillParams(da.SelectCommand);
da.Fill(toReturn);
da.SelectCommand.Dispose();
}
conn.Close();
}
}
public static IDbConnection Open(this IDbConnection connection, string intialDatabase)
{
if (connection != null)
{
var isClosed = connection.State == ConnectionState.Closed;
if (isClosed)
{
connection.Open();
}
connection.ChangeDatabase(intialDatabase);
return(connection);
}
throw new InvalidOperationException($"Connection cannot be null");
}
public static IDataReader Execute(this IDbConnection connection, string database, string procedureName, params SqlParameter[] parameters)
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
connection.ChangeDatabase(database);
using var command = connection.CreateCommand();
command.CommandText = procedureName;
command.CommandType = CommandType.StoredProcedure;
foreach (var param in parameters)
{
command.Parameters.Add(param);
}
return(command.ExecuteReader());
}
void IProvider.DeleteDatabase()
{
var SqlBuilder = new SqlBuilder(SqlIdentifier);
CheckDispose();
CheckInitialized();
if (!deleted)
{
if (Mode == ProviderMode.SqlCE)
{
((IProvider)this).ClearConnection();
File.Delete(dbName);
deleted = true;
}
else
{
string connectionString = conManager.Connection.ConnectionString;
IDbConnection connection = conManager.UseConnection(this);
try
{
connection.ChangeDatabase("MASTER");
if (connection is SqlConnection)
{
SqlConnection.ClearAllPools();
}
if (Log != null)
{
Log.WriteLine(Strings.LogAttemptingToDeleteDatabase(dbName));
}
ExecuteCommand(SqlBuilder.GetDropDatabaseCommand(dbName));
deleted = true;
}
finally
{
conManager.ReleaseConnection(this);
if ((conManager.Connection.State == ConnectionState.Closed) &&
(string.Compare(conManager.Connection.ConnectionString, connectionString,
StringComparison.Ordinal) != 0))
{
conManager.Connection.ConnectionString = connectionString;
}
}
}
}
}
//TODO : Remplacer l'objet Metadatas par ServerMetadata car l'objet Metadatas est réservé au contexte courant de clonage avec plusieurs serveurs SQL différents
public void LoadForeignKeys(IDbConnection connection, Metadatas metadata, string serverId, string database)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = SqlGetForeignKeys;
var p = cmd.CreateParameter();
p.ParameterName = SqlWriter.NamedParamPrefix + "DATABASE";
p.Value = database;
cmd.Parameters.Add(p);
connection.Open();
connection.ChangeDatabase(database);
using (var r = cmd.ExecuteReader())
MetadataLoader.LoadForeignKeys(r, metadata, serverId, database);
connection.Close();
}
}
public static IEnumerable <string> GetProcedures(this IDbConnection connection, string database)
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
connection.ChangeDatabase(database);
using var command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = ProceduresQuery;
using var result = command.ExecuteReader();
while (result.Read())
{
yield return($"{result.GetString(1)}.{result.GetString(2)}");
}
}
private IDbConnection GetConnection(string databaseName)
{
OpenConnection();
if (string.Compare(_connection.Database, databaseName, StringComparison.OrdinalIgnoreCase) == 0)
{
return(_connection);
}
try
{
TestContext.WriteLine($"Switching to database: '{databaseName}'");
_connection.ChangeDatabase(databaseName);
return(_connection);
}
catch
{
TestContext.Error.WriteLine($"Unable to switch to database: '{databaseName}'");
throw;
}
}
public virtual bool CheckConnection(IPooledDbConnection connection, DatabaseConnectionSettings settings)
{
if (connection.IsOpen)
{
IDbConnection conn = connection.DbConnection;
if (conn.Database == settings.Database)
{
return(true);
}
else
{
try {
conn.ChangeDatabase(settings.Database);
return(true);
} catch {
return(false);
}
}
}
return(false);
}
public void ExecuteReader(string query, string connString, ReaderCallback callback)
{
using (IDbConnection conn = CreateConnection(connString)) {
conn.Open();
if (MultipleSchema)
{
conn.ChangeDatabase(Server.MySQLDatabaseName);
}
using (IDbCommand cmd = CreateCommand(query, conn)) {
FillParams(cmd);
using (IDataReader reader = cmd.ExecuteReader()) {
while (reader.Read())
{
callback(reader);
}
}
}
conn.Close();
}
}
public SqlAggregateMigrationGenerator(Server server, Database database, GeneratorOptions options)
: base(server, database, options)
{
var providerLocator = new ProviderLocator(new ProviderFactory()); // CLEAN: use DI container
ProviderInfo provider = providerLocator.GetExactly(DbPlatform.SqlServer2008);
var versioningTableName = new TableName(options.VersioningTableName, options.VersioningTableSchema);
_history = new History(versioningTableName, provider.Metadata);
IDbConnection connection = server.ConnectionContext.SqlConnectionObject;
connection.Open();
connection.ChangeDatabase(Database.Name); // ATTENTION: possibly has side-effects
try
{
_history.Load(connection, null);
}
finally
{
connection.Close();
}
}
/// <summary>
/// Changes the active database on opened connection.
/// </summary>
/// <param name="databaseName"></param>
/// <returns>true if databse was changed; otherwise returns false</returns>
public bool SelectDb(string databaseName)
{
ClosePendingReader();
try
{
if (this.connection.State == ConnectionState.Open)
{
connection.ChangeDatabase(databaseName);
lastException = null;
return(true);
}
}
catch (Exception e)
{
lastException = e;
PhpException.Throw(PhpError.Warning, LibResources.GetString("database_selection_failed",
GetExceptionMessage(e)));
}
return(false);
}
/// <summary> Excecutes an SQL query, invoking a callback on the returned rows one by one. </summary>
public object Iterate(string sql, object[] parameters, object arg, ReaderCallback callback)
{
using (IDbConnection conn = CreateConnection()) {
conn.Open();
if (MultipleSchema)
{
conn.ChangeDatabase(Server.Config.MySQLDatabaseName);
}
using (IDbCommand cmd = CreateCommand(sql, conn)) {
FillParams(cmd, parameters);
using (IDataReader reader = cmd.ExecuteReader()) {
while (reader.Read())
{
arg = callback(reader, arg);
}
}
}
conn.Close();
}
return(arg);
}
/// <summary>
/// Changes the database name. This require the databases in the same machine. NOTE: This only work for MySQL right now.
/// </summary>
/// <param name="database">The database name.</param>
/// <remarks>
/// This only been used for supporting multiple databases in the same model. This require the databases in the same machine.
/// </remarks>
public void ChangeDatabase(string database)
{
if (_connection.State.HasFlag(ConnectionState.Open))
{
_connection.ChangeDatabase(database);
}
else
{
var connectionString = Regex.Replace(_connection.ConnectionString.Replace(" ", ""), @"(?<=[Dd]atabase=)\w+(?=;)", database, RegexOptions.Singleline);
_connection.ConnectionString = connectionString;
}
// Following code only working for mysql.
var items = _context.Model.GetEntityTypes();
foreach (var item in items)
{
if (item.Relational() is RelationalEntityTypeAnnotations extensions)
{
extensions.Schema = database;
}
}
}
protected virtual void SetUpConnection(IDbConnection cnx)
{
if (shouldOpen && cnx.State != ConnectionState.Open)
cnx.Open();
if (databaseName != null)
cnx.ChangeDatabase(databaseName);
}
