Update index.md(format of series entry) (#515)

* Update index.md
* more clear format representation
* move dots to the bottom
* update #labels count, #chunks count
* use correct variable types.

Signed-off-by: naivewong <[email protected]>

Author: krasi-georgiev

docs/format/index.md

@@ -85,34 +85,40 @@ After the labels, the number of indexed chunks is encoded, followed by a sequenc
 `mint` of the first chunk is stored, it's `maxt` is stored as a delta and the `mint` and `maxt` are encoded as deltas to the previous time for subsequent chunks. Similarly, the reference of the first chunk is stored and the next ref is stored as a delta to the previous one.
 
 ```
-┌─────────────────────────────────────────────────────────────────────────┐
-│ len <uvarint>                                                           │
-├─────────────────────────────────────────────────────────────────────────┤
-│ ┌──────────────────┬──────────────────────────────────────────────────┐ │
-│ │                  │ ┌──────────────────────────────────────────┐     │ │
-│ │                  │ │ ref(l_i.name) <uvarint>                  │     │ │
-│ │     #labels      │ ├──────────────────────────────────────────┤ ... │ │
-│ │    <uvarint>     │ │ ref(l_i.value) <uvarint>                 │     │ │
-│ │                  │ └──────────────────────────────────────────┘     │ │
-│ ├──────────────────┼──────────────────────────────────────────────────┤ │
-│ │                  │ ┌──────────────────────────────────────────┐     │ │
-│ │                  │ │ c_0.mint <varint>                        │     │ │
-│ │                  │ ├──────────────────────────────────────────┤     │ │
-│ │                  │ │ c_0.maxt - c_0.mint <uvarint>            │     │ │
-│ │                  │ ├──────────────────────────────────────────┤     │ │
-│ │                  │ │ ref(c_0.data) <uvarint>                  │     │ │
-│ │      #chunks     │ └──────────────────────────────────────────┘     │ │
-│ │     <uvarint>    │ ┌──────────────────────────────────────────┐     │ │
-│ │                  │ │ c_i.mint - c_i-1.maxt <uvarint>          │     │ │
-│ │                  │ ├──────────────────────────────────────────┤     │ │
-│ │                  │ │ c_i.maxt - c_i.mint <uvarint>            │     │ │
-│ │                  │ ├──────────────────────────────────────────┤ ... │ │
-│ │                  │ │ ref(c_i.data) - ref(c_i-1.data) <varint> │     │ │
-│ │                  │ └──────────────────────────────────────────┘     │ │
-│ └──────────────────┴──────────────────────────────────────────────────┘ │
-├─────────────────────────────────────────────────────────────────────────┤
-│ CRC32 <4b>                                                              │
-└─────────────────────────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────────────┐
+│ len <uvarint>                                                            │
+├──────────────────────────────────────────────────────────────────────────┤
+│ ┌──────────────────────────────────────────────────────────────────────┐ │
+│ │                     labels count <uvarint64>                         │ │
+│ ├──────────────────────────────────────────────────────────────────────┤ │
+│ │              ┌────────────────────────────────────────────┐          │ │
+│ │              │ ref(l_i.name) <uvarint32>                  │          │ │
+│ │              ├────────────────────────────────────────────┤          │ │
+│ │              │ ref(l_i.value) <uvarint32>                 │          │ │
+│ │              └────────────────────────────────────────────┘          │ │
+│ │                             ...                                      │ │
+│ ├──────────────────────────────────────────────────────────────────────┤ │
+│ │                     chunks count <uvarint64>                         │ │
+│ ├──────────────────────────────────────────────────────────────────────┤ │
+│ │              ┌────────────────────────────────────────────┐          │ │
+│ │              │ c_0.mint <varint64>                        │          │ │
+│ │              ├────────────────────────────────────────────┤          │ │
+│ │              │ c_0.maxt - c_0.mint <uvarint64>            │          │ │
+│ │              ├────────────────────────────────────────────┤          │ │
+│ │              │ ref(c_0.data) <uvarint64>                  │          │ │
+│ │              └────────────────────────────────────────────┘          │ │
+│ │              ┌────────────────────────────────────────────┐          │ │
+│ │              │ c_i.mint - c_i-1.maxt <uvarint64>          │          │ │
+│ │              ├────────────────────────────────────────────┤          │ │
+│ │              │ c_i.maxt - c_i.mint <uvarint64>            │          │ │
+│ │              ├────────────────────────────────────────────┤          │ │
+│ │              │ ref(c_i.data) - ref(c_i-1.data) <varint64> │          │ │
+│ │              └────────────────────────────────────────────┘          │ │
+│ │                             ...                                      │ │
+│ └──────────────────────────────────────────────────────────────────────┘ │
+├──────────────────────────────────────────────────────────────────────────┤
+│ CRC32 <4b>                                                               │
+└──────────────────────────────────────────────────────────────────────────┘
 ```
 
 
@@ -176,24 +182,24 @@ The sequence of postings sections is finalized by an [offset table](#offset-tabl
 An offset table stores a sequence of entries that maps a list of strings to an offset. They are used to track label index and postings sections. They are read into memory when an index file is loaded.
 
 ```
-┌─────────────────────┬────────────────────┐
-│ len <4b>            │ #entries <4b>      │
-├─────────────────────┴────────────────────┤
-│ ┌──────────────────────────────────────┐ │
-│ │  n = #strs <uvarint>                 │ │
-│ ├──────────────────────┬───────────────┤ │
-│ │ len(str_1) <uvarint> │ str_1 <bytes> │ │
-│ ├──────────────────────┴───────────────┤ │
-│ │  ...                                 │ │
-│ ├──────────────────────┬───────────────┤ │
-│ │ len(str_n) <uvarint> │ str_n <bytes> │ │
-│ ├──────────────────────┴───────────────┤ │
-│ │  offset <uvarint>                    │ │
-│ └──────────────────────────────────────┘ │
-│                  . . .                   │
-├──────────────────────────────────────────┤
-│  CRC32 <4b>                              │
-└──────────────────────────────────────────┘
+┌─────────────────────┬──────────────────────┐
+│ len <4b>            │ #entries <4b>        │
+├─────────────────────┴──────────────────────┤
+│ ┌────────────────────────────────────────┐ │
+│ │  n = #strs <uvarint>                   │ │
+│ ├──────────────────────┬─────────────────┤ │
+│ │ len(str_1) <uvarint> │ str_1 <bytes>   │ │
+│ ├──────────────────────┴─────────────────┤ │
+│ │  ...                                   │ │
+│ ├──────────────────────┬─────────────────┤ │
+│ │ len(str_n) <uvarint> │ str_n <bytes>   │ │
+│ ├──────────────────────┴─────────────────┤ │
+│ │  offset <uvarint64>                    │ │
+│ └────────────────────────────────────────┘ │
+│                    . . .                   │
+├────────────────────────────────────────────┤
+│  CRC32 <4b>                                │
+└────────────────────────────────────────────┘
 ```