Create GraphQL APIs on ClickHouse in 2 minutes

Connect Hasura to your new or existing ClickHouse database and generate high-quality, secure, and performant GraphQL APIs.

Instant GraphQL APIs

Build high-quality GraphQL APIs on ClickHouse, instantly

Connect to a new or existing ClickHouse database and get standardized, highly composable GraphQL APIs. The Hasura GraphQL Engine introspects the database and automatically generates GraphQL schemas and resolvers based on the ClickHouse tables, views, and functions.

GraphQL queries on ClickHouse

Leverage the full power of GraphQL API to interact with your ClickHouse database for all your read use cases.

Query exactly what you want from your ClickHouse tables, views, and functions.

Relationships and nesting

The GraphQL API on ClickHouse handles relationships between models, and queries can be nested to any depth if required.

Pagination

Easily manage large datasets with built-in pagination capabilities. Cursor-based, Relay-style, and offset-based pagination is supported natively.

Filtering

Filter query results on ClickHouse columns and fields using advanced WHERE clauses and Boolean / logical operators like _and / _or, etc.

Sorting

Sort data based on multiple fields in ClickHouse rows and specify the sort direction (ascending or descending), making it easy to present your data.

Aggregation

Perform various aggregations to get summary about your ClickHouse data directly within your GraphQL queries. Leverage aggregate functions in ClickHouse DB like count, sum, min, max, avg, etc.

Parameterized views

Create parameterized views in ClickHouse and query them via GraphQL.

query fetchPropertyPrice {
  ukPricePaid(limit: 10, order_by: {price: Desc}) {
    date
    district
    price
    region {
      name
      county
    }
  }
}

Fetch `date`, `district`, `price` and `region` relationship for UK property price data.

query fetchPropertyPrice {
  ukPricePaid(limit: 10, offset: 10) {
    county
    date
    district
    price
    type
    postcode1
  }
}

Fetch 10 records from the list of all property prices, starting with the 11th one.

query fetchNewData {
  mySubgraph_ukPricePaid(where: {isNew: {_eq: "true"}}, limit: 10) {
    isNew
    county
    date
    price
    type
  }
}

Fetch a list of property prices where the property is new.

query propertyPriceSortedByTown {
  ukPricePaid(order_by: {town: Asc}, limit: 10) {
    isNew
    county
    date
    price
    type
  }
}

Fetch a list of 10 property records sorted by their town names.

query {
  ukPricePaid_aggregate {
    aggregate {
      count
      sum {
        price
      }
      avg {
        price
      }
      max {
        price
      }
    }
    nodes {
      isNew
      price
      town
    }
  }
}

Fetch a list of property records with aggregated data of their price.

query fetchPropertyPrice {
  mySubgraph_ukPricePaid(where: {isNew: {_eq: "true"}, price: {_gt: "10000"}}) {
    isNew
    county
    date
    price
    type
  }
}

Query based on parameterized views on ClickHouse

GraphQL mutations on ClickHouse

Perform robust data manipulation operations on your ClickHouse database with GraphQL mutations. Insert, update, or delete data in ClickHouse via Hasura’s native queries.

mutation {
 insert_artist(id: 100, name: "New Artist") {
   ArtistId
   Name
 }
}

Insert into the artist row in ClickHouse DB table with values for `id` and `name` fields.

High-performance GraphQL APIs, at scale

Hasura takes a domain-driven approach to GraphQL, where a GraphQL query is compiled to a query on a domain model (a database query or existing APIs) resulting in superior API performance.

Hasura leverages the goodness of ClickHouse to create efficient GraphQL queries.

Compile vs. resolve

Hasura avoids the GraphQL N+1 query problem by compiling a query instead of resolving. This compiler-based approach allows Hasura to form a single database query for a GraphQL query of any depth and avoids the N+1 problem in GraphQL.

Predicate pushdown ClickHouse database query

Hasura filters data at the source with a predicate pushdown of queries to ClickHouse. Hasura can push down a majority of queries like relationships and joins, arguments, and filtering.

Performance benchmarks

Hasura’s GraphQL APIs are faster than handwritten subgraphs on top of ClickHouse

Learn more about how Hasura does high-performance domain-driven APIs.

Add caching to existing ClickHouse GraphQL APIs for faster response times

Get up to 10x faster API performance on ClickHouse with end-to-end caching, scaling vertically and horizontally.

Hasura has metadata about the data models across data sources, and the authorization rules at the application level, which helps provide end-to-end caching.