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.