<p>These articles will tell you all you need to know about creating apps on Slight.</p>


<h1 id="what-is-an-app">What Is an App?<a href="#what-is-an-app"><Link2Icon /></a></h1>
<p>We use the term a lot: what do we mean? In Slight Run an app, or a data app, is
a piece of code (SQL for now, but could be Python for example) that optionally
takes user input, runnable either on demand or on a schedule, that performs some
task. Typically the task is data related: for now they return data. Finally, the
app can be run through a graphical interface (for example, this website) or by
an API.</p>
<p>OK not amazingly insightful. To be more specific, in the current version of
Slight an app is a parametrised SQL query. So they take user input in the form
of variables, and return data that the user can play with in the browser or
download. For a simple example, see this <Link href="/apps/colman/covid-19_summary_statistics_by_country" passHref><a>COVID-19 summary
statistics</a></Link> app that takes
in a start and end date and an optional country filter and returns some
statistics per country.</p>
<p>This is the style of app detailed in the <Link href="/docs/apps/create_an_app_tutorial" passHref><a>app creation tutorial</a></Link>. However, it&#39;s not the only
type of app. We could have a Python script that takes in an email address and
sends that person store credit, we could have code that takes in a location and
draws a map, or we could have an API that turns on a feature flag. We don&#39;t
support all these types of apps yet, but they&#39;re high priority on our roadmap.</p>


What Is an App?

