schema.graphql

schema {
  query: query_root
  mutation: mutation_root
  subscription: subscription_root
}

scalar _text

# expression to compare columns of type _text. All fields are combined with logical 'AND'.
input _text_comparison_exp {
  _eq: _text
  _gt: _text
  _gte: _text
  _in: [_text!]
  _is_null: Boolean
  _lt: _text
  _lte: _text
  _neq: _text
  _nin: [_text!]
}

# columns and relationships of "authors"
type authors {
  id: String!
  name: String!
}

# aggregated selection of "authors"
type authors_aggregate {
  aggregate: authors_aggregate_fields
  nodes: [authors!]!
}

# aggregate fields of "authors"
type authors_aggregate_fields {
  count(columns: [authors_select_column!], distinct: Boolean): Int
  max: authors_max_fields
  min: authors_min_fields
}

# order by aggregate values of table "authors"
input authors_aggregate_order_by {
  count: order_by
  max: authors_max_order_by
  min: authors_min_order_by
}

# input type for inserting array relation for remote table "authors"
input authors_arr_rel_insert_input {
  data: [authors_insert_input!]!
  on_conflict: authors_on_conflict
}

# Boolean expression to filter rows from the table "authors". All fields are combined with a logical 'AND'.
input authors_bool_exp {
  _and: [authors_bool_exp]
  _not: authors_bool_exp
  _or: [authors_bool_exp]
  id: String_comparison_exp
  name: String_comparison_exp
}

# unique or primary key constraints on table "authors"
enum authors_constraint {
  # unique or primary key constraint
  authors_pkey
}

# input type for inserting data into table "authors"
input authors_insert_input {
  id: String
  name: String
}

# aggregate max on columns
type authors_max_fields {
  id: String
  name: String
}

# order by max() on columns of table "authors"
input authors_max_order_by {
  id: order_by
  name: order_by
}

# aggregate min on columns
type authors_min_fields {
  id: String
  name: String
}

# order by min() on columns of table "authors"
input authors_min_order_by {
  id: order_by
  name: order_by
}

# response of any mutation on the table "authors"
type authors_mutation_response {
  # number of affected rows by the mutation
  affected_rows: Int!

  # data of the affected rows by the mutation
  returning: [authors!]!
}

# input type for inserting object relation for remote table "authors"
input authors_obj_rel_insert_input {
  data: authors_insert_input!
  on_conflict: authors_on_conflict
}

# on conflict condition type for table "authors"
input authors_on_conflict {
  constraint: authors_constraint!
  update_columns: [authors_update_column!]!
  where: authors_bool_exp
}

# ordering options when selecting data from "authors"
input authors_order_by {
  id: order_by
  name: order_by
}

# primary key columns input for table: "authors"
input authors_pk_columns_input {
  id: String!
}

# select columns of table "authors"
enum authors_select_column {
  # column name
  id

  # column name
  name
}

# input type for updating data in table "authors"
input authors_set_input {
  id: String
  name: String
}

# update columns of table "authors"
enum authors_update_column {
  # column name
  id

  # column name
  name
}

input cites_args {
  limit_: Int
}

