GitBook: [master] 19 pages modified

Author: Simone Mosciatti

docs/SUMMARY.md

@@ -0,0 +1,52 @@
+# Table of contents
+
+* [zeeSQL, SQL and search by value for Redis. Fast, Simple and Reliable.](README.md)
+* [How to](how-to/README.md)
+  * [How to choose between QUERY and EXEC](how-to/choose-between-query-and-exec.md)
+  * [How to check if an index is used in zeeSQL and SQLite](how-to/check-if-the-index-is-used.md)
+  * [know-what-secondary-indexes-are defined](how-to/know-what-secondary-indexes-are-defined.md)
+  * [create-an-index](how-to/create-an-index.md)
+  * [create-a-view](how-to/create-a-view.md)
+  * [create-a-secondary-index](how-to/create-a-secondary-index.md)
+  * [How to create a trigger](how-to/create-a-trigger.md)
+  * [quickly-ingest-data](how-to/quickly-ingest-data.md)
+  * [copy-a-database](how-to/copy-a-database.md)
+  * [get-help](how-to/get-help.md)
+  * [work-with-dates](how-to/work-with-dates.md)
+  * [using-full-text-search](how-to/using-full-text-search.md)
+  * [work-with-json](how-to/work-with-json.md)
+  * [How to create a new database in zeeSQL](how-to/create-a-database.md)
+  * [How to create a new table in zeeSQL](how-to/create-a-table.md)
+  * [know-what-tables-are-defined](how-to/know-what-tables-are-defined.md)
+  * [know-what-databases-are-defined](how-to/know-what-databases-are-defined.md)
+  * [works-with-boolean](how-to/works-with-boolean.md)
+  * [How to get zeeSQL](how-to/get-zeesql.md)
+  * [know-what-secondary-indexes-are defined](how-to/know-what-secondary-indexes-are-defined-1.md)
+  * [How to get JSON output](how-to/get-json-output.md)
+  * [add-multiple-rows](how-to/add-multiple-rows.md)
+* [blog](blog/README.md)
+  * [node](blog/node/README.md)
+    * [Using RediSQL with Node.js](blog/node/using-redisql-with-node.md)
+  * [JSON on Redis via RediSQL, SQL steroids for Redis](blog/jaas.md)
+  * [golang](blog/golang/README.md)
+    * [Using RediSQL with Go\(lang\)](blog/golang/using-redisql-with-golang.md)
+  * [Doubling the performances of RediSQL, SQL steroids for Redis.](blog/performances.md)
+  * [RediSQL for analytics](blog/analytics.md)
+  * [Copying RediSQL databases](blog/copy_database.md)
+  * [Release 0.9.0 of RediSQL, SQL steroids for Redis](blog/release_0.9.0.md)
+  * [Release 0.8.0 of RediSQL, SQL steroids for Redis](blog/release_0.8.0.md)
+  * [Release 0.7.0 of RediSQL, SQL steroids for Redis](blog/release_0.7.0.md)
+  * [JSON on Redis via RediSQL, SQL steroids for Redis](blog/json-on-redis-via-redisql-sql-steroids-for-redis.md)
+  * [Release 0.6.0 of RediSQL, SQL steroids for Redis](blog/release_0.6.0.md)
+  * [python](blog/python/README.md)
+    * [using-redisql-with-python](blog/python/using-redisql-with-python.md)
+  * [Release 0.5.0 of RediSQL, SQL steroids for Redis](blog/release_0.5.0.md)
+* [References](references.md)
+* [zeeSQL, a solid product for busy developer](pro.md)
+* [zeeSQL and secondary indexes, how to search Redis key by value](secondary-indexes.md)
+* [Tutorial](tutorial.md)
+* [Pricing for zeeSQL](pricing.md)
+* [Why you should migrate from RediSQL to zeeSQL](why-migrate.md)
+* [FAQs](faqs.md)
+* [Motivation](motivations.md)
+

docs/blog/JaaS.md renamed to docs/blog/jaas.md

@@ -1,16 +1,16 @@
 # JSON on Redis via RediSQL, SQL steroids for Redis
 
-#### RediSQL, Redis on SQL steroids.
+### RediSQL, Redis on SQL steroids.
 
 RediSQL is a redis module that embeds SQLite to provide full SQL capabilities to redis.
 