<h1 id="writing-sql-queries">Writing SQL queries<a href="#writing-sql-queries"><Link2Icon /></a></h1>
<p>Inside apps <a href="https://en.wikipedia.org/wiki/SQL">SQL</a> can be used to query data. Slight uses <a href="https://cloud.google.com/bigquery">BigQuery</a> to run the
queries. For the supported SQL features and syntax we refer to the <a href="https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax">BigQuery SQL
syntax reference documentation</a>.</p>
<p>However SQL can be limiting in where variables (parameters in SQL&#39;s terminology)
are allowed. For example it doesn&#39;t allow variables as column names. So, in
additional to standard SQL, Slight also supports templating to provide more
flexibility and additional features. The templating syntax is explained in the
next section.</p>
<h2 id="template-syntax">Template syntax<a href="#template-syntax"><Link2Icon /></a></h2>
<p>To support features beyond standard SQL Slight uses templating. A templated
query looks like the following.</p>
<DisplayCode language="sql" code="SELECT client_id, paid_date, {{ column }}
  FROM revenue
  WHERE paid_date >= DATE_TRUNC(CURRENT_DATE(), MONTH)
    AND paid_date < DATE_TRUNC(DATE_ADD(CURRENT_DATE(), INTERVAL 1 MONTH), MONTH);" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>Anything between <code dangerouslySetInnerHTML={{__html: `{{` }} /> and <code dangerouslySetInnerHTML={{__html: `}}` }} /> is called an expression. In this example we have
only a single expression <code dangerouslySetInnerHTML={{__html: `column` }} />, which refers to a variable (see next section
on using variables). Slight uses simple substitution templating, meaning
variables are replaced in the query with the value represent.*</p>
<p>We can use the query above to generate a report of our (example) invoices,
showing the client&#39;s ID, the date when an invoice is paid (<code dangerouslySetInnerHTML={{__html: `paid_date` }} />) and a
third column as specified by the <code dangerouslySetInnerHTML={{__html: `column` }} /> variable. Here we could use the price
of the invoice, or the date when a service was provided. The thing to note here
is that any user can change the variable value easily, which means a user
without knowledge of SQL can change the report without assistance.</p>
<p>The following sections explain how you can use variables (of an app) in your
query and how to reference datasets in queries.</p>
<p>* <em>Technical note</em>: variables are used as bound SQL parameters where possible.</p>
<h2 id="using-variables">Using variables<a href="#using-variables"><Link2Icon /></a></h2>
<p>Variables can be accessed directly by name inside an expression (inside <code dangerouslySetInnerHTML={{__html: `{{` }} /> and
<code dangerouslySetInnerHTML={{__html: `}}` }} />). Note the <em>name</em> might be differ from the <em>label</em>, be sure to use name!
The variables are shown in a list on the right side of screen. The image below
highlights the variable names.</p>
<p><ImageHolder alt="Example of variable name location" src="/img/docs/0020_0010_highlight_var_name.png"
/></p>
<p>In this example we have two variables <code dangerouslySetInnerHTML={{__html: `min_paid_date` }} /> and <code dangerouslySetInnerHTML={{__html: `max_paid_date` }} /> which
we can use in the app. To use a variable in a query simply put them inbetween
<code dangerouslySetInnerHTML={{__html: `{{` }} /> and <code dangerouslySetInnerHTML={{__html: `}}` }} />, such as in the following query example.</p>
<DisplayCode language="sql" code="SELECT client_id, paid_date
  FROM revenue
  WHERE paid_date >= {{ min_paid_date }}
    AND paid_date < {{ max_paid_date }};" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>As shown in the example image above, our code editor will highlight expressions
using a variable in green.</p>
<p>Learn more about how to use variable by reading the <Link href="/docs/apps/using_variables" passHref><a>Using variables</a></Link> section.</p>
<h2 id="referring-to-datasets">Referring to datasets<a href="#referring-to-datasets"><Link2Icon /></a></h2>
<p>Similar to using variables, Slight&#39;s templating can also be used to refer to a
dataset. When referring to a dataset the expression must be in the form:
<code dangerouslySetInnerHTML={{__html: `@user/dataset` }} />, e.g. <code dangerouslySetInnerHTML={{__html: `joe/coffee-analysis` }} /> refers to the <code dangerouslySetInnerHTML={{__html: `coffee-analysis` }} />
dataset owned by user <code dangerouslySetInnerHTML={{__html: `joe` }} />.</p>
<p>The example query and image below shows a query using the <code dangerouslySetInnerHTML={{__html: `joe/coffee-analysis` }} />
dataset.</p>
<DisplayCode language="sql" code="SELECT name, strength
  FROM {{ @joe/coffee-analysis }}
  ORDER BY strength;" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p><ImageHolder alt="Example of using dataset" src="/img/docs/0020_0010_highlight_dataset_reference.png"
/></p>
<p>Learn more about how to use datasets in apps by reading the <Link href="/docs/apps/using_datasets" passHref><a>Using datasets</a></Link> section.</p>


Writing SQL queries

<h1 id="using-variables">Using variables<a href="#using-variables"><Link2Icon /></a></h1>
<p>This section documents how to use variables in apps. We start with the basics of
using variables, followed by determining when to use bound or raw variables.</p>
<h2 id="basics">Basics<a href="#basics"><Link2Icon /></a></h2>
<p>Recapping what we&#39;ve learning from the <Link href="/docs/apps/writing_queries#template-syntax" passHref><a>Write SQL queries</a></Link> section: we can use
variables by encapsulating them in <code dangerouslySetInnerHTML={{__html: `{{` }} /> and <code dangerouslySetInnerHTML={{__html: `}}` }} />. For example the following
query has a single variable <code dangerouslySetInnerHTML={{__html: `min_paid_date` }} />.</p>
<DisplayCode language="sql" code="SELECT client_id, paid_date
  FROM revenue
  WHERE paid_date >= {{ min_paid_date }};" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>To add a variable to the app you can use the &quot;Add Variable&quot; button at the bottom
right of the screen as shown by the image below. In the query body it will
highlight <code dangerouslySetInnerHTML={{__html: `my_variable` }} /> grey as it expects it to be a valid variable, although the
app has none!</p>
<p><ImageHolder alt="Location of the button to add a variable to an app" src="/img/docs/0020_0020_add_var.png"
/></p>
<p>Once the variable is added you see that the highlighting of <code dangerouslySetInnerHTML={{__html: `my_variable` }} />
changes to green, indicating it&#39;s a variable. On the right side of the screen
you can fill in a number of properties of the variable (most of which are
optional). The properties are briefly discussed below, but first let&#39;s see how
it looks.</p>
<p><ImageHolder alt="Example of an added variable" src="/img/docs/0020_0020_added_var.png"
/></p>
<p>Variables have the following properties.</p>
<ul>
<li>Name: the name of the variable to use when refering to them in the query
body.</li>
<li>Type: the type of the variable, see the <Link href="#variable-types" passHref><a>Variable types</a></Link> section below for
more information.</li>
<li>Bind: whether or not to use SQL bound parameters, see the <Link href="#bound-or-raw" passHref><a>Bound or Raw?</a></Link>
section below for more information.</li>
<li>Label: friendly name for the variable. This will be shown to the user of the
app instead of the variable name (which is limited by e.g. not allowing
spacing). By default it&#39;s generated based on the name of the variable, but it
can be modified if you can give it a better value.</li>
<li>Default: The default value for the variable when running, essentially making
the variable optional (as the default value will be used if the user provides
no value for it).</li>
<li>Example: an example value. This can be used to show how the value should be
used. For example when the variable filters the results the default value
could be no filter, but the example could filter based on the date.</li>
<li>Description: short form description of the variable.</li>
<li>Documentation: long form documentation of the variable, optional and supports
Markdown.</li>
<li>Type specific properties: additional properties that are specific to the
type. See the <Link href="#variable-types" passHref><a>Variable types</a></Link> section below for information about these
properties.</li>
</ul>
<h2 id="variable-types">Variable types<a href="#variable-types"><Link2Icon /></a></h2>
<p>All variable have a type so that we know how to process the value passed to it.
Most types, such as text or number, speak for themselves, but not all of them
do. In the following sections each variable type is discussed, where they can be
used and what additional type specific properties they have (see variable
properties in the previous section).</p>
<h3 id="boolean">Boolean<a href="#boolean"><Link2Icon /></a></h3>
<p>A boolean can be &quot;true&quot; (positive) or &quot;false&quot; (negative), the user has the option
of one or the other. A boolean variable has no type specific properties.</p>
<h3 id="category">Category<a href="#category"><Link2Icon /></a></h3>
<p>A category variable allows the users of the app to select from a list of
category options. As with variables the category options must also have a type, it
has the same options as a variable except for the category type.</p>
<p>An example of using a category variable can be the sales report for a business
that is active in different markets. By default the data would include all
markets, but people can select a market (from a list of category options) to
limit it to a certain market.</p>
<p><em>Why a category variable versusus a text variable?</em>
The benefit of a category variable over a text variable in this setting is that
it prevents the user from selecting a non-existent market.</p>
<p>To edit the category options click on the &quot;Edit options&quot; button on the right
side of the screen below the variable&#39;s name and type.</p>
<p><ImageHolder
  width="narrow"
  alt="Button to edit category options"
  src="/img/docs/0020_0020_go_to_edit_category_options.png"
/></p>
<p>Once clicked you&#39;ll see the following screen appear which allows you to add and
edit the category options. On the left side, under &quot;Current Options&quot; all
existing options will be listed which be edited or delted. On the right new
options can be added as highlighted by the red box in the image below.</p>
<p><ImageHolder alt="Screen to add and edit category options" src="/img/docs/0020_0020_edit_category_options.png"
/></p>
<h3 id="date">Date<a href="#date"><Link2Icon /></a></h3>
<p>A variable that consists of a year, month and day, colloquially known as a date.</p>
<p>As optional type specific properties it supports a lower and upper bound,
forcing the value to be in a certain date range. This can be used to for example
ensure that data is collected for the variable date input, no point in querying
for data we don&#39;t have. You can set none, one, or both bounds.</p>
<h3 id="time">Time<a href="#time"><Link2Icon /></a></h3>
<p>A variable that consists of an hour, minute and second, colloquially known as a
time variable.</p>
<p>Similar to a date a time variable has a lower and upper bound as type specific
properties.</p>
<h3 id="datetime">Datetime<a href="#datetime"><Link2Icon /></a></h3>
<p>A combination of a date and a time (hence the name!). Different to date and time
this type can optionally consider timezones by enabling the &quot;Timezone-aware
Datetime&quot; option. Whether or not to enable timezone awareness depends on the
data used.</p>
<p>As type specific properties datetime also support a lower and upper bound.</p>
<h3 id="number">Number<a href="#number"><Link2Icon /></a></h3>
<p>A number type can be an <a href="https://en.wikipedia.org/wiki/Integer">integer</a> or a <a href="https://en.wikipedia.org/wiki/Real_number">real number</a> (also known as
<a href="https://en.wikipedia.org/wiki/Floating-point_arithmetic">floating-point number</a>). By default numbers will be considered real numbers,
unless they explicited restricted to integers by enabling &quot;Restrict to whole
number&quot; (below the variable name).</p>
<p>Similar to the date/time types number variables have an optional lower and upper
bound as type specific properties.</p>
<h3 id="text">Text<a href="#text"><Link2Icon /></a></h3>
<p>A text variable is a sequence of characters (UTF-8) that make up readable text,
such as the sequence of characeters you&#39;re reading right now.</p>
<p>As for type specific properties, you can set the minimum and maximum input length.</p>
<h2 id="bound-or-raw">Bound or Raw?<a href="#bound-or-raw"><Link2Icon /></a></h2>
<p>Let&#39;s start with the most important advice first: when in doubt use &quot;Bound&quot; as
it&#39;s the safest option. When using &quot;Raw&quot; it&#39;s a lot easier to break stuff. Now,
let&#39;s learn what variable binding is and when to use what kind.</p>
<p>When using &quot;Bound&quot; variable binding it means that the variable&#39;s value will be
used as a <a href="https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#query_parameters">query parameter</a>, or a &quot;bound parameter&quot;, to the SQL query.
Generally, it&#39;s considered best-practice to do this as it allows the SQL
database (BigQuery in our case) to cache the query plan and optimise it further
on repeat runs. Additionally, because &quot;Bound&quot; inputs are not actually treated as
part of the query itself, a whole class of malicious <a href="https://stackoverflow.com/questions/332365/how-does-the-sql-injection-from-the-bobby-tables-xkcd-comic-work">SQL injection</a> attacks on
the database is prevented.</p>
<p>However, bound variables have limitations as to where they can
be used. For example they can&#39;t be as identifiers, such as column or table name.
To use a variable column name see the <Link href="#using-variables-as-columns" passHref><a>Using variables as columns</a></Link> section
below. For more limitations see the BigQuery documentation on <a href="https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#query_parameters">query
parameters</a>.</p>
<p>If you encounter a situation where a &quot;Bound&quot; variable doesn&#39;t work, such as using
it as a column name, then you can opt to use a &quot;Raw&quot; variable. Raw variables are
injected without modifications (i.e. &quot;raw&quot;) into the query. The content of
the variable input is simply substituted in the query without modifications.
This allows us to do very powerful things, such as having complex <code dangerouslySetInnerHTML={{__html: `WHERE` }} />
clauses or dynamicly choosing the columns to return, but also has it&#39;s pitfalls.
For example if you have a text variable then the contents likely needs to be
encapsulated in qoutes (<code dangerouslySetInnerHTML={{__html: `&#39;` }} />), but you can&#39;t be sure the input doesn&#39;t contain a
qoute character itself! When opting to use a &quot;Raw&quot; variable always be extra
careful and let the user know how to use the variable properly through a good
description and documentation. Better yet, you can balance the power of &quot;Raw&quot;
variable with the safety of a <Link href="#category" passHref><a>Category</a></Link> variable with a list of &quot;Raw&quot;
options (coming soon!) that you&#39;ve tested yourself.</p>
<p>Finally, in-between &quot;Bound&quot; and &quot;Raw&quot; we have &quot;Bound or Raw&quot;, which allows a
variable to &quot;Bound&quot;, but when needed allows a &quot;Raw&quot; input from the user (when
running the app). The option allows us to choose the safe option by default
(&quot;Bound&quot;), but provides an escape hatch for situations that don&#39;t work with
&quot;Bound&quot; variables.</p>
<h2 id="using-variables-as-columns">Using variables as columns<a href="#using-variables-as-columns"><Link2Icon /></a></h2>
<p>Some app might want to return different columns depending on the user input,
i.e. a variable. In those cases it&#39;s not possible to use a &quot;Bound&quot; variable as
it will consider it a text string as shown by the app below. You can set the
<code dangerouslySetInnerHTML={{__html: `bound_col` }} /> value to any string that you like and the app will return a column with
that input repeated for each row.</p>
<p>Instead, if we want to choose the column to return
we need to use a &quot;Raw&quot; variable that is interpreted as an identifier and used as a
column name. In the app, <code dangerouslySetInnerHTML={{__html: `raw_col` }} /> has a default value of <code dangerouslySetInnerHTML={{__html: `country` }} />. Try running the app
to see what happens. What happens if you try to change <code dangerouslySetInnerHTML={{__html: `raw_col` }} /> to a name that isn&#39;t a
column in the toy dataset (<code dangerouslySetInnerHTML={{__html: `name` }} /> or <code dangerouslySetInnerHTML={{__html: `country` }} />; see the <em>Body</em> tab for more details on how
we created the table)? You can check out the <em>Documentation</em> tab in the app below for more
details and exercises to help you understand the differences in behaviour and functionality
between &quot;Bound&quot; and &quot;Raw&quot; variables.</p>
<div className="mini-app">
  <ShowMiniApp
    handle="slight-docs"
    unqualifiedId="var_as_column_name"
  />
</div>

<p>As mentioned in <Link href="#bound-or-raw" passHref><a>Bound or Raw?</a></Link> above, you will soon able to support column
selection with variables by creating a &quot;Raw&quot; category variable with valid,
selectable columns as &quot;Raw&quot; category options.</p>


Using variables

<h1 id="using-datasets">Using datasets<a href="#using-datasets"><Link2Icon /></a></h1>
<p>For typical apps on Slight, the starting point is data.
A good place to find suitable data is our <Link href="/datasets" passHref><a>dataset catalog</a></Link>. Let&#39;s
assume we like trees, so we put that in the search bar:</p>
<p><ImageHolder
    alt="Datasets catalog with the term 'trees' in the search bar, and two resulting datasets. One is NYC Street Trees: Census 2015 and the other is the same but from 1995."
    src="/img/docs/0020_0040_search_for_trees.png"
/></p>
<p>Clicking the link to the first brings us to the page for the dataset <Link href="/datasets/bigquery-public-data/nyc_trees_census_2015" passHref><a>NYC Street
Trees: Census 2015</a></Link>.
After reading the docs, seeing what columns are available to us and looking at
the data preview, we&#39;ll assume we&#39;re happy that this is a good source of data
for an interesting app. It may be useful to keep this page open as a reference.
If a dataset already has apps using it, those can be great inspiration for an
app.</p>
<h3 id="getting-the-dataset-id">Getting the dataset ID<a href="#getting-the-dataset-id"><Link2Icon /></a></h3>
<p>To use this dataset in an app, we need its ID. Here, this is <code dangerouslySetInnerHTML={{__html: `bigquery-public-data/nyc_trees_census_2015` }} />. We have a few ways to get this. One is that it&#39;s the last parts of the URL, after <code dangerouslySetInnerHTML={{__html: `/datasets/` }} />. Another is that it&#39;s underneath the description of the dataset, up top, where we can click to copy it to the clipboard:</p>
<p><ImageHolder
    width="narrow"
    alt="Top view of the dataset page for the NYC Street Trees: Census 2015 dataset. The ID, under the description, has just been clicked, showing a tooltip saying 'Copied'"
    src="/img/docs/0020_0030_copying_dataset_id.png"
/></p>
<h3 id="referencing-the-dataset-and-the-create-app-tab">Referencing the dataset, and the Create App tab<a href="#referencing-the-dataset-and-the-create-app-tab"><Link2Icon /></a></h3>
<p>A nice way to get started with an app from a dataset is by opening up the
&quot;Create App&quot; tab. For the tree dataset, it&#39;ll tell us that the primary way to
use this dataset in an app is to reference it as <code dangerouslySetInnerHTML={{__html: `{{ @bigquery-public-data/nyc_trees_census_2015 }}` }} /> where you&#39;d normally put a table
name in a query, giving us the following pseudo-SQL snippet:</p>
<DisplayCode language="sql" code="SELECT COUNT(*) -- replace with whatever you want to query
  FROM {{ @bigquery-public-data/nyc_trees_census_2015 }}" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>Then it links to <Link href="/docs/apps/writing_queries#referring-to-datasets" passHref><a>our documentation page on writing
queries</a></Link> for more details on
referring to datasets. Another nice option is to click one of the buttons
further down, as seen here:</p>
<p><ImageHolder
    width="narrow"
    alt="The 'Create App' tab for the NYC Street Trees: Census 2015 dataset. Visible are the buttons 'Start with all columns' and 'Start with a simple variable'"
    src="/img/docs/0020_0030_app_from_dataset.png"
/></p>
<p>E.g. &quot;Start with a simple variable&quot; opens up the &quot;New App&quot; page with a simple
query that selects all of the variables from this table.</p>
<h3 id="seeing-this-in-action">Seeing this in action<a href="#seeing-this-in-action"><Link2Icon /></a></h3>
<p>See <Link href="/docs/apps/create_an_app_tutorial" passHref><a>our app creation tutorial</a></Link> for a full journey creating an app from the above dataset. To see the result, <Link href="/apps/colman/tree_health_statistics_nyc" passHref><a>here&#39;s an app using this dataset</a></Link>.</p>


Using datasets

Referencing the dataset, and the Create App tab

<h1 id="create-an-app-a-tutorial">Create an app: A Tutorial<a href="#create-an-app-a-tutorial"><Link2Icon /></a></h1>
<p>If you&#39;re familiar with our guides on <Link href="/docs/apps/using_datasets" passHref><a>writing SQL
queries</a></Link> and <Link href="/docs/apps/using_variables" passHref><a>using
variables</a></Link>, you&#39;re mostly ready to go! For the
rest of this tutorial, we&#39;ll assume you&#39;re somewhat familiar with SQL, and we&#39;ll link
to various docs along the way when needed.</p>
<p>This is a full tutorial on creating an app. We also have a <Link href="/docs/quickstart/create_an_app" passHref><a>quickstart on creating an app</a></Link> if you&#39;d like to get a quick overview instead.</p>
<p>Check back in a few days for a video version of the below.</p>
<h4 id="what-do-we-mean-by-app">What Do We Mean By App?<a href="#what-do-we-mean-by-app"><Link2Icon /></a></h4>
<p>In this document, we mean a very specific type of app: a parametrised SQL query,
one that can take values from users, and is runnable on demand to produce data.</p>
<p>For a more general discussion, see <Link href="/docs/apps/what_is_an_app" passHref><a>What Is An App?</a></Link></p>
<h4 id="is-there-no-shorter-way-this-is-a-long-doc">Is There No Shorter Way? This is a Long Doc<a href="#is-there-no-shorter-way-this-is-a-long-doc"><Link2Icon /></a></h4>
<p>As mentioned above, if you just want a quick overview, you should check out the <Link href="/docs/quickstart/create_an_app" passHref><a>quickstart on creating an app</a></Link>.</p>
<p>And indeed this doc doesn&#39;t need to be read straight through. See <Link href="/docs/quickstart/create_an_app#creating-an-app-from-a-template" passHref><a>Creating an app from a
template</a></Link> below
for a shortcut.</p>
<h2 id="for-now-we-need-some-data">For Now, We Need Some Data<a href="#for-now-we-need-some-data"><Link2Icon /></a></h2>
<p>For a longer version of this section, see our doc on <Link href="/docs/apps/using_datasets" passHref><a>using datasets in apps</a></Link>.</p>
<p>For the type of apps we&#39;ll mostly be making for now, the starting point is data.
A good place to find suitable data is our <Link href="/datasets" passHref><a>dataset catalog</a></Link>. Let&#39;s
assume we like trees, so we put that in the search bar:</p>
<p><ImageHolder
    alt="Datasets catalog with the term 'trees' in the search bar, and two resulting datasets. One is NYC Street Trees: Census 2015 and the other is the same but from 1995."
    src="/img/docs/0020_0040_search_for_trees.png"
/></p>
<p>Clicking the link to the first brings us to the page for the dataset <Link href="/datasets/bigquery-public-data/nyc_trees_census_2015" passHref><a>NYC Street
Trees: Census 2015 </a></Link>.
After reading the docs, seeing what columns are available to us and looking at
the data preview, we&#39;ll assume we&#39;re happy that this is a good source of data
for an interesting app. It may be useful to keep this page open as a reference.
If a dataset already has apps using it, those can be great inspiration for an
app.</p>
<p>To use this dataset, we need its ID, which is <code dangerouslySetInnerHTML={{__html: `bigquery-public-data/nyc_trees_census_2015` }} />. You can get this ID from the URL, or copying the ID from underneath the description. Or you can start with the &quot;Create App&quot; tab. Again, for more details on this, see our doc on <Link href="/docs/apps/using_datasets" passHref><a>using datasets in apps</a></Link>.</p>
<h2 id="write-a-query">Write a Query<a href="#write-a-query"><Link2Icon /></a></h2>
<p>Skip this section if you already have your query in mind. For more general details on writing SQL, see our doc on <Link href="/docs/apps/writing_queries" passHref><a>Writing SQL queries</a></Link>.</p>
<p>This is probably the most familiar part, and by far the hardest. In the
workplace, you may be trying to answer an interesting cohort analysis question
from the marketing team, or maybe the finance team needs the result of some
complex joins for their financial modelling. Hopefully you just have a burning
question in mind: which NYC neighborhoods have the healthiest trees?</p>
<p>Of course before we publish our app, we can poke around in the Test tab. In this
tab, we can grab the line separating the code from the table and see more of one
than the other if needed. First running the following shows we have 188
neighborhoods:</p>
<DisplayCode language="sql" code="SELECT COUNT(DISTINCT nta_name)
  FROM {{ @bigquery-public-data/nyc_trees_census_2015 }}" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>To get a sense of defining tree health, we might run:</p>
<DisplayCode language="sql" code="SELECT status,
       health,
       COUNT(*) AS count
  FROM {{ @bigquery-public-data/nyc_trees_census_2015 }}
 GROUP BY 1, 2" fullHeight={true} bottomMargin={true} darkMtk4={false} /><p>Which gives something like:</p>
<table>
<thead>
<tr>
<th>status</th>
<th>health</th>
<th align="right">count</th>
</tr>
</thead>
<tbody><tr>
<td>Alive</td>
<td>Good</td>
<td align="right">528,850</td>
</tr>
<tr>
<td>Alive</td>
<td>Fair</td>
<td align="right">96,504</td>
</tr>
<tr>
<td>Alive</td>
<td>Poor</td>
<td align="right">26,818</td>
</tr>
<tr>
<td>Alive</td>
<td></td>
<td align="right">1</td>
</tr>
<tr>
<td>Dead</td>
<td></td>
<td align="right">13,961</td>
</tr>
<tr>
<td>Stump</td>
<td></td>
<td align="right">17,654</td>
</tr>
</tbody></table>
<p>Ignoring the single alive tree without a health status, we have five states.
This should be enough now to write the general shape of our query, before
worrying about parameters:</p>
<DisplayCode language="sql" code="WITH tree_data AS (

SELECT nta_name AS neighborhood,
       boroname AS borough,
       IF(status = 'Alive' AND health = 'Good', 1, 0) AS good_health,
       IF(status = 'Alive' AND health = 'Fair', 1, 0) AS fair_health,
       IF(status = 'Alive' AND health = 'Poor', 1, 0) AS poor_health,
       IF(status = 'Dead', 1, 0) AS dead,
       IF(status = 'Stump', 1, 0) AS stump,
       ST_DISTANCE(ST_GEOGPOINT(longitude, latitude), ST_GEOGPOINT(-73.9776, 40.7615))
          AS distance_from_moma -- in metres
  FROM {{ @bigquery-public-data/nyc_trees_census_2015 }}

),

