Class AlgebraFactory

constructor

• new AlgebraFactory(
      dataFactory?: DataFactory<BaseQuad, BaseQuad>,
  ): AlgebraFactory

  Parameters

  • OptionaldataFactory: DataFactory<BaseQuad, BaseQuad>

  Returns AlgebraFactory

dataFactory

stringType

createAdd

• createAdd(
      source: NamedNode<string> | "DEFAULT",
      destination: NamedNode<string> | "DEFAULT",
      silent?: boolean,
  ): Algebra.Add

  Parameters

  • source: NamedNode<string> | "DEFAULT"
  • destination: NamedNode<string> | "DEFAULT"
  • Optionalsilent: boolean

  Returns Algebra.Add

createAggregateExpression

• createAggregateExpression(
      aggregator: string,
      expression: Algebra.BaseExpression,
      distinct: boolean,
      separator?: string,
  ): Algebra.AggregateExpression

  Parameters

  • aggregator: string
  • expression: Algebra.BaseExpression
  • distinct: boolean
  • Optionalseparator: string

  Returns Algebra.AggregateExpression

createAlt

• createAlt(input: Algebra.BaseOperation[], flatten?: boolean): Algebra.Alt

  Parameters

  • input: Algebra.BaseOperation[]
  • flatten: boolean = true

  Returns Algebra.Alt

createAsk

• createAsk(input: Algebra.BaseOperation): Algebra.Ask

  Parameters

  • input: Algebra.BaseOperation

  Returns Algebra.Ask

createBgp

• createBgp(patterns: Algebra.Pattern[]): Algebra.Bgp

  Parameters

  • patterns: Algebra.Pattern[]

  Returns Algebra.Bgp

createBoundAggregate

• createBoundAggregate(
      variable: Variable,
      aggregate: string,
      expression: Algebra.BaseExpression,
      distinct: boolean,
      separator?: string,
  ): Algebra.BoundAggregate

  Parameters

  • variable: Variable
  • aggregate: string
  • expression: Algebra.BaseExpression
  • distinct: boolean
  • Optionalseparator: string

  Returns Algebra.BoundAggregate

createBoundNamedAggregate

• createBoundNamedAggregate(
      variable: Variable,
      name: NamedNode,
      args: Algebra.BaseExpression[],
      distinct: boolean,
  ): Algebra.BoundNamedAggregate

  Creates a call of a custom aggregate, bound to the given variable, see the namedAggregatorCallback option of toAlgebra.

  Parameters

  • variable: Variable
  • name: NamedNode
  • args: Algebra.BaseExpression[]
  • distinct: boolean

  Returns Algebra.BoundNamedAggregate

createClear

• createClear(
      source: NamedNode<string> | "DEFAULT" | "NAMED" | "ALL",
      silent?: boolean,
  ): Algebra.Clear

  Parameters

  • source: NamedNode<string> | "DEFAULT" | "NAMED" | "ALL"
  • Optionalsilent: boolean

  Returns Algebra.Clear

createCompositeUpdate

• createCompositeUpdate(updates: Algebra.BaseOperation[]): Algebra.CompositeUpdate

  Parameters

  • updates: Algebra.BaseOperation[]

  Returns Algebra.CompositeUpdate

createConstruct

• createConstruct(
      input: Algebra.BaseOperation,
      template: Algebra.Pattern[],
  ): Algebra.Construct

  Parameters

  • input: Algebra.BaseOperation
  • template: Algebra.Pattern[]

  Returns Algebra.Construct

createCopy

• createCopy(
      source: NamedNode<string> | "DEFAULT",
      destination: NamedNode<string> | "DEFAULT",
      silent?: boolean,
  ): Algebra.Copy

  Parameters

  • source: NamedNode<string> | "DEFAULT"
  • destination: NamedNode<string> | "DEFAULT"
  • Optionalsilent: boolean

  Returns Algebra.Copy

createCreate

• createCreate(source: NamedNode, silent?: boolean): Algebra.Create

  Parameters

  • source: NamedNode
  • Optionalsilent: boolean

  Returns Algebra.Create

createDeleteInsert

• createDeleteInsert(
      deleteQuads?: Algebra.Pattern[],
      insertQuads?: Algebra.Pattern[],
      where?: Algebra.BaseOperation,
  ): Algebra.DeleteInsert

  Parameters

  • OptionaldeleteQuads: Algebra.Pattern[]
  • OptionalinsertQuads: Algebra.Pattern[]
  • Optionalwhere: Algebra.BaseOperation

  Returns Algebra.DeleteInsert

createDescribe

• createDescribe(
      input: Algebra.BaseOperation,
      terms: (Variable | NamedNode<string>)[],
  ): Algebra.Describe

  Parameters

  • input: Algebra.BaseOperation
  • terms: (Variable | NamedNode<string>)[]

  Returns Algebra.Describe

