mcs/class/Mono.Data.SqliteClient/Mono.Data.SqliteClient/SqliteParameterCollection.cs

   1 //
   2 // Mono.Data.SqliteClient.SqliteParameterCollection.cs
   3 //
   4 // Represents a collection of parameters relevant to a SqliteCommand as well as
   5 // their respective mappings to columns in a DataSet.
   6 //
   7 //Author(s):            Vladimir Vukicevic  <vladimir@pobox.com>
   8 //                      Everaldo Canuto  <everaldo_canuto@yahoo.com.br>
   9 //                      Chris Turchin <chris@turchin.net>
  10 //                      Jeroen Zwartepoorte <jeroen@xs4all.nl>
  11 //                      Thomas Zoechling <thomas.zoechling@gmx.at>
  12 //
  13 // Copyright (C) 2002  Vladimir Vukicevic
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 using System;
  36 using System.Data;
  37 using System.Collections;
  38
  39 namespace Mono.Data.SqliteClient
  40 {
  41         public class SqliteParameterCollection : IDataParameterCollection, IList
  42         {
  43
  44                 #region Fields
  45
  46                 ArrayList numeric_param_list = new ArrayList();
  47                 Hashtable named_param_hash = new Hashtable();
  48
  49                 #endregion
  50
  51                 #region Private Methods
  52
  53                 private void CheckSqliteParam (object value)
  54                 {
  55                         if (!(value is SqliteParameter))
  56                                 throw new InvalidCastException ("Can only use SqliteParameter objects");
  57                         SqliteParameter sqlp = value as SqliteParameter;
  58                         if (sqlp.ParameterName == null || sqlp.ParameterName.Length == 0)
  59                                 sqlp.ParameterName = this.GenerateParameterName();
  60                  }
  61
  62                 private void RecreateNamedHash ()
  63                 {
  64                         for (int i = 0; i < numeric_param_list.Count; i++)
  65                         {
  66                                 named_param_hash[((SqliteParameter) numeric_param_list[i]).ParameterName] = i;
  67                         }
  68                 }
  69
  70                 //FIXME: if the user is calling Insert at various locations with unnamed parameters, this is not going to work....
  71                 private string GenerateParameterName()
  72                 {
  73                         int             index   = this.Count + 1;
  74                         string  name    = String.Empty;
  75
  76                         while (index > 0)
  77                         {
  78                                 name = ":" + index.ToString();
  79                                         if (this.IndexOf(name) == -1)
  80                                         index = -1;
  81                                 else
  82                                 index++;
  83                         }
  84                         return name;
  85                 }
  86
  87                 #endregion
  88
  89                 #region Properties
  90
  91                 object IList.this[int index] {
  92                         get
  93                         {
  94                                 return this[index];
  95                         }
  96                         set
  97                         {
  98                                 CheckSqliteParam (value);
  99                                 this[index] = (SqliteParameter) value;
 100                         }
 101                 }
 102
 103                 object IDataParameterCollection.this[string parameterName] {
 104                         get
 105                         {
 106                                 return this[parameterName];
 107                         }
 108                         set
 109                         {
 110                                 CheckSqliteParam (value);
 111                                 this[parameterName] = (SqliteParameter) value;
 112                         }
 113                 }
 114
 115                 private bool isPrefixed (string parameterName)
 116                 {
 117                         return parameterName.Length > 1 && (parameterName[0] == ':' || parameterName[0] == '$');
 118                 }
 119
 120                 public SqliteParameter this[string parameterName]
 121                 {
 122                         get
 123                         {
 124                                 if (this.Contains(parameterName))
 125                                         return this[(int) named_param_hash[parameterName]];
 126                                 else if (isPrefixed(parameterName) && this.Contains(parameterName.Substring(1)))
 127                                         return this[(int) named_param_hash[parameterName.Substring(1)]];
 128                                 else
 129                                         throw new IndexOutOfRangeException("The specified name does not exist: " + parameterName);
 130                         }
 131                         set
 132                         {
 133                                 if (this.Contains(parameterName))
 134                                         numeric_param_list[(int) named_param_hash[parameterName]] = value;
 135                                 else if (parameterName.Length > 1 && this.Contains(parameterName.Substring(1)))
 136                                         numeric_param_list[(int) named_param_hash[parameterName.Substring(1)]] = value;
 137                                 else
 138                                         throw new IndexOutOfRangeException("The specified name does not exist: " + parameterName);
 139                         }
 140                 }
 141
 142                 public SqliteParameter this[int parameterIndex]
 143                 {
 144                         get
 145                         {
 146                                 if (this.Count >= parameterIndex+1)
 147                                         return (SqliteParameter) numeric_param_list[parameterIndex];
 148                                 else
 149                                         throw new IndexOutOfRangeException("The specified parameter index does not exist: " + parameterIndex.ToString());
 150                         }
 151                         set
 152                         {
 153                                 if (this.Count >= parameterIndex+1)
 154                                         numeric_param_list[parameterIndex] = value;
 155                                 else
 156                                         throw new IndexOutOfRangeException("The specified parameter index does not exist: " + parameterIndex.ToString());
 157                         }
 158                 }
 159
 160
 161                 public int Count
 162                 {
 163                         get
 164                         {
 165                                 return this.numeric_param_list.Count;
 166                         }
 167                 }
 168
 169                 bool IList.IsFixedSize
 170                 {
 171                         get
 172                         {
 173                                 return this.numeric_param_list.IsFixedSize;
 174                         }
 175                 }
 176
 177                 bool IList.IsReadOnly
 178                 {
 179                         get
 180                         {
 181                                 return this.numeric_param_list.IsReadOnly;
 182                         }
 183                 }
 184
 185
 186                 bool ICollection.IsSynchronized
 187                 {
 188                         get
 189                         {
 190                                 return this.numeric_param_list.IsSynchronized;
 191                         }
 192                 }
 193
 194
 195                 object ICollection.SyncRoot
 196                 {
 197                         get
 198                         {
 199                                 return this.numeric_param_list.SyncRoot;
 200                         }
 201                 }
 202
 203                 #endregion
 204
 205                 #region Public Methods
 206
 207                 public int Add (object value)
 208                 {
 209                         CheckSqliteParam (value);
 210                         SqliteParameter sqlp = value as SqliteParameter;
 211                         if (named_param_hash.Contains (sqlp.ParameterName))
 212                                 throw new DuplicateNameException ("Parameter collection already contains the a SqliteParameter with the given ParameterName.");
 213                         named_param_hash[sqlp.ParameterName] = numeric_param_list.Add(value);
 214                                 return (int) named_param_hash[sqlp.ParameterName];
 215                 }
 216
 217                 public SqliteParameter Add (SqliteParameter param)
 218                 {
 219                         Add ((object)param);
 220                         return param;
 221                 }
 222
 223                 public SqliteParameter Add (string name, object value)
 224                 {
 225                         return Add (new SqliteParameter (name, value));
 226                 }
 227
 228                 public SqliteParameter Add (string name, DbType type)
 229                 {
 230                         return Add (new SqliteParameter (name, type));
 231                 }
 232
 233                 public void Clear ()
 234                 {
 235                         numeric_param_list.Clear ();
 236                         named_param_hash.Clear ();
 237                 }
 238
 239                 public void CopyTo (Array array, int index)
 240                 {
 241                         this.numeric_param_list.CopyTo(array, index);
 242                 }
 243
 244                 bool IList.Contains (object value)
 245                 {
 246                         return Contains ((SqliteParameter) value);
 247                 }
 248
 249                 public bool Contains (string parameterName)
 250                 {
 251                         return named_param_hash.Contains (parameterName);
 252                 }
 253
 254                 public bool Contains (SqliteParameter param)
 255                 {
 256                         return Contains (param.ParameterName);
 257                 }
 258
 259                 public IEnumerator GetEnumerator ()
 260                 {
 261                         return this.numeric_param_list.GetEnumerator();
 262                 }
 263
 264                 int IList.IndexOf (object param)
 265                 {
 266                         return IndexOf ((SqliteParameter) param);
 267                 }
 268
 269                 public int IndexOf (string parameterName)
 270                 {
 271                         if (named_param_hash.Contains(parameterName))
 272                                 return (int) named_param_hash[parameterName];
 273                         else
 274                                 return -1;
 275                 }
 276
 277                 public int IndexOf (SqliteParameter param)
 278                 {
 279                         return IndexOf (param.ParameterName);
 280                 }
 281
 282                 public void Insert (int index, object value)
 283                 {
 284                         CheckSqliteParam (value);
 285                         if (numeric_param_list.Count == index)
 286                         {
 287                                 Add (value);
 288                                 return;
 289                         }
 290
 291                         numeric_param_list.Insert (index, value);
 292                         RecreateNamedHash ();
 293                 }
 294
 295                 public void Remove (object value)
 296                 {
 297                         CheckSqliteParam (value);
 298                         RemoveAt ((SqliteParameter) value);
 299                 }
 300
 301                 public void RemoveAt (int index)
 302                 {
 303                         RemoveAt (((SqliteParameter) numeric_param_list[index]).ParameterName);
 304                 }
 305
 306                 public void RemoveAt (string parameterName)
 307                 {
 308                         if (!named_param_hash.Contains (parameterName))
 309                                 throw new ApplicationException ("Parameter " + parameterName + " not found");
 310
 311                         numeric_param_list.RemoveAt ((int) named_param_hash[parameterName]);
 312                         named_param_hash.Remove (parameterName);
 313
 314                         RecreateNamedHash ();
 315                 }
 316
 317                 public void RemoveAt (SqliteParameter param)
 318                 {
 319                         RemoveAt (param.ParameterName);
 320                 }
 321
 322                 #endregion
 323         }
 324 }