internal static object ReadPrimitive(ReaderBase reader, TypeCode code)
        {
            switch (code)
            {
            case TypeCode.Boolean:
                return(reader.ReadBoolean());

            case TypeCode.Byte:
                return(reader.ReadByte());

            case TypeCode.Char:
                return(reader.ReadChar());

            case TypeCode.DateTime:
                return(reader.ReadDateTime());

            case TypeCode.Decimal:
                return(reader.ReadDecimal());

            case TypeCode.Double:
                return(reader.ReadDouble());

            case TypeCode.Int16:
                return(reader.ReadInt16());

            case TypeCode.Int32:
                return(reader.ReadInt32());

            case TypeCode.Int64:
                return(reader.ReadInt64());

            case TypeCode.SByte:
                return(reader.ReadSByte());

            case TypeCode.Single:
                return(reader.ReadSingle());

            case TypeCode.String:
                return(reader.ReadString());

            case TypeCode.UInt16:
                return(reader.ReadUInt16());

            case TypeCode.UInt32:
                return(reader.ReadUInt32());

            case TypeCode.UInt64:
                return(reader.ReadUInt64());

            case TypeCode.DBNull:
                return(DBNull.Value);
            }
            return(null);
        }
        public static BTreeHeader Parse(ReaderBase reader)
        {
            reader.CheckSize(8);

            BTreeHeader res = new BTreeHeader();

            res.Type             = (BTreeType)reader.ReadByte();
            res.FirstFreeBlock   = reader.ReadUInt16();
            res.CellCount        = reader.ReadUInt16();
            res.CellContentBegin = reader.ReadUInt16();
            res.CellContentFragmentedFreeBytes = reader.ReadByte();

            if (res.Type == BTreeType.InteriorIndexBtreePage || res.Type == BTreeType.InteriorTableBtreePage)
            {
                reader.CheckSize(sizeof(uint));

                res.RightMostPointer = reader.ReadUInt32();
            }

            return(res);
        }
Ejemplo n.º 3
0
        internal static BTreePage Parse(ReaderBase reader, uint page)
        {
            // Read header
            reader.SeekPage(page);

            if (page == 1)
            {
                // Skip the first 100 bytes
                reader.Skip(DatabaseHeader.HeaderSize);
            }

            BTreeHeader header = BTreeHeader.Parse(reader);

            // Read cells
            ushort[] cellOffsets = new ushort[header.CellCount];

            for (ushort i = 0; i < header.CellCount; i++)
            {
                cellOffsets[i] = reader.ReadUInt16();
            }

            Array.Sort(cellOffsets);

            BTreePage res;

            switch (header.Type)
            {
            case BTreeType.InteriorIndexBtreePage:
                throw new ArgumentOutOfRangeException();

            case BTreeType.InteriorTableBtreePage:
                res = new BTreeInteriorTablePage(reader, page, header, cellOffsets);
                break;

            case BTreeType.LeafIndexBtreePage:
                throw new ArgumentOutOfRangeException();

            case BTreeType.LeafTableBtreePage:
                res = new BTreeLeafTablePage(reader, page, header, cellOffsets);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            res.ParseInternal();

            return(res);
        }
        internal static DatabaseHeader Parse(ReaderBase reader)
        {
            // The header is 100 bytes
            reader.CheckSize(100);

            reader.CheckMagicBytes(_expectedHeader);

            // Read header
            DatabaseHeader res = new DatabaseHeader();

            res.PageSize                       = reader.ReadUInt16();
            res.WriteVersion                   = (FileWriteVersion)reader.ReadByte();
            res.ReadVersion                    = (FileReadVersion)reader.ReadByte();
            res.ReservedSpaceAtEndOfPage       = reader.ReadByte();
            res.MaximumEmbeddedPayloadFraction = reader.ReadByte();
            res.MinimumEmbeddedPayloadFraction = reader.ReadByte();
            res.LeafPayloadFraction            = reader.ReadByte();
            res.ChangeCounter                  = reader.ReadUInt32();

            res.DatabaseSizeInPages    = reader.ReadUInt32();
            res.FirstFreelistTrunkPage = reader.ReadUInt32();
            res.FreeListPages          = reader.ReadUInt32();
            res.SchemaCookie           = reader.ReadUInt32();
            res.SchemaFormat           = reader.ReadUInt32();
            res.DefaultPageCacheSize   = reader.ReadUInt32();
            res.Value7                = reader.ReadUInt32();
            res.TextEncoding          = (SqliteEncoding)reader.ReadUInt32();
            res.UserVersion           = reader.ReadUInt32();
            res.IncrementalVacuumMode = reader.ReadUInt32();
            res.ApplicationId         = reader.ReadUInt32();

            reader.Skip(20);

            res.VersionValidFor = reader.ReadUInt32();
            res.Version         = reader.ReadUInt32();

            // TODO: Warn/err on mismatch with expected values

            return(res);
        }