DEV: fix headings in indexing page (#505)

Author: dwdougherty

content/develop/use/patterns/indexes/index.md

@@ -9,9 +9,7 @@ categories:
 - oss
 - kubernetes
 - clients
-description: 'Building secondary indexes in Redis
-
-  '
+description: Building secondary indexes in Redis
 linkTitle: Secondary indexing
 title: Secondary indexing
 weight: 1
@@ -31,8 +29,7 @@ users that need to perform complex queries on data should understand if they
 are better served by a relational store. However often, especially in caching
 scenarios, there is the explicit need to store indexed data into Redis in order to speedup common queries which require some form of indexing in order to be executed.
 
-Simple numerical indexes with sorted sets
-===
+## Simple numerical indexes with sorted sets
 
 The simplest secondary index you can create with Redis is by using the
 sorted set data type, which is a data structure representing a set of
@@ -79,8 +76,7 @@ reversed order, which is often useful when data is indexed in a given
 direction (ascending or descending) but we want to retrieve information
 the other way around.
 
-Using objects IDs as associated values
----
+### Using objects IDs as associated values
 
 In the above example we associated names to ages. However in general we
 may want to index some field of an object which is stored elsewhere.
@@ -111,8 +107,7 @@ In the next examples we'll almost always use IDs as values associated with
 the index, since this is usually the more sounding design, with a few
 exceptions.
 
-Updating simple sorted set indexes
----
+### Updating simple sorted set indexes
 
 Often we index things which change over time. In the above
 example, the age of the user changes every year. In such a case it would
@@ -133,8 +128,7 @@ to execute the following two commands:
 The operation may be wrapped in a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) transaction in order to
 make sure both fields are updated or none.
 
-Turning multi dimensional data into linear data
----
+### Turning multi dimensional data into linear data
 
 Indexes created with sorted sets are able to index only a single numerical
 value. Because of this you may think it is impossible to index something
@@ -151,8 +145,7 @@ linear score of a sorted set to many small *squares* in the earth surface.
 By doing an 8+1 style center plus neighborhoods search it is possible to
 retrieve elements by radius.
 
-Limits of the score
----
+### Limits of the score
 
 Sorted set elements scores are double precision floats. It means that
 they can represent different decimal or integer values with different
@@ -165,8 +158,7 @@ When representing much larger numbers, you need a different form of indexing
 that is able to index numbers at any precision, called a lexicographical
 index.
 
-Lexicographical indexes
-===
+## Lexicographical indexes
 
 Redis sorted sets have an interesting property. When elements are added
 with the same score, they are sorted lexicographically, comparing the
@@ -229,8 +221,7 @@ string and the infinitely positive string, which are `-` and `+`.
 
 That's it basically. Let's see how to use these features to build indexes.
 
-A first example: completion
----
+### A first example: completion
 
 An interesting application of indexing is completion. Completion is what
 happens when you start typing your query into a search engine: the user
@@ -256,8 +247,7 @@ as start, and the same string plus a trailing byte set to 255, which is `\xff` i
 
 Note that we don't want too many items returned, so we may use the **LIMIT** option in order to reduce the number of results.
 
-Adding frequency into the mix
----
+### Adding frequency into the mix
 
 The above approach is a bit naive, because all the user searches are the same
 in this way. In a real system we want to complete strings according to their
@@ -320,8 +310,7 @@ A refinement to this algorithm is to pick entries in the list according to
 their weight: the higher the score, the less likely entries are picked
 in order to decrement its score, or evict them.
 
-Normalizing strings for case and accents
----
+### Normalizing strings for case and accents
 
 In the completion examples we always used lowercase strings. However
 reality is much more complex than that: languages have capitalized names,
@@ -343,8 +332,7 @@ Basically we add another field that we'll extract and use only for
 visualization. Ranges will always be computed using the normalized strings
 instead. This is a common trick which has multiple applications.
 
-Adding auxiliary information in the index
----
+### Adding auxiliary information in the index
 
 When using a sorted set in a direct way, we have two different attributes
 for each object: the score, which we use as an index, and an associated
@@ -380,8 +368,7 @@ that the separator will never happen to be part of the key.
 For example if you use two null bytes as separator `"\0\0"`, you may
 want to always escape null bytes into two bytes sequences in your strings.
 
-Numerical padding
----
+### Numerical padding
 
 Lexicographical indexes may look like good only when the problem at hand
 is to index strings. Actually it is very simple to use this kind of index
@@ -410,8 +397,7 @@ decimal part with trailing zeroes like in the following list of numbers:
         00000002121241.34893482930000
         00999999999999.00000000000000
 
-Using numbers in binary form
----
+### Using numbers in binary form
 
 Storing numbers in decimal may use too much memory. An alternative approach
 is just to store numbers, for example 128 bit integers, directly in their
@@ -423,8 +409,7 @@ the least significant bytes. This way when Redis compares the strings with
 Keep in mind that data stored in binary format is less observable for
 debugging, harder to parse and export. So it is definitely a trade off.
 
-Composite indexes
-===
+## Composite indexes
 
 So far we explored ways to index single fields. However we all know that
 SQL stores are able to create indexes using multiple fields. For example
@@ -481,8 +466,7 @@ ID 90, regardless of the *current* fields values of the object, we just
 have to retrieve the hash value by object ID and [`ZREM`]({{< relref "/commands/zrem" >}}) it in the sorted
 set view.
 
-Representing and querying graphs using a hexastore
-===
+## Representing and querying graphs using a hexastore
 
 One cool thing about composite indexes is that they are handy in order
 to represent graphs, using a data structure which is called
@@ -538,8 +522,7 @@ matteocollina.
 
 Make sure to check [Matteo Collina's slides about Levelgraph](http://nodejsconfit.levelgraph.io/) in order to better understand these ideas.
 
-Multi dimensional indexes
-===
+## Multi dimensional indexes
 
 A more complex type of index is an index that allows you to perform queries
 where two or more variables are queried at the same time for specific
@@ -703,8 +686,7 @@ For now, the good thing is that the complexity may be easily encapsulated
 inside a library that can be used in order to perform indexing and queries.
 One example of such library is [Redimension](https://github.com/antirez/redimension), a proof of concept Ruby library which indexes N-dimensional data inside Redis using the technique described here.
 
-Multi dimensional indexes with negative or floating point numbers
-===
+## Multi dimensional indexes with negative or floating point numbers
 
 The simplest way to represent negative values is just to work with unsigned
 integers and represent them using an offset, so that when you index, before
@@ -715,8 +697,7 @@ For floating point numbers, the simplest approach is probably to convert them
 to integers by multiplying the integer for a power of ten proportional to the
 number of digits after the dot you want to retain.
 
-Non range indexes
-===
+## Non range indexes
 
 So far we checked indexes which are useful to query by range or by single
 item. However other Redis data structures such as Sets or Lists can be used
@@ -741,8 +722,7 @@ are added with [`LPUSH`]({{< relref "/commands/lpush" >}}) and trimmed with [`LT
 with just the latest N items encountered, in the same order they were
 seen.
 
-Index inconsistency
-===
+## Index inconsistency
 
 Keeping the index updated may be challenging, in the course of months
 or years it is possible that inconsistencies are added because of software