<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ParameterizedSparqlString (Apache Jena ARQ)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: module: org.apache.jena.arq, package: org.apache.jena.query, class: ParameterizedSparqlString">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/ParameterizedSparqlString.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="module-label-in-type">Module</span>&nbsp;<a href="../../../../module-summary.html">org.apache.jena.arq</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jena.query</a></div>
<h1 title="Class ParameterizedSparqlString" class="title">Class ParameterizedSparqlString</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.jena.query.ParameterizedSparqlString</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">ParameterizedSparqlString</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements org.apache.jena.shared.PrefixMapping</span></div>
<div class="block"><p>
 A Parameterized SPARQL String is a SPARQL query/update into which values may
 be injected.
 </p>
 <h3>Injecting Values</h3>
 <p>
 Values may be injected in several ways:
 </p>
 <ul>
 <li>By treating a variable in the SPARQL string as a parameter</li>
 <li>Using JDBC style positional parameters</li>
 <li>Appending values directly to the command text being built</li>
 </ul>
 <h4>Variable Parameters</h4>
 <p>
 Any variable in the command may have a value injected to it, injecting a
 value replaces all usages of that variable in the command i.e. substitutes
 the variable for a constant, injection is done by textual substitution.
 </p>
 <h4>Positional Parameters</h4>
 <p>
 You can use JDBC style positional parameters if you prefer, a JDBC style
 parameter is a single <code>?</code> followed by whitespace or certain punctuation
 characters (currently <code>; , .</code>). Positional parameters have a unique
 index which reflects the order in which they appear in the string. Positional
 parameters use a zero based index.
 </p>
 <h4>Buffer Usage</h4>
 <p>
 Additionally you may use this purely as a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuffer.html" title="class or interface in java.lang" class="external-link"><code>StringBuffer</code></a> replacement
 for creating queries since it provides a large variety of convenience methods
 for appending things either as-is or as nodes (which causes appropriate
 formatting to be applied).
 </p>
 <h3>Intended Usage</h3>
 <p>
 The intended usage of this is where using a <a href="QuerySolutionMap.html" title="class in org.apache.jena.query"><code>QuerySolutionMap</code></a> as
 initial bindings is either inappropriate or not possible e.g.
 </p>
 <ul>
 <li>Generating query/update strings in code without lots of error prone and
 messy string concatenation</li>
 <li>Preparing a query/update for remote execution</li>
 <li>Where you do not want to simply say some variable should have a certain
 value but rather wish to insert constants into the query/update in place of
 variables</li>
 <li>Defending against SPARQL injection when creating a query/update using
 some external input, see SPARQL Injection notes for limitations.</li>
 <li>Provide a more convenient way to prepend common prefixes to your
 query</li>
 </ul>
 <p>
 This class is useful for preparing both queries and updates hence the generic
 name as it provides programmatic ways to replace variables in the query with
 constants and to add prefix and base declarations. A <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a> or
 <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a> can be created using the <a href="#asQuery()"><code>asQuery()</code></a> and
 <a href="#asUpdate()"><code>asUpdate()</code></a> methods assuming the command an instance represents is
 actually valid as a query/update.
 </p>
 <h3>Warnings</h3>
 <ol>
 <li>Note that this class does not in any way check that your command is
 syntactically correct until such time as you try and parse it as a
 <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a> or <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a>.</li>
 <li>Also note that injection is done purely based on textual replacement, it
 does not understand or respect variable scope in any way. For example if your
 command text contains sub queries you should ensure that variables within the
 sub query which you don't want replaced have distinct names from those in the
 outer query you do want replaced (or vice versa)</li>
 </ol>
 <h3>SPARQL Injection Notes</h3>
 <p>
 While this class was in part designed to prevent SPARQL injection it is by no
 means foolproof because it works purely at the textual level. The current
 version of the code addresses some possible attack vectors that the
 developers have identified but we do not claim to be sufficiently devious to
 have thought of and prevented every possible attack vector.
 </p>
 <p>
 Therefore we <strong>strongly</strong> recommend that users concerned about
 SPARQL Injection attacks perform their own validation on provided parameters
 and test their use of this class themselves prior to its use in any security
 conscious deployment. We also recommend that users do not use easily
 guess-able variable names for their parameters as these can allow a chained
 injection attack though generally speaking the code should prevent these.
 </p></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="inherited-list">
<h2 id="nested-classes-inherited-from-class-org.apache.jena.shared.PrefixMapping">Nested classes/interfaces inherited from interface&nbsp;org.apache.jena.shared.PrefixMapping</h2>
<code>org.apache.jena.shared.PrefixMapping.Factory, org.apache.jena.shared.PrefixMapping.IllegalPrefixException, org.apache.jena.shared.PrefixMapping.JenaLockedException</code></div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.jena.shared.PrefixMapping">Fields inherited from interface&nbsp;org.apache.jena.shared.PrefixMapping</h3>
<code>Extended, Standard</code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">ParameterizedSparqlString</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string with an empty command text</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.lang.String)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.lang.String,java.lang.String)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.lang.String,java.lang.String,org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.lang.String,org.apache.jena.query.QuerySolutionMap)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.lang.String,org.apache.jena.query.QuerySolutionMap,java.lang.String)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.lang.String,org.apache.jena.query.QuerySolutionMap,java.lang.String,org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.lang.String,org.apache.jena.query.QuerySolutionMap,org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.lang.String,org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.jena.query.QuerySolutionMap)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.jena.query.QuerySolutionMap,org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.jena.shared.PrefixMapping)" class="member-name-link">ParameterizedSparqlString</a><wbr>(org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new parameterized string</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(boolean)" class="member-name-link">append</a><wbr>(boolean&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a boolean as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(boolean)"><code>appendLiteral(boolean)</code></a> method</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(char)" class="member-name-link">append</a><wbr>(char&nbsp;c)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a character as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using one of the
 <code>appendLiteral()</code> methods</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(double)" class="member-name-link">append</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a double as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(double)</code></a> method</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(float)" class="member-name-link">append</a><wbr>(float&nbsp;f)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a float as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(float)</code></a> method</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(int)" class="member-name-link">append</a><wbr>(int&nbsp;i)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an integer as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(int)</code></a> method</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(long)" class="member-name-link">append</a><wbr>(long&nbsp;l)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a long as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(long)</code></a> method</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(java.lang.Object)" class="member-name-link">append</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;obj)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an object as-is to the existing command text, to ensure correct
 formatting when used as a constant consider converting into a more
 specific type and using the appropriate <code>appendLiteral()</code>,
 <code>appendIri()</code> or <code>appendNode</code> methods</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(java.lang.String)" class="member-name-link">append</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends some text as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(java.lang.String)"><code>appendLiteral(String)</code></a> or <a href="#appendIri(java.lang.String)"><code>appendIri(String)</code></a> method as
 appropriate</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendIri(java.lang.String)" class="member-name-link">appendIri</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a URI to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendIri(org.apache.jena.irix.IRIx)" class="member-name-link">appendIri</a><wbr>(org.apache.jena.irix.IRIx&nbsp;iri)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an IRI to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(boolean)" class="member-name-link">appendLiteral</a><wbr>(boolean&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a boolean to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(double)" class="member-name-link">appendLiteral</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a double to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(float)" class="member-name-link">appendLiteral</a><wbr>(float&nbsp;f)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a float to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(int)" class="member-name-link">appendLiteral</a><wbr>(int&nbsp;i)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an integer to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(long)" class="member-name-link">appendLiteral</a><wbr>(long&nbsp;l)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a long to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(java.lang.String)" class="member-name-link">appendLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a simple literal as a constant using appropriate formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(java.lang.String,java.lang.String)" class="member-name-link">appendLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a literal with a lexical value and language to the command text
 as a constant using appropriate formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(java.lang.String,org.apache.jena.datatypes.RDFDatatype)" class="member-name-link">appendLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a Typed Literal to the command text as a constant using
 appropriate formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendLiteral(java.util.Calendar)" class="member-name-link">appendLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a date time to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendNode(org.apache.jena.graph.Node)" class="member-name-link">appendNode</a><wbr>(org.apache.jena.graph.Node&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a Node to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendNode(org.apache.jena.rdf.model.RDFNode)" class="member-name-link">appendNode</a><wbr>(org.apache.jena.rdf.model.RDFNode&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a Node to the command text as a constant using appropriate
 formatting</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="Query.html" title="class in org.apache.jena.query">Query</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#asQuery()" class="member-name-link">asQuery</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="Query.html" title="class in org.apache.jena.query">Query</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#asQuery(org.apache.jena.query.Syntax)" class="member-name-link">asQuery</a><wbr>(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a> using the
 given <a href="Syntax.html" title="class in org.apache.jena.query"><code>Syntax</code></a> syntax</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../update/UpdateRequest.html" title="class in org.apache.jena.update">UpdateRequest</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#asUpdate()" class="member-name-link">asUpdate</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../update/UpdateRequest.html" title="class in org.apache.jena.update">UpdateRequest</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#asUpdate(org.apache.jena.query.Syntax)" class="member-name-link">asUpdate</a><wbr>(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a> using
 the given <a href="Syntax.html" title="class in org.apache.jena.query"><code>Syntax</code></a></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearNsPrefixMap()" class="member-name-link">clearNsPrefixMap</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearParam(int)" class="member-name-link">clearParam</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears the value for a positional parameter</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearParam(java.lang.String)" class="member-name-link">clearParam</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears the value for a variable or values parameter so the given variable
 will not * have a value injected</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearParams()" class="member-name-link">clearParams</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears all values for variable, values and positional parameters</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copy()" class="member-name-link">copy</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Makes a full copy of this parameterized string</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copy(boolean)" class="member-name-link">copy</a><wbr>(boolean&nbsp;copyParams)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Makes a copy of the command text, base URI and prefix mapping and
 optionally copies parameter values</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copy(boolean,boolean,boolean)" class="member-name-link">copy</a><wbr>(boolean&nbsp;copyParams,
 boolean&nbsp;copyBase,
 boolean&nbsp;copyPrefixes)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Makes a copy of the command text and optionally copies other aspects</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#expandPrefix(java.lang.String)" class="member-name-link">expandPrefix</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefixed)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getBaseUri()" class="member-name-link">getBaseUri</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the Base URI which will be prepended to a query</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCommandText()" class="member-name-link">getCommandText</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the basic Command Text</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getEligiblePositionalParameters()" class="member-name-link">getEligiblePositionalParameters</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the eligible positional parameters i.e.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNsPrefixMap()" class="member-name-link">getNsPrefixMap</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNsPrefixURI(java.lang.String)" class="member-name-link">getNsPrefixURI</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNsURIPrefix(java.lang.String)" class="member-name-link">getNsURIPrefix</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.graph.Node</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getParam(int)" class="member-name-link">getParam</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the current value for a positional parameter</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.graph.Node</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getParam(java.lang.String)" class="member-name-link">getParam</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the current value for a variable parameter</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr>org.apache.jena.graph.Node&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPositionalParameters()" class="member-name-link">getPositionalParameters</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the map of currently set positional parameters, this will be an
 unmodifiable map</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSyntax()" class="member-name-link">getSyntax</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the syntax used for parsing when calling <a href="#asQuery()"><code>asQuery()</code></a> or
 <a href="#asUpdate()"><code>asUpdate()</code></a></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>org.apache.jena.graph.Node&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getVariableParameters()" class="member-name-link">getVariableParameters</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the map of currently set variable parameters, this will be an
 unmodifiable map</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getVars()" class="member-name-link">getVars</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the variable names which are currently treated as variable
 parameters (i.e.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#hasNoMappings()" class="member-name-link">hasNoMappings</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#lock()" class="member-name-link">lock</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#numPrefixes()" class="member-name-link">numPrefixes</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#qnameFor(java.lang.String)" class="member-name-link">qnameFor</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeNsPrefix(java.lang.String)" class="member-name-link">removeNsPrefix</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#samePrefixMappingAs(org.apache.jena.shared.PrefixMapping)" class="member-name-link">samePrefixMappingAs</a><wbr>(org.apache.jena.shared.PrefixMapping&nbsp;other)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setBaseUri(java.lang.String)" class="member-name-link">setBaseUri</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the Base URI which will be prepended to the query/update</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setCommandText(java.lang.String)" class="member-name-link">setCommandText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the command text, overwriting any existing command text.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(int,java.lang.String)" class="member-name-link">setIri</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iri)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to an IRI</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(int,java.net.URL)" class="member-name-link">setIri</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to an IRI</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(int,org.apache.jena.irix.IRIx)" class="member-name-link">setIri</a><wbr>(int&nbsp;index,
 org.apache.jena.irix.IRIx&nbsp;iri)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to an IRI</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(java.lang.String,java.lang.String)" class="member-name-link">setIri</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to an IRI</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(java.lang.String,java.net.URL)" class="member-name-link">setIri</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to an IRI</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIri(java.lang.String,org.apache.jena.irix.IRIx)" class="member-name-link">setIri</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.irix.IRIx&nbsp;iri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to an IRI</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,boolean)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 boolean&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a boolean literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,double)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a double literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,float)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 float&nbsp;f)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a float literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,int)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 int&nbsp;i)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to an integer literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,long)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 long&nbsp;l)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to an integer literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,java.lang.String)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,java.lang.String,java.lang.String)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a literal with a language</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,java.lang.String,org.apache.jena.datatypes.RDFDatatype)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a typed literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,java.util.Calendar)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a date time literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(int,org.apache.jena.rdf.model.Literal)" class="member-name-link">setLiteral</a><wbr>(int&nbsp;index,
 org.apache.jena.rdf.model.Literal&nbsp;lit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter to a Literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,boolean)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 boolean&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a boolean literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,double)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a double literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,float)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 float&nbsp;f)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a float literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,int)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 int&nbsp;i)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to an integer literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,long)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 long&nbsp;l)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to an integer literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,java.lang.String)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a literal with a language</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,java.lang.String,org.apache.jena.datatypes.RDFDatatype)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a typed literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,java.util.Calendar)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a date time literal</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLiteral(java.lang.String,org.apache.jena.rdf.model.Literal)" class="member-name-link">setLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.rdf.model.Literal&nbsp;lit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter to a Literal</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setNsPrefix(java.lang.String,java.lang.String)" class="member-name-link">setNsPrefix</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setNsPrefixes(java.util.Map)" class="member-name-link">setNsPrefixes</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;map)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setNsPrefixes(org.apache.jena.shared.PrefixMapping)" class="member-name-link">setNsPrefixes</a><wbr>(org.apache.jena.shared.PrefixMapping&nbsp;other)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setParam(int,org.apache.jena.graph.Node)" class="member-name-link">setParam</a><wbr>(int&nbsp;index,
 org.apache.jena.graph.Node&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a Positional Parameter</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setParam(int,org.apache.jena.rdf.model.RDFNode)" class="member-name-link">setParam</a><wbr>(int&nbsp;index,
 org.apache.jena.rdf.model.RDFNode&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a positional parameter</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setParam(java.lang.String,org.apache.jena.graph.Node)" class="member-name-link">setParam</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.graph.Node&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setParam(java.lang.String,org.apache.jena.rdf.model.RDFNode)" class="member-name-link">setParam</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.rdf.model.RDFNode&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a variable parameter</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setParams(org.apache.jena.query.QuerySolutionMap)" class="member-name-link">setParams</a><wbr>(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the Parameters</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setRowValues(java.lang.String,java.util.Collection)" class="member-name-link">setRowValues</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&gt;&nbsp;rowItems)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Allocate multiple lists of variables to a single VALUES valueName.<br>
 Using "valuesName" with list(list(prop_A, obj_A), list(prop_B, obj_B)) on
 query "VALUES (?p ?o) {?valuesName}" would produce "VALUES (?p ?o)
 {(prop_A obj_A) * (prop_B obj_B)}".</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSyntax(org.apache.jena.query.Syntax)" class="member-name-link">setSyntax</a><wbr>(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the syntax used for parsing when calling <a href="#asQuery()"><code>asQuery()</code></a> or
 <a href="#asUpdate()"><code>asUpdate()</code></a></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setValues(java.lang.String,java.util.Collection)" class="member-name-link">setValues</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&nbsp;items)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign a VALUES valueName with a multiple items.<br>
 Can be used to assign multiple values to a single variable or single
 value to multiple variables (if using a List) in the SPARQL query.<br>
 See setRowValues to assign multiple values to multiple variables.<br>
 Using "valueName" with list(prop_A, obj_A) on query "VALUES (?p ?o)
 {?valueName}" * would produce "VALUES (?p ?o) {(prop_A obj_A)}".</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setValues(java.lang.String,org.apache.jena.rdf.model.RDFNode)" class="member-name-link">setValues</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 org.apache.jena.rdf.model.RDFNode&nbsp;item)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign a VALUES valueName with a single item.<br>
 Using "valueName" with Literal obj_A on query "VALUES ?o {?valueName}"
 would produce * "VALUES ?o {obj_A}".</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setValues(java.util.Map)" class="member-name-link">setValues</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&gt;&nbsp;itemsMap)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">** Sets a map of VALUES valueNames and their items.<br>
 Can be used to assign multiple values to a single variable or single
 value to multiple variables (if using a List) in the SPARQL query.<br>
 See setRowValues to assign multiple values to multiple variables.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#shortForm(java.lang.String)" class="member-name-link">shortForm</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toString()" class="member-name-link">toString</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">
 This method is where the actual work happens, the original command text
 is always preserved and we just generated a temporary command string by
 prepending the defined Base URI and namespace prefixes at the start of
 the command and injecting the set parameters into a copy of that base
 command string and return the resulting command.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jena.shared.PrefixMapping</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#withDefaultMappings(org.apache.jena.shared.PrefixMapping)" class="member-name-link">withDefaultMappings</a><wbr>(org.apache.jena.shared.PrefixMapping&nbsp;map)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,org.apache.jena.query.QuerySolutionMap,java.lang.String,org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>map</code> - Initial Parameters to inject</dd>
<dd><code>base</code> - Base URI</dd>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,org.apache.jena.query.QuerySolutionMap,java.lang.String)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>map</code> - Initial Parameters to inject</dd>
<dd><code>base</code> - Base URI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,org.apache.jena.query.QuerySolutionMap,org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>map</code> - Initial Parameters to inject</dd>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,org.apache.jena.query.QuerySolutionMap)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>map</code> - Initial Parameters to inject</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,java.lang.String,org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>base</code> - Base URI</dd>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,java.lang.String)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
<dd><code>base</code> - Base URI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Raw Command Text</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.jena.query.QuerySolutionMap,org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map,
 org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>map</code> - Initial Parameters to inject</dd>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.jena.query.QuerySolutionMap)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>map</code> - Initial Parameters to inject</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.jena.shared.PrefixMapping)">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span><wbr><span class="parameters">(org.apache.jena.shared.PrefixMapping&nbsp;prefixes)</span></div>
<div class="block">Creates a new parameterized string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>prefixes</code> - Prefix Mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>ParameterizedSparqlString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ParameterizedSparqlString</span>()</div>
<div class="block">Creates a new parameterized string with an empty command text</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getSyntax()">
<h3>getSyntax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a></span>&nbsp;<span class="element-name">getSyntax</span>()</div>
<div class="block">Gets the syntax used for parsing when calling <a href="#asQuery()"><code>asQuery()</code></a> or
 <a href="#asUpdate()"><code>asUpdate()</code></a></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Syntax</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSyntax(org.apache.jena.query.Syntax)">
<h3>setSyntax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setSyntax</span><wbr><span class="parameters">(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</span></div>
<div class="block">Sets the syntax used for parsing when calling <a href="#asQuery()"><code>asQuery()</code></a> or
 <a href="#asUpdate()"><code>asUpdate()</code></a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>syntax</code> - Syntax</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCommandText(java.lang.String)">
<h3>setCommandText</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCommandText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;command)</span></div>
<div class="block">Sets the command text, overwriting any existing command text. If you want
 to append to the command text use one of the <a href="#append(java.lang.Object)"><code>append(String)</code></a>,
 <a href="#appendIri(java.lang.String)"><code>appendIri(String)</code></a>, <a href="#appendLiteral(java.lang.String)"><code>appendLiteral(String)</code></a> or
 <a href="#appendNode(org.apache.jena.graph.Node)"><code>appendNode(Node)</code></a> methods instead</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>command</code> - Command Text</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(java.lang.String)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text)</span></div>
<div class="block">Appends some text as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(java.lang.String)"><code>appendLiteral(String)</code></a> or <a href="#appendIri(java.lang.String)"><code>appendIri(String)</code></a> method as
 appropriate</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>text</code> - Text to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(char)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(char&nbsp;c)</span></div>
<div class="block">Appends a character as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using one of the
 <code>appendLiteral()</code> methods</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>c</code> - Character to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(boolean)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(boolean&nbsp;b)</span></div>
<div class="block">Appends a boolean as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(boolean)"><code>appendLiteral(boolean)</code></a> method</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>b</code> - Boolean to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(double)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">Appends a double as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(double)</code></a> method</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>d</code> - Double to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(float)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(float&nbsp;f)</span></div>
<div class="block">Appends a float as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(float)</code></a> method</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>f</code> - Float to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(int)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(int&nbsp;i)</span></div>
<div class="block">Appends an integer as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(int)</code></a> method</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>i</code> - Integer to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(long)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(long&nbsp;l)</span></div>
<div class="block">Appends a long as-is to the existing command text, to ensure correct
 formatting when used as a constant consider using the
 <a href="#appendLiteral(double)"><code>appendLiteral(long)</code></a> method</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>l</code> - Long to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(java.lang.Object)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;obj)</span></div>
<div class="block">Appends an object as-is to the existing command text, to ensure correct
 formatting when used as a constant consider converting into a more
 specific type and using the appropriate <code>appendLiteral()</code>,
 <code>appendIri()</code> or <code>appendNode</code> methods</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>obj</code> - Object to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendNode(org.apache.jena.graph.Node)">
<h3>appendNode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendNode</span><wbr><span class="parameters">(org.apache.jena.graph.Node&nbsp;n)</span></div>
<div class="block">Appends a Node to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>n</code> - Node to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendNode(org.apache.jena.rdf.model.RDFNode)">
<h3>appendNode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendNode</span><wbr><span class="parameters">(org.apache.jena.rdf.model.RDFNode&nbsp;n)</span></div>
<div class="block">Appends a Node to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>n</code> - Node to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendIri(java.lang.String)">
<h3>appendIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendIri</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</span></div>
<div class="block">Appends a URI to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>uri</code> - URI to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendIri(org.apache.jena.irix.IRIx)">
<h3>appendIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendIri</span><wbr><span class="parameters">(org.apache.jena.irix.IRIx&nbsp;iri)</span></div>
<div class="block">Appends an IRI to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>iri</code> - IRI to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(java.lang.String)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Appends a simple literal as a constant using appropriate formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - Lexical Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(java.lang.String,java.lang.String)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</span></div>
<div class="block">Appends a literal with a lexical value and language to the command text
 as a constant using appropriate formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>lang</code> - Language</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(java.lang.String,org.apache.jena.datatypes.RDFDatatype)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</span></div>
<div class="block">Appends a Typed Literal to the command text as a constant using
 appropriate formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>datatype</code> - Datatype</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(boolean)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(boolean&nbsp;b)</span></div>
<div class="block">Appends a boolean to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>b</code> - Boolean to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(int)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(int&nbsp;i)</span></div>
<div class="block">Appends an integer to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>i</code> - Integer to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(long)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(long&nbsp;l)</span></div>
<div class="block">Appends a long to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>l</code> - Long to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(float)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(float&nbsp;f)</span></div>
<div class="block">Appends a float to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>f</code> - Float to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(double)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">Appends a double to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>d</code> - Double to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendLiteral(java.util.Calendar)">
<h3>appendLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</span></div>
<div class="block">Appends a date time to the command text as a constant using appropriate
 formatting</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dt</code> - Date Time to append</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCommandText()">
<h3>getCommandText</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getCommandText</span>()</div>
<div class="block">Gets the basic Command Text
 <p>
 <strong>Note:</strong> This will not reflect any injected parameters, to
 see the command with injected parameters invoke the <a href="#toString()"><code>toString()</code></a>
 method
 </p></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Command Text</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setBaseUri(java.lang.String)">
<h3>setBaseUri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setBaseUri</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base)</span></div>
<div class="block">Sets the Base URI which will be prepended to the query/update</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>base</code> - Base URI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getBaseUri()">
<h3>getBaseUri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getBaseUri</span>()</div>
<div class="block">Gets the Base URI which will be prepended to a query</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Base URI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParams(org.apache.jena.query.QuerySolutionMap)">
<h3>setParams</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParams</span><wbr><span class="parameters">(<a href="QuerySolutionMap.html" title="class in org.apache.jena.query">QuerySolutionMap</a>&nbsp;map)</span></div>
<div class="block">Sets the Parameters</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>map</code> - Parameters</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParam(int,org.apache.jena.graph.Node)">
<h3>setParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParam</span><wbr><span class="parameters">(int&nbsp;index,
 org.apache.jena.graph.Node&nbsp;n)</span></div>
<div class="block">Sets a Positional Parameter
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>n</code> - Node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParam(java.lang.String,org.apache.jena.graph.Node)">
<h3>setParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParam</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.graph.Node&nbsp;n)</span></div>
<div class="block">Sets a variable parameter
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>n</code> - Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParam(int,org.apache.jena.rdf.model.RDFNode)">
<h3>setParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParam</span><wbr><span class="parameters">(int&nbsp;index,
 org.apache.jena.rdf.model.RDFNode&nbsp;n)</span></div>
