// Generated from src/binary-wire.json by generate-binary-codecs.ts.
// Contract SHA256: f3e811d415bf6e48620b30d666547b023504647406200f3b8e0f9abbe367dd96
// Numeric variant tags and ordered fields are the versioned wire contract.

///|
impl Binary for Ordering with fn write(value, w) {
  Binary::write(value.expression, w)
  Binary::write(value.descending, w)
}

///|
impl Binary for Ordering with fn read(r) {
  r.enter()
  defer r.leave()
  let expression : Expr = Binary::read(r)
  let descending : Bool = Binary::read(r)
  let value : Ordering = { expression, descending, }

  value
}

///|
impl Binary for Projection with fn write(value, w) {
  Binary::write(value.expression, w)
  Binary::write(value.explicit_label, w)
  Binary::write(value.label, w)
}

///|
impl Binary for Projection with fn read(r) {
  r.enter()
  defer r.leave()
  let expression : Expr = Binary::read(r)
  let explicit_label : Bool = Binary::read(r)
  let label : String = Binary::read(r)
  let value : Projection = { expression, explicit_label, label, }

  value
}

///|
impl Binary for Source with fn write(value, w) {
  if value.right == Some(true) ||
    value.natural == Some(true) ||
    value.using_columns.unwrap_or([]).length() > 0 {
    w.require_feature(8U)
  }
  Binary::write(value.name, w)
  Binary::write(value.qualifier, w)
  Binary::write(value.left, w)
  Binary::write(value.right, w)
  Binary::write(value.using_columns, w)
  Binary::write(value.natural, w)
  Binary::write(value.on, w)
}

///|
impl Binary for Source with fn read(r) {
  r.enter()
  defer r.leave()
  let name : String = Binary::read(r)
  let qualifier : String = Binary::read(r)
  let left : Bool = Binary::read(r)
  let right : Bool? = Binary::read(r)
  let using_columns : Array[String]? = Binary::read(r)
  let natural : Bool? = Binary::read(r)
  let on : Expr = Binary::read(r)
  let value : Source = {
    name,
    qualifier,
    left,
    right,
    using_columns,
    natural,
    on,
  }
  if value.right == Some(true) ||
    value.natural == Some(true) ||
    value.using_columns.unwrap_or([]).length() > 0 {
    r.require_feature(8U)
  }
  value
}

///|
impl Binary for Selection with fn write(value, w) {
  Binary::write(value.ctes, w)
  Binary::write(value.projections, w)
  Binary::write(value.sources, w)
  Binary::write(value.predicate, w)
  Binary::write(value.groups, w)
  Binary::write(value.having, w)
  Binary::write(value.orders, w)
  Binary::write(value.limit, w)
  Binary::write(value.offset, w)
  Binary::write(value.distinct, w)
  Binary::write(value.compound, w)
  Binary::write(value.recursive, w)
  Binary::write(value.cte_names, w)
}

///|
impl Binary for Selection with fn read(r) {
  r.enter()
  defer r.leave()
  let ctes : Array[(String, Selection)] = Binary::read(r)
  let projections : Array[Projection] = Binary::read(r)
  let sources : Array[Source] = Binary::read(r)
  let predicate : Expr = Binary::read(r)
  let groups : Array[Expr] = Binary::read(r)
  let having : Expr = Binary::read(r)
  let orders : Array[Ordering] = Binary::read(r)
  let limit : Expr = Binary::read(r)
  let offset : Expr = Binary::read(r)
  let distinct : Bool = Binary::read(r)
  let compound : Array[(String, Selection)]? = Binary::read(r)
  let recursive : Bool? = Binary::read(r)
  let cte_names : Array[(String, Array[String])]? = Binary::read(r)
  let value : Selection = {
    ctes,
    projections,
    sources,
    predicate,
    groups,
    having,
    orders,
    limit,
    offset,
    distinct,
    compound,
    recursive,
    cte_names,
  }

  value
}

