schema.graphql

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

scalar jsonb

# Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.
input jsonb_comparison_exp {
  # is the column contained in the given json value
  _contained_in: jsonb

  # does the column contain the given json value at the top level
  _contains: jsonb
  _eq: jsonb
  _gt: jsonb
  _gte: jsonb

  # does the string exist as a top-level key in the column
  _has_key: String

  # do all of these strings exist as top-level keys in the column
  _has_keys_all: [String!]

  # do any of these strings exist as top-level keys in the column
  _has_keys_any: [String!]
  _in: [jsonb!]
  _is_null: Boolean
  _lt: jsonb
  _lte: jsonb
  _neq: jsonb
  _nin: [jsonb!]
}

# mutation root
type mutation_root {
  # delete data from the table: "spotipiano"
  delete_spotipiano(
    # filter the rows which have to be deleted
    where: spotipiano_bool_exp!
  ): spotipiano_mutation_response

  # delete single row from the table: "spotipiano"
  delete_spotipiano_by_pk(id: uuid!): spotipiano

  # insert data into the table: "spotipiano"
  insert_spotipiano(
    # the rows to be inserted
    objects: [spotipiano_insert_input!]!

    # on conflict condition
    on_conflict: spotipiano_on_conflict
  ): spotipiano_mutation_response

  # insert a single row into the table: "spotipiano"
  insert_spotipiano_one(
    # the row to be inserted
    object: spotipiano_insert_input!

    # on conflict condition
    on_conflict: spotipiano_on_conflict
  ): spotipiano

  # update data of the table: "spotipiano"
  update_spotipiano(
    # append existing jsonb value of filtered columns with new jsonb value
    _append: spotipiano_append_input

    # delete the field or element with specified path (for JSON arrays, negative integers count from the end)
    _delete_at_path: spotipiano_delete_at_path_input

    # delete the array element with specified index (negative integers count from
    # the end). throws an error if top level container is not an array
    _delete_elem: spotipiano_delete_elem_input

    # delete key/value pair or string element. key/value pairs are matched based on their key value
    _delete_key: spotipiano_delete_key_input

    # prepend existing jsonb value of filtered columns with new jsonb value
    _prepend: spotipiano_prepend_input

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

    # filter the rows which have to be updated
    where: spotipiano_bool_exp!
  ): spotipiano_mutation_response

  # update single row of the table: "spotipiano"
  update_spotipiano_by_pk(
    # append existing jsonb value of filtered columns with new jsonb value
    _append: spotipiano_append_input

    # delete the field or element with specified path (for JSON arrays, negative integers count from the end)
    _delete_at_path: spotipiano_delete_at_path_input

    # delete the array element with specified index (negative integers count from
    # the end). throws an error if top level container is not an array
    _delete_elem: spotipiano_delete_elem_input

    # delete key/value pair or string element. key/value pairs are matched based on their key value
    _delete_key: spotipiano_delete_key_input

    # prepend existing jsonb value of filtered columns with new jsonb value
    _prepend: spotipiano_prepend_input

    # sets the columns of the filtered rows to the given values
    _set: spotipiano_set_input
    pk_columns: spotipiano_pk_columns_input!
  ): spotipiano
}

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

  # in ascending order, nulls first
  asc_nulls_first

  # in ascending order, nulls last
  asc_nulls_last

  # in descending order, nulls first
  desc

  # in descending order, nulls first
  desc_nulls_first

  # in descending order, nulls last
  desc_nulls_last
}