<div class="block">Sets a positional parameter
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>n</code> - Node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParam(java.lang.String,org.apache.jena.rdf.model.RDFNode)">
<h3>setParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParam</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.rdf.model.RDFNode&nbsp;n)</span></div>
<div class="block">Sets a variable parameter
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>n</code> - Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(int,java.lang.String)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iri)</span></div>
<div class="block">Sets a positional parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>iri</code> - IRI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(java.lang.String,java.lang.String)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iri)</span></div>
<div class="block">Sets a variable parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>iri</code> - IRI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(int,org.apache.jena.irix.IRIx)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(int&nbsp;index,
 org.apache.jena.irix.IRIx&nbsp;iri)</span></div>
<div class="block">Sets a positional parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>iri</code> - IRI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(java.lang.String,org.apache.jena.irix.IRIx)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.irix.IRIx&nbsp;iri)</span></div>
<div class="block">Sets a variable parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>iri</code> - IRI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(int,java.net.URL)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</span></div>
<div class="block">Sets a positional parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>url</code> - URL</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIri(java.lang.String,java.net.URL)">
<h3>setIri</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIri</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</span></div>
<div class="block">Sets a variable parameter to an IRI
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>url</code> - URL used as IRI</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,org.apache.jena.rdf.model.Literal)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 org.apache.jena.rdf.model.Literal&nbsp;lit)</span></div>
<div class="block">Sets a positional parameter to a Literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>lit</code> - Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,org.apache.jena.rdf.model.Literal)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 org.apache.jena.rdf.model.Literal&nbsp;lit)</span></div>
<div class="block">Sets a variable parameter to a Literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>lit</code> - Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,java.lang.String)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Sets a positional parameter to a literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>value</code> - Lexical Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,java.lang.String)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Sets a variable parameter to a literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>value</code> - Lexical Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,java.lang.String,java.lang.String)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</span></div>
<div class="block">Sets a positional parameter to a literal with a language
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional index</dd>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>lang</code> - Language</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,java.lang.String,java.lang.String)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;lang)</span></div>
<div class="block">Sets a variable parameter to a literal with a language
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>lang</code> - Language</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,java.lang.String,org.apache.jena.datatypes.RDFDatatype)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</span></div>
<div class="block">Sets a positional parameter to a typed literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(int)"><code>clearParam(int)</code></a> for the given index
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>datatype</code> - Datatype</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,java.lang.String,org.apache.jena.datatypes.RDFDatatype)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 org.apache.jena.datatypes.RDFDatatype&nbsp;datatype)</span></div>
<div class="block">Sets a variable parameter to a typed literal
 <p>
 Setting a parameter to null is equivalent to calling
 <a href="#clearParam(java.lang.String)"><code>clearParam(String)</code></a> for the given variable
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>value</code> - Lexical Value</dd>
<dd><code>datatype</code> - Datatype</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,boolean)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 boolean&nbsp;value)</span></div>
<div class="block">Sets a positional parameter to a boolean literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>value</code> - boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,boolean)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 boolean&nbsp;value)</span></div>
<div class="block">Sets a variable parameter to a boolean literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>value</code> - boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,int)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 int&nbsp;i)</span></div>
<div class="block">Sets a positional parameter to an integer literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>i</code> - Integer Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,int)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 int&nbsp;i)</span></div>
<div class="block">Sets a variable parameter to an integer literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>i</code> - Integer Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,long)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 long&nbsp;l)</span></div>
<div class="block">Sets a positional parameter to an integer literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>l</code> - Integer Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,long)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 long&nbsp;l)</span></div>
<div class="block">Sets a variable parameter to an integer literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>l</code> - Integer Value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,float)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 float&nbsp;f)</span></div>
<div class="block">Sets a positional parameter to a float literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>f</code> - Float value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,float)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 float&nbsp;f)</span></div>
<div class="block">Sets a variable parameter to a float literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>f</code> - Float value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,double)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 double&nbsp;d)</span></div>
<div class="block">Sets a positional parameter to a double literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>d</code> - Double value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,double)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 double&nbsp;d)</span></div>
<div class="block">Sets a variable parameter to a double literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>d</code> - Double value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(int,java.util.Calendar)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</span></div>
<div class="block">Sets a positional parameter to a date time literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dd><code>dt</code> - Date Time value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLiteral(java.lang.String,java.util.Calendar)">
<h3>setLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a>&nbsp;dt)</span></div>
<div class="block">Sets a variable parameter to a date time literal</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dd><code>dt</code> - Date Time value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParam(java.lang.String)">
<h3>getParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.graph.Node</span>&nbsp;<span class="element-name">getParam</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var)</span></div>
<div class="block">Gets the current value for a variable parameter</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
<dt>Returns:</dt>
<dd>Current value or null if not set</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParam(int)">
<h3>getParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.graph.Node</span>&nbsp;<span class="element-name">getParam</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block">Gets the current value for a positional parameter</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
<dt>Returns:</dt>
<dd>Current value or null if not set</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getVars()">
<h3>getVars</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">getVars</span>()</div>
<div class="block">Gets the variable names which are currently treated as variable
 parameters (i.e. have values set for them)</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Iterator of variable names</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getVariableParameters()">
