/// <summary>
/// Initializes the statement and attempts to get all information about parameters in the statement
/// </summary>
/// <param name="sqlbase">The base SQLite object</param>
/// <param name="flags">The flags associated with the parent connection object</param>
/// <param name="stmt">The statement</param>
/// <param name="strCommand">The command text for this statement</param>
/// <param name="previous">The previous command in a multi-statement command</param>
internal SQLiteStatement(SQLiteBase sqlbase, SQLiteConnectionFlags flags, SQLiteStatementHandle stmt, string strCommand, SQLiteStatement previous)
{
_sql = sqlbase;
_sqlite_stmt = stmt;
_sqlStatement = strCommand;
_flags = flags;
// Determine parameters for this statement (if any) and prepare space for them.
int nCmdStart = 0;
int n = _sql.Bind_ParamCount(this, _flags);
int x;
string s;
if (n > 0)
{
if (previous != null)
nCmdStart = previous._unnamedParameters;
_paramNames = new string[n];
_paramValues = new SQLiteParameter[n];
for (x = 0; x < n; x++)
{
s = _sql.Bind_ParamName(this, _flags, x + 1);
if (String.IsNullOrEmpty(s))
{
s = String.Format(CultureInfo.InvariantCulture, ";{0}", nCmdStart);
nCmdStart++;
_unnamedParameters++;
}
_paramNames[x] = s;
_paramValues[x] = null;
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
private void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
if (_sqlite_stmt != null)
{
_sqlite_stmt.Dispose();
_sqlite_stmt = null;
}
_paramNames = null;
_paramValues = null;
_sql = null;
_sqlStatement = null;
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
internal override SQLiteStatement Prepare(SQLiteConnection cnn, string strSql, SQLiteStatement previous, uint timeoutMS, out string strRemain)
{
if (!String.IsNullOrEmpty(strSql))
{
//
// NOTE: SQLite does not support the concept of separate schemas
// in one database; therefore, remove the base schema name
// used to smooth integration with the base .NET Framework
// data classes.
//
string baseSchemaName = (cnn != null) ? cnn._baseSchemaName : null;
if (!String.IsNullOrEmpty(baseSchemaName))
{
strSql = strSql.Replace(
String.Format(CultureInfo.InvariantCulture,
"[{0}].", baseSchemaName), String.Empty);
strSql = strSql.Replace(
String.Format(CultureInfo.InvariantCulture,
"{0}.", baseSchemaName), String.Empty);
}
}
SQLiteConnectionFlags flags =
(cnn != null) ? cnn.Flags : SQLiteConnectionFlags.Default;
if ((flags & SQLiteConnectionFlags.LogPrepare) == SQLiteConnectionFlags.LogPrepare)
{
if ((strSql == null) || (strSql.Length == 0) || (strSql.Trim().Length == 0))
SQLiteLog.LogMessage("Preparing {<nothing>}...");
else
SQLiteLog.LogMessage(String.Format(
CultureInfo.CurrentCulture, "Preparing {{{0}}}...", strSql));
}
IntPtr stmt = IntPtr.Zero;
IntPtr ptr = IntPtr.Zero;
int len = 0;
SQLiteErrorCode n = SQLiteErrorCode.Schema;
int retries = 0;
byte[] b = ToUTF8(strSql);
string typedefs = null;
SQLiteStatement cmd = null;
Random rnd = null;
uint starttick = (uint)Environment.TickCount;
GCHandle handle = GCHandle.Alloc(b, GCHandleType.Pinned);
IntPtr psql = handle.AddrOfPinnedObject();
SQLiteStatementHandle statementHandle = null;
try
{
while ((n == SQLiteErrorCode.Schema || n == SQLiteErrorCode.Locked || n == SQLiteErrorCode.Busy) && retries < 3)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_prepare_interop(_sql, psql, b.Length - 1, out stmt, out ptr, out len);
#else
#if USE_PREPARE_V2
n = UnsafeNativeMethods.sqlite3_prepare_v2(_sql, psql, b.Length - 1, out stmt, out ptr);
#else
n = UnsafeNativeMethods.sqlite3_prepare(_sql, psql, b.Length - 1, out stmt, out ptr);
#endif
len = -1;
#endif
#if !NET_COMPACT_20 && TRACE_STATEMENT
Trace.WriteLine(String.Format("Prepare ({0}): {1}", n, stmt));
#endif
if ((n == SQLiteErrorCode.Ok) && (stmt != IntPtr.Zero))
{
if (statementHandle != null) statementHandle.Dispose();
statementHandle = new SQLiteStatementHandle(_sql, stmt);
}
}
if (statementHandle != null)
{
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null, null,
null, null, statementHandle, strSql, new object[] { cnn,
strSql, previous, timeoutMS }));
}
if (n == SQLiteErrorCode.Schema)
retries++;
else if (n == SQLiteErrorCode.Error)
{
if (String.Compare(GetLastError(), "near \"TYPES\": syntax error", StringComparison.OrdinalIgnoreCase) == 0)
{
int pos = strSql.IndexOf(';');
if (pos == -1) pos = strSql.Length - 1;
typedefs = strSql.Substring(0, pos + 1);
strSql = strSql.Substring(pos + 1);
strRemain = "";
while (cmd == null && strSql.Length > 0)
{
cmd = Prepare(cnn, strSql, previous, timeoutMS, out strRemain);
strSql = strRemain;
}
if (cmd != null)
cmd.SetTypes(typedefs);
return cmd;
}
#if (NET_35 || NET_40 || NET_45 || NET_451) && !PLATFORM_COMPACTFRAMEWORK
else if (_buildingSchema == false && String.Compare(GetLastError(), 0, "no such table: TEMP.SCHEMA", 0, 26, StringComparison.OrdinalIgnoreCase) == 0)
{
strRemain = "";
_buildingSchema = true;
try
{
ISQLiteSchemaExtensions ext = ((IServiceProvider)DenverDBFactory.Instance).GetService(typeof(ISQLiteSchemaExtensions)) as ISQLiteSchemaExtensions;
if (ext != null)
ext.BuildTempSchema(cnn);
while (cmd == null && strSql.Length > 0)
{
cmd = Prepare(cnn, strSql, previous, timeoutMS, out strRemain);
strSql = strRemain;
}
return cmd;
}
finally
{
_buildingSchema = false;
}
}
#endif
}
else if (n == SQLiteErrorCode.Locked || n == SQLiteErrorCode.Busy) // Locked -- delay a small amount before retrying
{
// Keep trying
if (rnd == null) // First time we've encountered the lock
rnd = new Random();
// If we've exceeded the command's timeout, give up and throw an error
if ((uint)Environment.TickCount - starttick > timeoutMS)
{
throw new SQLiteException(n, GetLastError());
}
else
{
// Otherwise sleep for a random amount of time up to 150ms
System.Threading.Thread.Sleep(rnd.Next(1, 150));
}
}
}
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, GetLastError());
strRemain = UTF8ToString(ptr, len);
if (statementHandle != null) cmd = new SQLiteStatement(this, flags, statementHandle, strSql.Substring(0, strSql.Length - strRemain.Length), previous);
return cmd;
}
finally
{
handle.Free();
}
}
protected static void LogBind(SQLiteStatementHandle handle, int index, byte[] value)
{
IntPtr handleIntPtr = handle;
SQLiteLog.LogMessage(String.Format(
"Binding statement {0} paramter #{1} as type {2} with value {{{3}}}...",
handleIntPtr, index, typeof(Byte[]), (value != null) ? ToHexadecimalString(value) : "<null>"));
}
protected static void LogBind(SQLiteStatementHandle handle, int index, DateTime value)
{
IntPtr handleIntPtr = handle;
SQLiteLog.LogMessage(String.Format(
"Binding statement {0} paramter #{1} as type {2} with value {{{3}}}...",
handleIntPtr, index, typeof(DateTime), FormatDateTime(value)));
}
protected static void LogBind(SQLiteStatementHandle handle, int index, ValueType value)
{
IntPtr handleIntPtr = handle;
SQLiteLog.LogMessage(String.Format(
"Binding statement {0} paramter #{1} as type {2} with value {{{3}}}...",
handleIntPtr, index, value.GetType(), value));
}
protected static void LogBind(SQLiteStatementHandle handle, int index)
{
IntPtr handleIntPtr = handle;
SQLiteLog.LogMessage(String.Format(
CultureInfo.CurrentCulture,
"Binding statement {0} paramter #{1} as NULL...",
handleIntPtr, index));
}
