@subsquid/openreader 1.0.1 → 2.0.0

package/src/sql/cursor.ts

@@ -0,0 +1,291 @@
+import {assertNotNull, unexpectedCase} from "@subsquid/util-internal"
+import {toSnakeCase} from "@subsquid/util-naming"
+import assert from "assert"
+import {Dialect} from "../dialect"
+import {Entity, JsonObject, Model, ObjectPropType, Prop, UnionPropType} from "../model"
+import {getEntity, getFtsQuery, getObject, getUnionProps} from "../model.tools"
+import {toColumn, toFkColumn, toTable} from "../util/util"
+import {AliasSet, escapeIdentifier, JoinSet} from "./util"
+
+
+export interface CursorCtx {
+    model: Model
+    dialect: Dialect
+    aliases: AliasSet
+    join: JoinSet
+}
+
+
+export interface Cursor {
+    output(field: string): string
+    native(field: string): string
+    ref(field: string): string
+    child(field: string): Cursor
+    prop(field: string): Prop
+}
+
+
+export class EntityCursor implements Cursor {
+    public readonly entity: Entity
+    public readonly table: string
+    public readonly tableAlias: string
+
+    constructor(
+        private ctx: CursorCtx,
+        private entityName: string,
+        joined?: {on: string, rhs: string}
+    ) {
+        this.entity = getEntity(this.ctx.model, this.entityName)
+        this.table = toTable(this.entityName)
+        if (joined) {
+            this.tableAlias = this.ctx.join.add(this.table, this._columnName(joined.on), joined.rhs)
+        } else {
+            this.tableAlias = this.ctx.aliases.add(this.table)
+        }
+    }
+
+    private ident(name: string): string {
+        return escapeIdentifier(this.ctx.dialect, name)
+    }
+
+    private column(field: string): string {
+        return this.ident(this.tableAlias) + "." + this.ident(this._columnName(field))
+    }
+
+    private _columnName(field: string): string {
+        let prop = this.prop(field)
+        if (prop.type.kind == 'fk') {
+            return toFkColumn(field)
+        } else {
+            return toColumn(field)
+        }
+    }
+
+    prop(field: string): Prop {
+        return assertNotNull(this.entity.properties[field])
+    }
+
+    output(field: string): string {
+        let col = this.column(field)
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "scalar":
+                switch(prop.type.name) {
+                    case "BigInt":
+                        return `(${col})::text`
+                    case "Bytes":
+                        return `'0x' || encode(${col}, 'hex')`
+                    case "DateTime":
+                        if (this.ctx.dialect == "cockroach") {
+                            return `experimental_strftime((${col}) at time zone 'UTC', '%Y-%m-%dT%H:%M:%S.%fZ')`
+                        } else {
+                            return `to_char((${col}) at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`
+                        }
+                    default:
+                        return col
+                }
+            case "enum":
+                return col
+            case "list": {
+                let itemType = prop.type.item.type
+                switch(itemType.kind) {
+                    case "scalar":
+                    case "enum":
+                        switch(itemType.name) {
+                            case "BigInt":
+                                return `(${col})::text[]`
+                            case "Bytes":
+                                return `array(select '0x' || encode(i, 'hex') from unnest(${col}) as i)`
+                            case "DateTime":
+                                if (this.ctx.dialect == "cockroach") {
+                                    return `array(select experimental_strftime(i at time zone 'UTC', '%Y-%m-%dT%H:%M:%S.%fZ') from unnest(${col}) as i)`
+                                } else {
+                                    return `array(select to_char(i at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') from unnest(${col}) as i)`
+                                }
+                            default:
+                                return col
+                        }
+                    default:
+                        return col
+                }
+            }
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    native(field: string): string {
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "fk":
+            case "scalar":
+            case "enum":
+                return this.column(field)
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    ref(field: string): string {
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "fk":
+            case "scalar":
+            case "enum":
+            case "union":
+            case "object":
+            case "list":
+                return this.column(field)
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    child(field: string): Cursor {
+        let prop = this.entity.properties[field]
+        switch(prop.type.kind) {
+            case "object":
+            case "union":
+                return new ObjectCursor(
+                    this.ctx,
+                    this.column(field),
+                    prop.type
+                )
+            case "fk":
+                return new EntityCursor(
+                    this.ctx,
+                    prop.type.foreignEntity,
+                    {on: 'id', rhs: this.native(field)}
+                )
+            case "lookup":
+                return new EntityCursor(
+                    this.ctx,
+                    prop.type.entity,
+                    {on: prop.type.field, rhs: this.column('id')}
+                )
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    tsv(queryName: string): string {
+        return this.ident(this.tableAlias) + "." + this.ident(toSnakeCase(queryName) + "_tsv")
+    }
+
+    doc(queryName: string): string {
+        let query = getFtsQuery(this.ctx.model, queryName)
+        let src = query.sources.find(src => src.entity == this.entityName)
+        assert(src != null)
+        return src.fields.map(f => `coalesce(${this.column(f)}, '')`).join(` || E'\\n\\n' || `)
+    }
+}
+
+
+export class ObjectCursor implements Cursor {
+    private object: JsonObject
+    public readonly isUnion: boolean
+
+    constructor(
+        private ctx: CursorCtx,
+        private prefix: string,
+        type: ObjectPropType | UnionPropType
+    ) {
+        if (type.kind == 'union') {
+            this.isUnion = true
+            this.object = getUnionProps(this.ctx.model, type.name)
+        } else {
+            this.isUnion = false
+            this.object = getObject(this.ctx.model, type.name)
+        }
+    }
+
+    private json(field: string): string {
+        return `${this.prefix}->'${field}'`
+    }
+
+    private string(field: string): string {
+        return `${this.prefix}->>'${field}'`
+    }
+
+    prop(field: string): Prop {
+        return assertNotNull(this.object.properties[field])
+    }
+
+    output(field: string): string {
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "scalar":
+                switch(prop.type.name) {
+                    case 'Int':
+                        return `(${this.json(field)})::integer`
+                    case 'Float':
+                        return `(${this.json(field)})::numeric`
+                    case 'Boolean':
+                        return `(${this.string(field)})::bool`
+                    case 'JSON':
+                        return this.json(field)
+                    default:
+                        return this.string(field)
+                }
+            case "enum":
+                return this.string(field)
+            case "list":
+                return this.json(field)
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    native(field: string): string {
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "fk":
+            case "enum":
+                return this.string(field)
+            case "scalar":
+                switch(prop.type.name) {
+                    case 'Int':
+                        return `(${this.json(field)})::integer`
+                    case 'Float':
+                        return `(${this.json(field)})::numeric`
+                    case 'Boolean':
+                        return `(${this.string(field)})::bool`
+                    case 'BigInt':
+                        return `(${this.string(field)})::numeric`
+                    case 'Bytes':
+                        return `decode(substr(${this.string(field)}, 3), 'hex')`
+                    case 'DateTime':
+                        return `(${this.string(field)})::timestamptz`
+                    default:
+                        return this.string(field)
+                }
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+
+    ref(field: string): string {
+        return this.json(field)
+    }
+
+    child(field: string): Cursor {
+        let prop = this.prop(field)
+        switch(prop.type.kind) {
+            case "object":
+            case "union":
+                return new ObjectCursor(
+                    this.ctx,
+                    this.json(field),
+                    prop.type
+                )
+            case "fk":
+                return new EntityCursor(
+                    this.ctx,
+                    prop.type.foreignEntity,
+                    {on: 'id', rhs: this.string(field)}
+                )
+            default:
+                throw unexpectedCase(prop.type.kind)
+        }
+    }
+}

package/src/sql/mapping.ts

@@ -0,0 +1,66 @@
+import {unexpectedCase} from "@subsquid/util-internal"
+import {FieldRequest} from "../ir/fields"
+
+
+export function mapRows(rows: any[][], fields: FieldRequest[]): any[] {
+    let result = new Array(rows.length)
+    for (let i = 0; i < rows.length; i++) {
+        result[i] = mapRow(rows[i], fields)
+    }
+    return result
+}
+
+
+export function mapRow(row: any[], fields: FieldRequest[], ifType?: string): any {
+    let rec: any = {}
+    for (let f of fields) {
+        if (f.ifType != ifType) continue
+        for (let alias of f.aliases) {
+            switch(f.kind) {
+                case "scalar":
+                case "enum":
+                case "list":
+                    rec[alias] = row[f.index]
+                    break
+                case "object": {
+                    let isNull = row[f.index]
+                    rec[alias] = isNull ? null : mapRow(row, f.children)
+                    break
+                }
+                case "union": {
+                    let isTypeOf = row[f.index]
+                    if (isTypeOf) {
+                        let obj = mapRow(row, f.children, isTypeOf)
+                        obj.isTypeOf = isTypeOf
+                        rec[alias] = obj
+                    } else {
+                        rec[alias] = null
+                    }
+                    break
+                }
+                case "fk":
+                case "lookup": {
+                    let id = row[f.index]
+                    if (id == null) {
+                        rec[alias] = null
+                    } else {
+                        rec[alias] = mapRow(row, f.children)
+                    }
+                    break
+                }
+                case "list-lookup": {
+                    let rows = row[f.index]
+                    if (rows == null) {
+                        rec[alias] = []
+                    } else {
+                        rec[alias] = mapRows(rows, f.children)
+                    }
+                    break
+                }
+                default:
+                    throw unexpectedCase((f as any).kind)
+            }
+        }
+    }
+    return rec
+}

package/src/sql/printer.ts

@@ -0,0 +1,328 @@
+import {unexpectedCase} from "@subsquid/util-internal"
+import assert from "assert"
+import {Dialect} from "../dialect"
+import {EntityListArguments, OrderBy, Where} from "../ir/args"
+import {FieldRequest} from "../ir/fields"
+import {Model} from "../model"
+import {Cursor, EntityCursor} from "./cursor"
+import {AliasSet, ColumnSet, escapeIdentifier, JoinSet, printClause} from "./util"
+
+
+export class EntityListQueryPrinter {
+    private aliases: AliasSet
+    private join: JoinSet
+    private root: EntityCursor
+    private columns = new ColumnSet()
+    private where: string[] = []
+    private orderBy: string[] = []
+
+    constructor(
+        private model: Model,
+        private dialect: Dialect,
+        private entityName: string,
+        private params: unknown[],
+        private args: EntityListArguments = {},
+        fields?: FieldRequest[],
+        aliases?: AliasSet
+    ) {
+        this.aliases = aliases || new AliasSet()
+        this.join = new JoinSet(this.aliases)
+        this.root = new EntityCursor(
+            {
+                model: this.model,
+                dialect: this.dialect,
+                aliases: this.aliases,
+                join: this.join
+            },
+            this.entityName
+        )
+        if (fields?.length) {
+            this.populateColumns(this.root, fields)
+        }
+        if (args.where) {
+            this.populateWhere(this.root, args.where, this.where)
+        }
+        if (args.orderBy) {
+            this.populateOrderBy(this.root, args.orderBy)
+        }
+    }
+
+    private sub(entityName: string, args?: EntityListArguments, fields?: FieldRequest[]): EntityListQueryPrinter {
+        return new EntityListQueryPrinter(this.model, this.dialect, entityName, this.params, args, fields, this.aliases)
+    }
+
+    private populateColumns(cursor: Cursor, fields: FieldRequest[]): void {
+        for (let f of fields) {
+            switch(f.kind) {
+                case "scalar":
+                case "enum":
+                case "list":
+                    f.index = this.columns.add(cursor.output(f.field))
+                    break
+                case "object":
+                    f.index = this.columns.add(cursor.ref(f.field) + " IS NULL")
+                    this.populateColumns(cursor.child(f.field), f.children)
+                    break
+                case "union": {
+                    let c = cursor.child(f.field)
+                    f.index = this.columns.add(c.output("isTypeOf"))
+                    this.populateColumns(c, f.children)
+                    break
+                }
+                case "fk":
+                case "lookup": {
+                    let c = cursor.child(f.field)
+                    f.index = this.columns.add(c.output("id"))
+                    this.populateColumns(c, f.children)
+                    break
+                }
+                case "list-lookup": {
+                    let sub = this.sub(f.type.entity, f.args, f.children).addWhereDerivedFrom(f.type.field, cursor.native("id"))
+                    let exp = `(SELECT jsonb_agg(row) FROM (${sub.printAsJsonRows()}) AS rows)`
+                    f.index = this.columns.add(exp)
+                    break
+                }
+                default:
+                    throw unexpectedCase()
+            }
+        }
+    }
+
+    private populateWhere(cursor: Cursor, where: Where, exps: string[]): void {
+        switch(where.op) {
+            case "AND":
+                for (let cond of where.args) {
+                    this.populateWhere(cursor, cond, exps)
+                }
+                break
+            case "OR": {
+                let or: string[] = []
+                for (let cond of where.args) {
+                    let exp = this.printWhere(cursor, cond)
+                    if (exp) {
+                        or.push("(" + exp + ")")
+                    }
+                }
+                if (or.length > 0) {
+                    exps.push("(" + printClause("OR", or) + ")")
+                }
+                break
+            }
+            case "REF":
+                this.populateWhere(cursor.child(where.field), where.where, exps)
+                break
+            case "in": {
+                let args = where.values.map(v => this.param(v))
+                if (args.length > 0) {
+                    exps.push(`${cursor.native(where.field)} IN (${args.join(", ")})`)
+                } else {
+                    exps.push("false")
+                }
+                break
+            }
+            case "not_in": {
+                let args = where.values.map(v => this.param(v))
+                if (args.length > 0) {
+                    exps.push(`${cursor.native(where.field)} NOT IN (${args.join(", ")})`)
+                }
+                break
+            }
+            case "isNull": {
+                let f = cursor.ref(where.field)
+                if (where.yes) {
+                    exps.push(`${f} IS NULL`)
+                } else {
+                    exps.push(`${f} IS NOT NULL`)
+                }
+                break
+            }
+            case "eq":
+                this.scalarBinaryCondition("=", cursor, where, exps)
+                break
+            case "not_eq":
+                this.scalarBinaryCondition("!=", cursor, where, exps)
+                break
+            case "gt":
+                this.scalarBinaryCondition(">", cursor, where, exps)
+                break
+            case "gte":
+                this.scalarBinaryCondition(">=", cursor, where, exps)
+                break
+            case "lt":
+                this.scalarBinaryCondition("<", cursor, where, exps)
+                break
+            case "lte":
+                this.scalarBinaryCondition("<=", cursor, where, exps)
+                break
+            case "jsonContains":
+                this.scalarBinaryCondition("@>", cursor, where, exps)
+                break
+            case "jsonHasKey":
+                this.scalarBinaryCondition("?", cursor, where, exps)
+                break
+            case "containsAll":
+                this.refBinaryCondition("@>", cursor, where, exps)
+                break
+            case "containsAny":
+                this.refBinaryCondition("&&", cursor, where, exps)
+                break
+            case "containsNone": {
+                let lhs = cursor.ref(where.field)
+                let rhs = this.param(where.value)
+                exps.push(`NOT (${lhs} && ${rhs})`)
+                break
+            }
+            case "startsWith":
+                if (this.dialect == "cockroach") {
+                    let f = cursor.native(where.field)
+                    let p = this.param(where.value) + "::text"
+                    exps.push(`${f} >= ${p}`)
+                    exps.push(`left(${f}, length(${p})) = ${p}`)
+                } else {
+                    exps.push(`starts_with(${cursor.native(where.field)}, ${this.param(where.value)})`)
+                }
+                break
+            case "not_startsWith":
+                if (this.dialect == "cockroach") {
+                    let f = cursor.native(where.field)
+                    let p = this.param(where.value) + "::text"
+                    exps.push(`(${f} < ${p} OR left(${f}, length(${p})) != ${p})`)
+                } else {
+                    exps.push(`NOT starts_with(${cursor.native(where.field)}, ${this.param(where.value)})`)
+                }
+                break
+            case "endsWith": {
+                let f = cursor.native(where.field)
+                let p = this.param(where.value) + "::text"
+                exps.push(`right(${f}, length(${p})) = ${p}`)
+                break
+            }
+            case "not_endsWith": {
+                let f = cursor.native(where.field)
+                let p = this.param(where.value) + "::text"
+                exps.push(`right(${f}, length(${p})) != ${p}`)
+                break
+            }
+            case "contains":
+                exps.push(`position(${this.param(where.value)} in ${cursor.native(where.field)}) > 0`)
+                break
+            case "not_contains":
+                exps.push(`position(${this.param(where.value)} in ${cursor.native(where.field)}) = 0`)
+                break
+            case "containsInsensitive":
+                exps.push(`position(lower(${this.param(where.value)}) in lower(${cursor.native(where.field)})) > 0`)
+                break
+            case "not_containsInsensitive":
+                exps.push(`position(lower(${this.param(where.value)}) in lower(${cursor.native(where.field)})) = 0`)
+                break
+            case "every": {
+                let rel = cursor.prop(where.field)
+                assert(rel.type.kind == "list-lookup")
+                let cond = this.sub(rel.type.entity, {where: where.where}).addWhereDerivedFrom(rel.type.field, cursor.native("id"))
+                let all = this.sub(rel.type.entity).addWhereDerivedFrom(rel.type.field, cursor.native("id"))
+                exps.push(`(SELECT count(*) ${cond.printFrom()}) = (SELECT count(*) ${all.printFrom()})`)
+                break
+            }
+            case "some":
+            case "none": {
+                let rel = cursor.prop(where.field)
+                assert(rel.type.kind == "list-lookup")
+                let sub = this.sub(rel.type.entity, {
+                    where: where.where,
+                    limit: 1
+                }).addWhereDerivedFrom(rel.type.field, cursor.native("id"))
+                if (where.op == "some") {
+                    exps.push(`(SELECT true ${sub.printFrom()})`)
+                } else {
+                    exps.push(`(SELECT count(*) FROM (SELECT true ${sub.printFrom()}) AS rows) = 0`)
+                }
+                break
+            }
+            default:
+                throw unexpectedCase((where as any).op)
+        }
+    }
+
+    private scalarBinaryCondition(sqlOp: string, cursor: Cursor, where: {field: string, value: unknown}, exps: string[]): void {
+        let f = cursor.native(where.field)
+        let p = this.param(where.value)
+        exps.push(`${f} ${sqlOp} ${p}`)
+    }
+
+    private refBinaryCondition(sqlOp: string, cursor: Cursor, where: {field: string, value: unknown}, exps: string[]): void {
+        let f = cursor.ref(where.field)
+        let p = this.param(where.value)
+        exps.push(`${f} ${sqlOp} ${p}`)
+    }
+
+    private printWhere(cursor: Cursor, where: Where): string {
+        let exps: string[] = []
+        this.populateWhere(cursor, where, exps)
+        return printClause("AND", exps)
+    }
+
+    private populateOrderBy(cursor: Cursor, orderBy: OrderBy): void {
+        for (let field in orderBy) {
+            let spec = orderBy[field]
+            if (typeof spec == "string") {
+                this.orderBy.push(`${cursor.native(field)} ${spec}`)
+            } else {
+                this.populateOrderBy(cursor.child(field), spec)
+            }
+        }
+    }
+
+    private param(value: any): string {
+        return "$" + this.params.push(value)
+    }
+
+    private ident(name: string): string {
+        return escapeIdentifier(this.dialect, name)
+    }
+
+    addWhereDerivedFrom(field: string, parentIdExp: string): this {
+        this.where.push(`${this.root.native(field)} = ${parentIdExp}`)
+        return this
+    }
+
+    printColumnList(options?: {withAliases?: boolean}): string {
+        let names = this.columns.names()
+        assert(names.length > 0)
+        if (options?.withAliases) {
+            names = names.map((name, idx) => `${name} AS _c${idx}`)
+        }
+        return names.join(', ')
+    }
+
+    printColumnListAsJsonArray(): string {
+        return `json_build_array(${this.printColumnList()})`
+    }
+
+    printFrom(): string {
+        let out = `FROM ${this.ident(this.root.table)} AS ${this.ident(this.root.tableAlias)}`
+        this.join.forEach(j => {
+            out += ` LEFT OUTER JOIN ${this.ident(j.table)} ${this.ident(j.alias)} ON ${this.ident(j.alias)}.${this.ident(j.column)} = ${j.rhs}`
+        })
+        if (this.where.length > 0) {
+            out += ` WHERE ${printClause("AND", this.where)}`
+        }
+        if (this.orderBy.length > 0) {
+            out += " ORDER BY " + this.orderBy.join(", ")
+        }
+        if (this.args.limit != null) {
+            out += ` LIMIT ${this.args.limit}`
+        }
+        if (this.args.offset) {
+            out += ` OFFSET ${this.args.offset}`
+        }
+        return out
+    }
+
+    print(): string {
+        return `SELECT ${this.printColumnList({withAliases: true})} ${this.printFrom()}`
+    }
+
+    printAsJsonRows(): string {
+        return `SELECT ${this.printColumnListAsJsonArray()} AS row ${this.printFrom()}`
+    }
+}