tree_counts AS (

SELECT neighborhood,
       ANY_VALUE(borough) AS borough,
       COUNT(*) as total_trees,
       SUM(good_health) AS good_health_trees,
       SUM(fair_health) AS fair_health_trees,
       SUM(poor_health) AS poor_health_trees,
       SUM(dead) AS dead_trees,
       SUM(stump) AS stumps
  FROM tree_data
 WHERE distance_from_moma < 5000 -- 5km
 GROUP BY 1

)

SELECT neighborhood,
       borough,
       total_trees,
       good_health_trees / total_trees AS healthy_tree_fraction,
       good_health_trees / (total_trees - stumps)
         AS healthy_tree_fraction_ignore_stumps,
       (good_health_trees + fair_health_trees) / total_trees
         AS reasonably_healthy_tree_fraction,
       poor_health_trees / (good_health_trees + fair_health_trees +
         poor_health_trees) AS poor_health_of_alive_trees_fraction,
       dead_trees / total_trees AS dead_tree_fraction,
       dead_trees / (total_trees - stumps) AS dead_tree_fraction_ignore_stumps,
       (dead_trees + stumps) / total_trees AS dead_or_stump_fraction
  FROM tree_counts
 ORDER BY healthy_tree_fraction DESC;" fullHeight={true} bottomMargin={true} darkMtk4={false} /><h2 id="parametrise--add-variables">Parametrise / Add Variables<a href="#parametrise--add-variables"><Link2Icon /></a></h2>
