|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use QueryException | |
---|---|
org.basex.core | This package contains the database core classes. |
org.basex.query | This package contains the XQuery implementation. |
org.basex.query.expr | This package contains all XQuery expressions. |
org.basex.query.ft | This package contains all XQuery Full Text expressions. |
org.basex.query.func | This package contains all XQuery functions. |
org.basex.query.item | This package contains XQuery data types. |
org.basex.query.iter | This package contains iterator implementations. |
org.basex.query.path | This package contains XQuery path expressions. |
org.basex.query.up | This package contains XQuery Update expressions. |
org.basex.query.up.primitives | This package contains XQuery Update primitives. |
org.basex.query.util | This package contains XQuery utility classes. |
org.basex.test.examples | Contains examples for using the project code. |
Uses of QueryException in org.basex.core |
---|
Methods in org.basex.core that throw QueryException | |
---|---|
void |
CommandParser.error(StringList comp,
String m,
Object... e)
Throws an error. |
Proc[] |
CommandParser.parse()
Parses the input and returns a command list. |
Uses of QueryException in org.basex.query |
---|
Methods in org.basex.query that throw QueryException | |
---|---|
SeqIter |
QueryContext.coll(byte[] coll)
Adds a collection instance or returns an existing one. |
void |
QueryProcessor.compile()
Compiles the query. |
void |
QueryContext.compile()
Optimizes the expression. |
Data |
QueryContext.data()
Returns the common database reference of all items or null. |
DBNode |
QueryContext.doc(byte[] path,
boolean coll,
boolean db)
Adds a database instance or returns an existing one. |
Iter |
QueryProcessor.iter()
Returns a result iterator. |
Iter |
QueryContext.iter()
Returns a result iterator. |
Iter |
QueryContext.iter(Expr e)
Evaluates the specified expression and returns an iterator. |
void |
QueryContext.module(String q)
Parses the specified module. |
void |
QueryProcessor.parse()
Parses the query. |
void |
QueryContext.parse(String q)
Parses the specified query. |
Expr |
QueryParser.parse(String q,
IO f,
Uri u)
Parses the specified query. |
Expr |
QueryParser.parse(Uri u,
boolean end)
Parses the specified query. |
Expr |
QueryParser.path()
[ 68] Parses a PathExpr |
Result |
QueryProcessor.query()
Evaluates the specified query and returns the result. |
Nodes |
QueryProcessor.queryNodes()
Evaluates the specified query and returns the result nodes. |
Uses of QueryException in org.basex.query.expr |
---|
Methods in org.basex.query.expr with parameters of type QueryException | |
---|---|
Iter |
Catch.iter(QueryContext ctx,
QueryException ex)
Catch iterator. |
Methods in org.basex.query.expr that throw QueryException | |
---|---|
void |
Order.add(QueryContext ctx)
Adds the items to be sorted. |
void |
Group.add(QueryContext ctx)
Adds the items to be grouped. |
Expr |
Expr.addText(QueryContext ctx)
Optionally adds a text node to an expression for potential index rewriting. |
Item |
Unary.atomic(QueryContext ctx)
|
Bln |
Satisfy.atomic(QueryContext ctx)
|
Bln |
Pos.atomic(QueryContext ctx)
|
Item |
Or.atomic(QueryContext ctx)
|
Bln |
Instance.atomic(QueryContext ctx)
|
Item |
Func.atomic(QueryContext ctx)
|
Item |
Expr.atomic(QueryContext ctx)
Evaluates the expression and returns the resulting item or a null reference. |
FTxt |
CText.atomic(QueryContext ctx)
|
FPI |
CPI.atomic(QueryContext ctx)
|
Bln |
CmpV.atomic(QueryContext ctx)
|
Item |
CmpR.atomic(QueryContext ctx)
|
Bln |
CmpN.atomic(QueryContext ctx)
|
Bln |
CmpG.atomic(QueryContext ctx)
|
Item |
Clc.atomic(QueryContext ctx)
|
abstract Nod |
CFrag.atomic(QueryContext ctx)
|
FElem |
CElem.atomic(QueryContext ctx)
|
FDoc |
CDoc.atomic(QueryContext ctx)
|
FComm |
CComm.atomic(QueryContext ctx)
|
FAttr |
CAttr.atomic(QueryContext ctx)
|
Item |
Cast.atomic(QueryContext ctx)
|
Bln |
And.atomic(QueryContext ctx)
|
static byte[] |
CPI.check(byte[] atom)
Checks the specified token for validity. |
static byte[] |
CComm.check(byte[] atom)
Checks the specified token for validity. |
Item |
Expr.checkCtx(QueryContext ctx)
Throws an exception if the context item is not set. |
double |
Expr.checkDbl(Expr e,
QueryContext ctx)
Checks if the specified expression yields a string. |
long |
Expr.checkItr(Expr e,
QueryContext ctx)
Checks if the specified expression is an integer. |
Expr |
VarCall.comp(QueryContext ctx)
|
Expr |
Union.comp(QueryContext ctx)
|
Expr |
Unary.comp(QueryContext ctx)
|
Expr |
TypeSwitch.comp(QueryContext ctx)
|
Expr |
Try.comp(QueryContext ctx)
|
Expr |
Treat.comp(QueryContext ctx)
|
Expr |
Single.comp(QueryContext ctx)
|
Expr |
Satisfy.comp(QueryContext ctx)
|
Expr |
Range.comp(QueryContext ctx)
|
Expr |
Preds.comp(QueryContext ctx)
|
Expr |
Pred.comp(QueryContext ctx)
|
Expr |
Order.comp(QueryContext ctx)
|
Expr |
Ord.comp(QueryContext ctx)
|
Expr |
Or.comp(QueryContext ctx)
|
Expr |
List.comp(QueryContext ctx)
|
Expr |
Let.comp(QueryContext ctx)
|
Expr |
InterSect.comp(QueryContext ctx)
|
Expr |
Instance.comp(QueryContext ctx)
|
Expr |
If.comp(QueryContext ctx)
|
Expr |
Grp.comp(QueryContext ctx)
|
Expr |
Group.comp(QueryContext ctx)
|
Expr |
FunCall.comp(QueryContext ctx)
|
Expr |
Func.comp(QueryContext ctx)
|
Expr |
For.comp(QueryContext ctx)
|
Expr |
FLWR.comp(QueryContext ctx)
|
Expr |
FLWOR.comp(QueryContext ctx)
|
abstract Expr |
Expr.comp(QueryContext ctx)
Optimizes and compiles the expression. |
Expr |
Except.comp(QueryContext ctx)
|
Expr |
CPI.comp(QueryContext ctx)
|
Expr |
CmpV.comp(QueryContext ctx)
|
Expr |
CmpN.comp(QueryContext ctx)
|
Expr |
CmpG.comp(QueryContext ctx)
|
Expr |
Clc.comp(QueryContext ctx)
|
Expr |
CElem.comp(QueryContext ctx)
|
Expr |
CDoc.comp(QueryContext ctx)
|
Expr |
CAttr.comp(QueryContext ctx)
|
Catch |
Catch.comp(QueryContext ctx)
|
Expr |
Castable.comp(QueryContext ctx)
|
Expr |
Cast.comp(QueryContext ctx)
|
Case |
Case.comp(QueryContext ctx)
|
Expr |
Arr.comp(QueryContext ctx)
|
Expr |
And.comp(QueryContext ctx)
|
Case |
Case.comp(QueryContext ctx,
Item it)
Compiles the expression. |
abstract boolean |
CmpV.Comp.e(Item a,
Item b)
Evaluates the expression. |
abstract boolean |
CmpN.Comp.e(Item a,
Item b)
Evaluates the expression. |
Item |
Expr.ebv(QueryContext ctx)
Checks if the iterator can be dissolved into an effective boolean value. |
abstract Item |
Calc.ev(Item a,
Item b)
Performs the calculation. |
boolean |
Or.indexAccessible(IndexContext ic)
|
boolean |
Expr.indexAccessible(IndexContext ic)
Checks if an index can be used for query evaluation. |
boolean |
CmpG.indexAccessible(IndexContext ic)
|
boolean |
And.indexAccessible(IndexContext ic)
|
Expr |
Or.indexEquivalent(IndexContext ic)
|
Expr |
Expr.indexEquivalent(IndexContext ic)
Returns an equivalent expression which accesses an index structure. |
Expr |
Arr.indexEquivalent(IndexContext ic)
|
Expr |
And.indexEquivalent(IndexContext ic)
|
Iter |
VarCall.iter(QueryContext ctx)
|
NodeIter |
Union.iter(QueryContext ctx)
|
Iter |
TypeSwitch.iter(QueryContext ctx)
|
Iter |
Treat.iter(QueryContext ctx)
|
Iter |
Root.iter(QueryContext ctx)
|
Iter |
Range.iter(QueryContext ctx)
|
Iter |
Pred.iter(QueryContext ctx)
|
Iter |
InterSect.iter(QueryContext ctx)
|
Iter |
IndexAccess.iter(QueryContext ctx)
|
Iter |
If.iter(QueryContext ctx)
|
Iter |
FunCall.iter(QueryContext ctx)
|
Iter |
FLWOR.iter(QueryContext ctx)
|
Iter |
Expr.iter(QueryContext ctx)
Evaluates the expression and returns an iterator on the resulting items. |
NodeIter |
Except.iter(QueryContext ctx)
|
Iter |
Context.iter(QueryContext ctx)
|
Iter |
Catch.iter(QueryContext ctx,
QueryException ex)
Catch iterator. |
long |
Range.size(QueryContext ctx)
|
long |
List.size(QueryContext ctx)
|
long |
Expr.size(QueryContext ctx)
Returns the sequence size or 1. |
Item |
Expr.test(QueryContext ctx)
Performs a predicate test and returns the item if test was successful. |
Constructors in org.basex.query.expr that throw QueryException | |
---|---|
Constr(QueryContext ctx,
Expr... expr)
Creates the children of the constructor. |
Uses of QueryException in org.basex.query.ft |
---|
Constructors in org.basex.query.ft that throw QueryException | |
---|---|
FTMildNot(FTExpr e1,
FTExpr e2)
Constructor. |
Uses of QueryException in org.basex.query.func |
---|
Methods in org.basex.query.func that throw QueryException | |
---|---|
Item |
FNSimple.atomic(QueryContext ctx)
|
Item |
FNSeq.atomic(QueryContext ctx)
|
Item |
FNGen.atomic(QueryContext ctx)
|
Item |
FNBaseX.atomic(QueryContext ctx)
|
Item |
FNAggr.atomic(QueryContext ctx)
|
Expr |
Fun.c(QueryContext ctx)
Compiles the function. |
Expr |
FNSimple.c(QueryContext ctx)
|
Expr |
FNGen.c(QueryContext ctx)
|
Expr |
FNBaseX.c(QueryContext ctx)
|
Expr |
FNAggr.c(QueryContext ctx)
|
Expr |
Fun.comp(QueryContext ctx)
|
static boolean |
FNSeq.deep(Iter iter1,
Iter iter2)
Checks items for deep equality. |
void |
FNIndex.error(byte[] name)
Finds similar function names for throwing an error message. |
Fun |
FNIndex.get(byte[] name,
byte[] uri,
Expr[] args)
Returns the specified function. |
Iter |
FunJava.iter(QueryContext ctx)
|
Iter |
FNSimple.iter(QueryContext ctx)
|
Iter |
FNSeq.iter(QueryContext ctx)
|
Iter |
FNGen.iter(QueryContext ctx)
|
Iter |
FNBaseX.iter(QueryContext ctx)
|
Uses of QueryException in org.basex.query.item |
---|
Methods in org.basex.query.item that throw QueryException | |
---|---|
Item |
Seq.atomic(QueryContext ctx)
|
Item |
Item.atomic(QueryContext ctx)
|
boolean |
QNm.bool()
|
boolean |
Item.bool()
Returns a boolean representation of the item. |
Item |
SeqType.cast(Item it,
Expr expr,
QueryContext ctx)
Casts the specified item. |
Item |
SeqType.cast(Item item,
QueryContext ctx)
Casts the specified item. |
double |
Str.dbl()
|
double |
Nod.dbl()
|
double |
Jav.dbl()
|
double |
Item.dbl()
Returns a double representation of the item. |
BigDecimal |
Str.dec()
|
BigDecimal |
Nod.dec()
|
BigDecimal |
Jav.dec()
|
BigDecimal |
Item.dec()
Returns a decimal representation of the item. |
BigDecimal |
Flt.dec()
|
BigDecimal |
Dbl.dec()
|
int |
YMd.diff(Item it)
|
int |
Str.diff(Item it)
|
int |
QNm.diff(Item it)
|
int |
Nod.diff(Item i)
|
int |
Itr.diff(Item it)
|
int |
Item.diff(Item it)
Returns the difference between the current and the specified item. |
int |
Flt.diff(Item it)
|
int |
Dur.diff(Item it)
|
int |
DTd.diff(Item it)
|
int |
DSim.diff(Item it)
|
int |
Dec.diff(Item it)
|
int |
Dbl.diff(Item it)
|
int |
Date.diff(Item it)
|
int |
Bln.diff(Item it)
|
int |
Atm.diff(Item it)
|
Item |
Type.e(Item it,
QueryContext ctx)
Constructs a new item from the specified item. |
Item |
Type.e(Object o)
Constructs a new item from the specified Java object. |
Item |
Seq.ebv(QueryContext ctx)
|
Item |
Item.ebv(QueryContext ctx)
|
boolean |
Str.eq(Item it)
|
boolean |
Seq.eq(Item it)
|
boolean |
QNm.eq(Item it)
|
boolean |
Nod.eq(Item i)
|
boolean |
Itr.eq(Item it)
|
abstract boolean |
Item.eq(Item it)
Checks the items for equality. |
boolean |
Hex.eq(Item it)
|
boolean |
Flt.eq(Item it)
|
boolean |
Dec.eq(Item it)
|
boolean |
Dbl.eq(Item it)
|
boolean |
Bln.eq(Item it)
|
boolean |
B64.eq(Item it)
|
boolean |
Atm.eq(Item it)
|
float |
Str.flt()
|
float |
Nod.flt()
|
float |
Jav.flt()
|
float |
Item.flt()
Returns a float representation of the item. |
static Dbl |
Dbl.get(byte[] v)
Returns an instance of this class. |
boolean |
SeqType.instance(Iter iter)
Checks the instance of the specified iterator. |
long |
Str.itr()
|
long |
Nod.itr()
|
long |
Jav.itr()
|
long |
Item.itr()
Returns an integer (long) representation of the item. |
QNm |
Nod.qname(QNm nm)
Returns a temporary node name. |
Item |
Seq.test(QueryContext ctx)
|
Item |
Item.test(QueryContext ctx)
|
Constructors in org.basex.query.item that throw QueryException | |
---|---|
B64(byte[] d)
Constructor. |
|
Dat(byte[] d)
Constructor. |
|
Dat(Date d,
Dur a,
boolean p)
Constructor. |
|
DTd(Dur it,
double f,
boolean m)
Constructor. |
|
Dtm(byte[] dt)
Constructor. |
|
Dtm(Date d,
Dur a,
boolean p)
Constructor. |
|
Dur(byte[] v)
Constructor. |
|
Dur(byte[] v,
Type t)
Constructor. |
|
Hex(byte[] v)
Constructor. |
|
NCN(byte[] v)
Constructor. |
|
QNm(byte[] n,
QueryContext ctx)
Constructor. |
|
Tim(byte[] tim)
Constructor. |
|
Tim(Tim d,
DTd a,
boolean p)
Constructor. |
|
YMd(Dur it,
double f,
boolean m)
Constructor. |
Uses of QueryException in org.basex.query.iter |
---|
Methods in org.basex.query.iter that throw QueryException | |
---|---|
void |
SeqIter.add(Iter iter)
Adds the contents of an iterator. |
Item |
Iter.finish()
Returns a sequence from all iterator values. |
static SeqIter |
SeqIter.get(Iter iter)
Returns the argument, if it is a sequence iterator. |
abstract Nod |
NodeIter.next()
|
abstract Item |
Iter.next()
Returns the next item or null if no other items are found. |
abstract FTItem |
FTIter.next()
|
Uses of QueryException in org.basex.query.path |
---|
Methods in org.basex.query.path that throw QueryException | |
---|---|
Expr |
AxisPath.addText(QueryContext ctx)
|
boolean |
Test.comp(QueryContext ctx)
Optimizes and compiles the expression. |
Expr |
Step.comp(QueryContext ctx)
|
Expr |
SimpleIterStep.comp(QueryContext ctx)
|
Expr |
Path.comp(QueryContext ctx)
|
boolean |
NameTest.comp(QueryContext ctx)
|
Expr |
MixedPath.comp(QueryContext ctx)
|
Expr |
AxisPath.comp(QueryContext ctx)
|
abstract boolean |
Test.eval(Nod nod)
Tests the specified node. |
boolean |
NameTest.eval(Nod node)
|
boolean |
KindTest.eval(Nod n)
|
NodeIter |
Step.iter(QueryContext ctx)
|
NodeIter |
SimpleIterStep.iter(QueryContext ctx)
|
Iter |
MixedPath.iter(QueryContext ctx)
|
Iter |
AxisPath.iter(QueryContext ctx)
|
Uses of QueryException in org.basex.query.up |
---|
Methods in org.basex.query.up that throw QueryException | |
---|---|
void |
Updates.add(UpdatePrimitive p,
QueryContext ctx)
Adds an update primitive to the corresponding primitive list. |
void |
Updates.apply()
Checks constraints and applies all update primitives to the databases if no constraints are hurt. |
Item |
Transform.atomic(QueryContext ctx)
|
Seq |
Replace.atomic(QueryContext ctx)
|
Seq |
Rename.atomic(QueryContext ctx)
|
Seq |
Insert.atomic(QueryContext ctx)
|
Seq |
Delete.atomic(QueryContext ctx)
|
Expr |
Transform.comp(QueryContext ctx)
|
Uses of QueryException in org.basex.query.up.primitives |
---|
Methods in org.basex.query.up.primitives that throw QueryException | |
---|---|
abstract void |
UpdatePrimitive.apply(int add)
Applies the update operation represented by this primitive to the database. |
void |
Put.apply(int add)
|
static MemData |
UpdatePrimitive.buildDB(NodIter ch,
MemData md)
Builds new data instance from iterator. |
void |
UpdatePrimitive.merge(UpdatePrimitive p)
Merges if possible two update primitives of the same type if they have the same target node. |
void |
ReplaceValue.merge(UpdatePrimitive p)
|
void |
ReplacePrimitive.merge(UpdatePrimitive p)
|
void |
ReplaceElemContent.merge(UpdatePrimitive p)
|
void |
RenamePrimitive.merge(UpdatePrimitive p)
|
void |
UpdatePrimitive.prepare()
Prepares the update. |
void |
NodeCopy.prepare()
|
Uses of QueryException in org.basex.query.util |
---|
Methods in org.basex.query.util that throw QueryException | |
---|---|
int |
Functions.add(Func fun)
Adds a local function. |
void |
NSLocal.add(QNm name)
Adds the specified namespace. |
Var |
Var.bind(Expr e,
QueryContext ctx)
Binds the specified expression to the variable. |
Var |
Var.bind(Item it,
QueryContext ctx)
Binds the specified item to the variable. |
static void |
Err.cast(Type t,
Item it)
Throws a numeric type exception. |
void |
Functions.check()
Checks if all functions have been correctly initialized. |
static void |
Err.cmp(Item it1,
Item it2)
Throws a comparison exception. |
void |
Variables.comp(QueryContext ctx)
Compiles the variables. |
Var |
Var.comp(QueryContext ctx)
|
void |
Functions.comp(QueryContext ctx)
Compiles the functions. |
static void |
Err.date(byte[] i,
Type t,
String ex)
Throws a date format exception. |
static void |
Err.empty(Expr e)
Throws a empty sequence exception. |
void |
Functions.funError(QNm name)
Finds similar function names and throws an error message. |
Expr |
Functions.get(QNm name,
Expr[] args,
QueryContext ctx)
Returns the specified function. |
boolean |
ItemSet.index(Item i)
Indexes the specified item. |
Item |
Var.item(QueryContext ctx)
Evaluates the variable and returns the resulting item. |
Iter |
Var.iter(QueryContext ctx)
|
static void |
Err.nodes(Expr ex)
Throws a node exception. |
static void |
Err.num(String inf,
Item it)
Throws a numeric type exception. |
static void |
Err.or(Object[] err,
Object... x)
Throws an exception. |
static void |
Err.range(Type t,
byte[] v)
Throws a date range exception. |
static void |
Err.type(String inf,
Type t,
Item it)
Throws a type exception. |
byte[] |
NSLocal.uri(byte[] pre,
boolean dn)
Finds the uri for the specified prefix in the local and global namespaces. |
static void |
Err.value(Type t,
Object v)
Throws an invalid value exception. |
Uses of QueryException in org.basex.test.examples |
---|
Methods in org.basex.test.examples that throw QueryException | |
---|---|
static void |
QueryExample.main(String[] args)
Runs the example code. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |