public DbConnectionInfo GetConnectionInfo()
{
var info = new DbConnectionInfo
{
State = "Disconnected"
};
using (this)
{
try
{
var connection = this.Database.GetDbConnection();
connection.Open();
if (connection.State == ConnectionState.Open)
{
info.State = connection.State.ToString();
info.Database = connection.Database;
info.DataSource = connection.DataSource;
info.ServerVersion = connection.ServerVersion;
info.ConnectionTimeout = connection.ConnectionTimeout;
connection.Close();
}
}
catch (Exception ex)
{
throw ex;
}
}
return(info);
}
public ToolingFacade(
string migrationsAssemblyName,
string contextAssemblyName,
string configurationTypeName,
string workingDirectory,
string configurationFilePath,
string dataDirectory,
DbConnectionInfo connectionStringInfo)
{
Check.NotEmpty(migrationsAssemblyName, nameof(migrationsAssemblyName));
this._migrationsAssemblyName = migrationsAssemblyName;
this._contextAssemblyName = contextAssemblyName;
this._configurationTypeName = configurationTypeName;
this._connectionStringInfo = connectionStringInfo;
AppDomainSetup info = new AppDomainSetup()
{
ShadowCopyFiles = "true"
};
if (!string.IsNullOrWhiteSpace(workingDirectory))
{
info.ApplicationBase = workingDirectory;
}
this._configurationFile = new ConfigurationFileUpdater().Update(configurationFilePath);
info.ConfigurationFile = this._configurationFile;
this._appDomain = AppDomain.CreateDomain("MigrationsToolingFacade" + Convert.ToBase64String(Guid.NewGuid().ToByteArray()), (Evidence)null, info);
if (string.IsNullOrWhiteSpace(dataDirectory))
{
return;
}
this._appDomain.SetData("DataDirectory", (object)dataDirectory);
}
public LazyInternalConnection(DbConnectionInfo connectionInfo)
{
DebugCheck.NotNull(connectionInfo);
_connectionInfo = connectionInfo;
AppConfig = AppConfig.DefaultInstance;
}
/// <summary>
/// 获取表索引信息集合
/// </summary>
/// <param name="tableName">表名</param>
/// <returns>表索引信息集合</returns>
public DBIndexInfoCollection GetTableIndexs(string tableName)
{
using (var connectionInfo = new DbConnectionInfo(this._dbid, Model.DBVisitType.R))
{
return(this.PrimitiveGetTableIndexs(connectionInfo.DbConnection, tableName));
}
}
private DbContext(string dbPassword)
{
_userDb = new DbConnectionInfo("draughts_user", "draughts_user", "devapp");
_authUserDb = new DbConnectionInfo("draughts_authuser", "draughts_authuser", "devapp");
_gameDb = new DbConnectionInfo("draughts_game", "draughts_game", "devapp");
_miscDb = new DbConnectionInfo("draughts_misc", "draughts_game", "devapp"); // All users can access the misc DB.
}
/// <summary>
/// ExecuteNonQuery执行SQL语句,返回受影响的行数
/// </summary>
/// <param name="sqlStr">sql语句</param>
/// <param name="visitType">数据库访问类型</param>
/// <param name="parameterNameValueDic">参数名名称及对应的值字典集合[key:参数名称,含参数符号;value:参数值]</param>
/// <returns>返回执行结果</returns>
public int ExecuteNonQuery(string sqlStr, DBVisitType visitType, Dictionary <string, object> parameterNameValueDic = null)
{
using (var connectionInfo = new DbConnectionInfo(this._dbid, Model.DBVisitType.R))
{
return(this.PrimitiveExecuteNonQuery(connectionInfo.DbConnection, sqlStr, parameterNameValueDic));
}
}
public override void RegisterRealTasks(PhysicalServer site)
{
DbConnectionInfo connectionInfo;
if (_connectionString.IsNotEmpty())
{
connectionInfo = new DbConnectionInfo(_connectionString);
}
else
{
connectionInfo = new DbConnectionInfo
{
Server = site.Name,
Instance = _instanceName,
DatabaseName = _databaseName,
UserName = _userName,
Password = _password
};
}
var task = new RoundhousETask(connectionInfo, _scriptsLocation,
_environmentName, _roundhouseMode,
_recoveryMode, _restorePath, _restoreTimeout, _restoreCustomOptions,
_repositoryPath, _versionFile, _versionXPath, _commandTimeout, _commandTimeoutAdmin,
_functionsFolderName, _sprocsFolderName, _viewsFolderName, _upFolderName,
_versionTable, _scriptsRunTable, _scriptsRunErrorTable, _warnOnOneTimeScriptChanges, _outputPath);
site.AddTask(task);
}
public SchemaBrowserVM(ISchemaBrowserModel iSchemaBrowserModel, ICodeGenerator iCodeGenerator, DbConnectionInfo dbConnectionInfo)
{
model = iSchemaBrowserModel;
codeGenerator = iCodeGenerator;
currentDb = dbConnectionInfo;
GeneratCodeCommand = new DelegateCommand<object>(GeneratCode);
}
public Tableau9RepoConn(DbConnectionInfo db, int streamingTablesPollLimit)
{
if (db == null)
{
Log.Error("DB connection info is NULL while making Tableau repo connection!");
return;
}
this.streamingTablesPollLimit = streamingTablesPollLimit;
connectionStringBuilder =
new NpgsqlConnectionStringBuilder()
{
// Always try to connect to the Tableau repository from the machine where the target
// Tableau repository resides
Host = "localhost",
Port = db.Port,
Username = db.Username,
Password = db.Password,
Database = db.DatabaseName,
SslMode = SslMode.Prefer,
// Trust invalid certificates as well
TrustServerCertificate = true
};
}
//public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var dbInfo = new DbConnectionInfo();
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddSession(options =>
{
options.Cookie.Name = ".makeMeLaugh";
options.Cookie.HttpOnly = true;
options.Cookie.IsEssential = true;
});
services.AddHttpContextAccessor();
services.AddHttpClient();
services.AddDbContext <ImageStoreContext>(options =>
{
options.UseSqlServer($"Server=tcp:makemelaugh.database.windows.net,1433;Initial Catalog=MakeMeLaugh;Persist Security Info=False;User ID={dbInfo.Username};Password={dbInfo.Password};MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;");
//options.UseSqlServer(Configuration.GetConnectionString("MakeMeLaugh"));
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
public DataTable GetTableData(DbTable table, DbConnectionInfo connectionInfo)
{
var sql = $"Select * from {table.Name}";
var qm = new QueryModel();
var result = qm.Execute(sql, connectionInfo);
return result.DataTable ;
}
static async Task MainAsync()
{
var cnInfo = new DbConnectionInfo("http://*****:*****@127.0.0.1:5984/", "mydb")
{
Timeout = TimeSpan.FromMilliseconds(System.Threading.Timeout.Infinite)
};
using (var client = new MyCouchClient(cnInfo))
{
var getChangesRequest = new GetChangesRequest
{
Feed = ChangesFeed.Continuous,
Since = "now", //Optional: FROM WHAT SEQUENCE DO WE WANT TO START CONSUMING
// Heartbeat = 3000, //Optional: LET COUCHDB SEND A I AM ALIVE BLANK ROW EACH ms
Filter = "person/filter_person"
};
var cancellation = new CancellationTokenSource();
await client.Changes.GetAsync(
getChangesRequest,
data => ChangeDo(data),
cancellation.Token);
cancellation.Cancel();
}
}
public void LoadSchemaObjects(ICollection<SchemaObject> objectList, DbConnectionInfo connectionInfo)
{
var extractor = new SchemaExtractor();
objectList.Clear();
var tables = extractor.GetTables(connectionInfo);
var columns = extractor.GetTableColumns(connectionInfo);
AddColumns(tables, columns);
var primaryKeyColumns = GetPrimaryKeyColumns(connectionInfo);
AddPrimaryKeys(tables, primaryKeyColumns);
var views = extractor.GetViews(connectionInfo);
var viewColumns = extractor.GetViewColumns(connectionInfo);
AddViewColumns(views, viewColumns);
var fKeys = GetForeignKeys(connectionInfo);
AddForeignKeysToTables(tables, fKeys);
var procedures = extractor.GetStoredProcedures(connectionInfo);
var parameters = extractor.GetStoredProcedureParameters(connectionInfo);
AddParametersToStoredProcedures(procedures, parameters);
foreach (var procedure in procedures.Values)
objectList.Add(procedure);
foreach (var view in views.Values)
objectList.Add(view);
var sortedTables = from t in tables.Values
orderby t.Name
select t;
foreach (var t in sortedTables)
objectList.Add(t);
}
internal virtual IDictionary ScaffoldInitialCreateInternal(
DbConnectionInfo connectionInfo,
string contextTypeName,
string contextAssemblyName,
string migrationsNamespace,
bool auto,
string migrationsDir)
{
var contextAssembly = LoadAssembly(contextAssemblyName) ?? _assembly;
var configuration = new DbMigrationsConfiguration
{
ContextType = contextAssembly.GetType(contextTypeName, throwOnError: true),
MigrationsAssembly = _assembly,
MigrationsNamespace = migrationsNamespace,
AutomaticMigrationsEnabled = auto,
MigrationsDirectory = migrationsDir
};
OverrideConfiguration(configuration, connectionInfo);
var scaffolder = CreateMigrationScaffolder(configuration);
var result = scaffolder.ScaffoldInitialCreate();
return(ToHashtable(result));
}
/// <summary>
/// 执行SQL语句,返回查询结果
/// </summary>
/// <param name="sqlStr">sql语句</param>
/// <param name="parameterNameValueDic">参数名名称及对应的值字典集合[key:参数名称,含参数符号;value:参数值]</param>
/// <returns>返回执行结果</returns>
protected DataTable PrimitiveQueryDataToDataTable(string sqlStr, Dictionary <string, object> parameterNameValueDic = null)
{
using (var connectionInfo = new DbConnectionInfo(this._dbid, Model.DBVisitType.R))
{
return(this.PrimitiveQueryDataToDataTable(connectionInfo.DbConnection, sqlStr, parameterNameValueDic));
}
}
public UserQueries(
IMapper mapper,
IOptions <DbConnectionInfo> dbConnectionInfo)
{
_mapper = mapper;
_dbConnectionInfo = dbConnectionInfo.Value;
}
public Configuration()
{
CodeGenerator = new MySqlMigrationCodeGenerator();
AutomaticMigrationsEnabled = false;
TargetDatabase = new DbConnectionInfo(DbSettings.Deserialize().GetConnectionString(), "MySql.Data.MySqlClient");
SetSqlGenerator("MySql.Data.MySqlClient", new MySqlMigrationSqlGenerator());
}
/// <param name="dbConnectionInfo">The database name and server (optional)</param>
/// <param name="databaseEngine">The database engine that tests should be performed against</param>
/// <remarks>
/// If <paramref name="dbConnectionInfo"/> is <see langword="null" /> or returns <see langword="null" />
/// or <see cref="string.Empty"/> for the <see cref="DbConnectionInfo.DatabaseName"/>, a database with a
/// name derived from the other parameters supplied will be created. See
/// <see cref="DeriveDatabaseNameFrom"/>
/// <para>
/// <paramref name="databaseEngine"/> largely determines the configuration of nhibernate. The argument
/// supplied is used to pick from the predefined <see cref="NhCommonConfigurations"/>
/// </para>
/// </remarks>
public NHibernateTestContextInitializer Using(DatabaseEngine databaseEngine, DbConnectionInfo dbConnectionInfo)
{
DatabaseEngine = databaseEngine;
ConnectionInfo = dbConnectionInfo;
return(this);
}
public static async Task DoThings(string from, string to)
{
var fromInfo = new DbConnectionInfo("http://localhost:5984/", from)
{
Timeout = TimeSpan.FromMilliseconds(System.Threading.Timeout.Infinite)
};
var toInfo = new DbConnectionInfo("http://localhost:5984/", to);
using (var client = new MyCouchClient(fromInfo))
{
var doc = await client.Documents.GetAsync("all");
var getChangesRequest = new GetChangesRequest
{
Feed = ChangesFeed.Continuous,
IncludeDocs = true,
Since = "now", //Optional: FROM WHAT SEQUENCE DO WE WANT TO START CONSUMING
Heartbeat = 3000 //Optional: LET COUCHDB SEND A I AM ALIVE BLANK ROW EACH ms
};
var cancellation = new CancellationTokenSource();
var response = await client.Changes.GetAsync(
getChangesRequest,
data => ProcessData(data, toInfo),
cancellation.Token);
}
}
public virtual string GetMigrationScript(MigrationInfo migrationInfo)
{
var infos = new StringBuilder();
var warnings = new StringBuilder();
var verbose = new StringBuilder();
//connection:connectionString, NameSpaceQualifiedConnectionType:for example :"System.Data.SqlClient"
var connectionStringInfo = new DbConnectionInfo(migrationInfo.Connection,
migrationInfo.NameSpaceQualifiedConnectionType);
var toolingFacade = new ToolingFacade(
migrationInfo.ContextAssemblyName, //"MyDll", // MigrationAssemblyName. In this case dll should be located in "C:\\Temp\\MigrationTest" dir
migrationInfo.ContextAssemblyName, //"MyDll", // ContextAssemblyName. Same as above
migrationInfo.ConfigurationTypeName, //KS.ObjectiveDataAccess.ContentManagementDbContextMigrations.Configuration
migrationInfo.ContextAssemblyPath, //"C:\\Temp\\MigrationTest", // Where the dlls are located
migrationInfo.WebConfigPath, //"C:\\Temp\\MigrationTest\\App.config", // Insert the right directory and change with Web.config if required
migrationInfo.AppDataPath, //"C:\\Temp\\App_Data",
connectionStringInfo)
{
LogInfoDelegate = s => { infos.AppendLine($"Infos : {s} . <br>"); },
LogWarningDelegate = s => { warnings.AppendLine($"Warning : {s} . <br>"); },
LogVerboseDelegate = s => { verbose.AppendLine($"Verbose : {s} . <br>"); }
};
if (migrationInfo.SourceName == "")
{
return(toolingFacade.ScriptUpdate(null, migrationInfo.TargetName,
migrationInfo.Force));
}
else
{
return(toolingFacade.ScriptUpdate(migrationInfo.SourceName,
migrationInfo.TargetName, migrationInfo.Force));
}
}
/// <summary>
/// 获取当前用户有权限的所有表集合
/// </summary>
/// <param name="getFieldInfo">是否获取字段信息[true:获取字段信息;false:不获取;默认不获取]</param>
/// <returns>当前用户有权限的所有表集合</returns>
public List <DBTableInfo> GetTableInfoList(bool getFieldInfo = false)
{
using (var connectionInfo = new DbConnectionInfo(this._dbid, Model.DBVisitType.R))
{
return(this.PrimitiveGetTableInfoList(connectionInfo.DbConnection, getFieldInfo));
}
}
public Dictionary<string, DbStoredProc> GetStoredProcedures(DbConnectionInfo connectionInfo)
{
var sql = @" select SCHEMA_NAME(p.schema_id) + '.' + p.name as fullname,p.name ,SCHEMA_NAME(p.schema_id) as schemaName, m.definition from sys.procedures p inner join
sys.sql_modules m on p.object_id = m.object_id";
var procedures = new Dictionary<string, DbStoredProc>();
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullNamePos = reader.GetOrdinal("fullName");
var namePos = reader.GetOrdinal("name");
var schemaNamePos = reader.GetOrdinal("schemaName");
var definitionPos = reader.GetOrdinal("definition");
while (reader.Read())
{
procedures.Add(reader.GetString(fullNamePos), new DbStoredProc()
{
Name = reader.GetString(namePos),
SchemaName = reader.GetString(schemaNamePos),
Definition = reader.GetString(definitionPos).Trim()
});
}
}
}
return procedures;
}
/// <summary>
/// ExecuteScalar执行SQL语句,返回执行结果的第一行第一列；
/// </summary>
/// <param name="sqlStr">sql语句</param>
/// <param name="visitType">数据库访问类型</param>
/// <param name="parameterNameValueDic">参数名名称及对应的值字典集合[key:参数名称,含参数符号;value:参数值]</param>
/// <returns>返回执行结果</returns>
protected object PrimitiveExecuteScalar(string sqlStr, DBVisitType visitType, Dictionary <string, object> parameterNameValueDic = null)
{
using (var conInfo = new DbConnectionInfo(this._dbid, visitType))
{
return(this.PrimitiveExecuteScalar(conInfo.DbConnection, sqlStr, parameterNameValueDic));
}
}
public Configuration()
{
//Creates a new instance of DbConnectionInfo based on a connection string.
TargetDatabase = new DbConnectionInfo(
connectionString: "The connection string to use for the connection",
providerInvariantName: "The name of the provider to use for the connection. Use 'System.Data.SqlClient' for SQL Server.");
}
/// <summary>
/// 获取数据库系统时间
/// </summary>
/// <returns>数据库系统时间</returns>
public DateTime GetDataBaseSysTime()
{
using (var connectionInfo = new DbConnectionInfo(this._dbid, Model.DBVisitType.R))
{
return(this.PrimitiveGetDataBaseSysTime(connectionInfo.DbConnection));
}
}
public static NHibernateDbBuilder For(DatabaseEngine databaseEngine,
DbConnectionInfo dbConnectionInfo,
MappingInfo mappingInfo)
{
return(new NHibernateDbBuilder(DbMediaBuilder.For(databaseEngine, dbConnectionInfo),
NHibernateConfigurator.Create(databaseEngine, dbConnectionInfo, mappingInfo)));
}
public void AssertEachPossibleDownwardMigration(string configurationType, DbConnectionInfo targetDatabase)
{
var migrator = GetMigrator(configurationType, targetDatabase);
var currentMigrationId = migrator
.GetDatabaseMigrations()
.OrderBy(migrationId => migrationId)
.LastOrDefault();
var migrationsToApply = migrator
.GetLocalMigrations()
.OrderByDescending(migrationId => migrationId)
.SkipWhile(migrationId =>
string.Compare(migrationId, currentMigrationId, StringComparison.OrdinalIgnoreCase) >= 0
)
.ToList();
var expectedMigrations = new List <string>(migrationsToApply);
// this will test migrating to before InitialCreate
migrationsToApply.Add("0");
foreach (var migrationId in migrationsToApply)
{
ApplyMigration(migrator, migrationId);
var actualMigrations = migrator.GetDatabaseMigrations().OrderByDescending(actualId => actualId);
AssertDatabaseMigrationsAreEqual(migrationId, expectedMigrations, actualMigrations);
expectedMigrations.Remove(migrationId);
}
}
/// <summary>
/// 查询分页信息
/// </summary>
/// <param name="pageSize">页大小</param>
/// <param name="sqlStr">sql语句</param>
/// <param name="parameterNameValueDic">参数名名称及对应的值字典集合[key:参数名称,含参数符号;value:参数值]</param>
/// <returns>分页信息</returns>
public DBPageInfo QueryPageInfo(long pageSize, string sqlStr, Dictionary <string, object> parameterNameValueDic = null)
{
using (var conInfo = new DbConnectionInfo(this._dbid, DBVisitType.R))
{
return(this.QueryPageInfo(conInfo.DbConnection, pageSize, sqlStr, parameterNameValueDic));
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
DbConnectionInfo dbConnectionInfo = null;
var cstr = "";
if (!string.IsNullOrWhiteSpace(ConnectionString))
{
dbConnectionInfo = new DbConnectionInfo(ConnectionString, "System.Data.SqlClient");
WriteVerbose(string.Format("Using database: {0}", ConnectionString));
cstr = ConnectionString;
}
else if (!string.IsNullOrWhiteSpace(ConnectionName))
{
var config = TralusConfiguration.GetConfiguration();
ConnectionStringSettings connectionString = config.ConnectionStrings.ConnectionStrings[ConnectionName];
if (connectionString != null)
{
WriteVerbose(string.Format("Using database: [{0}]: {1}", connectionString.Name, connectionString.ConnectionString));
dbConnectionInfo = new DbConnectionInfo(connectionString.ConnectionString, connectionString.ProviderName);
cstr = connectionString.ConnectionString;
}
else
{
WriteWarning(string.Format("Connection string not found: {0}", ConnectionName));
}
}
if (!string.IsNullOrWhiteSpace(cstr))
{
foreach (var migrationAssembly in MigrationAssemblies)
{
try
{
var assembly = Assembly.Load(migrationAssembly);
var configTypes = assembly.GetTypes()
.Where(t => t.IsSubclassOf(typeof(DbMigrationsConfiguration)) && !t.IsAbstract);
var configs = configTypes.Select(Activator.CreateInstance);
foreach (var config in configs)
{
var type = config.GetType();
var method = type.GetMethod("ApplySeed");
method.Invoke(config, new object[] { cstr });
}
}
catch (Exception exception)
{
WriteWarning(string.Format("Unable to load assembly: {0}", migrationAssembly));
WriteWarning(exception.ToString());
}
}
}
}
public void Setup()
{
_prompt = new MockPromptService();
_info = new DbConnectionInfo(_prompt)
{
Server = "foo", DatabaseName = "bar"
};
}
public LazyInternalConnection(DbContext context, DbConnectionInfo connectionInfo)
: base(new DbInterceptionContext().WithDbContext(context))
{
DebugCheck.NotNull(connectionInfo);
_connectionInfo = connectionInfo;
AppConfig = AppConfig.DefaultInstance;
}
public static NHibernateConfigurator Create(DatabaseEngine databaseEngine,
DbConnectionInfo dbConnectionInfo,
MappingInfo mappingInfo)
{
IDictionary <string, string> properties = NhCommonConfigurations.For(databaseEngine, dbConnectionInfo, true);
return(new NHibernateConfigurator(mappingInfo, properties));
}
public Configuration()
{
string connectionString = ConfigurationManager.ConnectionStrings["PrincipalDatabase"].ConnectionString;
TargetDatabase = new DbConnectionInfo(connectionString, "System.Data.SqlClient");
AutomaticMigrationsEnabled = false;
AutomaticMigrationDataLossAllowed = false;
}
/// <summary>
/// 查询分页数据
/// </summary>
/// <param name="sqlStr">查询SQL语句</param>
/// <param name="orderInfos">排序列名集合[null为或空不排序]</param>
/// <param name="pageSize">页大小</param>
/// <param name="pageIndex">查询页索引</param>
/// <param name="parameterNameValueDic">参数名名称及对应的值字典集合[key:参数名称,含参数符号;value:参数值]</param>
/// <param name="dataBaseVersion">数据库版本信息</param>
/// <returns>数据表</returns>
public DataTable QueryPagingData(string sqlStr, IEnumerable <DBOrderInfo> orderInfos, long pageSize, long pageIndex,
Dictionary <string, object> parameterNameValueDic = null, DataBaseVersionInfo dataBaseVersion = null)
{
using (var conInfo = new DbConnectionInfo(this._dbid, DBVisitType.R))
{
return(this.PrimitiveQueryPagingData(conInfo.DbConnection, sqlStr, orderInfos, pageSize, pageIndex, parameterNameValueDic, dataBaseVersion));
}
}
public ExportTableVm(DbConnectionInfo dbConnectionInfo, IExportTableModel iExportTableModel, ITableExportSettingsModel iTableExportSettingsModel)
{
model = iExportTableModel;
settingsManager = iTableExportSettingsModel;
CurrentDb = dbConnectionInfo;
ExportCommand = new DelegateCommand(Export);
settingsManager.LoadExportSettings(settings);
settings.BaseExportPath = @"D:\Temp\DB";
}
public void CopyOfDbConnectionInfoIsUsed()
{
var connectionInfo = new DbConnectionInfo {ConnectionString = "schema=schema", Provider = "System.Data.SqlClient"};
var result = new DbDescription {ConnectionInfo = connectionInfo};
connectionInfo.ConnectionString = "schema=other_schema";
Assert.That(result.ConnectionInfo.ConnectionString, Is.EqualTo("schema=schema"));
}
public void CanCreateFromConnectionStringName()
{
var result = new DbConnectionInfo {ConnectionStringName = "Valid"};
Assert.That(result, Is.Not.Null);
Assert.That(result.ConnectionString, Is.EqualTo("server=server"));
Assert.That(result.Provider, Is.EqualTo("System.Data.SqlClient"));
Assert.That(result.ProviderFactory, Is.InstanceOf<System.Data.SqlClient.SqlClientFactory>());
}
public void CanCreateFromConnectionStringNameWithBlankProviderName()
{
var result = new DbConnectionInfo {ConnectionStringName = "BlankProviderName"};
Assert.That(result, Is.Not.Null);
Assert.That(result.ConnectionString, Is.EqualTo("server=server"));
Assert.That(result.Provider, Is.Null);
Assert.That(result.ProviderFactory, Is.Null);
}
public ObservableCollection<DbTable> GetTables(DbConnectionInfo connectionInfo)
{
var extractor = new SchemaExtractor();
var tabledict = extractor.GetTables(connectionInfo);
var tables = from t in tabledict.Values
orderby t.Name
select t;
return new ObservableCollection<DbTable>(tables);
}
public void GetProviderWithInvalidProviderNameThrows()
{
var connectionInfo = new DbConnectionInfo
{
Provider = "Invalid.Provider.Name"
};
Assert.That(() => { var _ = connectionInfo.ProviderFactory; },
Throws.ArgumentException.With.Property("ParamName").EqualTo("Provider"));
}
private IExportTableModel GetExportTableModel(DbConnectionInfo connection)
{
switch (connection.DatabaseType)
{
case "Sql Server":
return new Models.SqlServer.ExportTableModel();
case "MySQL":
return new Models.MySql.ExportTableModel();
}
return null;
}
private IQueryModel GetQueryModel(DbConnectionInfo connection)
{
switch (connection.DatabaseType)
{
case "Sql Server":
return new Models.SqlServer.QueryModel();
case "MySQL":
return new Models.MySql.QueryModel();
}
return null;
}
private ISchemaBrowserModel GetSchemaBrowserModel(DbConnectionInfo connection)
{
switch (connection.DatabaseType)
{
case "Sql Server":
return new Models.SqlServer.SchemaBrowserModel();
case "MySQL":
return new Models.MySql.SchemaBrowserModel();
}
return null;
}
public void CanCreateWithConnectionString()
{
var result = new DbConnectionInfo
{
ConnectionString = "server=server"
};
Assert.That(result, Is.Not.Null);
Assert.That(result.ConnectionString, Is.EqualTo("server=server"));
Assert.That(result.Provider, Is.Null);
Assert.That(result.ProviderFactory, Is.Null);
}
public static QueryResult Execute(string query, DbConnectionInfo connectionInfo)
{
var result = new QueryResult();
Stopwatch swatch = new Stopwatch();
swatch.Start();
try
{
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
var reader = cmd.ExecuteReader();
var fieldCount = reader.FieldCount;
var dt = new DataTable();
for (int i = 0; i < fieldCount; i++)
{
var name = reader.GetName(i);
var ft = reader.GetFieldType(i);
dt.Columns.Add(new DataColumn(name, ft));
}
while (reader.Read())
{
var row = dt.NewRow();
for (int i = 0; i < fieldCount; i++)
{
row[i] = reader.GetValue(i);
}
dt.Rows.Add(row);
}
result.DataTable = dt;
//foreach (DataColumn column in dt.Columns)
//{
// Debug.WriteLine(string.Format("var {0}Pos = reader.GetOrdinal(\"{1}\");", Char.ToLowerInvariant(column.ColumnName[0]) + column.ColumnName.Substring(1), column.ColumnName));
//}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
result.QueryTimeSpan = swatch.Elapsed;
swatch.Stop();
return result;
}
public async void Execute_Works() {
var connectionInfo = new DbConnectionInfo() {
Uri = new Uri(BaseUri),
Host = "",
DatabaseName = "",
UserName = "",
Password = ""
};
var loginCommand = new LoginCommand(connectionInfo);
var httpClient = new HttpClient();
await loginCommand.Execute(httpClient);
}
public void CanCreateWithConnectionStringAndProviderType()
{
var result = new DbConnectionInfo
{
ConnectionString = "server=server",
Provider = "System.Data.SqlClient.SqlClientFactory, System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
};
Assert.That(result, Is.Not.Null);
Assert.That(result.ConnectionString, Is.EqualTo("server=server"));
Assert.That(result.Provider, Is.EqualTo("System.Data.SqlClient.SqlClientFactory, System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
Assert.That(result.ProviderFactory, Is.InstanceOf<System.Data.SqlClient.SqlClientFactory>());
}
public void LoadSchemaObjects(ICollection<SchemaObject> objectList, DbConnectionInfo connectionInfo)
{
var extractor = new SchemaExtractor();
objectList.Clear();
var tables = extractor.GetTables(connectionInfo);
var columns = extractor.GetTableColumns(connectionInfo);
AddColumns(tables, columns);
var sortedTables = from t in tables.Values
orderby t.Name
select t;
foreach (var t in sortedTables)
objectList.Add(t);
}
public static QueryResult Execute(string query, DbConnectionInfo connectionInfo)
{
var result = new QueryResult();
Stopwatch swatch = new Stopwatch();
swatch.Start();
try
{
using (var conn = new MySqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
var reader = cmd.ExecuteReader();
var fieldCount = reader.FieldCount;
DataTable dt = new DataTable();
for (int i = 0; i < fieldCount; i++)
{
var name = reader.GetName(i);
var ft = reader.GetFieldType(i);
Debug.Assert(ft != null, "ft != null");
dt.Columns.Add(new DataColumn(name, ft));
}
while (reader.Read())
{
var row = dt.NewRow();
for (int i = 0; i < fieldCount; i++)
{
row[i] = reader.GetValue(i);
}
dt.Rows.Add(row);
}
result.DataTable = dt;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
result.QueryTimeSpan = swatch.Elapsed;
swatch.Stop();
return result;
}
public Dictionary<string, List<DbColumn>> GetTableColumns(DbConnectionInfo connectionInfo)
{
var columns = new Dictionary<string, List<DbColumn>>();
var sql = @"SELECT TABLE_NAME as fullTableName , c.COLUMN_NAME as columnName, c.ORDINAL_POSITION as ordinal , c.IS_NULLABLE as is_nullable,
DATA_TYPE as datatype,c.CHARACTER_MAXIMUM_LENGTH as max_length
, c.NUMERIC_PRECISION
FROM INFORMATION_SCHEMA.COLUMNS c
where TABLE_SCHEMA != 'information_schema'
order by TABLE_NAME , ORDINAL_POSITION
";
using (var conn = new MySqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullTableNamePos = reader.GetOrdinal("fullTableName");
var columnNamePos = reader.GetOrdinal("columnName");
var is_nullablePos = reader.GetOrdinal("is_nullable");
//var is_identityPos = reader.GetOrdinal("is_identity");
var datatypePos = reader.GetOrdinal("datatype");
var max_lengthPos = reader.GetOrdinal("max_length");
while (reader.Read())
{
var fullTableName = reader.GetString(fullTableNamePos);
if (!columns.ContainsKey(fullTableName))
columns.Add(fullTableName, new List<DbColumn>());
var col = new DbColumn
{
Name = reader.GetString(columnNamePos),
IsNullable = (reader.GetString(is_nullablePos) == "YES"),
//IsIdentity = reader.GetBoolean(is_identityPos),
DataType = reader.GetString(datatypePos),
MaxLength = GetMaxLength(reader.GetValue(max_lengthPos))
};
col.DisplayDataType = DisplayType(col);
columns[fullTableName].Add(col);
}
}
}
return columns;
}
private void DuplicateConnection()
{
if (SelectedConnections.Contains(SelectedConnection) == false && SelectedConnection != null)
SelectedConnections.Add(SelectedConnection);
foreach (var origConn in SelectedConnections )
{
var newconn = new DbConnectionInfo
{
ObjectKey = new Guid(),
FriendlyName = origConn.FriendlyName + " copy",
DatabaseType = origConn.DatabaseType,
ConnectionString = origConn.ConnectionString,
Status = origConn.Status
};
Connections.Add(newconn);
}
}
public async void Execute_Works() {
var connectionInfo = new DbConnectionInfo() {
Uri = new Uri(BaseUri),
Host = "",
DatabaseName = "",
UserName = "",
Password = ""
};
var loginCommand = new LoginCommand(connectionInfo);
var httpClient = new HttpClient();
await loginCommand.Execute(httpClient);
using (var fileStream = File.Create("c:\\backup\\12345.bak")) {
var backupCommand = new BackupCommand(connectionInfo);
await backupCommand.Execute(httpClient, fileStream);
}
}
public MyCouchCloudantClient(DbConnectionInfo connectionInfo, MyCouchCloudantClientBootstrapper bootstrapper = null)
{
Ensure.That(connectionInfo, "connectionInfo").IsNotNull();
IsDisposed = false;
bootstrapper = bootstrapper ?? MyCouchCloudantClientBootstrappers.Default;
Connection = bootstrapper.DbConnectionFn(connectionInfo);
Serializer = bootstrapper.SerializerFn();
DocumentSerializer = bootstrapper.DocumentSerializerFn();
Changes = bootstrapper.ChangesFn(Connection);
Attachments = bootstrapper.AttachmentsFn(Connection);
Database = bootstrapper.DatabaseFn(Connection);
Documents = bootstrapper.DocumentsFn(Connection);
Entities = bootstrapper.EntitiesFn(Connection);
Views = bootstrapper.ViewsFn(Connection);
Searches = bootstrapper.SearchesFn(Connection);
Queries = bootstrapper.QueriesFn(Connection);
}
private static IMyCouchClient CreateDbClient(string dbName)
{
var config = Environment;
var connectionInfo = new DbConnectionInfo(config.ServerUrl, dbName);
if (config.HasCredentials())
connectionInfo.BasicAuth = new BasicAuthString(config.User, config.Password);
if (config.IsAgainstCloudant())
{
var bootstrapper = new MyCouchCloudantClientBootstrapper
{
DbConnectionFn = cnInfo => new CustomCloudantDbConnection(cnInfo)
};
return new MyCouchCloudantClient(connectionInfo, bootstrapper);
}
return new MyCouchClient(connectionInfo);
}
public Dictionary<string, List<DbParameter>> GetStoredProcedureParameters(DbConnectionInfo connectionInfo)
{
var parameters = new Dictionary<string, List<DbParameter>>();
var sql = @"select Specific_Schema + '.' + Specific_Name as Full_Procedure_Name,
PARAMETER_NAME, ORDINAL_POSITION, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, PARAMETER_MODE
from information_schema.parameters";
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullProcedureNamePos = reader.GetOrdinal("Full_Procedure_Name");
var ordinalPos = reader.GetOrdinal("ORDINAL_POSITION");
var parameterName = reader.GetOrdinal("PARAMETER_NAME");
var datatypePos = reader.GetOrdinal("DATA_TYPE");
var maxLengthPos = reader.GetOrdinal("CHARACTER_MAXIMUM_LENGTH");
while (reader.Read())
{
var fullName = reader.GetString(fullProcedureNamePos);
if (!parameters.ContainsKey(fullName))
parameters.Add(fullName, new List<DbParameter>());
parameters[fullName].Add(new DbParameter
{
Name = reader.GetString(parameterName),
Ordinal = reader.GetInt32( ordinalPos),
DataType = reader.GetString(datatypePos),
MaxLength = GetMaxLength(reader.GetValue(maxLengthPos))
});
}
}
}
return parameters;
}
public string Name(DbConnectionInfo connectionInfo)
{
Regex rx = new Regex(@"(?i)(database)\s*=\s*(?<Name>.*?)\s*;");
var db = rx.GroupValue(connectionInfo.ConnectionString, "Name");
return db;
}
public DbConnection(DbConnectionInfo connectionInfo) : base(connectionInfo)
{
DbName = connectionInfo.DbName;
}
private Dictionary<string, DbForeignKey> GetForeignKeys(DbConnectionInfo connectionInfo)
{
var fKeys = new Dictionary<string, DbForeignKey>();
var sql = @"select SCHEMA_NAME(sof.schema_id) + '.' + sof.name as ConstraintName ,
SCHEMA_NAME(sop.schema_id) + '.' + sop.name as ForeignKeyTable,
SCHEMA_NAME(sor.schema_id) + '.' +sor.name as PrimaryKeyTable,
scp.name as ForeignKeyColumn,
scf.name as PrimaryKeyColumn
from sys.foreign_key_columns fk
inner join Sys.objects sop on fk.parent_object_id = sop.object_id
inner join Sys.objects sof on fk.constraint_object_id = sof.object_id
inner join Sys.objects sor on fk.referenced_object_id = sor.object_id
inner join Sys.Columns scp on fk.parent_column_id = scp.column_id and fk.parent_object_id = scp.object_id
inner join Sys.Columns scf on fk.referenced_column_id = scf.column_id and fk.referenced_object_id = scf.object_id";
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var constraintNamePos = reader.GetOrdinal("ConstraintName");
var foreignKeyTablePos = reader.GetOrdinal("ForeignKeyTable");
var primaryKeyTablePos = reader.GetOrdinal("PrimaryKeyTable");
var foreignKeyColumnPos = reader.GetOrdinal("ForeignKeyColumn");
var primaryKeyColumnPos = reader.GetOrdinal("PrimaryKeyColumn");
while (reader.Read())
{
var constraintName = reader.GetString(constraintNamePos);
DbForeignKey fKey;
if (!fKeys.ContainsKey(constraintName))
{
fKey = new DbForeignKey
{
ConstraintFullName = constraintName,
ForeignKeyTable = reader.GetString(foreignKeyTablePos),
PrimaryKeyTable = reader.GetString(primaryKeyTablePos)
};
fKeys.Add(constraintName, fKey);
}
fKeys[constraintName].Columns.Add(new DbForeignKeyColumn
{
PrimaryKeyColumn = reader.GetString(primaryKeyColumnPos),
ForeignKeyColumn = reader.GetString(foreignKeyColumnPos),
});
}
}
}
return fKeys;
}
private Dictionary<string, List<string>> GetPrimaryKeyColumns(DbConnectionInfo connectionInfo)
{
var sql = @"SELECT
SCHEMA_NAME(t.schema_id) + '.' + t.name as tableFullName,
col_name(c.object_id, c.column_id) AS columnName,
c.key_ordinal AS ORDINAL_POSITION
FROM
sys.key_constraints k JOIN sys.index_columns c
ON c.object_id = k.parent_object_id
AND c.index_id = k.unique_index_id
JOIN sys.tables t ON t.object_id = k.parent_object_id";
var primaryKeys = new Dictionary<string, List<string>>();
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var tableFullNamePos = reader.GetOrdinal("tableFullName");
var columnNamePos = reader.GetOrdinal("columnName");
while (reader.Read())
{
var fullTableName = reader.GetString(tableFullNamePos);
if (!primaryKeys.ContainsKey(fullTableName))
primaryKeys.Add(fullTableName, new List<string>());
primaryKeys[fullTableName].Add(reader.GetString(columnNamePos));
}
}
}
return primaryKeys;
}
public override void RegisterRealTasks(PhysicalServer site)
{
var connectionInfo = new DbConnectionInfo{
Server = site.Name,
Instance = _instanceName,
DatabaseName = _databaseName,
UserName = _userName,
Password = _password
};
// string scriptsLocation = PathConverter.Convert(site, _path.GetFullPath(_scriptsLocation));
var task = new RoundhousETask(connectionInfo, _scriptsLocation,
_environmentName, _roundhouseMode,
_recoveryMode, _restorePath, _restoreTimeout, _restoreCustomOptions,
_repositoryPath, _versionFile, _versionXPath, _commandTimeout, _commandTimeoutAdmin,
_functionsFolderName, _sprocsFolderName, _viewsFolderName, _upFolderName, _runBeforeUpFolderName,
_versionTable, _scriptsRunTable, _scriptsRunErrorTable, _warnOnOneTimeScriptChanges,
_runAfterOtherAnytimeScriptsFolderName, _runAfterCreateDatabaseScriptsFolderName, _outputPath);
site.AddTask(task);
}