///|
impl Binary for ForeignKey with fn write(value, w) {
  w.require_feature(1U)
  Binary::write(value.column, w)
  Binary::write(value.parent, w)
  Binary::write(value.target, w)
  Binary::write(value.cascade, w)
  Binary::write(value.columns, w)
  Binary::write(value.targets, w)
  Binary::write(value.delete_action, w)
  Binary::write(value.update_action, w)
  Binary::write(value.initially_deferred, w)
}

///|
impl Binary for ForeignKey with fn read(r) {
  r.enter()
  defer r.leave()
  let column : Int32 = Binary::read(r)
  let parent : String = Binary::read(r)
  let target : String = Binary::read(r)
  let cascade : Bool = Binary::read(r)
  let columns : Array[Int32]? = Binary::read(r)
  let targets : Array[String]? = Binary::read(r)
  let delete_action : String? = Binary::read(r)
  let update_action : String? = Binary::read(r)
  let initially_deferred : Bool? = Binary::read(r)
  let value : ForeignKey = {
    column,
    parent,
    target,
    cascade,
    columns,
    targets,
    delete_action,
    update_action,
    initially_deferred,
  }
  r.require_feature(1U)
  value
}

///|
impl Binary for ColumnDef with fn write(value, w) {
  Binary::write(value.name, w)
  Binary::write(value.declared, w)
  Binary::write(value.not_null, w)
  Binary::write(value.primary, w)
  Binary::write(value.primary_desc, w)
  Binary::write(value.default_value, w)
  Binary::write(value.default_source, w)
  Binary::write(value.collation, w)
}

///|
impl Binary for ColumnDef with fn read(r) {
  r.enter()
  defer r.leave()
  let name : String = Binary::read(r)
  let declared : String = Binary::read(r)
  let not_null : Bool = Binary::read(r)
  let primary : Int32 = Binary::read(r)
  let primary_desc : Bool? = Binary::read(r)
  let default_value : Expr = Binary::read(r)
  let default_source : String? = Binary::read(r)
  let collation : String = Binary::read(r)
  let value : ColumnDef = {
    name,
    declared,
    not_null,
    primary,
    primary_desc,
    default_value,
    default_source,
    collation,
  }

  value
}

///|
impl Binary for Table with fn write(value, w) {
  if value.strict == Some(true) {
    w.require_feature(4U)
  }
  Binary::write(value.name, w)
  Binary::write(value.sql, w)
  Binary::write(value.columns, w)
  Binary::write(value.unique_keys, w)
  Binary::write(value.checks, w)
  Binary::write(value.foreign_keys, w)
  Binary::write(value.without_rowid, w)
  Binary::write(value.strict, w)
  Binary::write(value.autoincrement, w)
}

///|
impl Binary for Table with fn read(r) {
  r.enter()
  defer r.leave()
  let name : String = Binary::read(r)
  let sql : String = Binary::read(r)
  let columns : Array[ColumnDef] = Binary::read(r)
  let unique_keys : Array[Array[Int32]] = Binary::read(r)
  let checks : Array[Expr] = Binary::read(r)
  let foreign_keys : Array[ForeignKey] = Binary::read(r)
  let without_rowid : Bool = Binary::read(r)
  let strict : Bool? = Binary::read(r)
  let autoincrement : Bool = Binary::read(r)
  let value : Table = {
    name,
    sql,
    columns,
    unique_keys,
    checks,
    foreign_keys,
    without_rowid,
    strict,
    autoincrement,
    sequence: 0L,
    sequence_present: None,
    rows: row_pages([]),
  }
  if value.strict == Some(true) {
    r.require_feature(4U)
  }
  value
}

///|
impl Binary for SchemaObject with fn write(value, w) {
  Binary::write(value.kind, w)
  Binary::write(value.name, w)
  Binary::write(value.table, w)
  Binary::write(value.sql, w)
  Binary::write(value.unique, w)
  Binary::write(value.columns, w)
  Binary::write(value.query, w)
  Binary::write(value.selection, w)
  Binary::write(value.index_terms, w)
  Binary::write(value.index_predicate, w)
  Binary::write(value.trigger, w)
}

///|
impl Binary for SchemaObject with fn read(r) {
  r.enter()
  defer r.leave()
  let kind : String = Binary::read(r)
  let name : String = Binary::read(r)
  let table : String = Binary::read(r)
  let sql : String = Binary::read(r)
  let unique : Bool = Binary::read(r)
  let columns : Array[String] = Binary::read(r)
  let query : String = Binary::read(r)
  let selection : Selection? = Binary::read(r)
  let index_terms : Array[Ordering]? = Binary::read(r)
  let index_predicate : Expr? = Binary::read(r)
  let trigger : TriggerDefinition? = Binary::read(r)
  let value : SchemaObject = {
    kind,
    name,
    table,
    sql,
    unique,
    columns,
    query,
    selection,
    index_terms,
    index_predicate,
    trigger,
  }

  value
}

///|
impl Binary for Store with fn write(value, w) {
  Binary::write(value.encoding, w)
  Binary::write(value.tables, w)
  Binary::write(value.objects, w)
  Binary::write(value.cookie, w)
  Binary::write(value.foreign_keys, w)
}

///|
impl Binary for Store with fn read(r) {
  r.enter()
  defer r.leave()
  let encoding : Int32? = Binary::read(r)
  let tables : Array[Table] = Binary::read(r)
  let objects : Array[SchemaObject] = Binary::read(r)
  let cookie : Int32 = Binary::read(r)
  let foreign_keys : Bool = Binary::read(r)
  let value : Store = {
    encoding,
    tables,
    objects,
    cookie,
    foreign_keys,
    changes: 0,
    last_rowid: 0L,
    deferred: false,
    indexes: Map([]),
    primary_indexes: Map([]),
    declaration_sources: Map([]),
    dirty: dirty_state(),
    transactions: transaction_runtime(),
    triggers: trigger_runtime(),
  }

  value
}

///|
impl Binary for Insertion with fn write(value, w) {
  Binary::write(value.table, w)
  Binary::write(value.columns, w)
  Binary::write(value.values, w)
  Binary::write(value.conflict, w)
  Binary::write(value.target, w)
  Binary::write(value.updates, w)
  Binary::write(value.predicate, w)
  Binary::write(value.returning, w)
  Binary::write(value.conflict_override, w)
  Binary::write(value.target_predicate, w)
  Binary::write(value.selection, w)
}

///|
impl Binary for Insertion with fn read(r) {
  r.enter()
  defer r.leave()
  let table : String = Binary::read(r)
  let columns : Array[String] = Binary::read(r)
  let values : Array[Array[Expr]] = Binary::read(r)
  let conflict : String = Binary::read(r)
  let target : Array[String] = Binary::read(r)
  let updates : Array[(String, Expr)] = Binary::read(r)
  let predicate : Expr = Binary::read(r)
  let returning : Array[Projection] = Binary::read(r)
  let conflict_override : String? = Binary::read(r)
  let target_predicate : Expr? = Binary::read(r)
  let selection : Selection? = Binary::read(r)
  let value : Insertion = {
    table,
    columns,
    values,
    conflict,
    target,
    updates,
    predicate,
    returning,
    conflict_override,
    target_predicate,
    selection,
  }

  value
}

///|
impl Binary for TriggerDefinition with fn write(value, w) {
  w.require_feature(2U)
  Binary::write(value.timing, w)
  Binary::write(value.event, w)
  Binary::write(value.columns, w)
  Binary::write(value.condition, w)
  Binary::write(value.body, w)
}

///|
impl Binary for TriggerDefinition with fn read(r) {
  r.enter()
  defer r.leave()
  let timing : String = Binary::read(r)
  let event : String = Binary::read(r)
  let columns : Array[String] = Binary::read(r)
  let condition : Expr = Binary::read(r)
  let body : Array[DataStatement] = Binary::read(r)
  let value : TriggerDefinition = { timing, event, columns, condition, body, }
  r.require_feature(2U)
  value
}

///|
impl Binary for WindowFrame with fn write(value, w) {
  Binary::write(value.kind, w)
  Binary::write(value.start, w)
  Binary::write(value.end, w)
}

///|
impl Binary for WindowFrame with fn read(r) {
  r.enter()
  defer r.leave()
  let kind : String = Binary::read(r)
  let start : WindowBound = Binary::read(r)
  let end : WindowBound = Binary::read(r)
  let value : WindowFrame = { kind, start, end, }

  value
}

///|
impl Binary for CompiledQuery with fn write(value, w) {
  Binary::write(value.name, w)
  Binary::write(value.parameters, w)
  Binary::write(value.names, w)
  Binary::write(value.statement, w)
}

///|
impl Binary for CompiledQuery with fn read(r) {
  r.enter()
  defer r.leave()
  let name : String = Binary::read(r)
  let parameters : Int32 = Binary::read(r)
  let names : Array[String] = Binary::read(r)
  let statement : DataStatement = Binary::read(r)
  let value : CompiledQuery = { name, parameters, names, statement, }

  value
}

///|
impl Binary for StoredRow with fn write(value, w) {
  Binary::write(value.id, w)
  Binary::write(value.values, w)
}

///|
impl Binary for StoredRow with fn read(r) {
  r.enter()
  defer r.leave()
  let id : Int64 = Binary::read(r)
  let values : Array[Value] = Binary::read(r)
  let value : StoredRow = { id, values, }

  value
}

///|
impl Binary for StorageTree with fn write(value, w) {
  Binary::write(value.name, w)
  Binary::write(value.table, w)
  Binary::write(value.root, w)
  Binary::write(value.kind, w)
  Binary::write(value.fields, w)
  Binary::write(value.predicate, w)
}

///|
impl Binary for StorageTree with fn read(r) {
  r.enter()
  defer r.leave()
  let name : String = Binary::read(r)
  let table : String = Binary::read(r)
  let root : Int32 = Binary::read(r)
  let kind : String = Binary::read(r)
  let fields : Array[StorageField] = Binary::read(r)
  let predicate : Expr? = Binary::read(r)
  let value : StorageTree = { name, table, root, kind, fields, predicate, }

  value
}

///|
impl Binary for StorageField with fn write(value, w) {
  Binary::write(value.column, w)
  Binary::write(value.collation, w)
  Binary::write(value.descending, w)
  Binary::write(value.expression, w)
}

///|
impl Binary for StorageField with fn read(r) {
  r.enter()
  defer r.leave()
  let column : Int32 = Binary::read(r)
  let collation : String = Binary::read(r)
  let descending : Bool = Binary::read(r)
  let expression : Expr? = Binary::read(r)
  let value : StorageField = { column, collation, descending, expression, }

  value
}

