Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
org.basex.query.QueryException

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

Methods in org.basex.query.ft that throw QueryException
`FTItem` | `FTWords.atomic(QueryContext ctx)`
`FTItem` | `FTWeight.atomic(QueryContext ctx)`
`FTItem` | `FTOr.atomic(QueryContext ctx)`
`FTItem` | `FTOptions.atomic(QueryContext ctx)`
`FTItem` | `FTNot.atomic(QueryContext ctx)`
`FTItem` | `FTMildNot.atomic(QueryContext ctx)`
`abstract FTItem` | `FTExpr.atomic(QueryContext ctx)` This method is called by the sequential full-text evaluation.
`Bln` | `FTContainsIndex.atomic(QueryContext ctx)`
`Bln` | `FTContains.atomic(QueryContext ctx)`
`FTItem` | `FTAnd.atomic(QueryContext ctx)`
`FTExpr` | `FTWords.comp(QueryContext ctx)`
`FTExpr` | `FTWindow.comp(QueryContext ctx)`
`FTExpr` | `FTWeight.comp(QueryContext ctx)`
`FTExpr` | `FTOr.comp(QueryContext ctx)`
`FTExpr` | `FTOptions.comp(QueryContext ctx)`
`FTExpr` | `FTNot.comp(QueryContext ctx)`
`FTExpr` | `FTExpr.comp(QueryContext ctx)`
`FTExpr` | `FTDistance.comp(QueryContext ctx)`
`Expr` | `FTContains.comp(QueryContext ctx)`
`FTExpr` | `FTAnd.comp(QueryContext ctx)`
`byte[][]` | `ThesQuery.find(Tokenizer ft)` Finds a thesaurus term.
`boolean` | `FTOr.indexAccessible(IndexContext ic)`
`boolean` | `FTOptions.indexAccessible(IndexContext ic)`
`boolean` | `FTNot.indexAccessible(IndexContext ic)`
`boolean` | `FTMildNot.indexAccessible(IndexContext ic)`
`boolean` | `FTContains.indexAccessible(IndexContext ic)`
`boolean` | `FTAnd.indexAccessible(IndexContext ic)`
`FTExpr` | `FTExpr.indexEquivalent(IndexContext ic)`
`Expr` | `FTContains.indexEquivalent(IndexContext ic)`
`FTIter` | `FTOr.iter(QueryContext ctx)`
`FTIter` | `FTNot.iter(QueryContext ctx)`
`FTIter` | `FTMildNot.iter(QueryContext ctx)`
`Iter` | `FTIndexAccess.iter(QueryContext ctx)`
`abstract FTIter` | `FTExpr.iter(QueryContext ctx)` This method is called by the index-based full-text evaluation.
`FTIter` | `FTAnd.iter(QueryContext ctx)`

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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES