name: entitynode
data:
    a: {i8: 1, i16: 1, i16refs: [1], pi8: 1}
    b: {i8: 2, i16: 2}
    c: {i8: 2, i16: 1}
    d: {i8: 4, i16: 4, i16refs: [1, 2], pi8: 4}
    na: {value: a}
    nb: {value: b, left: na}
    nc: {value: c, right: nb}
attributes:
    a: {i16: 1, i16ref: [1], i8: 1, pi8: 1}
    b: {i16: 2, i8: 2}
    c: {i16: 1, i8: 2}
    na: {value: a}
    nb: {left: na, value: b}
    nc: {right: nb, value: c}
rules:
    - entityHasI16Eq($node, $entity, $i16):
        - $node[value] = $entity
        - $entity[i16] = $i16
    - nodeWithValuei16NotEq($node, $i16):
        not-join:
            - entityHasI16Eq($node, $entity, $i16)
    - joinParentLeft($parent, $child):
        - $parent[left] = $child
    - joinParentRight($parent, $child):
        - $parent[right] = $child
    - leftNotExists($node):
        not-join:
            - joinParentLeft($parent, $node)
    - rightNotExists($node):
        not-join:
            - joinParentRight($parent, $node)
    - hasNoChildren($node):
        - leftNotExists($n)
        - rightNotExists($n)
    - nodeEntity($node, $entity):
        - $node[value] = $entity
    - rightLeft($root, $right, $right-left, $v):
        - $root[Type] = '*entitynodetest.node'
        - $root[right] = $right
        - $right[left] = $right-left
        - $right[Type] = '*entitynodetest.node'
        - $right-left[value] = $v
        - '$v = {i8: 1, pi8: 1, i16: 1, i16refs: [1]}'
        - noop(*entitynodetest.node)($na)
    - passThrough($a, $b, $c, $d):
        - rightLeft($a, $b, $c, $d)
queries:
    - indexes:
        0:
            - {attrs: []}
        1:
            - {attrs: [value]}
            - {attrs: [pi8]}
            - {attrs: [i8, i16]}
        2:
            - {attrs: [value], where: {Type: '*entitynodetest.node'}}
            - {attrs: [pi8], where: {Type: '*entitynodetest.entity'}}
            - {attrs: [i8, i16], where: {Type: '*entitynodetest.entity'}}
        3:
            - {attrs: [value], where: {Type: '*entitynodetest.node'}}
            - {attrs: [pi8], exists: [pi8]}
            - {attrs: [i8, i16], where: {Type: '*entitynodetest.entity'}}
        4:
            - {attrs: [Type]}
            - {attrs: [Self]}
        5:
            - {attrs: [Self]}
        6:
            - {attrs: [Self], exists: [Self]}
        7:
            - {attrs: [], where: {Type: '*entitynodetest.node'}}
            - {attrs: [left], exists: [left]}
            - {attrs: [right], exists: [right]}
        8:
            - {attrs: []}
            - {attrs: [i16ref]}
      data: [a, b, c, d, na, nb, nc]
      queries:
        a fields:
            query:
                - $a[Type] = '*entitynodetest.entity'
                - $a[i16] = 1
                - $a[i8] = $ai8
                - $a[pi8] = $api8
            entities: [$a]
            result-vars: [$a, $ai8, $api8]
            results:
                - [a, 1, 1]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        a-c-b join:
            query:
                - $a[i8] = 1
                - $b[i16] = 2
                - $b[i8] = 2
                - $c[i16] = 1
                - $c[i8] = 2
            entities: [$a, $b, $c]
            result-vars: [$a, $b, $c]
            results:
                - [a, b, c]
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        nil values don't show up:
            query:
                - $value[pi8] = 1
            entities: [$value]
            result-vars: [$value]
            results:
                - [a]
            unsatisfiableIndexes: [2, 4, 5, 6, 7]
        nil values don't show up, scalar pointers same as pointers:
            query:
                - $value[pi8] = 1
            entities: [$value]
            result-vars: [$value]
            results:
                - [a]
            unsatisfiableIndexes: [2, 4, 5, 6, 7]
        list all the values:
            query:
                - $value[i8] = $i8
            entities: [$value]
            result-vars: [$value, $i8]
            results:
                - [a, 1]
                - [b, 2]
                - [c, 2]
                - [d, 4]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        list all the entities:
            query:
                - $entity[Type] = '*entitynodetest.entity'
            entities: [$entity]
            result-vars: [$entity]
            results:
                - [a]
                - [b]
                - [c]
                - [d]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        list all the values with type constraint:
            query:
                - $value[i8] = $i8
                - $value[Type] = '*entitynodetest.entity'
            entities: [$value]
            result-vars: [$value, $i8]
            results:
                - [a, 1]
                - [b, 2]
                - [c, 2]
                - [d, 4]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        nodes with elements where i8=2:
            query:
                - $i8 = 2
                - $value[i8] = $i8
                - $n[value] = $value
            entities: [$value, $n]
            result-vars: [$n, $value]
            results:
                - [nb, b]
                - [nc, c]
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        nodes with elements where i8=2 (rule):
            query:
                - $i8 = 2
                - $value[i8] = $i8
                - nodeEntity($n, $value)
            entities: [$value, $n]
            result-vars: [$n, $value]
            results:
                - [nb, b]
                - [nc, c]
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        list all the i8 values:
            query:
                - $value[i8] = $i8
                - $value[Type] = '*entitynodetest.entity'
            entities: [$value]
            result-vars: [$i8]
            results:
                - [1]
                - [2]
                - [2]
                - [4]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        use a filter:
            query:
                - $value[Self] = $_
                - i8eq1(*entitynodetest.entity)($value)
            entities: [$value]
            result-vars: [$value]
            results:
                - [a]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        types of all the entities:
            query:
                - $value[Type] = $typ
            entities: [$value]
            result-vars: [$value, $typ]
            results:
                - [a, '*entitynodetest.entity']
                - [b, '*entitynodetest.entity']
                - [c, '*entitynodetest.entity']
                - [d, '*entitynodetest.entity']
                - [na, '*entitynodetest.node']
                - [nb, '*entitynodetest.node']
                - [nc, '*entitynodetest.node']
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        nodes by type:
            query:
                - $na[Type] = '*entitynodetest.node'
                - $na[value] = $a
                - $nb[left] = $na
                - $nc[right] = $nb
            entities: [$na, $nb, $nc]
            result-vars: [$na, $nb, $nc, $a]
            results:
                - [na, nb, nc, a]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6]
        nodes with rule:
            query:
                - passThrough($nc, $nb, $na, $a)
            entities: [$nc, $nb, $na]
            result-vars: [$nc, $nb, $na, $a]
            results:
                - [nc, nb, na, a]
            unsatisfiableIndexes: [1, 2, 3, 5, 6]
        list nodes:
            query:
                - $n[Type] = '*entitynodetest.node'
            entities: [$n]
            result-vars: [$n]
            results:
                - [na]
                - [nb]
                - [nc]
            unsatisfiableIndexes: [1, 2, 3, 5, 6]
        basic any:
            query:
                - $entity[Type] IN ['*entitynodetest.node', '*entitynodetest.entity']
            entities: [$entity]
            result-vars: [$entity]
            results:
                - [a]
                - [b]
                - [c]
                - [d]
                - [na]
                - [nb]
                - [nc]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        self eq value:
            query:
                - '$entity[Self] = {i8: 2, pi8: null, i16: 1, i16refs: []}'
            entities: [$entity]
            result-vars: [$entity]
            results:
                - [c]
        contradiction due to missing attribute:
            query:
                - '$entity[Self] = {i8: 2, pi8: null, i16: 1, i16refs: []}'
                - $entity[pi8] = $pi8
            entities: [$entity]
            result-vars: [$entity, $pi8]
            results: []
        self eq self:
            query:
                - $entity[Self] = $entity
            entities: [$entity]
            result-vars: [$entity]
            results:
                - [a]
                - [b]
                - [c]
                - [d]
                - [na]
                - [nb]
                - [nc]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        variable type mismatch:
            query:
                - $entity[pi8] = 0
            error: 'failed to construct query: failed to process invalid clause \$entity\[pi8\] = 0: int64 is not int8'
        entity bound via variable:
            query:
                - $n1[value] = $e1
                - $e1[pi8] = 1
                - $n2[value] = $e2
                - $e1[i16] = $i16
                - $e2[i16] = $i16
            entities: [$n1, $e1, $n2, $e2]
            result-vars: [$n1, $e1, $n2, $e2]
            results:
                - [na, a, na, a]
                - [na, a, nc, c]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        entity bound via variable with ne filter:
            query:
                - $n1[value] = $e1
                - $e1[pi8] = 1
                - $n2[value] = $e2
                - $e1[i16] = $i16
                - $e2[i16] = $i16
                - neq(interface {}, interface {})($e1, $e2)
            entities: [$n1, $e1, $n2, $e2]
            result-vars: [$n1, $e1, $n2, $e2]
            results:
                - [na, a, nc, c]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        any value type mismatch:
            query:
                - $value[i8] IN [1, 2, 1]
            error: 'failed to process invalid clause \$value\[i8\] IN \[1, 2, 1\]: int16 is not int8'
        any clause no match on variable eq with type mismatch:
            query:
                - $e[i8] = $i8
                - $i8 IN [1, 2]
            entities: [$e]
            result-vars: [$e, $i8]
            results: []
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        pointer scalar values any:
            query:
                - $e[i8] IN [1, 2]
            entities: [$e]
            result-vars: [$e]
            results:
                - [a]
                - [b]
                - [c]
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        pointer scalar values:
            query:
                - $e[i8] = 1
            entities: [$e]
            result-vars: [$e]
            results:
                - [a]
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        nil pointer scalar values any:
            query:
                - $e[i8] IN [1, 1, null]
            error: 'failed to process invalid clause \$e\[i8\] IN \[1, 1, null\]: invalid nil \*int8'
        nil pointer scalar:
            query:
                - $e[i8] = null
            error: 'failed to process invalid clause \$e\[i8\] = null: invalid nil \*int8'
        no match in any expr:
            query:
                - $e[i8] IN [42, 43]
            entities: [$e]
            result-vars: [$e]
            results: []
            unsatisfiableIndexes: [2, 3, 4, 5, 6, 7]
        any clause no match on variable eq:
            query:
                - $e[i8] = $i8
                - $i8 IN [33, 42]
            entities: [$e]
            result-vars: [$e, $i8]
            results: []
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        using blank, bind all:
            query:
                - $e[i8] = $_
            entities: [$e]
            result-vars: [$e]
            results:
                - [a]
                - [b]
                - [c]
                - [d]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        using blank, bind non-nil pointer:
            query:
                - $e[pi8] = $_
            entities: [$e]
            result-vars: [$e]
            results:
                - [a]
                - [d]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6, 7]
        e[i8] != 1:
            query:
                - $e[Type] = '*entitynodetest.entity'
                - $e[i8] != 1
            entities: [$e]
            result-vars: [$e]
            results:
                - [b]
                - [c]
                - [d]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        e != a:
            query:
                - $e[Type] = '*entitynodetest.entity'
                - '$e != {i8: 1, pi8: 1, i16: 1, i16refs: [1]}'
            entities: [$e]
            result-vars: [$e]
            results:
                - [b]
                - [c]
                - [d]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        e[i8] = v; v != 1:
            query:
                - $e[Type] = '*entitynodetest.entity'
                - $e[i8] = $v
                - $v != 1
            entities: [$e]
            result-vars: [$e, $v]
            results:
                - [b, 2]
                - [c, 2]
                - [d, 4]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        e[i8] = v; v != 2:
            query:
                - $e[Type] = '*entitynodetest.entity'
                - $e[i8] = $v
                - $v != 2
            entities: [$e]
            result-vars: [$e, $v]
            results:
                - [a, 1]
                - [d, 4]
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        e[i8] = v; v != int16(2):
            query:
                - $e[Type] = '*entitynodetest.entity'
                - $e[i8] = $v
                - $v != 2
            entities: [$e]
            result-vars: [$e, $v]
            results: []
            unsatisfiableIndexes: [1, 2, 3, 5, 6, 7]
        node which is neither the left or right of another node (not-join):
            query:
                - $n[Type] = '*entitynodetest.node'
                - leftNotExists($n)
                - rightNotExists($n)
            entities: [$n]
            result-vars: [$n]
            results:
                - [nc]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6]
        node which is neither the left or right of another node (not-join), composed:
            query:
                - $n[Type] = '*entitynodetest.node'
                - hasNoChildren($n)
            entities: [$n]
            result-vars: [$n]
            results:
                - [nc]
            unsatisfiableIndexes: [1, 2, 3, 4, 5, 6]
        node with entity with i16 not 1:
            query:
                - $n[Type] = '*entitynodetest.node'
                - $i16 = 1
                - nodeWithValuei16NotEq($n, $i16)
            entities: [$n]
            result-vars: [$n, $i16]
            results:
                - [nb, 1]
            unsatisfiableIndexes: [1, 2, 3, 5, 6]
        node with entity with i16 not 2:
            query:
                - $n[Type] = '*entitynodetest.node'
                - $i16 = 2
                - nodeWithValuei16NotEq($n, $i16)
            entities: [$n]
            result-vars: [$n, $i16]
            results:
                - [na, 2]
                - [nc, 2]
            unsatisfiableIndexes: [1, 2, 3, 5, 6]
        containment by entity:
            query:
                - $n[Type] = '*entitynodetest.node'
                - $n[value] = $entity
                - $entity[i16ref] CONTAINS $otheri16
                - $otherEntity[i16] = $otheri16
            entities: [$n, $entity, $otherEntity]
            result-vars: [$n, $entity, $otheri16, $otherEntity]
            results:
                - [na, a, 1, c]
                - [na, a, 1, a]
            unsatisfiableIndexes: [0, 1, 2, 3, 4, 5, 6, 7]
        containment by value:
            query:
                - $i16 = 1
                - $entity[i16ref] CONTAINS $i16
            entities: [$entity]
            result-vars: [$i16, $entity]
            results:
                - [1, a]
                - [1, d]
            unsatisfiableIndexes: [0, 1, 2, 3, 4, 5, 6, 7]
        containment by value with any:
            query:
                - $i16 IN [2, 3]
                - $entity[i16ref] CONTAINS $i16
            entities: [$entity]
            result-vars: [$i16, $entity]
            results:
                - [2, d]
            unsatisfiableIndexes: [0, 1, 2, 3, 4, 5, 6, 7]
        containment by value (fails):
            query:
                - $i16 = 3
                - $entity[i16ref] CONTAINS $i16
            entities: [$entity]
            result-vars: [$i16, $entity]
            results: []
            unsatisfiableIndexes: [0, 1, 2, 3, 4, 5, 6, 7]
        join with containment:
            query:
                - $inverted_source[i16ref] CONTAINS $i16
                - $referenced_entity[i16] = $i16
            entities: [$inverted_source, $referenced_entity]
            result-vars: [$inverted_source, $i16, $referenced_entity]
            results:
                - [a, 1, a]
                - [a, 1, c]
                - [d, 1, a]
                - [d, 1, c]
                - [d, 2, b]
            unsatisfiableIndexes: [0, 1, 2, 3, 4, 5, 6, 7]
comparisons: []
