Query Views

​

Overview

The “Query View” feature in DuneSQL allows you to use an existing query as a view in another query. This powerful functionality enables you to create reusable queries, build complex queries, and take advantage of existing queries as views.

You can also pass on parameters when querying a query view.

​

Using Query View

To use the “Query View” feature, you will need the queryID of the query you want to use as a view. The queryID can be found in the URL of a query. For example, if the URL of a query is https://dune.com/queries/1746191, the queryID would be 1746191.

Once you have the queryID, you can use it in your new query using the following syntax:

select * from query_<queryID>

For example, if you want to use the query with queryID 1746191 as a view in your new query, you would write:

select * from query_1746191 

​

Adding Parameters When Using Query Views

You can also pass on parameters when querying a query view. This allows you to use the same query view with different parameters in different queries.

To pass on parameters when querying a query view, you need to use the following syntax:

Select * from "query_<queryID>(<parameter1>='<value1>', <parameter2>='<value2>', ...)"

For example, if you want to use the query with queryID 3256410 as a view in your new query and pass on the parameter blockchain with the value ethereum, the setup would look like this:

--query_3256410, our query to be invoked
Select 
    project,
    block_date,
    sum(amount_usd) as amount_usd
from dex.trades
where blockchain = '{{blockchain}}'
and block_time > now() - interval '7' day 

link to query

--query_3256401, our query that invokes the query_3256410
Select 
    project,
    block_date,
    amount_usd 
from "query_3256410(blockchain='ethereum')"

link to query

Parameters in the query view are passed on as strings and therefore always need to be wrapped in single quotes. Since we sometimes want to pass a string including the single quotes, we need to escape the single quotes in the query view. We can do that by adding a backslash in front of the single quote. Escaping single quotes means that the single quote will be treated as a literal character and not as a string delimiter.

For example:

--query to be invoked
Select 
    project,
    block_date,
    sum(amount_usd) as volume_in_usd
from dex.trades
where blockchain = {{blockchain}}
-- we want to pass a string including the single quotes to this query

--query that invokes the query above
Select 
    project,
    block_date,
    volume_in_usd
from "query_3256410(blockchain='\'ethereum\'')"
--note the escaped single quotes
--this will pass the parameter blockchain with the value 'ethereum'

The backslash is not needed when passing on a parameter that doesn’t need to be wrapped in single quotes on the receiving side, like integers or booleans. You can choose to handle this on the query view side or on the query that invokes the query view side. If you wrap your parameter in single quotes on the receiving side, you don’t need to escape the single quotes on the query view side.

For example:

--query_3256410, our query to be invoked
Select 
    project,
    block_date,
    sum(amount_usd) as amount_usd
from dex.trades
where blockchain = '{{blockchain}}'
and block_time > now() - interval '7' day 
--note the single quotes around the parameter blockchain

Select 
    project,
    block_date,
    amount_usd 
from "query_3256410(blockchain='ethereum')"
--since we wrap the parameter blockchain in single quotes on the receiving side, we don't need to escape the single quotes on the query view side

The table below shows how different parameter types are passed on when using the “Query view” feature:

​

Limitations

There are some important limitations and requirements to consider when using the “Query a Query” feature:

1. Named output columns: All output columns of the query being queried must be named. For example, you cannot query select 1 or select count(*) from ethereum.transactions, but you can query select 1 as v and select count(*) as total from ethereum.transactions.
2. Saved queries: Only saved queries can be used with the “Query a Query” feature.
3. Archived queries: Archived queries cannot be queried.
4. Dune SQL: Only queries written in Dune SQL can be queried.
5. Mixed cases on parameters: If you pass parameters when querying a query, the parameter key and its values should be lower case (i.e.: select "query_123(Key=\'VaLue\')" will not work).
6. List parameters: the query you’re querying cannot have parameters that use list options from the results of a separate query.

​

Best Practices

When using the “Query View” feature, consider the following best practices:

1. Naming conventions: Ensure that your queries follow a consistent naming convention for output columns. This will make it easier to understand and reuse queries as views.
2. Documentation: Provide clear documentation and comments for your queries, especially when they are intended to be used as views in other queries.
3. Modularity: Break down complex queries into smaller, reusable components. This will make your queries more maintainable and easier to understand.
4. Version control: If you need to update a query that is being used as a view in other queries, consider creating a new version of the query instead of modifying the existing one. This will help prevent unexpected changes in dependent queries.
5. Forking If you use the query of another user as a view in your query, consider forking the query instead of querying it. That way, you will not be affected by changes made to the Original Query. On the other hand, you will also not be able to benefit from any improvements made to the Original Query.