docs: Format all markdown files

Author: ohsayan

docs/b.using-repl.md

@@ -73,15 +73,20 @@ CREATE MODEL myspace.mymodel(username: string, password: string, notes: list { t
 
 ### Add, update and remove some data
 
-- **Insert some data**: 
+- **Insert some data**:
+
   ```sql
     INSERT INTO myspace.mymodel('sayan', 'password123', [])
   ```
+
 - **Update some data**:
+
     ```sql
     UPDATE myspace.mymodel SET notes += "mynewnote" WHERE username = 'sayan'
     ```
+
 - **Select some data**:
+
     ```sql
     SELECT notes, password FROM myspace.mymodel WHERE username = 'sayan'
     ```

docs/blueql/1.overview.md

@@ -6,6 +6,7 @@ id: overview
 In this document we explore some of the meta parts of BlueQL. If you want to look at how you can use BlueQL, consider looking at the sections that follow.
 
 Design principles:
+
 - **Simplicity and clarity**: The language shouldn't be overwhelming to understand
 - **Security with mandatory parameterization**: We want to reduce the surface of injection attacks. For this reason, [parameterization is mandatory](#parameters).
 
@@ -18,17 +19,18 @@ Just like SQL, BlueQL has three categories of commands/queries inside it:
 Jump to [differences from SQL](#differences-from-sql).
 
 :::info
-This text is *not* a detailed, formal guide. It's meant for developers and users who want to work with 
-Skytable.  If you need a more formal specification, like a grammar definition, please ask us, and we'll create 
+This text is *not* a detailed, formal guide. It's meant for developers and users who want to work with
+Skytable.  If you need a more formal specification, like a grammar definition, please ask us, and we'll create
 it. We haven't published it yet because no one has requested it.
 :::
 
 ## Identifiers
+
 Can begin with any ASCII alphabet or an underscore (`_`) and then have any number of alphanumeric characters and/or underscores.
 
 ## Keywords
 
-Keywords are identifiers with special meanings and hence can't be used as identifiers in other places. Here's a full-list of 
+Keywords are identifiers with special meanings and hence can't be used as identifiers in other places. Here's a full-list of
 keywords:
 
 ```ts
@@ -45,6 +47,7 @@ keywords:
 ## Data types
 
 ### Boolean
+
 A boolean value, either `true` or `false`
 
 ### Unsigned integers
@@ -75,9 +78,11 @@ A boolean value, either `true` or `false`
 
 - `list`: a list of any of the data types, including nested lists
   - A list is represented as: `[]` with values inbetween. For example, a `list { type:string }` would be represented as:
+
     ```sql
     ["sayan", "loves", "dogs"]
     ```
+
   - **Lists cannot contain null values**
   - **List can be nested**: You can have heavily nested lists like: `[[[]], [["another one"]]]`
   - **List can only have one base type**: This means that if you have a list like `[[[string]]]` each element must either be the same nested list, or an empty list
@@ -100,6 +105,7 @@ New data types are frequently added, so treat this list as non-exhaustive.
 
 :::warning Literals are not available everywhere
 It is very important for you to know that literals are not allowed everywhere. The only literals allowed everywhere are:
+
 - Lists
 - Dictionaries
 
@@ -150,6 +156,7 @@ On a final note, BlueQL doesn't support comments of any form also for security r
 ## DDL
 
 Queries include:
+
 - Spaces:
   - `CREATE SPACE myspace [WITH { property: value, ... }]`
   - `ALTER SPACE myspace [WITH { property: updated_value, ... }]`
@@ -172,6 +179,7 @@ Queries include:
 ## DCL
 
 Queries include:
+
 - `SYSCTL REPORT STATUS`: returns the status of the system. (Not a control query per se)
 - `SYSCTL CREATE USER "username" WITH { password: ... }`: create a new user
 - `SYSCTL DROP USER "username"`: removes the user in question

docs/blueql/2.ddl.md

@@ -22,21 +22,27 @@ This is so that you're specific about what DDL object you want to manipulate.
 Exception: `INSPECT` queries will respect the currently set `SPACE` if required.
 :::
 
-### INSPECT:
+### INSPECT
 
 - **Syntax**:
   - `INSPECT GLOBAL`: returns a JSON with a list of all spaces, users and other information. For example:
+
     ```json
     {"spaces":["space1"],"users":["root"],"settings":{}}
     ```
+
   - `INSPECT SPACE <space>`: returns a JSON with a list of all models in the space and other information, For example:
+
     ```json
     {"models":["model1"],"properties":{}}
     ```
+
   - `INSPECT MODEL <space>.<model>`: returns a JSON with information about the model such as the declaration, row count and such:
+
     ```json
     {"decl":"{*username: string, !password: string, ?notes: [string]}","size":12345678,"properties":{}}
     ```
+
 - **Access control**: any
 - **Returns**: string or error
 
@@ -68,8 +74,8 @@ CREATE SPACE IF NOT EXISTS apps
 
 ### ALTER SPACE
 
-
 **Syntax:**
+
 ```sql
 ALTER SPACE <space_name> WITH { property_name: property_value }
 ```
@@ -87,6 +93,7 @@ ALTER SPACE apps WITH { new_cache_value: 1234 }
 ### DROP SPACE
 
 **Syntax:**
+
 ```sql
 DROP SPACE [IF EXISTS] [ALLOW NOT EMPTY] <space_name>
 ```
@@ -96,9 +103,11 @@ DROP SPACE [IF EXISTS] [ALLOW NOT EMPTY] <space_name>
   - **A non-empty space cannot be dropped**
       To avoid catastrophic `DROP`s, a `SPACE` can only be dropped directly if it is non-empty. To drop a non-empty space, you must
       run:
+
       ```sql
       DROP SPACE ALLOW NOT EMPTY <space_name>
     ```
+
 - **Returns**:
   - empty or error
   - when used with `if exists`: bool indicating whether the space was actually present or not
@@ -126,9 +135,11 @@ DROP SPACE ALLOW NOT EMPTY myspace
 ### CREATE MODEL
 
 **Syntax**:
+
 ```sql
 CREATE MODEL [IF NOT EXISTS] <space_name>.<model_name>([primary] [null] field_name: field_type) [ WITH {property_name: property_value} ]
 ```
+
 - **Access control**: `root` only
 - **Properties**: None
 - **Operational notes**:
@@ -151,6 +162,7 @@ CREATE MODEL IF NOT EXISTS myspace.mymodel(username: string, password: string, n
 ### ALTER MODEL ADD
 
 **Syntax:**
+
 ```sql
 -- add a single field
 ALTER MODEL <space_name>.<model_name> ADD one_field { type: string }
@@ -165,6 +177,7 @@ ALTER MODEL <space_name>.<model_name> ADD (
 - **Returns**: empty or error
 
 #### Examples
+
 ```sql
 ALTER MODEL myspace.mymodel ADD one_field { type: list { type: string } }
 ALTER MODEL myspace.mymodel ADD (
@@ -182,6 +195,7 @@ ALTER MODEL myspace.mymodel ADD (
 ### ALTER MODEL UPDATE
 
 **Syntax**
+
 ```sql
 -- update one field
 ALTER MODEL <space_name>.<model_name> UPDATE one_field { type: string }
@@ -210,6 +224,7 @@ ALTER MODEL myspace.mymodel UPDATE (
 ### ALTER MODEL REMOVE
 
 **Syntax**:
+
 ```sql
 -- remove one field
 ALTER MODEL <space_name>.<model_name> REMOVE one_field
@@ -232,6 +247,7 @@ ALTER MODEL myspace.mymodel REMOVE (useless_field_1, useless_field2)
 ### DROP MODEL
 
 **Syntax**:
+
 ```sql
 DROP MODEL [IF EXISTS] [ALLOW NOT EMPTY] <space_name>.<model_name>
 ```
@@ -240,9 +256,11 @@ DROP MODEL [IF EXISTS] [ALLOW NOT EMPTY] <space_name>.<model_name>
 - **Operational notes**
   - **Non-empty models cannot be dropped** to avoid catastrophic drops
   - **To drop a non-empty model**: you must run:
+
     ```sql
     DROP MODEL ALLOW NOT EMPTY <space_name>.<model_name>
     ```
+
 - **Returns**:
   - empty or error
   - when used with `if exists`: bool indicating whether the model was actually present or not

docs/blueql/3.dml.md

@@ -28,6 +28,7 @@ INSERT INTO <model_name> {
     ...
 }
 ```
+
 ### Requirements and responses
 
 - **Access control**: any

docs/blueql/4.dcl.md

@@ -3,15 +3,17 @@ id: dcl
 title: DCL
 ---
 
-Data Control Language or DCL can be used to perform administrative tasks on the database. Currently, all DCL commands are 
+Data Control Language or DCL can be used to perform administrative tasks on the database. Currently, all DCL commands are
 available under the `SYSCTL` query.
 
 ## SYSCTL REPORT STATUS
 
 **Syntax**:
+
 ```sql
 SYSCTL REPORT STATUS
 ```
+
 - **Access control**: any
 - **Operational notes**:
   - This returns the current overall health of the system
@@ -20,15 +22,18 @@ SYSCTL REPORT STATUS
 ## SYSCTL CREATE USER
 
 **Syntax**:
+
 ```sql
 SYSCTL CREATE USER <username> WITH { password: 'password' }
 ```
+
 - **Access control**: `root` only
 - **Returns**: empty or error
 
 ## SYSCTL ALTER USER
 
 **Syntax**:
+
 ```sql
 SYSCTL ALTER USER <username> WITH { password: 'new password' }
 ```
@@ -44,8 +49,10 @@ Trying to change the `root` account password will throw an error. You can only c
 ## SYSCTL DROP USER
 
 **Syntax**:
+
 ```sql
 SYSCTL DROP USER <username>
 ```
+
 - **Access control**: `root` only
 - **Returns**: empty or error

docs/c.architecture.md

@@ -4,18 +4,18 @@ title: Architecture
 ---
 
 Skytable is a modern NoSQL database that prioritises performance, scalability and reliability while providing a rich and powerful querying interface.
-We are generally targetting an audience that wants to build high performance, large-scale, low latency applications, such as social networking services, 
+We are generally targetting an audience that wants to build high performance, large-scale, low latency applications, such as social networking services,
 auth services, adtech and such. Skytable is designed to work with both **structured and semi-structured data**.
 
-Our goal is to provide you with a powerful and solid foundation for your application with no gimmicks — just a solid core. That's why, every component in 
+Our goal is to provide you with a powerful and solid foundation for your application with no gimmicks — just a solid core. That's why, every component in
 Skytable has been engineered from the ground up, from scratch.
 
 And all of that, without you having to be an expert, and with the least maintenance that you can expect.
 
 ## Fundamental differences from relational systems
 
-BlueQL kind of looks and feels like using SQL with a relational database but that doesn't make Skytable's internals the same, with the most important 
-distinction being the fact that Skytable has a NoSQL engine! But Skytable's evaluation and execution of queries is fundamentally different from SQL 
+BlueQL kind of looks and feels like using SQL with a relational database but that doesn't make Skytable's internals the same, with the most important
+distinction being the fact that Skytable has a NoSQL engine! But Skytable's evaluation and execution of queries is fundamentally different from SQL
 counterparts and even NoSQL engines. Here are some key differences:
 
 - All DML queries are point queries and **not** range queries:
@@ -26,18 +26,18 @@ counterparts and even NoSQL engines. Here are some key differences:
 - **Remember, in NoSQL systems we denormalize.** Hence, no `JOIN`s or foreign keys as with many other NoSQL systems
 - A different transactional model:
   - All DDL and DCL queries are ACID transactions
-  - However, DML transactions are not ACID and instead are efficiently batched and are automatically made part of a batch     
-    transaction. The engine decides *when* it will execute them, for example based on the pressure on cache. That's because our 
+  - However, DML transactions are not ACID and instead are efficiently batched and are automatically made part of a batch
+    transaction. The engine decides *when* it will execute them, for example based on the pressure on cache. That's because our
     focus is to maximize throughput
   - All these differences mean that **DDL and DCL transactions are ACID transactions** while **DML queries are ACI and *eventually* D** (we call it a *delayed durability transaction*). This delay however can be adjusted to make sure that the DML
     queries *emulate* ACID transactions but that defeats the point of the eventually durable system which aims to heavily increase throughput.
-  - The idea of eventually durable transactions relies on the idea that hardware failure even though prominent is still rare, 
+  - The idea of eventually durable transactions relies on the idea that hardware failure even though prominent is still rare,
     thanks to the extreme hard work that cloud vendors put into reliability engineering. If you plan to run on unreliable hardware, then the delay setting (reliability service) is what you need to change.
   - For extremely unreliable hardware on the other hand, we're working on a new storage driver `rtsyncblock` that is expected to be released in Q1'24
 - The transactional engine powering DDL and DCL queries might often choose to demote a transaction to a virtual transaction which makes sure that the transaction is obviously durable but not necessarily actually executed but is eventually executed. If the system crashes, the engine will still be able to actually execute the transaction (even if it crashed halfway)
 
 :::tip
-We believe you can now hopefully see how Skytable's workings are fundamentally different from traditional engines. And, we know 
+We believe you can now hopefully see how Skytable's workings are fundamentally different from traditional engines. And, we know
 that you might have a lot of questions! If you do, please reach out. We're here to help.
 :::
 
@@ -52,18 +52,19 @@ While a `MODEL` is the only data container for now, many more are set to come. N
 
 ### A `space` is like a `database`
 
-A `space` in Skytable is a collection of `model`s and other objects, and settings. It is different from a traditional SQL 
+A `space` in Skytable is a collection of `model`s and other objects, and settings. It is different from a traditional SQL
 Database (that is created with SQL's `CREATE DATABASE`) because it is not meant for tables only, but many other things.
 
 Spaces have "space local" settings that can be set for the space (and will be respected by all its `models` and other items). You'll learn more about this in the section on DDL.
 
 ### A `model` is like a `table`
 
 A `model` in Skytable is like a `table` in SQL but is vastly different because of certain concepts such as:
+
 - DML queries are point and not range queries by default
 - Restrictions on indexes
 - Settings (which can't be created in traditional `table`s)
-- Semi-structured data: with collection types in columns such as lists and dictionaries that violates some of the ideas of 
+- Semi-structured data: with collection types in columns such as lists and dictionaries that violates some of the ideas of
   traditional schema enforcement
 
 ## Query language
@@ -75,13 +76,13 @@ For example, Skytable's BlueQL<sup>TM</sup> *only* allows the parameterization o
 ## Transactions
 
 Skytable's DDL and DCL queries are all ACID transactions. However, DML queries use an AOF-style storage driver that periodically
-records, analyses and then intelligently syncs the changes to disk. We're working on making ACID transactions widely available 
+records, analyses and then intelligently syncs the changes to disk. We're working on making ACID transactions widely available
 across DML queries as well.
 
 ## Storage
 
-Skytable's storage engine is collectively called the Skytable Disk Storage Subsystem or SDSS for short. The storage engine uses 
-several different storage drivers, using ones appropriate for the task. We do not use RocksDB or any other engine but we 
+Skytable's storage engine is collectively called the Skytable Disk Storage Subsystem or SDSS for short. The storage engine uses
+several different storage drivers, using ones appropriate for the task. We do not use RocksDB or any other engine but we
 implement everything in house, engineering them piece by piece.
 
 :::info Features on track
@@ -103,8 +104,9 @@ Skytable will use atleast as many threads as the number of logical CPUs present
 
 ## Networking
 
-Skytable uses its own in-house Skyhash protocol for client-server communication. It is built on top of TCP, enabling any programming language that has a 
+Skytable uses its own in-house Skyhash protocol for client-server communication. It is built on top of TCP, enabling any programming language that has a
 TCP client to use it without issues. There are three phases in the connection:
+
 - Handshake: All auth data, compatibility information and other data is exchanged at this step
 - Connection mode selection: based on the handshake parameters a connection mode is chosen and the server responds with the chosen exchange mode
 - Data exchange: This is where the real querying happens
@@ -115,14 +117,16 @@ You can [read more about the protocol here](protocol).
 ## Backwards compatibility
 
 We make the promise to you that no matter what changes in Skytable, you will always be able to:
+
 - Upgrade from one version to another without data loss or too many hoops
 - Export data from Skytable at any time
 
 More technically:
+
 - **For minor/patch releases**: The minor/patch is just in the name but it indicates that no data migration effort is needed. **No minor releases ever need data migration, and any migration is done automatically**
 - **For major releases**: Major releases generally introduce breaking changes (just like the upgrade from `0.7.x` to `0.8.0` is a largely breaking change). **Major releases will either automatically upgrade the data files or require you to use a migration tool that is shipped with the bundle**.
 - Definitions (closely following semantic versioning):
-  - **A major release** is something like `1.0.0` to `2.0.0` or `0.8.0` to `0.9.0` (in development versions, 0.8.0 to 0.9.0 is considered a major version 
+  - **A major release** is something like `1.0.0` to `2.0.0` or `0.8.0` to `0.9.0` (in development versions, 0.8.0 to 0.9.0 is considered a major version
   bump)
   - **A minor release** is something like `1.0.0` to `1.1.0` or `0.8.0` to `0.8.1`
   - **A patch release** is something like `1.0.0` to `1.0.1` or `0.8.0` to `0.8.1` (note that in development versions there is no distinction between a minor and patch release)

docs/deployment.md

@@ -4,6 +4,7 @@ title: Deployment
 ---
 
 Here are some recommendations for deployment:
+
 1. **Make sure you have enough memory and storage!** The server will start returning errors when your server runs out of resources, as you'd expect.
 2. **When deploying on docker**:
    - Try to map the volume to a local path. We've had unwarranted data losses when we accidentally ended up running a `docker system prune`