type query_root {
  # fetch data from the table: "spotipiano"
  spotipiano(
    # distinct select on columns
    distinct_on: [spotipiano_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: [spotipiano_order_by!]

    # filter the rows returned
    where: spotipiano_bool_exp
  ): [spotipiano!]!

  # fetch aggregated fields from the table: "spotipiano"
  spotipiano_aggregate(
    # distinct select on columns
    distinct_on: [spotipiano_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: [spotipiano_order_by!]

    # filter the rows returned
    where: spotipiano_bool_exp
  ): spotipiano_aggregate!

  # fetch data from the table: "spotipiano" using primary key columns
  spotipiano_by_pk(id: uuid!): spotipiano
}

# columns and relationships of "spotipiano"
type spotipiano {
  created_at: timestamptz!
  id: uuid!
  piano(
    # JSON select path
    path: String
  ): jsonb!
  song(
    # JSON select path
    path: String
  ): jsonb
  title: String!
}

# aggregated selection of "spotipiano"
type spotipiano_aggregate {
  aggregate: spotipiano_aggregate_fields
  nodes: [spotipiano!]!
}

# aggregate fields of "spotipiano"
type spotipiano_aggregate_fields {
  count(columns: [spotipiano_select_column!], distinct: Boolean): Int!
  max: spotipiano_max_fields
  min: spotipiano_min_fields
}

# append existing jsonb value of filtered columns with new jsonb value
input spotipiano_append_input {
  piano: jsonb
  song: jsonb
}

# Boolean expression to filter rows from the table "spotipiano". All fields are combined with a logical 'AND'.
input spotipiano_bool_exp {
  _and: [spotipiano_bool_exp!]
  _not: spotipiano_bool_exp
  _or: [spotipiano_bool_exp!]
  created_at: timestamptz_comparison_exp
  id: uuid_comparison_exp
  piano: jsonb_comparison_exp
  song: jsonb_comparison_exp
  title: String_comparison_exp
}

# unique or primary key constraints on table "spotipiano"
enum spotipiano_constraint {
  # unique or primary key constraint
  spotipiano_pkey
}

# delete the field or element with specified path (for JSON arrays, negative integers count from the end)
input spotipiano_delete_at_path_input {
  piano: [String!]
  song: [String!]
}

# delete the array element with specified index (negative integers count from the
# end). throws an error if top level container is not an array
input spotipiano_delete_elem_input {
  piano: Int
  song: Int
}

# delete key/value pair or string element. key/value pairs are matched based on their key value
input spotipiano_delete_key_input {
  piano: String
  song: String
}

# input type for inserting data into table "spotipiano"
input spotipiano_insert_input {
  created_at: timestamptz
  id: uuid
  piano: jsonb
  song: jsonb
  title: String
}

# aggregate max on columns
type spotipiano_max_fields {
  created_at: timestamptz
  id: uuid
  title: String
}

# aggregate min on columns
type spotipiano_min_fields {
  created_at: timestamptz
  id: uuid
  title: String
}

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

  # data from the rows affected by the mutation
  returning: [spotipiano!]!
}

# on conflict condition type for table "spotipiano"
input spotipiano_on_conflict {
  constraint: spotipiano_constraint!
  update_columns: [spotipiano_update_column!]! = []
  where: spotipiano_bool_exp
}

# Ordering options when selecting data from "spotipiano".
input spotipiano_order_by {
  created_at: order_by
  id: order_by
  piano: order_by
  song: order_by
  title: order_by
}

# primary key columns input for table: spotipiano
input spotipiano_pk_columns_input {
  id: uuid!
}

# prepend existing jsonb value of filtered columns with new jsonb value
input spotipiano_prepend_input {
  piano: jsonb
  song: jsonb
}

# select columns of table "spotipiano"
enum spotipiano_select_column {
  # column name
  created_at

  # column name
  id

  # column name
  piano

  # column name
  song

  # column name
  title
}

# input type for updating data in table "spotipiano"
input spotipiano_set_input {
  created_at: timestamptz
  id: uuid
  piano: jsonb
  song: jsonb
  title: String
}

# update columns of table "spotipiano"
enum spotipiano_update_column {
  # column name
  created_at

  # column name
  id

  # column name
  piano

  # column name
  song

  # column name
  title
}

# Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.
input String_comparison_exp {
  _eq: String
  _gt: String
  _gte: String

  # does the column match the given case-insensitive pattern
  _ilike: String
  _in: [String!]

  # does the column match the given POSIX regular expression, case insensitive
  _iregex: String
  _is_null: Boolean

  # does the column match the given pattern
  _like: String
  _lt: String
  _lte: String
  _neq: String

  # does the column NOT match the given case-insensitive pattern
  _nilike: String
  _nin: [String!]

  # does the column NOT match the given POSIX regular expression, case insensitive
  _niregex: String

  # does the column NOT match the given pattern
  _nlike: String

  # does the column NOT match the given POSIX regular expression, case sensitive
  _nregex: String

  # does the column NOT match the given SQL regular expression
  _nsimilar: String

  # does the column match the given POSIX regular expression, case sensitive
  _regex: String

  # does the column match the given SQL regular expression
  _similar: String
}

type subscription_root {
  # fetch data from the table: "spotipiano"
  spotipiano(
    # distinct select on columns
    distinct_on: [spotipiano_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: [spotipiano_order_by!]

    # filter the rows returned
    where: spotipiano_bool_exp
  ): [spotipiano!]!

  # fetch aggregated fields from the table: "spotipiano"
  spotipiano_aggregate(
    # distinct select on columns
    distinct_on: [spotipiano_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: [spotipiano_order_by!]

    # filter the rows returned
    where: spotipiano_bool_exp
  ): spotipiano_aggregate!

  # fetch data from the table: "spotipiano" using primary key columns
  spotipiano_by_pk(id: uuid!): spotipiano
}

scalar timestamptz

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

scalar uuid

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