System.Data.SQLite
Check-in [85ed84191d]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:1.0.56.0 beta
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | sourceforge
Files: files | file ages | folders
SHA1: 85ed84191d90d721a22be3a944dd361e7d25b72e
User & Date: rmsimpson 2008-08-08 05:42:20
Context
2008-08-11
21:12
1.0.56.0 check-in: faaaeb7bd7 user: rmsimpson tags: sourceforge
2008-08-08
05:42
1.0.56.0 beta check-in: 85ed84191d user: rmsimpson tags: sourceforge
2008-08-06
21:49
1.0.55.0 check-in: 8848fb5ed8 user: rmsimpson tags: sourceforge
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to System.Data.SQLite/AssemblyInfo.cs.

    44     44   //      Major Version
    45     45   //      Minor Version 
    46     46   //      Build Number
    47     47   //      Revision
    48     48   //
    49     49   // You can specify all the values or you can default the Revision and Build Numbers 
    50     50   // by using the '*' as shown below:
    51         -[assembly: AssemblyVersion("1.0.55.0")]
           51  +[assembly: AssemblyVersion("1.0.56.0")]
    52     52   #if !PLATFORM_COMPACTFRAMEWORK
    53         -[assembly: AssemblyFileVersion("1.0.55.0")]
           53  +[assembly: AssemblyFileVersion("1.0.56.0")]
    54     54   #endif

Changes to System.Data.SQLite/LINQ/SQLiteFactory_Linq.cs.

    41     41       }
    42     42   
    43     43       [ReflectionPermission(SecurityAction.Assert, MemberAccess = true)]
    44     44       private object GetSQLiteProviderServicesInstance()
    45     45       {
    46     46         if (_sqliteServices == null)
    47     47         {
    48         -        Type type = Type.GetType("System.Data.SQLite.SQLiteProviderServices, System.Data.SQLite.Linq, Version=2.0.35.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139", false);
           48  +        Type type = Type.GetType("System.Data.SQLite.SQLiteProviderServices, System.Data.SQLite.Linq, Version=2.0.36.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139", false);
    49     49           if (type != null)
    50     50           {
    51     51             FieldInfo field = type.GetField("Instance", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
    52     52             _sqliteServices = field.GetValue(null);
    53     53           }
    54     54         }
    55     55         return _sqliteServices;
    56     56       }
    57     57     }
    58     58   }

Changes to System.Data.SQLite/SQLite3.cs.

    67     67       internal override void Cancel()
    68     68       {
    69     69         UnsafeNativeMethods.sqlite3_interrupt(_sql);
    70     70       }
    71     71   
    72     72       internal override string Version
    73     73       {
           74  +      get
           75  +      {
           76  +        return SQLite3.SQLiteVersion;
           77  +      }
           78  +    }
           79  +
           80  +    internal static string SQLiteVersion
           81  +    {
    74     82         get
    75     83         {
    76     84           return UTF8ToString(UnsafeNativeMethods.sqlite3_libversion(), -1);
    77     85         }
    78     86       }
    79     87   
    80     88       internal override int Changes
................................................................................
   162    170               if ((uint)Environment.TickCount - starttick > timeout)
   163    171               {
   164    172                 throw new SQLiteException(r, SQLiteLastError());
   165    173               }
   166    174               else
   167    175               {
   168    176                 // Otherwise sleep for a random amount of time up to 250ms
   169         -              UnsafeNativeMethods.sqlite3_sleep((uint)rnd.Next(1, 250));
          177  +              System.Threading.Thread.CurrentThread.Join(rnd.Next(1, 250));
   170    178               }
   171    179             }
   172    180           }
   173    181         }
   174    182       }
   175    183   
   176    184       internal override int Reset(SQLiteStatement stmt)
................................................................................
   303    311               if ((uint)Environment.TickCount - starttick > timeoutMS)
   304    312               {
   305    313                 throw new SQLiteException(n, SQLiteLastError());
   306    314               }
   307    315               else
   308    316               {
   309    317                 // Otherwise sleep for a random amount of time up to 250ms
   310         -              UnsafeNativeMethods.sqlite3_sleep((uint)rnd.Next(1, 250));
          318  +              System.Threading.Thread.CurrentThread.Join(rnd.Next(1, 250));
   311    319               }
   312    320             }
   313    321           }
   314    322   
   315    323           if (n > 0) throw new SQLiteException(n, SQLiteLastError());
   316    324   
   317    325           strRemain = UTF8ToString(ptr, len);

Changes to System.Data.SQLite/SQLiteConnection.cs.

   467    467             cnn._enlistment._disposeConnection = true;
   468    468             _sql = null;
   469    469             _enlistment = null;
   470    470           }
   471    471   #endif
   472    472           if (_sql != null)
   473    473           {
   474         -          if (_transactionLevel > 0)
   475         -            SQLiteTransaction.IssueRollback(this);
   476         -
   477    474             _sql.Close();
   478    475           }
   479    476           _sql = null;
   480    477           _transactionLevel = 0;
   481    478         }
   482    479         OnStateChange(ConnectionState.Closed);
   483    480       }
................................................................................
   939    936         {
   940    937           if (_connectionState != ConnectionState.Open)
   941    938             throw new InvalidOperationException();
   942    939   
   943    940           return _sql.Version;
   944    941         }
   945    942       }
          943  +
          944  +    /// <summary>
          945  +    /// Returns the version of the underlying SQLite database engine
          946  +    /// </summary>
          947  +    public static string SQLiteVersion
          948  +    {
          949  +      get { return SQLite3.SQLiteVersion; }
          950  +    }
   946    951   
   947    952       /// <summary>
   948    953       /// Returns the state of the connection.
   949    954       /// </summary>
   950    955   #if !PLATFORM_COMPACTFRAMEWORK
   951    956       [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   952    957   #endif

Changes to System.Data.SQLite/SQLiteConnectionStringBuilder.cs.

    52     52       /// <summary>
    53     53       /// Private initializer, which assigns the connection string and resets the builder
    54     54       /// </summary>
    55     55       /// <param name="cnnString">The connection string to assign</param>
    56     56       private void Initialize(string cnnString)
    57     57       {
    58     58         _properties = new Hashtable();
    59         -      base.GetProperties(_properties);
           59  +      try
           60  +      {
           61  +        base.GetProperties(_properties);
           62  +      }
           63  +      catch(NotImplementedException)
           64  +      {
           65  +        FallbackGetProperties(_properties);
           66  +      }
    60     67   
    61     68         if (String.IsNullOrEmpty(cnnString) == false)
    62     69           ConnectionString = cnnString;
    63     70       }
    64     71   
    65     72       /// <summary>
    66     73       /// Gets/Sets the default version of the SQLite engine to instantiate.  Currently the only valid value is 3, indicating version 3 of the sqlite library.
................................................................................
   245    252   
   246    253       /// <summary>
   247    254       /// If set to true, will throw an exception if the database specified in the connection
   248    255       /// string does not exist.  If false, the database will be created automatically.
   249    256       /// </summary>
   250    257       [Browsable(true)]
   251    258       [DefaultValue(false)]
   252         -    [DisplayName("Fail If Missing")]
   253    259       public bool FailIfMissing
   254    260       {
   255    261         get
   256    262         {
   257    263           object value;
   258    264           TryGetValue("failifmissing", out value);
   259    265           return SQLiteConvert.ToBoolean(value);
................................................................................
   464    470   
   465    471         if (!_properties.ContainsKey(keyword)) return b;
   466    472   
   467    473         PropertyDescriptor pd = _properties[keyword] as PropertyDescriptor;
   468    474   
   469    475         if (pd == null) return b;
   470    476   
          477  +      // Attempt to coerce the value into something more solid
   471    478         if (b)
   472    479         {
   473         -        value = TypeDescriptor.GetConverter(pd.PropertyType).ConvertFrom(value);
          480  +        if (pd.PropertyType == typeof(Boolean))
          481  +          value = SQLiteConvert.ToBoolean(value);
          482  +        else
          483  +          value = TypeDescriptor.GetConverter(pd.PropertyType).ConvertFrom(value);
   474    484         }
   475    485         else
   476    486         {
   477    487           DefaultValueAttribute att = pd.Attributes[typeof(DefaultValueAttribute)] as DefaultValueAttribute;
   478    488           if (att != null)
   479    489           {
   480    490             value = att.Value;
   481    491             b = true;
   482    492           }
   483    493         }
   484    494         return b;
   485    495       }
          496  +
          497  +    private void FallbackGetProperties(Hashtable propertyList)
          498  +    {
          499  +      foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(this, true))
          500  +      {
          501  +        if (descriptor.Name != "ConnectionString" && propertyList.ContainsKey(descriptor.DisplayName) == false)
          502  +        {
          503  +          propertyList.Add(descriptor.DisplayName, descriptor);
          504  +        }
          505  +      }
          506  +    }
   486    507     }
   487    508   #endif
   488    509   }

Changes to System.Data.SQLite/SQLiteDataReader.cs.

   262    262             break;
   263    263           case TypeAffinity.Text:
   264    264             if (typ == DbType.SByte) return affinity;
   265    265             if (typ == DbType.String) return affinity;
   266    266             if (typ == DbType.SByte) return affinity;
   267    267             if (typ == DbType.Guid) return affinity;
   268    268             if (typ == DbType.DateTime) return affinity;
          269  +          if (typ == DbType.Decimal) return affinity;
   269    270             break;
   270    271           case TypeAffinity.Blob:
   271    272             if (typ == DbType.Guid) return affinity;
   272    273             if (typ == DbType.String) return affinity;
   273    274             if (typ == DbType.Binary) return affinity;
   274    275             break;
   275    276         }
................................................................................
   397    398       /// <returns>decimal</returns>
   398    399       public override decimal GetDecimal(int i)
   399    400       {
   400    401         if (i >= VisibleFieldCount && _keyInfo != null)
   401    402           return _keyInfo.GetDecimal(i - VisibleFieldCount);
   402    403   
   403    404         VerifyType(i, DbType.Decimal);
   404         -      return Convert.ToDecimal(_activeStatement._sql.GetDouble(_activeStatement, i));
          405  +      return Convert.ToDecimal(_activeStatement._sql.GetText(_activeStatement, i));
   405    406       }
   406    407   
   407    408       /// <summary>
   408    409       /// Returns the column as a double
   409    410       /// </summary>
   410    411       /// <param name="i">The index of the column to retrieve</param>
   411    412       /// <returns>double</returns>

Changes to System.Data.SQLite/SQLiteStatement.cs.

   192    192           case DbType.SByte:
   193    193           case DbType.Byte:
   194    194             _sql.Bind_Int32(this, index, Convert.ToInt32(obj, CultureInfo.CurrentCulture));
   195    195             break;
   196    196           case DbType.Single:
   197    197           case DbType.Double:
   198    198           case DbType.Currency:
   199         -        case DbType.Decimal:
          199  +        //case DbType.Decimal: // Dont store decimal as double ... loses precision
   200    200             _sql.Bind_Double(this, index, Convert.ToDouble(obj, CultureInfo.CurrentCulture));
   201    201             break;
   202    202           case DbType.Binary:
   203    203             _sql.Bind_Blob(this, index, (byte[])obj);
   204    204             break;
   205    205           case DbType.Guid:
   206    206             if (_command.Connection._binaryGuid == true)