<p>Note: this is a long section. If you&#39;re already familiar with our <Link href="/docs/apps/using_variables" passHref><a>using
variables</a></Link> doc, you can skip ahead.</p>
<p>This is great, now we can see the health in percentage terms of trees within 5km
of <a href="https://www.moma.org/">MoMA</a>, split by neighborhood. We could publish this
now, assuming we want to share a static app of just data. This is effectively a
way of storing views on a dataset, except you can document them and give them a
homepage.</p>
<p>But maybe our users don&#39;t quite understand why we&#39;d want to filter to trees
within 5km of MoMA. Instead of choosing the point of interest and the distance,
what if our users could decide? Let&#39;s parametrise these instead. We&#39;ll go
through a few days to do it.</p>
<p>First, in the Define tab, hit &quot;Add Variable&quot; on the right. You can just use the
default of type <code dangerouslySetInnerHTML={{__html: `Text` }} /> and adjust it later, or use the extra menu (arrow) to
select number specifically. See the picture:</p>
<p><ImageHolder
    width="narrow"
    alt="Using the extra menu for 'Add Variable', selecting the Number type in the 'Add by Type' submenu"
    src="/img/docs/0020_0040_add_number_var.png"
/></p>
<p>First to set up the longitude variable: we know a lot about this. We can bound
it, give it a default (probably somewhere in the middle of NYC), an example
(let&#39;s stick with MoMA) a description, and maybe some documentation. We can even
bound this, because we know longitude is from -180º to 180º. Finally, we need to
give it a name. Here I used <code dangerouslySetInnerHTML={{__html: `longitude_poi` }} /> for &quot;point of interest&quot;, but
simplified the label to &quot;Longitude of Interest&quot;:</p>
<p><ImageHolder
    width="tiny"
    alt="Defining the longitude variable with the values discussed above. Description is 'Longitude to potentially restrict to being close to.' and the Documentation links to the wiki page of Middle Village in Queens."
    src="/img/docs/0020_0040_longitude_variable.png"
/></p>
<p>Now, replace the hardcoded value of -73.9776 with <code dangerouslySetInnerHTML={{__html: `{{ longitude_poi }}` }} /> - you
should get the name autocompleting as you type it. Similarly, we can do the same
for the latitude. However, try something slightly different: highlight the value
40.7615 and right-click, and click &quot;Create Variable from Value&quot;:</p>
<p><ImageHolder
    alt="In the coding box, showing a submenu after right-clicking the highlighted latitude value, with the option 'Create Variable from Value' selected."
    src="/img/docs/0020_0040_create_variable_value.png"
/></p>
<p>I&#39;ll let you work out the details for that one - just want to note that if you
edit the name in the variable box, before navigating away you&#39;ll have a chance
to update the old name to the new one in the body too, so you don&#39;t have to edit
it twice:</p>
<p><ImageHolder
    width="tiny"
    alt="In variable editor, we're hovering over the button that pops up after changing a variable name that offers the opportunity to update the varaibles in the body too."
    src="/img/docs/0020_0040_latitude_rename.png"
/></p>
<p>Then edit the resulting column name to e.g. <code dangerouslySetInnerHTML={{__html: `distance_from_poi` }} /> instead of MoMa.</p>
<p>For the distance, we can do it a third way: replace the value 5000 with <code dangerouslySetInnerHTML={{__html: `{{ max_distance }}` }} /> in the body. It&#39;ll show up gray because no such variable exists
with this name. Right-click and select &quot;Add variable to app&quot; (or press ⌘-k ⌘-b
with the cursor on top):</p>
<p><ImageHolder
    width="narrow"
    alt="In the body, we've right-clicked the variable `max_distance`. In the menu that has openend, we're hovering the option 'Add variable to app'."
    src="/img/docs/0020_0040_add_variable_to_app_from_body.png"
/></p>
<p>I also added a borough Category variable, which can be
one of the five boroughs of NYC, or the value &quot;All&quot;, with the WHERE clause being
<code dangerouslySetInnerHTML={{__html: `({{ borough }} = &#39;All&#39; or {{ borough }} = boroname)` }} />.</p>
<h2 id="add-metadata--documentation">Add Metadata / Documentation<a href="#add-metadata--documentation"><Link2Icon /></a></h2>
<p>We&#39;re nearly there. We want to give interested users more context on our app,
both for discoverability (say, in the <Link href="/apps" passHref><a>app catalog</a></Link>) and for
understanding how best to use our app once they find it.</p>
<p>Your app needs a good title, this is the most prominent part of the app in the
catalog.</p>
<p>Your app also needs an ID. This identifies your app: it gives your app its URL,
and it&#39;s how your app will be called through an API. In many cases, the
autogenerated ID from the title is suitable, but you may find it&#39;s overly long.</p>
<p>An app can&#39;t be published without a description. It can be short, but very
useful to quickly get context on the purpose of an app before clicking into it.</p>
<p>Optionally, you can add long-form Documentation. Unlike the plaintext
description, this is markdown, so you can add codeblocks, links, tables etc. If
you&#39;re not familiar with markdown, see our guide to <Link href="/docs/apps/writing_markdown" passHref><a>writing markdown</a></Link>, or type <code dangerouslySetInnerHTML={{__html: `/` }} /> to bring up formatting options.</p>
<h2 id="publish">Publish!<a href="#publish"><Link2Icon /></a></h2>
<p>Everything&#39;s done, you&#39;re ready to publish. Hit the button and enjoy seeing your
app in the catalog!</p>
<p><Link href="/apps/colman/tree_health_statistics_nyc" passHref><a>Here&#39;s my version</a></Link> if you&#39;re
interested.</p>
<h2 id="editing-and-deletion">Editing and Deletion<a href="#editing-and-deletion"><Link2Icon /></a></h2>
<p>Deletion is possible from the app&#39;s homepage or from the catalog. From the app&#39;s
homepage, click the burger menu next to the share button, then select &quot;Delete
App&quot; from the menu:</p>
<p><ImageHolder
    width="tiny"
    alt="Burger menu clicked (aria label: 'Edit or Delete App'), with 'Delete App' selected within."
    src="/img/docs/0020_0040_deletion.png"
/></p>
<p>From the catalog, this menu is underneath the expansion button.</p>
<p>True editing is coming soon! For now, see below for using an app as a template:
you can recreate an app this way (plus edits), then delete the old one and
publish the new one. Assuming you&#39;ll keep the same ID, you can&#39;t publish the new
one till the old one is gone.</p>
<h2 id="creating-an-app-from-a-template">Creating an App from a Template<a href="#creating-an-app-from-a-template"><Link2Icon /></a></h2>
<p>All the above might seem like a lot. Or maybe someone else has a great app
already, and you want to build on from it. There&#39;s a solution: use an existing
app as a template. You&#39;ll see this button in the top-left section on an app&#39;s
homepage, beside the Share button. Clicking it will open up a dialog, where you
will choose the name for you new app. It defaults to the name of the app you&#39;re
building from, adding &quot;Copy of&quot; at the start. Don&#39;t worry, you can change this
later.</p>
<p><ImageHolder
    width="narrow"
    alt="The dialog box that opens after clicking 'Use as Template'. It's asking for the new app's name."
    src="/img/docs/0020_0040_create_app_from_template.png"
/></p>
<p>This will bring you to the <Link href="/apps/new" passHref><a>new apps</a></Link> page, with the same body and
variables as the app you were previously on. The new title will be what you
selected in the dialog, and the new ID will initially be generated from this new
title.</p>
<p>You don&#39;t get the old description or documentation. If you want to build off
those too, simply copy them over from the previous app.</p>


Create an app: A tutorial

Is There No Shorter Way? This is a Long Doc

<h1 id="writing-with-markdown">Writing with Markdown<a href="#writing-with-markdown"><Link2Icon /></a></h1>
<p>Within Slight Run, Markdown is used for &quot;Documentation&quot; entries, whether on a whole app or dataset, or on individual variables and columns. Each of these also comes with a simpler &quot;Description&quot; entry, which only takes plain text and a lower character limit.</p>
<p>We don&#39;t yet have our own guide up. For now, <a href="https://www.markdownguide.org/basic-syntax">The Markdown Guide&#39;s basic syntax page</a> is a great starting point. For any markdown block on our site, you should generally be able to type <code dangerouslySetInnerHTML={{__html: `/` }} /> to bring up formatting options.</p>


Writing with Markdown

Creating apps

<p>Get started <em>quickly</em> with the following articles.</p>


<h1 id="sign-up">Sign up<a href="#sign-up"><Link2Icon /></a></h1>
<p>The first step to sign up is to click on the &quot;Sign Up&quot; button in top right
corner of the page.</p>
<p><ImageHolder alt="Location of the Sign Up button in the header at the top of the page" src="/img/docs/0010_0010_toolbar_sign_up.png"
/></p>
<p>This will take you to the user creation page. In the creation page you can
continue using an existing Google or GitHub account, or create a new account using an
email address.</p>
<p><ImageHolder alt="User creation page" src="/img/docs/0010_0010_new_account.png"
/></p>
<p>The final step of the sign up process is to select a user handle which will be
used to reference your datasets and apps.</p>
<p><ImageHolder alt="Choosing a user handle page" src="/img/docs/0010_0010_choose_handle.png"
/></p>
<p>Once you&#39;ve signed up and logged in you&#39;ll see your avatar in the top right
corner of the page (replacing the &quot;Sign up&quot; button you clicked on earlier).</p>
<p><ImageHolder alt="Page header with a logged in user" src="/img/docs/0010_0010_toolbar_logged_in.png"
/></p>
<p>Now that you are signed up you can create your first app! You can do this by following
the <Link href="/docs/quickstart/create_an_app" passHref><a>create an app</a></Link> quickstart guide.</p>


Sign up

<h1 id="login">Login<a href="#login"><Link2Icon /></a></h1>
<p>Before you can log in you&#39;ll need to sign up first. You can create an account
following the <Link href="/docs/quickstart/sign_up" passHref><a>sign up</a></Link> guide. After you&#39;ve created an account you should
already be logged in. However the next time you visit the site you might be
logged out.</p>
<p>The first step to log in is to click on the &quot;Log In&quot; button in top right corner
of the page.</p>
<p><ImageHolder alt="Location of the Log In button in the header at the top of the page" src="/img/docs/0010_0020_toolbar_login.png"
/></p>
<p>This will take you to the log in page. You can continue using an existing Google
or GitHub account, or use the email address you&#39;ve previously signed up with.</p>
<p><ImageHolder alt="Login page" src="/img/docs/0010_0020_login_page.png"
/></p>
<p>Once you&#39;re logged in you&#39;ll see your avatar in the top right corner of the page
(replacing the &quot;Log In&quot; button you&#39;ve used earlier).</p>
<p><ImageHolder alt="Page header with a logged in user" src="/img/docs/0010_0010_toolbar_logged_in.png"
/></p>
<p>Now that you are logged in you can create your first app! You can do this by following
the <Link href="/docs/quickstart/create_an_app" passHref><a>create an app</a></Link> quickstart guide.</p>


Login

<h1 id="create-an-app">Create an app<a href="#create-an-app"><Link2Icon /></a></h1>
<p>If you&#39;re familiar with our guides on <Link href="/docs/apps/using_datasets" passHref><a>writing SQL
queries</a></Link> and <Link href="/docs/apps/using_variables" passHref><a>using
variables</a></Link>, you&#39;re basically ready to go! For the
rest of this doc, we&#39;ll assume you&#39;re somewhat familiar with SQL, and we&#39;ll link
to various docs along the way when needed.</p>
<p>This is the quickstart version. We also have a <Link href="/docs/apps/create_an_app_tutorial" passHref><a>full tutorial on creating an app</a></Link> if you&#39;d like more detail.</p>
<p>You can watch the video version, or see the text below.</p>
<p><EmbedVideo
    videoSrc="https://player.vimeo.com/video/647078132?h=b8c4a1f942&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479"
    title="Slight Run: Create an App Overview"
/></p>
<h2 id="overview-of-app-creation">Overview of App Creation<a href="#overview-of-app-creation"><Link2Icon /></a></h2>
<p>The steps for a typical app are:</p>
<ul>
<li>Start with at least one dataset, typically found in the <Link href="/datasets" passHref><a>dataset
catalog</a></Link>. Get the dataset&#39;s ID (from the URL or
just under the description) or start from the &quot;Create App&quot; tab on the dataset&#39;s page. See <Link href="/docs/apps/using_datasets" passHref><a>Using Datasets</a></Link>
for more.</li>
<li>Write a SQL query using this dataset. See <Link href="/docs/apps/writing_queries#referring-to-datasets" passHref><a>our documentation page on writing
queries</a></Link> for more details on
referring to datasets within queries.</li>
<li>For any values you&#39;d like the users of your app to be able to choose,
turn them into variables by replacing the hard-coded values with a variable name
wrapped in <code dangerouslySetInnerHTML={{__html: `{{` }} /> and <code dangerouslySetInnerHTML={{__html: `}}` }} /> and then add the variable to the app. See our page on <Link href="/docs/apps/using_variables" passHref><a>using
variables</a></Link> for more details.</li>
<li>Test your app, making sure it gives the results you expect. On this tab, the
variables will be in &quot;Run&quot; mode, the same as when the app is published. Edit
your app and variables until all looks well.</li>
<li>Fill out the metadata: add a title, optionally edit the ID if the
autogenerated one isn&#39;t to your liking, and add a description. We usually
recommend adding Documentation too (it uses markdown - you can get creative).</li>
<li>Hit &quot;Publish&quot;!</li>
<li><del>Go to your app and see all your typos and immediately edit the app</del> Enjoy
your new app, and share it publicly.</li>
</ul>


Create an app

<h1 id="using-the-api">Using the API<a href="#using-the-api"><Link2Icon /></a></h1>
<p><strong>Before we dive in</strong>: if you just want the API reference, it&#39;s <a href="https://www.slight.dev/api">available on our slight.dev site</a>.</p>
<p>Practically all actions you can do on Slight are available through our API. You can create an app, upload a dataset, run an app etc. all from the API. We&#39;ll mostly focus on running an app in this quickstart, but it should give you a base to work with the whole API.</p>
<h2 id="overview-of-running-an-app-via-the-api">Overview of Running an App via the API<a href="#overview-of-running-an-app-via-the-api"><Link2Icon /></a></h2>
<p>In essence, to run an app we need to know:</p>
<ul>
<li><strong>How to identify the app.</strong> This can be its ID (e.g.
<code dangerouslySetInnerHTML={{__html: `colman/tree_health_statistics_nyc` }} /> for <a href="https://slight.run/apps/colman/tree_health_statistics_nyc">this app</a>) or its
<a href="https://en.wikipedia.org/wiki/Universally_unique_identifier">UUID</a>. You can
find this on the app&#39;s page for example (the URL is partially made from the
ID).</li>
<li><strong>What values we want to use for the variables.</strong> E.g. if the app is parametrized
by a start date variable and an end date variable, we need to decide what
dates to actually use.</li>
</ul>
<p>Further, we will normally want to authenticate, although this is optional in the
public version. And if we want to limit the number of results, we can do that
too.</p>
<p>Let&#39;s run a quick example that uses a single variable. We&#39;ll run <a href="https://slight.run/apps/amaris/popularity_of_a_given_name_by_year">Popularity of a given first name by year</a>; we won&#39;t focus a lot on the details of the app for this doc. Let&#39;s assume we want to run it with the name <code dangerouslySetInnerHTML={{__html: `Maya` }} />. Our API is hosted at <code dangerouslySetInnerHTML={{__html: `api.slightdata.com` }} />, so using <a href="https://en.wikipedia.org/wiki/CURL">cURL</a>, we can run it like so:</p>
<DisplayCode language="shell" code="curl 'https://api.slightdata.com/v0/apps/user/amaris/popularity_of_a_given_name_by_year/run' \
  --request POST \
  --header 'Content-Type: application/json' \
  --data '{
    &quot;variable_values&quot;: [
      {
        &quot;name&quot;: &quot;first_name&quot;,
        &quot;value&quot;: &quot;Maya&quot;
      }
    ]
  }'" fullHeight={true} bottomMargin={true} darkMtk4={true} /><p>Try running this locally, or pipe it through e.g. <a href="https://stedolan.github.io/jq/">jq</a> for nicer output. You&#39;ll see that