///|
impl Binary for Expr with fn write(value, w) {
  match value {
    Literal(v0) => {
      w.uint(0U)

      Binary::write(v0, w)
    }
    TruthLiteral(v0) => {
      w.uint(1U)

      Binary::write(v0, w)
    }
    CurrentTime(v0) => {
      w.uint(2U)
      w.require_feature(32U)
      Binary::write(v0, w)
    }
    Parameter(v0) => {
      w.uint(3U)

      Binary::write(v0, w)
    }
    Column(v0, v1) => {
      w.uint(4U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    Star(v0) => {
      w.uint(5U)

      Binary::write(v0, w)
    }
    Unary(v0, v1) => {
      w.uint(6U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    Binary(v0, v1, v2) => {
      w.uint(7U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
    }
    Call(v0, v1) => {
      w.uint(8U)
      w.require_feature(function_features(v0))
      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    Collate(v0, v1) => {
      w.uint(9U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    Cast(v0, v1) => {
      w.uint(10U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    RowNumber(v0) => {
      w.uint(11U)
      w.require_feature(64U)
      Binary::write(v0, w)
    }
    Window(v0, v1, v2, v3, v4) => {
      w.uint(12U)
      w.require_feature(64U)
      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
      Binary::write(v3, w)
      Binary::write(v4, w)
    }
    Between(v0, v1, v2) => {
      w.uint(13U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
    }
    Case(v0, v1, v2) => {
      w.uint(14U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
    }
    InSelect(v0, v1) => {
      w.uint(15U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    ScalarSelect(v0) => {
      w.uint(16U)

      Binary::write(v0, w)
    }
    Exists(v0) => {
      w.uint(17U)

      Binary::write(v0, w)
    }
  }
}

///|
impl Binary for Expr with fn read(r) {
  r.enter()
  defer r.leave()
  match r.uint() {
    0U => {
      let v0 : Value = Binary::read(r)

      Literal(v0)
    }
    1U => {
      let v0 : Bool = Binary::read(r)

      TruthLiteral(v0)
    }
    2U => {
      let v0 : String = Binary::read(r)
      r.require_feature(32U)
      CurrentTime(v0)
    }
    3U => {
      let v0 : Int32 = Binary::read(r)

      Parameter(v0)
    }
    4U => {
      let v0 : String = Binary::read(r)
      let v1 : String = Binary::read(r)

      Column(v0, v1)
    }
    5U => {
      let v0 : String = Binary::read(r)

      Star(v0)
    }
    6U => {
      let v0 : String = Binary::read(r)
      let v1 : Expr = Binary::read(r)

      Unary(v0, v1)
    }
    7U => {
      let v0 : String = Binary::read(r)
      let v1 : Expr = Binary::read(r)
      let v2 : Expr = Binary::read(r)

      Binary(v0, v1, v2)
    }
    8U => {
      let v0 : String = Binary::read(r)
      let v1 : Array[Expr] = Binary::read(r)
      r.require_feature(function_features(v0))
      Call(v0, v1)
    }
    9U => {
      let v0 : Expr = Binary::read(r)
      let v1 : String = Binary::read(r)

      Collate(v0, v1)
    }
    10U => {
      let v0 : Expr = Binary::read(r)
      let v1 : String = Binary::read(r)

      Cast(v0, v1)
    }
    11U => {
      let v0 : Array[Ordering] = Binary::read(r)
      r.require_feature(64U)
      RowNumber(v0)
    }
    12U => {
      let v0 : String = Binary::read(r)
      let v1 : Array[Expr] = Binary::read(r)
      let v2 : Array[Expr] = Binary::read(r)
      let v3 : Array[Ordering] = Binary::read(r)
      let v4 : WindowFrame = Binary::read(r)
      r.require_feature(64U)
      Window(v0, v1, v2, v3, v4)
    }
    13U => {
      let v0 : Expr = Binary::read(r)
      let v1 : Expr = Binary::read(r)
      let v2 : Expr = Binary::read(r)

      Between(v0, v1, v2)
    }
    14U => {
      let v0 : Expr? = Binary::read(r)
      let v1 : Array[(Expr, Expr)] = Binary::read(r)
      let v2 : Expr = Binary::read(r)

      Case(v0, v1, v2)
    }
    15U => {
      let v0 : Expr = Binary::read(r)
      let v1 : Selection = Binary::read(r)

      InSelect(v0, v1)
    }
    16U => {
      let v0 : Selection = Binary::read(r)

      ScalarSelect(v0)
    }
    17U => {
      let v0 : Selection = Binary::read(r)

      Exists(v0)
    }
    _ => fail("unknown binary Expr tag")
  }
}

///|
impl Binary for DataStatement with fn write(value, w) {
  match value {
    PreparedTransaction(v0, v1) => {
      w.uint(0U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    PreparedSelect(v0) => {
      w.uint(1U)

      Binary::write(v0, w)
    }
    PreparedPragma(v0, v1) => {
      w.uint(2U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    PreparedInsert(v0) => {
      w.uint(3U)

      Binary::write(v0, w)
    }
    PreparedUpdate(v0, v1, v2, v3) => {
      w.uint(4U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
      Binary::write(v3, w)
    }
    PreparedDelete(v0, v1, v2) => {
      w.uint(5U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
    }
  }
}

///|
impl Binary for DataStatement with fn read(r) {
  r.enter()
  defer r.leave()
  match r.uint() {
    0U => {
      let v0 : String = Binary::read(r)
      let v1 : String = Binary::read(r)

      PreparedTransaction(v0, v1)
    }
    1U => {
      let v0 : Selection = Binary::read(r)

      PreparedSelect(v0)
    }
    2U => {
      let v0 : String = Binary::read(r)
      let v1 : String = Binary::read(r)

      PreparedPragma(v0, v1)
    }
    3U => {
      let v0 : Insertion = Binary::read(r)

      PreparedInsert(v0)
    }
    4U => {
      let v0 : String = Binary::read(r)
      let v1 : Array[(String, Expr)] = Binary::read(r)
      let v2 : Expr = Binary::read(r)
      let v3 : Array[Projection] = Binary::read(r)

      PreparedUpdate(v0, v1, v2, v3)
    }
    5U => {
      let v0 : String = Binary::read(r)
      let v1 : Expr = Binary::read(r)
      let v2 : Array[Projection] = Binary::read(r)

      PreparedDelete(v0, v1, v2)
    }
    _ => fail("unknown binary DataStatement tag")
  }
}

///|
impl Binary for WindowBound with fn write(value, w) {
  match value {
    UnboundedPreceding => w.uint(0U)
    Preceding(v0) => {
      w.uint(1U)

      Binary::write(v0, w)
    }
    Current => w.uint(2U)
    Following(v0) => {
      w.uint(3U)

      Binary::write(v0, w)
    }
    UnboundedFollowing => w.uint(4U)
  }
}

///|
impl Binary for WindowBound with fn read(r) {
  r.enter()
  defer r.leave()
  match r.uint() {
    0U => UnboundedPreceding
    1U => {
      let v0 : Expr = Binary::read(r)

      Preceding(v0)
    }
    2U => Current
    3U => {
      let v0 : Expr = Binary::read(r)

      Following(v0)
    }
    4U => UnboundedFollowing
    _ => fail("unknown binary WindowBound tag")
  }
}

///|
impl Binary for RowEdit with fn write(value, w) {
  match value {
    AppendRow(v0, v1) => {
      w.uint(0U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    ReplaceRow(v0, v1, v2) => {
      w.uint(1U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
    }
    DeleteRow(v0, v1) => {
      w.uint(2U)

      Binary::write(v0, w)
      Binary::write(v1, w)
    }
    PatchRow(v0, v1, v2, v3) => {
      w.uint(3U)

      Binary::write(v0, w)
      Binary::write(v1, w)
      Binary::write(v2, w)
      Binary::write(v3, w)
    }
  }
}

///|
impl Binary for RowEdit with fn read(r) {
  r.enter()
  defer r.leave()
  match r.uint() {
    0U => {
      let v0 : String = Binary::read(r)
      let v1 : StoredRow = Binary::read(r)

      AppendRow(v0, v1)
    }
    1U => {
      let v0 : String = Binary::read(r)
      let v1 : Int64 = Binary::read(r)
      let v2 : StoredRow = Binary::read(r)

      ReplaceRow(v0, v1, v2)
    }
    2U => {
      let v0 : String = Binary::read(r)
      let v1 : Int64 = Binary::read(r)

      DeleteRow(v0, v1)
    }
    3U => {
      let v0 : String = Binary::read(r)
      let v1 : Int64 = Binary::read(r)
      let v2 : Int64 = Binary::read(r)
      let v3 : Array[(Int32, Value)] = Binary::read(r)

      PatchRow(v0, v1, v2, v3)
    }
    _ => fail("unknown binary RowEdit tag")
  }
}