sqlite3.cs

破解的飞信源代码

namespace Imps.Client.Data
{
    using System;
    using System.Globalization;
    using System.Runtime.InteropServices;

    internal class SQLite3 : SQLiteBase
    {
        protected SQLiteFunction[] _functionsArray;
        protected SQLiteConnectionHandle _sql;

        internal SQLite3(SQLiteDateFormats fmt) : base(fmt)
        {
        }

        internal override IntPtr AggregateContext(IntPtr context)
        {
            return UnsafeNativeMethods.sqlite3_aggregate_context_interop(context, 1);
        }

        internal override int AggregateCount(IntPtr context)
        {
            return UnsafeNativeMethods.sqlite3_aggregate_count_interop(context);
        }

        internal override void Bind_Blob(SQLiteStatement stmt, int index, byte[] blobData)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_bind_blob_interop(stmt._sqlite_stmt, index, blobData, blobData.Length, (IntPtr) (-1));
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Bind_DateTime(SQLiteStatement stmt, int index, DateTime dt)
        {
            byte[] buffer = base.ToUTF8(dt);
            int errorCode = UnsafeNativeMethods.sqlite3_bind_text_interop(stmt._sqlite_stmt, index, buffer, buffer.Length - 1, (IntPtr) (-1));
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Bind_Double(SQLiteStatement stmt, int index, double value)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_bind_double_interop(stmt._sqlite_stmt, index, ref value);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Bind_Int32(SQLiteStatement stmt, int index, int value)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_bind_int_interop(stmt._sqlite_stmt, index, value);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Bind_Int64(SQLiteStatement stmt, int index, long value)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_bind_int64_interop(stmt._sqlite_stmt, index, ref value);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Bind_Null(SQLiteStatement stmt, int index)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_bind_null_interop(stmt._sqlite_stmt, index);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override int Bind_ParamCount(SQLiteStatement stmt)
        {
            return UnsafeNativeMethods.sqlite3_bind_parameter_count_interop(stmt._sqlite_stmt);
        }

        internal override int Bind_ParamIndex(SQLiteStatement stmt, string paramName)
        {
            return UnsafeNativeMethods.sqlite3_bind_parameter_index_interop(stmt._sqlite_stmt, base.ToUTF8(paramName));
        }

        internal override string Bind_ParamName(SQLiteStatement stmt, int index)
        {
            int nativestringlen;
            return this.ToString(UnsafeNativeMethods.sqlite3_bind_parameter_name_interop(stmt._sqlite_stmt, index, out nativestringlen), nativestringlen);
        }

        internal override void Bind_Text(SQLiteStatement stmt, int index, string value)
        {
            byte[] buffer = base.ToUTF8(value);
            int errorCode = UnsafeNativeMethods.sqlite3_bind_text_interop(stmt._sqlite_stmt, index, buffer, buffer.Length - 1, (IntPtr) (-1));
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Cancel()
        {
            UnsafeNativeMethods.sqlite3_interrupt_interop(this._sql);
        }

        internal override void ChangePassword(byte[] newPasswordBytes)
        {
            int errorCode = UnsafeNativeMethods.sqlite3_rekey_interop(this._sql, newPasswordBytes, (newPasswordBytes == null) ? 0 : newPasswordBytes.Length);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
        }

        internal override void Close()
        {
            if (this._sql != null)
            {
                this._sql.Dispose();
            }
            this._sql = null;
        }

        internal override TypeAffinity ColumnAffinity(SQLiteStatement stmt, int index)
        {
            return UnsafeNativeMethods.sqlite3_column_type_interop(stmt._sqlite_stmt, index);
        }

        internal override int ColumnCount(SQLiteStatement stmt)
        {
            return UnsafeNativeMethods.sqlite3_column_count_interop(stmt._sqlite_stmt);
        }

        internal override string ColumnDatabaseName(SQLiteStatement stmt, int index)
        {
            int nativestringlen;
            return this.ToString(UnsafeNativeMethods.sqlite3_column_database_name_interop(stmt._sqlite_stmt, index, out nativestringlen), nativestringlen);
        }

        internal override int ColumnIndex(SQLiteStatement stmt, string columnName)
        {
            int num = this.ColumnCount(stmt);
            for (int i = 0; i < num; i++)
            {
                if (string.Compare(columnName, this.ColumnName(stmt, i), true, CultureInfo.InvariantCulture) == 0)
                {
                    return i;
                }
            }
            return -1;
        }

        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 ptrDataType;
            IntPtr ptrCollSeq;
            int dtLen;
            int csLen;
            int num3;
            int num4;
            int autoInc;
            int errorCode = UnsafeNativeMethods.sqlite3_table_column_metadata_interop(this._sql, base.ToUTF8(dataBase), base.ToUTF8(table), base.ToUTF8(column), out ptrDataType, out ptrCollSeq, out num3, out num4, out autoInc, out dtLen, out csLen);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
            dataType = base.ToString(ptrDataType, dtLen);
            collateSequence = base.ToString(ptrCollSeq, csLen);
            notNull = num3 == 1;
            primaryKey = num4 == 1;
            autoIncrement = autoInc == 1;
        }

        internal override string ColumnName(SQLiteStatement stmt, int index)
        {
            int nativestringlen;
            return this.ToString(UnsafeNativeMethods.sqlite3_column_name_interop(stmt._sqlite_stmt, index, out nativestringlen), nativestringlen);
        }

        internal override string ColumnOriginalName(SQLiteStatement stmt, int index)
        {
            int nativestringlen;
            return this.ToString(UnsafeNativeMethods.sqlite3_column_origin_name_interop(stmt._sqlite_stmt, index, out nativestringlen), nativestringlen);
        }

        internal override string ColumnTableName(SQLiteStatement stmt, int index)
        {
            int nativestringlen;
            return this.ToString(UnsafeNativeMethods.sqlite3_column_table_name_interop(stmt._sqlite_stmt, index, out nativestringlen), nativestringlen);
        }

        internal override string ColumnType(SQLiteStatement stmt, int index, out TypeAffinity nAffinity)
        {
            int len;
            IntPtr nativestring = UnsafeNativeMethods.sqlite3_column_decltype_interop(stmt._sqlite_stmt, index, out len);
            nAffinity = this.ColumnAffinity(stmt, index);
            if (nativestring != IntPtr.Zero)
            {
                return base.ToString(nativestring, len);
            }
            string[] typeDefinitions = stmt.TypeDefinitions;
            if (((typeDefinitions != null) && (index < typeDefinitions.Length)) && (typeDefinitions[index] != null))
            {
                return typeDefinitions[index];
            }
            switch (nAffinity)
            {
                case TypeAffinity.Int64:
                    return "BIGINT";

                case TypeAffinity.Double:
                    return "DOUBLE";

                case TypeAffinity.Blob:
                    return "BLOB";
            }
            return "TEXT";
        }

        internal override IntPtr CreateCollation(string strCollation, SQLiteCollation func)
        {
            IntPtr nCookie;
            int errorCode = UnsafeNativeMethods.sqlite3_create_collation_interop(this._sql, base.ToUTF8(strCollation), 1, 0, func, out nCookie);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
            return nCookie;
        }

        internal override IntPtr CreateFunction(string strFunction, int nArgs, SQLiteCallback func, SQLiteCallback funcstep, SQLiteCallback funcfinal)
        {
            IntPtr nCookie;
            int errorCode = UnsafeNativeMethods.sqlite3_create_function_interop(this._sql, base.ToUTF8(strFunction), nArgs, 1, func, funcstep, funcfinal, out nCookie);
            if (errorCode > 0)
            {
                throw new SQLiteException(errorCode, this.SQLiteLastError());
            }
            return nCookie;
        }

        protected override void Dispose(bool bDisposing)
        {
            this.Close();
        }

        internal override void FreeFunction(IntPtr nCookie)
        {
            UnsafeNativeMethods.sqlite3_function_free_callbackcookie(nCookie);
        }

        internal override long GetBytes(SQLiteStatement stmt, int index, int nDataOffset, byte[] bDest, int nStart, int nLength)
        {
            int length = nLength;
            int num = UnsafeNativeMethods.sqlite3_column_bytes_interop(stmt._sqlite_stmt, index);
            IntPtr ptr = UnsafeNativeMethods.sqlite3_column_blob_interop(stmt._sqlite_stmt, index);
            if (bDest == null)
            {
                return (long) num;
            }
            if ((length + nStart) > bDest.Length)
            {
                length = bDest.Length - nStart;
            }
            if ((length + nDataOffset) > num)
            {
                length = num - nDataOffset;
            }
            if (length > 0)
            {
                Marshal.Copy((IntPtr) (ptr.ToInt32() + nDataOffset), bDest, nStart, length);
            }
            else
            {
                length = 0;
            }
            return (long) length;
        }

        internal override long GetChars(SQLiteStatement stmt, int index, int nDataOffset, char[] bDest, int nStart, int nLength)
        {
            int count = nLength;
            string text = this.GetText(stmt, index);
            int length = text.Length;
            if (bDest == null)
            {
                return (long) length;
            }
            if ((count + nStart) > bDest.Length)
            {
                count = bDest.Length - nStart;
            }
            if ((count + nDataOffset) > length)
            {
                count = length - nDataOffset;
            }
            if (count > 0)
            {
                text.CopyTo(nDataOffset, bDest, nStart, count);
            }
            else
            {
                count = 0;
            }
            return (long) count;
        }

        internal override int GetCursorForTable(SQLiteStatement stmt, int db, int rootPage)
        {
            return UnsafeNativeMethods.sqlite3_table_cursor(stmt._sqlite_stmt, db, rootPage);
        }

        internal override DateTime GetDateTime(SQLiteStatement stmt, int index)
        {
            int len;
            return base.ToDateTime(UnsafeNativeMethods.sqlite3_column_text_interop(stmt._sqlite_stmt, index, out len), len);
        }

        internal override double GetDouble(SQLiteStatement stmt, int index)
        {
            double num;
            UnsafeNativeMethods.sqlite3_column_double_interop(stmt._sqlite_stmt, index, out num);
            return num;
        }

        internal override int GetInt32(SQLiteStatement stmt, int index)
        {
            return UnsafeNativeMethods.sqlite3_column_int_interop(stmt._sqlite_stmt, index);
        }

        internal override long GetInt64(SQLiteStatement stmt, int index)
        {
            long num;
            UnsafeNativeMethods.sqlite3_column_int64_interop(stmt._sqlite_stmt, index, out num);
            return num;
        }

        internal override long GetParamValueBytes(IntPtr p, int nDataOffset, byte[] bDest, int nStart, int nLength)
        {
            int length = nLength;
            int num = UnsafeNativeMethods.sqlite3_value_bytes_interop(p);