Changes to System.Data.SQLite/UnsafeNativeMethods.cs.

   328    328   
   329    329       #endregion
   330    330   
   331    331       // Standard API calls global across versions.  There are a few instances of interop calls
   332    332       // scattered in here, but they are only active when PLATFORM_COMPACTFRAMEWORK is declared.
   333    333       #region standard sqlite api calls
   334    334   
   335         -#if !PLATFORM_COMPACTFRAMEWORK
   336         -    [DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
   337         -#else
   338         -    [DllImport(SQLITE_DLL)]
   339         -#endif
   340         -    internal static extern void sqlite3_sleep(uint dwMilliseconds);
   341         -
   342    335   #if !PLATFORM_COMPACTFRAMEWORK
   343    336       [DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
   344    337   #else
   345    338       [DllImport(SQLITE_DLL)]
   346    339   #endif
   347    340       internal static extern IntPtr sqlite3_libversion();
   348    341   

Added bin/ManagedOnly/System.Data.SQLite.XML.

            1  +<?xml version="1.0"?>
            2  +<doc>
            3  +    <assembly>
            4  +        <name>System.Data.SQLite</name>
            5  +    </assembly>
            6  +    <members>
            7  +        <member name="F:System.Data.SQLite.SQLiteConnectionPool._connections">
            8  +            <summary>
            9  +            The connection pool object
           10  +            </summary>
           11  +        </member>
           12  +        <member name="F:System.Data.SQLite.SQLiteConnectionPool._poolVersion">
           13  +            <summary>
           14  +            The default version number new pools will get
           15  +            </summary>
           16  +        </member>
           17  +        <member name="M:System.Data.SQLite.SQLiteConnectionPool.Remove(System.String,System.Int32,System.Int32@)">
           18  +            <summary>
           19  +            Attempt to pull a pooled connection out of the queue for active duty
           20  +            </summary>
           21  +            <param name="fileName">The filename for a desired connection</param>
           22  +            <param name="maxPoolSize">The maximum size the connection pool for the filename can be</param>
           23  +            <param name="version">The pool version the returned connection will belong to</param>
           24  +            <returns>Returns NULL if no connections were available.  Even if none are, the poolversion will still be a valid pool version</returns>
           25  +        </member>
           26  +        <member name="M:System.Data.SQLite.SQLiteConnectionPool.ClearAllPools">
           27  +            <summary>
           28  +            Clears out all pooled connections and rev's up the default pool version to force all old active objects
           29  +            not in the pool to get discarded rather than returned to their pools.
           30  +            </summary>
           31  +        </member>
           32  +        <member name="M:System.Data.SQLite.SQLiteConnectionPool.ClearPool(System.String)">
           33  +            <summary>
           34  +            Clear a given pool for a given filename.  Discards anything in the pool for the given file, and revs the pool
           35  +            version so current active objects on the old version of the pool will get discarded rather than be returned to the pool.
           36  +            </summary>
           37  +            <param name="fileName">The filename of the pool to clear</param>
           38  +        </member>
           39  +        <member name="M:System.Data.SQLite.SQLiteConnectionPool.Add(System.String,System.Data.SQLite.SQLiteConnectionHandle,System.Int32)">
           40  +            <summary>
           41  +            Return a connection to the pool for someone else to use.
           42  +            </summary>
           43  +            <param name="fileName">The filename of the pool to use</param>
           44  +            <param name="hdl">The connection handle to pool</param>
           45  +            <param name="version">The pool version the handle was created under</param>
           46  +            <remarks>
           47  +            If the version numbers don't match between the connection and the pool, then the handle is discarded.
           48  +            </remarks>
           49  +        </member>
           50  +        <member name="T:System.Data.SQLite.SQLiteConnectionPool.Pool">
           51  +            <summary>
           52  +            Keeps track of connections made on a specified file.  The PoolVersion dictates whether old objects get
           53  +            returned to the pool or discarded when no longer in use.
           54  +            </summary>
           55  +        </member>
           56  +        <member name="T:System.Data.SQLite.SQLiteConnection">
           57  +            <summary>
           58  +            SQLite implentation of DbConnection.
           59  +            </summary>
           60  +            <remarks>
           61  +            The <see cref="P:System.Data.SQLite.SQLiteConnection.ConnectionString">ConnectionString</see> property of the SQLiteConnection class can contain the following parameter(s), delimited with a semi-colon:
           62  +            <list type="table">
           63  +            <listheader>
           64  +            <term>Parameter</term>
           65  +            <term>Values</term>
           66  +            <term>Required</term>
           67  +            <term>Default</term>
           68  +            </listheader>
           69  +            <item>
           70  +            <description>Data Source</description>
           71  +            <description>{filename}</description>
           72  +            <description>Y</description>
           73  +            <description></description>
           74  +            </item>
           75  +            <item>
           76  +            <description>Version</description>
           77  +            <description>3</description>
           78  +            <description>N</description>
           79  +            <description>3</description>
           80  +            </item>
           81  +            <item>
           82  +            <description>UseUTF16Encoding</description>
           83  +            <description><b>True</b><br/><b>False</b></description>
           84  +            <description>N</description>
           85  +            <description>False</description>
           86  +            </item>
           87  +            <item>
           88  +            <description>DateTimeFormat</description>
           89  +            <description><b>Ticks</b> - Use DateTime.Ticks<br/><b>ISO8601</b> - Use ISO8601 DateTime format</description>
           90  +            <description>N</description>
           91  +            <description>ISO8601</description>
           92  +            </item>
           93  +            <item>
           94  +            <description>BinaryGUID</description>
           95  +            <description><b>True</b> - Store GUID columns in binary form<br/><b>False</b> - Store GUID columns as text</description>
           96  +            <description>N</description>
           97  +            <description>True</description>
           98  +            </item>
           99  +            <item>
          100  +            <description>Cache Size</description>
          101  +            <description>{size in bytes}</description>
          102  +            <description>N</description>
          103  +            <description>2000</description>
          104  +            </item>
          105  +            <item>
          106  +            <description>Synchronous</description>
          107  +            <description><b>Normal</b> - Normal file flushing behavior<br/><b>Full</b> - Full flushing after all writes<br/><b>Off</b> - Underlying OS flushes I/O's</description>
          108  +            <description>N</description>
          109  +            <description>Normal</description>
          110  +            </item>
          111  +            <item>
          112  +            <description>Page Size</description>
          113  +            <description>{size in bytes}</description>
          114  +            <description>N</description>
          115  +            <description>1024</description>
          116  +            </item>
          117  +            <item>
          118  +            <description>Password</description>
          119  +            <description>{password}</description>
          120  +            <description>N</description>
          121  +            <description></description>
          122  +            </item>
          123  +            <item>
          124  +            <description>Enlist</description>
          125  +            <description><b>Y</b> - Automatically enlist in distributed transactions<br/><b>N</b> - No automatic enlistment</description>
          126  +            <description>N</description>
          127  +            <description>Y</description>
          128  +            </item>
          129  +            <item>
          130  +            <description>Pooling</description>
          131  +            <description><b>True</b> - Use connection pooling<br/><b>False</b> - Do not use connection pooling</description>
          132  +            <description>N</description>
          133  +            <description>False</description>
          134  +            </item>
          135  +            <item>
          136  +            <description>FailIfMissing</description>
          137  +            <description><b>True</b> - Don't create the database if it does not exist, throw an error instead<br/><b>False</b> - Automatically create the database if it does not exist</description>
          138  +            <description>N</description>
          139  +            <description>False</description>
          140  +            </item>
          141  +            <item>
          142  +            <description>Max Page Count</description>
          143  +            <description>{size in pages} - Limits the maximum number of pages (limits the size) of the database</description>
          144  +            <description>N</description>
          145  +            <description>0</description>
          146  +            </item>
          147  +            <item>
          148  +            <description>Legacy Format</description>
          149  +            <description><b>True</b> - Use the more compatible legacy 3.x database format<br/><b>False</b> - Use the newer 3.3x database format which compresses numbers more effectively</description>
          150  +            <description>N</description>
          151  +            <description>False</description>
          152  +            </item>
          153  +            <item>
          154  +            <description>Default Timeout</description>
          155  +            <description>{time in seconds}<br/>The default command timeout</description>
          156  +            <description>N</description>
          157  +            <description>30</description>
          158  +            </item>
          159  +            <item>
          160  +            <description>Journal Mode</description>
          161  +            <description><b>Delete</b> - Delete the journal file after a commit<br/><b>Persist</b> - Zero out and leave the journal file on disk after a commit<br/><b>Off</b> - Disable the rollback journal entirely</description>
          162  +            <description>N</description>
          163  +            <description>Delete</description>
          164  +            </item>
          165  +            <item>
          166  +            <description>Read Only</description>
          167  +            <description><b>True</b> - Open the database for read only access<br/><b>False</b> - Open the database for normal read/write access</description>
          168  +            <description>N</description>
          169  +            <description>False</description>
          170  +            </item>
          171  +            <item>
          172  +            <description>Max Pool Size</description>
          173  +            <description>The maximum number of connections for the given connection string that can be in the connection pool</description>
          174  +            <description>N</description>
          175  +            <description>100</description>
          176  +            </item>
          177  +            <item>
          178  +            <description>Default IsolationLevel</description>
          179  +            <description>The default transaciton isolation level</description>
          180  +            <description>N</description>
          181  +            <description>Serializable</description>
          182  +            </item>
          183  +            </list>
          184  +            </remarks>
          185  +        </member>
          186  +        <member name="F:System.Data.SQLite.SQLiteConnection._connectionState">
          187  +            <summary>
          188  +            State of the current connection
          189  +            </summary>
          190  +        </member>
          191  +        <member name="F:System.Data.SQLite.SQLiteConnection._connectionString">
          192  +            <summary>
          193  +            The connection string
          194  +            </summary>
          195  +        </member>
          196  +        <member name="F:System.Data.SQLite.SQLiteConnection._transactionLevel">
          197  +            <summary>
          198  +            Nesting level of the transactions open on the connection
          199  +            </summary>
          200  +        </member>
          201  +        <member name="F:System.Data.SQLite.SQLiteConnection._defaultIsolation">
          202  +            <summary>
          203  +            The default isolation level for new transactions
          204  +            </summary>
          205  +        </member>
          206  +        <member name="F:System.Data.SQLite.SQLiteConnection._enlistment">
          207  +            <summary>
          208  +            Whether or not the connection is enlisted in a distrubuted transaction
          209  +            </summary>
          210  +        </member>
          211  +        <member name="F:System.Data.SQLite.SQLiteConnection._sql">
          212  +            <summary>
          213  +            The base SQLite object to interop with
          214  +            </summary>
          215  +        </member>
          216  +        <member name="F:System.Data.SQLite.SQLiteConnection._dataSource">
          217  +            <summary>
          218  +            The database filename minus path and extension
          219  +            </summary>
          220  +        </member>
          221  +        <member name="F:System.Data.SQLite.SQLiteConnection._password">
          222  +            <summary>
          223  +            Temporary password storage, emptied after the database has been opened
          224  +            </summary>
          225  +        </member>
          226  +        <member name="F:System.Data.SQLite.SQLiteConnection._defaultTimeout">
          227  +            <summary>
          228  +            Default command timeout
          229  +            </summary>
          230  +        </member>
          231  +        <member name="M:System.Data.SQLite.SQLiteConnection.#ctor">
          232  +            <overloads>
          233  +             Constructs a new SQLiteConnection object
          234  +             </overloads>
          235  +             <summary>
          236  +             Default constructor
          237  +             </summary>
          238  +        </member>
          239  +        <member name="M:System.Data.SQLite.SQLiteConnection.#ctor(System.String)">
          240  +            <summary>
          241  +            Initializes the connection with the specified connection string
          242  +            </summary>
          243  +            <param name="connectionString">The connection string to use on the connection</param>
          244  +        </member>
          245  +        <member name="M:System.Data.SQLite.SQLiteConnection.#ctor(System.Data.SQLite.SQLiteConnection)">
          246  +            <summary>
          247  +            Clones the settings and connection string from an existing connection.  If the existing connection is already open, this
          248  +            function will open its own connection, enumerate any attached databases of the original connection, and automatically
          249  +            attach to them.
          250  +            </summary>
          251  +            <param name="connection"></param>
          252  +        </member>
          253  +        <member name="M:System.Data.SQLite.SQLiteConnection.Clone">
          254  +            <summary>
          255  +            Creates a clone of the connection.  All attached databases and user-defined functions are cloned.  If the existing connection is open, the cloned connection 
          256  +            will also be opened.
          257  +            </summary>
          258  +            <returns></returns>
          259  +        </member>
          260  +        <member name="M:System.Data.SQLite.SQLiteConnection.Dispose(System.Boolean)">
          261  +            <summary>
          262  +            Disposes of the SQLiteConnection, closing it if it is active.
          263  +            </summary>
          264  +            <param name="disposing">True if the connection is being explicitly closed.</param>
          265  +        </member>
          266  +        <member name="M:System.Data.SQLite.SQLiteConnection.CreateFile(System.String)">
          267  +            <summary>
          268  +            Creates a database file.  This just creates a zero-byte file which SQLite
          269  +            will turn into a database when the file is opened properly.
          270  +            </summary>
          271  +            <param name="databaseFileName">The file to create</param>
          272  +        </member>
          273  +        <member name="M:System.Data.SQLite.SQLiteConnection.OnStateChange(System.Data.ConnectionState)">
          274  +            <summary>
          275  +            Raises the state change event when the state of the connection changes
          276  +            </summary>
          277  +            <param name="newState">The new state.  If it is different from the previous state, an event is raised.</param>
          278  +        </member>
          279  +        <member name="M:System.Data.SQLite.SQLiteConnection.BeginTransaction(System.Data.IsolationLevel,System.Boolean)">
          280  +            <summary>
          281  +            OBSOLETE.  Creates a new SQLiteTransaction if one isn't already active on the connection.
          282  +            </summary>
          283  +            <param name="isolationLevel">This parameter is ignored.</param>
          284  +            <param name="deferredLock">When TRUE, SQLite defers obtaining a write lock until a write operation is requested.
          285  +            When FALSE, a writelock is obtained immediately.  The default is TRUE, but in a multi-threaded multi-writer 
          286  +            environment, one may instead choose to lock the database immediately to avoid any possible writer deadlock.</param>
          287  +            <returns>Returns a SQLiteTransaction object.</returns>
          288  +        </member>
          289  +        <member name="M:System.Data.SQLite.SQLiteConnection.BeginTransaction(System.Boolean)">
          290  +            <summary>
          291  +            OBSOLETE.  Creates a new SQLiteTransaction if one isn't already active on the connection.
          292  +            </summary>
          293  +            <param name="deferredLock">When TRUE, SQLite defers obtaining a write lock until a write operation is requested.
          294  +            When FALSE, a writelock is obtained immediately.  The default is false, but in a multi-threaded multi-writer 
          295  +            environment, one may instead choose to lock the database immediately to avoid any possible writer deadlock.</param>
          296  +            <returns>Returns a SQLiteTransaction object.</returns>
          297  +        </member>
          298  +        <member name="M:System.Data.SQLite.SQLiteConnection.BeginTransaction(System.Data.IsolationLevel)">
          299  +            <summary>
          300  +            Creates a new SQLiteTransaction if one isn't already active on the connection.
          301  +            </summary>
          302  +            <param name="isolationLevel">Supported isolation levels are Serializable, ReadCommitted and Unspecified.</param>
          303  +            <remarks>
          304  +            Unspecified will use the default isolation level specified in the connection string.  If no isolation level is specified in the 
          305  +            connection string, Serializable is used.
          306  +            Serializable transactions are the default.  In this mode, the engine gets an immediate lock on the database, and no other threads
          307  +            may begin a transaction.  Other threads may read from the database, but not write.
          308  +            With a ReadCommitted isolation level, locks are deferred and elevated as needed.  It is possible for multiple threads to start
          309  +            a transaction in ReadCommitted mode, but if a thread attempts to commit a transaction while another thread
          310  +            has a ReadCommitted lock, it may timeout or cause a deadlock on both threads until both threads' CommandTimeout's are reached.
          311  +            </remarks>
          312  +            <returns>Returns a SQLiteTransaction object.</returns>
          313  +        </member>
          314  +        <member name="M:System.Data.SQLite.SQLiteConnection.BeginTransaction">
          315  +            <summary>
          316  +            Creates a new SQLiteTransaction if one isn't already active on the connection.
          317  +            </summary>
          318  +            <returns>Returns a SQLiteTransaction object.</returns>
          319  +        </member>
          320  +        <member name="M:System.Data.SQLite.SQLiteConnection.BeginDbTransaction(System.Data.IsolationLevel)">
          321  +            <summary>
          322  +            Forwards to the local BeginTransaction() function
          323  +            </summary>
          324  +            <param name="isolationLevel">Supported isolation levels are Unspecified, Serializable, and ReadCommitted</param>
          325  +            <returns></returns>
          326  +        </member>
          327  +        <member name="M:System.Data.SQLite.SQLiteConnection.ChangeDatabase(System.String)">
          328  +            <summary>
          329  +            Not implemented
          330  +            </summary>
          331  +            <param name="databaseName"></param>
          332  +        </member>
          333  +        <member name="M:System.Data.SQLite.SQLiteConnection.Close">
          334  +            <summary>
          335  +            When the database connection is closed, all commands linked to this connection are automatically reset.
          336  +            </summary>
          337  +        </member>
          338  +        <member name="M:System.Data.SQLite.SQLiteConnection.ClearPool(System.Data.SQLite.SQLiteConnection)">
          339  +            <summary>
          340  +            Clears the connection pool associated with the connection.  Any other active connections using the same database file
          341  +            will be discarded instead of returned to the pool when they are closed.
          342  +            </summary>
          343  +            <param name="connection"></param>
          344  +        </member>
          345  +        <member name="M:System.Data.SQLite.SQLiteConnection.ClearAllPools">
          346  +            <summary>
          347  +            Clears all connection pools.  Any active connections will be discarded instead of sent to the pool when they are closed.
          348  +            </summary>
          349  +        </member>
          350  +        <member name="M:System.Data.SQLite.SQLiteConnection.CreateCommand">
          351  +            <summary>
          352  +            Create a new SQLiteCommand and associate it with this connection.
          353  +            </summary>
          354  +            <returns>Returns an instantiated SQLiteCommand object already assigned to this connection.</returns>
          355  +        </member>
          356  +        <member name="M:System.Data.SQLite.SQLiteConnection.CreateDbCommand">
          357  +            <summary>
          358  +            Forwards to the local CreateCommand() function
          359  +            </summary>
          360  +            <returns></returns>
          361  +        </member>
          362  +        <member name="M:System.Data.SQLite.SQLiteConnection.ParseConnectionString(System.String)">
          363  +            <summary>
          364  +            Parses the connection string into component parts
          365  +            </summary>
          366  +            <param name="connectionString">The connection string to parse</param>
          367  +            <returns>An array of key-value pairs representing each parameter of the connection string</returns>
          368  +        </member>
          369  +        <member name="M:System.Data.SQLite.SQLiteConnection.EnlistTransaction(System.Transactions.Transaction)">
          370  +            <summary>
          371  +            Manual distributed transaction enlistment support
          372  +            </summary>
          373  +            <param name="transaction">The distributed transaction to enlist in</param>
          374  +        </member>
          375  +        <member name="M:System.Data.SQLite.SQLiteConnection.FindKey(System.Collections.Generic.SortedList{System.String,System.String},System.String,System.String)">
          376  +            <summary>
          377  +            Looks for a key in the array of key/values of the parameter string.  If not found, return the specified default value
          378  +            </summary>
          379  +            <param name="items">The list to look in</param>
          380  +            <param name="key">The key to find</param>
          381  +            <param name="defValue">The default value to return if the key is not found</param>
          382  +            <returns>The value corresponding to the specified key, or the default value if not found.</returns>
          383  +        </member>
          384  +        <member name="M:System.Data.SQLite.SQLiteConnection.Open">
          385  +            <summary>
          386  +            Opens the connection using the parameters found in the <see cref="P:System.Data.SQLite.SQLiteConnection.ConnectionString">ConnectionString</see>
          387  +            </summary>
          388  +        </member>
          389  +        <member name="M:System.Data.SQLite.SQLiteConnection.ChangePassword(System.String)">
          390  +            <summary>
          391  +            Change the password (or assign a password) to an open database.
          392  +            </summary>
          393  +            <remarks>
          394  +            No readers or writers may be active for this process.  The database must already be open
          395  +            and if it already was password protected, the existing password must already have been supplied.
          396  +            </remarks>
          397  +            <param name="newPassword">The new password to assign to the database</param>
          398  +        </member>
          399  +        <member name="M:System.Data.SQLite.SQLiteConnection.ChangePassword(System.Byte[])">
          400  +            <summary>
          401  +            Change the password (or assign a password) to an open database.
          402  +            </summary>
          403  +            <remarks>
          404  +            No readers or writers may be active for this process.  The database must already be open
          405  +            and if it already was password protected, the existing password must already have been supplied.
          406  +            </remarks>
          407  +            <param name="newPassword">The new password to assign to the database</param>
          408  +        </member>
          409  +        <member name="M:System.Data.SQLite.SQLiteConnection.SetPassword(System.String)">
          410  +            <summary>
          411  +            Sets the password for a password-protected database.  A password-protected database is
          412  +            unusable for any operation until the password has been set.
          413  +            </summary>
          414  +            <param name="databasePassword">The password for the database</param>
          415  +        </member>
          416  +        <member name="M:System.Data.SQLite.SQLiteConnection.SetPassword(System.Byte[])">
          417  +            <summary>
          418  +            Sets the password for a password-protected database.  A password-protected database is
          419  +            unusable for any operation until the password has been set.
          420  +            </summary>
          421  +            <param name="databasePassword">The password for the database</param>
          422  +        </member>
          423  +        <member name="M:System.Data.SQLite.SQLiteConnection.ExpandFileName(System.String)">
          424  +            <summary>
          425  +            Expand the filename of the data source, resolving the |DataDirectory| macro as appropriate.
          426  +            </summary>
          427  +            <param name="sourceFile">The database filename to expand</param>
          428  +            <returns>The expanded path and filename of the filename</returns>
          429  +        </member>
          430  +        <member name="M:System.Data.SQLite.SQLiteConnection.GetSchema">
          431  +            <overloads>
          432  +             The following commands are used to extract schema information out of the database.  Valid schema types are:
          433  +             <list type="bullet">
          434  +             <item>
          435  +             <description>MetaDataCollections</description>
          436  +             </item>
          437  +             <item>
          438  +             <description>DataSourceInformation</description>
          439  +             </item>
          440  +             <item>
          441  +             <description>Catalogs</description>
          442  +             </item>
          443  +             <item>
          444  +             <description>Columns</description>
          445  +             </item>
          446  +             <item>
          447  +             <description>ForeignKeys</description>
          448  +             </item>
          449  +             <item>
          450  +             <description>Indexes</description>
          451  +             </item>
          452  +             <item>
          453  +             <description>IndexColumns</description>
          454  +             </item>
          455  +             <item>
          456  +             <description>Tables</description>
          457  +             </item>
          458  +             <item>
          459  +             <description>Views</description>
          460  +             </item>
          461  +             <item>
          462  +             <description>ViewColumns</description>
          463  +             </item>
          464  +             </list>
          465  +             </overloads>
          466  +             <summary>
          467  +             Returns the MetaDataCollections schema
          468  +             </summary>
          469  +             <returns>A DataTable of the MetaDataCollections schema</returns>
          470  +        </member>
          471  +        <member name="M:System.Data.SQLite.SQLiteConnection.GetSchema(System.String)">
          472  +            <summary>
          473  +            Returns schema information of the specified collection
          474  +            </summary>
          475  +            <param name="collectionName">The schema collection to retrieve</param>
          476  +            <returns>A DataTable of the specified collection</returns>
          477  +        </member>
          478  +        <member name="M:System.Data.SQLite.SQLiteConnection.GetSchema(System.String,System.String[])">
          479  +            <summary>
          480  +            Retrieves schema information using the specified constraint(s) for the specified collection
          481  +            </summary>
          482  +            <param name="collectionName">The collection to retrieve</param>
          483  +            <param name="restrictionValues">The restrictions to impose</param>
          484  +            <returns>A DataTable of the specified collection</returns>
          485  +        </member>
          486  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_MetaDataCollections">
          487  +            <summary>
          488  +            Builds a MetaDataCollections schema datatable
          489  +            </summary>
          490  +            <returns>DataTable</returns>
          491  +        </member>
          492  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_DataSourceInformation">
          493  +            <summary>
          494  +            Builds a DataSourceInformation datatable
          495  +            </summary>
          496  +            <returns>DataTable</returns>
          497  +        </member>
          498  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_Columns(System.String,System.String,System.String)">
          499  +            <summary>
          500  +            Build a Columns schema
          501  +            </summary>
          502  +            <param name="strCatalog">The catalog (attached database) to query, can be null</param>
          503  +            <param name="strTable">The table to retrieve schema information for, must not be null</param>
          504  +            <param name="strColumn">The column to retrieve schema information for, can be null</param>
          505  +            <returns>DataTable</returns>
          506  +        </member>
          507  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_Indexes(System.String,System.String,System.String)">
          508  +            <summary>
          509  +            Returns index information for the given database and catalog
          510  +            </summary>
          511  +            <param name="strCatalog">The catalog (attached database) to query, can be null</param>
          512  +            <param name="strIndex">The name of the index to retrieve information for, can be null</param>
          513  +            <param name="strTable">The table to retrieve index information for, can be null</param>
          514  +            <returns>DataTable</returns>
          515  +        </member>
          516  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_Tables(System.String,System.String,System.String)">
          517  +            <summary>
          518  +            Retrieves table schema information for the database and catalog
          519  +            </summary>
          520  +            <param name="strCatalog">The catalog (attached database) to retrieve tables on</param>
          521  +            <param name="strTable">The table to retrieve, can be null</param>
          522  +            <param name="strType">The table type, can be null</param>
          523  +            <returns>DataTable</returns>
          524  +        </member>
          525  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_Views(System.String,System.String)">
          526  +            <summary>
          527  +            Retrieves view schema information for the database
          528  +            </summary>
          529  +            <param name="strCatalog">The catalog (attached database) to retrieve views on</param>
          530  +            <param name="strView">The view name, can be null</param>
          531  +            <returns>DataTable</returns>
          532  +        </member>
          533  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_Catalogs(System.String)">
          534  +            <summary>
          535  +            Retrieves catalog (attached databases) schema information for the database
          536  +            </summary>
          537  +            <param name="strCatalog">The catalog to retrieve, can be null</param>
          538  +            <returns>DataTable</returns>
          539  +        </member>
          540  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_IndexColumns(System.String,System.String,System.String,System.String)">
          541  +            <summary>
          542  +            Returns the base column information for indexes in a database
          543  +            </summary>
          544  +            <param name="strCatalog">The catalog to retrieve indexes for (can be null)</param>
          545  +            <param name="strTable">The table to restrict index information by (can be null)</param>
          546  +            <param name="strIndex">The index to restrict index information by (can be null)</param>
          547  +            <param name="strColumn">The source column to restrict index information by (can be null)</param>
          548  +            <returns>A DataTable containing the results</returns>
          549  +        </member>
          550  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_ViewColumns(System.String,System.String,System.String)">
          551  +            <summary>
          552  +            Returns detailed column information for a specified view
          553  +            </summary>
          554  +            <param name="strCatalog">The catalog to retrieve columns for (can be null)</param>
          555  +            <param name="strView">The view to restrict column information by (can be null)</param>
          556  +            <param name="strColumn">The source column to restrict column information by (can be null)</param>
          557  +            <returns>A DataTable containing the results</returns>
          558  +        </member>
          559  +        <member name="M:System.Data.SQLite.SQLiteConnection.Schema_ForeignKeys(System.String,System.String,System.String)">
          560  +            <summary>
          561  +            Retrieves foreign key information from the specified set of filters
          562  +            </summary>
          563  +            <param name="strCatalog">An optional catalog to restrict results on</param>
          564  +            <param name="strTable">An optional table to restrict results on</param>
          565  +            <param name="strKeyName">An optional foreign key name to restrict results on</param>
          566  +            <returns>A DataTable with the results of the query</returns>
          567  +        </member>
          568  +        <member name="P:System.Data.SQLite.SQLiteConnection.DbProviderFactory">
          569  +            <summary>
          570  +            Returns a SQLiteProviderFactory object.
          571  +            </summary>
          572  +        </member>
          573  +        <member name="E:System.Data.SQLite.SQLiteConnection.StateChange">
          574  +            <summary>
          575  +            This event is raised whenever the database is opened or closed.
          576  +            </summary>
          577  +        </member>
          578  +        <member name="P:System.Data.SQLite.SQLiteConnection.ConnectionString">
          579  +            <summary>
          580  +            The connection string containing the parameters for the connection
          581  +            </summary>
          582  +            <remarks>
          583  +            <list type="table">
          584  +            <listheader>
          585  +            <term>Parameter</term>
          586  +            <term>Values</term>
          587  +            <term>Required</term>
          588  +            <term>Default</term>
          589  +            </listheader>
          590  +            <item>
          591  +            <description>Data Source</description>
          592  +            <description>{filename}</description>
          593  +            <description>Y</description>
          594  +            <description></description>
          595  +            </item>
          596  +            <item>
          597  +            <description>Version</description>
          598  +            <description>3</description>
          599  +            <description>N</description>
          600  +            <description>3</description>
          601  +            </item>
          602  +            <item>
          603  +            <description>UseUTF16Encoding</description>
          604  +            <description><b>True</b><br/><b>False</b></description>
          605  +            <description>N</description>
          606  +            <description>False</description>
          607  +            </item>
          608  +            <item>
          609  +            <description>DateTimeFormat</description>
          610  +            <description><b>Ticks</b> - Use DateTime.Ticks<br/><b>ISO8601</b> - Use ISO8601 DateTime format<br/><b>JulianDay</b> - Use JulianDay format</description>
          611  +            <description>N</description>
          612  +            <description>ISO8601</description>
          613  +            </item>
          614  +            <item>
          615  +            <description>BinaryGUID</description>
          616  +            <description><b>Yes/On/1</b> - Store GUID columns in binary form<br/><b>No/Off/0</b> - Store GUID columns as text</description>
          617  +            <description>N</description>
          618  +            <description>On</description>
          619  +            </item>
          620  +            <item>
          621  +            <description>Cache Size</description>
          622  +            <description>{size in bytes}</description>
          623  +            <description>N</description>
          624  +            <description>2000</description>
          625  +            </item>
          626  +            <item>
          627  +            <description>Synchronous</description>
          628  +            <description><b>Normal</b> - Normal file flushing behavior<br/><b>Full</b> - Full flushing after all writes<br/><b>Off</b> - Underlying OS flushes I/O's</description>
          629  +            <description>N</description>
          630  +            <description>Normal</description>
          631  +            </item>
          632  +            <item>
          633  +            <description>Page Size</description>
          634  +            <description>{size in bytes}</description>
          635  +            <description>N</description>
          636  +            <description>1024</description>
          637  +            </item>
          638  +            <item>
          639  +            <description>Password</description>
          640  +            <description>{password}</description>
          641  +            <description>N</description>
          642  +            <description></description>
          643  +            </item>
          644  +            <item>
          645  +            <description>Enlist</description>
          646  +            <description><B>Y</B> - Automatically enlist in distributed transactions<br/><b>N</b> - No automatic enlistment</description>
          647  +            <description>N</description>
          648  +            <description>Y</description>
          649  +            </item>
          650  +            <item>
          651  +            <description>Pooling</description>
          652  +            <description><b>True</b> - Use connection pooling<br/><b>False</b> - Do not use connection pooling</description>
          653  +            <description>N</description>
          654  +            <description>False</description>
          655  +            </item>
          656  +            <item>
          657  +            <description>FailIfMissing</description>
          658  +            <description><b>True</b> - Don't create the database if it does not exist, throw an error instead<br/><b>False</b> - Automatically create the database if it does not exist</description>
          659  +            <description>N</description>
          660  +            <description>False</description>
          661  +            </item>
          662  +            <item>
          663  +            <description>Max Page Count</description>
          664  +            <description>{size in pages} - Limits the maximum number of pages (limits the size) of the database</description>
          665  +            <description>N</description>
          666  +            <description>0</description>
          667  +            </item>
          668  +            <item>
          669  +            <description>Legacy Format</description>
          670  +            <description><b>True</b> - Use the more compatible legacy 3.x database format<br/><b>False</b> - Use the newer 3.3x database format which compresses numbers more effectively</description>
          671  +            <description>N</description>
          672  +            <description>False</description>
          673  +            </item>
          674  +            <item>
          675  +            <description>Default Timeout</description>
          676  +            <description>{time in seconds}<br/>The default command timeout</description>
          677  +            <description>N</description>
          678  +            <description>30</description>
          679  +            </item>
          680  +            <item>
          681  +            <description>Journal Mode</description>
          682  +            <description><b>Delete</b> - Delete the journal file after a commit<br/><b>Persist</b> - Zero out and leave the journal file on disk after a commit<br/><b>Off</b> - Disable the rollback journal entirely</description>
          683  +            <description>N</description>
          684  +            <description>Delete</description>
          685  +            </item>
          686  +            <item>
          687  +            <description>Read Only</description>
          688  +            <description><b>True</b> - Open the database for read only access<br/><b>False</b> - Open the database for normal read/write access</description>
          689  +            <description>N</description>
          690  +            <description>False</description>
          691  +            </item>
          692  +            <item>
          693  +            <description>Max Pool Size</description>
          694  +            <description>The maximum number of connections for the given connection string that can be in the connection pool</description>
          695  +            <description>N</description>
          696  +            <description>100</description>
          697  +            </item>
          698  +            <item>
          699  +            <description>Default IsolationLevel</description>
          700  +            <description>The default transaciton isolation level</description>
          701  +            <description>N</description>
          702  +            <description>Serializable</description>
          703  +            </item>
          704  +            </list>
          705  +            </remarks>
          706  +        </member>
          707  +        <member name="P:System.Data.SQLite.SQLiteConnection.DataSource">
          708  +            <summary>
          709  +            Returns the filename without extension or path
          710  +            </summary>
          711  +        </member>
          712  +        <member name="P:System.Data.SQLite.SQLiteConnection.Database">
          713  +            <summary>
          714  +            Returns an empty string
          715  +            </summary>
          716  +        </member>
          717  +        <member name="P:System.Data.SQLite.SQLiteConnection.DefaultTimeout">
          718  +            <summary>
          719  +            Gets/sets the default command timeout for newly-created commands.  This is especially useful for 
          720  +            commands used internally such as inside a SQLiteTransaction, where setting the timeout is not possible.
          721  +            This can also be set in the ConnectionString with "Default Timeout"
          722  +            </summary>
          723  +        </member>
          724  +        <member name="P:System.Data.SQLite.SQLiteConnection.ServerVersion">
          725  +            <summary>
          726  +            Returns the version of the underlying SQLite database engine
          727  +            </summary>
          728  +        </member>
          729  +        <member name="P:System.Data.SQLite.SQLiteConnection.SQLiteVersion">
          730  +            <summary>
          731  +            Returns the version of the underlying SQLite database engine
          732  +            </summary>
          733  +        </member>
          734  +        <member name="P:System.Data.SQLite.SQLiteConnection.State">
          735  +            <summary>
          736  +            Returns the state of the connection.
          737  +            </summary>
          738  +        </member>
          739  +        <member name="E:System.Data.SQLite.SQLiteConnection.Update">
          740  +            <summary>
          741  +            This event is raised whenever SQLite makes an update/delete/insert into the database on
          742  +            this connection.  It only applies to the given connection.
          743  +            </summary>
          744  +        </member>
          745  +        <member name="E:System.Data.SQLite.SQLiteConnection.Commit">
          746  +            <summary>
          747  +            This event is raised whenever SQLite is committing a transaction.
          748  +            Return non-zero to trigger a rollback
          749  +            </summary>
          750  +        </member>
          751  +        <member name="E:System.Data.SQLite.SQLiteConnection.RollBack">
          752  +            <summary>
          753  +            This event is raised whenever SQLite is committing a transaction.
          754  +            Return non-zero to trigger a rollback
          755  +            </summary>
          756  +        </member>
          757  +        <member name="T:System.Data.SQLite.SQLiteDataAdapter">
          758  +            <summary>
          759  +            SQLite implementation of DbDataAdapter.
          760  +            </summary>
          761  +        </member>
          762  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.#ctor">
          763  +            <overloads>
          764  +            This class is just a shell around the DbDataAdapter.  Nothing from DbDataAdapter is overridden here, just a few constructors are defined.
          765  +            </overloads>
          766  +            <summary>
          767  +            Default constructor.
          768  +            </summary>
          769  +        </member>
          770  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.#ctor(System.Data.SQLite.SQLiteCommand)">
          771  +            <summary>
          772  +            Constructs a data adapter using the specified select command.
          773  +            </summary>
          774  +            <param name="cmd">The select command to associate with the adapter.</param>
          775  +        </member>
          776  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.#ctor(System.String,System.Data.SQLite.SQLiteConnection)">
          777  +            <summary>
          778  +            Constructs a data adapter with the supplied select command text and associated with the specified connection.
          779  +            </summary>
          780  +            <param name="commandText">The select command text to associate with the data adapter.</param>
          781  +            <param name="connection">The connection to associate with the select command.</param>
          782  +        </member>
          783  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.#ctor(System.String,System.String)">
          784  +            <summary>
          785  +            Constructs a data adapter with the specified select command text, and using the specified database connection string.
          786  +            </summary>
          787  +            <param name="commandText">The select command text to use to construct a select command.</param>
          788  +            <param name="connectionString">A connection string suitable for passing to a new SQLiteConnection, which is associated with the select command.</param>
          789  +        </member>
          790  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)">
          791  +            <summary>
          792  +            Raised by the underlying DbDataAdapter when a row is being updated
          793  +            </summary>
          794  +            <param name="value">The event's specifics</param>
          795  +        </member>
          796  +        <member name="M:System.Data.SQLite.SQLiteDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)">
          797  +            <summary>
          798  +            Raised by DbDataAdapter after a row is updated
          799  +            </summary>
          800  +            <param name="value">The event's specifics</param>
          801  +        </member>
          802  +        <member name="E:System.Data.SQLite.SQLiteDataAdapter.RowUpdating">
          803  +            <summary>
          804  +            Row updating event handler
          805  +            </summary>
          806  +        </member>
          807  +        <member name="E:System.Data.SQLite.SQLiteDataAdapter.RowUpdated">
          808  +            <summary>
          809  +            Row updated event handler
          810  +            </summary>
          811  +        </member>
          812  +        <member name="P:System.Data.SQLite.SQLiteDataAdapter.SelectCommand">
          813  +            <summary>
          814  +            Gets/sets the select command for this DataAdapter
          815  +            </summary>
          816  +        </member>
          817  +        <member name="P:System.Data.SQLite.SQLiteDataAdapter.InsertCommand">
          818  +            <summary>
          819  +            Gets/sets the insert command for this DataAdapter
          820  +            </summary>
          821  +        </member>
          822  +        <member name="P:System.Data.SQLite.SQLiteDataAdapter.UpdateCommand">
          823  +            <summary>
          824  +            Gets/sets the update command for this DataAdapter
          825  +            </summary>
          826  +        </member>
          827  +        <member name="P:System.Data.SQLite.SQLiteDataAdapter.DeleteCommand">
          828  +            <summary>
          829  +            Gets/sets the delete command for this DataAdapter
          830  +            </summary>
          831  +        </member>
          832  +        <member name="T:System.Data.SQLite.SQLiteConvert">
          833  +            <summary>
          834  +            This base class provides datatype conversion services for the SQLite provider.
          835  +            </summary>
          836  +        </member>
          837  +        <member name="F:System.Data.SQLite.SQLiteConvert._datetimeFormats">
          838  +            <summary>
          839  +            An array of ISO8601 datetime formats we support conversion from
          840  +            </summary>
          841  +        </member>
          842  +        <member name="F:System.Data.SQLite.SQLiteConvert._utf8">
          843  +            <summary>
          844  +            An UTF-8 Encoding instance, so we can convert strings to and from UTF-8
          845  +            </summary>
          846  +        </member>
          847  +        <member name="F:System.Data.SQLite.SQLiteConvert._datetimeFormat">
          848  +            <summary>
          849  +            The default DateTime format for this instance
          850  +            </summary>
          851  +        </member>
          852  +        <member name="M:System.Data.SQLite.SQLiteConvert.#ctor(System.Data.SQLite.SQLiteDateFormats)">
          853  +            <summary>
          854  +            Initializes the conversion class
          855  +            </summary>
          856  +            <param name="fmt">The default date/time format to use for this instance</param>
          857  +        </member>
          858  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToUTF8(System.String)">
          859  +            <summary>
          860  +            Converts a string to a UTF-8 encoded byte array sized to include a null-terminating character.
          861  +            </summary>
          862  +            <param name="sourceText">The string to convert to UTF-8</param>
          863  +            <returns>A byte array containing the converted string plus an extra 0 terminating byte at the end of the array.</returns>
          864  +        </member>
          865  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToUTF8(System.DateTime)">
          866  +            <summary>
          867  +            Convert a DateTime to a UTF-8 encoded, zero-terminated byte array.
          868  +            </summary>
          869  +            <remarks>
          870  +            This function is a convenience function, which first calls ToString() on the DateTime, and then calls ToUTF8() with the
          871  +            string result.
          872  +            </remarks>
          873  +            <param name="dateTimeValue">The DateTime to convert.</param>
          874  +            <returns>The UTF-8 encoded string, including a 0 terminating byte at the end of the array.</returns>
          875  +        </member>
          876  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToString(System.IntPtr,System.Int32)">
          877  +            <summary>
          878  +            Converts a UTF-8 encoded IntPtr of the specified length into a .NET string
          879  +            </summary>
          880  +            <param name="nativestring">The pointer to the memory where the UTF-8 string is encoded</param>
          881  +            <param name="nativestringlen">The number of bytes to decode</param>
          882  +            <returns>A string containing the translated character(s)</returns>
          883  +        </member>
          884  +        <member name="M:System.Data.SQLite.SQLiteConvert.UTF8ToString(System.IntPtr,System.Int32)">
          885  +            <summary>
          886  +            Converts a UTF-8 encoded IntPtr of the specified length into a .NET string
          887  +            </summary>
          888  +            <param name="nativestring">The pointer to the memory where the UTF-8 string is encoded</param>
          889  +            <param name="nativestringlen">The number of bytes to decode</param>
          890  +            <returns>A string containing the translated character(s)</returns>
          891  +        </member>
          892  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToDateTime(System.String)">
          893  +            <summary>
          894  +            Converts a string into a DateTime, using the current DateTimeFormat specified for the connection when it was opened.
          895  +            </summary>
          896  +            <remarks>
          897  +            Acceptable ISO8601 DateTime formats are:
          898  +              yyyy-MM-dd HH:mm:ss
          899  +              yyyyMMddHHmmss
          900  +              yyyyMMddTHHmmssfffffff
          901  +              yyyy-MM-dd
          902  +              yy-MM-dd
          903  +              yyyyMMdd
          904  +              HH:mm:ss
          905  +              THHmmss
          906  +            </remarks>
          907  +            <param name="dateText">The string containing either a Tick value, a JulianDay double, or an ISO8601-format string</param>
          908  +            <returns>A DateTime value</returns>
          909  +        </member>
          910  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToDateTime(System.Double)">
          911  +            <summary>
          912  +            Converts a julianday value into a DateTime
          913  +            </summary>
          914  +            <param name="julianDay">The value to convert</param>
          915  +            <returns>A .NET DateTime</returns>
          916  +        </member>
          917  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToJulianDay(System.DateTime)">
          918  +            <summary>
          919  +            Converts a DateTime struct to a JulianDay double
          920  +            </summary>
          921  +            <param name="value">The DateTime to convert</param>
          922  +            <returns>The JulianDay value the Datetime represents</returns>
          923  +        </member>
          924  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToString(System.DateTime)">
          925  +            <summary>
          926  +            Converts a DateTime to a string value, using the current DateTimeFormat specified for the connection when it was opened.
          927  +            </summary>
          928  +            <param name="dateValue">The DateTime value to convert</param>
          929  +            <returns>Either a string consisting of the tick count for DateTimeFormat.Ticks, a JulianDay double, or a date/time in ISO8601 format.</returns>
          930  +        </member>
          931  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToDateTime(System.IntPtr,System.Int32)">
          932  +            <summary>
          933  +            Internal function to convert a UTF-8 encoded IntPtr of the specified length to a DateTime.
          934  +            </summary>
          935  +            <remarks>
          936  +            This is a convenience function, which first calls ToString() on the IntPtr to convert it to a string, then calls
          937  +            ToDateTime() on the string to return a DateTime.
          938  +            </remarks>
          939  +            <param name="ptr">A pointer to the UTF-8 encoded string</param>
          940  +            <param name="len">The length in bytes of the string</param>
          941  +            <returns>The parsed DateTime value</returns>
          942  +        </member>
          943  +        <member name="M:System.Data.SQLite.SQLiteConvert.Split(System.String,System.Char)">
          944  +            <summary>
          945  +            Smart method of splitting a string.  Skips quoted elements, removes the quotes.
          946  +            </summary>
          947  +            <remarks>
          948  +            This split function works somewhat like the String.Split() function in that it breaks apart a string into
          949  +            pieces and returns the pieces as an array.  The primary differences are:
          950  +            <list type="bullet">
          951  +            <item><description>Only one character can be provided as a separator character</description></item>
          952  +            <item><description>Quoted text inside the string is skipped over when searching for the separator, and the quotes are removed.</description></item>
          953  +            </list>
          954  +            Thus, if splitting the following string looking for a comma:<br/>
          955  +            One,Two, "Three, Four", Five<br/>
          956  +            <br/>
          957  +            The resulting array would contain<br/>
          958  +            [0] One<br/>
          959  +            [1] Two<br/>
          960  +            [2] Three, Four<br/>
          961  +            [3] Five<br/>
          962  +            <br/>
          963  +            Note that the leading and trailing spaces were removed from each item during the split.
          964  +            </remarks>
          965  +            <param name="source">Source string to split apart</param>
          966  +            <param name="separator">Separator character</param>
          967  +            <returns>A string array of the split up elements</returns>
          968  +        </member>
          969  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToBoolean(System.Object)">
          970  +            <summary>
          971  +            Convert a value to true or false.
          972  +            </summary>
          973  +            <param name="source">A string or number representing true or false</param>
          974  +            <returns></returns>
          975  +        </member>
          976  +        <member name="M:System.Data.SQLite.SQLiteConvert.ToBoolean(System.String)">
          977  +            <summary>
          978  +            Convert a string to true or false.
          979  +            </summary>
          980  +            <param name="source">A string representing true or false</param>
          981  +            <returns></returns>
          982  +            <remarks>
          983  +            "yes", "no", "y", "n", "0", "1", "on", "off" as well as Boolean.FalseString and Boolean.TrueString will all be
          984  +            converted to a proper boolean value.
          985  +            </remarks>
          986  +        </member>
          987  +        <member name="M:System.Data.SQLite.SQLiteConvert.ColumnToType(System.Data.SQLite.SQLiteStatement,System.Int32,System.Data.SQLite.SQLiteType)">
          988  +            <summary>
          989  +            Determines the data type of a column in a statement
          990  +            </summary>
          991  +            <param name="stmt">The statement to retrieve information for</param>
          992  +            <param name="i">The column to retrieve type information on</param>
          993  +            <param name="typ">The SQLiteType to receive the affinity for the given column</param>
          994  +        </member>
          995  +        <member name="M:System.Data.SQLite.SQLiteConvert.SQLiteTypeToType(System.Data.SQLite.SQLiteType)">
          996  +            <summary>
          997  +            Converts a SQLiteType to a .NET Type object
          998  +            </summary>
          999  +            <param name="t">The SQLiteType to convert</param>
         1000  +            <returns>Returns a .NET Type object</returns>
         1001  +        </member>
         1002  +        <member name="M:System.Data.SQLite.SQLiteConvert.TypeToDbType(System.Type)">
         1003  +            <summary>
         1004  +            For a given intrinsic type, return a DbType
         1005  +            </summary>
         1006  +            <param name="typ">The native type to convert</param>
         1007  +            <returns>The corresponding (closest match) DbType</returns>
         1008  +        </member>
         1009  +        <member name="M:System.Data.SQLite.SQLiteConvert.DbTypeToColumnSize(System.Data.DbType)">
         1010  +            <summary>
         1011  +            Returns the ColumnSize for the given DbType
         1012  +            </summary>
         1013  +            <param name="typ">The DbType to get the size of</param>
         1014  +            <returns></returns>
         1015  +        </member>
         1016  +        <member name="M:System.Data.SQLite.SQLiteConvert.DbTypeToType(System.Data.DbType)">
         1017  +            <summary>
         1018  +            Convert a DbType to a Type
         1019  +            </summary>
         1020  +            <param name="typ">The DbType to convert from</param>
         1021  +            <returns>The closest-match .NET type</returns>
         1022  +        </member>
         1023  +        <member name="M:System.Data.SQLite.SQLiteConvert.TypeToAffinity(System.Type)">
         1024  +            <summary>
         1025  +            For a given type, return the closest-match SQLite TypeAffinity, which only understands a very limited subset of types.
         1026  +            </summary>
         1027  +            <param name="typ">The type to evaluate</param>
         1028  +            <returns>The SQLite type affinity for that type.</returns>
         1029  +        </member>
         1030  +        <member name="M:System.Data.SQLite.SQLiteConvert.TypeNameToDbType(System.String)">
         1031  +            <summary>
         1032  +            For a given type name, return a closest-match .NET type
         1033  +            </summary>
         1034  +            <param name="Name">The name of the type to match</param>
         1035  +            <returns>The .NET DBType the text evaluates to.</returns>
         1036  +        </member>
         1037  +        <member name="T:System.Data.SQLite.TypeAffinity">
         1038  +            <summary>
         1039  +            SQLite has very limited types, and is inherently text-based.  The first 5 types below represent the sum of all types SQLite
         1040  +            understands.  The DateTime extension to the spec is for internal use only.
         1041  +            </summary>
         1042  +        </member>
         1043  +        <member name="F:System.Data.SQLite.TypeAffinity.Uninitialized">
         1044  +            <summary>
         1045  +            Not used
         1046  +            </summary>
         1047  +        </member>
         1048  +        <member name="F:System.Data.SQLite.TypeAffinity.Int64">
         1049  +            <summary>
         1050  +            All integers in SQLite default to Int64
         1051  +            </summary>
         1052  +        </member>
         1053  +        <member name="F:System.Data.SQLite.TypeAffinity.Double">
         1054  +            <summary>
         1055  +            All floating point numbers in SQLite default to double
         1056  +            </summary>
         1057  +        </member>
         1058  +        <member name="F:System.Data.SQLite.TypeAffinity.Text">
         1059  +            <summary>
         1060  +            The default data type of SQLite is text
         1061  +            </summary>
         1062  +        </member>
         1063  +        <member name="F:System.Data.SQLite.TypeAffinity.Blob">
         1064  +            <summary>
         1065  +            Typically blob types are only seen when returned from a function
         1066  +            </summary>
         1067  +        </member>
         1068  +        <member name="F:System.Data.SQLite.TypeAffinity.Null">
         1069  +            <summary>
         1070  +            Null types can be returned from functions
         1071  +            </summary>
         1072  +        </member>
         1073  +        <member name="F:System.Data.SQLite.TypeAffinity.DateTime">
         1074  +            <summary>
         1075  +            Used internally by this provider
         1076  +            </summary>
         1077  +        </member>
         1078  +        <member name="F:System.Data.SQLite.TypeAffinity.None">
         1079  +            <summary>
         1080  +            Used internally
         1081  +            </summary>
         1082  +        </member>
         1083  +        <member name="T:System.Data.SQLite.SQLiteDateFormats">
         1084  +            <summary>
         1085  +            This implementation of SQLite for ADO.NET can process date/time fields in databases in only one of three formats.  Ticks, ISO8601
         1086  +            and JulianDay.
         1087  +            </summary>
         1088  +            <remarks>
         1089  +            ISO8601 is more compatible, readable, fully-processable, but less accurate as it doesn't provide time down to fractions of a second.
         1090  +            JulianDay is the numeric format the SQLite uses internally and is arguably the most compatible with 3rd party tools.  It is
         1091  +            not readable as text without post-processing.
         1092  +            Ticks less compatible with 3rd party tools that query the database, and renders the DateTime field unreadable as text without post-processing.
         1093  +            
         1094  +            The preferred order of choosing a datetime format is JulianDay, ISO8601, and then Ticks.  Ticks is mainly present for legacy 
         1095  +            code support.
         1096  +            </remarks>
         1097  +        </member>
         1098  +        <member name="F:System.Data.SQLite.SQLiteDateFormats.Ticks">
         1099  +            <summary>
         1100  +            Using ticks is not recommended and is not well supported with LINQ.
         1101  +            </summary>
         1102  +        </member>
         1103  +        <member name="F:System.Data.SQLite.SQLiteDateFormats.ISO8601">
         1104  +            <summary>
         1105  +            The default format for this provider.
         1106  +            </summary>
         1107  +        </member>
         1108  +        <member name="F:System.Data.SQLite.SQLiteDateFormats.JulianDay">
         1109  +            <summary>
         1110  +            JulianDay format, which is what SQLite uses internally
         1111  +            </summary>
         1112  +        </member>
         1113  +        <member name="T:System.Data.SQLite.SQLiteJournalModeEnum">
         1114  +            <summary>
         1115  +            This enum determines how SQLite treats its journal file.
         1116  +            </summary>
         1117  +            <remarks>
         1118  +            By default SQLite will create and delete the journal file when needed during a transaction.
         1119  +            However, for some computers running certain filesystem monitoring tools, the rapid
         1120  +            creation and deletion of the journal file can cause those programs to fail, or to interfere with SQLite.
         1121  +            
         1122  +            If a program or virus scanner is interfering with SQLite's journal file, you may receive errors like "unable to open database file"
         1123  +            when starting a transaction.  If this is happening, you may want to change the default journal mode to Persist.
         1124  +            </remarks>
         1125  +        </member>
         1126  +        <member name="F:System.Data.SQLite.SQLiteJournalModeEnum.Delete">
         1127  +            <summary>
         1128  +            The default mode, this causes SQLite to create and destroy the journal file as-needed.
         1129  +            </summary>
         1130  +        </member>
         1131  +        <member name="F:System.Data.SQLite.SQLiteJournalModeEnum.Persist">
         1132  +            <summary>
         1133  +            When this is set, SQLite will keep the journal file even after a transaction has completed.  It's contents will be erased,
         1134  +            and the journal re-used as often as needed.  If it is deleted, it will be recreated the next time it is needed.
         1135  +            </summary>
         1136  +        </member>
         1137  +        <member name="F:System.Data.SQLite.SQLiteJournalModeEnum.Off">
         1138  +            <summary>
         1139  +            This option disables the rollback journal entirely.  Interrupted transactions or a program crash can cause database
         1140  +            corruption in this mode!
         1141  +            </summary>
         1142  +        </member>
         1143  +        <member name="T:System.Data.SQLite.SQLiteType">
         1144  +            <summary>
         1145  +            Struct used internally to determine the datatype of a column in a resultset
         1146  +            </summary>
         1147  +        </member>
         1148  +        <member name="F:System.Data.SQLite.SQLiteType.Type">
         1149  +            <summary>
         1150  +            The DbType of the column, or DbType.Object if it cannot be determined
         1151  +            </summary>
         1152  +        </member>
         1153  +        <member name="F:System.Data.SQLite.SQLiteType.Affinity">
         1154  +            <summary>
         1155  +            The affinity of a column, used for expressions or when Type is DbType.Object
         1156  +            </summary>
         1157  +        </member>
         1158  +        <member name="T:System.Data.SQLite.SQLiteTransaction">
         1159  +            <summary>
         1160  +            SQLite implementation of DbTransaction.
         1161  +            </summary>
         1162  +        </member>
         1163  +        <member name="F:System.Data.SQLite.SQLiteTransaction._cnn">
         1164  +            <summary>
         1165  +            The connection to which this transaction is bound
         1166  +            </summary>
         1167  +        </member>
         1168  +        <member name="M:System.Data.SQLite.SQLiteTransaction.#ctor(System.Data.SQLite.SQLiteConnection,System.Boolean)">
         1169  +            <summary>
         1170  +            Constructs the transaction object, binding it to the supplied connection
         1171  +            </summary>
         1172  +            <param name="connection">The connection to open a transaction on</param>
         1173  +            <param name="deferredLock">TRUE to defer the writelock, or FALSE to lock immediately</param>
         1174  +        </member>
         1175  +        <member name="M:System.Data.SQLite.SQLiteTransaction.Commit">
         1176  +            <summary>
         1177  +            Commits the current transaction.
         1178  +            </summary>
         1179  +        </member>
         1180  +        <member name="M:System.Data.SQLite.SQLiteTransaction.Dispose(System.Boolean)">
         1181  +            <summary>
         1182  +            Disposes the transaction.  If it is currently active, any changes are rolled back.
         1183  +            </summary>
         1184  +        </member>
         1185  +        <member name="M:System.Data.SQLite.SQLiteTransaction.Rollback">
         1186  +            <summary>
         1187  +            Rolls back the active transaction.
         1188  +            </summary>
         1189  +        </member>
         1190  +        <member name="P:System.Data.SQLite.SQLiteTransaction.Connection">
         1191  +            <summary>
         1192  +            Returns the underlying connection to which this transaction applies.
         1193  +            </summary>
         1194  +        </member>
         1195  +        <member name="P:System.Data.SQLite.SQLiteTransaction.DbConnection">
         1196  +            <summary>
         1197  +            Forwards to the local Connection property
         1198  +            </summary>
         1199  +        </member>
         1200  +        <member name="P:System.Data.SQLite.SQLiteTransaction.IsolationLevel">
         1201  +            <summary>
         1202  +            Gets the isolation level of the transaction.  SQLite only supports Serializable transactions.
         1203  +            </summary>
         1204  +        </member>
         1205  +        <member name="T:System.Data.SQLite.SQLiteKeyReader">
         1206  +            <summary>
         1207  +            This class provides key info for a given SQLite statement.
         1208  +            <remarks>
         1209  +            Providing key information for a given statement is non-trivial :(
         1210  +            </remarks>
         1211  +            </summary>
         1212  +        </member>
         1213  +        <member name="M:System.Data.SQLite.SQLiteKeyReader.#ctor(System.Data.SQLite.SQLiteConnection,System.Data.SQLite.SQLiteDataReader,System.Data.SQLite.SQLiteStatement)">
         1214  +            <summary>
         1215  +            This function does all the nasty work at determining what keys need to be returned for
         1216  +            a given statement.
         1217  +            </summary>
         1218  +            <param name="cnn"></param>
         1219  +            <param name="reader"></param>
         1220  +            <param name="stmt"></param>
         1221  +        </member>
         1222  +        <member name="M:System.Data.SQLite.SQLiteKeyReader.Sync">
         1223  +            <summary>
         1224  +            Make sure all the subqueries are open and ready and sync'd with the current rowid
         1225  +            of the table they're supporting
         1226  +            </summary>
         1227  +        </member>
         1228  +        <member name="M:System.Data.SQLite.SQLiteKeyReader.Reset">
         1229  +            <summary>
         1230  +            Release any readers on any subqueries
         1231  +            </summary>
         1232  +        </member>
         1233  +        <member name="M:System.Data.SQLite.SQLiteKeyReader.AppendSchemaTable(System.Data.DataTable)">
         1234  +            <summary>
         1235  +            Append all the columns we've added to the original query to the schema
         1236  +            </summary>
         1237  +            <param name="tbl"></param>
         1238  +        </member>
         1239  +        <member name="P:System.Data.SQLite.SQLiteKeyReader.Count">
         1240  +            <summary>
         1241  +            How many additional columns of keyinfo we're holding
         1242  +            </summary>
         1243  +        </member>
         1244  +        <member name="T:System.Data.SQLite.SQLiteKeyReader.KeyInfo">
         1245  +            <summary>
         1246  +            Used to support CommandBehavior.KeyInfo
         1247  +            </summary>
         1248  +        </member>
         1249  +        <member name="T:System.Data.SQLite.SQLiteKeyReader.KeyQuery">
         1250  +            <summary>
         1251  +            A single sub-query for a given table/database.
         1252  +            </summary>
         1253  +        </member>
         1254  +        <member name="T:System.Data.SQLite.SQLiteFunction">
         1255  +            <summary>
         1256  +            This abstract class is designed to handle user-defined functions easily.  An instance of the derived class is made for each
         1257  +            connection to the database.
         1258  +            </summary>
         1259  +            <remarks>
         1260  +            Although there is one instance of a class derived from SQLiteFunction per database connection, the derived class has no access
         1261  +            to the underlying connection.  This is necessary to deter implementers from thinking it would be a good idea to make database
         1262  +            calls during processing.
         1263  +            
         1264  +            It is important to distinguish between a per-connection instance, and a per-SQL statement context.  One instance of this class
         1265  +            services all SQL statements being stepped through on that connection, and there can be many.  One should never store per-statement
         1266  +            information in member variables of user-defined function classes.
         1267  +            
         1268  +            For aggregate functions, always create and store your per-statement data in the contextData object on the 1st step.  This data will
         1269  +            be automatically freed for you (and Dispose() called if the item supports IDisposable) when the statement completes.
         1270  +            </remarks>
         1271  +        </member>
         1272  +        <member name="F:System.Data.SQLite.SQLiteFunction._base">
         1273  +            <summary>
         1274  +            The base connection this function is attached to
         1275  +            </summary>
         1276  +        </member>
         1277  +        <member name="F:System.Data.SQLite.SQLiteFunction._contextDataList">
         1278  +            <summary>
         1279  +            Internal array used to keep track of aggregate function context data
         1280  +            </summary>
         1281  +        </member>
         1282  +        <member name="F:System.Data.SQLite.SQLiteFunction._InvokeFunc">
         1283  +            <summary>
         1284  +            Holds a reference to the callback function for user functions
         1285  +            </summary>
         1286  +        </member>
         1287  +        <member name="F:System.Data.SQLite.SQLiteFunction._StepFunc">
         1288  +            <summary>
         1289  +            Holds a reference to the callbakc function for stepping in an aggregate function
         1290  +            </summary>
         1291  +        </member>
         1292  +        <member name="F:System.Data.SQLite.SQLiteFunction._FinalFunc">
         1293  +            <summary>
         1294  +            Holds a reference to the callback function for finalizing an aggregate function
         1295  +            </summary>
         1296  +        </member>
         1297  +        <member name="F:System.Data.SQLite.SQLiteFunction._CompareFunc">
         1298  +            <summary>
         1299  +            Holds a reference to the callback function for collation sequences
         1300  +            </summary>
         1301  +        </member>
         1302  +        <member name="F:System.Data.SQLite.SQLiteFunction._context">
         1303  +            <summary>
         1304  +            Current context of the current callback.  Only valid during a callback
         1305  +            </summary>
         1306  +        </member>
         1307  +        <member name="F:System.Data.SQLite.SQLiteFunction._registeredFunctions">
         1308  +            <summary>
         1309  +            This static list contains all the user-defined functions declared using the proper attributes.
         1310  +            </summary>
         1311  +        </member>
         1312  +        <member name="M:System.Data.SQLite.SQLiteFunction.#ctor">
         1313  +            <summary>
         1314  +            Internal constructor, initializes the function's internal variables.
         1315  +            </summary>
         1316  +        </member>
         1317  +        <member name="M:System.Data.SQLite.SQLiteFunction.Invoke(System.Object[])">
         1318  +            <summary>
         1319  +            Scalar functions override this method to do their magic.
         1320  +            </summary>
         1321  +            <remarks>
         1322  +            Parameters passed to functions have only an affinity for a certain data type, there is no underlying schema available
         1323  +            to force them into a certain type.  Therefore the only types you will ever see as parameters are
         1324  +            DBNull.Value, Int64, Double, String or byte[] array.
         1325  +            </remarks>
         1326  +            <param name="args">The arguments for the command to process</param>
         1327  +            <returns>You may return most simple types as a return value, null or DBNull.Value to return null, DateTime, or
         1328  +            you may return an Exception-derived class if you wish to return an error to SQLite.  Do not actually throw the error,
         1329  +            just return it!</returns>
         1330  +        </member>
         1331  +        <member name="M:System.Data.SQLite.SQLiteFunction.Step(System.Object[],System.Int32,System.Object@)">
         1332  +            <summary>
         1333  +            Aggregate functions override this method to do their magic.
         1334  +            </summary>
         1335  +            <remarks>
         1336  +            Typically you'll be updating whatever you've placed in the contextData field and returning as quickly as possible.
         1337  +            </remarks>
         1338  +            <param name="args">The arguments for the command to process</param>
         1339  +            <param name="stepNumber">The 1-based step number.  This is incrememted each time the step method is called.</param>
         1340  +            <param name="contextData">A placeholder for implementers to store contextual data pertaining to the current context.</param>
         1341  +        </member>
         1342  +        <member name="M:System.Data.SQLite.SQLiteFunction.Final(System.Object)">
         1343  +            <summary>
         1344  +            Aggregate functions override this method to finish their aggregate processing.
         1345  +            </summary>
         1346  +            <remarks>
         1347  +            If you implemented your aggregate function properly,
         1348  +            you've been recording and keeping track of your data in the contextData object provided, and now at this stage you should have
         1349  +            all the information you need in there to figure out what to return.
         1350  +            NOTE:  It is possible to arrive here without receiving a previous call to Step(), in which case the contextData will
         1351  +            be null.  This can happen when no rows were returned.  You can either return null, or 0 or some other custom return value
         1352  +            if that is the case.
         1353  +            </remarks>
         1354  +            <param name="contextData">Your own assigned contextData, provided for you so you can return your final results.</param>
         1355  +            <returns>You may return most simple types as a return value, null or DBNull.Value to return null, DateTime, or
         1356  +            you may return an Exception-derived class if you wish to return an error to SQLite.  Do not actually throw the error,
         1357  +            just return it!
         1358  +            </returns>
         1359  +        </member>
         1360  +        <member name="M:System.Data.SQLite.SQLiteFunction.Compare(System.String,System.String)">
         1361  +            <summary>
         1362  +            User-defined collation sequences override this method to provide a custom string sorting algorithm.
         1363  +            </summary>
         1364  +            <param name="param1">The first string to compare</param>
         1365  +            <param name="param2">The second strnig to compare</param>
         1366  +            <returns>1 if param1 is greater than param2, 0 if they are equal, or -1 if param1 is less than param2</returns>
         1367  +        </member>
         1368  +        <member name="M:System.Data.SQLite.SQLiteFunction.ConvertParams(System.Int32,System.IntPtr)">
         1369  +            <summary>
         1370  +            Converts an IntPtr array of context arguments to an object array containing the resolved parameters the pointers point to.
         1371  +            </summary>
         1372  +            <remarks>
         1373  +            Parameters passed to functions have only an affinity for a certain data type, there is no underlying schema available
         1374  +            to force them into a certain type.  Therefore the only types you will ever see as parameters are
         1375  +            DBNull.Value, Int64, Double, String or byte[] array.
         1376  +            </remarks>
         1377  +            <param name="nArgs">The number of arguments</param>
         1378  +            <param name="argsptr">A pointer to the array of arguments</param>
         1379  +            <returns>An object array of the arguments once they've been converted to .NET values</returns>
         1380  +        </member>
         1381  +        <member name="M:System.Data.SQLite.SQLiteFunction.SetReturnValue(System.IntPtr,System.Object)">
         1382  +            <summary>
         1383  +            Takes the return value from Invoke() and Final() and figures out how to return it to SQLite's context.
         1384  +            </summary>
         1385  +            <param name="context">The context the return value applies to</param>
         1386  +            <param name="returnValue">The parameter to return to SQLite</param>
         1387  +        </member>
         1388  +        <member name="M:System.Data.SQLite.SQLiteFunction.ScalarCallback(System.IntPtr,System.Int32,System.IntPtr)">
         1389  +            <summary>
         1390  +            Internal scalar callback function, which wraps the raw context pointer and calls the virtual Invoke() method.
         1391  +            </summary>
         1392  +            <param name="context">A raw context pointer</param>
         1393  +            <param name="nArgs">Number of arguments passed in</param>
         1394  +            <param name="argsptr">A pointer to the array of arguments</param>
         1395  +        </member>
         1396  +        <member name="M:System.Data.SQLite.SQLiteFunction.CompareCallback(System.IntPtr,System.Int32,System.IntPtr,System.Int32,System.IntPtr)">
         1397  +            <summary>
         1398  +            Internal collation sequence function, which wraps up the raw string pointers and executes the Compare() virtual function.
         1399  +            </summary>
         1400  +            <param name="ptr">Not used</param>
         1401  +            <param name="len1">Length of the string pv1</param>
         1402  +            <param name="ptr1">Pointer to the first string to compare</param>
         1403  +            <param name="len2">Length of the string pv2</param>
         1404  +            <param name="ptr2">Pointer to the second string to compare</param>
         1405  +            <returns>Returns -1 if the first string is less than the second.  0 if they are equal, or 1 if the first string is greater
         1406  +            than the second.</returns>
         1407  +        </member>
         1408  +        <member name="M:System.Data.SQLite.SQLiteFunction.StepCallback(System.IntPtr,System.Int32,System.IntPtr)">
         1409  +            <summary>
         1410  +            The internal aggregate Step function callback, which wraps the raw context pointer and calls the virtual Step() method.
         1411  +            </summary>
         1412  +            <remarks>
         1413  +            This function takes care of doing the lookups and getting the important information put together to call the Step() function.
         1414  +            That includes pulling out the user's contextData and updating it after the call is made.  We use a sorted list for this so
         1415  +            binary searches can be done to find the data.
         1416  +            </remarks>
         1417  +            <param name="context">A raw context pointer</param>
         1418  +            <param name="nArgs">Number of arguments passed in</param>
         1419  +            <param name="argsptr">A pointer to the array of arguments</param>
         1420  +        </member>
         1421  +        <member name="M:System.Data.SQLite.SQLiteFunction.FinalCallback(System.IntPtr)">
         1422  +            <summary>
         1423  +            An internal aggregate Final function callback, which wraps the context pointer and calls the virtual Final() method.
         1424  +            </summary>
         1425  +            <param name="context">A raw context pointer</param>
         1426  +        </member>
         1427  +        <member name="M:System.Data.SQLite.SQLiteFunction.Dispose(System.Boolean)">
         1428  +            <summary>
         1429  +            Placeholder for a user-defined disposal routine
         1430  +            </summary>
         1431  +            <param name="disposing">True if the object is being disposed explicitly</param>
         1432  +        </member>
         1433  +        <member name="M:System.Data.SQLite.SQLiteFunction.Dispose">
         1434  +            <summary>
         1435  +            Disposes of any active contextData variables that were not automatically cleaned up.  Sometimes this can happen if
         1436  +            someone closes the connection while a DataReader is open.
         1437  +            </summary>
         1438  +        </member>
         1439  +        <member name="M:System.Data.SQLite.SQLiteFunction.#cctor">
         1440  +            <summary>
         1441  +            Using reflection, enumerate all assemblies in the current appdomain looking for classes that
         1442  +            have a SQLiteFunctionAttribute attribute, and registering them accordingly.
         1443  +            </summary>
         1444  +        </member>
         1445  +        <member name="M:System.Data.SQLite.SQLiteFunction.RegisterFunction(System.Type)">
         1446  +            <summary>
         1447  +            Manual method of registering a function.  The type must still have the SQLiteFunctionAttributes in order to work
         1448  +            properly, but this is a workaround for the Compact Framework where enumerating assemblies is not currently supported.
         1449  +            </summary>
         1450  +            <param name="typ">The type of the function to register</param>
         1451  +        </member>
         1452  +        <member name="M:System.Data.SQLite.SQLiteFunction.BindFunctions(System.Data.SQLite.SQLiteBase)">
         1453  +            <summary>
         1454  +            Called by SQLiteBase derived classes, this function binds all user-defined functions to a connection.
         1455  +            It is done this way so that all user-defined functions will access the database using the same encoding scheme
         1456  +            as the connection (UTF-8 or UTF-16).
         1457  +            </summary>
         1458  +            <remarks>
         1459  +            The wrapper functions that interop with SQLite will create a unique cookie value, which internally is a pointer to
         1460  +            all the wrapped callback functions.  The interop function uses it to map CDecl callbacks to StdCall callbacks.
         1461  +            </remarks>
         1462  +            <param name="sqlbase">The base object on which the functions are to bind</param>
         1463  +            <returns>Returns an array of functions which the connection object should retain until the connection is closed.</returns>
         1464  +        </member>
         1465  +        <member name="P:System.Data.SQLite.SQLiteFunction.SQLiteConvert">
         1466  +            <summary>
         1467  +            Returns a reference to the underlying connection's SQLiteConvert class, which can be used to convert
         1468  +            strings and DateTime's into the current connection's encoding schema.
         1469  +            </summary>
         1470  +        </member>
         1471  +        <member name="T:System.Data.SQLite.SQLiteFunctionEx">
         1472  +            <summary>
         1473  +            Extends SQLiteFunction and allows an inherited class to obtain the collating sequence associated with a function call.
         1474  +            </summary>
         1475  +            <remarks>
         1476  +            User-defined functions can call the GetCollationSequence() method in this class and use it to compare strings and char arrays.
         1477  +            </remarks>
         1478  +        </member>
         1479  +        <member name="M:System.Data.SQLite.SQLiteFunctionEx.GetCollationSequence">
         1480  +            <summary>
         1481  +            Obtains the collating sequence in effect for the given function.
         1482  +            </summary>
         1483  +            <remarks>
         1484  +            As an optimization, SQLite does not fill in this information when calling functions, unless the NeedCollationSequence
         1485  +            boolean value is set to true in the SQLiteFunctionAttribute.
         1486  +            </remarks>
         1487  +            <returns></returns>
         1488  +        </member>
         1489  +        <member name="T:System.Data.SQLite.FunctionType">
         1490  +            <summary>
         1491  +            The type of user-defined function to declare
         1492  +            </summary>
         1493  +        </member>
         1494  +        <member name="F:System.Data.SQLite.FunctionType.Scalar">
         1495  +            <summary>
         1496  +            Scalar functions are designed to be called and return a result immediately.  Examples include ABS(), Upper(), Lower(), etc.
         1497  +            </summary>
         1498  +        </member>
         1499  +        <member name="F:System.Data.SQLite.FunctionType.Aggregate">
         1500  +            <summary>
         1501  +            Aggregate functions are designed to accumulate data until the end of a call and then return a result gleaned from the accumulated data.
         1502  +            Examples include SUM(), COUNT(), AVG(), etc.
         1503  +            </summary>
         1504  +        </member>
         1505  +        <member name="F:System.Data.SQLite.FunctionType.Collation">
         1506  +            <summary>
         1507  +            Collation sequences are used to sort textual data in a custom manner, and appear in an ORDER BY clause.  Typically text in an ORDER BY is
         1508  +            sorted using a straight case-insensitive comparison function.  Custom collating sequences can be used to alter the behavior of text sorting
         1509  +            in a user-defined manner.
         1510  +            </summary>
         1511  +        </member>
         1512  +        <member name="T:System.Data.SQLite.SQLiteCallback">
         1513  +            <summary>
         1514  +            An internal callback delegate declaration.
         1515  +            </summary>
         1516  +            <param name="context">Raw context pointer for the user function</param>
         1517  +            <param name="nArgs">Count of arguments to the function</param>
         1518  +            <param name="argsptr">A pointer to the array of argument pointers</param>
         1519  +        </member>
         1520  +        <member name="T:System.Data.SQLite.SQLiteFinalCallback">
         1521  +            <summary>
         1522  +            An internal final callback delegate declaration.
         1523  +            </summary>
         1524  +            <param name="context">Raw context pointer for the user function</param>
         1525  +        </member>
         1526  +        <member name="T:System.Data.SQLite.SQLiteCollation">
         1527  +            <summary>
         1528  +            Internal callback delegate for implementing collation sequences
         1529  +            </summary>
         1530  +            <param name="puser">Not used</param>
         1531  +            <param name="len1">Length of the string pv1</param>
         1532  +            <param name="pv1">Pointer to the first string to compare</param>
         1533  +            <param name="len2">Length of the string pv2</param>
         1534  +            <param name="pv2">Pointer to the second string to compare</param>
         1535  +            <returns>Returns -1 if the first string is less than the second.  0 if they are equal, or 1 if the first string is greater
         1536  +            than the second.</returns>
         1537  +        </member>
         1538  +        <member name="T:System.Data.SQLite.CollationTypeEnum">
         1539  +            <summary>
         1540  +            The type of collating sequence
         1541  +            </summary>
         1542  +        </member>
         1543  +        <member name="F:System.Data.SQLite.CollationTypeEnum.Binary">
         1544  +            <summary>
         1545  +            The built-in BINARY collating sequence
         1546  +            </summary>
         1547  +        </member>
         1548  +        <member name="F:System.Data.SQLite.CollationTypeEnum.NoCase">
         1549  +            <summary>
         1550  +            The built-in NOCASE collating sequence
         1551  +            </summary>
         1552  +        </member>
         1553  +        <member name="F:System.Data.SQLite.CollationTypeEnum.Reverse">
         1554  +            <summary>
         1555  +            The built-in REVERSE collating sequence
         1556  +            </summary>
         1557  +        </member>
         1558  +        <member name="F:System.Data.SQLite.CollationTypeEnum.Custom">
         1559  +            <summary>
         1560  +            A custom user-defined collating sequence
         1561  +            </summary>
         1562  +        </member>
         1563  +        <member name="T:System.Data.SQLite.CollationEncodingEnum">
         1564  +            <summary>
         1565  +            The encoding type the collation sequence uses
         1566  +            </summary>
         1567  +        </member>
         1568  +        <member name="F:System.Data.SQLite.CollationEncodingEnum.UTF8">
         1569  +            <summary>
         1570  +            The collation sequence is UTF8
         1571  +            </summary>
         1572  +        </member>
         1573  +        <member name="F:System.Data.SQLite.CollationEncodingEnum.UTF16LE">
         1574  +            <summary>
         1575  +            The collation sequence is UTF16 little-endian
         1576  +            </summary>
         1577  +        </member>
         1578  +        <member name="F:System.Data.SQLite.CollationEncodingEnum.UTF16BE">
         1579  +            <summary>
         1580  +            The collation sequence is UTF16 big-endian
         1581  +            </summary>
         1582  +        </member>
         1583  +        <member name="T:System.Data.SQLite.CollationSequence">
         1584  +            <summary>
         1585  +            A struct describing the collating sequence a function is executing in
         1586  +            </summary>
         1587  +        </member>
         1588  +        <member name="F:System.Data.SQLite.CollationSequence.Name">
         1589  +            <summary>
         1590  +            The name of the collating sequence
         1591  +            </summary>
         1592  +        </member>
         1593  +        <member name="F:System.Data.SQLite.CollationSequence.Type">
         1594  +            <summary>
         1595  +            The type of collating sequence
         1596  +            </summary>
         1597  +        </member>
         1598  +        <member name="F:System.Data.SQLite.CollationSequence.Encoding">
         1599  +            <summary>
         1600  +            The text encoding of the collation sequence
         1601  +            </summary>
         1602  +        </member>
         1603  +        <member name="F:System.Data.SQLite.CollationSequence._func">
         1604  +            <summary>
         1605  +            Context of the function that requested the collating sequence
         1606  +            </summary>
         1607  +        </member>
         1608  +        <member name="M:System.Data.SQLite.CollationSequence.Compare(System.String,System.String)">
         1609  +            <summary>
         1610  +            Calls the base collating sequence to compare two strings
         1611  +            </summary>
         1612  +            <param name="s1">The first string to compare</param>
         1613  +            <param name="s2">The second string to compare</param>
         1614  +            <returns>-1 if s1 is less than s2, 0 if s1 is equal to s2, and 1 if s1 is greater than s2</returns>
         1615  +        </member>
         1616  +        <member name="M:System.Data.SQLite.CollationSequence.Compare(System.Char[],System.Char[])">
         1617  +            <summary>
         1618  +            Calls the base collating sequence to compare two character arrays
         1619  +            </summary>
         1620  +            <param name="c1">The first array to compare</param>
         1621  +            <param name="c2">The second array to compare</param>
         1622  +            <returns>-1 if c1 is less than c2, 0 if c1 is equal to c2, and 1 if c1 is greater than c2</returns>
         1623  +        </member>
         1624  +        <member name="T:System.Data.SQLite.SQLiteDataReader">
         1625  +            <summary>
         1626  +            SQLite implementation of DbDataReader.
         1627  +            </summary>
         1628  +        </member>
         1629  +        <member name="F:System.Data.SQLite.SQLiteDataReader._command">
         1630  +            <summary>
         1631  +            Underlying command this reader is attached to
         1632  +            </summary>
         1633  +        </member>
         1634  +        <member name="F:System.Data.SQLite.SQLiteDataReader._activeStatementIndex">
         1635  +            <summary>
         1636  +            Index of the current statement in the command being processed
         1637  +            </summary>
         1638  +        </member>
         1639  +        <member name="F:System.Data.SQLite.SQLiteDataReader._activeStatement">
         1640  +            <summary>
         1641  +            Current statement being Read()
         1642  +            </summary>
         1643  +        </member>
         1644  +        <member name="F:System.Data.SQLite.SQLiteDataReader._readingState">
         1645  +            <summary>
         1646  +            State of the current statement being processed.
         1647  +            -1 = First Step() executed, so the first Read() will be ignored
         1648  +             0 = Actively reading
         1649  +             1 = Finished reading
         1650  +             2 = Non-row-returning statement, no records
         1651  +            </summary>
         1652  +        </member>
         1653  +        <member name="F:System.Data.SQLite.SQLiteDataReader._rowsAffected">
         1654  +            <summary>
         1655  +            Number of records affected by the insert/update statements executed on the command
         1656  +            </summary>
         1657  +        </member>
         1658  +        <member name="F:System.Data.SQLite.SQLiteDataReader._fieldCount">
         1659  +            <summary>
         1660  +            Count of fields (columns) in the row-returning statement currently being processed
         1661  +            </summary>
         1662  +        </member>
         1663  +        <member name="F:System.Data.SQLite.SQLiteDataReader._fieldTypeArray">
         1664  +            <summary>
         1665  +            Datatypes of active fields (columns) in the current statement, used for type-restricting data
         1666  +            </summary>
         1667  +        </member>
         1668  +        <member name="F:System.Data.SQLite.SQLiteDataReader._commandBehavior">
         1669  +            <summary>
         1670  +            The behavior of the datareader
         1671  +            </summary>
         1672  +        </member>
         1673  +        <member name="F:System.Data.SQLite.SQLiteDataReader._disposeCommand">
         1674  +            <summary>
         1675  +            If set, then dispose of the command object when the reader is finished
         1676  +            </summary>
         1677  +        </member>
         1678  +        <member name="F:System.Data.SQLite.SQLiteDataReader._keyInfo">
         1679  +            <summary>
         1680  +            An array of rowid's for the active statement if CommandBehavior.KeyInfo is specified
         1681  +            </summary>
         1682  +        </member>
         1683  +        <member name="M:System.Data.SQLite.SQLiteDataReader.#ctor(System.Data.SQLite.SQLiteCommand,System.Data.CommandBehavior)">
         1684  +            <summary>
         1685  +            Internal constructor, initializes the datareader and sets up to begin executing statements
         1686  +            </summary>
         1687  +            <param name="cmd">The SQLiteCommand this data reader is for</param>
         1688  +            <param name="behave">The expected behavior of the data reader</param>
         1689  +        </member>
         1690  +        <member name="M:System.Data.SQLite.SQLiteDataReader.Close">
         1691  +            <summary>
         1692  +            Closes the datareader, potentially closing the connection as well if CommandBehavior.CloseConnection was specified.
         1693  +            </summary>
         1694  +        </member>
         1695  +        <member name="M:System.Data.SQLite.SQLiteDataReader.CheckClosed">
         1696  +            <summary>
         1697  +            Throw an error if the datareader is closed
         1698  +            </summary>
         1699  +        </member>
         1700  +        <member name="M:System.Data.SQLite.SQLiteDataReader.CheckValidRow">
         1701  +            <summary>
         1702  +            Throw an error if a row is not loaded
         1703  +            </summary>
         1704  +        </member>
         1705  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetEnumerator">
         1706  +            <summary>
         1707  +            Enumerator support
         1708  +            </summary>
         1709  +            <returns>Returns a DbEnumerator object.</returns>
         1710  +        </member>
         1711  +        <member name="M:System.Data.SQLite.SQLiteDataReader.VerifyType(System.Int32,System.Data.DbType)">
         1712  +            <summary>
         1713  +            SQLite is inherently un-typed.  All datatypes in SQLite are natively strings.  The definition of the columns of a table
         1714  +            and the affinity of returned types are all we have to go on to type-restrict data in the reader.
         1715  +            
         1716  +            This function attempts to verify that the type of data being requested of a column matches the datatype of the column.  In
         1717  +            the case of columns that are not backed into a table definition, we attempt to match up the affinity of a column (int, double, string or blob)
         1718  +            to a set of known types that closely match that affinity.  It's not an exact science, but its the best we can do.
         1719  +            </summary>
         1720  +            <returns>
         1721  +            This function throws an InvalidTypeCast() exception if the requested type doesn't match the column's definition or affinity.
         1722  +            </returns>
         1723  +            <param name="i">The index of the column to type-check</param>
         1724  +            <param name="typ">The type we want to get out of the column</param>
         1725  +        </member>
         1726  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetBoolean(System.Int32)">
         1727  +            <summary>
         1728  +            Retrieves the column as a boolean value
         1729  +            </summary>
         1730  +            <param name="i">The index of the column to retrieve</param>
         1731  +            <returns>bool</returns>
         1732  +        </member>
         1733  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetByte(System.Int32)">
         1734  +            <summary>
         1735  +            Retrieves the column as a single byte value
         1736  +            </summary>
         1737  +            <param name="i">The index of the column to retrieve</param>
         1738  +            <returns>byte</returns>
         1739  +        </member>
         1740  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetBytes(System.Int32,System.Int64,System.Byte[],System.Int32,System.Int32)">
         1741  +            <summary>
         1742  +            Retrieves a column as an array of bytes (blob)
         1743  +            </summary>
         1744  +            <param name="i">The index of the column to retrieve</param>
         1745  +            <param name="fieldOffset">The zero-based index of where to begin reading the data</param>
         1746  +            <param name="buffer">The buffer to write the bytes into</param>
         1747  +            <param name="bufferoffset">The zero-based index of where to begin writing into the array</param>
         1748  +            <param name="length">The number of bytes to retrieve</param>
         1749  +            <returns>The actual number of bytes written into the array</returns>
         1750  +            <remarks>
         1751  +            To determine the number of bytes in the column, pass a null value for the buffer.  The total length will be returned.
         1752  +            </remarks>
         1753  +        </member>
         1754  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetChar(System.Int32)">
         1755  +            <summary>
         1756  +            Returns the column as a single character
         1757  +            </summary>
         1758  +            <param name="i">The index of the column to retrieve</param>
         1759  +            <returns>char</returns>
         1760  +        </member>
         1761  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetChars(System.Int32,System.Int64,System.Char[],System.Int32,System.Int32)">
         1762  +            <summary>
         1763  +            Retrieves a column as an array of chars (blob)
         1764  +            </summary>
         1765  +            <param name="i">The index of the column to retrieve</param>
         1766  +            <param name="fieldoffset">The zero-based index of where to begin reading the data</param>
         1767  +            <param name="buffer">The buffer to write the characters into</param>
         1768  +            <param name="bufferoffset">The zero-based index of where to begin writing into the array</param>
         1769  +            <param name="length">The number of bytes to retrieve</param>
         1770  +            <returns>The actual number of characters written into the array</returns>
         1771  +            <remarks>
         1772  +            To determine the number of characters in the column, pass a null value for the buffer.  The total length will be returned.
         1773  +            </remarks>
         1774  +        </member>
         1775  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetDataTypeName(System.Int32)">
         1776  +            <summary>
         1777  +            Retrieves the name of the back-end datatype of the column
         1778  +            </summary>
         1779  +            <param name="i">The index of the column to retrieve</param>
         1780  +            <returns>string</returns>
         1781  +        </member>
         1782  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetDateTime(System.Int32)">
         1783  +            <summary>
         1784  +            Retrieve the column as a date/time value
         1785  +            </summary>
         1786  +            <param name="i">The index of the column to retrieve</param>
         1787  +            <returns>DateTime</returns>
         1788  +        </member>
         1789  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetDecimal(System.Int32)">
         1790  +            <summary>
         1791  +            Retrieve the column as a decimal value
         1792  +            </summary>
         1793  +            <param name="i">The index of the column to retrieve</param>
         1794  +            <returns>decimal</returns>
         1795  +        </member>
         1796  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetDouble(System.Int32)">
         1797  +            <summary>
         1798  +            Returns the column as a double
         1799  +            </summary>
         1800  +            <param name="i">The index of the column to retrieve</param>
         1801  +            <returns>double</returns>
         1802  +        </member>
         1803  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetFieldType(System.Int32)">
         1804  +            <summary>
         1805  +            Returns the .NET type of a given column
         1806  +            </summary>
         1807  +            <param name="i">The index of the column to retrieve</param>
         1808  +            <returns>Type</returns>
         1809  +        </member>
         1810  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetFloat(System.Int32)">
         1811  +            <summary>
         1812  +            Returns a column as a float value
         1813  +            </summary>
         1814  +            <param name="i">The index of the column to retrieve</param>
         1815  +            <returns>float</returns>
         1816  +        </member>
         1817  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetGuid(System.Int32)">
         1818  +            <summary>
         1819  +            Returns the column as a Guid
         1820  +            </summary>
         1821  +            <param name="i">The index of the column to retrieve</param>
         1822  +            <returns>Guid</returns>
         1823  +        </member>
         1824  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetInt16(System.Int32)">
         1825  +            <summary>
         1826  +            Returns the column as a short
         1827  +            </summary>
         1828  +            <param name="i">The index of the column to retrieve</param>
         1829  +            <returns>Int16</returns>
         1830  +        </member>
         1831  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetInt32(System.Int32)">
         1832  +            <summary>
         1833  +            Retrieves the column as an int
         1834  +            </summary>
         1835  +            <param name="i">The index of the column to retrieve</param>
         1836  +            <returns>Int32</returns>
         1837  +        </member>
         1838  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetInt64(System.Int32)">
         1839  +            <summary>
         1840  +            Retrieves the column as a long
         1841  +            </summary>
         1842  +            <param name="i">The index of the column to retrieve</param>
         1843  +            <returns>Int64</returns>
         1844  +        </member>
         1845  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetName(System.Int32)">
         1846  +            <summary>
         1847  +            Retrieves the name of the column
         1848  +            </summary>
         1849  +            <param name="i">The index of the column to retrieve</param>
         1850  +            <returns>string</returns>
         1851  +        </member>
         1852  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetOrdinal(System.String)">
         1853  +            <summary>
         1854  +            Retrieves the i of a column, given its name
         1855  +            </summary>
         1856  +            <param name="name">The name of the column to retrieve</param>
         1857  +            <returns>The int i of the column</returns>
         1858  +        </member>
         1859  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetSchemaTable">
         1860  +            <summary>
         1861  +            Schema information in SQLite is difficult to map into .NET conventions, so a lot of work must be done
         1862  +            to gather the necessary information so it can be represented in an ADO.NET manner.
         1863  +            </summary>
         1864  +            <returns>Returns a DataTable containing the schema information for the active SELECT statement being processed.</returns>
         1865  +        </member>
         1866  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetString(System.Int32)">
         1867  +            <summary>
         1868  +            Retrieves the column as a string
         1869  +            </summary>
         1870  +            <param name="i">The index of the column to retrieve</param>
         1871  +            <returns>string</returns>
         1872  +        </member>
         1873  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetValue(System.Int32)">
         1874  +            <summary>
         1875  +            Retrieves the column as an object corresponding to the underlying datatype of the column
         1876  +            </summary>
         1877  +            <param name="i">The index of the column to retrieve</param>
         1878  +            <returns>object</returns>
         1879  +        </member>
         1880  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetValues(System.Object[])">
         1881  +            <summary>
         1882  +            Retreives the values of multiple columns, up to the size of the supplied array
         1883  +            </summary>
         1884  +            <param name="values">The array to fill with values from the columns in the current resultset</param>
         1885  +            <returns>The number of columns retrieved</returns>
         1886  +        </member>
         1887  +        <member name="M:System.Data.SQLite.SQLiteDataReader.IsDBNull(System.Int32)">
         1888  +            <summary>
         1889  +            Returns True if the specified column is null
         1890  +            </summary>
         1891  +            <param name="i">The index of the column to retrieve</param>
         1892  +            <returns>True or False</returns>
         1893  +        </member>
         1894  +        <member name="M:System.Data.SQLite.SQLiteDataReader.NextResult">
         1895  +            <summary>
         1896  +            Moves to the next resultset in multiple row-returning SQL command.
         1897  +            </summary>
         1898  +            <returns>True if the command was successful and a new resultset is available, False otherwise.</returns>
         1899  +        </member>
         1900  +        <member name="M:System.Data.SQLite.SQLiteDataReader.GetSQLiteType(System.Int32)">
         1901  +            <summary>
         1902  +            Retrieves the SQLiteType for a given column, and caches it to avoid repetetive interop calls.
         1903  +            </summary>
         1904  +            <param name="i">The index of the column to retrieve</param>
         1905  +            <returns>A SQLiteType structure</returns>
         1906  +        </member>
         1907  +        <member name="M:System.Data.SQLite.SQLiteDataReader.Read">
         1908  +            <summary>
         1909  +            Reads the next row from the resultset
         1910  +            </summary>
         1911  +            <returns>True if a new row was successfully loaded and is ready for processing</returns>
         1912  +        </member>
         1913  +        <member name="P:System.Data.SQLite.SQLiteDataReader.Depth">
         1914  +            <summary>
         1915  +            Not implemented.  Returns 0
         1916  +            </summary>
         1917  +        </member>
         1918  +        <member name="P:System.Data.SQLite.SQLiteDataReader.FieldCount">
         1919  +            <summary>
         1920  +            Returns the number of columns in the current resultset
         1921  +            </summary>
         1922  +        </member>
         1923  +        <member name="P:System.Data.SQLite.SQLiteDataReader.VisibleFieldCount">
         1924  +            <summary>
         1925  +            Returns the number of visible fielsd in the current resultset
         1926  +            </summary>
         1927  +        </member>
         1928  +        <member name="P:System.Data.SQLite.SQLiteDataReader.HasRows">
         1929  +            <summary>
         1930  +            Returns True if the resultset has rows that can be fetched
         1931  +            </summary>
         1932  +        </member>
         1933  +        <member name="P:System.Data.SQLite.SQLiteDataReader.IsClosed">
         1934  +            <summary>
         1935  +            Returns True if the data reader is closed
         1936  +            </summary>
         1937  +        </member>
         1938  +        <member name="P:System.Data.SQLite.SQLiteDataReader.RecordsAffected">
         1939  +            <summary>
         1940  +            Retrieve the count of records affected by an update/insert command.  Only valid once the data reader is closed!
         1941  +            </summary>
         1942  +        </member>
         1943  +        <member name="P:System.Data.SQLite.SQLiteDataReader.Item(System.String)">
         1944  +            <summary>
         1945  +            Indexer to retrieve data from a column given its name
         1946  +            </summary>
         1947  +            <param name="name">The name of the column to retrieve data for</param>
         1948  +            <returns>The value contained in the column</returns>
         1949  +        </member>
         1950  +        <member name="P:System.Data.SQLite.SQLiteDataReader.Item(System.Int32)">
         1951  +            <summary>
         1952  +            Indexer to retrieve data from a column given its i
         1953  +            </summary>
         1954  +            <param name="i">The index of the column to retrieve</param>
         1955  +            <returns>The value contained in the column</returns>
         1956  +        </member>
         1957  +        <member name="T:System.Data.SQLite.SQLiteParameter">
         1958  +            <summary>
         1959  +            SQLite implementation of DbParameter.
         1960  +            </summary>
         1961  +        </member>
         1962  +        <member name="F:System.Data.SQLite.SQLiteParameter._dbType">
         1963  +            <summary>
         1964  +            The data type of the parameter
         1965  +            </summary>
         1966  +        </member>
         1967  +        <member name="F:System.Data.SQLite.SQLiteParameter._rowVersion">
         1968  +            <summary>
         1969  +            The version information for mapping the parameter
         1970  +            </summary>
         1971  +        </member>
         1972  +        <member name="F:System.Data.SQLite.SQLiteParameter._objValue">
         1973  +            <summary>
         1974  +            The value of the data in the parameter
         1975  +            </summary>
         1976  +        </member>
         1977  +        <member name="F:System.Data.SQLite.SQLiteParameter._sourceColumn">
         1978  +            <summary>
         1979  +            The source column for the parameter
         1980  +            </summary>
         1981  +        </member>
         1982  +        <member name="F:System.Data.SQLite.SQLiteParameter._parameterName">
         1983  +            <summary>
         1984  +            The column name
         1985  +            </summary>
         1986  +        </member>
         1987  +        <member name="F:System.Data.SQLite.SQLiteParameter._dataSize">
         1988  +            <summary>
         1989  +            The data size, unused by SQLite
         1990  +            </summary>
         1991  +        </member>
         1992  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor">
         1993  +            <summary>
         1994  +            Default constructor
         1995  +            </summary>
         1996  +        </member>
         1997  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String)">
         1998  +            <summary>
         1999  +            Constructs a named parameter given the specified parameter name
         2000  +            </summary>
         2001  +            <param name="parameterName">The parameter name</param>
         2002  +        </member>
         2003  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Object)">
         2004  +            <summary>
         2005  +            Constructs a named parameter given the specified parameter name and initial value
         2006  +            </summary>
         2007  +            <param name="parameterName">The parameter name</param>
         2008  +            <param name="value">The initial value of the parameter</param>
         2009  +        </member>
         2010  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType)">
         2011  +            <summary>
         2012  +            Constructs a named parameter of the specified type
         2013  +            </summary>
         2014  +            <param name="parameterName">The parameter name</param>
         2015  +            <param name="dbType">The datatype of the parameter</param>
         2016  +        </member>
         2017  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.String)">
         2018  +            <summary>
         2019  +            Constructs a named parameter of the specified type and source column reference
         2020  +            </summary>
         2021  +            <param name="parameterName">The parameter name</param>
         2022  +            <param name="dbType">The data type</param>
         2023  +            <param name="sourceColumn">The source column</param>
         2024  +        </member>
         2025  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.String,System.Data.DataRowVersion)">
         2026  +            <summary>
         2027  +            Constructs a named parameter of the specified type, source column and row version
         2028  +            </summary>
         2029  +            <param name="parameterName">The parameter name</param>
         2030  +            <param name="dbType">The data type</param>
         2031  +            <param name="sourceColumn">The source column</param>
         2032  +            <param name="rowVersion">The row version information</param>
         2033  +        </member>
         2034  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType)">
         2035  +            <summary>
         2036  +            Constructs an unnamed parameter of the specified data type
         2037  +            </summary>
         2038  +            <param name="dbType">The datatype of the parameter</param>
         2039  +        </member>
         2040  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.Object)">
         2041  +            <summary>
         2042  +            Constructs an unnamed parameter of the specified data type and sets the initial value
         2043  +            </summary>
         2044  +            <param name="dbType">The datatype of the parameter</param>
         2045  +            <param name="value">The initial value of the parameter</param>
         2046  +        </member>
         2047  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.String)">
         2048  +            <summary>
         2049  +            Constructs an unnamed parameter of the specified data type and source column
         2050  +            </summary>
         2051  +            <param name="dbType">The datatype of the parameter</param>
         2052  +            <param name="sourceColumn">The source column</param>
         2053  +        </member>
         2054  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.String,System.Data.DataRowVersion)">
         2055  +            <summary>
         2056  +            Constructs an unnamed parameter of the specified data type, source column and row version
         2057  +            </summary>
         2058  +            <param name="dbType">The data type</param>
         2059  +            <param name="sourceColumn">The source column</param>
         2060  +            <param name="rowVersion">The row version information</param>
         2061  +        </member>
         2062  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.Int32)">
         2063  +            <summary>
         2064  +            Constructs a named parameter of the specified type and size
         2065  +            </summary>
         2066  +            <param name="parameterName">The parameter name</param>
         2067  +            <param name="parameterType">The data type</param>
         2068  +            <param name="parameterSize">The size of the parameter</param>
         2069  +        </member>
         2070  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.Int32,System.String)">
         2071  +            <summary>
         2072  +            Constructs a named parameter of the specified type, size and source column
         2073  +            </summary>
         2074  +            <param name="parameterName">The name of the parameter</param>
         2075  +            <param name="parameterType">The data type</param>
         2076  +            <param name="parameterSize">The size of the parameter</param>
         2077  +            <param name="sourceColumn">The source column</param>
         2078  +        </member>
         2079  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.Int32,System.String,System.Data.DataRowVersion)">
         2080  +            <summary>
         2081  +            Constructs a named parameter of the specified type, size, source column and row version
         2082  +            </summary>
         2083  +            <param name="parameterName">The name of the parameter</param>
         2084  +            <param name="parameterType">The data type</param>
         2085  +            <param name="parameterSize">The size of the parameter</param>
         2086  +            <param name="sourceColumn">The source column</param>
         2087  +            <param name="rowVersion">The row version information</param>
         2088  +        </member>
         2089  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.Int32,System.Data.ParameterDirection,System.Boolean,System.Byte,System.Byte,System.String,System.Data.DataRowVersion,System.Object)">
         2090  +            <summary>
         2091  +            Constructs a named parameter of the specified type, size, source column and row version
         2092  +            </summary>
         2093  +            <param name="parameterName">The name of the parameter</param>
         2094  +            <param name="parameterType">The data type</param>
         2095  +            <param name="parameterSize">The size of the parameter</param>
         2096  +            <param name="direction">Only input parameters are supported in SQLite</param>
         2097  +            <param name="isNullable">Ignored</param>
         2098  +            <param name="precision">Ignored</param>
         2099  +            <param name="scale">Ignored</param>
         2100  +            <param name="sourceColumn">The source column</param>
         2101  +            <param name="rowVersion">The row version information</param>
         2102  +            <param name="value">The initial value to assign the parameter</param>   
         2103  +        </member>
         2104  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.String,System.Data.DbType,System.Int32,System.Data.ParameterDirection,System.Byte,System.Byte,System.String,System.Data.DataRowVersion,System.Boolean,System.Object)">
         2105  +            <summary>
         2106  +            Constructs a named parameter, yet another flavor
         2107  +            </summary>
         2108  +            <param name="parameterName">The name of the parameter</param>
         2109  +            <param name="parameterType">The data type</param>
         2110  +            <param name="parameterSize">The size of the parameter</param>
         2111  +            <param name="direction">Only input parameters are supported in SQLite</param>
         2112  +            <param name="precision">Ignored</param>
         2113  +            <param name="scale">Ignored</param>
         2114  +            <param name="sourceColumn">The source column</param>
         2115  +            <param name="rowVersion">The row version information</param>
         2116  +            <param name="sourceColumnNullMapping">Whether or not this parameter is for comparing NULL's</param>
         2117  +            <param name="value">The intial value to assign the parameter</param>
         2118  +        </member>
         2119  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.Int32)">
         2120  +            <summary>
         2121  +            Constructs an unnamed parameter of the specified type and size
         2122  +            </summary>
         2123  +            <param name="parameterType">The data type</param>
         2124  +            <param name="parameterSize">The size of the parameter</param>
         2125  +        </member>
         2126  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.Int32,System.String)">
         2127  +            <summary>
         2128  +            Constructs an unnamed parameter of the specified type, size, and source column
         2129  +            </summary>
         2130  +            <param name="parameterType">The data type</param>
         2131  +            <param name="parameterSize">The size of the parameter</param>
         2132  +            <param name="sourceColumn">The source column</param>
         2133  +        </member>
         2134  +        <member name="M:System.Data.SQLite.SQLiteParameter.#ctor(System.Data.DbType,System.Int32,System.String,System.Data.DataRowVersion)">
         2135  +            <summary>
         2136  +            Constructs an unnamed parameter of the specified type, size, source column and row version
         2137  +            </summary>
         2138  +            <param name="parameterType">The data type</param>
         2139  +            <param name="parameterSize">The size of the parameter</param>
         2140  +            <param name="sourceColumn">The source column</param>
         2141  +            <param name="rowVersion">The row version information</param>
         2142  +        </member>
         2143  +        <member name="M:System.Data.SQLite.SQLiteParameter.ResetDbType">
         2144  +            <summary>
         2145  +            Resets the DbType of the parameter so it can be inferred from the value
         2146  +            </summary>
         2147  +        </member>
         2148  +        <member name="M:System.Data.SQLite.SQLiteParameter.Clone">
         2149  +            <summary>
         2150  +            Clones a parameter
         2151  +            </summary>
         2152  +            <returns>A new, unassociated SQLiteParameter</returns>
         2153  +        </member>
         2154  +        <member name="P:System.Data.SQLite.SQLiteParameter.IsNullable">
         2155  +            <summary>
         2156  +            Whether or not the parameter can contain a null value
         2157  +            </summary>
         2158  +        </member>
         2159  +        <member name="P:System.Data.SQLite.SQLiteParameter.DbType">
         2160  +            <summary>
         2161  +            Returns the datatype of the parameter
         2162  +            </summary>
         2163  +        </member>
         2164  +        <member name="P:System.Data.SQLite.SQLiteParameter.Direction">
         2165  +            <summary>
         2166  +            Supports only input parameters
         2167  +            </summary>
         2168  +        </member>
         2169  +        <member name="P:System.Data.SQLite.SQLiteParameter.ParameterName">
         2170  +            <summary>
         2171  +            Returns the parameter name
         2172  +            </summary>
         2173  +        </member>
         2174  +        <member name="P:System.Data.SQLite.SQLiteParameter.Size">
         2175  +            <summary>
         2176  +            Returns the size of the parameter
         2177  +            </summary>
         2178  +        </member>
         2179  +        <member name="P:System.Data.SQLite.SQLiteParameter.SourceColumn">
         2180  +            <summary>
         2181  +            Gets/sets the source column
         2182  +            </summary>
         2183  +        </member>
         2184  +        <member name="P:System.Data.SQLite.SQLiteParameter.SourceColumnNullMapping">
         2185  +            <summary>
         2186  +            Used by DbCommandBuilder to determine the mapping for nullable fields
         2187  +            </summary>
         2188  +        </member>
         2189  +        <member name="P:System.Data.SQLite.SQLiteParameter.SourceVersion">
         2190  +            <summary>
         2191  +            Gets and sets the row version
         2192  +            </summary>
         2193  +        </member>
         2194  +        <member name="P:System.Data.SQLite.SQLiteParameter.Value">
         2195  +            <summary>
         2196  +            Gets and sets the parameter value.  If no datatype was specified, the datatype will assume the type from the value given.
         2197  +            </summary>
         2198  +        </member>
         2199  +        <member name="T:System.Data.SQLite.SQLiteMetaDataCollectionNames">
         2200  +            <summary>
         2201  +            MetaDataCollections specific to SQLite
         2202  +            </summary>
         2203  +        </member>
         2204  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Catalogs">
         2205  +            <summary>
         2206  +            Returns a list of databases attached to the connection
         2207  +            </summary>
         2208  +        </member>
         2209  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Columns">
         2210  +            <summary>
         2211  +            Returns column information for the specified table
         2212  +            </summary>
         2213  +        </member>
         2214  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Indexes">
         2215  +            <summary>
         2216  +            Returns index information for the optionally-specified table
         2217  +            </summary>
         2218  +        </member>
         2219  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.IndexColumns">
         2220  +            <summary>
         2221  +            Returns base columns for the given index
         2222  +            </summary>
         2223  +        </member>
         2224  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Tables">
         2225  +            <summary>
         2226  +            Returns the tables in the given catalog
         2227  +            </summary>
         2228  +        </member>
         2229  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Views">
         2230  +            <summary>
         2231  +            Returns user-defined views in the given catalog
         2232  +            </summary>
         2233  +        </member>
         2234  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.ViewColumns">
         2235  +            <summary>
         2236  +            Returns underlying column information on the given view
         2237  +            </summary>
         2238  +        </member>
         2239  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.ForeignKeys">
         2240  +            <summary>
         2241  +            Returns foreign key information for the given catalog
         2242  +            </summary>
         2243  +        </member>
         2244  +        <member name="F:System.Data.SQLite.SQLiteMetaDataCollectionNames.Triggers">
         2245  +            <summary>
         2246  +            Returns the triggers on the database
         2247  +            </summary>
         2248  +        </member>
         2249  +        <member name="T:System.Data.SQLite.SQLiteCommand">
         2250  +            <summary>
         2251  +            SQLite implementation of DbCommand.
         2252  +            </summary>
         2253  +        </member>
         2254  +        <member name="F:System.Data.SQLite.SQLiteCommand._commandText">
         2255  +            <summary>
         2256  +            The command text this command is based on
         2257  +            </summary>
         2258  +        </member>
         2259  +        <member name="F:System.Data.SQLite.SQLiteCommand._cnn">
         2260  +            <summary>
         2261  +            The connection the command is associated with
         2262  +            </summary>
         2263  +        </member>
         2264  +        <member name="F:System.Data.SQLite.SQLiteCommand._version">
         2265  +            <summary>
         2266  +            The version of the connection the command is associated with
         2267  +            </summary>
         2268  +        </member>
         2269  +        <member name="F:System.Data.SQLite.SQLiteCommand._activeReader">
         2270  +            <summary>
         2271  +            Indicates whether or not a DataReader is active on the command.
         2272  +            </summary>
         2273  +        </member>
         2274  +        <member name="F:System.Data.SQLite.SQLiteCommand._commandTimeout">
         2275  +            <summary>
         2276  +            The timeout for the command, kludged because SQLite doesn't support per-command timeout values
         2277  +            </summary>
         2278  +        </member>
         2279  +        <member name="F:System.Data.SQLite.SQLiteCommand._designTimeVisible">
         2280  +            <summary>
         2281  +            Designer support
         2282  +            </summary>
         2283  +        </member>
         2284  +        <member name="F:System.Data.SQLite.SQLiteCommand._updateRowSource">
         2285  +            <summary>
         2286  +            Used by DbDataAdapter to determine updating behavior
         2287  +            </summary>
         2288  +        </member>
         2289  +        <member name="F:System.Data.SQLite.SQLiteCommand._parameterCollection">
         2290  +            <summary>
         2291  +            The collection of parameters for the command
         2292  +            </summary>
         2293  +        </member>
         2294  +        <member name="F:System.Data.SQLite.SQLiteCommand._statementList">
         2295  +            <summary>
         2296  +            The SQL command text, broken into individual SQL statements as they are executed
         2297  +            </summary>
         2298  +        </member>
         2299  +        <member name="F:System.Data.SQLite.SQLiteCommand._remainingText">
         2300  +            <summary>
         2301  +            Unprocessed SQL text that has not been executed
         2302  +            </summary>
         2303  +        </member>
         2304  +        <member name="F:System.Data.SQLite.SQLiteCommand._transaction">
         2305  +            <summary>
         2306  +            Transaction associated with this command
         2307  +            </summary>
         2308  +        </member>
         2309  +        <member name="M:System.Data.SQLite.SQLiteCommand.#ctor">
         2310  +            <overloads>
         2311  +             Constructs a new SQLiteCommand
         2312  +             </overloads>
         2313  +             <summary>
         2314  +             Default constructor
         2315  +             </summary>
         2316  +        </member>
         2317  +        <member name="M:System.Data.SQLite.SQLiteCommand.#ctor(System.String)">
         2318  +            <summary>
         2319  +            Initializes the command with the given command text
         2320  +            </summary>
         2321  +            <param name="commandText">The SQL command text</param>
         2322  +        </member>
         2323  +        <member name="M:System.Data.SQLite.SQLiteCommand.#ctor(System.String,System.Data.SQLite.SQLiteConnection)">
         2324  +            <summary>
         2325  +            Initializes the command with the given SQL command text and attach the command to the specified
         2326  +            connection.
         2327  +            </summary>
         2328  +            <param name="commandText">The SQL command text</param>
         2329  +            <param name="connection">The connection to associate with the command</param>
         2330  +        </member>
         2331  +        <member name="M:System.Data.SQLite.SQLiteCommand.#ctor(System.Data.SQLite.SQLiteConnection)">
         2332  +            <summary>
         2333  +            Initializes the command and associates it with the specified connection.
         2334  +            </summary>
         2335  +            <param name="connection">The connection to associate with the command</param>
         2336  +        </member>
         2337  +        <member name="M:System.Data.SQLite.SQLiteCommand.#ctor(System.String,System.Data.SQLite.SQLiteConnection,System.Data.SQLite.SQLiteTransaction)">
         2338  +            <summary>
         2339  +            Initializes a command with the given SQL, connection and transaction
         2340  +            </summary>
         2341  +            <param name="commandText">The SQL command text</param>
         2342  +            <param name="connection">The connection to associate with the command</param>
         2343  +            <param name="transaction">The transaction the command should be associated with</param>
         2344  +        </member>
         2345  +        <member name="M:System.Data.SQLite.SQLiteCommand.Dispose(System.Boolean)">
         2346  +            <summary>
         2347  +            Disposes of the command and clears all member variables
         2348  +            </summary>
         2349  +            <param name="disposing">Whether or not the class is being explicitly or implicitly disposed</param>
         2350  +        </member>
         2351  +        <member name="M:System.Data.SQLite.SQLiteCommand.ClearCommands">
         2352  +            <summary>
         2353  +            Clears and destroys all statements currently prepared
         2354  +            </summary>
         2355  +        </member>
         2356  +        <member name="M:System.Data.SQLite.SQLiteCommand.BuildNextCommand">
         2357  +            <summary>
         2358  +            Builds an array of prepared statements for each complete SQL statement in the command text
         2359  +            </summary>
         2360  +        </member>
         2361  +        <member name="M:System.Data.SQLite.SQLiteCommand.Cancel">
         2362  +            <summary>
         2363  +            Not implemented
         2364  +            </summary>
         2365  +        </member>
         2366  +        <member name="M:System.Data.SQLite.SQLiteCommand.CreateDbParameter">
         2367  +            <summary>
         2368  +            Forwards to the local CreateParameter() function
         2369  +            </summary>
         2370  +            <returns></returns>
         2371  +        </member>
         2372  +        <member name="M:System.Data.SQLite.SQLiteCommand.CreateParameter">
         2373  +            <summary>
         2374  +            Create a new parameter
         2375  +            </summary>
         2376  +            <returns></returns>
         2377  +        </member>
         2378  +        <member name="M:System.Data.SQLite.SQLiteCommand.InitializeForReader">
         2379  +            <summary>
         2380  +            This function ensures there are no active readers, that we have a valid connection,
         2381  +            that the connection is open, that all statements are prepared and all parameters are assigned
         2382  +            in preparation for allocating a data reader.
         2383  +            </summary>
         2384  +        </member>
         2385  +        <member name="M:System.Data.SQLite.SQLiteCommand.ExecuteDbDataReader(System.Data.CommandBehavior)">
         2386  +            <summary>
         2387  +            Creates a new SQLiteDataReader to execute/iterate the array of SQLite prepared statements
         2388  +            </summary>
         2389  +            <param name="behavior">The behavior the data reader should adopt</param>
         2390  +            <returns>Returns a SQLiteDataReader object</returns>
         2391  +        </member>
         2392  +        <member name="M:System.Data.SQLite.SQLiteCommand.ExecuteReader(System.Data.CommandBehavior)">
         2393  +            <summary>
         2394  +            Overrides the default behavior to return a SQLiteDataReader specialization class
         2395  +            </summary>
         2396  +            <param name="behavior">The flags to be associated with the reader</param>
         2397  +            <returns>A SQLiteDataReader</returns>
         2398  +        </member>
         2399  +        <member name="M:System.Data.SQLite.SQLiteCommand.ExecuteReader">
         2400  +            <summary>
         2401  +            Overrides the default behavior of DbDataReader to return a specialized SQLiteDataReader class
         2402  +            </summary>
         2403  +            <returns>A SQLiteDataReader</returns>
         2404  +        </member>
         2405  +        <member name="M:System.Data.SQLite.SQLiteCommand.ClearDataReader">
         2406  +            <summary>
         2407  +            Called by the SQLiteDataReader when the data reader is closed.
         2408  +            </summary>
         2409  +        </member>
         2410  +        <member name="M:System.Data.SQLite.SQLiteCommand.ExecuteNonQuery">
         2411  +            <summary>
         2412  +            Execute the command and return the number of rows inserted/updated affected by it.
         2413  +            </summary>
         2414  +            <returns></returns>
         2415  +        </member>
         2416  +        <member name="M:System.Data.SQLite.SQLiteCommand.ExecuteScalar">
         2417  +            <summary>
         2418  +            Execute the command and return the first column of the first row of the resultset
         2419  +            (if present), or null if no resultset was returned.
         2420  +            </summary>
         2421  +            <returns>The first column of the first row of the first resultset from the query</returns>
         2422  +        </member>
         2423  +        <member name="M:System.Data.SQLite.SQLiteCommand.Prepare">
         2424  +            <summary>
         2425  +            Does nothing.  Commands are prepared as they are executed the first time, and kept in prepared state afterwards.
         2426  +            </summary>
         2427  +        </member>
         2428  +        <member name="M:System.Data.SQLite.SQLiteCommand.Clone">
         2429  +            <summary>
         2430  +            Clones a command, including all its parameters
         2431  +            </summary>
         2432  +            <returns>A new SQLiteCommand with the same commandtext, connection and parameters</returns>
         2433  +        </member>
         2434  +        <member name="P:System.Data.SQLite.SQLiteCommand.CommandText">
         2435  +            <summary>
         2436  +            The SQL command text associated with the command
         2437  +            </summary>
         2438  +        </member>
         2439  +        <member name="P:System.Data.SQLite.SQLiteCommand.CommandTimeout">
         2440  +            <summary>
         2441  +            The amount of time to wait for the connection to become available before erroring out
         2442  +            </summary>
         2443  +        </member>
         2444  +        <member name="P:System.Data.SQLite.SQLiteCommand.CommandType">
         2445  +            <summary>
         2446  +            The type of the command.  SQLite only supports CommandType.Text
         2447  +            </summary>
         2448  +        </member>
         2449  +        <member name="P:System.Data.SQLite.SQLiteCommand.Connection">
         2450  +            <summary>
         2451  +            The connection associated with this command
         2452  +            </summary>
         2453  +        </member>
         2454  +        <member name="P:System.Data.SQLite.SQLiteCommand.DbConnection">
         2455  +            <summary>
         2456  +            Forwards to the local Connection property
         2457  +            </summary>
         2458  +        </member>
         2459  +        <member name="P:System.Data.SQLite.SQLiteCommand.Parameters">
         2460  +            <summary>
         2461  +            Returns the SQLiteParameterCollection for the given command
         2462  +            </summary>
         2463  +        </member>
         2464  +        <member name="P:System.Data.SQLite.SQLiteCommand.DbParameterCollection">
         2465  +            <summary>
         2466  +            Forwards to the local Parameters property
         2467  +            </summary>
         2468  +        </member>
         2469  +        <member name="P:System.Data.SQLite.SQLiteCommand.Transaction">
         2470  +            <summary>
         2471  +            The transaction associated with this command.  SQLite only supports one transaction per connection, so this property forwards to the
         2472  +            command's underlying connection.
         2473  +            </summary>
         2474  +        </member>
         2475  +        <member name="P:System.Data.SQLite.SQLiteCommand.DbTransaction">
         2476  +            <summary>
         2477  +            Forwards to the local Transaction property
         2478  +            </summary>
         2479  +        </member>
         2480  +        <member name="P:System.Data.SQLite.SQLiteCommand.UpdatedRowSource">
         2481  +            <summary>
         2482  +            Sets the method the SQLiteCommandBuilder uses to determine how to update inserted or updated rows in a DataTable.
         2483  +            </summary>
         2484  +        </member>
         2485  +        <member name="P:System.Data.SQLite.SQLiteCommand.DesignTimeVisible">
         2486  +            <summary>
         2487  +            Determines if the command is visible at design time.  Defaults to True.
         2488  +            </summary>
         2489  +        </member>
         2490  +        <member name="T:System.Data.SQLite.SQLiteBase">
         2491  +            <summary>
         2492  +            This internal class provides the foundation of SQLite support.  It defines all the abstract members needed to implement
         2493  +            a SQLite data provider, and inherits from SQLiteConvert which allows for simple translations of string to and from SQLite.
         2494  +            </summary>
         2495  +        </member>
         2496  +        <member name="M:System.Data.SQLite.SQLiteBase.Open(System.String,System.Data.SQLite.SQLiteOpenFlagsEnum,System.Int32,System.Boolean)">
         2497  +            <summary>
         2498  +            Opens a database.
         2499  +            </summary>
         2500  +            <remarks>
         2501  +            Implementers should call SQLiteFunction.BindFunctions() and save the array after opening a connection
         2502  +            to bind all attributed user-defined functions and collating sequences to the new connection.
         2503  +            </remarks>
         2504  +            <param name="strFilename">The filename of the database to open.  SQLite automatically creates it if it doesn't exist.</param>
         2505  +            <param name="flags">The open flags to use when creating the connection</param>
         2506  +            <param name="maxPoolSize">The maximum size of the pool for the given filename</param>
         2507  +            <param name="usePool">If true, the connection can be pulled from the connection pool</param>
         2508  +        </member>
         2509  +        <member name="M:System.Data.SQLite.SQLiteBase.Close">
         2510  +            <summary>
         2511  +            Closes the currently-open database.
         2512  +            </summary>
         2513  +            <remarks>
         2514  +            After the database has been closed implemeters should call SQLiteFunction.UnbindFunctions() to deallocate all interop allocated
         2515  +            memory associated with the user-defined functions and collating sequences tied to the closed connection.
         2516  +            </remarks>
         2517  +        </member>
         2518  +        <member name="M:System.Data.SQLite.SQLiteBase.SetTimeout(System.Int32)">
         2519  +            <summary>
         2520  +            Sets the busy timeout on the connection.  SQLiteCommand will call this before executing any command.
         2521  +            </summary>
         2522  +            <param name="nTimeoutMS">The number of milliseconds to wait before returning SQLITE_BUSY</param>
         2523  +        </member>
         2524  +        <member name="M:System.Data.SQLite.SQLiteBase.SQLiteLastError">
         2525  +            <summary>
         2526  +            Returns the text of the last error issued by SQLite
         2527  +            </summary>
         2528  +            <returns></returns>
         2529  +        </member>
         2530  +        <member name="M:System.Data.SQLite.SQLiteBase.ClearPool">
         2531  +            <summary>
         2532  +            When pooling is enabled, force this connection to be disposed rather than returned to the pool
         2533  +            </summary>
         2534  +        </member>
         2535  +        <member name="M:System.Data.SQLite.SQLiteBase.Prepare(System.Data.SQLite.SQLiteConnection,System.String,System.Data.SQLite.SQLiteStatement,System.UInt32,System.String@)">
         2536  +            <summary>
         2537  +            Prepares a SQL statement for execution.
         2538  +            </summary>
         2539  +            <param name="cnn">The source connection preparing the command.  Can be null for any caller except LINQ</param>
         2540  +            <param name="strSql">The SQL command text to prepare</param>
         2541  +            <param name="previous">The previous statement in a multi-statement command, or null if no previous statement exists</param>
         2542  +            <param name="timeoutMS">The timeout to wait before aborting the prepare</param>
         2543  +            <param name="strRemain">The remainder of the statement that was not processed.  Each call to prepare parses the
         2544  +            SQL up to to either the end of the text or to the first semi-colon delimiter.  The remaining text is returned
         2545  +            here for a subsequent call to Prepare() until all the text has been processed.</param>
         2546  +            <returns>Returns an initialized SQLiteStatement.</returns>
         2547  +        </member>
         2548  +        <member name="M:System.Data.SQLite.SQLiteBase.Step(System.Data.SQLite.SQLiteStatement)">
         2549  +            <summary>
         2550  +            Steps through a prepared statement.
         2551  +            </summary>
         2552  +            <param name="stmt">The SQLiteStatement to step through</param>
         2553  +            <returns>True if a row was returned, False if not.</returns>
         2554  +        </member>
         2555  +        <member name="M:System.Data.SQLite.SQLiteBase.Reset(System.Data.SQLite.SQLiteStatement)">
         2556  +            <summary>
         2557  +            Resets a prepared statement so it can be executed again.  If the error returned is SQLITE_SCHEMA, 
         2558  +            transparently attempt to rebuild the SQL statement and throw an error if that was not possible.
         2559  +            </summary>
         2560  +            <param name="stmt">The statement to reset</param>
         2561  +            <returns>Returns -1 if the schema changed while resetting, 0 if the reset was sucessful or 6 (SQLITE_LOCKED) if the reset failed due to a lock</returns>
         2562  +        </member>
         2563  +        <member name="P:System.Data.SQLite.SQLiteBase.Version">
         2564  +            <summary>
         2565  +            Returns a string representing the active version of SQLite
         2566  +            </summary>
         2567  +        </member>
         2568  +        <member name="P:System.Data.SQLite.SQLiteBase.Changes">
         2569  +            <summary>
         2570  +            Returns the number of changes the last executing insert/update caused.
         2571  +            </summary>
         2572  +        </member>
         2573  +        <member name="T:System.Data.SQLite.SQLiteConnectionStringBuilder">
         2574  +            <summary>
         2575  +            SQLite implementation of DbConnectionStringBuilder.
         2576  +            </summary>
         2577  +        </member>
         2578  +        <member name="F:System.Data.SQLite.SQLiteConnectionStringBuilder._properties">
         2579  +            <summary>
         2580  +            Properties of this class
         2581  +            </summary>
         2582  +        </member>
         2583  +        <member name="M:System.Data.SQLite.SQLiteConnectionStringBuilder.#ctor">
         2584  +            <overloads>
         2585  +            Constructs a new instance of the class
         2586  +            </overloads>
         2587  +            <summary>
         2588  +            Default constructor
         2589  +            </summary>
         2590  +        </member>
         2591  +        <member name="M:System.Data.SQLite.SQLiteConnectionStringBuilder.#ctor(System.String)">
         2592  +            <summary>
         2593  +            Constructs a new instance of the class using the specified connection string.
         2594  +            </summary>
         2595  +            <param name="connectionString">The connection string to parse</param>
         2596  +        </member>
         2597  +        <member name="M:System.Data.SQLite.SQLiteConnectionStringBuilder.Initialize(System.String)">
         2598  +            <summary>
         2599  +            Private initializer, which assigns the connection string and resets the builder
         2600  +            </summary>
         2601  +            <param name="cnnString">The connection string to assign</param>
         2602  +        </member>
         2603  +        <member name="M:System.Data.SQLite.SQLiteConnectionStringBuilder.TryGetValue(System.String,System.Object@)">
         2604  +            <summary>
         2605  +            Helper function for retrieving values from the connectionstring
         2606  +            </summary>
         2607  +            <param name="keyword">The keyword to retrieve settings for</param>
         2608  +            <param name="value">The resulting parameter value</param>
         2609  +            <returns>Returns true if the value was found and returned</returns>
         2610  +        </member>
         2611  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.Version">
         2612  +            <summary>
         2613  +            Gets/Sets the default version of the SQLite engine to instantiate.  Currently the only valid value is 3, indicating version 3 of the sqlite library.
         2614  +            </summary>
         2615  +        </member>
         2616  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.SyncMode">
         2617  +            <summary>
         2618  +            Gets/Sets the synchronous mode of the connection string.  Default is "Normal".
         2619  +            </summary>
         2620  +        </member>
         2621  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.UseUTF16Encoding">
         2622  +            <summary>
         2623  +            Gets/Sets the encoding for the connection string.  The default is "False" which indicates UTF-8 encoding.
         2624  +            </summary>
         2625  +        </member>
         2626  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.Pooling">
         2627  +            <summary>
         2628  +            Gets/Sets whether or not to use connection pooling.  The default is "False"
         2629  +            </summary>
         2630  +        </member>
         2631  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.BinaryGUID">
         2632  +            <summary>
         2633  +            Gets/Sets whethor not to store GUID's in binary format.  The default is True
         2634  +            which saves space in the database.
         2635  +            </summary>
         2636  +        </member>
         2637  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.DataSource">
         2638  +            <summary>
         2639  +            Gets/Sets the filename to open on the connection string.
         2640  +            </summary>
         2641  +        </member>
         2642  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.Uri">
         2643  +            <summary>
         2644  +            An alternate to the data source property
         2645  +            </summary>
         2646  +        </member>
         2647  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.DefaultTimeout">
         2648  +            <summary>
         2649  +            Gets/sets the default command timeout for newly-created commands.  This is especially useful for 
         2650  +            commands used internally such as inside a SQLiteTransaction, where setting the timeout is not possible.
         2651  +            </summary>
         2652  +        </member>
         2653  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.Enlist">
         2654  +            <summary>
         2655  +            Determines whether or not the connection will automatically participate
         2656  +            in the current distributed transaction (if one exists)
         2657  +            </summary>
         2658  +        </member>
         2659  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.FailIfMissing">
         2660  +            <summary>
         2661  +            If set to true, will throw an exception if the database specified in the connection
         2662  +            string does not exist.  If false, the database will be created automatically.
         2663  +            </summary>
         2664  +        </member>
         2665  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.LegacyFormat">
         2666  +            <summary>
         2667  +            If enabled, uses the legacy 3.xx format for maximum compatibility, but results in larger
         2668  +            database sizes.
         2669  +            </summary>
         2670  +        </member>
         2671  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.ReadOnly">
         2672  +            <summary>
         2673  +            When enabled, the database will be opened for read-only access and writing will be disabled.
         2674  +            </summary>
         2675  +        </member>
         2676  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.Password">
         2677  +            <summary>
         2678  +            Gets/sets the database encryption password
         2679  +            </summary>
         2680  +        </member>
         2681  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.PageSize">
         2682  +            <summary>
         2683  +            Gets/Sets the page size for the connection.
         2684  +            </summary>
         2685  +        </member>
         2686  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.MaxPageCount">
         2687  +            <summary>
         2688  +            Gets/Sets the maximum number of pages the database may hold
         2689  +            </summary>
         2690  +        </member>
         2691  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.CacheSize">
         2692  +            <summary>
         2693  +            Gets/Sets the cache size for the connection.
         2694  +            </summary>
         2695  +        </member>
         2696  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.DateTimeFormat">
         2697  +            <summary>
         2698  +            Gets/Sets the datetime format for the connection.
         2699  +            </summary>
         2700  +        </member>
         2701  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.JournalMode">
         2702  +            <summary>
         2703  +            Determines how SQLite handles the transaction journal file.
         2704  +            </summary>
         2705  +        </member>
         2706  +        <member name="P:System.Data.SQLite.SQLiteConnectionStringBuilder.DefaultIsolationLevel">
         2707  +            <summary>
         2708  +            Sets the default isolation level for transactions on the connection.
         2709  +            </summary>
         2710  +        </member>
         2711  +        <member name="T:System.Data.SQLite.SQLite3">
         2712  +            <summary>
         2713  +            This class implements SQLiteBase completely, and is the guts of the code that interop's SQLite with .NET
         2714  +            </summary>
         2715  +        </member>
         2716  +        <member name="F:System.Data.SQLite.SQLite3._sql">
         2717  +            <summary>
         2718  +            The opaque pointer returned to us by the sqlite provider
         2719  +            </summary>
         2720  +        </member>
         2721  +        <member name="F:System.Data.SQLite.SQLite3._functionsArray">
         2722  +            <summary>
         2723  +            The user-defined functions registered on this connection
         2724  +            </summary>
         2725  +        </member>
         2726  +        <member name="M:System.Data.SQLite.SQLite3.GetValue(System.Data.SQLite.SQLiteStatement,System.Int32,System.Data.SQLite.SQLiteType)">
         2727  +            <summary>
         2728  +            Helper function to retrieve a column of data from an active statement.
         2729  +            </summary>
         2730  +            <param name="stmt">The statement being step()'d through</param>
         2731  +            <param name="index">The column index to retrieve</param>
         2732  +            <param name="typ">The type of data contained in the column.  If Uninitialized, this function will retrieve the datatype information.</param>
         2733  +            <returns>Returns the data in the column</returns>
         2734  +        </member>
         2735  +        <member name="T:System.Data.SQLite.SQLiteParameterCollection">
         2736  +            <summary>
         2737  +            SQLite implementation of DbParameterCollection.
         2738  +            </summary>
         2739  +        </member>
         2740  +        <member name="F:System.Data.SQLite.SQLiteParameterCollection._command">
         2741  +            <summary>
         2742  +            The underlying command to which this collection belongs
         2743  +            </summary>
         2744  +        </member>
         2745  +        <member name="F:System.Data.SQLite.SQLiteParameterCollection._parameterList">
         2746  +            <summary>
         2747  +            The internal array of parameters in this collection
         2748  +            </summary>
         2749  +        </member>
         2750  +        <member name="F:System.Data.SQLite.SQLiteParameterCollection._unboundFlag">
         2751  +            <summary>
         2752  +            Determines whether or not all parameters have been bound to their statement(s)
         2753  +            </summary>
         2754  +        </member>
         2755  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.#ctor(System.Data.SQLite.SQLiteCommand)">
         2756  +            <summary>
         2757  +            Initializes the collection
         2758  +            </summary>
         2759  +            <param name="cmd">The command to which the collection belongs</param>
         2760  +        </member>
         2761  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.GetEnumerator">
         2762  +            <summary>
         2763  +            Retrieves an enumerator for the collection
         2764  +            </summary>
         2765  +            <returns>An enumerator for the underlying array</returns>
         2766  +        </member>
         2767  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Add(System.String,System.Data.DbType,System.Int32,System.String)">
         2768  +            <summary>
         2769  +            Adds a parameter to the collection
         2770  +            </summary>
         2771  +            <param name="parameterName">The parameter name</param>
         2772  +            <param name="parameterType">The data type</param>
         2773  +            <param name="parameterSize">The size of the value</param>
         2774  +            <param name="sourceColumn">The source column</param>
         2775  +            <returns>A SQLiteParameter object</returns>
         2776  +        </member>
         2777  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Add(System.String,System.Data.DbType,System.Int32)">
         2778  +            <summary>
         2779  +            Adds a parameter to the collection
         2780  +            </summary>
         2781  +            <param name="parameterName">The parameter name</param>
         2782  +            <param name="parameterType">The data type</param>
         2783  +            <param name="parameterSize">The size of the value</param>
         2784  +            <returns>A SQLiteParameter object</returns>
         2785  +        </member>
         2786  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Add(System.String,System.Data.DbType)">
         2787  +            <summary>
         2788  +            Adds a parameter to the collection
         2789  +            </summary>
         2790  +            <param name="parameterName">The parameter name</param>
         2791  +            <param name="parameterType">The data type</param>
         2792  +            <returns>A SQLiteParameter object</returns>
         2793  +        </member>
         2794  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Add(System.Data.SQLite.SQLiteParameter)">
         2795  +            <summary>
         2796  +            Adds a parameter to the collection
         2797  +            </summary>
         2798  +            <param name="parameter">The parameter to add</param>
         2799  +            <returns>A zero-based index of where the parameter is located in the array</returns>
         2800  +        </member>
         2801  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Add(System.Object)">
         2802  +            <summary>
         2803  +            Adds a parameter to the collection
         2804  +            </summary>
         2805  +            <param name="value">The parameter to add</param>
         2806  +            <returns>A zero-based index of where the parameter is located in the array</returns>
         2807  +        </member>
         2808  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.AddWithValue(System.String,System.Object)">
         2809  +            <summary>
         2810  +            Adds a named/unnamed parameter and its value to the parameter collection.
         2811  +            </summary>
         2812  +            <param name="parameterName">Name of the parameter, or null to indicate an unnamed parameter</param>
         2813  +            <param name="value">The initial value of the parameter</param>
         2814  +            <returns>Returns the SQLiteParameter object created during the call.</returns>
         2815  +        </member>
         2816  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.AddRange(System.Data.SQLite.SQLiteParameter[])">
         2817  +            <summary>
         2818  +            Adds an array of parameters to the collection
         2819  +            </summary>
         2820  +            <param name="values">The array of parameters to add</param>
         2821  +        </member>
         2822  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.AddRange(System.Array)">
         2823  +            <summary>
         2824  +            Adds an array of parameters to the collection
         2825  +            </summary>
         2826  +            <param name="values">The array of parameters to add</param>
         2827  +        </member>
         2828  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Clear">
         2829  +            <summary>
         2830  +            Clears the array and resets the collection
         2831  +            </summary>
         2832  +        </member>
         2833  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Contains(System.String)">
         2834  +            <summary>
         2835  +            Determines if the named parameter exists in the collection
         2836  +            </summary>
         2837  +            <param name="parameterName">The name of the parameter to check</param>
         2838  +            <returns>True if the parameter is in the collection</returns>
         2839  +        </member>
         2840  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Contains(System.Object)">
         2841  +            <summary>
         2842  +            Determines if the parameter exists in the collection
         2843  +            </summary>
         2844  +            <param name="value">The SQLiteParameter to check</param>
         2845  +            <returns>True if the parameter is in the collection</returns>
         2846  +        </member>
         2847  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.CopyTo(System.Array,System.Int32)">
         2848  +            <summary>
         2849  +            Not implemented
         2850  +            </summary>
         2851  +            <param name="array"></param>
         2852  +            <param name="index"></param>
         2853  +        </member>
         2854  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.GetParameter(System.String)">
         2855  +            <summary>
         2856  +            Retrieve a parameter by name from the collection
         2857  +            </summary>
         2858  +            <param name="parameterName">The name of the parameter to fetch</param>
         2859  +            <returns>A DbParameter object</returns>
         2860  +        </member>
         2861  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.GetParameter(System.Int32)">
         2862  +            <summary>
         2863  +            Retrieves a parameter by its index in the collection
         2864  +            </summary>
         2865  +            <param name="index">The index of the parameter to retrieve</param>
         2866  +            <returns>A DbParameter object</returns>
         2867  +        </member>
         2868  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.IndexOf(System.String)">
         2869  +            <summary>
         2870  +            Returns the index of a parameter given its name
         2871  +            </summary>
         2872  +            <param name="parameterName">The name of the parameter to find</param>
         2873  +            <returns>-1 if not found, otherwise a zero-based index of the parameter</returns>
         2874  +        </member>
         2875  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.IndexOf(System.Object)">
         2876  +            <summary>
         2877  +            Returns the index of a parameter
         2878  +            </summary>
         2879  +            <param name="value">The parameter to find</param>
         2880  +            <returns>-1 if not found, otherwise a zero-based index of the parameter</returns>
         2881  +        </member>
         2882  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Insert(System.Int32,System.Object)">
         2883  +            <summary>
         2884  +            Inserts a parameter into the array at the specified location
         2885  +            </summary>
         2886  +            <param name="index">The zero-based index to insert the parameter at</param>
         2887  +            <param name="value">The parameter to insert</param>
         2888  +        </member>
         2889  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Remove(System.Object)">
         2890  +            <summary>
         2891  +            Removes a parameter from the collection
         2892  +            </summary>
         2893  +            <param name="value">The parameter to remove</param>
         2894  +        </member>
         2895  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.RemoveAt(System.String)">
         2896  +            <summary>
         2897  +            Removes a parameter from the collection given its name
         2898  +            </summary>
         2899  +            <param name="parameterName">The name of the parameter to remove</param>
         2900  +        </member>
         2901  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.RemoveAt(System.Int32)">
         2902  +            <summary>
         2903  +            Removes a parameter from the collection given its index
         2904  +            </summary>
         2905  +            <param name="index">The zero-based parameter index to remove</param>
         2906  +        </member>
         2907  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.SetParameter(System.String,System.Data.Common.DbParameter)">
         2908  +            <summary>
         2909  +            Re-assign the named parameter to a new parameter object
         2910  +            </summary>
         2911  +            <param name="parameterName">The name of the parameter to replace</param>
         2912  +            <param name="value">The new parameter</param>
         2913  +        </member>
         2914  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.SetParameter(System.Int32,System.Data.Common.DbParameter)">
         2915  +            <summary>
         2916  +            Re-assign a parameter at the specified index
         2917  +            </summary>
         2918  +            <param name="index">The zero-based index of the parameter to replace</param>
         2919  +            <param name="value">The new parameter</param>
         2920  +        </member>
         2921  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.Unbind">
         2922  +            <summary>
         2923  +            Un-binds all parameters from their statements
         2924  +            </summary>
         2925  +        </member>
         2926  +        <member name="M:System.Data.SQLite.SQLiteParameterCollection.MapParameters(System.Data.SQLite.SQLiteStatement)">
         2927  +            <summary>
         2928  +            This function attempts to map all parameters in the collection to all statements in a Command.
         2929  +            Since named parameters may span multiple statements, this function makes sure all statements are bound
         2930  +            to the same named parameter.  Unnamed parameters are bound in sequence.
         2931  +            </summary>
         2932  +        </member>
         2933  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.IsSynchronized">
         2934  +            <summary>
         2935  +            Returns true
         2936  +            </summary>
         2937  +        </member>
         2938  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.IsFixedSize">
         2939  +            <summary>
         2940  +            Returns false
         2941  +            </summary>
         2942  +        </member>
         2943  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.IsReadOnly">
         2944  +            <summary>
         2945  +            Returns false
         2946  +            </summary>
         2947  +        </member>
         2948  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.SyncRoot">
         2949  +            <summary>
         2950  +            Returns null
         2951  +            </summary>
         2952  +        </member>
         2953  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.Count">
         2954  +            <summary>
         2955  +            Returns a count of parameters in the collection
         2956  +            </summary>
         2957  +        </member>
         2958  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.Item(System.String)">
         2959  +            <summary>
         2960  +            Overloaded to specialize the return value of the default indexer
         2961  +            </summary>
         2962  +            <param name="parameterName">Name of the parameter to get/set</param>
         2963  +            <returns>The specified named SQLite parameter</returns>
         2964  +        </member>
         2965  +        <member name="P:System.Data.SQLite.SQLiteParameterCollection.Item(System.Int32)">
         2966  +            <summary>
         2967  +            Overloaded to specialize the return value of the default indexer
         2968  +            </summary>
         2969  +            <param name="index">The index of the parameter to get/set</param>
         2970  +            <returns>The specified SQLite parameter</returns>
         2971  +        </member>
         2972  +        <member name="T:System.Data.SQLite.SQLite3_UTF16">
         2973  +            <summary>
         2974  +            Alternate SQLite3 object, overriding many text behaviors to support UTF-16 (Unicode)
         2975  +            </summary>
         2976  +        </member>
         2977  +        <member name="M:System.Data.SQLite.SQLite3_UTF16.ToString(System.IntPtr,System.Int32)">
         2978  +            <summary>
         2979  +            Overrides SQLiteConvert.ToString() to marshal UTF-16 strings instead of UTF-8
         2980  +            </summary>
         2981  +            <param name="b">A pointer to a UTF-16 string</param>
         2982  +            <param name="nbytelen">The length (IN BYTES) of the string</param>
         2983  +            <returns>A .NET string</returns>
         2984  +        </member>
         2985  +        <member name="T:System.Data.SQLite.SQLiteFactory">
         2986  +            <summary>
         2987  +            SQLite implementation of DbProviderFactory.
         2988  +            </summary>
         2989  +            <summary>
         2990  +            SQLite implementation of DbProviderFactory.
         2991  +            </summary>
         2992  +        </member>
         2993  +        <member name="M:System.Data.SQLite.SQLiteFactory.System#IServiceProvider#GetService(System.Type)">
         2994  +            <summary>
         2995  +            Will provide a DbProviderServices object in .NET 3.5
         2996  +            </summary>
         2997  +            <param name="serviceType">The class or interface type to query for</param>
         2998  +            <returns></returns>
         2999  +        </member>
         3000  +        <member name="F:System.Data.SQLite.SQLiteFactory.Instance">
         3001  +            <summary>
         3002  +            Static instance member which returns an instanced SQLiteFactory class.
         3003  +            </summary>
         3004  +        </member>
         3005  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateCommand">
         3006  +            <summary>
         3007  +            Returns a new SQLiteCommand object.
         3008  +            </summary>
         3009  +            <returns>A SQLiteCommand object.</returns>
         3010  +        </member>
         3011  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateCommandBuilder">
         3012  +            <summary>
         3013  +            Returns a new SQLiteCommandBuilder object.
         3014  +            </summary>
         3015  +            <returns>A SQLiteCommandBuilder object.</returns>
         3016  +        </member>
         3017  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateConnection">
         3018  +            <summary>
         3019  +            Creates a new SQLiteConnection.
         3020  +            </summary>
         3021  +            <returns>A SQLiteConnection object.</returns>
         3022  +        </member>
         3023  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateConnectionStringBuilder">
         3024  +            <summary>
         3025  +            Creates a new SQLiteConnectionStringBuilder.
         3026  +            </summary>
         3027  +            <returns>A SQLiteConnectionStringBuilder object.</returns>
         3028  +        </member>
         3029  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateDataAdapter">
         3030  +            <summary>
         3031  +            Creates a new SQLiteDataAdapter.
         3032  +            </summary>
         3033  +            <returns>A SQLiteDataAdapter object.</returns>
         3034  +        </member>
         3035  +        <member name="M:System.Data.SQLite.SQLiteFactory.CreateParameter">
         3036  +            <summary>
         3037  +            Creates a new SQLiteParameter.
         3038  +            </summary>
         3039  +            <returns>A SQLiteParameter object.</returns>
         3040  +        </member>
         3041  +        <member name="T:System.Data.SQLite.SR">
         3042  +            <summary>
         3043  +              A strongly-typed resource class, for looking up localized strings, etc.
         3044  +            </summary>
         3045  +        </member>
         3046  +        <member name="P:System.Data.SQLite.SR.ResourceManager">
         3047  +            <summary>
         3048  +              Returns the cached ResourceManager instance used by this class.
         3049  +            </summary>
         3050  +        </member>
         3051  +        <member name="P:System.Data.SQLite.SR.Culture">
         3052  +            <summary>
         3053  +              Overrides the current thread's CurrentUICulture property for all
         3054  +              resource lookups using this strongly typed resource class.
         3055  +            </summary>
         3056  +        </member>
         3057  +        <member name="P:System.Data.SQLite.SR.DataTypes">
         3058  +             <summary>
         3059  +               Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; standalone=&quot;yes&quot;?&gt;
         3060  +            &lt;DocumentElement&gt;
         3061  +              &lt;DataTypes&gt;
         3062  +                &lt;TypeName&gt;smallint&lt;/TypeName&gt;
         3063  +                &lt;ProviderDbType&gt;10&lt;/ProviderDbType&gt;
         3064  +                &lt;ColumnSize&gt;5&lt;/ColumnSize&gt;
         3065  +                &lt;DataType&gt;System.Int16&lt;/DataType&gt;
         3066  +                &lt;CreateFormat&gt;smallint&lt;/CreateFormat&gt;
         3067  +                &lt;IsAutoIncrementable&gt;false&lt;/IsAutoIncrementable&gt;
         3068  +                &lt;IsCaseSensitive&gt;false&lt;/IsCaseSensitive&gt;
         3069  +                &lt;IsFixedLength&gt;true&lt;/IsFixedLength&gt;
         3070  +                &lt;IsFixedPrecisionScale&gt;true&lt;/IsFixedPrecisionScale&gt;
         3071  +                &lt;IsLong&gt;false&lt;/IsLong&gt;
         3072  +                &lt;IsNullable&gt;true&lt;/ [rest of string was truncated]&quot;;.
         3073  +             </summary>
         3074  +        </member>
         3075  +        <member name="P:System.Data.SQLite.SR.Keywords">
         3076  +            <summary>
         3077  +              Looks up a localized string similar to ALL,ALTER,AND,AS,AUTOINCREMENT,BETWEEN,BY,CASE,CHECK,COLLATE,COMMIT,CONSTRAINT,CREATE,CROSS,DEFAULT,DEFERRABLE,DELETE,DISTINCT,DROP,ELSE,ESCAPE,EXCEPT,FOREIGN,FROM,FULL,GROUP,HAVING,IN,INDEX,INNER,INSERT,INTERSECT,INTO,IS,ISNULL,JOIN,LEFT,LIMIT,NATURAL,NOT,NOTNULL,NULL,ON,OR,ORDER,OUTER,PRIMARY,REFERENCES,RIGHT,ROLLBACK,SELECT,SET,TABLE,THEN,TO,TRANSACTION,UNION,UNIQUE,UPDATE,USING,VALUES,WHEN,WHERE.
         3078  +            </summary>
         3079  +        </member>
         3080  +        <member name="P:System.Data.SQLite.SR.MetaDataCollections">
         3081  +             <summary>
         3082  +               Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot; ?&gt;
         3083  +            &lt;DocumentElement&gt;
         3084  +              &lt;MetaDataCollections&gt;
         3085  +                &lt;CollectionName&gt;MetaDataCollections&lt;/CollectionName&gt;
         3086  +                &lt;NumberOfRestrictions&gt;0&lt;/NumberOfRestrictions&gt;
         3087  +                &lt;NumberOfIdentifierParts&gt;0&lt;/NumberOfIdentifierParts&gt;
         3088  +              &lt;/MetaDataCollections&gt;
         3089  +              &lt;MetaDataCollections&gt;
         3090  +                &lt;CollectionName&gt;DataSourceInformation&lt;/CollectionName&gt;
         3091  +                &lt;NumberOfRestrictions&gt;0&lt;/NumberOfRestrictions&gt;
         3092  +                &lt;NumberOfIdentifierParts&gt;0&lt;/NumberOfIdentifierParts&gt;
         3093  +              &lt;/MetaDataCollections&gt;
         3094  +              &lt;MetaDataC [rest of string was truncated]&quot;;.
         3095  +             </summary>
         3096  +        </member>
         3097  +        <member name="T:System.Data.SQLite.SQLiteException">
         3098  +            <summary>
         3099  +            SQLite exception class.
         3100  +            </summary>
         3101  +        </member>
         3102  +        <member name="M:System.Data.SQLite.SQLiteException.#ctor(System.Int32,System.String)">
         3103  +            <summary>
         3104  +            Public constructor for generating a SQLite error given the base error code
         3105  +            </summary>
         3106  +            <param name="errorCode">The SQLite error code to report</param>
         3107  +            <param name="extendedInformation">Extra text to go along with the error message text</param>
         3108  +        </member>
         3109  +        <member name="M:System.Data.SQLite.SQLiteException.#ctor(System.String)">
         3110  +            <summary>
         3111  +            Various public constructors that just pass along to the base Exception
         3112  +            </summary>
         3113  +            <param name="message">Passed verbatim to Exception</param>
         3114  +        </member>
         3115  +        <member name="M:System.Data.SQLite.SQLiteException.#ctor">
         3116  +            <summary>
         3117  +            Various public constructors that just pass along to the base Exception
         3118  +            </summary>
         3119  +        </member>
         3120  +        <member name="M:System.Data.SQLite.SQLiteException.#ctor(System.String,System.Exception)">
         3121  +            <summary>
         3122  +            Various public constructors that just pass along to the base Exception
         3123  +            <param name="message">Passed to Exception</param>
         3124  +            <param name="innerException">Passed to Exception</param>
         3125  +            </summary>
         3126  +        </member>
         3127  +        <member name="M:System.Data.SQLite.SQLiteException.GetStockErrorMessage(System.Int32,System.String)">
         3128  +            <summary>
         3129  +            Initializes the exception class with the SQLite error code.
         3130  +            </summary>
         3131  +            <param name="errorCode">The SQLite error code</param>
         3132  +            <param name="errorMessage">A detailed error message</param>
         3133  +            <returns>An error message string</returns>
         3134  +        </member>
         3135  +        <member name="P:System.Data.SQLite.SQLiteException.ErrorCode">
         3136  +            <summary>
         3137  +            Retrieves the underlying SQLite error code for this exception
         3138  +            </summary>
         3139  +        </member>
         3140  +        <member name="T:System.Data.SQLite.SQLiteErrorCode">
         3141  +            <summary>
         3142  +            SQLite error codes
         3143  +            </summary>
         3144  +        </member>
         3145  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Ok">
         3146  +            <summary>
         3147  +            Success
         3148  +            </summary>
         3149  +        </member>
         3150  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Error">
         3151  +            <summary>
         3152  +            SQL error or missing database
         3153  +            </summary>
         3154  +        </member>
         3155  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Internal">
         3156  +            <summary>
         3157  +            Internal logic error in SQLite
         3158  +            </summary>
         3159  +        </member>
         3160  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Perm">
         3161  +            <summary>
         3162  +            Access permission denied
         3163  +            </summary>
         3164  +        </member>
         3165  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Abort">
         3166  +            <summary>
         3167  +            Callback routine requested an abort
         3168  +            </summary>
         3169  +        </member>
         3170  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Busy">
         3171  +            <summary>
         3172  +            The database file is locked
         3173  +            </summary>
         3174  +        </member>
         3175  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Locked">
         3176  +            <summary>
         3177  +            A table in the database is locked
         3178  +            </summary>
         3179  +        </member>
         3180  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.NoMem">
         3181  +            <summary>
         3182  +            malloc() failed
         3183  +            </summary>
         3184  +        </member>
         3185  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.ReadOnly">
         3186  +            <summary>
         3187  +            Attempt to write a read-only database
         3188  +            </summary>
         3189  +        </member>
         3190  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Interrupt">
         3191  +            <summary>
         3192  +            Operation terminated by sqlite3_interrupt()
         3193  +            </summary>
         3194  +        </member>
         3195  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.IOErr">
         3196  +            <summary>
         3197  +            Some kind of disk I/O error occurred
         3198  +            </summary>
         3199  +        </member>
         3200  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Corrupt">
         3201  +            <summary>
         3202  +            The database disk image is malformed
         3203  +            </summary>
         3204  +        </member>
         3205  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.NotFound">
         3206  +            <summary>
         3207  +            Table or record not found
         3208  +            </summary>
         3209  +        </member>
         3210  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Full">
         3211  +            <summary>
         3212  +            Insertion failed because database is full
         3213  +            </summary>
         3214  +        </member>
         3215  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.CantOpen">
         3216  +            <summary>
         3217  +            Unable to open the database file
         3218  +            </summary>
         3219  +        </member>
         3220  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Protocol">
         3221  +            <summary>
         3222  +            Database lock protocol error
         3223  +            </summary>
         3224  +        </member>
         3225  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Empty">
         3226  +            <summary>
         3227  +            Database is empty
         3228  +            </summary>
         3229  +        </member>
         3230  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Schema">
         3231  +            <summary>
         3232  +            The database schema changed
         3233  +            </summary>
         3234  +        </member>
         3235  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.TooBig">
         3236  +            <summary>
         3237  +            Too much data for one row of a table
         3238  +            </summary>
         3239  +        </member>
         3240  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Constraint">
         3241  +            <summary>
         3242  +            Abort due to constraint violation
         3243  +            </summary>
         3244  +        </member>
         3245  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Mismatch">
         3246  +            <summary>
         3247  +            Data type mismatch
         3248  +            </summary>
         3249  +        </member>
         3250  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Misuse">
         3251  +            <summary>
         3252  +            Library used incorrectly
         3253  +            </summary>
         3254  +        </member>
         3255  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.NOLFS">
         3256  +            <summary>
         3257  +            Uses OS features not supported on host
         3258  +            </summary>
         3259  +        </member>
         3260  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Auth">
         3261  +            <summary>
         3262  +            Authorization denied
         3263  +            </summary>
         3264  +        </member>
         3265  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Format">
         3266  +            <summary>
         3267  +            Auxiliary database format error
         3268  +            </summary>
         3269  +        </member>
         3270  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Range">
         3271  +            <summary>
         3272  +            2nd parameter to sqlite3_bind out of range
         3273  +            </summary>
         3274  +        </member>
         3275  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.NotADatabase">
         3276  +            <summary>
         3277  +            File opened that is not a database file
         3278  +            </summary>
         3279  +        </member>
         3280  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Row">
         3281  +            <summary>
         3282  +            sqlite3_step() has another row ready
         3283  +            </summary>
         3284  +        </member>
         3285  +        <member name="F:System.Data.SQLite.SQLiteErrorCode.Done">
         3286  +            <summary>
         3287  +            sqlite3_step() has finished executing
         3288  +            </summary>
         3289  +        </member>
         3290  +        <member name="T:System.Data.SQLite.SynchronizationModes">
         3291  +            <summary>
         3292  +            The I/O file cache flushing behavior for the connection
         3293  +            </summary>
         3294  +        </member>
         3295  +        <member name="F:System.Data.SQLite.SynchronizationModes.Normal">
         3296  +            <summary>
         3297  +            Normal file flushing at critical sections of the code
         3298  +            </summary>
         3299  +        </member>
         3300  +        <member name="F:System.Data.SQLite.SynchronizationModes.Full">
         3301  +            <summary>
         3302  +            Full file flushing after every write operation
         3303  +            </summary>
         3304  +        </member>
         3305  +        <member name="F:System.Data.SQLite.SynchronizationModes.Off">
         3306  +            <summary>
         3307  +            Use the default operating system's file flushing, SQLite does not explicitly flush the file buffers after writing
         3308  +            </summary>
         3309  +        </member>
         3310  +        <member name="T:System.Data.SQLite.SQLiteCommitHandler">
         3311  +            <summary>
         3312  +            Raised when a transaction is about to be committed.  To roll back a transaction, set the 
         3313  +            rollbackTrans boolean value to true.
         3314  +            </summary>
         3315  +            <param name="sender">The connection committing the transaction</param>
         3316  +            <param name="e">Event arguments on the transaction</param>
         3317  +        </member>
         3318  +        <member name="T:System.Data.SQLite.SQLiteUpdateEventHandler">
         3319  +            <summary>
         3320  +            Raised when data is inserted, updated and deleted on a given connection
         3321  +            </summary>
         3322  +            <param name="sender">The connection committing the transaction</param>
         3323  +            <param name="e">The event parameters which triggered the event</param>
         3324  +        </member>
         3325  +        <member name="T:System.Data.SQLite.UpdateEventType">
         3326  +            <summary>
         3327  +            Whenever an update event is triggered on a connection, this enum will indicate
         3328  +            exactly what type of operation is being performed.
         3329  +            </summary>
         3330  +        </member>
         3331  +        <member name="F:System.Data.SQLite.UpdateEventType.Delete">
         3332  +            <summary>
         3333  +            A row is being deleted from the given database and table
         3334  +            </summary>
         3335  +        </member>
         3336  +        <member name="F:System.Data.SQLite.UpdateEventType.Insert">
         3337  +            <summary>
         3338  +            A row is being inserted into the table.
         3339  +            </summary>
         3340  +        </member>
         3341  +        <member name="F:System.Data.SQLite.UpdateEventType.Update">
         3342  +            <summary>
         3343  +            A row is being updated in the table.
         3344  +            </summary>
         3345  +        </member>
         3346  +        <member name="T:System.Data.SQLite.UpdateEventArgs">
         3347  +            <summary>
         3348  +            Passed during an Update callback, these event arguments detail the type of update operation being performed
         3349  +            on the given connection.
         3350  +            </summary>
         3351  +        </member>
         3352  +        <member name="F:System.Data.SQLite.UpdateEventArgs.Database">
         3353  +            <summary>
         3354  +            The name of the database being updated (usually "main" but can be any attached or temporary database)
         3355  +            </summary>
         3356  +        </member>
         3357  +        <member name="F:System.Data.SQLite.UpdateEventArgs.Table">
         3358  +            <summary>
         3359  +            The name of the table being updated
         3360  +            </summary>
         3361  +        </member>
         3362  +        <member name="F:System.Data.SQLite.UpdateEventArgs.Event">
         3363  +            <summary>
         3364  +            The type of update being performed (insert/update/delete)
         3365  +            </summary>
         3366  +        </member>
         3367  +        <member name="F:System.Data.SQLite.UpdateEventArgs.RowId">
         3368  +            <summary>
         3369  +            The RowId affected by this update.
         3370  +            </summary>
         3371  +        </member>
         3372  +        <member name="T:System.Data.SQLite.CommitEventArgs">
         3373  +            <summary>
         3374  +            Event arguments raised when a transaction is being committed
         3375  +            </summary>
         3376  +        </member>
         3377  +        <member name="F:System.Data.SQLite.CommitEventArgs.AbortTransaction">
         3378  +            <summary>
         3379  +            Set to true to abort the transaction and trigger a rollback
         3380  +            </summary>
         3381  +        </member>
         3382  +        <member name="T:System.Data.SQLite.SQLiteStatement">
         3383  +            <summary>
         3384  +            Represents a single SQL statement in SQLite.
         3385  +            </summary>
         3386  +        </member>
         3387  +        <member name="F:System.Data.SQLite.SQLiteStatement._sql">
         3388  +            <summary>
         3389  +            The underlying SQLite object this statement is bound to
         3390  +            </summary>
         3391  +        </member>
         3392  +        <member name="F:System.Data.SQLite.SQLiteStatement._sqlStatement">
         3393  +            <summary>
         3394  +            The command text of this SQL statement
         3395  +            </summary>
         3396  +        </member>
         3397  +        <member name="F:System.Data.SQLite.SQLiteStatement._sqlite_stmt">
         3398  +            <summary>
         3399  +            The actual statement pointer
         3400  +            </summary>
         3401  +        </member>
         3402  +        <member name="F:System.Data.SQLite.SQLiteStatement._unnamedParameters">
         3403  +            <summary>
         3404  +            An index from which unnamed parameters begin
         3405  +            </summary>
         3406  +        </member>
         3407  +        <member name="F:System.Data.SQLite.SQLiteStatement._paramNames">
         3408  +            <summary>
         3409  +            Names of the parameters as SQLite understands them to be
         3410  +            </summary>
         3411  +        </member>
         3412  +        <member name="F:System.Data.SQLite.SQLiteStatement._paramValues">
         3413  +            <summary>
         3414  +            Parameters for this statement
         3415  +            </summary>
         3416  +        </member>
         3417  +        <member name="F:System.Data.SQLite.SQLiteStatement._command">
         3418  +            <summary>
         3419  +            Command this statement belongs to (if any)
         3420  +            </summary>
         3421  +        </member>
         3422  +        <member name="M:System.Data.SQLite.SQLiteStatement.#ctor(System.Data.SQLite.SQLiteBase,System.Data.SQLite.SQLiteStatementHandle,System.String,System.Data.SQLite.SQLiteStatement)">
         3423  +            <summary>
         3424  +            Initializes the statement and attempts to get all information about parameters in the statement
         3425  +            </summary>
         3426  +            <param name="sqlbase">The base SQLite object</param>
         3427  +            <param name="stmt">The statement</param>
         3428  +            <param name="strCommand">The command text for this statement</param>
         3429  +            <param name="previous">The previous command in a multi-statement command</param>
         3430  +        </member>
         3431  +        <member name="M:System.Data.SQLite.SQLiteStatement.MapParameter(System.String,System.Data.SQLite.SQLiteParameter)">
         3432  +            <summary>
         3433  +            Called by SQLiteParameterCollection, this function determines if the specified parameter name belongs to
         3434  +            this statement, and if so, keeps a reference to the parameter so it can be bound later.
         3435  +            </summary>
         3436  +            <param name="s">The parameter name to map</param>
         3437  +            <param name="p">The parameter to assign it</param>
         3438  +        </member>
         3439  +        <member name="M:System.Data.SQLite.SQLiteStatement.Dispose">
         3440  +            <summary>
         3441  +            Disposes and finalizes the statement
         3442  +            </summary>
         3443  +        </member>
         3444  +        <member name="M:System.Data.SQLite.SQLiteStatement.BindParameters">
         3445  +            <summary>
         3446  +             Bind all parameters, making sure the caller didn't miss any
         3447  +            </summary>
         3448  +        </member>
         3449  +        <member name="M:System.Data.SQLite.SQLiteStatement.BindParameter(System.Int32,System.Data.SQLite.SQLiteParameter)">
         3450  +            <summary>
         3451  +            Perform the bind operation for an individual parameter
         3452  +            </summary>
         3453  +            <param name="index">The index of the parameter to bind</param>
         3454  +            <param name="param">The parameter we're binding</param>
         3455  +        </member>
         3456  +        <member name="T:System.Data.SQLite.SQLiteFunctionAttribute">
         3457  +            <summary>
         3458  +            A simple custom attribute to enable us to easily find user-defined functions in
         3459  +            the loaded assemblies and initialize them in SQLite as connections are made.
         3460  +            </summary>
         3461  +        </member>
         3462  +        <member name="M:System.Data.SQLite.SQLiteFunctionAttribute.#ctor">
         3463  +            <summary>
         3464  +            Default constructor, initializes the internal variables for the function.
         3465  +            </summary>
         3466  +        </member>
         3467  +        <member name="P:System.Data.SQLite.SQLiteFunctionAttribute.Name">
         3468  +            <summary>
         3469  +            The function's name as it will be used in SQLite command text.
         3470  +            </summary>
         3471  +        </member>
         3472  +        <member name="P:System.Data.SQLite.SQLiteFunctionAttribute.Arguments">
         3473  +            <summary>
         3474  +            The number of arguments this function expects.  -1 if the number of arguments is variable.
         3475  +            </summary>
         3476  +        </member>
         3477  +        <member name="P:System.Data.SQLite.SQLiteFunctionAttribute.FuncType">
         3478  +            <summary>
         3479  +            The type of function this implementation will be.
         3480  +            </summary>
         3481  +        </member>
         3482  +        <member name="T:System.Data.SQLite.SQLiteCommandBuilder">
         3483  +            <summary>
         3484  +            SQLite implementation of DbCommandBuilder.
         3485  +            </summary>
         3486  +        </member>
         3487  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.#ctor">
         3488  +            <summary>
         3489  +            Default constructor
         3490  +            </summary>
         3491  +        </member>
         3492  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.#ctor(System.Data.SQLite.SQLiteDataAdapter)">
         3493  +            <summary>
         3494  +            Initializes the command builder and associates it with the specified data adapter.
         3495  +            </summary>
         3496  +            <param name="adp"></param>
         3497  +        </member>
         3498  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.ApplyParameterInfo(System.Data.Common.DbParameter,System.Data.DataRow,System.Data.StatementType,System.Boolean)">
         3499  +            <summary>
         3500  +            Minimal amount of parameter processing.  Primarily sets the DbType for the parameter equal to the provider type in the schema
         3501  +            </summary>
         3502  +            <param name="parameter">The parameter to use in applying custom behaviors to a row</param>
         3503  +            <param name="row">The row to apply the parameter to</param>
         3504  +            <param name="statementType">The type of statement</param>
         3505  +            <param name="whereClause">Whether the application of the parameter is part of a WHERE clause</param>
         3506  +        </member>
         3507  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetParameterName(System.String)">
         3508  +            <summary>
         3509  +            Returns a valid named parameter
         3510  +            </summary>
         3511  +            <param name="parameterName">The name of the parameter</param>
         3512  +            <returns>Error</returns>
         3513  +        </member>
         3514  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetParameterName(System.Int32)">
         3515  +            <summary>
         3516  +            Returns a named parameter for the given ordinal
         3517  +            </summary>
         3518  +            <param name="parameterOrdinal">The i of the parameter</param>
         3519  +            <returns>Error</returns>
         3520  +        </member>
         3521  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetParameterPlaceholder(System.Int32)">
         3522  +            <summary>
         3523  +            Returns a placeholder character for the specified parameter i.
         3524  +            </summary>
         3525  +            <param name="parameterOrdinal">The index of the parameter to provide a placeholder for</param>
         3526  +            <returns>Returns a named parameter</returns>
         3527  +        </member>
         3528  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.SetRowUpdatingHandler(System.Data.Common.DbDataAdapter)">
         3529  +            <summary>
         3530  +            Sets the handler for receiving row updating events.  Used by the DbCommandBuilder to autogenerate SQL
         3531  +            statements that may not have previously been generated.
         3532  +            </summary>
         3533  +            <param name="adapter">A data adapter to receive events on.</param>
         3534  +        </member>
         3535  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetDeleteCommand">
         3536  +            <summary>
         3537  +            Returns the automatically-generated SQLite command to delete rows from the database
         3538  +            </summary>
         3539  +            <returns></returns>
         3540  +        </member>
         3541  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetDeleteCommand(System.Boolean)">
         3542  +            <summary>
         3543  +            Returns the automatically-generated SQLite command to delete rows from the database
         3544  +            </summary>
         3545  +            <param name="useColumnsForParameterNames"></param>
         3546  +            <returns></returns>
         3547  +        </member>
         3548  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetUpdateCommand">
         3549  +            <summary>
         3550  +            Returns the automatically-generated SQLite command to update rows in the database
         3551  +            </summary>
         3552  +            <returns></returns>
         3553  +        </member>
         3554  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetUpdateCommand(System.Boolean)">
         3555  +            <summary>
         3556  +            Returns the automatically-generated SQLite command to update rows in the database
         3557  +            </summary>
         3558  +            <param name="useColumnsForParameterNames"></param>
         3559  +            <returns></returns>
         3560  +        </member>
         3561  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetInsertCommand">
         3562  +            <summary>
         3563  +            Returns the automatically-generated SQLite command to insert rows into the database
         3564  +            </summary>
         3565  +            <returns></returns>
         3566  +        </member>
         3567  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetInsertCommand(System.Boolean)">
         3568  +            <summary>
         3569  +            Returns the automatically-generated SQLite command to insert rows into the database
         3570  +            </summary>
         3571  +            <param name="useColumnsForParameterNames"></param>
         3572  +            <returns></returns>
         3573  +        </member>
         3574  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.QuoteIdentifier(System.String)">
         3575  +            <summary>
         3576  +            Places brackets around an identifier
         3577  +            </summary>
         3578  +            <param name="unquotedIdentifier">The identifier to quote</param>
         3579  +            <returns>The bracketed identifier</returns>
         3580  +        </member>
         3581  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.UnquoteIdentifier(System.String)">
         3582  +            <summary>
         3583  +            Removes brackets around an identifier
         3584  +            </summary>
         3585  +            <param name="quotedIdentifier">The quoted (bracketed) identifier</param>
         3586  +            <returns>The undecorated identifier</returns>
         3587  +        </member>
         3588  +        <member name="M:System.Data.SQLite.SQLiteCommandBuilder.GetSchemaTable(System.Data.Common.DbCommand)">
         3589  +            <summary>
         3590  +            Override helper, which can help the base command builder choose the right keys for the given query
         3591  +            </summary>
         3592  +            <param name="sourceCommand"></param>
         3593  +            <returns></returns>
         3594  +        </member>
         3595  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.DataAdapter">
         3596  +            <summary>
         3597  +            Gets/sets the DataAdapter for this CommandBuilder
         3598  +            </summary>
         3599  +        </member>
         3600  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.CatalogLocation">
         3601  +            <summary>
         3602  +            Overridden to hide its property from the designer
         3603  +            </summary>
         3604  +        </member>
         3605  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.CatalogSeparator">
         3606  +            <summary>
         3607  +            Overridden to hide its property from the designer
         3608  +            </summary>
         3609  +        </member>
         3610  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.QuotePrefix">
         3611  +            <summary>
         3612  +            Overridden to hide its property from the designer
         3613  +            </summary>
         3614  +        </member>
         3615  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.QuoteSuffix">
         3616  +            <summary>
         3617  +            Overridden to hide its property from the designer
         3618  +            </summary>
         3619  +        </member>
         3620  +        <member name="P:System.Data.SQLite.SQLiteCommandBuilder.SchemaSeparator">
         3621  +            <summary>
         3622  +            Overridden to hide its property from the designer
         3623  +            </summary>
         3624  +        </member>
         3625  +    </members>
         3626  +</doc>

Added bin/ManagedOnly/System.Data.SQLite.dll.

cannot compute difference between binary files