/// <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;
        }
      }
    }

 internal abstract long GetBytes(SQLiteStatement stmt, int index, int nDataoffset, byte[] bDest, int nStart, int nLength);

 internal abstract string ColumnDatabaseName(SQLiteStatement stmt, int index);

 internal abstract TypeAffinity ColumnAffinity(SQLiteStatement stmt, int index);

 internal abstract string Bind_ParamName(SQLiteStatement stmt, int index);

 internal abstract int Bind_ParamCount(SQLiteStatement stmt);

        /// <summary>
        /// Helper function to retrieve a column of data from an active statement.
        /// </summary>
        /// <param name="stmt">The statement being step()'d through</param>
        /// <param name="index">The column index to retrieve</param>
        /// <param name="typ">The type of data contained in the column.  If Uninitialized, this function will retrieve the datatype information.</param>
        /// <returns>Returns the data in the column</returns>
        internal virtual object GetValue(SQLiteStatement stmt, int index, ref SQLiteType typ)
        {
            if (typ.Affinity == 0) typ = SQLiteConvert.ColumnToType(stmt, index);
              if (IsNull(stmt, index)) return DBNull.Value;

              Type t = SQLiteConvert.SQLiteTypeToType(typ);

              switch (TypeToAffinity(t))
              {
            case TypeAffinity.Blob:
              if (typ.Type == DbType.Guid && typ.Affinity == TypeAffinity.Text)
            return new Guid(GetText(stmt, index));

              int n = (int)GetBytes(stmt, index, 0, null, 0, 0);
              byte[] b = new byte[n];
              GetBytes(stmt, index, 0, b, 0, n);

              if (typ.Type == DbType.Guid && n == 16)
            return new Guid(b);

              return b;
            case TypeAffinity.DateTime:
              return GetDateTime(stmt, index);
            case TypeAffinity.Double:
              return Convert.ChangeType(GetDouble(stmt, index), t, null);
            case TypeAffinity.Int64:
              return Convert.ChangeType(GetInt64(stmt, index), t, null);
            default:
              return GetText(stmt, index);
              }
        }

 internal abstract string GetText(SQLiteStatement stmt, int index);

 internal abstract Int64 GetInt64(SQLiteStatement stmt, int index);

 internal abstract Int32 GetInt32(SQLiteStatement stmt, int index);

 internal abstract double GetDouble(SQLiteStatement stmt, int index);

 internal abstract DateTime GetDateTime(SQLiteStatement stmt, int index);

 internal abstract long GetChars(SQLiteStatement stmt, int index, int nDataoffset, char[] bDest, int nStart, int nLength);

 internal abstract void Bind_Int64(SQLiteStatement stmt, int index, Int64 value);

 internal abstract void Bind_Null(SQLiteStatement stmt, int index);

 internal abstract bool IsNull(SQLiteStatement stmt, int index);

 internal abstract int Bind_ParamIndex(SQLiteStatement stmt, string paramName);

 /// <summary>
 /// Prepares a SQL statement for execution.
 /// </summary>
 /// <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="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(string strSql, SQLiteStatement previous, out string strRemain);

 internal abstract void Bind_Text(SQLiteStatement stmt, int index, string value);

 /// <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);