-The fastest introduction to RediSQL is [our homepage](/)
+The fastest introduction to RediSQL is [our homepage](https://github.com/RedBeardLab/zeeSQL-doc/tree/70a762a22db224251819ed5ce9119aa9d87adf58/README.md)
 
-tl;dr; We build a **JSON as a Service** in less than 500 lines of javascript + RediSQL, you can check out the [whole source file here.][jaas]
+tl;dr; We build a **JSON as a Service** in less than 500 lines of javascript + RediSQL, you can check out the [whole source file here.](https://github.com/RedBeardLab/JaaS/blob/master/index.js)
 
 ## JSON as a Service in 500 lines of code + RediSQL
 
-While building web services is common to have the need to store some un-structured or semi-structured data (aka **JSON**) somewhere.
+While building web services is common to have the need to store some un-structured or semi-structured data \(aka **JSON**\) somewhere.
 
 Unfortunately, it is not always so easy.
 
@@ -20,7 +20,7 @@ If you are already using some kind of NoSQL database you may be a little luckier
 
 ## A faster solution
 
-A faster solution could be to use RediSQL exploiting the [JSON1][JSON1] extension.
+A faster solution could be to use RediSQL exploiting the [JSON1](https://www.sqlite.org/json1.html) extension.
 
 SQLite provides several interesting extensions and one of our favourites is JSON1 that allow an efficient and fast manipulation of JSON data, all inside a full SQL engine.
 
@@ -34,7 +34,7 @@ We will create JSON object that will have names and then each object will live i
 
 Then we will like to have a simple RediSQL interface like this one:
 
-```
+```text
 127.0.0.1:6379> REDISQL.EXEC_STATEMENT DB create_namespace noises
 1) DONE
 2) (integer) 1
@@ -48,12 +48,12 @@ Then we will like to have a simple RediSQL interface like this one:
 1) 1) "blablabla"
 127.0.0.1:6379> REDISQL.EXEC_STATEMENT DB extract noises animals $.dog
 1) 1) "woof"
-127.0.0.1:6379> 
+127.0.0.1:6379>
 ```
 
 Of course, we would also like to navigate complex JSONs and to add fields and values at will.
 
-```
+```text
 127.0.0.1:6379> REDISQL.EXEC_STATEMENT DB create_namespace foo
 1) DONE
 2) (integer) 1
@@ -77,15 +77,15 @@ Of course, we would also like to navigate complex JSONs and to add fields and va
 
 In this specific example we are only showing JSON, but keep in mind that the JSON field can be stored alongside the regular SQL fields as an extra field to hold any kind of unstructured data.
 
-Also please note how these APIs are quite pleasant to work with, they seem almost native to redis and thanks to redis-module we have the possibility to simply create more powerful commands. 
+Also please note how these APIs are quite pleasant to work with, they seem almost native to redis and thanks to redis-module we have the possibility to simply create more powerful commands.
 
 ## Implementation
 
 Now that we know what we are trying to achieve let's proceed to the implementation that you will see is quite simple.
 
 Usually is a good idea to start from the data structure, and in our simple, but powerful, example, we need only a single table:
 
-``` SQL
+```sql
 CREATE TABLE IF NOT EXISTS namespace ( 
     namespace TEXT PRIMARY KEY 
 ); 
@@ -103,7 +103,7 @@ We could have done everything with just `json_data` and without `namespace`, but
 
 Now that we have our data structure we can proceed with the procedures that I have show you above:
 
-``` SQL
+```sql
 -- create_namespace
 INSERT INTO namespace VALUES(?1);
 
@@ -134,7 +134,7 @@ UPDATE json_data
 
 In order to actually create those table here is an example on RediSQL that is more difficult to read but simpler to just copy and paste into the redis-cli.
 
-```
+```text
 127.0.0.1:6379> REDISQL.CREATE_DB DB
 OK
 127.0.0.1:6379> REDISQL.EXEC DB "CREATE TABLE IF NOT EXISTS namespace (namespace TEXT PRIMARY KEY);" 
@@ -155,9 +155,9 @@ OK
 OK
 ```
 