createDistinct

• createDistinct(input: Algebra.BaseOperation): Algebra.Distinct

  Parameters

  • input: Algebra.BaseOperation

  Returns Algebra.Distinct

createDrop

• createDrop(
      source: NamedNode<string> | "DEFAULT" | "NAMED" | "ALL",
      silent?: boolean,
  ): Algebra.Drop

  Parameters

  • source: NamedNode<string> | "DEFAULT" | "NAMED" | "ALL"
  • Optionalsilent: boolean

  Returns Algebra.Drop

createExistenceExpression

• createExistenceExpression(
      not: boolean,
      input: Algebra.BaseOperation,
  ): Algebra.ExistenceExpression

  Parameters

  • not: boolean
  • input: Algebra.BaseOperation

  Returns Algebra.ExistenceExpression

createExtend

• createExtend(
      input: Algebra.BaseOperation,
      variable: Variable,
      expression: Algebra.BaseExpression,
  ): Algebra.Extend

  Parameters

  • input: Algebra.BaseOperation
  • variable: Variable
  • expression: Algebra.BaseExpression

  Returns Algebra.Extend

createFilter

• createFilter(
      input: Algebra.BaseOperation,
      expression: Algebra.BaseExpression,
  ): Algebra.Filter

  Parameters

  • input: Algebra.BaseOperation
  • expression: Algebra.BaseExpression

  Returns Algebra.Filter

createFrom

• createFrom(
      input: Algebra.BaseOperation,
      def: NamedNode<string>[],
      named: NamedNode<string>[],
  ): Algebra.From

  Parameters

  • input: Algebra.BaseOperation
  • def: NamedNode<string>[]
  • named: NamedNode<string>[]

  Returns Algebra.From

createGraph

• createGraph(
      input: Algebra.BaseOperation,
      name: Variable | NamedNode<string>,
  ): Algebra.Graph

  Parameters

  • input: Algebra.BaseOperation
  • name: Variable | NamedNode<string>

  Returns Algebra.Graph

createGroup

• createGroup(
      input: Algebra.BaseOperation,
      variables: Variable[],
      aggregates: Algebra.BaseOperation[],
  ): Algebra.Group

  Parameters

  • input: Algebra.BaseOperation
  • variables: Variable[]
  • aggregates: Algebra.BaseOperation[]

  Returns Algebra.Group

createInv

• createInv(path: Algebra.BaseOperation): Algebra.Inv

  Parameters

  • path: Algebra.BaseOperation

  Returns Algebra.Inv

createJoin

• createJoin(input: Algebra.BaseOperation[], flatten?: boolean): Algebra.Join

  Parameters

  • input: Algebra.BaseOperation[]
  • flatten: boolean = true

  Returns Algebra.Join

createLeftJoin

• createLeftJoin(
      left: Algebra.BaseOperation,
      right: Algebra.BaseOperation,
      expression?: Algebra.BaseExpression,
  ): Algebra.LeftJoin

  Parameters

  • left: Algebra.BaseOperation
  • right: Algebra.BaseOperation
  • Optionalexpression: Algebra.BaseExpression

  Returns Algebra.LeftJoin

createLink

• createLink(iri: NamedNode): Algebra.Link

  Parameters

  • iri: NamedNode

  Returns Algebra.Link

createLoad

• createLoad(
      source: NamedNode,
      destination?: NamedNode<string>,
      silent?: boolean,
  ): Algebra.Load

  Parameters

  • source: NamedNode
  • Optionaldestination: NamedNode<string>
  • Optionalsilent: boolean

  Returns Algebra.Load

createMinus

• createMinus(
      left: Algebra.BaseOperation,
      right: Algebra.BaseOperation,
  ): Algebra.Minus

  Parameters

  • left: Algebra.BaseOperation
  • right: Algebra.BaseOperation

  Returns Algebra.Minus

createMove

• createMove(
      source: NamedNode<string> | "DEFAULT",
      destination: NamedNode<string> | "DEFAULT",
      silent?: boolean,
  ): Algebra.Move

  Parameters

  • source: NamedNode<string> | "DEFAULT"
  • destination: NamedNode<string> | "DEFAULT"
  • Optionalsilent: boolean

  Returns Algebra.Move

createNamedExpression

• createNamedExpression(
      name: NamedNode,
      args: Algebra.BaseExpression[],
  ): Algebra.NamedExpression

  Parameters

  • name: NamedNode
  • args: Algebra.BaseExpression[]

  Returns Algebra.NamedExpression

createNop

• createNop(): Algebra.Nop

  Returns Algebra.Nop

createNps

