static void Main(string[] args) { var databaseName = args.Length > 0 ? args[0] : null; var connectionString = new NpgsqlConnectionStringBuilder { Host = ConfigurationManager.AppSettings["host"], Database = databaseName ?? ConfigurationManager.AppSettings["database"], Username = ConfigurationManager.AppSettings["user"], Password = ConfigurationManager.AppSettings["password"], SslMode = SslMode.Prefer, TrustServerCertificate = true } .ConnectionString; var upgradeEngine = DeployChanges.To .PostgresqlDatabase(connectionString) .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly()) .LogToConsole() .Build(); var result = upgradeEngine.PerformUpgrade(); if (!result.Successful) { Console.ReadLine(); } }
internal static bool TestConnectionString(string connectString) { //Connection should be fast var sb = new Npgsql.NpgsqlConnectionStringBuilder(connectString); sb.Timeout = 15; connectString = sb.ToString(); var valid = false; using (var conn = new NpgsqlConnection()) { try { conn.ConnectionString = connectString; conn.Open(); valid = true; } catch (Exception ex) { Log.Warning(ex.ToString()); valid = false; } finally { conn.Close(); } } return(valid); }
public ViewModelConnectPgSql() { _connStrBuilder = new NpgsqlConnectionStringBuilder(); _connStrBuilder.Host = "localhost"; _connStrBuilder.Port = 5432; _connStrBuilder.SslMode = Npgsql.SslMode.Prefer; }
public NpgsqlStartupPacket(String database_name, String user_name, NpgsqlConnectionStringBuilder settings) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "BuildStartupPacket"); Dictionary<String, String> parameters = new Dictionary<String, String>(); parameters.Add("DateStyle", "ISO"); parameters.Add("client_encoding", "UTF8"); parameters.Add("extra_float_digits", "2"); if (! string.IsNullOrEmpty(settings.ApplicationName)) { parameters.Add("application_name", settings.ApplicationName); } if (! string.IsNullOrEmpty(settings.SearchPath)) { parameters.Add("search_path", settings.SearchPath); } //database parameterNames.Add(BackendEncoding.UTF8Encoding.GetBytes("database")); parameterValues.Add(BackendEncoding.UTF8Encoding.GetBytes(database_name)); //user parameterNames.Add(BackendEncoding.UTF8Encoding.GetBytes("user")); parameterValues.Add(BackendEncoding.UTF8Encoding.GetBytes(user_name)); //parameters foreach (KeyValuePair<String, String> param in parameters) { parameterNames.Add(BackendEncoding.UTF8Encoding.GetBytes(param.Key)); parameterValues.Add(BackendEncoding.UTF8Encoding.GetBytes(param.Value)); } }
public void Execute(Dictionary <string, string> input) { if (!input.Any(x => x.Key == PARAMKEYS_CREATE)) { return; } connectionString = DatabaseInstaller.GetSetting(input, DatabaseInstaller.PARAMKEYS_APPDB, string.Empty); Log.Information($"connectionstring censored: {CensorConnectionString(connectionString)}"); masterConnectionString = DatabaseInstaller.GetSetting(input, PARAMKEYS_MASTERDB, string.Empty); Log.Information($"masterconnectionstring censored: {CensorConnectionString(masterConnectionString)}"); newDatabaseName = DatabaseInstaller.GetSetting(input, PARAMKEYS_NEWNAME, string.Empty); Log.Information($"newDatabaseName: {newDatabaseName}"); if (DatabaseServer.TestConnectionString(connectionString)) { throw new Exception("The connection string references an existing database."); } if (string.IsNullOrEmpty(newDatabaseName)) { throw new Exception("A new database name was not specified."); } var builder = new Npgsql.NpgsqlConnectionStringBuilder(connectionString); if (builder.Database.ToLower() != newDatabaseName.ToLower()) { throw new Exception("A new database name does not match the specified connection string."); } CreateDatabase(); }
public IDocumentStore Initialize(Action<MartenRegistry> register = null) { var builder = new NpgsqlConnectionStringBuilder(_targetConnectionString); var targetDatabaseName = builder.Database; using (var connection = new NpgsqlConnection(_masterConnectionString)) { connection.Open(); var existsCommand = connection.CreateCommand(); existsCommand.CommandText = "select (count(*) > 0)::boolean as exists from pg_database where datname=:0"; existsCommand.Parameters.Add(new NpgsqlParameter("0", targetDatabaseName)); var exists = (bool)existsCommand.ExecuteScalar(); if (!exists) { var createCommand = connection.CreateCommand(); createCommand.CommandText = string.Format("CREATE DATABASE \"{0}\"", targetDatabaseName); createCommand.ExecuteNonQuery(); } } var store = DocumentStore.For(cfg => { cfg.Connection(_targetConnectionString); cfg.AutoCreateSchemaObjects = true; cfg.Schema.For<Commit>() .Searchable(x => x.StreamId) .Searchable(x => x.StreamVersion); if (register != null) { register(cfg.Schema); } }); return store; }
public static void Initialize() { var connectionString = ConfigurationManager.ConnectionStrings["TestDb"].ConnectionString; var connectionBuilder = new NpgsqlConnectionStringBuilder(connectionString); //connect to postgres database to create a new database var databaseName = connectionBuilder.Database; connectionBuilder.Database = "postgres"; connectionString = connectionBuilder.ToString(); using (var conn = new NpgsqlConnection(connectionString)) { conn.Open(); bool dbExists; using (var cmd = new NpgsqlCommand()) { cmd.CommandText = string.Format(@"SELECT TRUE FROM pg_database WHERE datname='{0}'", databaseName); cmd.Connection = conn; var result = cmd.ExecuteScalar(); dbExists = result != null && Convert.ToBoolean(result); } if (dbExists) { DoClean(conn); } else { DoCreate(conn, databaseName); } } }
// Zu Quell- und Zieldatenbank verbinden private void connectFischFaunaButton_Click(object sender, EventArgs e) { DatabaseConnection sourceCon = (DatabaseConnection)sourceDatabaseConnetions.SelectedValue; DatabaseConnection targetCon = (DatabaseConnection)targetDatabaseConnetions.SelectedValue; NpgsqlConnectionStringBuilder pgConStrBuilder = new NpgsqlConnectionStringBuilder(); pgConStrBuilder.Host = sourceCon.ServerAddress; pgConStrBuilder.UserName = sourceCon.UserName; pgConStrBuilder.Password = sourceCon.Password; pgConStrBuilder.Database = sourceCon.Database; MySqlConnectionStringBuilder mySqlConStrBuilder = new MySqlConnectionStringBuilder(); mySqlConStrBuilder.Server = targetCon.ServerAddress; mySqlConStrBuilder.UserID = targetCon.UserName; mySqlConStrBuilder.Password = targetCon.Password; mySqlConStrBuilder.Database = targetCon.Database; mySqlConStrBuilder.AllowZeroDateTime = true; _sourceCon = new NpgsqlConnection(pgConStrBuilder.ToString()); _targetCon = new MySqlConnection(mySqlConStrBuilder.ToString()); _mainLogic = new MainLogic(_sourceCon, _targetCon); _mainLogic.CheckForImportedFieldInMySql(); FillImportsCombobox(); FillImportUsersCombobox(); FillRecordQualityCombobox(); FillSourceTypeCombobox(); FillCountryCombobox(); PreSelectTestData(); groupBox2.Enabled = true; }
public static NpgsqlStartupPacket BuildStartupPacket(ProtocolVersion protocol_version, String database_name, String user_name, NpgsqlConnectionStringBuilder settings) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "BuildStartupPacket"); if (protocol_version == ProtocolVersion.Version2) { return new NpgsqlStartupPacketV2(database_name,user_name, "", "", ""); } else { Dictionary<String, String> parameters = new Dictionary<String, String>(); parameters.Add("DateStyle", "ISO"); parameters.Add("client_encoding", "UTF8"); parameters.Add("extra_float_digits", "2"); parameters.Add("lc_monetary", "C"); if (!string.IsNullOrEmpty(settings.ApplicationName)) { parameters.Add("application_name", settings.ApplicationName); } if (!string.IsNullOrEmpty(settings.SearchPath)) { parameters.Add("search_path", settings.SearchPath); } return new NpgsqlStartupPacketV3(database_name,user_name,parameters); } }
public Update(NpgsqlConnectionStringBuilder connectionInfo) { connectionInfo.PreloadReader = true; _dbName = connectionInfo.Database; _conn = new NpgsqlConnection(connectionInfo.ConnectionString); _conn.Open(); }
/// <summary> /// Default Constructor /// </summary> public ConnectionStringDialog() { InitializeComponent(); this.cmbServerName.Items.Add("<Browse for more>"); this.cmbServerName.Text = ""; dbConnectionStringBuilder = new NpgsqlConnectionStringBuilder(); }
public static string GetPgCon() { Npgsql.NpgsqlConnectionStringBuilder csb = new Npgsql.NpgsqlConnectionStringBuilder(); csb.Host = "127.0.0.1"; csb.Port = 5432; csb.Database = "postgres"; csb.IntegratedSecurity = false; if (!csb.IntegratedSecurity) { csb.Username = "******"; csb.Password = "******"; } csb.PersistSecurityInfo = false; csb.MinPoolSize = 1; csb.MaxPoolSize = 5; csb.Pooling = true; csb.ApplicationName = "foobar Application"; csb.Encoding = System.Text.Encoding.UTF8.WebName; return(csb.ConnectionString); }
public override void SetUpFixture() { PostgreSQLInsightDbProvider.RegisterProvider(); _connectionStringBuilder = new NpgsqlConnectionStringBuilder(); _connectionStringBuilder.ConnectionString = "Host = testserver; User Id = postgres; Password = Password1"; _connection = _connectionStringBuilder.Open(); }
/// <summary> /// Сохранение активного фильтра /// </summary> public void Save(object parameter = null) { FilterSaveFrm frm = new FilterSaveFrm(); frm.Text = "Фильтр"; if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK) { int idSource = 0; int idTable = 0; Npgsql.NpgsqlConnectionStringBuilder connect = (_source.Table.Source as PgDataRepositoryVM).Connect; String sourceName = String.Format("{0}@{1}", connect.Database, connect.Host); String sourceType = _source.Table.Source.Type.ToString(); Pg_M.PgTableBaseM pgTable = _source.Table as Pg_M.PgTableBaseM; String tableName = String.Format("\"{0}\".\"{1}\"", pgTable.SchemeName, pgTable.Name); bool sourceExists = (from Source src in Program.SettingsDB.Sources where src.SourceName == sourceName && src.SourceType == sourceType select src).Count() > 0; if (!sourceExists) { Program.SettingsDB.Sources.AddObject(new Source() { SourceName = sourceName, SourceType = sourceType }); } idSource = Convert.ToInt32((from Source src in Program.SettingsDB.Sources where src.SourceName == sourceName && src.SourceType == sourceType select src.Id).FirstOrDefault()); bool tableExists = (from Table tbl in Program.SettingsDB.Tables where tbl.SourceId == idSource && tbl.TableName == tableName select tbl).Count() > 0; if (!tableExists) { Program.SettingsDB.Tables.AddObject(new Table() { TableName = tableName, SourceId = idSource }); } idTable = Convert.ToInt32((from Table tbl in Program.SettingsDB.Tables where tbl.TableName == tableName && tbl.SourceId == idSource select tbl.Id).FirstOrDefault()); FilterRelationModel filterRM = GetFilterModel(_dynamicFilter); Program.SettingsDB.Filters.AddObject(new Filter() { FilterName = frm.textBox1.Text, WhereText = SqlJsonParser.ToJson(filterRM), IdTable = idTable }); Program.SettingsDB.SaveChanges(); ReloadFiltersFromSqLite(); } }
public override void Startup(NpgsqlConnector context,NpgsqlConnectionStringBuilder settings) { NpgsqlStartupPacket startupPacket = new NpgsqlStartupPacket(context.Database, context.UserName, settings); startupPacket.WriteToStream(context.Stream); context.RequireReadyForQuery = false; ProcessAndDiscardBackendResponses(context); }
public static NpgsqlConnection CreateConnection() { NpgsqlConnectionStringBuilder csb = new NpgsqlConnectionStringBuilder(GetConnectionString()); csb.Enlist = false; var connection = new NpgsqlConnection(csb.ToString()); connection.Open(); return connection; }
public DatabaseWorker() { var connectionParams = new NpgsqlConnectionStringBuilder(); connectionParams.Host = "127.0.0.1"; connectionParams.UserName = "******"; connectionParams.Password = "******"; connectionParams.Database = "bbrother"; _pgConnect = new NpgsqlConnection(connectionParams.ConnectionString); _pgConnect.Open(); }
private static void CreateDatabase() { var cxBuilder = new NpgsqlConnectionStringBuilder(ConnectionString); var database = cxBuilder.Database; cxBuilder.Database = null; var db = new NpgsqlConnection(cxBuilder.ToString()); db.Execute($"DROP DATABASE IF EXISTS \"{database}\""); db.Execute($"CREATE DATABASE \"{database}\""); }
public string ForceTestDB(string connectionString) { var cb = new NpgsqlConnectionStringBuilder(connectionString); if (!cb.Database.EndsWith("_test")) { cb.Database += "_test"; } return cb.ToString(); }
private static void UsingPostgresDBConnection(NpgsqlConnection connection, Action<NpgsqlConnection> action) { var connectionBuilder = new NpgsqlConnectionStringBuilder(connection.ConnectionString); using (var masterConnection = new NpgsqlConnection(connectionBuilder.ConnectionString)) { masterConnection.Open(); action(masterConnection); } }
public void Bug1011001() { //[#1011001] Bug in NpgsqlConnectionStringBuilder affects on cache and connection pool var csb1 = new NpgsqlConnectionStringBuilder(@"Server=server;Port=5432;User Id=user;Password=passwor;Database=database;"); var cs1 = csb1.ToString(); var csb2 = new NpgsqlConnectionStringBuilder(cs1); var cs2 = csb2.ToString(); Assert.IsTrue(cs1 == cs2); }
public static string ConnectionString() { var connectionStringBuilder = new NpgsqlConnectionStringBuilder(); connectionStringBuilder.Host = ConfigurationManager.AppSettings["Server"]; connectionStringBuilder.Database = ConfigurationManager.AppSettings["Database"]; connectionStringBuilder.UserName = ConfigurationManager.AppSettings["UserId"]; connectionStringBuilder.Password = ConfigurationManager.AppSettings["Password"]; return connectionStringBuilder.ConnectionString; }
public void BaseTypeResolution() { var csb = new NpgsqlConnectionStringBuilder(ConnectionString) { ApplicationName = nameof(BaseTypeResolution), // Prevent backend type caching in TypeHandlerRegistry Pooling = false }; using (var conn = OpenConnection(csb)) { // Resolve type by NpgsqlDbType using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.AddWithValue("p", NpgsqlDbType.Integer, DBNull.Value); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Is.EqualTo("int4")); } } // Resolve type by DbType conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter("p", DbType.Int32) { Value = DBNull.Value }); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Is.EqualTo("int4")); } } // Resolve type by ClrType (type inference) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter { ParameterName="p", Value = 8 }); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Is.EqualTo("int4")); } } // Resolve type by OID (read) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT 8", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Is.EqualTo("int4")); } } }
public void EnumTypeResolutionWithGlobalMapping() { var csb = new NpgsqlConnectionStringBuilder(ConnectionString) { ApplicationName = nameof(EnumTypeResolutionWithGlobalMapping), // Prevent backend type caching in TypeHandlerRegistry Pooling = false }; using (var conn = OpenConnection(csb)) { conn.ExecuteNonQuery("CREATE TYPE pg_temp.mood1 AS ENUM ('sad', 'ok', 'happy')"); NpgsqlConnection.MapEnumGlobally<Mood>("mood1"); try { conn.ReloadTypes(); // Resolve type by NpgsqlDbType using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Enum) { SpecificType = typeof(Mood), Value=DBNull.Value }); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".mood1")); Assert.That(reader.IsDBNull(0), Is.True); } } // Resolve type by ClrType (type inference) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p", Value = Mood.Ok }); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".mood1")); } } // Resolve type by OID (read) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT 'happy'::MOOD1", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".mood1")); } } finally { NpgsqlConnection.UnmapEnumGlobally<Mood>("mood1"); } } }
public void CompositeTypeResolutionWithGlobalMapping() { var csb = new NpgsqlConnectionStringBuilder(ConnectionString) { ApplicationName = nameof(CompositeTypeResolutionWithGlobalMapping), // Prevent backend type caching in TypeHandlerRegistry Pooling = false }; using (var conn = OpenConnection(csb)) { conn.ExecuteNonQuery("CREATE TYPE pg_temp.composite1 AS (x int, some_text text)"); NpgsqlConnection.MapCompositeGlobally<SomeComposite>("composite1"); try { conn.ReloadTypes(); // Resolve type by NpgsqlDbType using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Composite) { SpecificType = typeof(SomeComposite), Value = DBNull.Value }); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".composite1")); Assert.That(reader.IsDBNull(0), Is.True); } } // Resolve type by ClrType (type inference) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT @p", conn)) { cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p", Value = new SomeComposite { x = 8, SomeText = "foo" }}); using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".composite1")); } } // Resolve type by OID (read) conn.ReloadTypes(); using (var cmd = new NpgsqlCommand("SELECT ROW(1, 'foo')::COMPOSITE1", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetDataTypeName(0), Does.StartWith("pg_temp").And.EndWith(".composite1")); } } finally { NpgsqlConnection.UnmapCompositeGlobally<SomeComposite>("composite1"); } } }
private void button1_Click(object sender, EventArgs e) { NpgsqlConnectionStringBuilder pgsCS = new NpgsqlConnectionStringBuilder(); pgsCS.Host = @"10.211.55.2"; pgsCS.Database = @"openbrain"; pgsCS.UserName = @"postgres"; pgsCS.Password = @"postgres"; NpgsqlConnection pgCon = new NpgsqlConnection(pgsCS.ConnectionString); pgCon.Open(); pgCon.Close(); }
public override void Startup(NpgsqlConnector context,NpgsqlConnectionStringBuilder settings) { NpgsqlStartupPacket startupPacket = NpgsqlStartupPacket.BuildStartupPacket(context.BackendProtocolVersion, context.Database, context.UserName, settings); startupPacket.WriteToStream(context.Stream); context.RequireReadyForQuery = false; // This still makes part of the connection stablishment handling. // So we use the connectiontimeout here too. context.Mediator.CommandTimeout = context.ConnectionTimeout; ProcessAndDiscardBackendResponses(context); }
public ConnectionBuilder(bool standardConnection) { _connectionStringBuilder = new NpgsqlConnectionStringBuilder(); if (standardConnection) { this.Server("localhost") .Port("5432") .Database("App1") .User("App1DatabaseUser") .Password("pass1234"); } }
/// <summary> /// Initializes a new instance of the NpgsqlConnectionWithSchema class. /// </summary> /// <param name="connectionString">The connection string to wrap.</param> /// <param name="schema">The schema to select upon opening the connection.</param> public NpgsqlConnectionWithSchema(NpgsqlConnectionStringBuilder connectionString, string schema) : base(connectionString.Connection()) { if (schema == null) throw new ArgumentNullException("schema"); if (!Regex.Match(schema, String.Format(CultureInfo.InvariantCulture, "^{0}(,{0})*$", _validPostgresIdentifier)).Success) throw new ArgumentException("Schema contained invalid characters", "schema"); Schema = schema; _switchSchemaSql = String.Format(CultureInfo.InvariantCulture, "SET SCHEMA '{0}'", Schema); }
public NpgsqlConnectionStringBuilder ConStr() { string myConnectionString = ""; NpgsqlConnectionStringBuilder builder = new NpgsqlConnectionStringBuilder(myConnectionString); builder.Add("Server", textServer.Text); builder.Add("Port", textPort.Text); builder.Add("User", textUser.Text); builder.Add("Password", textPas.Text); builder.Add("Database", textBase.Text); return builder; }
private string GetConnectionString() { NpgsqlConnectionStringBuilder builder = new NpgsqlConnectionStringBuilder { Host = "localhost", Database = this.DatabaseName, UserName = this.UserName, Password = this.Password, ApplicationName = "MixERP Installer" }; return builder.ConnectionString; }
public virtual INpgsqlEFConnection CreateMasterConnection() { var builder = new NpgsqlConnectionStringBuilder { ConnectionString = ConnectionString }; // TODO: See #566 builder.Database = "postgres"; // TODO use clone connection method once implimented see #1406 var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseNpgsql(builder.ConnectionString).CommandTimeout(CommandTimeout); return new NpgsqlRelationalConnection(optionsBuilder.Options, _loggerFactory); }
internal static string ConnectionString() { NpgsqlConnectionStringBuilder connectionStringBuilder = new NpgsqlConnectionStringBuilder { Host = Program.Server, Port = Program.Port, Database = Program.Database, UserName = Program.UserId, Password = Program.Password }; return connectionStringBuilder.ConnectionString; }
/// <summary> /// builds connection to database and returns npgsql connection object /// </summary> /// <returns> Npgsql connection object</returns> private static NpgsqlConnection Connect() { NpgsqlConnectionStringBuilder myBuilder = new NpgsqlConnectionStringBuilder() { Host = "127.0.0.1", Port = 5432, Database = "KaminariWan.Website", IntegratedSecurity = true }; NpgsqlConnection conn = new NpgsqlConnection(myBuilder); return conn; }
internal static string BuildConnectionString(bool integratedSecurity, string databaseName, string serverName, string userName, string password) { var connStr = new StringBuilder(); var sb = new Npgsql.NpgsqlConnectionStringBuilder(); sb.IntegratedSecurity = integratedSecurity; sb.Database = databaseName; sb.Host = serverName; if (!integratedSecurity) { sb.Username = userName; sb.Password = password; } return(sb.ToString()); }
public DataManager() { Npgsql.NpgsqlConnectionStringBuilder ssb = new Npgsql.NpgsqlConnectionStringBuilder(); ssb.Host = "localhost"; ssb.Port = 5432; ssb.Username = "******"; ssb.Password = "******"; ssb.Database = "test_db"; ssb.CommandTimeout = 30; ssb.Pooling = true; ssb.MaxPoolSize = 20; ssb.MinPoolSize = 1; var cond = new Npgsql.NpgsqlConnection(ssb.ToString()); database = new Database(cond.ConnectionString); }
/// <summary> /// Загружает из базы SQLite названия и идентификаторы всех фильтров, относящихся к таблице _source.Table /// </summary> private void ReloadFiltersFromSqLite() { IdNameFilter.Clear(); Npgsql.NpgsqlConnectionStringBuilder connect = (_source.Table.Source as PgDataRepositoryVM).Connect; Pg_M.PgTableBaseM pgTable = _source.Table as Pg_M.PgTableBaseM; String sourceName = String.Format("{0}@{1}", connect.Database, connect.Host); String sourceType = pgTable.Source.Type.ToString(); String tableName = String.Format("\"{0}\".\"{1}\"", pgTable.SchemeName, pgTable.Name); var filters = from Filter f in Program.SettingsDB.Filters where f.Table.TableName == tableName && f.Table.Source.SourceName == sourceName && f.Table.Source.SourceType == sourceType select f; foreach (var filter in filters) { IdNameFilter.Add(new NameValue(filter.Id, filter.FilterName)); } }
/// <summary> /// Sets the `settings` ConnectionStringBuilder based on the given `connectionString` /// </summary> /// <param name="connectionString">The connection string to load the builder from</param> private void LoadConnectionStringBuilder(NpgsqlConnectionStringBuilder connectionString) { settings = connectionString; RefreshConnectionString(); LogConnectionString(); }
/// <summary> /// Initializes a new instance of the /// <see cref="NpgsqlConnection">NpgsqlConnection</see> class /// and sets the <see cref="NpgsqlConnection.ConnectionString">ConnectionString</see>. /// </summary> /// <param name="connectionString">The connection used to open the PostgreSQL database.</param> public NpgsqlConnection(NpgsqlConnectionStringBuilder connectionString) { LoadConnectionStringBuilder(connectionString); Init(); }
public virtual void Startup(NpgsqlConnector context, NpgsqlConnectionStringBuilder settings) { throw new InvalidOperationException("Internal Error! " + this); }
/// <summary> /// Initializes a new instance of the /// <see cref="NpgsqlConnection">NpgsqlConnection</see> class /// and sets the <see cref="NpgsqlConnection.ConnectionString">ConnectionString</see>. /// </summary> /// <param name="builder">The connection used to open the PostgreSQL database.</param> public NpgsqlConnection(NpgsqlConnectionStringBuilder builder) : this(builder.ConnectionString) { }