-Of course, there are a lot more commands in JSON1 API to use and explore, so I will simply [leave you the reference][JSON1].
+Of course, there are a lot more commands in JSON1 API to use and explore, so I will simply [leave you the reference](https://www.sqlite.org/json1.html).
 
-I also prepare a simple node application which exposes this exact same interface via REST API, it is a single, ~500 LOC, file that you can find [here][jaas]
+I also prepare a simple node application which exposes this exact same interface via REST API, it is a single, ~500 LOC, file that you can find [here](https://github.com/RedBeardLab/JaaS/blob/master/index.js)
 
 Feel free to use the node application as a blueprint for your next project.
 
@@ -173,7 +173,5 @@ Of course, if you have any question on RediSQL either open a public issue or wri
 
 Cheers,
 
-;)
+;\)
 
-[JSON1]: https://www.sqlite.org/json1.html
-[jaas]: https://github.com/RedBeardLab/JaaS/blob/master/index.js

docs/how-to/README.md

@@ -1,4 +1,6 @@
-# How to
+---
+description: Set of short tutorial to get you started with zeeSQL as fast as possible!
+---
 
-Set of short tutorial to get you started with zeeSQL as fast as possible!
+# How to
 

docs/how-to/check-if-the-index-is-used.md

@@ -1,7 +1,6 @@
 # How to check if an index is used in zeeSQL and SQLite
 
-This tutorial will cover both zeeSQL and SQLite.
-As you might know, zeeSQL is actually based on SQLite, so everything we say about zeeSQL can also be applied to raw SQLite.
+This tutorial will cover both zeeSQL and SQLite. As you might know, zeeSQL is actually based on SQLite, so everything we say about zeeSQL can also be applied to raw SQLite.
 
 ## What are indexes
 
@@ -11,25 +10,21 @@ They don't store the main data, but only a subset of them, usually a few columns
 
 The main point of indexes is that the data is always store sorted for the columns they are indexing.
 
-For instance, if we create an index for the `score` of some users, in the index, the scores will be stored sorted, from the smallest to the largest (or vice-versa).
+For instance, if we create an index for the `score` of some users, in the index, the scores will be stored sorted, from the smallest to the largest \(or vice-versa\).
 
-Storing the field sorted, allows a fast comparison for those fields.
-For instance, if we want to select all the users with a score greater than 20, we can look up in the index where the users with a score greater than 20 starts, and return all the users after that.
+Storing the field sorted, allows a fast comparison for those fields. For instance, if we want to select all the users with a score greater than 20, we can look up in the index where the users with a score greater than 20 starts, and return all the users after that.
 
-However, an index on the score, won't help if we are looking for all the users that played more than 15 games.
-For that query, you will need a different index.
+However, an index on the score, won't help if we are looking for all the users that played more than 15 games. For that query, you will need a different index.
 
 As your use cases become complex, and the table larger, eventually a lot of indexes will be accumulated.
 
 Then, for complex queries, it becomes very difficult to know what index, if any, is going to be used.
 
 The SQL engine has its own algorithms and heuristic to figure out, what it thinks is the fastest way to execute a query.
 
-Please note that while indexes help in retrieving information, they need to be maintained, which implies more load when the data are updated or added.
-There is a tradeoff between insertion speed, (no index, fastest insertion) and query speed (the more indexes they are, the more query will run optimally).
+Please note that while indexes help in retrieving information, they need to be maintained, which implies more load when the data are updated or added. There is a tradeoff between insertion speed, \(no index, fastest insertion\) and query speed \(the more indexes they are, the more query will run optimally\).
 
-When no index can be used to speed up a query, SQLite will fallback in a full table scan, which means that it will look at every row in the table.
-For big tables, this implies a higher latency and slower results.
+When no index can be used to speed up a query, SQLite will fallback in a full table scan, which means that it will look at every row in the table. For big tables, this implies a higher latency and slower results.
 
 ## Am I using some index?
 
@@ -39,7 +34,7 @@ SQLite, and so zeeSQL, comes with a handy command to check what the SQL engine i
 
 An example will help clarify, suppose we have two tables, `foo` and `bar`.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.CREATE_DB DB
 1) 1) "OK"
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "create table foo(a int, b int, c int);"
@@ -52,7 +47,7 @@ An example will help clarify, suppose we have two tables, `foo` and `bar`.
 
 At this point, we don't have any indexes, so any query will go through a full table scan.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "EXPLAIN QUERY PLAN select a from foo where a = 3 and b = 4 and c = 5;" NO_HEADER
 1) 1) "RESULT"
 2) 1) (integer) 2