• createNps(iris: NamedNode<string>[]): Algebra.Nps

  Parameters

  • iris: NamedNode<string>[]

  Returns Algebra.Nps

createOneOrMorePath

• createOneOrMorePath(path: Algebra.BaseOperation): Algebra.OneOrMorePath

  Parameters

  • path: Algebra.BaseOperation

  Returns Algebra.OneOrMorePath

createOperatorExpression

• createOperatorExpression(
      operator: string,
      args: Algebra.BaseExpression[],
  ): Algebra.OperatorExpression

  Parameters

  • operator: string
  • args: Algebra.BaseExpression[]

  Returns Algebra.OperatorExpression

createOrderBy

• createOrderBy(
      input: Algebra.BaseOperation,
      expressions: Algebra.BaseExpression[],
  ): Algebra.OrderBy

  Parameters

  • input: Algebra.BaseOperation
  • expressions: Algebra.BaseExpression[]

  Returns Algebra.OrderBy

createPath

• createPath(
      subject: Term,
      predicate: Algebra.BaseOperation,
      object: Term,
      graph?: Term,
  ): Algebra.Path

  Parameters

  • subject: Term
  • predicate: Algebra.BaseOperation
  • object: Term
  • Optionalgraph: Term

  Returns Algebra.Path

createPattern

• createPattern(
      subject: Term,
      predicate: Term,
      object: Term,
      graph?: Term,
  ): Algebra.Pattern

  Parameters

  • subject: Term
  • predicate: Term
  • object: Term
  • Optionalgraph: Term

  Returns Algebra.Pattern

createProject

• createProject(
      input: Algebra.BaseOperation,
      variables: Variable[],
  ): Algebra.Project

  Providing no variables is interpreted as a SELECT *.

  Parameters

  • input: Algebra.BaseOperation
  • variables: Variable[]

  Returns Algebra.Project

createReduced

• createReduced(input: Algebra.BaseOperation): Algebra.Reduced

  Parameters

  • input: Algebra.BaseOperation

  Returns Algebra.Reduced

createSeq

• createSeq(input: Algebra.BaseOperation[], flatten?: boolean): Algebra.Seq

  Parameters

  • input: Algebra.BaseOperation[]
  • flatten: boolean = true

  Returns Algebra.Seq

createService

• createService(
      input: Algebra.BaseOperation,
      name: Variable | NamedNode<string>,
      silent?: boolean,
  ): Algebra.Service

  Parameters

  • input: Algebra.BaseOperation
  • name: Variable | NamedNode<string>
  • Optionalsilent: boolean

  Returns Algebra.Service

createSlice

• createSlice(
      input: Algebra.BaseOperation,
      start: number,
      length?: number,
  ): Algebra.Slice

  Parameters

  • input: Algebra.BaseOperation
  • start: number
  • Optionallength: number

  Returns Algebra.Slice

createTerm

• createTerm(str: string): Term

  Parameters

  • str: string

  Returns Term

createTermExpression

• createTermExpression(term: Term): Algebra.TermExpression

  Parameters

  • term: Term

  Returns Algebra.TermExpression

createUnion

• createUnion(input: Algebra.BaseOperation[], flatten?: boolean): Algebra.Union

  Parameters

  • input: Algebra.BaseOperation[]
  • flatten: boolean = true

  Returns Algebra.Union

createValues

• createValues(
      variables: Variable[],
      bindings: Record<string, Literal | NamedNode<string>>[],
  ): Algebra.Values

  Parameters

  • variables: Variable[]
  • bindings: Record<string, Literal | NamedNode<string>>[]

  Returns Algebra.Values

createWildcardExpression

• createWildcardExpression(): Algebra.WildcardExpression

  Returns Algebra.WildcardExpression

createZeroOrMorePath

• createZeroOrMorePath(path: Algebra.BaseOperation): Algebra.ZeroOrMorePath

  Parameters

  • path: Algebra.BaseOperation

  Returns Algebra.ZeroOrMorePath

createZeroOrOnePath

• createZeroOrOnePath(path: Algebra.BaseOperation): Algebra.ZeroOrOnePath

  Parameters

  • path: Algebra.BaseOperation

  Returns Algebra.ZeroOrOnePath

isBoundNamedAggregate

• isBoundNamedAggregate(
      op: Algebra.BaseOperation,
  ): op is Algebra.BoundNamedAggregate

  Whether the operation is a call of a custom aggregate, bound to a variable, as found in A.Group.aggregates. Since Group.aggregates is typed as A.BoundAggregate until the next major, TypeScript narrows its elements to never with this guard: type them as A.Expression first, e.g. const aggregates: Algebra.Expression[] = group.aggregates;.

  Parameters

  • op: Algebra.BaseOperation

  Returns op is Algebra.BoundNamedAggregate