# mutation root
type mutation_root {
  # delete data from the table: "authors"
  delete_authors(
    # filter the rows which have to be deleted
    where: authors_bool_exp!
  ): authors_mutation_response

  # delete single row from the table: "authors"
  delete_authors_by_pk(id: String!): authors

  # delete data from the table: "paper_authors"
  delete_paper_authors(
    # filter the rows which have to be deleted
    where: paper_authors_bool_exp!
  ): paper_authors_mutation_response

  # delete single row from the table: "paper_authors"
  delete_paper_authors_by_pk(author_id: String!, paper_id: String!): paper_authors

  # delete data from the table: "papers"
  delete_papers(
    # filter the rows which have to be deleted
    where: papers_bool_exp!
  ): papers_mutation_response

  # delete single row from the table: "papers"
  delete_papers_by_pk(id: String!): papers

  # insert data into the table: "authors"
  insert_authors(
    # the rows to be inserted
    objects: [authors_insert_input!]!

    # on conflict condition
    on_conflict: authors_on_conflict
  ): authors_mutation_response

  # insert a single row into the table: "authors"
  insert_authors_one(
    # the row to be inserted
    object: authors_insert_input!

    # on conflict condition
    on_conflict: authors_on_conflict
  ): authors

  # insert data into the table: "paper_authors"
  insert_paper_authors(
    # the rows to be inserted
    objects: [paper_authors_insert_input!]!

    # on conflict condition
    on_conflict: paper_authors_on_conflict
  ): paper_authors_mutation_response

  # insert a single row into the table: "paper_authors"
  insert_paper_authors_one(
    # the row to be inserted
    object: paper_authors_insert_input!

    # on conflict condition
    on_conflict: paper_authors_on_conflict
  ): paper_authors

  # insert data into the table: "papers"
  insert_papers(
    # the rows to be inserted
    objects: [papers_insert_input!]!

    # on conflict condition
    on_conflict: papers_on_conflict
  ): papers_mutation_response

  # insert a single row into the table: "papers"
  insert_papers_one(
    # the row to be inserted
    object: papers_insert_input!

    # on conflict condition
    on_conflict: papers_on_conflict
  ): papers

  # update data of the table: "authors"
  update_authors(
    # sets the columns of the filtered rows to the given values
    _set: authors_set_input

    # filter the rows which have to be updated
    where: authors_bool_exp!
  ): authors_mutation_response

  # update single row of the table: "authors"
  update_authors_by_pk(
    # sets the columns of the filtered rows to the given values
    _set: authors_set_input
    pk_columns: authors_pk_columns_input!
  ): authors

  # update data of the table: "paper_authors"
  update_paper_authors(
    # sets the columns of the filtered rows to the given values
    _set: paper_authors_set_input

    # filter the rows which have to be updated
    where: paper_authors_bool_exp!
  ): paper_authors_mutation_response

  # update single row of the table: "paper_authors"
  update_paper_authors_by_pk(
    # sets the columns of the filtered rows to the given values
    _set: paper_authors_set_input
    pk_columns: paper_authors_pk_columns_input!
  ): paper_authors

  # update data of the table: "papers"
  update_papers(
    # increments the integer columns with given value of the filtered values
    _inc: papers_inc_input

    # sets the columns of the filtered rows to the given values
    _set: papers_set_input

    # filter the rows which have to be updated
    where: papers_bool_exp!
  ): papers_mutation_response

  # update single row of the table: "papers"
  update_papers_by_pk(
    # increments the integer columns with given value of the filtered values
    _inc: papers_inc_input

    # sets the columns of the filtered rows to the given values
    _set: papers_set_input
    pk_columns: papers_pk_columns_input!
  ): papers
}

# column ordering options
enum order_by {
  # in the ascending order, nulls last
  asc

  # in the ascending order, nulls first
  asc_nulls_first

  # in the ascending order, nulls last
  asc_nulls_last

  # in the descending order, nulls first
  desc

  # in the descending order, nulls first
  desc_nulls_first

  # in the descending order, nulls last
  desc_nulls_last
}

# columns and relationships of "paper_authors"
type paper_authors {
  # An object relationship
  author: authors
  author_id: String!

  # An object relationship
  paper: papers
  paper_id: String!
}

# aggregated selection of "paper_authors"
type paper_authors_aggregate {
  aggregate: paper_authors_aggregate_fields
  nodes: [paper_authors!]!
}

# aggregate fields of "paper_authors"
type paper_authors_aggregate_fields {
  count(columns: [paper_authors_select_column!], distinct: Boolean): Int
  max: paper_authors_max_fields
  min: paper_authors_min_fields
}

# order by aggregate values of table "paper_authors"
input paper_authors_aggregate_order_by {
  count: order_by
  max: paper_authors_max_order_by
  min: paper_authors_min_order_by
}

# input type for inserting array relation for remote table "paper_authors"
input paper_authors_arr_rel_insert_input {
  data: [paper_authors_insert_input!]!
  on_conflict: paper_authors_on_conflict
}

# Boolean expression to filter rows from the table "paper_authors". All fields are combined with a logical 'AND'.
input paper_authors_bool_exp {
  _and: [paper_authors_bool_exp]
  _not: paper_authors_bool_exp
  _or: [paper_authors_bool_exp]
  author: authors_bool_exp
  author_id: String_comparison_exp
  paper: papers_bool_exp
  paper_id: String_comparison_exp
}

# unique or primary key constraints on table "paper_authors"
enum paper_authors_constraint {
  # unique or primary key constraint
  paper_authors_pkey
}

# input type for inserting data into table "paper_authors"
input paper_authors_insert_input {
  author: authors_obj_rel_insert_input
  author_id: String
  paper: papers_obj_rel_insert_input
  paper_id: String
}

# aggregate max on columns
type paper_authors_max_fields {
  author_id: String
  paper_id: String
}

