Add syntax highlighting languages to various snippets.

A few hacks were needed for Bash that had newline escapes that didn't work with `bash` or `shell-session` -- these are either `python` or nothing at all.

Author: mildbyte

content/docs/0000_getting-started/0200_installation.mdx

@@ -17,7 +17,7 @@ To run the Splitgraph engine, you will need to be able to run [Docker](https://w
 
 For Linux and OSX, there's a single script:
 
-```
+```bash
 $ bash -c "$(curl -sL https://github.com/splitgraph/splitgraph/releases/latest/download/install.sh)"
 ```
 
@@ -36,7 +36,7 @@ First, get the binary for `sgr` from [the releases page](https://github.com/spli
 
 Then, create a new Splitgraph engine. Do:
 
-```
+```shell-session
 $ sgr engine add
 ```
 
@@ -68,7 +68,7 @@ The simplest way to do this is by adding `alias sgr='winpty sgr'` to your `.bash
 You can also install the Splitgraph library from pip. This is useful if you want to use the
 [Splitgraph Python API](../python_api/splitgraph) to manipulate images from your code:
 
-```
+```bash
 $ pip install splitgraph
 ```
 
@@ -81,7 +81,7 @@ on our GitHub.
 You can use Docker directly to pull and start the
 [engine](https://hub.docker.com/r/splitgraph/engine/):
 
-```
+```python
 $ docker run -d \\
     -e POSTGRES_PASSWORD=supersecure \\
     -p 5432:5432 \\
@@ -97,14 +97,14 @@ can be changed by changing the [configuration file](#configuration-file).
 
 To complete the installation, run:
 
-```
+```shell-session
 $ sgr init
 ```
 
 You can also use [docker-compose](https://docs.docker.com/compose/). A sample
 Compose configuration for the service is as follows:
 
-```
+```yaml
 version: '3'
 services:
   engine:

content/docs/0200_concepts/0300_splitfiles.mdx

@@ -7,20 +7,20 @@ Splitfiles are inspired by Dockerfiles and are the simplest way to build Splitgr
 
 Here's an example Splitfile:
 
-```
+```splitfile
 FROM splitgraph/geonames:latest IMPORT {
     SELECT
         -- Note we need to escape the closing curly brace here for the
         -- Splitfile executor.
-        substring(alternatenames FROM ',([A-Z]{3\}),') AS iata_code,
+        substring(alternatenames FROM ',([A-Z]{3\\}),') AS iata_code,
         name,
         latitude,
         longitude,
         geonameid
     FROM all_countries
     WHERE feature_code = 'AIRP'
     AND country_code = 'US'
-    AND substring(alternatenames FROM ',([A-Z]{3\}),') IS NOT NULL
+    AND substring(alternatenames FROM ',([A-Z]{3\\}),') IS NOT NULL
 } AS airports
 
 SQL {

content/docs/0300_ingesting_data/0100_load_csv_files.mdx

@@ -4,16 +4,18 @@ export const meta = {
 };
 
 <cast src="@splitgraph/content/casts/versioned/latest/import-from-csv.cast" />
+
 [Link to example](https://github.com/splitgraph/splitgraph/tree/master/examples/import-from-csv)
 
 Splitgraph supports importing data from CSV files into Postgres tables. It uses [TableSchema](https://github.com/frictionlessdata/tableschema-py)'s schema inference functionality and
 Postgres' `COPY FROM STDIN` command to ingest the actual data.
 
 To create a Splitgraph image from a CSV file:
 
-```
-    sgr init [repository_name]
-    sgr csv import -f [filename] -k [primary_key] ... [repository_name] [table_name]
-    # Import more data or alter the schema of table_name as you see fit
-    sgr commit [repository_name]
+```bash
+sgr init [repository_name]
+sgr csv import -f [filename] -k [primary_key] ... [repository_name] [table_name]
+
+# Import more data or alter the schema of table_name as you see fit
+sgr commit [repository_name]
 ```

content/docs/0300_ingesting_data/0300_foreign_data_wrappers/0200_load_mongo_collections.mdx

@@ -5,7 +5,7 @@ export const meta = {
 
 First, add this to your `.sgconfig`'s `mount_handlers` section to use [`mongo_fdw`](https://github.com/EnterpriseDB/mongo_fdw):
 
-```
+```ini
 mongo_fdw=splitgraph.hooks.mount_handlers.mount_mongo
 ```
 

content/docs/0300_ingesting_data/0300_foreign_data_wrappers/0300_load_postgres_tables.mdx

@@ -5,7 +5,7 @@ export const meta = {
 
 Add this to your `.sgconfig`'s `mount_handlers` section to use [`postgres_fdw`](https://www.postgresql.org/docs/12/postgres-fdw.html).
 
-```
+```ini
 postgres_fdw=splitgraph.hooks.mount_handlers.mount_postgres
 ```
 

content/docs/0300_ingesting_data/0300_foreign_data_wrappers/0400_load_mysql_tables.mdx

@@ -5,7 +5,7 @@ export const meta = {
 
 To mount a MySQL database into the Splitgraph engine using [`mysql_fdw`](https://github.com/EnterpriseDB/mysql_fdw), first, add this to your `.sgconfig`'s `mount_handlers` section:
 
-```
+```ini
 mysql_fdw=splitgraph.hooks.mount_handlers.mount_mysql
 ```
 

content/docs/0300_ingesting_data/0300_foreign_data_wrappers/0500_load_mount_handlers.mdx

@@ -10,10 +10,11 @@ To mount a custom database into your Splitgraph engine, you have to do three thi
 - Write a Python function that, when invoked, will create the required mountpoint on the engine and initialize
   the remote foreign data wrapper. For an example, see `mount_postgres` in `splitgraph.hooks.mount_handlers`.
 - Register the handler in your `.sgconfig` file:
-  ```ini
-  [mount_handlers]
-  handler_name=your.handler.module.handler_function
-  ```
+
+```ini
+[mount_handlers]
+handler_name=your.handler.module.handler_function
+```
 
 Registering the handler in such a way will also parse its function signature and docstring, adding the handler automatically to the `sgr` client as a subcommand, as well as making it available to be used in Splitfiles.
 
@@ -57,7 +58,7 @@ def mount_postgres(mountpoint, server, port, username, password, dbname, remote_
 
 gets made available in the `sgr` client with this help message:
 
-```
+```bash
 $ sgr mount postgres_fdw --help
 Usage: sgr mount postgres_fdw [OPTIONS] SCHEMA
 

content/docs/0400_working_with_data/0100_query_the_engine.mdx

@@ -6,7 +6,7 @@ export const meta = {
 Splitgraph images can be checked out into schemata with the same name as the repository that
 the image belongs to. For example:
 
-```
+```bash
 $ sgr checkout example/repo_1:latest
 ```
 
@@ -15,15 +15,15 @@ can access the engine via a normal database connection can interact with the che
 
 `sgr` provides a shorthand, [`sgr sql`](../sgr/image_information/sql), to run arbitrary SQL queries against the engine:
 
-```
+```bash
 $ sgr sql --schema example/repo_1 "SELECT * FROM demo"
 ```
 
 However, any other SQL client will do. For example, you can use [pgcli](https://www.pgcli.com/) to
 query and write data to the engine. In the default `sgr engine add` configuration, the connection
 string is:
 
-```
+```bash
 pgcli postgresql://sgr:password@localhost:5432/splitgraph
 ```
 
@@ -35,7 +35,7 @@ transformation on these datasets.
 
 `sgr` comes with a few routines to set up repositories with some example data:
 
-```
+```shell-session
 $ sgr example generate example/repo_1
 
 Generated example/repo_1:demo with 10 rows, image hash 103cb2da2da0
@@ -47,8 +47,9 @@ in it called `demo`. The table has two columns, `key` (an integer) and
 
 You can also inspect the currently checked out image in-depth:
 
-```
+```shell-session
 $ sgr show example/repo_1:latest
+
 Image example/repo_1:103cb2da2da000f3dce9512e3cc67434d7a3c977c0df259411c73a2687244706
 
 Created at 2020-04-06T10:14:54.184552
@@ -64,8 +65,9 @@ and one table, `demo`.
 
 Let's take a closer look at the new table.
 
-```
+```shell-session
 $ sgr table example/repo_1:latest demo
+
 Table example/repo_1:103cb2da2da000f3dce9512e3cc67434d7a3c977c0df259411c73a2687244706/demo
 
 Size: 963.00 B

content/docs/0400_working_with_data/0200_clone_vs_checkout.mdx

@@ -5,7 +5,7 @@ export const meta = {
 
 A Splitgraph repository can be cloned using [`sgr clone`](../sgr/sharing_images/clone):
 
-```
+```shell-session
 $ sgr clone some_namespace/some_repository
 ```
 
@@ -16,9 +16,10 @@ By default, cloning a Splitgraph repository is different than what happens with
 In this case, only the repository's metadata is cloned, which is lightweight compared to the
 actual data but still lets the user to get an overview of the repository.
 
-```
+```shell-session
 # This only transfers a few KB of metadata.
 $ sgr clone splitgraph/2016_election
+
 Gathering remote metadata...
 Fetched metadata for 1 image, 1 table, 20 objects and 1 tag.
 
@@ -42,8 +43,9 @@ checkout requires it. This behaviour can be overridden by passing `--download-al
 On checkout of an image, all objects that are required by that image are gathered, downloaded and
 assembled into tables in a process called "materialization".
 
-```
+```shell-session
 $ sgr checkout splitgraph/2016_election:latest
+
 Need to download 20 objects (26.75 MiB), cache occupancy: 492.69 MiB/10.00 GiB
 Fetching 20 objects, total size 26.75 MiB
 Getting download URLs from registry PostgresEngine data.splitgraph.com (5a87...@data.splitgraph.com:5432/sgregistry)...

content/docs/0400_working_with_data/0300_tracking_changes.mdx

@@ -19,7 +19,7 @@ this renders the whole repository as a tree.
 
 Let's create another example repository and give the new image a tag:
 
-```
+```shell-session
 $ sgr example generate example/repo_2
 $ sgr sql --schema example/repo_2 "SELECT * FROM demo ORDER BY key"
 $ sgr tag example/repo_2 original_data
@@ -29,7 +29,7 @@ The next step can be done from any application that can access the
 PostgreSQL database backing the Splitgraph engine, but `sgr` provides a
 shorthand to alter the generated image:
 
-```
+```shell-session
 $ sgr example alter example/repo_2
 
 Deleting 2 rows...
@@ -39,7 +39,7 @@ Adding 2 rows...
 
 Let's inspect the current state of the repository:
 
-```
+```shell-session
 $ sgr sql --schema example/repo_2 "SELECT * FROM demo ORDER BY key"
 ```
 
@@ -48,7 +48,7 @@ rows have been altered and two more rows have been added.
 
 Let's compare the `demo` table to its previous version:
 
-```
+```shell-session
 $ sgr diff example/repo_2 -v
 
 Between 97900a827962 and the current working copy: