Create GraphQL APIs on SingleStore in 2 minutes

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

Instant GraphQL APIs

Build high-quality GraphQL APIs on SingleStore, instantly

Connect to a new or existing SingleStore 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 SingleStore tables, views, and functions.

GraphQL queries on SingleStore

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

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

Relationships and nesting

The GraphQL API on SingleStore 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 SingleStore using advanced WHERE clauses and Boolean / logical operators like _and / _or, etc.

Sorting

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

Aggregation

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

query fetchUsersAndPosts {
  users(where: { age: { _gt: 18 } }) {
    id
    name
    posts {
      title
      comments {
        text
      }
    }
  }
}

Fetch users' data like the `id` and `name` where the age is > 18, and fetch the `posts` written by them along with the `comments` for each post.

query {
 authors(where: { articles: { rating: { _gt: 4 } } }) {
   id
   name
   articles(where: { rating: { _gt: 4 } }) {
     id
     title
     rating
   }
 }
}

Fetch a list of authors who have articles with a rating greater than 4 along with those articles.

query {
  authors (order_by: {name: asc}) {
    id
    name
    articles(order_by: {rating: desc}) {
      id
      title
      rating
    }
  }
}

Fetch a list of authors sorted by their names with a list of their articles sorted by their rating.

query {
  articles_aggregate {
    aggregate {
      count
      sum {
        rating
      }
      avg {
        rating
      }
      max {
        rating
      }
    }
    nodes {
      id
      title
      rating
    }
  }
}

Fetch a list of articles with aggregated data of their rating.

GraphQL mutations on SingleStore

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

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

Insert into the artist table in SingleStore with values for `id` and `name` columns.

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 SingleStore 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 SQL query for a GraphQL query of any depth and avoids the N+1 problem in GraphQL.

Predicate pushdown SQL to SingleStore

Hasura filters data at the source with a predicate pushdown of SQL queries to SingleStore.

Performance benchmarks

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

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

Add caching to existing SingleStore APIs for faster response times

Get up to 10x faster API performance on SingleStore with end-to-end caching, scaling vertically and horizontally. [Coming soon]

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.