you get back the <code dangerouslySetInnerHTML={{__html: `columns` }} /> as an array of objects, and the <code dangerouslySetInnerHTML={{__html: `rows` }} /> as an
array of row arrays, each the same length as the number of columns.</p>
<p>Note: this isn&#39;t using authentication. We&#39;ll discuss that below.</p>
<h2 id="do-i-have-to-write-the-whole-thing">Do I Have to Write the Whole Thing?<a href="#do-i-have-to-write-the-whole-thing"><Link2Icon /></a></h2>
<p>No — navigate to an app&#39;s page, and click on the API tab. You&#39;ll see a runnable
example API call generated for you, in one of four langauge options. It will
update live to match the values currently set for your variables, using the
default otherwise. This avoids you having to fiddle around to get it to work,
and you can test that the API call gives the same result as the web UI.</p>
<p>So putting <code dangerouslySetInnerHTML={{__html: `Maya` }} /> in as the name gives this for me:</p>
<p><ImageHolder
    alt="Screenshot of the bottom half of the app page, with the API tab open. It shows a token value `slightpat_SOME_TOKEN_HERE` in an input field, and an example API call the same as we see above, but here with the Authorization header added"
    src="/img/docs/0010_0040_api_tab.png"
/></p>
<p>This is the same as the example in the above section, except it uses a (non-working) token for authentication. Deleting the fourth line (removing authentication) gives the exact same thing as that example.</p>
<h2 id="how-do-i-authenticate">How Do I Authenticate?<a href="#how-do-i-authenticate"><Link2Icon /></a></h2>
<p>The easiest way to authenticate is to generate a Personal Access Token, or PAT for short. You can see in the above screenshot we&#39;ve used <code dangerouslySetInnerHTML={{__html: `slightpat_SOME_TOKEN_HERE` }} /> as a placeholder. You&#39;ll want to replace this with a real PAT. Once you fill in the input, it&#39;ll change in the example.</p>
<p>We&#39;ll add more docs on those in the future. For now, you can generate a PAT by
navigating to your settings page while logged in (<a href="https://slight.run/settings">https://slight.run/settings</a> or
click on your avatar in the top right). You&#39;ll see a section called Personal
Access Tokens:</p>
<p><ImageHolder
    alt="Screenshot of the section in `/settings` where you can generate a token."
    width="narrow"
    src="/img/docs/0010_0040_pat_gen.png"