# order by max() on columns of table "paper_authors"
input paper_authors_max_order_by {
  author_id: order_by
  paper_id: order_by
}

# aggregate min on columns
type paper_authors_min_fields {
  author_id: String
  paper_id: String
}

# order by min() on columns of table "paper_authors"
input paper_authors_min_order_by {
  author_id: order_by
  paper_id: order_by
}

# response of any mutation on the table "paper_authors"
type paper_authors_mutation_response {
  # number of affected rows by the mutation
  affected_rows: Int!

  # data of the affected rows by the mutation
  returning: [paper_authors!]!
}

# input type for inserting object relation for remote table "paper_authors"
input paper_authors_obj_rel_insert_input {
  data: paper_authors_insert_input!
  on_conflict: paper_authors_on_conflict
}

# on conflict condition type for table "paper_authors"
input paper_authors_on_conflict {
  constraint: paper_authors_constraint!
  update_columns: [paper_authors_update_column!]!
  where: paper_authors_bool_exp
}

# ordering options when selecting data from "paper_authors"
input paper_authors_order_by {
  author: authors_order_by
  author_id: order_by
  paper: papers_order_by
  paper_id: order_by
}

# primary key columns input for table: "paper_authors"
input paper_authors_pk_columns_input {
  author_id: String!
  paper_id: String!
}

# select columns of table "paper_authors"
enum paper_authors_select_column {
  # column name
  author_id

  # column name
  paper_id
}

# input type for updating data in table "paper_authors"
input paper_authors_set_input {
  author_id: String
  paper_id: String
}

# update columns of table "paper_authors"
enum paper_authors_update_column {
  # column name
  author_id

  # column name
  paper_id
}

