Database.HSparql.QueryGenerator

The query generator DSL for SPARQL, used when connecting to remote endpoints.

Creating Queries

createQuery :: Query [Variable] -> String

Execute a Query action, returning the String representation of the query.

Query Actions

prefix :: IRIRef -> Query Prefix

Add a prefix to the query, given an IRI reference, and return it.

var :: Query Variable

Create and return a variable to the query, usable in later expressions.

triple :: (TermLike a, TermLike b, TermLike c) => a -> b -> c -> Query Pattern

Restrict the query to only results for which values match constants in this triple, or for which the variables can be bound.

optional :: Query a -> Query Pattern

Add optional constraints on matches. Variable bindings within the optional action are lost, so variables must always be defined prior to opening the optional block.

union :: Query a -> Query b -> Query Pattern

Add a union structure to the query pattern. As with optional blocks, variables must be defined prior to the opening of any block.

filterExpr :: TermLike a => a -> Query Pattern

Restrict results to only those for which the given expression is true.

Duplicate handling

distinct :: Query Duplicates

Set duplicate handling to Distinct. By default, there are no reductions.

reduced :: Query Duplicates

Set duplicate handling to Reduced. By default, there are no reductions.

Order handling

orderNext :: TermLike a => a -> Query ()

Alias of orderNextAsc.

orderNextAsc :: TermLike a => a -> Query ()

Order the results, after any previous ordering, based on the term, in ascending order.

orderNextDesc :: TermLike a => a -> Query ()

Order the results, after any previous ordering, based on the term, in descending order.

Auxiliary

(.:.) :: Prefix -> String -> IRIRef

Form a PrefixedName IRIRef, with the Prefix and reference name.

iriRef :: String -> IRIRef

Create an IRIRef with an absolute reference to the address at which it is located.

Term Manipulation

Operations

(.+.) :: (TermLike a, TermLike b) => a -> b -> Expr

Add two terms.

(.-.) :: (TermLike a, TermLike b) => a -> b -> Expr

Find the difference between two terms.

(.*.) :: (TermLike a, TermLike b) => a -> b -> Expr

Multiply two terms.

(./.) :: (TermLike a, TermLike b) => a -> b -> Expr

Divide two terms.

Relations

(.==.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their equivalence.

(.!=.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their equivalence.

(.<.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their relative value.

(.>.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their relative value.

(.<=.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their relative value.

(.>=.) :: (TermLike a, TermLike b) => a -> b -> Expr

Create an expression which tests the relationship of the two operands, evaluating their relative value.

Negation

notExpr :: TermLike a => a -> Expr

Negate any term-like expression, for use, e.g., in filtering.

Builtin Functions

str :: BuiltinFunc1

lang :: BuiltinFunc1

langMatches :: BuiltinFunc2

datatype :: BuiltinFunc1

bound :: Variable -> Expr

sameTerm :: BuiltinFunc2

isIRI :: BuiltinFunc1

isURI :: BuiltinFunc1

isBlank :: BuiltinFunc1

isLiteral :: BuiltinFunc1

regex :: BuiltinFunc2

Printing Queries

qshow :: QueryShow a => a -> String

Convert most query-related types to a String, most importantly QueryDatas.

Types

type Query a = State QueryData a

The State monad applied to QueryData.

data Variable

Instances

QueryShow Variable

TermLike Variable