@@ -65,7 +60,7 @@ In this example, were are scanning the whole `foo` table.
 
 Adding a simple index to the `foo` table will help SQLite in searching more efficiently the table.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "CREATE INDEX foo_a on foo(a);" NO_HEADER
 1) 1) "DONE"
 2) 1) (integer) 0
@@ -79,7 +74,7 @@ Adding a simple index to the `foo` table will help SQLite in searching more effi
 
 This works also when you are working with multiple tables.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "EXPLAIN QUERY PLAN select a from foo, bar where a = 3 and b = 4 and c = 5 and c = z;" NO_HEADER
 1) 1) "RESULT"
 2) 1) (integer) 4
@@ -96,7 +91,7 @@ On `foo`, we have the index we created previously that simplifies the search, in
 
 As soon as we add an index:
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "CREATE INDEX bar_z on bar(z);" NO_HEADER
 1) 1) "DONE"
 2) 1) (integer) 0
@@ -116,17 +111,15 @@ Now searches on both tables are using an index.
 
 One detail, on `bar` we are using a `COVERING INDEX` instead of a standard index.
 
-A standard index makes it faster to look up the id of the rows that we are interested in, but then we still need to fetch those rows from the database.
-A covering index means that you are not going to fetch extra rows because all the data you care about are already stored in the index itself.
-Note that in the query above we don't ask for any columns from the `bar` table in the result set, but we only compare that one column of `foo` is equal to one of `bar`.
+A standard index makes it faster to look up the id of the rows that we are interested in, but then we still need to fetch those rows from the database. A covering index means that you are not going to fetch extra rows because all the data you care about are already stored in the index itself. Note that in the query above we don't ask for any columns from the `bar` table in the result set, but we only compare that one column of `foo` is equal to one of `bar`.
 
 ## Composite indexes
 
 Indexes can be against a single column or against multiple columns.
 
 The more the index is specific, the faster will be your query.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "CREATE INDEX foo_b_c on foo(b, c);" NO_HEADER
 1) 1) "DONE"
 2) 1) (integer) 0
@@ -142,7 +135,7 @@ In this case, instead of using the index `foo_a` the SQLite engine prefers the o
 
 It is important to be careful between `AND` and `OR` conditions.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "EXPLAIN QUERY PLAN select a from foo where a = 3 OR b = 4 and c = 5;" NO_HEADER                                                     1) 1) "RESULT"
 2) 1) (integer) 4
    2) (integer) 0
@@ -162,7 +155,7 @@ The query seems the same, but instead of an `AND` we have an `OR`, in this case,
 
 If they were all `OR`, then a full table scan is almost guarantee, unless you don't have a separated index for each column in the table.
 
-```
+```text
 127.0.0.1:6379> ZEESQL.EXEC DB COMMAND "EXPLAIN QUERY PLAN select a from foo where a = 3 OR b = 4 OR c = 5;" NO_HEADER
 1) 1) "RESULT"
 2) 1) (integer) 2
@@ -201,18 +194,11 @@ Indexes are fundamental for every database system, however, they might be confus
 
 zeeSQL, and SQLite, provide a very simple way to check what indexes are going to be used for each of your queries, and when in doubt, it is a good idea to check it.
 
-Do not add too many indexes, they slow down insertion.
-Moreover, in small datasets, a full table scan can be fast enough.
+Do not add too many indexes, they slow down insertion. Moreover, in small datasets, a full table scan can be fast enough.
 
 Always verify your assumption about indexes.
 
 ## About zeeSQL
 
-zeeSQL is a Redis Module that provides SQL capabilities to Redis.
-It allows the creation and management of several SQL databases, each one independent from the other.
-Moreover, zeeSQL provides out-of-the-box [secondary indexes](../secondary-indexes.md) capabilities, allowing fast and easy search by value in Redis.
-
-
-[exec]: ../references.md#zeesql-exec
-[query]: ../references.md#zeesql-query
+zeeSQL is a Redis Module that provides SQL capabilities to Redis. It allows the creation and management of several SQL databases, each one independent from the other. Moreover, zeeSQL provides out-of-the-box [secondary indexes](../secondary-indexes.md) capabilities, allowing fast and easy search by value in Redis.