Database.HSparql.QueryGenerator

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

Creating Queries

createSelectQuery :: Query SelectQuery -> String

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

createConstructQuery :: Query ConstructQuery -> String

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

createAskQuery :: Query AskQuery -> String

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

createUpdateQuery :: Query UpdateQuery -> String

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

createDescribeQuery :: Query DescribeQuery -> String

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

Query Actions

prefix :: Text -> 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.

embeddedTriple :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> EmbeddedTriple

Create an embedded triple usable in an expression. See SPARQL* at https://wiki.blazegraph.com/wiki/index.php/Reification_Done_Right or https://arxiv.org/abs/1406.3399.

triple :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike 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.

triple_ :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query ()

mkPredicateObject :: (PredicateTermLike a, ObjectTermLike b, QueryShow a, QueryShow b, Show a, Show b) => a -> b -> DynamicPredicateObject

support for blank nodes.

Define a convenient alias for mkPredicateObject. Note: a pointfree definition leads to the monomorphism restriction (&) = mkPredicateObject. An example of its use:

p & o = mkPredicateObject p o

for example

q = do
  p <- prefix "" (iriRef "http://example.com/")
  s <- var
  o1 <- var
  o2 <- var
  _ <- triple s (p .:. "p1") [(p .:. "p2") & [(p .:. "p3") & o1], (p .:. "p4") & o2]
  return SelectQuery { queryVars = [s, o1] }

>>> createSelectQuery q
"PREFIX : <http://example.com/> SELECT  ?x0 ?x1 WHERE {?x0 :p1 [:p2 [:p3 ?x1]], [:p4 ?x2] .} "

constructTriple :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query Pattern

constructTriple_ :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query ()

askTriple :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query Pattern

askTriple_ :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query ()

updateTriple :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query Pattern

updateTriple_ :: (SubjectTermLike a, PredicateTermLike b, ObjectTermLike c) => a -> b -> c -> Query ()

describeIRI :: IRIRef -> Query IRIRef

describeIRI_ :: IRIRef -> Query ()

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.

optional_ :: Query a -> Query ()

service

Arguments

:: IRIRef

SPARQL endpoint

-> Query a

SPARQL query to invoke against a remote SPARQL endpoint

-> Query Pattern

Instruct a federated query processor to invoke the portion of a SPARQL query against a remote SPARQL endpoint.

For example

createQuery $ do
  foaf <- prefix "foaf" (iriRef "http://xmlns.com/foaf/0.1/")

  person    <- var
  name      <- var

  triple_ (iriRef "http://example.org/myfoaf/I") (foaf .:. "knows") person

  _ <- service (iriRef "http://people.example.org/sparql") $ do
    triple_ person (foaf .:. "name") name

  selectVars [name]

produces the SPARQL query:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?x1 WHERE {
  <http://example.org/myfoaf/I> foaf:knows ?x0 .
  SERVICE <http://people.example.org/sparql> {
    ?x0 foaf:name ?x1 .
  }
}

service_ :: IRIRef -> Query a -> Query ()

Same as service, but without returning the query patterns.

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.

union_ :: Query a -> Query b -> Query ()

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

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

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

filterExists :: Query a -> Query Pattern

filterExists_ :: Query a -> Query ()

filterNotExists :: Query a -> Query Pattern

filterNotExists_ :: Query a -> Query ()

bind :: Expr -> Variable -> Query Pattern

Bind the result of an expression to a variable.

bind_ :: Expr -> Variable -> Query ()

subQuery :: Query SelectQuery -> Query Pattern

Perform a subquery.

subQuery_ :: Query SelectQuery -> Query ()

select :: [SelectExpr] -> Query SelectQuery

selectVars :: [Variable] -> Query SelectQuery

as :: Expr -> Variable -> SelectExpr

Property paths

SPARQL 1.1 property paths documentation: https://www.w3.org/TR/sparql11-query/#propertypaths

a :: PathLengthOne

Variable "a" representing the rdf:type property.

Binary operators

Property path binary operators

