static SQLiteFactory()
{
#if (SQLITE_STANDARD || USE_INTEROP_DLL || PLATFORM_COMPACTFRAMEWORK) && PRELOAD_NATIVE_LIBRARY
UnsafeNativeMethods.Initialize();
#endif
#if USE_INTEROP_DLL && INTEROP_LOG
if (UnsafeNativeMethods.sqlite3_config_log_interop() == SQLiteErrorCode.Ok)
{
UnsafeNativeMethods.sqlite3_log(
SQLiteErrorCode.Ok, SQLiteConvert.ToUTF8("logging initialized."));
}
#endif
SQLiteLog.Initialize();
string version =
#if NET_40 || NET_45 || NET_451 || NET_452 || NET_46 || NET_461
"4.0.0.0";
#else
"3.5.0.0";
#endif
_dbProviderServicesType = Type.GetType(HelperMethods.StringFormat(CultureInfo.InvariantCulture, "System.Data.Common.DbProviderServices, System.Data.Entity, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089", version), false);
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a <see cref="SQLiteBlob" /> object. This will not work
/// for tables that were created WITHOUT ROWID.
/// </summary>
/// <param name="connection">
/// The connection to use when opening the blob object.
/// </param>
/// <param name="databaseName">
/// The name of the database containing the blob object.
/// </param>
/// <param name="tableName">
/// The name of the table containing the blob object.
/// </param>
/// <param name="columnName">
/// The name of the column containing the blob object.
/// </param>
/// <param name="rowId">
/// The integer identifier for the row associated with the desired
/// blob object.
/// </param>
/// <param name="readOnly">
/// Non-zero to open the blob object for read-only access.
/// </param>
/// <returns>
/// The newly created <see cref="SQLiteBlob" /> instance -OR- null
/// if an error occurs.
/// </returns>
public static SQLiteBlob Create(
SQLiteConnection connection,
string databaseName,
string tableName,
string columnName,
long rowId,
bool readOnly
)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
SQLite3 sqlite3 = connection._sql as SQLite3;
if (sqlite3 == null)
{
throw new InvalidOperationException("Connection has no wrapper");
}
SQLiteConnectionHandle handle = sqlite3._sql;
if (handle == null)
{
throw new InvalidOperationException("Connection has an invalid handle.");
}
SQLiteBlobHandle blob = null;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr ptrBlob = IntPtr.Zero;
SQLiteErrorCode rc = UnsafeNativeMethods.sqlite3_blob_open(
handle, SQLiteConvert.ToUTF8(databaseName),
SQLiteConvert.ToUTF8(tableName), SQLiteConvert.ToUTF8(
columnName), rowId, readOnly ? 0 : 1, ref ptrBlob);
if (rc != SQLiteErrorCode.Ok)
{
throw new SQLiteException(rc, null);
}
blob = new SQLiteBlobHandle(handle, ptrBlob);
}
SQLiteConnection.OnChanged(connection, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null, null,
null, null, blob, null, new object[] { typeof(SQLiteBlob),
databaseName, tableName, columnName, rowId, readOnly }));
return(new SQLiteBlob(sqlite3, blob));
}
internal override void Bind_Text(SQLiteStatement stmt, int index, string value)
{
byte[] buffer = SQLiteConvert.ToUTF8(value);
int errorCode = UnsafeNativeMethods.sqlite3_bind_text((IntPtr)stmt._sqlite_stmt, index, buffer, buffer.Length - 1, (IntPtr)(-1));
if (errorCode > 0)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
}
internal override void CreateCollation(string strCollation, SQLiteCollation func, SQLiteCollation func16)
{
int errorCode = UnsafeNativeMethods.sqlite3_create_collation((IntPtr)this._sql, SQLiteConvert.ToUTF8(strCollation), 2, IntPtr.Zero, func16);
if (errorCode == 0)
{
UnsafeNativeMethods.sqlite3_create_collation((IntPtr)this._sql, SQLiteConvert.ToUTF8(strCollation), 1, IntPtr.Zero, func);
}
if (errorCode > 0)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
}
internal static void ResetConnection(SQLiteConnectionHandle db)
{
lock (_lock)
{
IntPtr zero = IntPtr.Zero;
do
{
zero = UnsafeNativeMethods.sqlite3_next_stmt((IntPtr)db, zero);
if (zero != IntPtr.Zero)
{
UnsafeNativeMethods.sqlite3_reset_interop(zero);
}
}while (zero != IntPtr.Zero);
UnsafeNativeMethods.sqlite3_exec((IntPtr)db, SQLiteConvert.ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out zero);
}
}
internal override void Open(string strFilename, SQLiteOpenFlagsEnum flags, int maxPoolSize, bool usePool)
{
if (base._sql == null)
{
base._usePool = usePool;
if (usePool)
{
base._fileName = strFilename;
base._sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out this._poolVersion);
}
if (base._sql == null)
{
IntPtr ptr;
int errorCode = UnsafeNativeMethods.sqlite3_open16_interop(SQLiteConvert.ToUTF8(strFilename), (int)flags, out ptr);
if (errorCode > 0)
{
throw new SQLiteException(errorCode, null);
}
base._sql = ptr;
}
base._functionsArray = SQLiteFunction.BindFunctions(this);
}
}
internal override int Bind_ParamIndex(SQLiteStatement stmt, string paramName)
{
return(UnsafeNativeMethods.sqlite3_bind_parameter_index((IntPtr)stmt._sqlite_stmt, SQLiteConvert.ToUTF8(paramName)));
}
internal override void ReturnText(IntPtr context, string value)
{
byte[] buffer = SQLiteConvert.ToUTF8(value);
UnsafeNativeMethods.sqlite3_result_text(context, SQLiteConvert.ToUTF8(value), buffer.Length - 1, (IntPtr)(-1));
}
internal override void ReturnError(IntPtr context, string value)
{
UnsafeNativeMethods.sqlite3_result_error(context, SQLiteConvert.ToUTF8(value), value.Length);
}
internal override SQLiteStatement Prepare(SQLiteConnection cnn, string strSql, SQLiteStatement previous, uint timeoutMS, out string strRemain)
{
SQLiteStatement statement2;
IntPtr zero = IntPtr.Zero;
IntPtr ptrRemain = IntPtr.Zero;
int nRemain = 0;
int errorCode = 0x11;
int num3 = 0;
byte[] buffer = SQLiteConvert.ToUTF8(strSql);
string typedefs = null;
SQLiteStatement statement = null;
Random random = null;
uint tickCount = (uint)Environment.TickCount;
GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
IntPtr pSql = handle.AddrOfPinnedObject();
try
{
while ((((errorCode == 0x11) || (errorCode == 6)) || (errorCode == 5)) && (num3 < 3))
{
errorCode = UnsafeNativeMethods.sqlite3_prepare_interop((IntPtr)this._sql, pSql, buffer.Length - 1, out zero, out ptrRemain, out nRemain);
if (errorCode == 0x11)
{
num3++;
}
else
{
if (errorCode == 1)
{
if (string.Compare(this.SQLiteLastError(), "near \"TYPES\": syntax error", StringComparison.OrdinalIgnoreCase) == 0)
{
int index = strSql.IndexOf(';');
if (index == -1)
{
index = strSql.Length - 1;
}
typedefs = strSql.Substring(0, index + 1);
strSql = strSql.Substring(index + 1);
strRemain = "";
while ((statement == null) && (strSql.Length > 0))
{
statement = this.Prepare(cnn, strSql, previous, timeoutMS, out strRemain);
strSql = strRemain;
}
if (statement != null)
{
statement.SetTypes(typedefs);
}
return(statement);
}
if (this._buildingSchema || (string.Compare(this.SQLiteLastError(), 0, "no such table: TEMP.SCHEMA", 0, 0x1a, StringComparison.OrdinalIgnoreCase) != 0))
{
continue;
}
strRemain = "";
this._buildingSchema = true;
try
{
ISQLiteSchemaExtensions service = ((IServiceProvider)SQLiteFactory.Instance).GetService(typeof(ISQLiteSchemaExtensions)) as ISQLiteSchemaExtensions;
if (service != null)
{
service.BuildTempSchema(cnn);
}
while ((statement == null) && (strSql.Length > 0))
{
statement = this.Prepare(cnn, strSql, previous, timeoutMS, out strRemain);
strSql = strRemain;
}
return(statement);
}
finally
{
this._buildingSchema = false;
}
}
switch (errorCode)
{
case 6:
case 5:
if (random == null)
{
random = new Random();
}
if ((Environment.TickCount - tickCount) > timeoutMS)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
Thread.Sleep(random.Next(1, 150));
break;
}
}
}
if (errorCode > 0)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
strRemain = SQLiteConvert.UTF8ToString(ptrRemain, nRemain);
if (zero != IntPtr.Zero)
{
statement = new SQLiteStatement(this, zero, strSql.Substring(0, strSql.Length - strRemain.Length), previous);
}
statement2 = statement;
}
finally
{
handle.Free();
}
return(statement2);
}
internal override void GetIndexColumnExtendedInfo(string database, string index, string column, out int sortMode, out int onError, out string collationSequence)
{
IntPtr ptr;
int num;
int errorCode = UnsafeNativeMethods.sqlite3_index_column_info_interop((IntPtr)this._sql, SQLiteConvert.ToUTF8(database), SQLiteConvert.ToUTF8(index), SQLiteConvert.ToUTF8(column), out sortMode, out onError, out ptr, out num);
if (errorCode != 0)
{
throw new SQLiteException(errorCode, "");
}
collationSequence = SQLiteConvert.UTF8ToString(ptr, num);
}
internal override void CreateFunction(string strFunction, int nArgs, bool needCollSeq, SQLiteCallback func, SQLiteCallback funcstep, SQLiteFinalCallback funcfinal)
{
int errorCode = UnsafeNativeMethods.sqlite3_create_function_interop((IntPtr)this._sql, SQLiteConvert.ToUTF8(strFunction), nArgs, 4, IntPtr.Zero, func, funcstep, funcfinal, needCollSeq ? 1 : 0);
if (errorCode == 0)
{
errorCode = UnsafeNativeMethods.sqlite3_create_function_interop((IntPtr)this._sql, SQLiteConvert.ToUTF8(strFunction), nArgs, 1, IntPtr.Zero, func, funcstep, funcfinal, needCollSeq ? 1 : 0);
}
if (errorCode > 0)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
}
internal override void ColumnMetaData(string dataBase, string table, string column, out string dataType, out string collateSequence, out bool notNull, out bool primaryKey, out bool autoIncrement)
{
IntPtr ptr;
IntPtr ptr2;
int num;
int num2;
int num3;
int num5;
int num6;
int errorCode = UnsafeNativeMethods.sqlite3_table_column_metadata_interop((IntPtr)this._sql, SQLiteConvert.ToUTF8(dataBase), SQLiteConvert.ToUTF8(table), SQLiteConvert.ToUTF8(column), out ptr, out ptr2, out num, out num2, out num3, out num5, out num6);
if (errorCode > 0)
{
throw new SQLiteException(errorCode, this.SQLiteLastError());
}
dataType = SQLiteConvert.UTF8ToString(ptr, num5);
collateSequence = SQLiteConvert.UTF8ToString(ptr2, num6);
notNull = num == 1;
primaryKey = num2 == 1;
autoIncrement = num3 == 1;
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Static "Factory" Methods
/// <summary>
/// Creates a <see cref="SQLiteBlob" /> object. This will not work
/// for tables that were created WITHOUT ROWID -OR- if the query
/// does not include the "rowid" column or one of its aliases -OR-
/// if the <see cref="SQLiteDataReader" /> was not created with the
/// <see cref="CommandBehavior.KeyInfo" /> flag.
/// </summary>
/// <param name="dataReader">
/// The <see cref="SQLiteDataReader" /> instance with a result set
/// containing the desired blob column.
/// </param>
/// <param name="i">
/// The index of the blob column.
/// </param>
/// <param name="readOnly">
/// Non-zero to open the blob object for read-only access.
/// </param>
/// <returns>
/// The newly created <see cref="SQLiteBlob" /> instance -OR- null
/// if an error occurs.
/// </returns>
public static SQLiteBlob Create(
SQLiteDataReader dataReader,
int i,
bool readOnly
)
{
SQLiteConnection connection = SQLiteDataReader.GetConnection(
dataReader);
if (connection == null)
{
throw new InvalidOperationException("Connection not available");
}
SQLite3 sqlite3 = connection._sql as SQLite3;
if (sqlite3 == null)
{
throw new InvalidOperationException("Connection has no wrapper");
}
SQLiteConnectionHandle handle = sqlite3._sql;
if (handle == null)
{
throw new InvalidOperationException("Connection has an invalid handle.");
}
long?rowId = dataReader.GetRowId(i);
if (rowId == null)
{
throw new InvalidOperationException("No RowId is available");
}
SQLiteBlobHandle blob = null;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr ptrBlob = IntPtr.Zero;
SQLiteErrorCode rc = UnsafeNativeMethods.sqlite3_blob_open(
sqlite3._sql, SQLiteConvert.ToUTF8(
dataReader.GetDatabaseName(i)), SQLiteConvert.ToUTF8(
dataReader.GetTableName(i)), SQLiteConvert.ToUTF8(
dataReader.GetName(i)), (long)rowId, readOnly ? 0 : 1,
ref ptrBlob);
if (rc != SQLiteErrorCode.Ok)
{
throw new SQLiteException(rc, null);
}
blob = new SQLiteBlobHandle(handle, ptrBlob);
}
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null,
null, null, dataReader, blob, null, new object[] {
typeof(SQLiteBlob), dataReader, i, readOnly
}));
return(new SQLiteBlob(sqlite3, blob));
}