/></p>
<p>Open the creation modal by clicking on &quot;Create Token&quot;. To run an app, make sure
to give it &quot;Run an App&quot; (<code dangerouslySetInnerHTML={{__html: `run` }} />) permissions at least. After you create the
token, you&#39;ll get the chance to copy it (until you close the tab):</p>
<p><ImageHolder
    alt="Screenshot of the Personal Access Tokens section of the `/settings` page, with a newly generated token, and the option to copy it presented."
    width="narrow"
    src="/img/docs/0010_0040_save_pat.png"
/></p>
<p>Fill this in anywhere you need a PAT: while inserting a value
into the input in the API tab, or e.g. in the <a href="https://www.slight.dev/api/reference/operations/apps/run/by-id">reference doc for running an app</a>.</p>
<p>Finally, you can also generate a new token directly from the API tab too.
You can see in the screenshot above (or by navigating to an app&#39;s API tab) that there&#39;s a button with a <code dangerouslySetInnerHTML={{__html: `+` }} /> symbol. This opens the same modal as the PAT box in settings.</p>
<h2 id="do-i-have-to-specify-the-bind-field">Do I Have to Specify the <code dangerouslySetInnerHTML={{__html: `bind` }} /> Field<a href="#do-i-have-to-specify-the-bind-field"><Link2Icon /></a></h2>
<p>In our examples, you see that the <code dangerouslySetInnerHTML={{__html: `variable_values` }} /> element is an array, and
each value is an object in which you give the name and value of the variable to
specify. You can also optionally supply another field called <code dangerouslySetInnerHTML={{__html: `bind` }} />. The possible values are
<code dangerouslySetInnerHTML={{__html: `&quot;bound&quot;` }} />, <code dangerouslySetInnerHTML={{__html: `&quot;raw&quot;` }} />, or you can just leave it unset.</p>
<p><Link href="/" passHref><a></a></Link> { /* This fixes the link below. No idea how or why. */ }
To learn about the differences, see our <a href="https://slight.run/docs/apps/using_variables#bound-or-raw">section on &quot;Bound or Raw?&quot; in the doc
page on variables</a>.</p>
<p>So when do you have to set it?</p>
<ul>
<li>If the variable value can be either bound or raw (<code dangerouslySetInnerHTML={{__html: `bound_allow_raw` }} />), you should specify it. If not, it&#39;ll default to <code dangerouslySetInnerHTML={{__html: `bound` }} />.</li>
<li>If the variable is a category variable, it&#39;s possible to have options that
are the same string, but have different bind states. E.g. maybe you have a column called <code dangerouslySetInnerHTML={{__html: `team` }} /> and you want to let users use that, or use the string <code dangerouslySetInnerHTML={{__html: `&quot;team&quot;` }} />. Here you should specify which of the two you mean.</li>
</ul>
<p>Try adding <code dangerouslySetInnerHTML={{__html: `&quot;bind&quot;: &quot;bound&quot;` }} /> (and a comma
after <code dangerouslySetInnerHTML={{__html: `Maya` }} />) and you can verify the results don&#39;t change.</p>


Documentation

Quickstart

Apps