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.Expression,
      distinct: boolean,
      separator?: string,
  ): Algebra.AggregateExpression

  Parameters

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

  Returns Algebra.AggregateExpression

createAlt

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

  Parameters

  • input: Algebra.PropertyPathSymbol[]
  • Optionalflatten: boolean

  Returns Algebra.Alt

createAsk

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

  Parameters

  • input: Algebra.Operation

  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.Expression,
      distinct: boolean,
      separator?: string,
  ): Algebra.BoundAggregate

  Parameters

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

  Returns Algebra.BoundAggregate

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.Update[]): Algebra.CompositeUpdate

  Parameters

  • updates: Algebra.Update[]

  Returns Algebra.CompositeUpdate

createConstruct

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

  Parameters

  • input: Algebra.Operation
  • 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.Operation,
  ): Algebra.DeleteInsert

  Parameters

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

  Returns Algebra.DeleteInsert

createDescribe

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

  Parameters

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

  Returns Algebra.Describe

createDistinct

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

  Parameters

  • input: Algebra.Operation

  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.Operation,
  ): Algebra.ExistenceExpression

  Parameters

  • not: boolean
  • input: Algebra.Operation

  Returns Algebra.ExistenceExpression

createExtend

• createExtend(
      input: Algebra.Operation,
      variable: Variable,
      expression: Algebra.Expression,
  ): Algebra.Extend

  Parameters

  • input: Algebra.Operation
  • variable: Variable
  • expression: Algebra.Expression

  Returns Algebra.Extend

createFilter

• createFilter(
      input: Algebra.Operation,
      expression: Algebra.Expression,
  ): Algebra.Filter

  Parameters

  • input: Algebra.Operation
  • expression: Algebra.Expression

  Returns Algebra.Filter

createFrom

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

  Parameters

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

  Returns Algebra.From

createGraph

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

  Parameters

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

  Returns Algebra.Graph

createGroup

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

  Parameters

  • input: Algebra.Operation
  • variables: Variable[]
  • aggregates: Algebra.BoundAggregate[]

  Returns Algebra.Group

createInv

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

  Parameters

  • path: Algebra.PropertyPathSymbol

  Returns Algebra.Inv

createJoin

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

  Parameters

  • input: Algebra.Operation[]
  • Optionalflatten: boolean

  Returns Algebra.Join

createLeftJoin

• createLeftJoin(
      left: Algebra.Operation,
      right: Algebra.Operation,
      expression?: Algebra.Expression,
  ): Algebra.LeftJoin

  Parameters

  • left: Algebra.Operation
  • right: Algebra.Operation
  • Optionalexpression: Algebra.Expression

  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.Operation, right: Algebra.Operation): Algebra.Minus

  Parameters

  • left: Algebra.Operation
  • right: Algebra.Operation

  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.Expression[],
  ): Algebra.NamedExpression

  Parameters

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

  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.PropertyPathSymbol): Algebra.OneOrMorePath

  Parameters

  • path: Algebra.PropertyPathSymbol

  Returns Algebra.OneOrMorePath

createOperatorExpression

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

  Parameters

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

  Returns Algebra.OperatorExpression

createOrderBy

• createOrderBy(
      input: Algebra.Operation,
      expressions: Algebra.Expression[],
  ): Algebra.OrderBy

  Parameters

  • input: Algebra.Operation
  • expressions: Algebra.Expression[]

  Returns Algebra.OrderBy

createPath

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

  Parameters

  • subject: Term
  • predicate: Algebra.PropertyPathSymbol
  • 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.Operation, variables: Variable[]): Algebra.Project

  Parameters

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

  Returns Algebra.Project

createReduced

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

  Parameters

  • input: Algebra.Operation

  Returns Algebra.Reduced

createSeq

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

  Parameters

  • input: Algebra.PropertyPathSymbol[]
  • Optionalflatten: boolean

  Returns Algebra.Seq

createService

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

  Parameters

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

  Returns Algebra.Service

createSlice

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

  Parameters

  • input: Algebra.Operation
  • 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.Operation[], flatten?: boolean): Algebra.Union

  Parameters

  • input: Algebra.Operation[]
  • Optionalflatten: boolean

  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.PropertyPathSymbol): Algebra.ZeroOrMorePath

  Parameters

  • path: Algebra.PropertyPathSymbol

  Returns Algebra.ZeroOrMorePath

createZeroOrOnePath

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

  Parameters

  • path: Algebra.PropertyPathSymbol

  Returns Algebra.ZeroOrOnePath