<h3>getVariableParameters</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>org.apache.jena.graph.Node&gt;</span>&nbsp;<span class="element-name">getVariableParameters</span>()</div>
<div class="block">Gets the map of currently set variable parameters, this will be an
 unmodifiable map</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Map of variable names and values</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPositionalParameters()">
<h3>getPositionalParameters</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr>org.apache.jena.graph.Node&gt;</span>&nbsp;<span class="element-name">getPositionalParameters</span>()</div>
<div class="block">Gets the map of currently set positional parameters, this will be an
 unmodifiable map</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Map of positional indexes and values</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getEligiblePositionalParameters()">
<h3>getEligiblePositionalParameters</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">getEligiblePositionalParameters</span>()</div>
<div class="block">Gets the eligible positional parameters i.e. detected positional
 parameters that may be set in the command string as it currently stands</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Iterator of eligible positional parameters</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearParam(java.lang.String)">
<h3>clearParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearParam</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;var)</span></div>
<div class="block">Clears the value for a variable or values parameter so the given variable
 will not * have a value injected</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>var</code> - Variable</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearParam(int)">
<h3>clearParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearParam</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block">Clears the value for a positional parameter</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - Positional Index</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearParams()">
<h3>clearParams</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearParams</span>()</div>
<div class="block">Clears all values for variable, values and positional parameters</div>
</section>
</li>
<li>
<section class="detail" id="toString()">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span>()</div>
<div class="block"><p>
 This method is where the actual work happens, the original command text
 is always preserved and we just generated a temporary command string by
 prepending the defined Base URI and namespace prefixes at the start of
 the command and injecting the set parameters into a copy of that base
 command string and return the resulting command.
 </p>
 <p>
 This class makes no guarantees about the validity of the returned string
 for use as a SPARQL Query or Update, for example if a variable parameter
 was injected which was mentioned in the SELECT variables list you'd have
 a syntax error when you try to parse the query. If you run into issues
 like this try using a mixture of variable and positional parameters.
 </p></div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></dd>
<dt>Throws:</dt>
<dd><code><a href="../sparql/ARQException.html" title="class in org.apache.jena.sparql">ARQException</a></code> - May be thrown if the code detects a SPARQL Injection
             vulnerability because of the interaction of the command
             string and the injected variables</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asQuery()">
<h3>asQuery</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="Query.html" title="class in org.apache.jena.query">Query</a></span>&nbsp;<span class="element-name">asQuery</span>()
              throws <span class="exceptions"><a href="QueryException.html" title="class in org.apache.jena.query">QueryException</a></span></div>
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Query if the command text is a valid SPARQL query</dd>
<dt>Throws:</dt>
<dd><code><a href="QueryException.html" title="class in org.apache.jena.query">QueryException</a></code> - Thrown if the command text does not parse</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asQuery(org.apache.jena.query.Syntax)">
<h3>asQuery</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="Query.html" title="class in org.apache.jena.query">Query</a></span>&nbsp;<span class="element-name">asQuery</span><wbr><span class="parameters">(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</span></div>
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="Query.html" title="class in org.apache.jena.query"><code>Query</code></a> using the
 given <a href="Syntax.html" title="class in org.apache.jena.query"><code>Syntax</code></a> syntax</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Query if the command text is a valid SPARQL query</dd>
<dt>Throws:</dt>
<dd><code><a href="QueryException.html" title="class in org.apache.jena.query">QueryException</a></code> - Thrown if the command text does not parse</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asUpdate()">
<h3>asUpdate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../update/UpdateRequest.html" title="class in org.apache.jena.update">UpdateRequest</a></span>&nbsp;<span class="element-name">asUpdate</span>()</div>
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Update if the command text is a valid SPARQL Update request
         (one/more update commands)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asUpdate(org.apache.jena.query.Syntax)">
<h3>asUpdate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../update/UpdateRequest.html" title="class in org.apache.jena.update">UpdateRequest</a></span>&nbsp;<span class="element-name">asUpdate</span><wbr><span class="parameters">(<a href="Syntax.html" title="class in org.apache.jena.query">Syntax</a>&nbsp;syntax)</span></div>
<div class="block">Attempts to take the command text with parameters injected from the
 <a href="#toString()"><code>toString()</code></a> method and parse it as a <a href="../update/UpdateRequest.html" title="class in org.apache.jena.update"><code>UpdateRequest</code></a> using
 the given <a href="Syntax.html" title="class in org.apache.jena.query"><code>Syntax</code></a></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Update if the command text is a valid SPARQL Update request
         (one/more update commands)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copy()">
<h3>copy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></span>&nbsp;<span class="element-name">copy</span>()</div>
<div class="block">Makes a full copy of this parameterized string</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Copy of the string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copy(boolean)">
<h3>copy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></span>&nbsp;<span class="element-name">copy</span><wbr><span class="parameters">(boolean&nbsp;copyParams)</span></div>
<div class="block">Makes a copy of the command text, base URI and prefix mapping and
 optionally copies parameter values</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>copyParams</code> - Whether to copy parameters</dd>
<dt>Returns:</dt>
<dd>Copy of the string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copy(boolean,boolean,boolean)">
<h3>copy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ParameterizedSparqlString.html" title="class in org.apache.jena.query">ParameterizedSparqlString</a></span>&nbsp;<span class="element-name">copy</span><wbr><span class="parameters">(boolean&nbsp;copyParams,
 boolean&nbsp;copyBase,
 boolean&nbsp;copyPrefixes)</span></div>
