parent
3d836afa59
commit
f63891ef99
@ -0,0 +1,88 @@
|
||||
import {Model} from './Model'
|
||||
import {Collection, Maybe} from '../../util'
|
||||
import {HasSubtree} from './relation/HasSubtree'
|
||||
import {Related} from './relation/decorators'
|
||||
|
||||
/**
|
||||
* Model implementation with helpers for querying tree-structured data.
|
||||
*
|
||||
* This works by using a modified pre-order traversal to number the tree nodes
|
||||
* with a left- and right-side numbers. For example:
|
||||
*
|
||||
* ```txt
|
||||
* (1) A (14)
|
||||
* |
|
||||
* (2) B (9) (10) C (11) (12) D (14)
|
||||
* |
|
||||
* (3) E (6) (7) G (8)
|
||||
* |
|
||||
* (4) F (5)
|
||||
* ```
|
||||
*
|
||||
* These numbers are stored, by default, in `left_num` and `right_num` columns.
|
||||
* The `subtree()` method returns a `HasSubtree` relation which loads the subtree
|
||||
* of a model and recursively nests the nodes.
|
||||
*
|
||||
* You can use the `children()` helper method to get a collection of the immediate
|
||||
* children of this node, which also have the subtree set.
|
||||
*
|
||||
* To query the model without loading the entire subtree, use the `without()`
|
||||
* method on the `ModelBuilder`. For example:
|
||||
*
|
||||
* ```ts
|
||||
* MyModel.query<MyModel>().without('subtree')
|
||||
* ```
|
||||
*/
|
||||
export abstract class TreeModel<T extends TreeModel<T>> extends Model<T> {
|
||||
|
||||
/** The table column where the left tree number is stored. */
|
||||
public static readonly leftTreeField = 'left_num'
|
||||
|
||||
/** The table column where the right tree number is stored. */
|
||||
public static readonly rightTreeField = 'right_num'
|
||||
|
||||
/**
|
||||
* @override to eager-load the subtree by default
|
||||
* @protected
|
||||
*/
|
||||
protected with: (keyof T)[] = ['subtree']
|
||||
|
||||
/** Get the left tree number for this model. */
|
||||
public leftTreeNum(): Maybe<number> {
|
||||
const ctor = this.constructor as typeof TreeModel
|
||||
return this.originalSourceRow?.[ctor.leftTreeField]
|
||||
}
|
||||
|
||||
/** Get the right tree number for this model. */
|
||||
public rightTreeNum(): Maybe<number> {
|
||||
const ctor = this.constructor as typeof TreeModel
|
||||
return this.originalSourceRow?.[ctor.rightTreeField]
|
||||
}
|
||||
|
||||
/** Returns true if this node has no children. */
|
||||
public isLeaf(): boolean {
|
||||
const left = this.leftTreeNum()
|
||||
const right = this.rightTreeNum()
|
||||
return Boolean(left && right && (right - left === 1))
|
||||
}
|
||||
|
||||
/** Returns true if the given `node` exists within the subtree of this node. */
|
||||
public contains(node: this): boolean {
|
||||
const num = node.leftTreeNum()
|
||||
const left = this.leftTreeNum()
|
||||
const right = this.rightTreeNum()
|
||||
return Boolean(num && left && right && (left < num && right > num))
|
||||
}
|
||||
|
||||
/** The subtree nodes of this model, recursively nested. */
|
||||
@Related()
|
||||
public subtree(): HasSubtree<T> {
|
||||
const ctor = this.constructor as typeof TreeModel
|
||||
return this.make<HasSubtree<T>>(HasSubtree, this, ctor.leftTreeField)
|
||||
}
|
||||
|
||||
/** Get the immediate children of this model. */
|
||||
public children(): Collection<T> {
|
||||
return this.subtree().getValue()
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,147 @@
|
||||
import {TreeModel} from '../TreeModel'
|
||||
import {Relation, RelationNotLoadedError} from './Relation'
|
||||
import {collect, Collection, Maybe} from '../../../util'
|
||||
import {RelationBuilder} from './RelationBuilder'
|
||||
import {raw} from '../../dialect/SQLDialect'
|
||||
import {AbstractBuilder} from '../../builder/AbstractBuilder'
|
||||
import {ModelBuilder} from '../ModelBuilder'
|
||||
|
||||
/**
|
||||
* A relation that recursively loads the subtree of a model using
|
||||
* modified preorder traversal.
|
||||
*/
|
||||
export class HasSubtree<T extends TreeModel<T>> extends Relation<T, T, Collection<T>> {
|
||||
|
||||
/**
|
||||
* When the relation is loaded, the immediate children of the node.
|
||||
* @protected
|
||||
*/
|
||||
protected instances: Maybe<Collection<T>>
|
||||
|
||||
constructor(
|
||||
protected readonly model: T,
|
||||
protected readonly leftTreeField: string,
|
||||
) {
|
||||
super(model, model)
|
||||
}
|
||||
|
||||
protected get parentValue(): any {
|
||||
return this.model.key()
|
||||
}
|
||||
|
||||
public query(): RelationBuilder<T> {
|
||||
return this.builder()
|
||||
.select(raw('*'))
|
||||
.orderByAscending(this.leftTreeField)
|
||||
}
|
||||
|
||||
public applyScope(where: AbstractBuilder<T>): void {
|
||||
const left = this.model.leftTreeNum()
|
||||
const right = this.model.rightTreeNum()
|
||||
if ( !left || !right ) {
|
||||
where.whereMatchNone()
|
||||
return
|
||||
}
|
||||
|
||||
where.where(this.leftTreeField, '>', left)
|
||||
.where(this.leftTreeField, '<', right)
|
||||
}
|
||||
|
||||
public buildEagerQuery(parentQuery: ModelBuilder<T>, result: Collection<T>): ModelBuilder<T> {
|
||||
const query = this.model.query().without('subtree')
|
||||
|
||||
if ( result.isEmpty() ) {
|
||||
return query.whereMatchNone()
|
||||
}
|
||||
|
||||
result.each(inst => {
|
||||
const left = inst.leftTreeNum()
|
||||
const right = inst.rightTreeNum()
|
||||
if ( !left || !right ) {
|
||||
return
|
||||
}
|
||||
|
||||
query.where(where => {
|
||||
where.where(this.leftTreeField, '>', left)
|
||||
.where(this.leftTreeField, '<', right)
|
||||
})
|
||||
})
|
||||
|
||||
return query
|
||||
}
|
||||
|
||||
public matchResults(possiblyRelated: Collection<T>): Collection<T> {
|
||||
const modelLeft = this.model.leftTreeNum()
|
||||
const modelRight = this.model.rightTreeNum()
|
||||
if ( !modelLeft || !modelRight ) {
|
||||
return collect()
|
||||
}
|
||||
|
||||
return possiblyRelated.filter(inst => {
|
||||
const instLeft = inst.leftTreeNum()
|
||||
return Boolean(instLeft && instLeft > modelLeft && instLeft < modelRight)
|
||||
})
|
||||
}
|
||||
|
||||
public setValue(related: Collection<T>): void {
|
||||
// `related` contains a flat collection of the subtree nodes, ordered by left key ascending
|
||||
// We will loop through the related nodes and recursively call `setValue` for our immediate
|
||||
// children to build the tree.
|
||||
|
||||
type ReduceState = {
|
||||
currentChild: T,
|
||||
currentSubtree: Collection<T>,
|
||||
}
|
||||
|
||||
const children = this.instances = collect()
|
||||
const firstChild = related.pop()
|
||||
if ( !firstChild ) {
|
||||
return
|
||||
}
|
||||
|
||||
const finalState = related.reduce<ReduceState>((state: ReduceState, node: T) => {
|
||||
if ( state.currentChild.contains(node) ) {
|
||||
// `node` belongs in the subtree of `currentChild`, not this node
|
||||
state.currentSubtree.push(node)
|
||||
return state
|
||||
}
|
||||
|
||||
// We've hit the end of the subtree for `currentChild`, so set the child's
|
||||
// subtree relation value and move on to the next child.
|
||||
state.currentChild.subtree().setValue(state.currentSubtree)
|
||||
children.push(state.currentChild)
|
||||
|
||||
return {
|
||||
currentChild: node,
|
||||
currentSubtree: collect(),
|
||||
}
|
||||
}, {
|
||||
currentChild: firstChild,
|
||||
currentSubtree: collect(),
|
||||
})
|
||||
|
||||
// Do this one last time, since the reducer isn't called for the last node in the collection
|
||||
if ( finalState ) {
|
||||
finalState.currentChild.subtree().setValue(finalState.currentSubtree)
|
||||
children.push(finalState.currentChild)
|
||||
}
|
||||
|
||||
this.instances = children.sortBy(inst => inst.getOriginalValues()?.[this.leftTreeField])
|
||||
}
|
||||
|
||||
public getValue(): Collection<T> {
|
||||
if ( !this.instances ) {
|
||||
throw new RelationNotLoadedError()
|
||||
}
|
||||
|
||||
return this.instances
|
||||
}
|
||||
|
||||
public isLoaded(): boolean {
|
||||
return Boolean(this.instances)
|
||||
}
|
||||
|
||||
public get(): Promise<Collection<T>> {
|
||||
return this.fetch().collect()
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue