Index: System.Data.SQLite/SQLiteCommand.cs
==================================================================
--- System.Data.SQLite/SQLiteCommand.cs
+++ System.Data.SQLite/SQLiteCommand.cs
@@ -40,11 +40,11 @@
     /// </summary>
     private SQLiteConnection _cnn;
     /// <summary>
     /// The version of the connection the command is associated with
     /// </summary>
-    private long _version;
+    private int _version;
     /// <summary>
     /// Indicates whether or not a DataReader is active on the command.
     /// </summary>
     private WeakReference _activeReader;
     /// <summary>

Index: System.Data.SQLite/SQLiteConnection.cs
==================================================================
--- System.Data.SQLite/SQLiteConnection.cs
+++ System.Data.SQLite/SQLiteConnection.cs
@@ -518,11 +518,11 @@
     /// </summary>
     private bool _parseViaFramework;
 
     internal bool _binaryGuid;
 
-    internal long _version;
+    internal int _version;
 
     private event SQLiteAuthorizerEventHandler _authorizerHandler;
     private event SQLiteUpdateEventHandler _updateHandler;
     private event SQLiteCommitHandler _commitHandler;
     private event SQLiteTraceEventHandler _traceHandler;

Index: System.Data.SQLite/SQLiteDataReader.cs
==================================================================
--- System.Data.SQLite/SQLiteDataReader.cs
+++ System.Data.SQLite/SQLiteDataReader.cs
@@ -86,11 +86,11 @@
     private SQLiteKeyReader _keyInfo;
 
     /// <summary>
     /// Matches the version of the connection.
     /// </summary>
-    internal long _version;
+    internal int _version;
 
     /// <summary>
     /// The "stub" (i.e. placeholder) base schema name to use when returning
     /// column schema information.  Matches the base schema name used by the
     /// associated connection.
@@ -267,11 +267,13 @@
         throw new InvalidOperationException("DataReader has been closed");
 
       if (_version == 0)
         throw new SQLiteException("Execution was aborted by the user");
 
-      if (_command.Connection.State != ConnectionState.Open || _command.Connection._version != _version)
+      SQLiteConnection connection = _command.Connection;
+
+      if (connection._version != _version || connection.State != ConnectionState.Open)
         throw new InvalidOperationException("Connection was closed, statement was terminated");
     }
 
     /// <summary>
     /// Throw an error if a row is not loaded
@@ -344,10 +346,15 @@
             CheckClosed();
 
             return _stepCount;
         }
     }
+
+    private int PrivateVisibleFieldCount
+    {
+        get { return _fieldCount; }
+    }
 
     /// <summary>
     /// Returns the number of visible fields in the current resultset
     /// </summary>
     public override int VisibleFieldCount
@@ -354,13 +361,22 @@
     {
       get
       {
         CheckDisposed();
         CheckClosed();
-        return _fieldCount;
+        return PrivateVisibleFieldCount;
       }
     }
+
+    /// <summary>
+    /// This method is used to make sure the result set is open and a row is currently available.
+    /// </summary>
+    private void VerifyForGet()
+    {
+        CheckClosed();
+        CheckValidRow();
+    }
 
     /// <summary>
     /// SQLite is inherently un-typed.  All datatypes in SQLite are natively strings.  The definition of the columns of a table
     /// and the affinity of returned types are all we have to go on to type-restrict data in the reader.
     ///
