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