[9dba08]: / System.Data.SQLite / SQLiteBase.cs  Maximize  Restore  History

Download this file

290 lines (244 with data), 14.0 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
/********************************************************
* ADO.NET 2.0 Data Provider for SQLite Version 3.X
* Written by Robert Simpson (robert@blackcastlesoft.com)
*
* Released to the public domain, use at your own risk!
********************************************************/
namespace System.Data.SQLite
{
/// <summary>
/// This internal class provides the foundation of SQLite support. It defines all the abstract members needed to implement
/// a SQLite data provider, and inherits from SQLiteConvert which allows for simple translations of string to and from SQLite.
/// </summary>
internal abstract class SQLiteBase : SQLiteConvert, IDisposable
{
internal static object _lock = new object();
internal SQLiteBase(SQLiteDateFormats fmt)
: base(fmt)
{
}
/// <summary>
/// Returns a string representing the active version of SQLite
/// </summary>
internal abstract string Version { get; }
/// <summary>
/// Returns the number of changes the last executing insert/update caused.
/// </summary>
internal abstract int Changes { get; }
internal abstract bool AutoCommit { get; }
#region IDisposable Members
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
/// <summary>
/// Opens a database.
/// </summary>
/// <remarks>
/// Implementers should call SQLiteFunction.BindFunctions() and save the array after opening a connection
/// to bind all attributed user-defined functions and collating sequences to the new connection.
/// </remarks>
/// <param name="strFilename">The filename of the database to open. SQLite automatically creates it if it doesn't exist.</param>
/// <param name="flags">The open flags to use when creating the connection</param>
/// <param name="maxPoolSize">The maximum size of the pool for the given filename</param>
/// <param name="usePool">If true, the connection can be pulled from the connection pool</param>
internal abstract void Open(string strFilename, SQLiteOpenFlagsEnum flags, int maxPoolSize, bool usePool);
/// <summary>
/// Closes the currently-open database.
/// </summary>
/// <remarks>
/// After the database has been closed implemeters should call SQLiteFunction.UnbindFunctions() to deallocate all interop allocated
/// memory associated with the user-defined functions and collating sequences tied to the closed connection.
/// </remarks>
internal abstract void Close();
/// <summary>
/// Sets the busy timeout on the connection. SQLiteCommand will call this before executing any command.
/// </summary>
/// <param name="nTimeoutMS">The number of milliseconds to wait before returning SQLITE_BUSY</param>
internal abstract void SetTimeout(int nTimeoutMS);
/// <summary>
/// Returns the text of the last error issued by SQLite
/// </summary>
/// <returns></returns>
internal abstract string SQLiteLastError();
/// <summary>
/// When pooling is enabled, force this connection to be disposed rather than returned to the pool
/// </summary>
internal abstract void ClearPool();
/// <summary>
/// Prepares a SQL statement for execution.
/// </summary>
/// <param name="cnn">The source connection preparing the command. Can be null for any caller except LINQ</param>
/// <param name="strSql">The SQL command text to prepare</param>
/// <param name="previous">The previous statement in a multi-statement command, or null if no previous statement exists</param>
/// <param name="timeoutMS">The timeout to wait before aborting the prepare</param>
/// <param name="strRemain">The remainder of the statement that was not processed. Each call to prepare parses the
/// SQL up to to either the end of the text or to the first semi-colon delimiter. The remaining text is returned
/// here for a subsequent call to Prepare() until all the text has been processed.</param>
/// <returns>Returns an initialized SQLiteStatement.</returns>
internal abstract SQLiteStatement Prepare(SQLiteConnection cnn, string strSql, SQLiteStatement previous,
uint timeoutMS, out string strRemain);
/// <summary>
/// Steps through a prepared statement.
/// </summary>
/// <param name="stmt">The SQLiteStatement to step through</param>
/// <returns>True if a row was returned, False if not.</returns>
internal abstract bool Step(SQLiteStatement stmt);
/// <summary>
/// Resets a prepared statement so it can be executed again. If the error returned is SQLITE_SCHEMA,
/// transparently attempt to rebuild the SQL statement and throw an error if that was not possible.
/// </summary>
/// <param name="stmt">The statement to reset</param>
/// <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>
internal abstract int Reset(SQLiteStatement stmt);
internal abstract void Cancel();
internal abstract void Bind_Double(SQLiteStatement stmt, int index, double value);
internal abstract void Bind_Int32(SQLiteStatement stmt, int index, Int32 value);
internal abstract void Bind_Int64(SQLiteStatement stmt, int index, Int64 value);
internal abstract void Bind_Text(SQLiteStatement stmt, int index, string value);
internal abstract void Bind_Blob(SQLiteStatement stmt, int index, byte[] blobData);
internal abstract void Bind_DateTime(SQLiteStatement stmt, int index, DateTime dt);
internal abstract void Bind_Null(SQLiteStatement stmt, int index);
internal abstract int Bind_ParamCount(SQLiteStatement stmt);
internal abstract string Bind_ParamName(SQLiteStatement stmt, int index);
internal abstract int Bind_ParamIndex(SQLiteStatement stmt, string paramName);
internal abstract int ColumnCount(SQLiteStatement stmt);
internal abstract string ColumnName(SQLiteStatement stmt, int index);
internal abstract TypeAffinity ColumnAffinity(SQLiteStatement stmt, int index);
internal abstract string ColumnType(SQLiteStatement stmt, int index, out TypeAffinity nAffinity);
internal abstract int ColumnIndex(SQLiteStatement stmt, string columnName);
internal abstract string ColumnOriginalName(SQLiteStatement stmt, int index);
internal abstract string ColumnDatabaseName(SQLiteStatement stmt, int index);
internal abstract string ColumnTableName(SQLiteStatement stmt, int index);
internal abstract void ColumnMetaData(string dataBase, string table, string column, out string dataType,
out string collateSequence, out bool notNull, out bool primaryKey,
out bool autoIncrement);
internal abstract void GetIndexColumnExtendedInfo(string database, string index, string column, out int sortMode,
out int onError, out string collationSequence);
internal abstract double GetDouble(SQLiteStatement stmt, int index);
internal abstract Int32 GetInt32(SQLiteStatement stmt, int index);
internal abstract Int64 GetInt64(SQLiteStatement stmt, int index);
internal abstract string GetText(SQLiteStatement stmt, int index);
internal abstract long GetBytes(SQLiteStatement stmt, int index, int nDataoffset, byte[] bDest, int nStart,
int nLength);
internal abstract long GetChars(SQLiteStatement stmt, int index, int nDataoffset, char[] bDest, int nStart,
int nLength);
internal abstract DateTime GetDateTime(SQLiteStatement stmt, int index);
internal abstract bool IsNull(SQLiteStatement stmt, int index);
internal abstract void CreateCollation(string strCollation, SQLiteCollation func, SQLiteCollation func16);
internal abstract void CreateFunction(string strFunction, int nArgs, bool needCollSeq, SQLiteCallback func,
SQLiteCallback funcstep, SQLiteFinalCallback funcfinal);
internal abstract CollationSequence GetCollationSequence(SQLiteFunction func, IntPtr context);
internal abstract int ContextCollateCompare(CollationEncodingEnum enc, IntPtr context, string s1, string s2);
internal abstract int ContextCollateCompare(CollationEncodingEnum enc, IntPtr context, char[] c1, char[] c2);
internal abstract int AggregateCount(IntPtr context);
internal abstract IntPtr AggregateContext(IntPtr context);
internal abstract long GetParamValueBytes(IntPtr ptr, int nDataOffset, byte[] bDest, int nStart, int nLength);
internal abstract double GetParamValueDouble(IntPtr ptr);
internal abstract int GetParamValueInt32(IntPtr ptr);
internal abstract Int64 GetParamValueInt64(IntPtr ptr);
internal abstract string GetParamValueText(IntPtr ptr);
internal abstract TypeAffinity GetParamValueType(IntPtr ptr);
internal abstract void ReturnBlob(IntPtr context, byte[] value);
internal abstract void ReturnDouble(IntPtr context, double value);
internal abstract void ReturnError(IntPtr context, string value);
internal abstract void ReturnInt32(IntPtr context, Int32 value);
internal abstract void ReturnInt64(IntPtr context, Int64 value);
internal abstract void ReturnNull(IntPtr context);
internal abstract void ReturnText(IntPtr context, string value);
internal abstract void SetPassword(byte[] passwordBytes);
internal abstract void ChangePassword(byte[] newPasswordBytes);
internal abstract void SetUpdateHook(SQLiteUpdateCallback func);
internal abstract void SetCommitHook(SQLiteCommitCallback func);
internal abstract void SetRollbackHook(SQLiteRollbackCallback func);
internal abstract int GetCursorForTable(SQLiteStatement stmt, int database, int rootPage);
internal abstract long GetRowIdForCursor(SQLiteStatement stmt, int cursor);
internal abstract object GetValue(SQLiteStatement stmt, int index, SQLiteType typ);
protected virtual void Dispose(bool bDisposing)
{
}
// These statics are here for lack of a better place to put them.
// They exist here because they are called during the finalization of
// a SQLiteStatementHandle, SQLiteConnectionHandle, and SQLiteFunctionCookieHandle.
// Therefore these functions have to be static, and have to be low-level.
internal static string SQLiteLastError(SQLiteConnectionHandle db)
{
#if !SQLITE_STANDARD
int len;
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
#else
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
}
internal static void FinalizeStatement(SQLiteStatementHandle stmt)
{
lock (_lock)
{
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_finalize_interop(stmt);
#else
int n = UnsafeNativeMethods.sqlite3_finalize(stmt);
#endif
if (n > 0) throw new SQLiteException(n, null);
}
}
internal static void CloseConnection(SQLiteConnectionHandle db)
{
lock (_lock)
{
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_close_interop(db);
#else
ResetConnection(db);
int n = UnsafeNativeMethods.sqlite3_close(db);
#endif
if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
}
}
internal static void ResetConnection(SQLiteConnectionHandle db)
{
lock (_lock)
{
IntPtr stmt = IntPtr.Zero;
int n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
if (IsAutocommit(db) == false) // a transaction is pending on the connection
{
n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
}
}
}
internal static bool IsAutocommit(SQLiteConnectionHandle hdl)
{
return (UnsafeNativeMethods.sqlite3_get_autocommit(hdl) == 1);
}
}
internal interface ISQLiteSchemaExtensions
{
void BuildTempSchema(SQLiteConnection cnn);
}
[Flags]
internal enum SQLiteOpenFlagsEnum
{
None = 0,
ReadOnly = 0x01,
ReadWrite = 0x02,
Create = 0x04,
SharedCache = 0x01000000,
Default = 0x06,
}
}