@@ -373,81 +389,80 @@
     /// </returns>
     /// <param name="i">The index of the column to type-check</param>
     /// <param name="typ">The type we want to get out of the column</param>
     private TypeAffinity VerifyType(int i, DbType typ)
     {
-      CheckClosed();
-      CheckValidRow();
-
-      TypeAffinity affinity = GetSQLiteType(_flags, i).Affinity;
-
-      switch (affinity)
-      {
-        case TypeAffinity.Int64:
-          if (typ == DbType.Int16) return affinity;
-          if (typ == DbType.Int32) return affinity;
-          if (typ == DbType.Int64) return affinity;
-          if (typ == DbType.Boolean) return affinity;
-          if (typ == DbType.SByte) return affinity;
-          if (typ == DbType.Byte) return affinity;
-          if (typ == DbType.DateTime) return affinity;
-          if (typ == DbType.Single) return affinity;
-          if (typ == DbType.Double) return affinity;
-          if (typ == DbType.Decimal) return affinity;
-          break;
-        case TypeAffinity.Double:
-          if (typ == DbType.Single) return affinity;
-          if (typ == DbType.Double) return affinity;
-          if (typ == DbType.Decimal) return affinity;
-          if (typ == DbType.DateTime) return affinity;
-          break;
-        case TypeAffinity.Text:
-          if (typ == DbType.String) return affinity;
-          if (typ == DbType.Guid) return affinity;
-          if (typ == DbType.DateTime) return affinity;
-          if (typ == DbType.Decimal) return affinity;
-          break;
-        case TypeAffinity.Blob:
-          if (typ == DbType.Guid) return affinity;
-          if (typ == DbType.String) return affinity;
-          if (typ == DbType.Binary) return affinity;
-          break;
-      }
-
-      throw new InvalidCastException();
+        TypeAffinity affinity = GetSQLiteType(_flags, i).Affinity;
+
+        switch (affinity)
+        {
+            case TypeAffinity.Int64:
+                if (typ == DbType.Int64) return affinity;
+                if (typ == DbType.Int32) return affinity;
+                if (typ == DbType.Int16) return affinity;
+                if (typ == DbType.Byte) return affinity;
+                if (typ == DbType.SByte) return affinity;
+                if (typ == DbType.Boolean) return affinity;
+                if (typ == DbType.DateTime) return affinity;
+                if (typ == DbType.Double) return affinity;
+                if (typ == DbType.Single) return affinity;
+                if (typ == DbType.Decimal) return affinity;
+                break;
+            case TypeAffinity.Double:
+                if (typ == DbType.Double) return affinity;
+                if (typ == DbType.Single) return affinity;
+                if (typ == DbType.Decimal) return affinity;
+                if (typ == DbType.DateTime) return affinity;
+                break;
+            case TypeAffinity.Text:
+                if (typ == DbType.String) return affinity;
+                if (typ == DbType.Guid) return affinity;
+                if (typ == DbType.DateTime) return affinity;
+                if (typ == DbType.Decimal) return affinity;
+                break;
+            case TypeAffinity.Blob:
+                if (typ == DbType.Guid) return affinity;
+                if (typ == DbType.Binary) return affinity;
+                if (typ == DbType.String) return affinity;
+                break;
+        }
+
+        throw new InvalidCastException();
     }
 
     /// <summary>
     /// Retrieves the column as a boolean value
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>bool</returns>
     public override bool GetBoolean(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetBoolean(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetBoolean(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Boolean);
-      return Convert.ToBoolean(GetValue(i), CultureInfo.CurrentCulture);
+        VerifyType(i, DbType.Boolean);
+        return Convert.ToBoolean(GetValue(i), CultureInfo.CurrentCulture);
     }
 
     /// <summary>
     /// Retrieves the column as a single byte value
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>byte</returns>
     public override byte GetByte(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetByte(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetByte(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Byte);
-      return Convert.ToByte(_activeStatement._sql.GetInt32(_activeStatement, i));
+        VerifyType(i, DbType.Byte);
+        return Convert.ToByte(_activeStatement._sql.GetInt32(_activeStatement, i));
     }
 
     /// <summary>
     /// Retrieves a column as an array of bytes (blob)
     /// </summary>
@@ -460,33 +475,35 @@
     /// <remarks>
     /// To determine the number of bytes in the column, pass a null value for the buffer.  The total length will be returned.
     /// </remarks>
     public override long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetBytes(i - VisibleFieldCount, fieldOffset, buffer, bufferoffset, length);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetBytes(i - PrivateVisibleFieldCount, fieldOffset, buffer, bufferoffset, length);
 
-      VerifyType(i, DbType.Binary);
-      return _activeStatement._sql.GetBytes(_activeStatement, i, (int)fieldOffset, buffer, bufferoffset, length);
+        VerifyType(i, DbType.Binary);
+        return _activeStatement._sql.GetBytes(_activeStatement, i, (int)fieldOffset, buffer, bufferoffset, length);
     }
 
     /// <summary>
     /// Returns the column as a single character
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>char</returns>
     public override char GetChar(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetChar(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetChar(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.SByte);
-      return Convert.ToChar(_activeStatement._sql.GetInt32(_activeStatement, i));
+        VerifyType(i, DbType.SByte);
+        return Convert.ToChar(_activeStatement._sql.GetInt32(_activeStatement, i));
     }
 
     /// <summary>
     /// Retrieves a column as an array of chars (blob)
     /// </summary>
@@ -499,199 +516,209 @@
     /// <remarks>
     /// To determine the number of characters in the column, pass a null value for the buffer.  The total length will be returned.
     /// </remarks>
     public override long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetChars(i - VisibleFieldCount, fieldoffset, buffer, bufferoffset, length);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetChars(i - PrivateVisibleFieldCount, fieldoffset, buffer, bufferoffset, length);
 
-      VerifyType(i, DbType.String);
-      return _activeStatement._sql.GetChars(_activeStatement, i, (int)fieldoffset, buffer, bufferoffset, length);
+        VerifyType(i, DbType.String);
+        return _activeStatement._sql.GetChars(_activeStatement, i, (int)fieldoffset, buffer, bufferoffset, length);
     }
 
     /// <summary>
     /// Retrieves the name of the back-end datatype of the column
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>string</returns>
     public override string GetDataTypeName(int i)
     {
-      CheckDisposed();
-
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetDataTypeName(i - VisibleFieldCount);
-
-      SQLiteType typ = GetSQLiteType(_flags, i);
-      if (typ.Type == DbType.Object) return SQLiteConvert.SQLiteTypeToType(typ).Name;
-      return _activeStatement._sql.ColumnType(_activeStatement, i, out typ.Affinity);
+        CheckDisposed();
+        VerifyForGet();
+
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetDataTypeName(i - PrivateVisibleFieldCount);
+
+        SQLiteType typ = GetSQLiteType(_flags, i);
+        if (typ.Type == DbType.Object) return SQLiteConvert.SQLiteTypeToType(typ).Name;
+        return _activeStatement._sql.ColumnType(_activeStatement, i, out typ.Affinity);
     }
 
     /// <summary>
     /// Retrieve the column as a date/time value
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>DateTime</returns>
     public override DateTime GetDateTime(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetDateTime(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetDateTime(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.DateTime);
-      return _activeStatement._sql.GetDateTime(_activeStatement, i);
+        VerifyType(i, DbType.DateTime);
+        return _activeStatement._sql.GetDateTime(_activeStatement, i);
     }
 
     /// <summary>
     /// Retrieve the column as a decimal value
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>decimal</returns>
     public override decimal GetDecimal(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetDecimal(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetDecimal(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Decimal);
-      return Decimal.Parse(_activeStatement._sql.GetText(_activeStatement, i), NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture);
+        VerifyType(i, DbType.Decimal);
+        return Decimal.Parse(_activeStatement._sql.GetText(_activeStatement, i), NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture);
     }
 
     /// <summary>
     /// Returns the column as a double
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>double</returns>
     public override double GetDouble(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetDouble(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetDouble(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Double);
-      return _activeStatement._sql.GetDouble(_activeStatement, i);
+        VerifyType(i, DbType.Double);
+        return _activeStatement._sql.GetDouble(_activeStatement, i);
     }
 
     /// <summary>
     /// Returns the .NET type of a given column
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>Type</returns>
     public override Type GetFieldType(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetFieldType(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetFieldType(i - PrivateVisibleFieldCount);
 
-      return SQLiteConvert.SQLiteTypeToType(GetSQLiteType(_flags, i));
+        return SQLiteConvert.SQLiteTypeToType(GetSQLiteType(_flags, i));
     }
 
     /// <summary>
     /// Returns a column as a float value
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>float</returns>
     public override float GetFloat(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetFloat(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetFloat(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Single);
-      return Convert.ToSingle(_activeStatement._sql.GetDouble(_activeStatement, i));
+        VerifyType(i, DbType.Single);
+        return Convert.ToSingle(_activeStatement._sql.GetDouble(_activeStatement, i));
     }
 
     /// <summary>
     /// Returns the column as a Guid
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>Guid</returns>
     public override Guid GetGuid(int i)
     {
-      CheckDisposed();
-
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetGuid(i - VisibleFieldCount);
-
-      TypeAffinity affinity = VerifyType(i, DbType.Guid);
-      if (affinity == TypeAffinity.Blob)
-      {
-        byte[] buffer = new byte[16];
-        _activeStatement._sql.GetBytes(_activeStatement, i, 0, buffer, 0, 16);
-        return new Guid(buffer);
-      }
-      else
-        return new Guid(_activeStatement._sql.GetText(_activeStatement, i));
+        CheckDisposed();
+        VerifyForGet();
+
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetGuid(i - PrivateVisibleFieldCount);
+
+        TypeAffinity affinity = VerifyType(i, DbType.Guid);
+        if (affinity == TypeAffinity.Blob)
+        {
+            byte[] buffer = new byte[16];
+            _activeStatement._sql.GetBytes(_activeStatement, i, 0, buffer, 0, 16);
+            return new Guid(buffer);
+        }
+        else
+            return new Guid(_activeStatement._sql.GetText(_activeStatement, i));
     }
 
     /// <summary>
     /// Returns the column as a short
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>Int16</returns>
     public override Int16 GetInt16(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetInt16(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetInt16(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Int16);
-      return Convert.ToInt16(_activeStatement._sql.GetInt32(_activeStatement, i));
+        VerifyType(i, DbType.Int16);
+        return Convert.ToInt16(_activeStatement._sql.GetInt32(_activeStatement, i));
     }
 
     /// <summary>
     /// Retrieves the column as an int
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>Int32</returns>
     public override Int32 GetInt32(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetInt32(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetInt32(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Int32);
-      return _activeStatement._sql.GetInt32(_activeStatement, i);
+        VerifyType(i, DbType.Int32);
+        return _activeStatement._sql.GetInt32(_activeStatement, i);
     }
 
     /// <summary>
     /// Retrieves the column as a long
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>Int64</returns>
     public override Int64 GetInt64(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetInt64(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetInt64(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.Int64);
-      return _activeStatement._sql.GetInt64(_activeStatement, i);
+        VerifyType(i, DbType.Int64);
+        return _activeStatement._sql.GetInt64(_activeStatement, i);
     }
 
     /// <summary>
     /// Retrieves the name of the column
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>string</returns>
     public override string GetName(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetName(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetName(i - PrivateVisibleFieldCount);
 
-      return _activeStatement._sql.ColumnName(_activeStatement, i);
+        return _activeStatement._sql.ColumnName(_activeStatement, i);
     }
 
     /// <summary>
     /// Retrieves the i of a column, given its name
     /// </summary>
@@ -698,11 +725,12 @@
     /// <param name="name">The name of the column to retrieve</param>
     /// <returns>The int i of the column</returns>
     public override int GetOrdinal(string name)
     {
       CheckDisposed();
-      CheckClosed();
+      VerifyForGet();
+
       if (_throwOnDisposed) SQLiteCommand.Check(_command);
 
       //
       // NOTE: First, check if the column name cache has been initialized yet.
       //       If not, do it now.
@@ -725,11 +753,11 @@
           r = _activeStatement._sql.ColumnIndex(_activeStatement, name);
 
           if (r == -1 && _keyInfo != null)
           {
               r = _keyInfo.GetOrdinal(name);
-              if (r > -1) r += VisibleFieldCount;
+              if (r > -1) r += PrivateVisibleFieldCount;
           }
 
           _fieldIndexes.Add(name, r);
       }
 
@@ -1123,48 +1151,49 @@
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>string</returns>
     public override string GetString(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetString(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetString(i - PrivateVisibleFieldCount);
 
-      VerifyType(i, DbType.String);
-      return _activeStatement._sql.GetText(_activeStatement, i);
+        VerifyType(i, DbType.String);
+        return _activeStatement._sql.GetText(_activeStatement, i);
     }
 
     /// <summary>
     /// Retrieves the column as an object corresponding to the underlying datatype of the column
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>object</returns>
     public override object GetValue(int i)
     {
-      CheckDisposed();
-      CheckValidRow();
-
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.GetValue(i - VisibleFieldCount);
-
-      SQLiteType typ = GetSQLiteType(_flags, i);
-
-      if (((_flags & SQLiteConnectionFlags.DetectTextAffinity) == SQLiteConnectionFlags.DetectTextAffinity) &&
-          ((typ == null) || (typ.Affinity == TypeAffinity.Text)))
-      {
-          typ = GetSQLiteType(
-              typ, _activeStatement._sql.GetText(_activeStatement, i));
-      }
-      else if (((_flags & SQLiteConnectionFlags.DetectStringType) == SQLiteConnectionFlags.DetectStringType) &&
-          ((typ == null) || SQLiteConvert.IsStringDbType(typ.Type)))
-      {
-          typ = GetSQLiteType(
-              typ, _activeStatement._sql.GetText(_activeStatement, i));
-      }
-
-      return _activeStatement._sql.GetValue(_activeStatement, _flags, i, typ);
+        CheckDisposed();
+        VerifyForGet();
+
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.GetValue(i - PrivateVisibleFieldCount);
+
+        SQLiteType typ = GetSQLiteType(_flags, i);
+
+        if (((_flags & SQLiteConnectionFlags.DetectTextAffinity) == SQLiteConnectionFlags.DetectTextAffinity) &&
+            ((typ == null) || (typ.Affinity == TypeAffinity.Text)))
+        {
+            typ = GetSQLiteType(
+                typ, _activeStatement._sql.GetText(_activeStatement, i));
+        }
+        else if (((_flags & SQLiteConnectionFlags.DetectStringType) == SQLiteConnectionFlags.DetectStringType) &&
+            ((typ == null) || SQLiteConvert.IsStringDbType(typ.Type)))
+        {
+            typ = GetSQLiteType(
+                typ, _activeStatement._sql.GetText(_activeStatement, i));
+        }
+
+        return _activeStatement._sql.GetValue(_activeStatement, _flags, i, typ);
     }
 
     /// <summary>
     /// Retreives the values of multiple columns, up to the size of the supplied array
     /// </summary>
@@ -1200,11 +1229,11 @@
         CheckDisposed();
 
         if ((_activeStatement == null) || (_activeStatement._sql == null))
             throw new InvalidOperationException();
 
-        int nMax = VisibleFieldCount;
+        int nMax = PrivateVisibleFieldCount;
         NameValueCollection result = new NameValueCollection(nMax);
 
         for (int n = 0; n < nMax; n++)
         {
             string name = _activeStatement._sql.ColumnName(_activeStatement, n);
@@ -1260,16 +1289,17 @@
     /// </summary>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>True or False</returns>
     public override bool IsDBNull(int i)
     {
-      CheckDisposed();
+        CheckDisposed();
+        VerifyForGet();
 
-      if (i >= VisibleFieldCount && _keyInfo != null)
-        return _keyInfo.IsDBNull(i - VisibleFieldCount);
+        if (i >= PrivateVisibleFieldCount && _keyInfo != null)
+            return _keyInfo.IsDBNull(i - PrivateVisibleFieldCount);
 
-      return _activeStatement._sql.IsNull(_activeStatement, i);
+        return _activeStatement._sql.IsNull(_activeStatement, i);
     }
 
     /// <summary>
     /// Moves to the next resultset in multiple row-returning SQL command.
     /// </summary>
@@ -1358,12 +1388,12 @@
         }
 
         // Ahh, we found a row-returning resultset eligible to be returned!
         _activeStatement = stmt;
         _fieldCount = fieldCount;
-        _fieldIndexes = null;
-        _fieldTypeArray = null;
+        _fieldIndexes = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
+        _fieldTypeArray = new SQLiteType[PrivateVisibleFieldCount];
 
         if ((_commandBehavior & CommandBehavior.KeyInfo) != 0)
           LoadKeyInfo();
 
         return true;
@@ -1446,29 +1476,33 @@
     /// <param name="flags">The flags associated with the parent connection object.</param>
     /// <param name="i">The index of the column to retrieve</param>
     /// <returns>A SQLiteType structure</returns>
     private SQLiteType GetSQLiteType(SQLiteConnectionFlags flags, int i)
     {
-      SQLiteType typ;
-
-      // Initialize the field types array if not already initialized
-      if (_fieldTypeArray == null)
-        _fieldTypeArray = new SQLiteType[VisibleFieldCount];
-
-      // Initialize this column's field type instance
-      if (_fieldTypeArray[i] == null) _fieldTypeArray[i] = new SQLiteType();
-
-      typ = _fieldTypeArray[i];
-
-      // If not initialized, then fetch the declared column datatype and attempt to convert it
-      // to a known DbType.
-      if (typ.Affinity == TypeAffinity.Uninitialized)
-        typ.Type = SQLiteConvert.TypeNameToDbType(GetConnection(this), _activeStatement._sql.ColumnType(_activeStatement, i, out typ.Affinity), flags);
-      else
-        typ.Affinity = _activeStatement._sql.ColumnAffinity(_activeStatement, i);
-
-      return typ;
+        SQLiteType typ = _fieldTypeArray[i];
+
+        if (typ == null)
+        {
+            // Initialize this column's field type instance
+            typ = _fieldTypeArray[i] = new SQLiteType();
+        }
+
+        // If not initialized, then fetch the declared column datatype and attempt to convert it
+        // to a known DbType.
+        if (typ.Affinity == TypeAffinity.Uninitialized)
+        {
+            typ.Type = SQLiteConvert.TypeNameToDbType(
+                GetConnection(this), _activeStatement._sql.ColumnType(
+                _activeStatement, i, out typ.Affinity), flags);
+        }
+        else
+        {
+            typ.Affinity = _activeStatement._sql.ColumnAffinity(
+                _activeStatement, i);
+        }
+
+        return typ;
     }
 
     /// <summary>
     /// Reads the next row from the resultset
     /// </summary>

Index: System.Data.SQLite/SQLiteTransaction.cs
==================================================================
--- System.Data.SQLite/SQLiteTransaction.cs
+++ System.Data.SQLite/SQLiteTransaction.cs
@@ -19,11 +19,11 @@
   {
     /// <summary>
     /// The connection to which this transaction is bound
     /// </summary>
     internal SQLiteConnection _cnn;
-    internal long _version; // Matches the version of the connection
+    internal int _version; // Matches the version of the connection
     private IsolationLevel _level;
 
     /// <summary>
     /// Constructs the transaction object, binding it to the supplied connection
     /// </summary>