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: |
85ed84191d90d721a22be3a944dd361e |
| 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
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 <?xml version="1.0" standalone="yes"?> 3060 + <DocumentElement> 3061 + <DataTypes> 3062 + <TypeName>smallint</TypeName> 3063 + <ProviderDbType>10</ProviderDbType> 3064 + <ColumnSize>5</ColumnSize> 3065 + <DataType>System.Int16</DataType> 3066 + <CreateFormat>smallint</CreateFormat> 3067 + <IsAutoIncrementable>false</IsAutoIncrementable> 3068 + <IsCaseSensitive>false</IsCaseSensitive> 3069 + <IsFixedLength>true</IsFixedLength> 3070 + <IsFixedPrecisionScale>true</IsFixedPrecisionScale> 3071 + <IsLong>false</IsLong> 3072 + <IsNullable>true</ [rest of string was truncated]";. 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 <?xml version="1.0" encoding="utf-8" ?> 3083 + <DocumentElement> 3084 + <MetaDataCollections> 3085 + <CollectionName>MetaDataCollections</CollectionName> 3086 + <NumberOfRestrictions>0</NumberOfRestrictions> 3087 + <NumberOfIdentifierParts>0</NumberOfIdentifierParts> 3088 + </MetaDataCollections> 3089 + <MetaDataCollections> 3090 + <CollectionName>DataSourceInformation</CollectionName> 3091 + <NumberOfRestrictions>0</NumberOfRestrictions> 3092 + <NumberOfIdentifierParts>0</NumberOfIdentifierParts> 3093 + </MetaDataCollections> 3094 + <MetaDataC [rest of string was truncated]";. 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