public CSqlOptions CreateCsqlOptions() { DbConnectionParameter connectionParameter = new DbConnectionParameter(); connectionParameter.Provider = this.System; connectionParameter.DatasourceAddress = this.Server; connectionParameter.DatasourcePort = this.ServerPort; connectionParameter.Catalog = this.Database; connectionParameter.UserId = this.User; connectionParameter.Password = this.Password; connectionParameter.IntegratedSecurity = string.IsNullOrEmpty(this.User); CSqlOptions csqlOptions = new CSqlOptions(); csqlOptions.ConnectionParameter = connectionParameter; csqlOptions.ScriptFile = this.ScriptFile; csqlOptions.TempFile = this.TempFile; csqlOptions.DistributionFile = this.DistFile; csqlOptions.UsePreprocessor = this.UsePreprocessor; csqlOptions.BreakOnError = this.BreakOnError; csqlOptions.NoLogo = this.NoLogo; csqlOptions.Verbosity.Level = (TraceLevel)Verbose; csqlOptions.PreprocessorOptions.AdvancedArguments = this.PreprocessorArgs; csqlOptions.AddPreprocessorMacros(); return(csqlOptions); }
private void DbConnectionParameter_PropertyChangedTimer_Tick(object sender, EventArgs e) { Timer timer = (Timer)sender; string propertyName = (string)timer.Tag; timer.Stop(); this.ignoreParameterPropertyChanges = true; try { DbConnectionParameter parameter = this.dbConnectionParameter; switch (propertyName) { case "Provider": SelectMruDatasource(parameter, mruConnections); break; case "DatasourceComment": SelectMruDatasourceParameterByComment(parameter, mruConnections); break; case "DatasourceAddress": SelectMruDatasourceParameterByAddress(parameter, mruConnections); break; case "DatasourcePort": SelectMruDatasourceParameterByAddress(parameter, mruConnections); break; } this.propertyGrid.Refresh(); } finally { this.ignoreParameterPropertyChanges = false; } }
public string GetConnectionString(DbConnectionParameter parameter) { SqlConnectionStringBuilder connectionStringBuilder = new SqlConnectionStringBuilder(); if (!String.IsNullOrEmpty(parameter.DatasourceAddress)) { connectionStringBuilder.DataSource = parameter.DatasourceAddress; } if (!String.IsNullOrEmpty(parameter.Catalog)) { connectionStringBuilder.InitialCatalog = parameter.Catalog; } connectionStringBuilder.IntegratedSecurity = parameter.IntegratedSecurity; if (!String.IsNullOrEmpty(parameter.UserId)) { connectionStringBuilder.UserID = parameter.UserId; connectionStringBuilder.Password = parameter.Password ?? ""; } if (parameter.Timeout > 0) { connectionStringBuilder.ConnectTimeout = parameter.Timeout; } return(connectionStringBuilder.ConnectionString); }
/// <summary> /// Defines the method to be called when the command is invoked. /// </summary> /// <param name="parameter">The connection parameter.</param> public void Execute(object parameter) { DbConnectionParameter connectionParameter = (DbConnectionParameter)parameter; IWrappedDbConnectionFactory connectionFactory = DbConnectionFactoryProvider.GetFactory(connectionParameter.Provider); WrappedDbConnection dbConnection = null; bool succeeded = false; try { dbConnection = connectionFactory.CreateConnection(connectionParameter); succeeded = true; } catch (WrappedDbException) { } finally { if (dbConnection != null) { dbConnection.Dispose(); } } if (succeeded) { MessageBox.Show("Connection succeeded", "Connection Test", MessageBoxButton.OK, MessageBoxImage.Information); } else { MessageBox.Show("Connection failed", "Connection Test", MessageBoxButton.OK, MessageBoxImage.Error); } }
/// <summary> /// Defines the method that determines whether the command can execute in its current state. /// </summary> /// <param name="parameter">The connection parameter.</param> /// <returns> /// true if this command can be executed; otherwise, false. /// </returns> public bool CanExecute(object parameter) { if (!(parameter is DbConnectionParameter)) { return(false); } DbConnectionParameter connectionParameter = (DbConnectionParameter)parameter; if (connectionParameter == null || connectionParameter.Provider == ProviderType.Undefined) { return(false); } if (!connectionParameter.IntegratedSecurity) { if (String.IsNullOrEmpty(connectionParameter.UserId)) { return(false); } } return(true); }
public string GetConnectionString(DbConnectionParameter parameter) { StringBuilder sb = new StringBuilder(); if (!String.IsNullOrEmpty(parameter.DatasourceAddress)) { sb.Append("DataSource=").Append(parameter.DatasourceAddress).Append(";"); } if (!String.IsNullOrEmpty(parameter.Catalog)) { sb.Append("Database=").Append(parameter.Catalog).Append(";"); } if (!String.IsNullOrEmpty(parameter.UserId)) { sb.Append("User ID=").Append(parameter.UserId).Append(";"); sb.Append("Password="******";"); } else { sb.Append("Integrated Security=SSPI;"); } if (!String.IsNullOrEmpty(parameter.ApplicationName)) { sb.Append("Application Name=").Append(parameter.ApplicationName).Append(";"); } // The following property is a work around for the // error "30182 Invalid amount of parameters Optionen" sometime // raised by the provider if it encounters variable names. sb.Append("NamedParameters=false;"); string connectionString = sb.ToString(); return(connectionString); }
/// <summary> /// Initializes a new instance of the <see cref="ExecutionProcessor"/> class. /// </summary> /// <param name="cmdArgs">The CMD args.</param> public ExecutionProcessor(CSqlOptions csqlOptions) { this.options = csqlOptions; DbConnectionParameter connectionParameter = csqlOptions.ConnectionParameter; this.connection = DbConnectionFactoryProvider.CreateConnection(connectionParameter); this.connection.InfoMessage += new EventHandler <DbMessageEventArgs>(InfoMessageEventHandler); }
protected override IDbConnection CreateAdoConnection(DbConnectionParameter parameter) { var adoConnection = connectionFactory.CreateAdoConnection(parameter); adoConnection.InfoMessage += new SqlCeInfoMessageEventHandler(InfoMessageHandler); adoConnection.Open(); return(adoConnection); }
/// <summary> /// Creates the ADO.NET connection. /// </summary> /// <param name="parameter">The connection parameter.</param> /// <returns>An open ADO connection.</returns> internal System.Data.SqlServerCe.SqlCeConnection CreateAdoConnection(DbConnectionParameter parameter) { string connectionString = GetConnectionString(parameter); Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to SQL CE database using following connection string:\r\n" + connectionString); System.Data.SqlServerCe.SqlCeConnection connection = new System.Data.SqlServerCe.SqlCeConnection(connectionString); return(connection); }
/// <summary> /// Creates the ADO.NET connection. /// </summary> /// <param name="parameter">The connection parameter.</param> /// <returns>An open ADO connection.</returns> internal SqlConnection CreateAdoConnection(DbConnectionParameter parameter) { string connectionString = GetConnectionString(parameter); Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to MS SQL Server using following connection string:\r\n" + connectionString); SqlConnection connection = new SqlConnection(connectionString); return(connection); }
private static DbConnectionParameter CreateDbConnectionParameter(DbConnectionParameter dbConnectionParameter, Document activeDocument) { DocumentEnvironment environment = new DocumentEnvironment(activeDocument); VariableSubstitutor substitutor = new VariableSubstitutor(environment); DbConnectionParameter dbConnectionParameterCopy = new DbConnectionParameter(dbConnectionParameter); dbConnectionParameterCopy.DatasourceAddress = substitutor.Substitute(dbConnectionParameter.DatasourceAddress); dbConnectionParameterCopy.Catalog = substitutor.Substitute(dbConnectionParameter.Catalog); return(dbConnectionParameterCopy); }
public UnitOfWork(DbConnectionParameter dbConnectionParameter) { if (dbConnectionParameter == DbConnectionParameter.eCollabro) { _context = new eCollabroDbModel(); } //else if (dbConnectionParameter == DbConnectionParameter.ADP) // _context = new ADPModel(); _context.Configuration.LazyLoadingEnabled = false; _instanceId = Guid.NewGuid(); }
protected override IDbConnection CreateAdoConnection(DbConnectionParameter parameter) { string connectionString = connectionFactory.GetConnectionString(parameter); Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to Sybase ASE Server using following connection string:\r\n" + connectionString); IDbConnection adoConnection = CreateAseConnection(); adoConnection.ConnectionString = connectionString; adoConnection.Open(); return(adoConnection); }
public CSqlOptions() { this.connectionParameter = new DbConnectionParameter(); this.preprocessorOptions = new SqtppOptions(); this.verbosity = new VerbositySwitch(); DistributionFile = String.Empty; TempFile = String.Empty; ScriptFile = String.Empty; BreakOnError = true; UsePreprocessor = true; MaxResultColumnWidth = 40; }
private static void SelectMruDatasourceParameter( DbConnectionParameter parameter, Datasource datasource ) { if ( datasource.Catalogs != null && datasource.Catalogs.Count > 0 ) { string catalog = datasource.Catalogs[0]; parameter.Catalog = catalog; } if ( datasource.Authentications != null && datasource.Authentications.Count > 0 ) { Authentication authentication = datasource.Authentications[0]; parameter.IntegratedSecurity = authentication.Integrated; parameter.UserId = authentication.UserId; parameter.Password = authentication.Password; } }
private static void SelectMruDatasource( DbConnectionParameter parameter, MruConnections mruConnection ) { if ( mruConnection == null ) return; var datasources = mruConnection.FindDatasources( parameter.Provider ); if ( datasources == null || datasources.Datasource == null || datasources.Datasource.Count == 0 ) return; var datasource = datasources.Datasource[0]; parameter.DatasourceComment = datasource.Comment; parameter.DatasourceAddress = datasource.Address; SelectMruDatasourceParameter( parameter, datasource ); }
private static void SelectMruDatasourceParameterByComment( DbConnectionParameter parameter, MruConnections mruConnection ) { if ( mruConnection == null ) return; var provider = parameter.Provider; var datasource = mruConnection.FindDatasourceByComment( ref provider, parameter.DatasourceComment ); if ( datasource == null ) return; parameter.Provider = provider; parameter.DatasourceComment = datasource.Comment; parameter.DatasourceAddress = datasource.Address; SelectMruDatasourceParameter( parameter, datasource ); }
/// <summary> /// Stores the current database connection parameter in the global variables /// of the visual studio environment. /// </summary> /// <param name="dbConnectionParameter">The database connection parameter.</param> internal void SaveDbConnectionParameterInGlobals(DbConnectionParameter dbConnectionParameter) { IWrappedDbConnectionFactory factory = DbConnectionFactoryProvider.GetFactory(dbConnectionParameter.Provider); string providerName = factory.ProviderName; string connectionString = factory.GetConnectionString(dbConnectionParameter); Globals globals = application.Globals; string variableName = CSqlConnectionFactory.CSqlConnectionProviderVariableName; globals[variableName] = providerName; globals.set_VariablePersists(variableName, true); variableName = CSqlConnectionFactory.CSqlConnectionStringVariableName; globals[variableName] = connectionString; globals.set_VariablePersists(variableName, true); }
private void ReloadSettings() { SettingsManager settingsManager = SettingsManager.GetInstance( application ); this.mruConnections = settingsManager.MruDbConnectionParameters; this.dbConnectionParameter = settingsManager.CurrentDbConnectionParameter; this.scriptParameters = settingsManager.ScriptParameters; InitObjectSelectionComboBox(); this.reloadSettings = false; if ( dbConnectionParameter != null ) { dbConnectionParameter.GetDatasourceNameValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetDatasourceNameValues ); dbConnectionParameter.GetDatasourceAddressValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetDatasourceAddressValues ); dbConnectionParameter.GetCatalogValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetCatalogValues ); dbConnectionParameter.GetUserIdValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetUserIdValues ); dbConnectionParameter.PropertyChanged += new PropertyChangedEventHandler( DbConnectionParameter_PropertyChanged ); } }
private static BindingList<SelectedObjectComboBoxItem> CreateComboItems( DbConnectionParameter dbConnectionParameter, ScriptParameterCollection scriptParameters ) { var result = new BindingList<SelectedObjectComboBoxItem>(); if ( dbConnectionParameter != null ) { var connectionItem = new DbConnectionComboBoxItem( dbConnectionParameter ); result.Add( connectionItem ); } if ( scriptParameters != null ) { foreach ( var scriptParameter in scriptParameters ) { var parameterItem = new SelectedScriptParameterComboBoxItem( scriptParameter ); parameterItem.IsCurrent = scriptParameter.Equals( scriptParameters.Current ); result.Add( parameterItem ); } } return result; }
/// <summary> /// Update the most recently used db connection parameter in the application data folder. /// </summary> /// <param name="dbConnectionParameter">The db connection parameter.</param> internal void SaveDbConnectionParameterInMruHistory(DbConnectionParameter dbConnectionParameter) { MruConnections mruConnections = MruDbConnectionParameters; if (mruConnections == null) { return; } bool parameterChanged = MruDbConnectionParameterAdapter.SetMruDbConnectionParameter(mruConnections, dbConnectionParameter); if (!parameterChanged) { return; } string mruConnectionsPath = GetGlobalFilePath(MruConnectionFileName); if (String.IsNullOrEmpty(mruConnectionsPath)) { return; } try { string directory = Path.GetDirectoryName(mruConnectionsPath); Directory.CreateDirectory(directory); using (Stream stream = new FileStream(mruConnectionsPath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan)) { XmlSchema xmlSchema = MruConnections.Schema; XmlSerializer serializer = new XmlSerializer(typeof(MruConnections), xmlSchema.TargetNamespace); serializer.Serialize(stream, mruConnections); stream.Close(); } } catch (Exception ex) { string context = MethodInfo.GetCurrentMethod().Name; string message = String.Format("{0}: Failed to save connection settings because [{1}].", context, ex.Message); Debug.WriteLine(message); var outputPane = Output.GetAndActivateOutputPane((EnvDTE80.DTE2)application); outputPane.OutputString(message); } }
private static CSqlOptions CreateCSqlOptions(DbConnectionParameter dbConnectionParameter, ScriptParameter csqlParameter, Document activeDocument) { CSqlOptions csqlOptions = new CSqlOptions(); DocumentEnvironment environment = new DocumentEnvironment(activeDocument); VariableSubstitutor substitutor = new VariableSubstitutor(environment); csqlOptions.ScriptFile = activeDocument.FullName; if (csqlParameter.IsOutputFileEnabled) { string file = substitutor.Substitute(csqlParameter.OutputFile); csqlOptions.DistributionFile = file; } else { csqlOptions.DistributionFile = null; } if (csqlParameter.IsTemporaryFileEnabled) { string file = substitutor.Substitute(csqlParameter.TemporaryFile); csqlOptions.TempFile = file; } else { csqlOptions.TempFile = null; } csqlOptions.BreakOnError = csqlParameter.IsBreakOnErrorEnabled; csqlOptions.UsePreprocessor = csqlParameter.IsPreprocessorEnabled; csqlOptions.ConnectionParameter = dbConnectionParameter; csqlOptions.PreprocessorOptions = CreatePreprocessorArguments(substitutor, csqlParameter); csqlOptions.AddPreprocessorMacros(); csqlOptions.Verbosity.Level = csqlParameter.Verbosity; csqlOptions.NoLogo = false; csqlOptions.MaxResultColumnWidth = csqlParameter.MaxResultColumnWidth; return(csqlOptions); }
/// <inheritdoc/> public string GetConnectionString(DbConnectionParameter parameter) { DbConnectionStringBuilder connectionStringBuilder = new DbConnectionStringBuilder(); string dataSource = string.Empty; if (!string.IsNullOrEmpty(parameter.DatasourceAddress)) { dataSource = parameter.DatasourceAddress; } if (!string.IsNullOrEmpty(parameter.Catalog)) { dataSource = Path.Combine(dataSource, parameter.Catalog); } if (!string.IsNullOrEmpty(dataSource)) { connectionStringBuilder.Add("Data Source", dataSource); } return(connectionStringBuilder.ConnectionString); }
/// <inheritdoc/> public WrappedDbConnection CreateConnection(DbConnectionParameter parameter) { var connection = new MsSqlWrappedConnection(this, parameter); return(connection); }
internal SqlCeWrappedConnection(SqlCeConnectionFactory connectionFactory, DbConnectionParameter parameter) : base(parameter) { this.connectionFactory = connectionFactory; }
internal DbConnectionComboBoxItem(DbConnectionParameter connectionParameter) : base(connectionParameter) { }
public WrappedDbConnection CreateConnection(DbConnectionParameter parameter) { WrappedDbConnection connection = new SybaseConnection(this, parameter); return(connection); }
public SybaseConnection(SybaseConnectionFactory connectionFactory, DbConnectionParameter parameter) : base(parameter) { this.connectionFactory = connectionFactory; }
public WrappedDbConnection CreateConnection(DbConnectionParameter parameter) { throw new NotImplementedException(); }
public string GetConnectionString(DbConnectionParameter parameter) { throw new NotImplementedException(); }