internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
//
// NOTE: If the database connection is currently open, attempt to
// close it now. This must be done because the file name or
// other parameters that may impact the underlying database
// connection may have changed.
//
if (_sql != null)
{
Close(true);
}
//
// NOTE: If the connection was not closed successfully, throw an
// exception now.
//
if (_sql != null)
{
throw new SQLiteException("connection handle is still active");
}
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16 (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db;
SQLiteErrorCode n;
#if !SQLITE_STANDARD
if ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions)
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), openFlags, out db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
}
n = UnsafeNativeMethods.sqlite3_open16(strFilename, out db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok)
{
throw new SQLiteException(n, null);
}
_sql = new SQLiteConnectionHandle(db, true);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null, null,
null, null, _sql, strFilename, new object[] { strFilename,
connectionFlags, openFlags, maxPoolSize, usePool }));
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions)
{
if (_functions == null)
{
_functions = new List <SQLiteFunction>();
}
_functions.AddRange(new List <SQLiteFunction>(SQLiteFunction.BindFunctions(this, connectionFlags)));
}
SetTimeout(0);
GC.KeepAlive(_sql);
}
///////////////////////////////////////////////////////////////////////
/// <summary>
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </summary>
/// <param name="table">
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </param>
/// <param name="argumentCount">
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </param>
/// <param name="name">
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </param>
/// <param name="function">
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </param>
/// <param name="pClientData">
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </param>
/// <returns>
/// See the <see cref="ISQLiteManagedModule.FindFunction" /> method.
/// </returns>
public override bool FindFunction(
SQLiteVirtualTable table,
int argumentCount,
string name,
ref SQLiteFunction function,
ref IntPtr pClientData
)
{
CheckDisposed();
return ResultCodeToFindFunctionResult(GetMethodResultCode(
"FindFunction"));
}
///////////////////////////////////////////////////////////////////////
#region Function Lookup Methods
/// <summary>
/// Deterimines the key that should be used to identify and store the
/// <see cref="SQLiteFunction" /> object instance for the virtual table
/// (i.e. to be returned via the
/// <see cref="ISQLiteNativeModule.xFindFunction" /> method).
/// </summary>
/// <param name="argumentCount">
/// The number of arguments to the virtual table function.
/// </param>
/// <param name="name">
/// The name of the virtual table function.
/// </param>
/// <param name="function">
/// The <see cref="SQLiteFunction" /> object instance associated with
/// this virtual table function.
/// </param>
/// <returns>
/// The string that should be used to identify and store the virtual
/// table function instance. This method cannot return null. If null
/// is returned from this method, the behavior is undefined.
/// </returns>
protected virtual string GetFunctionKey(
int argumentCount,
string name,
SQLiteFunction function
)
{
return String.Format("{0}:{1}", argumentCount, name);
}
///////////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called in response to the
/// <see cref="ISQLiteNativeModule.xFindFunction" /> method.
/// </summary>
/// <param name="table">
/// The <see cref="SQLiteVirtualTable" /> object instance associated
/// with this virtual table.
/// </param>
/// <param name="argumentCount">
/// The number of arguments to the function being sought.
/// </param>
/// <param name="name">
/// The name of the function being sought.
/// </param>
/// <param name="function">
/// Upon success, this parameter must be modified to contain the
/// <see cref="SQLiteFunction" /> object instance responsible for
/// implementing the specified function.
/// </param>
/// <param name="pClientData">
/// Upon success, this parameter must be modified to contain the
/// native user-data pointer associated with
/// <paramref name="function" />.
/// </param>
/// <returns>
/// Non-zero if the specified function was found; zero otherwise.
/// </returns>
public abstract bool FindFunction(
SQLiteVirtualTable table,
int argumentCount,
string name,
ref SQLiteFunction function,
ref IntPtr pClientData
);
/// <summary>
/// This function binds a user-defined function to the connection.
/// </summary>
/// <param name="functionAttribute">
/// The <see cref="SQLiteFunctionAttribute"/> object instance containing
/// the metadata for the function to be bound.
/// </param>
/// <param name="function">
/// The <see cref="SQLiteFunction"/> object instance that implements the
/// function to be bound.
/// </param>
/// <param name="flags">
/// The flags associated with the parent connection object.
/// </param>
internal override void BindFunction(
SQLiteFunctionAttribute functionAttribute,
SQLiteFunction function,
SQLiteConnectionFlags flags
)
{
SQLiteFunction.BindFunction(this, functionAttribute, function, flags);
if (_functions == null)
_functions = new List<SQLiteFunction>();
_functions.Add(function);
}
internal override CollationSequence GetCollationSequence(SQLiteFunction func, IntPtr context)
{
#if !SQLITE_STANDARD
CollationSequence seq = new CollationSequence();
int len;
int type;
int enc;
IntPtr p = UnsafeNativeMethods.sqlite3_context_collseq_interop(context, out type, out enc, out len);
if (p != null) seq.Name = UTF8ToString(p, len);
seq.Type = (CollationTypeEnum)type;
seq._func = func;
seq.Encoding = (CollationEncodingEnum)enc;
return seq;
#else
throw new NotImplementedException();
#endif
}
/// <summary>
/// This function binds a user-defined functions to a connection.
/// </summary>
/// <param name="sqliteBase">
/// The <see cref="SQLiteBase" /> object instance associated with the
/// <see cref="SQLiteConnection" /> that the function should be bound to.
/// </param>
/// <param name="functionAttribute">
/// The <see cref="SQLiteFunctionAttribute"/> object instance containing
/// the metadata for the function to be bound.
/// </param>
/// <param name="function">
/// The <see cref="SQLiteFunction"/> object instance that implements the
/// function to be bound.
/// </param>
/// <param name="flags">
/// The flags associated with the parent connection object.
/// </param>
internal static void BindFunction(
SQLiteBase sqliteBase,
SQLiteFunctionAttribute functionAttribute,
SQLiteFunction function,
SQLiteConnectionFlags flags
)
{
if (sqliteBase == null)
throw new ArgumentNullException("sqliteBase");
if (functionAttribute == null)
throw new ArgumentNullException("functionAttribute");
if (function == null)
throw new ArgumentNullException("function");
FunctionType functionType = functionAttribute.FuncType;
function._base = sqliteBase;
function._flags = flags;
function._InvokeFunc = (functionType == FunctionType.Scalar) ?
new SQLiteCallback(function.ScalarCallback) : null;
function._StepFunc = (functionType == FunctionType.Aggregate) ?
new SQLiteCallback(function.StepCallback) : null;
function._FinalFunc = (functionType == FunctionType.Aggregate) ?
new SQLiteFinalCallback(function.FinalCallback) : null;
function._CompareFunc = (functionType == FunctionType.Collation) ?
new SQLiteCollation(function.CompareCallback) : null;
function._CompareFunc16 = (functionType == FunctionType.Collation) ?
new SQLiteCollation(function.CompareCallback16) : null;
string name = functionAttribute.Name;
if (functionType != FunctionType.Collation)
{
bool needCollSeq = (function is SQLiteFunctionEx);
sqliteBase.CreateFunction(
name, functionAttribute.Arguments, needCollSeq,
function._InvokeFunc, function._StepFunc,
function._FinalFunc);
}
else
{
sqliteBase.CreateCollation(
name, function._CompareFunc, function._CompareFunc16);
}
}
internal abstract CollationSequence GetCollationSequence(SQLiteFunction func, IntPtr context);
/// <summary> /// This function binds a user-defined functions to the connection. /// </summary> /// <param name="functionAttribute"> /// The <see cref="SQLiteFunctionAttribute"/> object instance containing /// the metadata for the function to be bound. /// </param> /// <param name="function"> /// The <see cref="SQLiteFunction"/> object instance that implements the /// function to be bound. /// </param> /// <param name="flags"> /// The flags associated with the parent connection object. /// </param> internal abstract void BindFunction(SQLiteFunctionAttribute functionAttribute, SQLiteFunction function, SQLiteConnectionFlags flags);