internal static void Load(IndexRecord record)
        {
            var varColStartIndex = 0;

            LoadIndexType(record);

            LoadStatusBits(record);

            if (record.HasNullBitmap)
            {
                LoadNullBitmap(record);

                varColStartIndex = 2 + record.NullBitmapSize;
            }

            if (record.HasVariableLengthColumns)
            {
                LoadColumnOffsetArray(record, varColStartIndex);
            }

            record.VariableLengthDataOffset = (ushort)(record.Page.Header.MinLen + sizeof(short) + varColStartIndex + (sizeof(short) * record.VariableLengthColumnCount));

            LoadColumnValues(record);

            if (record.IsIndexType(IndexTypes.Node) | record.Page.Header.IndexId == 1)
            {
                LoadDownPagePointer(record);
            }

            if (record.IsIndexType(IndexTypes.Heap) && (!(record.Structure as IndexStructure).Unique | record.IsIndexType(IndexTypes.Leaf)))
            {
                LoadRid(record);
            }
        }
        private static void LoadIndexType(IndexRecord record)
        {
            if (record.Page.Header.IndexId > 0)
            {
                record.IndexType = record.IndexType | IndexTypes.NonClustered;
            }
            else
            {
                record.IndexType = record.IndexType | IndexTypes.Clustered;
            }

            if (record.Page.Header.Level > 0)
            {
                record.IndexType = record.IndexType | IndexTypes.Node;
            }
            else
            {
                record.IndexType = record.IndexType | IndexTypes.Leaf;
            }

            if ((record.Structure as IndexStructure).Heap)
            {
                record.IndexType = record.IndexType | IndexTypes.Heap;
            }
            else
            {
                record.IndexType = record.IndexType | IndexTypes.TableClustered;
            }

            record.IncludeKey = (!(record.Structure as IndexStructure).Unique &&
                                 record.IsIndexType(IndexTypes.NonClustered)) ||
                                record.IsIndexType(IndexTypes.NonClusteredLeaf);
        }
        private static void LoadRid(IndexRecord record)
        {
            int ridOffset;
            var ridAddress = new byte[8];

            if (record.IsIndexType(IndexTypes.Leaf))
            {
                ridOffset = record.SlotOffset + record.Page.Header.MinLen - 8;
            }
            else
            {
                ridOffset = record.SlotOffset + record.Page.Header.MinLen - 14;
            }

            Array.Copy(record.Page.PageData, ridOffset, ridAddress, 0, RowIdentifier.Size);

            record.Rid = new RowIdentifier(ridAddress);

            record.Mark("Rid", ridOffset, RowIdentifier.Size);
        }
        private static void LoadColumnValues(IndexRecord record)
        {
            RecordField field;

            var columnValues = new List <RecordField>();

            var index = 0;

            foreach (IndexColumn indexCol in (record.Structure as IndexStructure).Columns)
            {
                var processKeyColumn      = !indexCol.Key || (record.IncludeKey && indexCol.Key);
                var processIncludesColumn = !indexCol.IncludedColumn || (indexCol.IncludedColumn && record.IsIndexType(IndexTypes.Leaf));

                if (processKeyColumn & processIncludesColumn)
                {
                    field = new RecordField(indexCol);

                    var    length        = 0;
                    var    offset        = 0;
                    byte[] data          = null;
                    var    variableIndex = 0;

                    if (indexCol.LeafOffset >= 0)
                    {
                        // Fixed length field
                        offset = indexCol.LeafOffset;
                        length = indexCol.DataLength;
                        data   = new byte[length];

                        Array.Copy(record.Page.PageData, indexCol.LeafOffset + record.SlotOffset, data, 0, length);
                    }
                    else if (record.HasVariableLengthColumns)
                    {
                        //Variable length field
                        variableIndex = (indexCol.LeafOffset * -1) - 1;

                        if (variableIndex == 0)
                        {
                            offset = record.VariableLengthDataOffset;
                        }
                        else
                        {
                            offset = record.ColOffsetArray[variableIndex - 1];
                        }

                        if (variableIndex >= record.ColOffsetArray.Length)
                        {
                            length = 0;
                        }
                        else
                        {
                            length = record.ColOffsetArray[variableIndex] - offset;
                        }

                        data = new byte[length];

                        Array.Copy(record.Page.PageData, offset + record.SlotOffset, data, 0, length);
                    }

                    field.Offset         = offset;
                    field.Length         = length;
                    field.Data           = data;
                    field.VariableOffset = variableIndex;

                    field.Mark("Value", record.SlotOffset + field.Offset, field.Length);


                    record.Mark("FieldsArray", field.Name, index);

                    index++;

                    columnValues.Add(field);
                }
            }

            record.Fields.AddRange(columnValues);
        }