# columns and relationships of "papers"
type papers {
  # An array relationship
  authors(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): [paper_authors!]!

  # An aggregated array relationship
  authors_aggregate(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): paper_authors_aggregate!

  # A computed field, executes function "cites"
  cites(
    # input parameters for function "cites"
    args: cites_args!

    # distinct select on columns
    distinct_on: [papers_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [papers_order_by!]

    # filter the rows returned
    where: papers_bool_exp
  ): [papers!]
  doi: String
  doi_url: String
  entities: _text
  fields_of_study: _text
  id: String!
  in_citations: _text

  # A computed field, executes function "num_citations"
  num_citations: Int
  out_citations: _text
  paper_abstract: String
  pdf_urls: _text
  s2_url: String
  title: String!
  year: smallint
}

# aggregated selection of "papers"
type papers_aggregate {
  aggregate: papers_aggregate_fields
  nodes: [papers!]!
}

# aggregate fields of "papers"
type papers_aggregate_fields {
  avg: papers_avg_fields
  count(columns: [papers_select_column!], distinct: Boolean): Int
  max: papers_max_fields
  min: papers_min_fields
  stddev: papers_stddev_fields
  stddev_pop: papers_stddev_pop_fields
  stddev_samp: papers_stddev_samp_fields
  sum: papers_sum_fields
  var_pop: papers_var_pop_fields
  var_samp: papers_var_samp_fields
  variance: papers_variance_fields
}

# order by aggregate values of table "papers"
input papers_aggregate_order_by {
  avg: papers_avg_order_by
  count: order_by
  max: papers_max_order_by
  min: papers_min_order_by
  stddev: papers_stddev_order_by
  stddev_pop: papers_stddev_pop_order_by
  stddev_samp: papers_stddev_samp_order_by
  sum: papers_sum_order_by
  var_pop: papers_var_pop_order_by
  var_samp: papers_var_samp_order_by
  variance: papers_variance_order_by
}

# input type for inserting array relation for remote table "papers"
input papers_arr_rel_insert_input {
  data: [papers_insert_input!]!
  on_conflict: papers_on_conflict
}

# aggregate avg on columns
type papers_avg_fields {
  year: Float
}

# order by avg() on columns of table "papers"
input papers_avg_order_by {
  year: order_by
}

# Boolean expression to filter rows from the table "papers". All fields are combined with a logical 'AND'.
input papers_bool_exp {
  _and: [papers_bool_exp]
  _not: papers_bool_exp
  _or: [papers_bool_exp]
  authors: paper_authors_bool_exp
  doi: String_comparison_exp
  doi_url: String_comparison_exp
  entities: _text_comparison_exp
  fields_of_study: _text_comparison_exp
  id: String_comparison_exp
  in_citations: _text_comparison_exp
  out_citations: _text_comparison_exp
  paper_abstract: String_comparison_exp
  pdf_urls: _text_comparison_exp
  s2_url: String_comparison_exp
  title: String_comparison_exp
  year: smallint_comparison_exp
}

# unique or primary key constraints on table "papers"
enum papers_constraint {
  # unique or primary key constraint
  papers_pkey
}

# input type for incrementing integer column in table "papers"
input papers_inc_input {
  year: smallint
}

# input type for inserting data into table "papers"
input papers_insert_input {
  authors: paper_authors_arr_rel_insert_input
  doi: String
  doi_url: String
  entities: _text
  fields_of_study: _text
  id: String
  in_citations: _text
  out_citations: _text
  paper_abstract: String
  pdf_urls: _text
  s2_url: String
  title: String
  year: smallint
}

# aggregate max on columns
type papers_max_fields {
  doi: String
  doi_url: String
  id: String
  paper_abstract: String
  s2_url: String
  title: String
  year: smallint
}

# order by max() on columns of table "papers"
input papers_max_order_by {
  doi: order_by
  doi_url: order_by
  id: order_by
  paper_abstract: order_by
  s2_url: order_by
  title: order_by
  year: order_by
}

# aggregate min on columns
type papers_min_fields {
  doi: String
  doi_url: String
  id: String
  paper_abstract: String
  s2_url: String
  title: String
  year: smallint
}

# order by min() on columns of table "papers"
input papers_min_order_by {
  doi: order_by
  doi_url: order_by
  id: order_by
  paper_abstract: order_by
  s2_url: order_by
  title: order_by
  year: order_by
}

# response of any mutation on the table "papers"
type papers_mutation_response {
  # number of affected rows by the mutation
  affected_rows: Int!

  # data of the affected rows by the mutation
  returning: [papers!]!
}

# input type for inserting object relation for remote table "papers"
input papers_obj_rel_insert_input {
  data: papers_insert_input!
  on_conflict: papers_on_conflict
}

# on conflict condition type for table "papers"
input papers_on_conflict {
  constraint: papers_constraint!
  update_columns: [papers_update_column!]!
  where: papers_bool_exp
}

# ordering options when selecting data from "papers"
input papers_order_by {
  authors_aggregate: paper_authors_aggregate_order_by
  doi: order_by
  doi_url: order_by
  entities: order_by
  fields_of_study: order_by
  id: order_by
  in_citations: order_by
  out_citations: order_by
  paper_abstract: order_by
  pdf_urls: order_by
  s2_url: order_by
  title: order_by
  year: order_by
}

# primary key columns input for table: "papers"
input papers_pk_columns_input {
  id: String!
}

# select columns of table "papers"
enum papers_select_column {
  # column name
  doi

  # column name
  doi_url

  # column name
  entities

  # column name
  fields_of_study

  # column name
  id

  # column name
  in_citations

  # column name
  out_citations

  # column name
  paper_abstract

  # column name
  pdf_urls

  # column name
  s2_url

  # column name
  title

  # column name
  year
}

# input type for updating data in table "papers"
input papers_set_input {
  doi: String
  doi_url: String
  entities: _text
  fields_of_study: _text
  id: String
  in_citations: _text
  out_citations: _text
  paper_abstract: String
  pdf_urls: _text
  s2_url: String
  title: String
  year: smallint
}

# aggregate stddev on columns
type papers_stddev_fields {
  year: Float
}

# order by stddev() on columns of table "papers"
input papers_stddev_order_by {
  year: order_by
}

# aggregate stddev_pop on columns
type papers_stddev_pop_fields {
  year: Float
}

# order by stddev_pop() on columns of table "papers"
input papers_stddev_pop_order_by {
  year: order_by
}

# aggregate stddev_samp on columns
type papers_stddev_samp_fields {
  year: Float
}

# order by stddev_samp() on columns of table "papers"
input papers_stddev_samp_order_by {
  year: order_by
}

# aggregate sum on columns
type papers_sum_fields {
  year: smallint
}

# order by sum() on columns of table "papers"
input papers_sum_order_by {
  year: order_by
}

# update columns of table "papers"
enum papers_update_column {
  # column name
  doi

  # column name
  doi_url

  # column name
  entities

  # column name
  fields_of_study

  # column name
  id

  # column name
  in_citations

  # column name
  out_citations

  # column name
  paper_abstract

  # column name
  pdf_urls

  # column name
  s2_url

  # column name
  title

  # column name
  year
}

# aggregate var_pop on columns
type papers_var_pop_fields {
  year: Float
}

# order by var_pop() on columns of table "papers"
input papers_var_pop_order_by {
  year: order_by
}

# aggregate var_samp on columns
type papers_var_samp_fields {
  year: Float
}

# order by var_samp() on columns of table "papers"
input papers_var_samp_order_by {
  year: order_by
}

# aggregate variance on columns
type papers_variance_fields {
  year: Float
}

# order by variance() on columns of table "papers"
input papers_variance_order_by {
  year: order_by
}

# query root
type query_root {
  # fetch data from the table: "authors"
  authors(
    # distinct select on columns
    distinct_on: [authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [authors_order_by!]

    # filter the rows returned
    where: authors_bool_exp
  ): [authors!]!

  # fetch aggregated fields from the table: "authors"
  authors_aggregate(
    # distinct select on columns
    distinct_on: [authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [authors_order_by!]

    # filter the rows returned
    where: authors_bool_exp
  ): authors_aggregate!

  # fetch data from the table: "authors" using primary key columns
  authors_by_pk(id: String!): authors

  # fetch data from the table: "paper_authors"
  paper_authors(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): [paper_authors!]!

  # fetch aggregated fields from the table: "paper_authors"
  paper_authors_aggregate(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): paper_authors_aggregate!

  # fetch data from the table: "paper_authors" using primary key columns
  paper_authors_by_pk(author_id: String!, paper_id: String!): paper_authors

  # fetch data from the table: "papers"
  papers(
    # distinct select on columns
    distinct_on: [papers_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [papers_order_by!]

    # filter the rows returned
    where: papers_bool_exp
  ): [papers!]!

  # fetch aggregated fields from the table: "papers"
  papers_aggregate(
    # distinct select on columns
    distinct_on: [papers_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [papers_order_by!]

    # filter the rows returned
    where: papers_bool_exp
  ): papers_aggregate!

  # fetch data from the table: "papers" using primary key columns
  papers_by_pk(id: String!): papers
}

scalar smallint

# expression to compare columns of type smallint. All fields are combined with logical 'AND'.
input smallint_comparison_exp {
  _eq: smallint
  _gt: smallint
  _gte: smallint
  _in: [smallint!]
  _is_null: Boolean
  _lt: smallint
  _lte: smallint
  _neq: smallint
  _nin: [smallint!]
}

# expression to compare columns of type String. All fields are combined with logical 'AND'.
input String_comparison_exp {
  _eq: String
  _gt: String
  _gte: String
  _ilike: String
  _in: [String!]
  _is_null: Boolean
  _like: String
  _lt: String
  _lte: String
  _neq: String
  _nilike: String
  _nin: [String!]
  _nlike: String
  _nsimilar: String
  _similar: String
}

# subscription root
type subscription_root {
  # fetch data from the table: "authors"
  authors(
    # distinct select on columns
    distinct_on: [authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [authors_order_by!]

    # filter the rows returned
    where: authors_bool_exp
  ): [authors!]!

  # fetch aggregated fields from the table: "authors"
  authors_aggregate(
    # distinct select on columns
    distinct_on: [authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [authors_order_by!]

    # filter the rows returned
    where: authors_bool_exp
  ): authors_aggregate!

  # fetch data from the table: "authors" using primary key columns
  authors_by_pk(id: String!): authors

  # fetch data from the table: "paper_authors"
  paper_authors(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): [paper_authors!]!

  # fetch aggregated fields from the table: "paper_authors"
  paper_authors_aggregate(
    # distinct select on columns
    distinct_on: [paper_authors_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [paper_authors_order_by!]

    # filter the rows returned
    where: paper_authors_bool_exp
  ): paper_authors_aggregate!

  # fetch data from the table: "paper_authors" using primary key columns
  paper_authors_by_pk(author_id: String!, paper_id: String!): paper_authors

  # fetch data from the table: "papers"
  papers(
    # distinct select on columns
    distinct_on: [papers_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [papers_order_by!]

    # filter the rows returned
    where: papers_bool_exp
  ): [papers!]!

  # fetch aggregated fields from the table: "papers"
  papers_aggregate(
    # distinct select on columns
    distinct_on: [papers_select_column!]

    # limit the number of rows returned
    limit: Int

    # skip the first n rows. Use only with order_by
    offset: Int

    # sort the rows by one or more columns
    order_by: [papers_order_by!]

    # filter the rows returned
    where: papers_bool_exp
  ): papers_aggregate!

  # fetch data from the table: "papers" using primary key columns
  papers_by_pk(id: String!): papers
}