16 package org.zorbaxquery.api.xqj;
19 import java.math.BigDecimal;
20 import java.math.BigInteger;
22 import java.nio.CharBuffer;
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.Iterator;
26 import java.util.Properties;
27 import javax.xml.datatype.DatatypeConstants;
28 import javax.xml.datatype.Duration;
29 import javax.xml.datatype.XMLGregorianCalendar;
30 import javax.xml.namespace.QName;
31 import javax.xml.stream.XMLOutputFactory;
32 import javax.xml.stream.XMLStreamReader;
33 import javax.xml.stream.XMLStreamWriter;
34 import javax.xml.transform.*;
35 import javax.xml.transform.dom.DOMSource;
36 import javax.xml.transform.sax.SAXSource;
37 import javax.xml.transform.stax.StAXResult;
38 import javax.xml.transform.stax.StAXSource;
39 import javax.xml.transform.stream.StreamResult;
40 import javax.xml.transform.stream.StreamSource;
41 import javax.xml.xquery.*;
43 import org.zorbaxquery.api.*;
76 private InMemoryStore store;
78 private boolean autocommit;
79 private boolean closed;
80 private Collection<XQExpression> cExpression;
81 private Collection<XQPreparedExpression> cPreparedExpression;
82 private Collection<XQMetaData> cMetadata;
83 private XQStaticContext lStaticContext;
85 private Properties properties;
86 private StringVector uriPaths;
87 private StringVector libPaths;
88 private StringVector modulePaths;
94 throw new XQException(
"Error returning Zorba Instance");
98 cExpression =
new ArrayList<XQExpression>();
99 cPreparedExpression =
new ArrayList<XQPreparedExpression>();
100 store = InMemoryStore.getInstance();
101 zorba = Zorba.getInstance ( store );
106 cExpression =
new ArrayList<XQExpression>();
107 cPreparedExpression =
new ArrayList<XQPreparedExpression>();
108 store = InMemoryStore.getInstance();
109 zorba = Zorba.getInstance ( store );
112 properties = aProperties;
113 for (String prop :properties.stringPropertyNames()) {
115 String[] paths = properties.getProperty(prop).split(
"[;,]");
116 uriPaths =
new StringVector();
117 for (String path: paths) {
122 String[] paths = properties.getProperty(prop).split(
"[;,]");
123 libPaths =
new StringVector();
124 for (String path: paths) {
129 String[] paths = properties.getProperty(prop).split(
"[;,]");
130 modulePaths =
new StringVector();
131 for (String path: paths) {
132 modulePaths.add(path);
137 if (uriPaths!=null) {
140 if (libPaths!=null) {
143 if (modulePaths!=null) {
156 public void close() throws XQException {
159 for (XQExpression exp : cExpression ){
162 for (XQPreparedExpression exp : cPreparedExpression ){
165 }
catch (XQException e) {
166 throw new XQException(
"Error closing connection: " + e.getLocalizedMessage());
169 if (lStaticContext != null ) {
172 if (lXmlDataManager != null) {
173 lXmlDataManager.close();
176 InMemoryStore.shutdown ( store );
181 if (lXmlDataManager==null) {
184 return lXmlDataManager;
189 isClosedXQException();
200 isClosedXQException();
211 public void commit() throws XQException {
212 isClosedXQException();
213 throw new UnsupportedOperationException(
"Zorba does not support transactions... yet...");
225 isClosedXQException();
226 XQExpression expression;
227 if (lStaticContext == null) {
232 cExpression.add(expression);
246 isClosedXQException();
247 isNullXQException(value);
249 cExpression.add(expression);
260 isClosedXQException();
283 isClosedXQException();
284 isNullXQException(value);
285 XQPreparedExpression expression;
287 if (lStaticContext == null) {
292 cPreparedExpression.add(expression);
293 }
catch (Exception e) {
294 throw new XQException(
"Error preparing expression: "+e.getLocalizedMessage());
309 public XQPreparedExpression
prepareExpression(String
string, XQStaticContext xqsc)
throws XQException {
310 isClosedXQException();
311 isNullXQException(
string);
312 isNullXQException(xqsc);
313 XQPreparedExpression expression = null;
316 cPreparedExpression.add(expression);
317 }
catch (Exception e) {
318 throw new XQException(
"Error preparing expression");
333 isClosedXQException();
334 isNullXQException(reader);
336 XQPreparedExpression expression;
337 if (lStaticContext == null) {
342 cPreparedExpression.add(expression);
356 public XQPreparedExpression
prepareExpression(Reader reader, XQStaticContext xqsc)
throws XQException {
357 isClosedXQException();
358 isNullXQException(reader);
359 isNullXQException(xqsc);
363 cPreparedExpression.add(expression);
377 isClosedXQException();
378 isNullXQException(in);
380 XQPreparedExpression expression;
381 if (lStaticContext == null) {
387 cPreparedExpression.add(expression);
388 }
catch (Exception ex) {
389 throw new XQException(
"Error preparing expression" + ex.getLocalizedMessage());
405 public XQPreparedExpression
prepareExpression(InputStream in, XQStaticContext xqsc)
throws XQException {
406 isClosedXQException();
407 isNullXQException(in);
408 isNullXQException(xqsc);
410 XQPreparedExpression expression = null;
413 cPreparedExpression.add(expression);
414 }
catch (Exception ex) {
415 throw new XQException(
"Error preparing expression" + ex.getLocalizedMessage());
428 throw new UnsupportedOperationException(
"Zorba does not support transactions... yet...");
440 isClosedXQException();
442 if (uriPaths!=null) {
445 if (libPaths!=null) {
448 if (modulePaths!=null) {
451 return lStaticContext;
463 isClosedXQException();
464 isNullXQException(xqsc);
465 if ((lStaticContext!=null) && (lStaticContext!=xqsc)) {
468 lStaticContext = xqsc;
482 isClosedXQException();
483 isNullXQException(value);
484 isNullXQException(type);
485 if (type.getItemKind()!=XQItemType.XQITEMKIND_ATOMIC) {
486 throw new XQException(
"ItemType is not Atomic");
490 item = this.createItemFromString(value, type);
491 }
catch (Exception e) {
492 throw new XQException(
"Error creating item of this type " + e.getLocalizedMessage());
509 isClosedXQException();
510 isNullXQException(value);
514 ItemFactory itemFactory = zorba.getItemFactory();
517 switch (type.getBaseType()) {
518 case XQItemType.XQBASETYPE_BOOLEAN:
519 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createBoolean(Boolean.parseBoolean(value)), type);
521 case XQItemType.XQBASETYPE_ANYURI:
522 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createAnyURI(value), type);
524 case XQItemType.XQBASETYPE_BASE64BINARY:
525 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createBase64Binary(value, value.length()), type);
527 case XQItemType.XQBASETYPE_BYTE:
528 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createByte(value.charAt(0)), type);
530 case XQItemType.XQBASETYPE_DATE:
531 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDate(value), type);
533 case XQItemType.XQBASETYPE_DATETIME:
534 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDateTime(value), type);
536 case XQItemType.XQBASETYPE_DAYTIMEDURATION:
537 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value), type);
539 case XQItemType.XQBASETYPE_DECIMAL:
540 BigDecimal dec =
new BigDecimal(value);
541 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDecimal(value), type);
543 case XQItemType.XQBASETYPE_DOUBLE:
544 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDouble(Double.parseDouble(value)), type);
546 case XQItemType.XQBASETYPE_DURATION:
547 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value), type);
549 case XQItemType.XQBASETYPE_FLOAT:
550 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createFloat(value), type);
552 case XQItemType.XQBASETYPE_GDAY:
553 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGDay(value), type);
555 case XQItemType.XQBASETYPE_GMONTH:
556 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGMonth(value), type);
558 case XQItemType.XQBASETYPE_GMONTHDAY:
559 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGMonthDay(value), type);
561 case XQItemType.XQBASETYPE_GYEAR:
562 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGYear(value), type);
564 case XQItemType.XQBASETYPE_GYEARMONTH:
565 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGYearMonth(value), type);
567 case XQItemType.XQBASETYPE_HEXBINARY:
568 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createHexBinary(value, value.length()), type);
570 case XQItemType.XQBASETYPE_INT:
571 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInt(Integer.parseInt(value)), type);
573 case XQItemType.XQBASETYPE_INTEGER:
574 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInteger(Integer.parseInt(value)), type);
576 case XQItemType.XQBASETYPE_LONG:
577 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createLong(Long.parseLong(value)), type);
579 case XQItemType.XQBASETYPE_NCNAME:
580 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNCName(value), type);
582 case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
583 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNegativeInteger(Long.parseLong(value)), type);
585 case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
586 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonNegativeInteger(
new BigInteger(value)), type);
588 case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
589 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonPositiveInteger(Long.parseLong(value)), type);
591 case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
592 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createPositiveInteger(
new BigInteger(value)), type);
594 case XQItemType.XQBASETYPE_QNAME:
595 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createQName(type.getSchemaURI().toString(), value), type);
597 case XQItemType.XQBASETYPE_SHORT:
598 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createShort(Short.parseShort(value)), type);
600 case XQItemType.XQBASETYPE_STRING:
601 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createString(value), type);
603 case XQItemType.XQBASETYPE_TIME:
604 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createTime(value), type);
606 case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
607 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedByte(Short.parseShort(value)), type);
609 case XQItemType.XQBASETYPE_UNSIGNED_INT:
610 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedInt(Long.parseLong(value)), type);
612 case XQItemType.XQBASETYPE_UNSIGNED_LONG:
613 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedLong(
new BigInteger(value)), type);
615 case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
616 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedShort(Integer.parseInt(value)), type);
618 case XQItemType.XQBASETYPE_YEARMONTHDURATION:
619 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value), type);
622 case XQItemType.XQBASETYPE_ANYATOMICTYPE:
623 case XQItemType.XQBASETYPE_ANYSIMPLETYPE:
624 case XQItemType.XQBASETYPE_ENTITY:
625 case XQItemType.XQBASETYPE_ENTITIES:
626 case XQItemType.XQBASETYPE_ANYTYPE:
627 case XQItemType.XQBASETYPE_LANGUAGE:
628 case XQItemType.XQBASETYPE_ID:
629 case XQItemType.XQBASETYPE_IDREF:
630 case XQItemType.XQBASETYPE_IDREFS:
631 case XQItemType.XQBASETYPE_NAME:
632 case XQItemType.XQBASETYPE_NMTOKEN:
633 case XQItemType.XQBASETYPE_NMTOKENS:
634 case XQItemType.XQBASETYPE_NORMALIZED_STRING:
635 case XQItemType.XQBASETYPE_NOTATION:
636 case XQItemType.XQBASETYPE_TOKEN:
637 case XQItemType.XQBASETYPE_UNTYPED:
638 case XQItemType.XQBASETYPE_UNTYPEDATOMIC:
639 throw new UnsupportedOperationException(
"Not supported yet.");
642 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createString(value), type);
645 }
catch (Exception e) {
646 throw new XQException (
"Error parsing value" + e.getLocalizedMessage());
667 isClosedXQException();
668 isNullXQException(value);
670 if ( ! ((type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_ELEMENT)||(type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT)) ) {
671 throw new XQException(
"Invalid type");
674 type = this.createElementType(null, XQItemType.XQBASETYPE_UNTYPED);
677 XmlDataManager dm = null;
681 dm = zorba.getXmlDataManager();
683 doc = dm.parseXMLtoItem(value);
684 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(doc);
685 }
catch (Exception e) {
686 throw new XQException(
"Error creating Item" + e.getLocalizedMessage());
707 isClosedXQException();
708 isNullXQException(value);
710 if ( ! ((type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_ELEMENT)||(type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT)) ) {
711 throw new XQException(
"Invalid type");
714 type = this.createElementType(null, XQItemType.XQBASETYPE_UNTYPED);
717 XmlDataManager dm = null;
721 dm = zorba.getXmlDataManager();
723 ZorbaReaderWrapper stream =
new ZorbaReaderWrapper(value);
724 doc = dm.parseXMLtoItem(stream);
725 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(doc);
726 }
catch (Exception e) {
727 throw new XQException(
"Error creating Item" + e.getLocalizedMessage());
748 isClosedXQException();
749 isNullXQException(value);
751 if ( ! ((type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_ELEMENT)||(type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT)) ) {
752 throw new XQException(
"Invalid type");
755 type = this.createElementType(null, XQItemType.XQBASETYPE_UNTYPED);
758 XmlDataManager dm = null;
762 dm = zorba.getXmlDataManager();
764 ZorbaInputWrapper stream =
new ZorbaInputWrapper(value);
765 doc = dm.parseXMLtoItem(stream);
766 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(doc);
767 }
catch (Exception e) {
768 throw new XQException(
"Error creating Item" + e.getLocalizedMessage());
788 isClosedXQException();
789 isNullXQException(value);
790 TransformerFactory tf = TransformerFactory.newInstance();
794 XMLOutputFactory xof = XMLOutputFactory.newInstance();
795 Writer writer =
new StringWriter();
797 XMLStreamWriter xmlStreamWriter = xof.createXMLStreamWriter(writer);
798 t = tf.newTransformer();
799 source =
new StAXSource(value);
800 result =
new StAXResult(xmlStreamWriter);
801 t.transform(source, result);
802 }
catch (Exception ex) {
803 throw new XQException(
"Error transforming xml expression" + ex.getLocalizedMessage());
809 private String nodeToString(Node node) {
810 StringWriter sw =
new StringWriter();
812 Transformer t = TransformerFactory.newInstance().newTransformer();
813 t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,
"yes");
814 t.transform(
new DOMSource(node),
new StreamResult(sw));
815 }
catch (TransformerException te) {
816 System.out.println(
"nodeToString Transformer Exception" + te.getLocalizedMessage());
818 return sw.toString();
841 isClosedXQException();
842 isNullXQException(value);
844 if (value instanceof StreamSource) {
846 }
else if (value instanceof SAXSource) {
848 }
else if (value instanceof DOMSource) {
851 throw new UnsupportedOperationException(
"Not supported yet.");
868 isClosedXQException();
869 isNullXQException(value);
870 if (value instanceof XQItem) {
871 return (XQItem)value;
874 ItemFactory itemFactory = zorba.getItemFactory();
878 if (value instanceof Boolean) {
880 }
else if (value instanceof Byte) {
882 }
else if (value instanceof Float) {
884 }
else if (value instanceof Double) {
886 }
else if (value instanceof Integer) {
888 }
else if (value instanceof Long) {
890 }
else if (value instanceof Short) {
892 }
else if (value instanceof String) {
894 }
else if (value instanceof BigDecimal) {
896 }
else if (value instanceof BigInteger) {
898 }
else if (value instanceof Duration) {
900 }
else if (value instanceof XMLGregorianCalendar) {
901 QName schType = ((XMLGregorianCalendar)value).getXMLSchemaType();
902 if (schType.equals(DatatypeConstants.GDAY)) {
904 }
else if (schType.equals(DatatypeConstants.GMONTHDAY)) {
906 }
else if (schType.equals(DatatypeConstants.GMONTH)) {
908 }
else if (schType.equals(DatatypeConstants.GYEAR)) {
910 }
else if (schType.equals(DatatypeConstants.GYEARMONTH)) {
912 }
else if (schType.equals(DatatypeConstants.DATETIME)) {
914 }
else if (schType.equals(DatatypeConstants.DATE)) {
916 }
else if (schType.equals(DatatypeConstants.TIME)) {
919 }
else if (value instanceof QName) {
921 }
else if (value instanceof Document) {
923 }
else if (value instanceof DocumentFragment) {
925 }
else if (value instanceof Element){
927 }
else if (value instanceof Attr) {
929 }
else if (value instanceof Comment) {
931 }
else if (value instanceof ProcessingInstruction) {
933 }
else if (value instanceof Text) {
940 switch (type.getItemKind()) {
941 case XQItemType.XQITEMKIND_ATOMIC:
942 switch (type.getBaseType()) {
943 case XQItemType.XQBASETYPE_BOOLEAN:
944 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createBoolean((Boolean)value), type);
946 case XQItemType.XQBASETYPE_ANYURI:
947 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createAnyURI(value.toString()), type);
949 case XQItemType.XQBASETYPE_BASE64BINARY:
950 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createBase64Binary(value.toString(), (value.toString()).length()), type);
952 case XQItemType.XQBASETYPE_BYTE:
953 if (value instanceof Byte) {
954 byte tmpByte = ((Byte)value).byteValue();
955 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createByte((char)tmpByte), type);
957 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createByte((value.toString()).charAt(0)), type);
960 case XQItemType.XQBASETYPE_DATE:
961 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDate(value.toString()), type);
963 case XQItemType.XQBASETYPE_DATETIME:
964 if (value.toString().contains(
":")) {
965 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDateTime(value.toString()), type);
967 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDate(value.toString()), type);
970 case XQItemType.XQBASETYPE_DAYTIMEDURATION:
971 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value.toString()), type);
973 case XQItemType.XQBASETYPE_DECIMAL:
974 if (value instanceof BigDecimal) {
975 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDecimal(((BigDecimal)value).toPlainString()), type);
977 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDecimal(value.toString()), type);
980 case XQItemType.XQBASETYPE_DOUBLE:
981 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDouble(value.toString()), type);
983 case XQItemType.XQBASETYPE_DURATION:
984 if (value instanceof Duration) {
985 Duration duration = (Duration)value;
986 Boolean daytime = duration.isSet(DatatypeConstants.DAYS) || duration.isSet(DatatypeConstants.HOURS) ||
987 duration.isSet(DatatypeConstants.MINUTES) || duration.isSet(DatatypeConstants.SECONDS);
988 Boolean yearmonth = duration.isSet(DatatypeConstants.YEARS) || duration.isSet(DatatypeConstants.MONTHS);
989 if (daytime && yearmonth){
990 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value.toString()), type);
991 }
else if (yearmonth) {
992 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createYearMonthDuration(value.toString()), type);
993 }
else if (daytime) {
994 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDayTimeDuration(value.toString()), type);
997 boolean yearMonth = value.toString().contains(
"Y") || value.toString().contains(
"M");
998 boolean dayTime = value.toString().contains(
"D") || value.toString().contains(
"T");
999 if (yearMonth && dayTime) {
1000 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value.toString()), type);
1001 }
else if (yearMonth) {
1002 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createYearMonthDuration(value.toString()), type);
1003 }
else if (dayTime) {
1004 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDayTimeDuration(value.toString()), type);
1008 case XQItemType.XQBASETYPE_FLOAT:
1009 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createFloat((Float)value), type);
1011 case XQItemType.XQBASETYPE_GDAY:
1012 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGDay(value.toString()), type);
1014 case XQItemType.XQBASETYPE_GMONTH:
1015 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGMonth(value.toString()), type);
1017 case XQItemType.XQBASETYPE_GMONTHDAY:
1018 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGMonthDay(value.toString()), type);
1020 case XQItemType.XQBASETYPE_GYEAR:
1021 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGYear(value.toString()), type);
1023 case XQItemType.XQBASETYPE_GYEARMONTH:
1024 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createGYearMonth(value.toString()), type);
1026 case XQItemType.XQBASETYPE_HEXBINARY:
1027 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createHexBinary(value.toString(), (value.toString()).length()), type);
1029 case XQItemType.XQBASETYPE_INT:
1030 case XQItemType.XQBASETYPE_INTEGER:
1031 if (value instanceof BigInteger) {
1032 BigInteger val = (BigInteger)value;
1033 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInteger(val.longValue()), type);
1034 }
else if (value instanceof Integer) {
1035 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInt((Integer)value), type);
1036 }
else if (value instanceof String) {
1037 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInteger(value.toString()), type);
1039 throw new XQException (
"Error parsing integer: " + value.toString());
1042 case XQItemType.XQBASETYPE_LONG:
1043 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createLong((Long)value), type);
1045 case XQItemType.XQBASETYPE_NCNAME:
1046 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNCName(value.toString()), type);
1048 case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
1049 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNegativeInteger((Long)value), type);
1051 case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
1052 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonNegativeInteger(
new BigInteger(value.toString())), type);
1054 case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
1055 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonPositiveInteger((Long)value), type);
1057 case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
1058 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createPositiveInteger(
new BigInteger(value.toString())), type);
1060 case XQItemType.XQBASETYPE_QNAME:
1061 if (value instanceof QName) {
1062 QName qname = (QName) value;
1063 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createQName(qname.getNamespaceURI(), qname.getPrefix(), qname.getLocalPart()), type);
1064 }
else if (value.toString().contains(
"{")) {
1065 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createQName(value.toString()), type);
1067 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createQName(
"", value.toString()), type);
1070 case XQItemType.XQBASETYPE_SHORT:
1071 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createShort((Short)value), type);
1073 case XQItemType.XQBASETYPE_STRING:
1074 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createString(value.toString()), type);
1076 case XQItemType.XQBASETYPE_TIME:
1077 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createTime(value.toString()), type);
1079 case XQItemType.XQBASETYPE_TOKEN:
1081 case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
1082 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedByte((Short)value), type);
1084 case XQItemType.XQBASETYPE_UNSIGNED_INT:
1085 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedInt((Long)value), type);
1087 case XQItemType.XQBASETYPE_UNSIGNED_LONG:
1088 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedLong(
new BigInteger(value.toString())), type);
1090 case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
1091 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedShort((Integer)value), type);
1093 case XQItemType.XQBASETYPE_YEARMONTHDURATION:
1094 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDuration(value.toString()), type);
1096 case XQItemType.XQBASETYPE_ANYATOMICTYPE:
1097 case XQItemType.XQBASETYPE_ANYSIMPLETYPE:
1098 case XQItemType.XQBASETYPE_ANYTYPE:
1099 case XQItemType.XQBASETYPE_ENTITIES:
1100 case XQItemType.XQBASETYPE_ENTITY:
1101 case XQItemType.XQBASETYPE_ID:
1102 case XQItemType.XQBASETYPE_IDREF:
1103 case XQItemType.XQBASETYPE_IDREFS:
1104 case XQItemType.XQBASETYPE_LANGUAGE:
1105 case XQItemType.XQBASETYPE_NAME:
1106 case XQItemType.XQBASETYPE_NMTOKEN:
1107 case XQItemType.XQBASETYPE_NMTOKENS:
1108 case XQItemType.XQBASETYPE_NORMALIZED_STRING:
1109 case XQItemType.XQBASETYPE_NOTATION:
1110 case XQItemType.XQBASETYPE_UNTYPED:
1111 case XQItemType.XQBASETYPE_UNTYPEDATOMIC:
1112 throw new XQException (
"Base type not supported yet.");
1114 throw new XQException (
"Unable to determine XQBASETYPE.");
1117 case XQItemType.XQITEMKIND_ATTRIBUTE:
1118 if (value instanceof Attr){
1119 Attr attribute = (Attr) value;
1120 Item iEmpty =
new Item();
1121 Item nodeName = itemFactory.createQName(attribute.getNamespaceURI()==null?
"":attribute.getNamespaceURI(),
1122 attribute.getPrefix()==null?
"":attribute.getPrefix(),
1123 attribute.getName()==null?
"":attribute.getName());
1124 Item nodeValue = null;
1125 if (!attribute.getValue().isEmpty()) {
1126 nodeValue = itemFactory.createQName(attribute.getNamespaceURI()==null?
"":attribute.getNamespaceURI(),
1127 attribute.getPrefix()==null?
"":attribute.getPrefix(),
1128 attribute.getValue()==null?
"":attribute.getValue());
1130 nodeValue =
new Item();
1133 Item iUntyped = itemFactory.createQName(
"http://www.w3.org/2001/XMLSchema",
"xs",
"untyped");
1134 Item attributeNode = itemFactory.createAttributeNode(iEmpty, nodeName, iUntyped, nodeValue);
1135 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(attributeNode, type);
1138 case XQItemType.XQITEMKIND_COMMENT:
1139 if (value instanceof Comment){
1140 Comment comment = (Comment) value;
1141 Item iEmpty =
new Item();
1142 Item elementNode = itemFactory.createCommentNode(iEmpty, comment.getTextContent());
1143 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(elementNode, type);
1145 Item iEmpty =
new Item();
1146 Item elementNode = itemFactory.createCommentNode(iEmpty, value.toString());
1147 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(elementNode, type);
1150 case XQItemType.XQITEMKIND_DOCUMENT:
1151 if ((value instanceof Document) || (value instanceof DocumentFragment)){
1152 DOMSource source = null;
1153 if (value instanceof Document) {
1154 source =
new DOMSource((Document)value);
1156 source =
new DOMSource((DocumentFragment)value);
1159 Transformer transformer = TransformerFactory.newInstance().newTransformer();
1160 transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,
"yes");
1161 StreamResult result =
new StreamResult(
new StringWriter());
1163 transformer.transform(source, result);
1164 String xmlString = result.getWriter().toString();
1165 Item tmpItem =
new Item();
1166 if (xmlString.length()>0) {
1167 XmlDataManager dataManager = zorba.getXmlDataManager();
1168 tmpItem = dataManager.parseXMLtoItem(xmlString);
1170 tmpItem = itemFactory.createDocumentNode(
"",
"");
1173 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(tmpItem, type);
1177 case XQItemType.XQITEMKIND_ELEMENT:
1178 if (value instanceof Element){
1179 Element element = (Element) value;
1180 Item iEmpty =
new Item();
1181 Item nodeName = itemFactory.createQName(element.getNamespaceURI()==null?
"":element.getNamespaceURI(),
1182 element.getPrefix()==null?
"":element.getPrefix(),
1183 element.getNodeName()==null?
"":element.getNodeName());
1184 Item iUntyped = itemFactory.createQName(
"http://www.w3.org/2001/XMLSchema",
"xs",
"untyped");
1185 Item elementNode = itemFactory.createElementNode(iEmpty, nodeName, iUntyped,
false,
false);
1186 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(elementNode, type);
1189 case XQItemType.XQITEMKIND_PI:
1190 if (value instanceof ProcessingInstruction){
1191 ProcessingInstruction pi = (ProcessingInstruction) value;
1192 Item iEmpty =
new Item();
1193 Item elementNode = itemFactory.createPiNode(iEmpty,
1195 pi.getTextContent(),
1196 pi.getBaseURI()==null?
"":pi.getBaseURI());
1197 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(elementNode, type);
1200 case XQItemType.XQITEMKIND_TEXT:
1201 if (value instanceof Text){
1202 Text text = (Text) value;
1203 Item iEmpty =
new Item();
1204 Item elementNode = itemFactory.createTextNode(iEmpty, text.getWholeText());
1205 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(elementNode, type);
1208 case XQItemType.XQITEMKIND_DOCUMENT_ELEMENT:
1209 case XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT:
1210 case XQItemType.XQITEMKIND_ITEM:
1211 case XQItemType.XQITEMKIND_NODE:
1212 case XQItemType.XQITEMKIND_SCHEMA_ATTRIBUTE:
1213 case XQItemType.XQITEMKIND_SCHEMA_ELEMENT:
1214 throw new XQException (
"This item kind is currently unsupported.");
1216 throw new XQException (
"Unable to determine XQITEMKIND.");
1218 }
catch (Exception e) {
1219 throw new XQException (
"Error parsing value" + e.getLocalizedMessage());
1226 isClosedXQException();
1230 if (type.getBaseType() != XQItemType.XQBASETYPE_BOOLEAN) {
1231 throw new XQException(
"Type is not boolean, use proper method");
1236 ItemFactory itemFactory = zorba.getItemFactory();
1237 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createBoolean(bln));
1238 }
catch (Exception e) {
1239 throw new XQException(
"Error creating new item");
1244 private XQItem createDecimal(BigDecimal value, XQItemType type)
throws XQException {
1247 ItemFactory itemFactory = zorba.getItemFactory();
1248 switch (type.getBaseType()) {
1249 case XQItemType.XQBASETYPE_BYTE:
1250 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createByte((char)value.byteValue()), type);
1252 case XQItemType.XQBASETYPE_INTEGER:
1253 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInteger(value.longValue()), type);
1255 case XQItemType.XQBASETYPE_DECIMAL:
1256 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDecimalFromLong(value.longValue()), type);
1258 case XQItemType.XQBASETYPE_INT:
1259 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createInt(value.intValue()), type);
1261 case XQItemType.XQBASETYPE_LONG:
1262 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createLong(value.longValue()), type);
1264 case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
1265 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNegativeInteger(value.longValue()), type);
1267 case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
1268 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonNegativeInteger(value.toBigInteger()), type);
1270 case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
1271 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createNonPositiveInteger(value.longValue()), type);
1273 case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
1274 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createPositiveInteger(value.toBigInteger()), type);
1276 case XQItemType.XQBASETYPE_SHORT:
1277 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createShort(value.shortValue()), type);
1279 case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
1280 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedByte(value.shortValue()), type);
1282 case XQItemType.XQBASETYPE_UNSIGNED_INT:
1283 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedInt(value.longValue()), type);
1285 case XQItemType.XQBASETYPE_UNSIGNED_LONG:
1286 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createUnsignedLong(value.toBigInteger()), type);
1288 case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
1289 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createShort(value.shortValue()), type);
1292 throw new XQException(
"Type is not xs:decimal or a derivate.");
1294 }
catch (Exception e) {
1295 throw new XQException(
"Error creating Item: " + e.getLocalizedMessage());
1311 isClosedXQException();
1315 return createDecimal(
new BigDecimal(b), type);
1329 isClosedXQException();
1333 if (type.getBaseType() != XQItemType.XQBASETYPE_DOUBLE) {
1334 throw new XQException(
"Type is not double, use proper method");
1338 ItemFactory itemFactory = zorba.getItemFactory();
1339 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createDouble(value), type);
1340 }
catch (Exception e) {
1341 throw new XQException(
"Error Creating Item From Double" + e.getLocalizedMessage());
1357 isClosedXQException();
1361 if (type.getBaseType() != XQItemType.XQBASETYPE_FLOAT) {
1362 throw new XQException(
"Type is not float, use proper method");
1366 ItemFactory itemFactory = zorba.getItemFactory();
1367 item =
new org.zorbaxquery.api.xqj.ZorbaXQItem(itemFactory.createFloat(value), type);
1368 }
catch (Exception e) {
1369 throw new XQException(
"Error Creating Item From Float" + e.getLocalizedMessage());
1385 isClosedXQException();
1389 switch (type.getBaseType()) {
1390 case XQItemType.XQBASETYPE_BYTE:
1391 case XQItemType.XQBASETYPE_SHORT:
1392 throw new XQException(
"Can't downgrade the Base Type from an Int number");
1396 return createDecimal(
new BigDecimal(value), type);
1410 isClosedXQException();
1414 switch (type.getBaseType()) {
1415 case XQItemType.XQBASETYPE_BYTE:
1416 case XQItemType.XQBASETYPE_SHORT:
1417 case XQItemType.XQBASETYPE_INT:
1418 throw new XQException(
"Can't downgrade the Base Type from an Long number");
1422 return createDecimal(
new BigDecimal(value), type);
1436 isClosedXQException();
1437 isNullXQException(value);
1439 XQItem result = null;
1442 }
catch( Exception e ) {
1443 throw new XQException(
"Error Creating Item From Node" + e.getLocalizedMessage());
1459 isClosedXQException();
1463 if (type.getBaseType()==XQItemType.XQBASETYPE_BYTE) {
1464 throw new XQException(
"Can't create a Byte from a Short number");
1466 return createDecimal(
new BigDecimal(value), type);
1479 isClosedXQException();
1480 isNullXQException(value);
1481 if (value.isClosed()) {
1482 throw new XQException(
"Item is closed.");
1484 XQItem result =
new org.zorbaxquery.api.xqj.ZorbaXQItem(value);
1498 isClosedXQException();
1499 isNullXQException(value);
1500 if (value.isClosed()) {
1501 throw new XQException(
"Sequence is closed.");
1503 XQSequence result = null;
1506 }
catch (Exception ex) {
1507 throw new XQException(
"Error creating sequence: " + ex.getLocalizedMessage());
1522 isClosedXQException();
1523 isNullXQException(value);
1524 XQSequence result = null;
1527 }
catch (Exception ex) {
1528 throw new XQException(
"Error creating sequence: " + ex.getLocalizedMessage());
1549 isClosedXQException();
1550 if ((basetype==XQItemType.XQBASETYPE_UNTYPED) ||
1551 (basetype==XQItemType.XQBASETYPE_ANYTYPE) ||
1552 (basetype==XQItemType.XQBASETYPE_IDREFS) ||
1553 (basetype==XQItemType.XQBASETYPE_NMTOKENS) ||
1554 (basetype==XQItemType.XQBASETYPE_ENTITIES) ||
1555 (basetype==XQItemType.XQBASETYPE_ANYSIMPLETYPE)) {
1556 throw new XQException(
"Invalid base type.");
1581 throw new XQException(
"Object closed");
1583 if ((basetype==XQItemType.XQBASETYPE_UNTYPED) ||
1584 (basetype==XQItemType.XQBASETYPE_ANYTYPE) ||
1585 (basetype==XQItemType.XQBASETYPE_IDREFS) ||
1586 (basetype==XQItemType.XQBASETYPE_NMTOKENS) ||
1587 (basetype==XQItemType.XQBASETYPE_ENTITIES) ||
1588 (basetype==XQItemType.XQBASETYPE_ANYSIMPLETYPE)) {
1589 throw new XQException(
"Invalid base type.");
1632 isClosedXQException();
1633 if ((basetype==XQItemType.XQBASETYPE_UNTYPED)||(basetype==XQItemType.XQBASETYPE_ANYTYPE)) {
1634 throw new XQException(
"Base Type can't be XQItemType.XQBASETYPE_UNTYPED or XQItemType.XQBASETYPE_ANYTYPE");
1684 public XQItemType
createAttributeType(QName nodename,
int basetype, QName
typename, URI schemaURI)
throws XQException {
1685 isClosedXQException();
1686 if ((basetype==XQItemType.XQBASETYPE_UNTYPED)||(basetype==XQItemType.XQBASETYPE_ANYTYPE)) {
1687 throw new XQException(
"Base Type can't be XQItemType.XQBASETYPE_UNTYPED or XQItemType.XQBASETYPE_ANYTYPE");
1689 if ((schemaURI!=null) && (
typename==null)) {
1690 throw new XQException(
"If Schema URI is specified, Base Type must be also specified");
1717 isClosedXQException();
1744 isClosedXQException();
1758 isClosedXQException();
1759 isNullXQException(elementType);
1760 if (elementType.getItemKind()!=XQItemType.XQITEMKIND_ELEMENT) {
1761 throw new XQException(
"Item Kind must be XQItemType.XQITEMKIND_ELEMENT");
1776 isClosedXQException();
1777 if (elementType.getItemKind()!=XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT) {
1778 throw new XQException(
"Item Kind must be XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT");
1792 isClosedXQException();
1832 isClosedXQException();
1895 public XQItemType
createElementType(QName nodename,
int baseType, QName
typename, URI schemaURI,
boolean allowNill)
throws XQException {
1896 isClosedXQException();
1921 isClosedXQException();
1940 isClosedXQException();
1954 isClosedXQException();
1990 isClosedXQException();
2004 isClosedXQException();
2005 if ( ((item==null) && (occurence != XQSequenceType.OCC_EMPTY)) || ((item!=null) && (occurence == XQSequenceType.OCC_EMPTY))) {
2006 throw new XQException(
"Item is null");
2008 if (!((occurence == XQSequenceType.OCC_ZERO_OR_ONE) ||
2009 (occurence == XQSequenceType.OCC_EXACTLY_ONE) ||
2010 (occurence == XQSequenceType.OCC_ZERO_OR_MORE) ||
2011 (occurence == XQSequenceType.OCC_ONE_OR_MORE) ||
2012 (occurence == XQSequenceType.OCC_EMPTY))) {
2013 throw new XQException(
"Occurence must be from: OCC_ZERO_OR_ONE, OCC_EXACTLY_ONE, OCC_ZERO_OR_MORE, OCC_ONE_OR_MORE, OCC_EMPTY ");
2029 isClosedXQException();
2034 private void isClosedXQException() throws XQException {
2036 throw new XQException(
"This connection is closed");
2039 private void isNullXQException(Object value)
throws XQException {
2041 throw new XQException(
"Parameter shouldn't be null");
XQItem createItemFromAtomicValue(String value, XQItemType type)
Creates an item from a given value.
XQItemType createElementType(QName nodename, int baseType)
Creates a new ZorbaXQItemType object representing the XQuery element(nodename, basetype) type...
XQItemType createDocumentSchemaElementType(XQItemType elementType)
Creates a new ZorbaXQItemType object representing the XQuery document-node(elementType) type containi...
XQItemType createElementType(QName nodename, int baseType, QName typename, URI schemaURI, boolean allowNill)
Creates a new ZorbaXQItemType object representing the XQuery element(nodename,basetype,typename,schemaURI, allowNill) type, given the node name, base type, schema type name, schema URI, and nilled check.
XQItem createItemFromFloat(float value, XQItemType type)
Creates an item from a given value.
An ZorbaXQStaticContext represents default values for various XQuery Static Context Components...
XQExpression createExpression(XQStaticContext value)
Creates a new ZorbaXQExpression object that can be used to perform execute immediate operations with ...
ZorbaXQXmlDataManager getXmlDataManager()
An ZorbaXQDataSource is a factory for ZorbaXQConnection objects.
XQItem createItemFromInt(int value, XQItemType type)
Creates an item from a given value.
A connection (session) with a specific XQuery engine.
XQSequence createSequence(XQSequence value)
Creates a copy of the specified ZorbaXQSequence.
XQItem createItemFromShort(short value, XQItemType type)
Creates an item from a given value.
XQItemType createNodeType()
Creates a new ZorbaXQItemType object representing the XQuery node() type.
This class describes an expression that can be prepared for multiple subsequent executions.
The ZorbaXQSequenceType interface represents a sequence type as XQuery 1.0: An XML Query language...
XQItem createItemFromDocument(String value, String baseURI, XQItemType type)
Creates an item from the given value.
XQSequenceType createSequenceType(XQItemType item, int occurence)
Creates a new sequence type from an item type and occurence indicator.
ZorbaXQConnection(Properties aProperties)
XQItem createItemFromNode(Node value, XQItemType type)
Creates an item from a given value.
XQItem createItemFromLong(long value, XQItemType type)
Creates an item from a given value.
static final String ZORBA_PROPERTIES_URI_PATHS
static final String ZORBA_PROPERTIES_LIB_PATHS
void close()
Closes the connection.
XQItemType createCommentType()
Creates a new ZorbaXQItemType object representing the XQuery comment() type.
This interface describes the execute immediate functionality for expressions.
XQPreparedExpression prepareExpression(Reader reader, XQStaticContext xqsc)
Prepares an expression for execution.
boolean getAutoCommit()
Gets the auto-commit attribute of this connection.
The ZorbaXQItemType class represents an item type as defined in XQuery 1.0: An XML Query language...
XQItemType createProcessingInstructionType(String piTarget)
Creates a new ZorbaXQItemType object representing the XQuery processing-instruction(piTarget) type...
XQItem createItemFromObject(Object value, XQItemType type)
Creates an item from a given value.
XQItem createItemFromDocument(XMLStreamReader value, XQItemType type)
Creates an item from the given value.
XQMetaData getMetaData()
Gets the metadata for this connection.
XQItemType createAttributeType(QName nodename, int basetype, QName typename, URI schemaURI)
Creates a new ZorbaXQItemType object representing the XQuery attribute(nodename, basetype) type with ...
XQPreparedExpression prepareExpression(InputStream in, XQStaticContext xqsc)
Prepares an expression for execution.
void setAutoCommit(boolean bln)
XQPreparedExpression prepareExpression(InputStream in)
Prepares an expression for execution.
static final String ZORBA_PROPERTIES_MODULE_PATHS
XQItem createItemFromDouble(double value, XQItemType type)
Creates an item from a given value.
XQPreparedExpression prepareExpression(String value)
Prepares an expression for execution.
XQItemType createDocumentElementType(XQItemType elementType)
Creates a new ZorbaXQItemType object representing the XQuery document-node(elementType) type containi...
XQItem createItemFromDocument(InputStream value, String baseURI, XQItemType type)
Creates an item from the given value.
void commit()
Makes all changes made in the current transaction permanent and releases any locks held by the dataso...
XQItemType createSchemaAttributeType(QName nodename, int basetype, URI uri)
Creates a new ZorbaXQItemType object representing the XQuery schema-attribute(nodename,basetype,schemaURI) type, with the given node name, base type, and schema URI.
boolean isClosed()
Checks if the connection is closed.
XQItem createItemFromBoolean(boolean bln, XQItemType type)
This interface represents a sequence of items as defined in the XDM.
XQItem createItemFromString(String value, XQItemType type)
Creates an item from a given value.
XQSequence createSequence(Iterator value)
Creates an ZorbaXQSequence, containing all the items from the iterator.
XQItem createItemFromByte(byte b, XQItemType type)
Creates an item from a given value.
XQItemType createAttributeType(QName nodename, int basetype)
Creates a new ZorbaXQItemType object representing the XQuery attribute(nodename, basetype) type with ...
XQItemType createSchemaElementType(QName nodename, int baseType, URI schemaURI)
Creates a new ZorbaXQItemType object representing the XQuery schema-element(nodename,basetype,schemaURI) type, given the node name, base type, and the schema URI.
XQItemType createDocumentType()
Creates a new ZorbaXQItemType object representing the XQuery document-node() type.
void rollback()
Undoes all changes made in the current transaction and releases any locks held by the datasource...
XQItemType createAtomicType(int basetype, QName qname, URI uri)
Creates a new ZorbaXQItemType object representing an XQuery atomic type.
XQItem createItem(XQItem value)
Creates a copy of the specified ZorbaXQItem.
XQItemType createItemType()
Creates a new ZorbaXQItemType object representing the XQuery item type.
XQItem createItemFromDocument(Reader value, String baseURI, XQItemType type)
Creates an item from the given value.
void setStaticContext(XQStaticContext xqsc)
Sets the default values for all expression properties.
XQPreparedExpression prepareExpression(Reader reader)
Prepares an expression for execution.
XQStaticContext getStaticContext()
Gets an ZorbaXQStaticContext representing the default values for all expression properties.
XQPreparedExpression prepareExpression(String string, XQStaticContext xqsc)
Prepares an expression for execution.
XQItemType createAtomicType(int basetype)
Creates a new ZorbaXQItemType object representing an XQuery atomic type.
XQExpression createExpression()
Creates a new ZorbaXQExpression object that can be used to perform execute immediate operations with ...
XQItem createItemFromDocument(Source value, XQItemType type)
Creates an item from the given value.
Using the ZorbaXQXmlDataManager one can manage documents and collections.
XQItemType createTextType()
Creates a new ZorbaXQItemType object representing the XQuery text() type.