(.//.) :: (PropertyPathExprLike a, PropertyPathExprLike b) => a -> b -> PropertyPathExpr infixl 5

Creating a property path sequence.

>>> IRIRef "rdf:type" ./. IRIRef "rdfs:subClassOf" ./. IRIRef "rdfs:subClassOf"
rdf:type/rdfs:subClassOf/rdfs:subClassOf

(.|.) :: (PropertyPathExprLike a, PropertyPathExprLike b) => a -> b -> PropertyPathExpr infixl 4

Creating an alternative property path.

>>> IRIRef "rdfs:label" .|. IRIRef "foaf:name" .|. IRIRef "foaf:givenName
rdfs:label|foaf:name|foaf:givenName

Negative property set binary operators

(..|..) :: (NegativePropertySetLike a, NegativePropertySetLike b) => a -> b -> NegativePropertySet infixl 4

Creating an alternative property path inside a negative property set.

>>> neg $ IRIRef "rdfs:label" ..|.. IRIRef "foaf:name" ..|.. IRIRef "foaf:givenName"
!(rdfs:label|foaf:name|foaf:givenName)

Unary operators

Property path unary operators

inv :: PropertyPathExprLike a => a -> PropertyPathExpr

Creating an inverse property path.

>>> inv (IRIRef "foaf:mbox")
^foaf:mbox

(*.) :: PropertyPathExprLike a => a -> PropertyPathExpr

Creating a zero or more path.

>>> IRIRef "rdf:type" ./. ((IRIRef "rdfs:subClassOf") *.)
rdf:type/rdfs:subClassOf*

(+.) :: PropertyPathExprLike a => a -> PropertyPathExpr

Creating a one or more path.

>>> ((IRIRef "foaf:knows") +.) ./. IRIRef "foaf:name"
foaf:knows+/foaf:name

(?.) :: PropertyPathExprLike a => a -> PropertyPathExpr

Creating a zero or one path.

>>> rdfType ./. (rdfsSubClassOf ?.)
rdf:type/rdfs:subClassOf?

Negative property set unary operators

neg :: NegativePropertySet -> PropertyPathExpr

Creating a negative property set.

>>> inv foafMbox
^foaf:mbox

inv' :: NegativePropertySetLike a => a -> NegativePropertySet

Creating an inverse path of length one inside a negative property set.

>>> neg $ IRIRef "rdfs:label" ..|.. IRIRef "foaf:name" ..|.. (inv' $ IRIRef "foaf:givenName")
!(rdfs:label|foaf:name|^foaf:givenName)

Duplicate handling

distinct :: Query Duplicates

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

distinct_ :: Query ()

reduced :: Query Duplicates

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

reduced_ :: Query ()

Limit handling

limit :: Int -> Query Limit

Set limit handling to the given value. By default, there are no limits. Note: negative numbers cause no query results to be returned.

limit_ :: Int -> Query ()

Groups handling

groupBy :: TermLike a => a -> Query [GroupBy]

Divide the solution into one or more groups.

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

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 -> Text -> IRIRef

Form a Node, with the Prefix and reference name.

iriRef :: Text -> IRIRef

Term Manipulation

Operations

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

Add two terms.

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

Find the difference between two terms.

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

Multiply two terms.

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

Divide two terms.

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

Combine two boolean terms with AND

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

Combine two boolean terms with OR

Relations

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

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

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

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

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

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

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

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

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

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

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

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 aggregation functions

count :: BuiltinFunc1

Aggregate by count

sum_ :: BuiltinFunc1

Aggregate by sum

min_ :: BuiltinFunc1

Aggregate by minimum value

max_ :: BuiltinFunc1

Aggregate by maximum value

avg :: BuiltinFunc1

Aggregate by average

groupConcat :: TermLike a => a -> String -> Expr

Aggregate a column by string concatenation with a separator.

Builtin Functions

str :: BuiltinFunc1

Cast as a string

lang :: BuiltinFunc1

Get the language of this element

langMatches :: BuiltinFunc2

datatype :: BuiltinFunc1

bound :: Variable -> Expr

sameTerm :: BuiltinFunc2

isIRI :: BuiltinFunc1

isURI :: BuiltinFunc1

isBlank :: BuiltinFunc1

isLiteral :: BuiltinFunc1

regex :: BuiltinFunc2

regexOpts :: BuiltinFunc3

strlen :: BuiltinFunc1

strlen ( string ) - get the length of a string

substr :: BuiltinFunc1

substr ( string beginPosition stringLength ) - get a substring

ucase :: BuiltinFunc1

ucase ( string ) - convert to upper case

lcase :: BuiltinFunc1

lcase ( string ) - convert to lower case

strstarts :: BuiltinFunc2

strstarts ( string x ) - return true if x matches the beginning of string

strends :: BuiltinFunc2

strends ( string x ) - return true if x matches the end of string

contains :: BuiltinFunc2

contains ( string x ) - return true if x matches anywhere in string

strbefore :: BuiltinFunc2

strbefore ( string x ) - return the string preceding a match to x

strafter :: BuiltinFunc2

strafter ( string x ) - return the string after a match to x

abs_ :: BuiltinFunc1

abs_ ( x ) - take the absolute value of number x

round_ :: BuiltinFunc1

round ( x ) - round x to the nearest integer

ceil :: BuiltinFunc1

ceil ( number ) - round x up to the nearest integer

floor_ :: BuiltinFunc1

floor ( number ) - round x down to the nearest integer

concat_ :: BuiltinFunc2

concat_ ( x y ) - concatenate strings x and y

replace :: BuiltinFunc3

replace ( string p r ) - replace literal p with literal r in string

rand :: BuiltinFunc0

rand ( ) - produce a random number between 0 and 1

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 Prefix

Instances

Eq Prefix

Defined in Database.HSparql.QueryGenerator

Methods

(==) :: Prefix -> Prefix -> Bool

(/=) :: Prefix -> Prefix -> Bool

Show Prefix

Defined in Database.HSparql.QueryGenerator

Methods

showsPrec :: Int -> Prefix -> ShowS

show :: Prefix -> String

showList :: [Prefix] -> ShowS

data Variable

Instances

Show Variable

Defined in Database.HSparql.QueryGenerator

Methods

showsPrec :: Int -> Variable -> ShowS

show :: Variable -> String

showList :: [Variable] -> ShowS

ObjectTermLike Variable

Defined in Database.HSparql.QueryGenerator

PredicateTermLike Variable

Defined in Database.HSparql.QueryGenerator

SubjectTermLike Variable

Defined in Database.HSparql.QueryGenerator

TermLike Variable

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Variable -> VarOrTerm

expr :: Variable -> Expr

data VarOrNode

Enables programmatic construction of triples where it is not known in advance which parts of the triple will be variables and which will be Nodes.

Constructors

Var' Variable

RDFNode Node

Instances

Show VarOrNode

Defined in Database.HSparql.QueryGenerator

Methods

showsPrec :: Int -> VarOrNode -> ShowS

show :: VarOrNode -> String

showList :: [VarOrNode] -> ShowS

ObjectTermLike VarOrNode

Defined in Database.HSparql.QueryGenerator

TermLike VarOrNode

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: VarOrNode -> VarOrTerm

expr :: VarOrNode -> Expr

type BlankNodePattern = [DynamicPredicateObject]

data Pattern

Instances

Show Pattern

Defined in Database.HSparql.QueryGenerator

Methods

showsPrec :: Int -> Pattern -> ShowS

show :: Pattern -> String

showList :: [Pattern] -> ShowS

data SelectQuery

Constructors

SelectQuery

Fields

• queryExpr :: [SelectExpr]

data SelectExpr

Constructors

SelectExpr Expr Variable

SelectVar Variable

Instances

Show SelectExpr

Defined in Database.HSparql.QueryGenerator

Methods

showsPrec :: Int -> SelectExpr -> ShowS

show :: SelectExpr -> String

showList :: [SelectExpr] -> ShowS

data ConstructQuery

Constructors

ConstructQuery

Fields

• queryConstructs :: [Pattern]

data AskQuery

Constructors

AskQuery

Fields

• queryAsk :: [Pattern]

data UpdateQuery

Constructors

UpdateQuery

Fields

• queryUpdate :: [Pattern]

data DescribeQuery

Constructors

DescribeQuery

Fields

• queryDescribe :: IRIRef

Classes

class TermLike a where

Permit variables and values to seemlessly be put into argument for triple and similar functions

Minimal complete definition

varOrTerm

Methods

varOrTerm :: a -> VarOrTerm

expr :: a -> Expr

Instances

TermLike Bool

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Bool -> VarOrTerm

expr :: Bool -> Expr

TermLike Integer

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Integer -> VarOrTerm

expr :: Integer -> Expr

TermLike Text

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Text -> VarOrTerm

expr :: Text -> Expr

TermLike Node

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Node -> VarOrTerm

expr :: Node -> Expr

TermLike VarOrNode

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: VarOrNode -> VarOrTerm

expr :: VarOrNode -> Expr

TermLike BlankNodePattern

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: BlankNodePattern -> VarOrTerm

expr :: BlankNodePattern -> Expr

TermLike Variable

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: Variable -> VarOrTerm

expr :: Variable -> Expr

TermLike (Text, Text)

Defined in Database.HSparql.QueryGenerator

Methods

varOrTerm :: (Text, Text) -> VarOrTerm

expr :: (Text, Text) -> Expr

class TermLike a => SubjectTermLike a

Restriction of TermLike to the role of subject.

Instances

SubjectTermLike BlankNodePattern

Defined in Database.HSparql.QueryGenerator

SubjectTermLike Variable

Defined in Database.HSparql.QueryGenerator

class TermLike a => PredicateTermLike a

Restriction of TermLike to the role of predicate.

Instances

PredicateTermLike Variable

Defined in Database.HSparql.QueryGenerator

class TermLike a => ObjectTermLike a

Restriction of TermLike to the role of object.

Instances

ObjectTermLike Bool

Defined in Database.HSparql.QueryGenerator

ObjectTermLike Integer

Defined in Database.HSparql.QueryGenerator

ObjectTermLike Text

Defined in Database.HSparql.QueryGenerator

ObjectTermLike Node

Defined in Database.HSparql.QueryGenerator

ObjectTermLike VarOrNode

Defined in Database.HSparql.QueryGenerator

ObjectTermLike BlankNodePattern

Defined in Database.HSparql.QueryGenerator

ObjectTermLike Variable

Defined in Database.HSparql.QueryGenerator

ObjectTermLike (Text, Text)

Defined in Database.HSparql.QueryGenerator