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,
  ): Add

  Parameters

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

  Returns Add

createAggregateExpression

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

  Parameters

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

  Returns AggregateExpression

createAlt

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

  Parameters

  • input: BaseOperation[]
  • Optionalflatten: boolean

  Returns Alt

createAsk

• createAsk(input: BaseOperation): Ask

  Parameters

  • input: BaseOperation

  Returns Ask

createBgp

• createBgp(patterns: Pattern[]): Bgp

  Parameters

  • patterns: Pattern[]

  Returns Bgp

createBoundAggregate

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

  Parameters

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

  Returns BoundAggregate

createClear

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

  Parameters

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

  Returns Clear

createCompositeUpdate

• createCompositeUpdate(updates: BaseOperation[]): CompositeUpdate

  Parameters

  • updates: BaseOperation[]

  Returns CompositeUpdate

createConstruct

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

  Parameters

  • input: BaseOperation
  • template: Pattern[]

  Returns Construct

createCopy

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

  Parameters

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

  Returns Copy

createCreate

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

  Parameters

  • source: NamedNode
  • Optionalsilent: boolean

  Returns Create

createDeleteInsert

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

  Parameters

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

  Returns DeleteInsert

createDescribe

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

  Parameters

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

  Returns Describe

createDistinct

• createDistinct(input: BaseOperation): Distinct

  Parameters

  • input: BaseOperation

  Returns Distinct

createDrop

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

  Parameters

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

  Returns Drop

createExistenceExpression

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

  Parameters

  • not: boolean
  • input: BaseOperation

  Returns ExistenceExpression

createExtend

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

  Parameters

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

  Returns Extend

createFilter

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

  Parameters

  • input: BaseOperation
  • expression: BaseExpression

  Returns Filter

createFrom

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

  Parameters

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

  Returns From

createGraph

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

  Parameters

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

  Returns Graph

createGroup

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

  Parameters

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

  Returns Group

createInv

• createInv(path: BaseOperation): Inv

  Parameters

  • path: BaseOperation

  Returns Inv

createJoin

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

  Parameters

  • input: BaseOperation[]
  • Optionalflatten: boolean

  Returns Join

createLeftJoin

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

  Parameters

  • left: BaseOperation
  • right: BaseOperation
  • Optionalexpression: BaseExpression

  Returns LeftJoin

createLink

• createLink(iri: NamedNode): Link

  Parameters

  • iri: NamedNode

  Returns Link

createLoad

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

  Parameters

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

  Returns Load

createMinus

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

  Parameters

  • left: BaseOperation
  • right: BaseOperation

  Returns Minus

createMove

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

  Parameters

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

  Returns Move

createNamedExpression

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

  Parameters

  • name: NamedNode
  • args: BaseExpression[]

  Returns NamedExpression

createNop

• createNop(): Nop

  Returns Nop

createNps

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

  Parameters

  • iris: NamedNode<string>[]

  Returns Nps

createOneOrMorePath

• createOneOrMorePath(path: BaseOperation): OneOrMorePath

  Parameters

  • path: BaseOperation

  Returns OneOrMorePath

createOperatorExpression

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

  Parameters

  • operator: string
  • args: BaseExpression[]

  Returns OperatorExpression

createOrderBy

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

  Parameters

  • input: BaseOperation
  • expressions: BaseExpression[]

  Returns OrderBy

createPath

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

  Parameters

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

  Returns Path

createPattern

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

  Parameters

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

  Returns Pattern

createProject

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

  Parameters

  • input: BaseOperation
  • variables: Variable[]

  Returns Project

createReduced

• createReduced(input: BaseOperation): Reduced

  Parameters

  • input: BaseOperation

  Returns Reduced

createSeq

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

  Parameters

  • input: BaseOperation[]
  • Optionalflatten: boolean

  Returns Seq

createService

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

  Parameters

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

  Returns Service

createSlice

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

  Parameters

  • input: BaseOperation
  • start: number
  • Optionallength: number

  Returns Slice

createTerm

• createTerm(str: string): Term

  Parameters

  • str: string

  Returns Term

createTermExpression

• createTermExpression(term: Term): TermExpression

  Parameters

  • term: Term

  Returns TermExpression

createUnion

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

  Parameters

  • input: BaseOperation[]
  • Optionalflatten: boolean

  Returns Union

createValues

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

  Parameters

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

  Returns Values

createWildcardExpression

• createWildcardExpression(): WildcardExpression

  Returns WildcardExpression

createZeroOrMorePath

• createZeroOrMorePath(path: BaseOperation): ZeroOrMorePath

  Parameters

  • path: BaseOperation

  Returns ZeroOrMorePath

createZeroOrOnePath

• createZeroOrOnePath(path: BaseOperation): ZeroOrOnePath

  Parameters

  • path: BaseOperation

  Returns ZeroOrOnePath