class/Npgsql/Npgsql/NpgsqlConnectionStringBuilder.cs

   1 // created on 29/11/2007
   2
   3
   4 // Npgsql.NpgsqlConnectionStringBuilder.cs
   5
   6 //
   7
   8 // Author:
   9
  10 //      Glen Parker (glenebob@nwlink.com)
  11
  12 //      Ben Sagal (bensagal@gmail.com)
  13
  14 //      Tao Wang (dancefire@gmail.com)
  15
  16 //      Veerapuram Varadhan  (vvaradhan@novell.com)
  17
  18 //
  19
  20 //      Copyright (C) 2007 The Npgsql Development Team
  21
  22 //      npgsql-general@gborg.postgresql.org
  23
  24 //      http://gborg.postgresql.org/project/npgsql/projdisplay.php
  25
  26 //
  27
  28 //      Copyright (C) 2009 Novell Inc
  29
  30 // Permission to use, copy, modify, and distribute this software and its
  31
  32 // documentation for any purpose, without fee, and without a written
  33
  34 // agreement is hereby granted, provided that the above copyright notice
  35
  36 // and this paragraph and the following two paragraphs appear in all copies.
  37
  38 //
  39
  40 // IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY
  41
  42 // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
  43
  44 // INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  45
  46 // DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF
  47
  48 // THE POSSIBILITY OF SUCH DAMAGE.
  49
  50 //
  51
  52 // THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  53
  54 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  55
  56 // AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
  57
  58 // ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS
  59
  60 // TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  61
  62 #if NET_2_0
  63 using System;
  64 using System.Collections.Generic;
  65 using System.Data.Common;
  66 using System.Resources;
  67
  68 namespace Npgsql
  69
  70 {
  71         public sealed class NpgsqlConnectionStringBuilder : DbConnectionStringBuilder
  72
  73         {
  74                 private static readonly ResourceManager resman = new ResourceManager(typeof (NpgsqlConnectionStringBuilder));
  75
  76                 private static readonly Dictionary<Keywords, object> defaults = new Dictionary<Keywords, object>();
  77
  78
  79                 private string originalConnectionString;
  80
  81
  82                 private const int POOL_SIZE_LIMIT = 1024;
  83
  84                 private const int TIMEOUT_LIMIT = 1024;
  85
  86
  87                 static NpgsqlConnectionStringBuilder()
  88
  89                 {
  90                         defaults.Add(Keywords.Host, string.Empty);
  91
  92                         defaults.Add(Keywords.Port, 5432);
  93
  94                         defaults.Add(Keywords.Protocol, ProtocolVersion.Unknown);
  95
  96                         defaults.Add(Keywords.Database, string.Empty);
  97
  98                         defaults.Add(Keywords.UserName, string.Empty);
  99
 100                         defaults.Add(Keywords.Password, string.Empty);
 101
 102                         defaults.Add(Keywords.SSL, false);
 103
 104                         defaults.Add(Keywords.SslMode, SslMode.Disable);
 105
 106                         defaults.Add(Keywords.Timeout, 15);
 107
 108                         defaults.Add(Keywords.SearchPath, string.Empty);
 109
 110                         defaults.Add(Keywords.Pooling, true);
 111
 112                         defaults.Add(Keywords.ConnectionLifeTime, 15);
 113
 114                         defaults.Add(Keywords.MinPoolSize, 1);
 115
 116                         defaults.Add(Keywords.MaxPoolSize, 20);
 117
 118                         defaults.Add(Keywords.SyncNotification, false);
 119
 120                         defaults.Add(Keywords.CommandTimeout, 20);
 121
 122                         defaults.Add(Keywords.Enlist, false);
 123
 124                         defaults.Add(Keywords.PreloadReader, false);
 125
 126                         defaults.Add(Keywords.UseExtendedTypes, false);
 127             defaults.Add(Keywords.IntegratedSecurity, false);
 128                 }
 129
 130
 131                 public NpgsqlConnectionStringBuilder()
 132
 133                 {
 134                         this.Clear();
 135                 }
 136
 137                 public NpgsqlConnectionStringBuilder(string connectionString)
 138
 139                 {
 140                     this.Clear();
 141
 142                     this.originalConnectionString = connectionString;
 143
 144                     base.ConnectionString = connectionString;
 145                 }
 146
 147
 148                 /// <summary>
 149                 /// Return an exact copy of this NpgsqlConnectionString.
 150                 /// </summary>
 151                 public NpgsqlConnectionStringBuilder Clone()
 152
 153                 {
 154                         NpgsqlConnectionStringBuilder builder = new NpgsqlConnectionStringBuilder();
 155
 156                         foreach (string key in this.Keys)
 157
 158                         {
 159                                 builder[key] = this[key];
 160                         }
 161
 162                         return builder;
 163                 }
 164
 165                 #region Parsing Functions
 166
 167                 private static SslMode ToSslMode(object value)
 168
 169                 {
 170                         if (value is SslMode)
 171
 172                         {
 173                                 return (SslMode) value;
 174                         }
 175
 176                         else
 177
 178                         {
 179                                 return (SslMode) Enum.Parse(typeof (SslMode), value.ToString(), true);
 180                         }
 181                 }
 182
 183
 184                 private static ProtocolVersion ToProtocolVersion(object value)
 185
 186                 {
 187                         if (value is ProtocolVersion)
 188
 189                         {
 190                                 return (ProtocolVersion) value;
 191                         }
 192
 193                         else
 194
 195                         {
 196                                 int ver = Convert.ToInt32(value);
 197
 198
 199                                 switch (ver)
 200
 201                                 {
 202                                         case 2:
 203
 204                                                 return ProtocolVersion.Version2;
 205
 206                                         case 3:
 207
 208                                                 return ProtocolVersion.Version3;
 209
 210                                         default:
 211
 212                                                 throw new InvalidCastException(value.ToString());
 213                                 }
 214                         }
 215                 }
 216
 217
 218                 private static string ToString(ProtocolVersion protocolVersion)
 219
 220                 {
 221                         switch (protocolVersion)
 222
 223                         {
 224                                 case ProtocolVersion.Version2:
 225
 226                                         return "2";
 227
 228                                 case ProtocolVersion.Version3:
 229
 230                                         return "3";
 231
 232                                 default:
 233
 234                                         return string.Empty;
 235                         }
 236                 }
 237
 238
 239                 private static int ToInt32(object value, int min, int max, string key)
 240
 241                 {
 242                         int v = Convert.ToInt32(value);
 243
 244                         if (v < min)
 245
 246                         {
 247                                 throw new ArgumentOutOfRangeException(String.Format(resman.GetString("Exception_IntegerKeyValMin"), key, min), key);
 248                         }
 249
 250                         else if (v > max)
 251
 252                         {
 253                                 throw new ArgumentOutOfRangeException(String.Format(resman.GetString("Exception_IntegerKeyValMax"), key, max), key);
 254                         }
 255
 256                         return v;
 257                 }
 258
 259
 260                 private static Boolean ToBoolean(object value)
 261
 262                 {
 263                         string text = value as string;
 264
 265                         if (text != null)
 266
 267                         {
 268                                 switch (text.ToLowerInvariant())
 269
 270                                 {
 271                                         case "t":
 272
 273                                         case "true":
 274
 275                                         case "y":
 276
 277                                         case "yes":
 278
 279                                                 return true;
 280
 281
 282                                         case "f":
 283
 284                                         case "false":
 285
 286                                         case "n":
 287
 288                                         case "no":
 289
 290                                                 return false;
 291
 292
 293                                         default:
 294
 295                                                 throw new InvalidCastException(value.ToString());
 296                                 }
 297                         }
 298
 299                         else
 300
 301                         {
 302                                 return Convert.ToBoolean(value);
 303                         }
 304                 }
 305
 306         private Boolean ToIntegratedSecurity(object value)
 307         {
 308             string text = value as string;
 309             if (text != null)
 310             {
 311                 switch (text.ToLowerInvariant())
 312                 {
 313                     case "t":
 314                     case "true":
 315                     case "y":
 316                     case "yes":
 317                     case "sspi":
 318                         return true;
 319
 320                     case "f":
 321                     case "false":
 322                     case "n":
 323                     case "no":
 324                         return false;
 325
 326                     default:
 327                         throw new InvalidCastException(value.ToString());
 328                 }
 329             }
 330             else
 331             {
 332                 return Convert.ToBoolean(value);
 333             }
 334         }
 335
 336                 #endregion
 337
 338                 #region Properties
 339
 340                 private string _host;
 341
 342
 343                 public string Host
 344
 345                 {
 346                         get { return _host; }
 347
 348                         set { SetValue(GetKeyName(Keywords.Host), value); }
 349                 }
 350
 351
 352                 private int _port;
 353
 354
 355                 public int Port
 356
 357                 {
 358                         get { return _port; }
 359
 360                         set { SetValue(GetKeyName(Keywords.Port), value); }
 361                 }
 362
 363
 364                 private ProtocolVersion _protocol;
 365
 366
 367                 public ProtocolVersion Protocol
 368
 369                 {
 370                         get { return _protocol; }
 371
 372                         set { SetValue(GetKeyName(Keywords.Protocol), value); }
 373                 }
 374
 375                 private string _database;
 376
 377
 378                 public string Database
 379
 380                 {
 381                         get { return _database; }
 382
 383                         set { SetValue(GetKeyName(Keywords.Database), value); }
 384                 }
 385
 386                 private string _username;
 387
 388
 389                 public string UserName
 390
 391                 {
 392                         get
 393             {
 394                 if (_integrated_security)
 395                 {
 396                     System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent();
 397                     _username = identity.Name.Split('\\')[1];
 398                 }
 399                 return _username;
 400             }
 401
 402                         set { SetValue(GetKeyName(Keywords.UserName), value); }
 403                 }
 404
 405                 private string _password;
 406
 407
 408                 public string Password
 409
 410                 {
 411                         get { return _password; }
 412
 413                         set { SetValue(GetKeyName(Keywords.Password), value); }
 414                 }
 415
 416                 private bool _ssl;
 417
 418
 419                 public bool SSL
 420
 421                 {
 422                         get { return _ssl; }
 423
 424                         set { SetValue(GetKeyName(Keywords.SSL), value); }
 425                 }
 426
 427
 428                 private SslMode _sslmode;
 429
 430
 431                 public SslMode SslMode
 432
 433                 {
 434                         get { return _sslmode; }
 435
 436                         set { SetValue(GetKeyName(Keywords.SslMode), value); }
 437                 }
 438
 439
 440                 [Obsolete("UTF-8 is always used regardless of this setting.")]
 441                 public string Encoding
 442                 {
 443                         get { return "UNICODE"; }
 444
 445                         //set { }
 446                 }
 447
 448
 449                 private int _timeout;
 450
 451
 452                 public int Timeout
 453
 454                 {
 455                         get { return _timeout; }
 456
 457                         set { SetValue(GetKeyName(Keywords.Timeout), value); }
 458                 }
 459
 460                 private string _searchpath;
 461
 462
 463                 public string SearchPath
 464
 465                 {
 466                         get { return _searchpath; }
 467
 468                         set { SetValue(GetKeyName(Keywords.SearchPath), value); }
 469                 }
 470
 471                 private bool _pooling;
 472
 473
 474                 public bool Pooling
 475
 476                 {
 477                         get { return _pooling; }
 478
 479                         set { SetValue(GetKeyName(Keywords.Pooling), value); }
 480                 }
 481
 482                 private int _connection_life_time;
 483
 484
 485                 public int ConnectionLifeTime
 486
 487                 {
 488                         get { return _connection_life_time; }
 489
 490                         set { SetValue(GetKeyName(Keywords.ConnectionLifeTime), value); }
 491                 }
 492
 493                 private int _min_pool_size;
 494
 495
 496                 public int MinPoolSize
 497
 498                 {
 499                         get { return _min_pool_size; }
 500
 501                         set { SetValue(GetKeyName(Keywords.MinPoolSize), value); }
 502                 }
 503
 504                 private int _max_pool_size;
 505
 506
 507                 public int MaxPoolSize
 508
 509                 {
 510                         get { return _max_pool_size; }
 511
 512                         set { SetValue(GetKeyName(Keywords.MaxPoolSize), value); }
 513                 }
 514
 515                 private bool _sync_notification;
 516
 517
 518                 public bool SyncNotification
 519
 520                 {
 521                         get { return _sync_notification; }
 522
 523                         set { SetValue(GetKeyName(Keywords.SyncNotification), value); }
 524                 }
 525
 526                 private int _command_timeout;
 527
 528
 529                 public int CommandTimeout
 530
 531                 {
 532                         get { return _command_timeout; }
 533
 534                         set { SetValue(GetKeyName(Keywords.CommandTimeout), value); }
 535                 }
 536
 537                 private bool _enlist;
 538
 539
 540                 public bool Enlist
 541
 542                 {
 543                         get { return _enlist; }
 544
 545                         set { SetValue(GetKeyName(Keywords.Enlist), value); }
 546                 }
 547
 548                 private bool _preloadReader;
 549
 550                 public bool PreloadReader
 551                 {
 552                         get { return _preloadReader; }
 553                         set { SetValue(GetKeyName(Keywords.PreloadReader), value); }
 554                 }
 555
 556                 private bool _useExtendedTypes;
 557
 558                 public bool UseExtendedTypes
 559                 {
 560                         get { return _useExtendedTypes; }
 561                         set { SetValue(GetKeyName(Keywords.UseExtendedTypes), value); }
 562                 }
 563
 564         private bool _integrated_security;
 565
 566         public bool IntegratedSecurity
 567         {
 568             get { return _integrated_security; }
 569             set { SetValue(GetKeyName(Keywords.IntegratedSecurity), value); }
 570         }
 571
 572                 #endregion
 573
 574                 private static Keywords GetKey(string key)
 575
 576                 {
 577                         switch (key.ToUpperInvariant())
 578
 579                         {
 580                                 case "HOST":
 581
 582                                 case "SERVER":
 583
 584                                         return Keywords.Host;
 585
 586                                 case "PORT":
 587
 588                                         return Keywords.Port;
 589
 590                                 case "PROTOCOL":
 591
 592                                         return Keywords.Protocol;
 593
 594                                 case "DATABASE":
 595
 596                                 case "DB":
 597
 598                                         return Keywords.Database;
 599
 600                                 case "USERNAME":
 601
 602                                 case "USER NAME":
 603
 604                                 case "USER":
 605
 606                                 case "USERID":
 607
 608                                 case "USER ID":
 609
 610                                 case "UID":
 611
 612                                         return Keywords.UserName;
 613
 614                                 case "PASSWORD":
 615
 616                                 case "PSW":
 617
 618                                 case "PWD":
 619
 620                                         return Keywords.Password;
 621
 622                                 case "SSL":
 623
 624                                         return Keywords.SSL;
 625
 626                                 case "SSLMODE":
 627
 628                                         return Keywords.SslMode;
 629
 630                                 case "ENCODING":
 631 #pragma warning disable 618
 632                                         return Keywords.Encoding;
 633 #pragma warning restore 618
 634                                 case "TIMEOUT":
 635
 636                                         return Keywords.Timeout;
 637
 638                                 case "SEARCHPATH":
 639
 640                                         return Keywords.SearchPath;
 641
 642                                 case "POOLING":
 643
 644                                         return Keywords.Pooling;
 645
 646                                 case "CONNECTIONLIFETIME":
 647
 648                                         return Keywords.ConnectionLifeTime;
 649
 650                                 case "MINPOOLSIZE":
 651
 652                                         return Keywords.MinPoolSize;
 653
 654                                 case "MAXPOOLSIZE":
 655
 656                                         return Keywords.MaxPoolSize;
 657
 658                                 case "SYNCNOTIFICATION":
 659
 660                                         return Keywords.SyncNotification;
 661
 662                                 case "COMMANDTIMEOUT":
 663
 664                                         return Keywords.CommandTimeout;
 665
 666                                 case "ENLIST":
 667
 668                                         return Keywords.Enlist;
 669
 670                                 case "PRELOADREADER":
 671                                 case "PRELOAD READER":
 672                                         return Keywords.PreloadReader;
 673
 674                                 case "USEEXTENDEDTYPES":
 675                                 case "USE EXTENDED TYPES":
 676                     return Keywords.UseExtendedTypes;
 677                 case "INTEGRATED SECURITY":
 678                     return Keywords.IntegratedSecurity;
 679
 680                                 default:
 681
 682                                         throw new ArgumentException(resman.GetString("Exception_WrongKeyVal"), key);
 683                         }
 684                 }
 685
 686
 687                 internal static string GetKeyName(Keywords keyword)
 688
 689                 {
 690                         if (keyword == Keywords.UserName)
 691
 692                         {
 693                                 return "USER ID";
 694             }
 695             else if (keyword == Keywords.IntegratedSecurity)
 696             {
 697                 return "INTEGRATED SECURITY";
 698             }
 699
 700                         else
 701
 702                         {
 703                                 return keyword.ToString().ToUpperInvariant();
 704                         }
 705                 }
 706
 707
 708                 internal static object GetDefaultValue(Keywords keyword)
 709
 710                 {
 711                         return defaults[keyword];
 712                 }
 713
 714
 715                 /// <summary>
 716                 /// Case insensative accessor for indivual connection string values.
 717                 /// </summary>
 718                 public override object this[string keyword]
 719
 720                 {
 721                         get { return this[GetKey(keyword)]; }
 722
 723                         set { this[GetKey(keyword)] = value; }
 724                 }
 725
 726                 public object this[Keywords keyword]
 727
 728                 {
 729                         get { return base[GetKeyName(keyword)]; }
 730
 731                         set { SetValue(GetKeyName(keyword), value); }
 732                 }
 733
 734
 735                 public override bool Remove(string keyword)
 736
 737                 {
 738                         Keywords key = GetKey(keyword);
 739
 740                         SetValue(key, defaults[key]);
 741
 742                         return base.Remove(keyword);
 743                 }
 744
 745
 746                 public bool ContainsKey(Keywords keyword)
 747
 748                 {
 749                         return base.ContainsKey(GetKeyName(keyword));
 750                 }
 751
 752
 753                 /// <summary>
 754                 /// This function will set value for known key, both private member and base[key].
 755                 /// </summary>
 756                 /// <param name="keyword"></param>
 757                 /// <param name="value"></param>
 758                 private void SetValue(string keyword, object value)
 759
 760                 {
 761                         if (value == null)
 762
 763                         {
 764                                 Remove(keyword);
 765                         }
 766
 767                         else
 768
 769                         {
 770                                 Keywords key = GetKey(keyword);
 771
 772                                 SetValue(key, value);
 773
 774                                 if (key == Keywords.Protocol)
 775
 776                                 {
 777                                         base[GetKeyName(key)] = ToString(this.Protocol);
 778                                 }
 779
 780                                 else
 781
 782                                 {
 783                                         base[GetKeyName(key)] = value;
 784                                 }
 785                         }
 786                 }
 787
 788
 789                 /// <summary>
 790                 /// The function will modify private member only, not base[key].
 791                 /// </summary>
 792                 /// <param name="keyword"></param>
 793                 /// <param name="value"></param>
 794                 private void SetValue(Keywords keyword, object value)
 795
 796                 {
 797                         string key_name = GetKeyName(keyword);
 798
 799                         try
 800
 801                         {
 802                                 switch (keyword)
 803
 804                                 {
 805                                         case Keywords.Host:
 806
 807                                                 this._host = Convert.ToString(value);
 808
 809                                                 break;
 810
 811                                         case Keywords.Port:
 812
 813                                                 this._port = Convert.ToInt32(value);
 814
 815                                                 break;
 816
 817                                         case Keywords.Protocol:
 818
 819                                                 this._protocol = ToProtocolVersion(value);
 820
 821                                                 break;
 822
 823                                         case Keywords.Database:
 824
 825                                                 this._database = Convert.ToString(value);
 826
 827                                                 break;
 828
 829                                         case Keywords.UserName:
 830
 831                                                 this._username = Convert.ToString(value);
 832
 833                                                 break;
 834
 835                                         case Keywords.Password:
 836
 837                                                 this._password = Convert.ToString(value);
 838
 839                                                 break;
 840
 841                                         case Keywords.SSL:
 842
 843                                                 this._ssl = ToBoolean(value);
 844
 845                                                 break;
 846
 847                                         case Keywords.SslMode:
 848
 849                                                 this._sslmode = ToSslMode(value);
 850
 851                                                 break;
 852
 853 #pragma warning disable 618
 854                                         case Keywords.Encoding:
 855                                                 break;
 856 #pragma warning restore 618
 857
 858                                         case Keywords.Timeout:
 859
 860                                                 this._timeout = ToInt32(value, 0, TIMEOUT_LIMIT, key_name);
 861
 862                                                 break;
 863
 864                                         case Keywords.SearchPath:
 865
 866                                                 this._searchpath = Convert.ToString(value);
 867
 868                                                 break;
 869
 870                                         case Keywords.Pooling:
 871
 872                                                 this._pooling = ToBoolean(value);
 873
 874                                                 break;
 875
 876                                         case Keywords.ConnectionLifeTime:
 877
 878                                                 this._connection_life_time = Convert.ToInt32(value);
 879
 880                                                 break;
 881
 882                                         case Keywords.MinPoolSize:
 883
 884                                                 this._min_pool_size = (MaxPoolSize > 0) ? ToInt32(value, 0, MaxPoolSize, key_name) : Convert.ToInt32(value);
 885
 886                                                 break;
 887
 888                                         case Keywords.MaxPoolSize:
 889
 890                                                 this._max_pool_size = ToInt32(value, 0, POOL_SIZE_LIMIT, key_name);
 891
 892                                                 break;
 893
 894                                         case Keywords.SyncNotification:
 895
 896                                                 this._sync_notification = ToBoolean(value);
 897
 898                                                 break;
 899
 900                                         case Keywords.CommandTimeout:
 901
 902                                                 this._command_timeout = Convert.ToInt32(value);
 903
 904                                                 break;
 905
 906                                         case Keywords.Enlist:
 907
 908                                                 this._enlist = ToBoolean(value);
 909
 910                                                 break;
 911
 912                                         case Keywords.PreloadReader:
 913
 914                                                 this._preloadReader = ToBoolean(value);
 915
 916                                                 break;
 917
 918                                         case Keywords.UseExtendedTypes:
 919
 920                                                 this._useExtendedTypes = ToBoolean(value);
 921
 922                         break;
 923                     case Keywords.IntegratedSecurity:
 924                         this._integrated_security = ToIntegratedSecurity(value);
 925                         break;
 926                                 }
 927                         }
 928
 929                         catch (InvalidCastException exception)
 930
 931                         {
 932                                 string exception_template = string.Empty;
 933
 934                                 switch (keyword)
 935
 936                                 {
 937                                         case Keywords.Port:
 938
 939                                         case Keywords.Timeout:
 940
 941                                         case Keywords.ConnectionLifeTime:
 942
 943                                         case Keywords.MinPoolSize:
 944
 945                                         case Keywords.MaxPoolSize:
 946
 947                                         case Keywords.CommandTimeout:
 948
 949                                                 exception_template = resman.GetString("Exception_InvalidIntegerKeyVal");
 950
 951                                                 break;
 952
 953                                         case Keywords.SSL:
 954
 955                                         case Keywords.Pooling:
 956
 957                                         case Keywords.SyncNotification:
 958
 959                                                 exception_template = resman.GetString("Exception_InvalidBooleanKeyVal");
 960
 961                                                 break;
 962
 963                                         case Keywords.Protocol:
 964
 965                                                 exception_template = resman.GetString("Exception_InvalidProtocolVersionKeyVal");
 966
 967                                                 break;
 968                                 }
 969
 970                                 if (!string.IsNullOrEmpty(exception_template))
 971
 972                                 {
 973                                         throw new ArgumentException(string.Format(exception_template, key_name), key_name, exception);
 974                                 }
 975
 976                                 throw;
 977                         }
 978                 }
 979
 980                 /// <summary>
 981                 /// Clear the member and assign them to the default value.
 982                 /// </summary>
 983                 public override void Clear()
 984
 985                 {
 986                         base.Clear();
 987
 988                         foreach (Keywords keyword in defaults.Keys)
 989
 990                         {
 991                                 SetValue(keyword, defaults[keyword]);
 992                         }
 993                 }
 994         }
 995
 996
 997         public enum Keywords
 998
 999         {
1000                 Host,
1001
1002                 Port,
1003
1004                 Protocol,
1005
1006                 Database,
1007
1008                 UserName,
1009
1010                 Password,
1011
1012                 SSL,
1013
1014                 SslMode,
1015
1016                 [Obsolete("UTF-8 is always used regardless of this setting.")] Encoding,
1017
1018                 Timeout,
1019
1020                 SearchPath,
1021
1022                 //      These are for the connection pool
1023
1024                 Pooling,
1025
1026                 ConnectionLifeTime,
1027
1028                 MinPoolSize,
1029
1030                 MaxPoolSize,
1031
1032                 SyncNotification,
1033
1034                 // These are for the command
1035
1036                 CommandTimeout,
1037
1038                 // These are for the resource manager
1039
1040                 Enlist,
1041
1042                 PreloadReader,
1043
1044                 UseExtendedTypes,
1045         IntegratedSecurity
1046         }
1047
1048
1049         public enum SslMode
1050
1051         {
1052                 Disable = 1 << 0,
1053
1054                 Allow = 1 << 1,
1055
1056                 Prefer = 1 << 2,
1057
1058                 Require = 1 << 3
1059         }
1060
1061 #endif
1062 }