<div class="block">Makes a copy of the command text and optionally copies other aspects</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>copyParams</code> - Whether to copy parameters</dd>
<dd><code>copyBase</code> - Whether to copy the Base URI</dd>
<dd><code>copyPrefixes</code> - Whether to copy the prefix mappings</dd>
<dt>Returns:</dt>
<dd>Copy of the string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setNsPrefix(java.lang.String,java.lang.String)">
<h3>setNsPrefix</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">setNsPrefix</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setNsPrefix</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeNsPrefix(java.lang.String)">
<h3>removeNsPrefix</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">removeNsPrefix</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>removeNsPrefix</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearNsPrefixMap()">
<h3>clearNsPrefixMap</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">clearNsPrefixMap</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clearNsPrefixMap</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setNsPrefixes(org.apache.jena.shared.PrefixMapping)">
<h3>setNsPrefixes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">setNsPrefixes</span><wbr><span class="parameters">(org.apache.jena.shared.PrefixMapping&nbsp;other)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setNsPrefixes</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setNsPrefixes(java.util.Map)">
<h3>setNsPrefixes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">setNsPrefixes</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;map)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setNsPrefixes</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="withDefaultMappings(org.apache.jena.shared.PrefixMapping)">
<h3>withDefaultMappings</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">withDefaultMappings</span><wbr><span class="parameters">(org.apache.jena.shared.PrefixMapping&nbsp;map)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>withDefaultMappings</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNsPrefixURI(java.lang.String)">
<h3>getNsPrefixURI</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getNsPrefixURI</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefix)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getNsPrefixURI</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNsURIPrefix(java.lang.String)">
<h3>getNsURIPrefix</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getNsURIPrefix</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getNsURIPrefix</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNsPrefixMap()">
<h3>getNsPrefixMap</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">getNsPrefixMap</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getNsPrefixMap</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="expandPrefix(java.lang.String)">
<h3>expandPrefix</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">expandPrefix</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;prefixed)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>expandPrefix</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="shortForm(java.lang.String)">
<h3>shortForm</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">shortForm</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>shortForm</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="qnameFor(java.lang.String)">
<h3>qnameFor</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">qnameFor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;uri)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>qnameFor</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasNoMappings()">
<h3>hasNoMappings</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasNoMappings</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>hasNoMappings</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="numPrefixes()">
<h3>numPrefixes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">numPrefixes</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>numPrefixes</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="lock()">
<h3>lock</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jena.shared.PrefixMapping</span>&nbsp;<span class="element-name">lock</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>lock</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="samePrefixMappingAs(org.apache.jena.shared.PrefixMapping)">
<h3>samePrefixMappingAs</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">samePrefixMappingAs</span><wbr><span class="parameters">(org.apache.jena.shared.PrefixMapping&nbsp;other)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>samePrefixMappingAs</code>&nbsp;in interface&nbsp;<code>org.apache.jena.shared.PrefixMapping</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setValues(java.lang.String,java.util.Collection)">
<h3>setValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setValues</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&nbsp;items)</span></div>
<div class="block">Assign a VALUES valueName with a multiple items.<br>
 Can be used to assign multiple values to a single variable or single
 value to multiple variables (if using a List) in the SPARQL query.<br>
 See setRowValues to assign multiple values to multiple variables.<br>
 Using "valueName" with list(prop_A, obj_A) on query "VALUES (?p ?o)
 {?valueName}" * would produce "VALUES (?p ?o) {(prop_A obj_A)}".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>valueName</code> - </dd>
<dd><code>items</code> - </dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setValues(java.lang.String,org.apache.jena.rdf.model.RDFNode)">
<h3>setValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setValues</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 org.apache.jena.rdf.model.RDFNode&nbsp;item)</span></div>
<div class="block">Assign a VALUES valueName with a single item.<br>
 Using "valueName" with Literal obj_A on query "VALUES ?o {?valueName}"
 would produce * "VALUES ?o {obj_A}".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>valueName</code> - </dd>
<dd><code>item</code> - </dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setValues(java.util.Map)">
<h3>setValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setValues</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&gt;&nbsp;itemsMap)</span></div>
<div class="block">** Sets a map of VALUES valueNames and their items.<br>
 Can be used to assign multiple values to a single variable or single
 value to multiple variables (if using a List) in the SPARQL query.<br>
 See setRowValues to assign multiple values to multiple variables.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>itemsMap</code> - </dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setRowValues(java.lang.String,java.util.Collection)">
<h3>setRowValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setRowValues</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;valueName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends org.apache.jena.rdf.model.RDFNode&gt;&gt;&nbsp;rowItems)</span></div>
<div class="block">Allocate multiple lists of variables to a single VALUES valueName.<br>
 Using "valuesName" with list(list(prop_A, obj_A), list(prop_B, obj_B)) on
 query "VALUES (?p ?o) {?valuesName}" would produce "VALUES (?p ?o)
 {(prop_A obj_A) * (prop_B obj_B)}".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>valueName</code> - </dd>
<dd><code>rowItems</code> - </dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Licensed under the Apache License, Version 2.0</small></p>
</footer>
</div>
</div>
</body>
</html>
