Merge lp:~zorba-coders/zorba/markos-scratch into lp:zorba

[Markos Zaharioudakis]

Fixed bug when inserting consecutive text nodes in an xml tree (fix provided by Joel de Poter) + storing the schema type code inside the atomic items themselves.

Fixed bug when inserting consecutive text nodes in an xml tree (fix provided by Joel de Poter) + storing the schema type code inside the atomic items themselves.

[lp:~zorba-coders/zorba/markos-scratch]

11009. By Markos Zaharioudakis on 2013-01-16

store the shema type code inside the atomic item itself + fixed bug found by joel when inserting consecutive text nodes in an xml tree

11010. By Markos Zaharioudakis on 2013-01-16

merge from trunk

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2013-01-17T15-54-28.717Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job markos-scratch-2013-01-17T15-54-28.717Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp'
--- src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp	2012-11-17 01:08:54 +0000
+++ src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp	2013-01-16 16:58:20 +0000
@@ -112,7 +112,9 @@
 
   // If $arg is the empty sequence, then the result is the empty sequence.
   if (!consumeNext(item0, theChild.getp(), planState))
+  {
     STACK_PUSH(false, state);
+  }
   else
   {
     try
@@ -124,10 +126,26 @@
     {
       throw XQUERY_EXCEPTION(err::FODT0003, ERROR_PARAMS(e.get_tz_seconds()));
     }
-    STACK_PUSH(GENV_ITEMFACTORY->createDateTime(result, dt.get()), state);
+
+    if (item0->getTypeCode() == store::XS_DATETIME)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createDateTime(result, dt.get()), state);
+    }
+    else if (item0->getTypeCode() == store::XS_DATE)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createDate(result, dt.get()), state);
+    }
+    else if (item0->getTypeCode() == store::XS_TIME)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createTime(result, dt.get()), state);
+    }
+    else
+    {
+      ZORBA_ASSERT(false);
+    }
   }
 
-  STACK_END (state);
+  STACK_END(state);
 }
 
 
@@ -143,7 +161,9 @@
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
   if (!consumeNext(item0, theChild0.getp(), planState))
+  {
     STACK_PUSH(false, state);
+  }
   else
   {
     s1 = consumeNext(item1, theChild1.getp(), planState);
@@ -155,12 +175,29 @@
     {
       throw XQUERY_EXCEPTION(err::FODT0003, ERROR_PARAMS(e.get_tz_seconds()));
     }
-    STACK_PUSH(GENV_ITEMFACTORY->createDateTime(result, dt.get()), state);
+
+    if (item0->getTypeCode() == store::XS_DATETIME)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createDateTime(result, dt.get()), state);
+    }
+    else if (item0->getTypeCode() == store::XS_DATE)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createDate(result, dt.get()), state);
+    }
+    else if (item0->getTypeCode() == store::XS_TIME)
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createTime(result, dt.get()), state);
+    }
+    else
+    {
+      ZORBA_ASSERT(false);
+    }
   }
 
-  STACK_END (state);
+  STACK_END(state);
 }
 
+
 /**
  *______________________________________________________________________
  *

=== modified file 'src/runtime/nodes/node_position_impl.cpp'
--- src/runtime/nodes/node_position_impl.cpp	2012-09-19 21:16:15 +0000
+++ src/runtime/nodes/node_position_impl.cpp	2013-01-16 16:58:20 +0000
@@ -24,8 +24,6 @@
 #include "store/api/iterator.h"
 #include "store/api/item_factory.h"
 #include "store/api/store.h"
-#include "store/naive/atomic_items.h"
-#include "store/naive/ordpath.h"
 
 #include "util/string_util.h"
 #include "util/uri_util.h"

=== modified file 'src/store/api/item.h'
--- src/store/api/item.h	2012-12-14 13:23:51 +0000
+++ src/store/api/item.h	2013-01-16 16:58:20 +0000
@@ -54,15 +54,15 @@
 public:
   enum ItemKind
   {
-    NODE       = 0x10,
-    ATOMIC     = 0x21,
-    PUL        = 0x41, 
-    FUNCTION   = 0x81,
-    LIST       = 0x101,
+    NODE       = 0x0,
+    ATOMIC     = 0x1,
+    PUL        = 0x3, 
+    FUNCTION   = 0x5,
+    LIST       = 0x7,
 #ifdef ZORBA_WITH_JSON
-    JSONIQ     = 0x201,
+    JSONIQ     = 0x9,
 #endif
-    ERROR_     = 0x401
+    ERROR_     = 0xB
   };
 
 protected:
@@ -110,51 +110,73 @@
   /**
    * @return the kind of the item
    */
-  ItemKind getKind() const;
+  ItemKind getKind() const
+  {
+    if ((reinterpret_cast<uint64_t>(theUnion.treeRCPtr) & 0x1) == 0)
+      return NODE;
+
+    return static_cast<ItemKind>(theUnion.itemKind & 0xF);
+  }
 
   /**
    *  @return  "true" if the item is a node
    */
-  bool 
-  isNode() const;
+  bool isNode() const 
+  {
+    return ((reinterpret_cast<uint64_t>(theUnion.treeRCPtr) & 0x1) == 0 &&
+            theUnion.treeRCPtr != 0);
+  }
 
 #ifdef ZORBA_WITH_JSON
   /**
    *  @return  "true" if the item is a JSON item
    */
-  bool
-  isJSONItem() const;
+  bool isJSONItem() const
+  {
+    return ((theUnion.itemKind & 0xF) == JSONIQ); 
+  }
 #endif
 
   /**
    *  @return  "true" if the item is an atomic value
    */
-  bool 
-  isAtomic() const;
+  bool isAtomic() const 
+  {
+    return ((theUnion.itemKind & 0xF) == ATOMIC); 
+  }
 
   /**
    * @return  "true" if the item is an list of atomic values
    */
-  bool 
-  isList() const;
+  bool isList() const
+  {
+    return ((theUnion.itemKind & 0xF) == LIST); 
+  }
 
   /**
    *  @return  "true" if the item is a pending update list
    */
-  bool 
-  isPul() const;
+  bool isPul() const
+  {
+    return ((theUnion.itemKind & 0xF) == PUL);
+  }
 
   /**
    * @return "true" if the item is an error.
    */
-  bool
-  isError() const;
+  bool isError() const
+  {
+    return ((theUnion.itemKind & 0xF) == ERROR_);
+  }
 
   /**
    * @return "true" if the item is a function.
    */
-  bool
-  isFunction() const;
+  bool isFunction() const
+  {
+    return ((theUnion.itemKind & 0xF) == FUNCTION);
+  }
+
 
   /**
    * @return a string representation of the item's kind
@@ -176,7 +198,7 @@
 #endif
 
   /**
-   *  @return  (dynamic) XQuery type of the item
+   *  @return the qname identifying the XQuery type of the item
    */
   virtual Item*
   getType() const;
@@ -193,7 +215,7 @@
    * @return The hash value
    */
   virtual uint32_t 
-  hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
+  hash(long timezone = 0, const XQPCollator* collation = 0) const;
   
   /**
    * Compares (by value) two items for equality. 
@@ -206,7 +228,7 @@
    *         the table of http://www.w3.org/TR/xquery/#mapping.  
    */
   virtual bool 
-  equals(const Item*, long timezone = 0, const XQPCollator* aCollation = 0) const;
+  equals(const Item*, long timezone = 0, const XQPCollator* collation = 0) const;
 
   /**
    *  Compares (by value) two items, returning < 0 if "this" is less than "other",
@@ -223,7 +245,7 @@
    *         or xs:float and at leat one of the items is NaN.
    */
   virtual long
-  compare(const Item* other, long timezone = 0, const XQPCollator* aCollation = 0) const;
+  compare(const Item* other, long timezone = 0, const XQPCollator* collation = 0) const;
   
   /**
    *  Computes the Effective Boolean Value for that item as specified in the
@@ -278,7 +300,7 @@
   /**
    * @return The numeric code coresponding to the data type of this item.
    */
-  virtual SchemaTypeCode getTypeCode() const;
+  SchemaTypeCode getTypeCode() const;
 
   /**
    * @return If this is an atomic item with a user-defined data type UT, return

=== modified file 'src/store/naive/atomic_items.cpp'
--- src/store/naive/atomic_items.cpp	2013-01-10 19:24:23 +0000
+++ src/store/naive/atomic_items.cpp	2013-01-16 16:58:20 +0000
@@ -626,8 +626,13 @@
 /*******************************************************************************
   class QNameItem
 ********************************************************************************/
-QNameItem::QNameItem(const char* ns, const char* prefix, const char* local)
+QNameItem::QNameItem(
+    store::SchemaTypeCode t,
+    const char* ns,
+    const char* prefix,
+    const char* local)
   :
+  AtomicItem(t),
   theNormalizedQName(NULL),
   theIsInPool(false)
 {
@@ -635,8 +640,13 @@
 }
 
 
-QNameItem::QNameItem(const zstring& ns, const zstring& prefix, const zstring& local)
+QNameItem::QNameItem(
+    store::SchemaTypeCode t,
+    const zstring& ns,
+    const zstring& prefix,
+    const zstring& local)
   :
+  AtomicItem(t),
   theNormalizedQName(NULL),
   theIsInPool(false)
 {
@@ -802,14 +812,18 @@
   return res;
 }
 
+
 /*******************************************************************************
   class NotationItem
 ********************************************************************************/
 
 NotationItem::NotationItem(
+    store::SchemaTypeCode t,
     const zstring& nameSpace,
     const zstring& prefix,
     const zstring& localName)
+  :
+  AtomicItem(t)
 {
   store::Item_t temp;
   GET_FACTORY().createQName(temp, nameSpace, prefix, localName);
@@ -817,7 +831,9 @@
 }
 
 
-NotationItem::NotationItem(store::Item* qname)
+NotationItem::NotationItem(store::SchemaTypeCode t, store::Item* qname)
+  :
+  AtomicItem(t)
 {
   theQName = qname;
 }
@@ -1113,11 +1129,13 @@
 ********************************************************************************/
 
 StructuralAnyUriItem::StructuralAnyUriItem(
+    store::SchemaTypeCode t,
     ulong collectionId,
     const TreeId& treeId, 
     store::StoreConsts::NodeKind nodeKind,
     const OrdPath& ordPath)
   :
+  AtomicItem(t),
   theCollectionId(collectionId),
   theTreeId(treeId),
   theNodeKind(nodeKind),
@@ -1127,7 +1145,9 @@
 }
 
 
-StructuralAnyUriItem::StructuralAnyUriItem(zstring& value)
+StructuralAnyUriItem::StructuralAnyUriItem(store::SchemaTypeCode t, zstring& value)
+  :
+  AtomicItem(t)
 {
   if (value == "")
     throw ZORBA_EXCEPTION(zerr::ZAPI0028_INVALID_NODE_URI,
@@ -1876,9 +1896,12 @@
   class StreamableStringItem
 ********************************************************************************/
 StreamableStringItem::StreamableStringItem(
+    store::SchemaTypeCode t,
     std::istream& aStream,
     StreamReleaser streamReleaser,
-    bool seekable) :
+    bool seekable) 
+  :
+  StringItem(t),
   theIstream(aStream),
   theIsMaterialized(false),
   theIsConsumed(false),
@@ -1889,7 +1912,10 @@
 }
 
 StreamableStringItem::StreamableStringItem(
-    store::Item_t& aStreamableDependent) :
+    store::SchemaTypeCode t,
+    store::Item_t& aStreamableDependent)
+  :
+  StringItem(t),
   theIstream(aStreamableDependent->getStream()),
   theIsMaterialized(false),
   theIsConsumed(false),
@@ -2251,40 +2277,6 @@
 }
 
 
-store::SchemaTypeCode DateTimeItem::getTypeCode() const
-{
-  switch (theValue.getFacet())
-  {
-  case DateTime::GYEARMONTH_FACET:
-    return store::XS_GYEAR_MONTH;
-
-  case DateTime::GYEAR_FACET:
-    return store::XS_GYEAR;
-
-  case DateTime::GMONTH_FACET:
-    return store::XS_GMONTH;
-
-  case DateTime::GMONTHDAY_FACET:
-    return store::XS_GMONTH_DAY;
-
-  case DateTime::GDAY_FACET:
-    return store::XS_GDAY;
-
-  case DateTime::DATE_FACET:
-    return store::XS_DATE;
-
-  case DateTime::TIME_FACET:
-    return store::XS_TIME;
-
-  case DateTime::DATETIME_FACET:
-    return store::XS_DATETIME;
-
-  default:
-    ZORBA_ASSERT(false);
-  }
-}
-
-
 store::Item* DateTimeItem::getType() const
 {
   return GET_STORE().theSchemaTypeNames[getTypeCode()];
@@ -2414,23 +2406,6 @@
 }
 
 
-store::SchemaTypeCode DurationItem::getTypeCode() const
-{
-  switch (theValue.getFacet())
-  {
-  case Duration::DURATION_FACET:
-    return store::XS_DURATION;
-
-  case Duration::DAYTIMEDURATION_FACET:
-    return store::XS_DT_DURATION;
-
-  case Duration::YEARMONTHDURATION_FACET:
-  default:
-    return store::XS_YM_DURATION;
-  }
-}
-
-
 store::Item* DurationItem::getType() const
 {
   return GET_STORE().theSchemaTypeNames[getTypeCode()];

=== modified file 'src/store/naive/atomic_items.h'
--- src/store/naive/atomic_items.h	2012-10-08 12:09:36 +0000
+++ src/store/naive/atomic_items.h	2013-01-16 16:58:20 +0000
@@ -74,7 +74,10 @@
   SYNC_CODE(mutable RCLock  theRCLock;)
 
 public:
-  AtomicItem() : store::Item(ATOMIC) { }
+  AtomicItem(store::SchemaTypeCode t) : store::Item(ATOMIC)
+  {
+    theUnion.itemKind |= (t << 4);
+  }
 
   virtual ~AtomicItem() {}
 
@@ -103,48 +106,40 @@
   store::Item_t  theTypeName;
 
 protected:
-  UserTypedAtomicItem(
-        store::Item_t& baseItem,
-        store::Item_t& typeName)
+  UserTypedAtomicItem(store::Item_t& baseItem, store::Item_t& typeName)
+    :
+    AtomicItem(baseItem->getTypeCode())
   {
     theBaseItem.transfer(baseItem);
     theTypeName.transfer(typeName);
   }
 
-  UserTypedAtomicItem() {}
+  //UserTypedAtomicItem() {}
 
 public:
   store::Item* getBaseItem() const;
 
-  store::SchemaTypeCode getTypeCode() const { return theBaseItem->getTypeCode(); }
-
   store::Item* getType() const { return theTypeName.getp(); }
 
-  uint32_t hash(long timezone = 0, const XQPCollator* collation = 0) const
-  {
-    return theBaseItem->hash(timezone, collation);
-  }
-
-  bool equals(
-        const store::Item* other,
-        long timezone = 0,
-        const XQPCollator* collation = 0) const
-  {
-    if (other->getBaseItem() == NULL)
-      return theBaseItem->equals(other, timezone, collation);
-    else
-      return theBaseItem->equals(other->getBaseItem(), timezone, collation);
-  }
-
-  long compare(
-        const store::Item* other,
-        long timezone = 0,
-        const XQPCollator* collation = 0) const
-  {
-    if (other->getBaseItem() == NULL)
-      return theBaseItem->compare(other, timezone, collation);
-    else
-      return theBaseItem->compare(other->getBaseItem(), timezone, collation);
+  uint32_t hash(long tz = 0, const XQPCollator* c = 0) const
+  {
+    return theBaseItem->hash(tz, c);
+  }
+
+  bool equals(const store::Item* i, long tz = 0, const XQPCollator* c = 0) const
+  {
+    if (i->getBaseItem() == NULL)
+      return theBaseItem->equals(i, tz, c);
+    else
+      return theBaseItem->equals(i->getBaseItem(), tz, c);
+  }
+
+  long compare(const store::Item* i, long tz = 0, const XQPCollator* c = 0) const
+  {
+    if (i->getBaseItem() == NULL)
+      return theBaseItem->compare(i, tz, c);
+    else
+      return theBaseItem->compare(i->getBaseItem(), tz, c);
   }
 
   bool getEBV() const { return theBaseItem->getEBV(); }
@@ -269,9 +264,14 @@
   zstring theValue;
 
 protected:
-  UntypedAtomicItem(zstring& value) { theValue.take(value); }
+  UntypedAtomicItem(store::SchemaTypeCode t, zstring& value)
+    :
+    AtomicItem(t)
+  {
+    theValue.take(value);
+  }
 
-  UntypedAtomicItem() {}
+  UntypedAtomicItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   bool castToUri(store::Item_t& result) const;
@@ -308,8 +308,6 @@
 
   bool castToBoolean(store::Item_t& result) const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_UNTYPED_ATOMIC; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -388,17 +386,12 @@
 
   // zorba::store::Item interface.
 
-  bool equals(
-      const store::Item* item,
-      long timezone = 0,
-      const XQPCollator* aCollation = 0) const;
+  bool equals(const store::Item* i, long tz = 0, const XQPCollator* c = 0) const;
 
-  uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
+  uint32_t hash(long tz = 0, const XQPCollator* c = 0) const;
 
   store::Item* getType() const;
     
-  store::SchemaTypeCode getTypeCode() const { return store::XS_QNAME; }
-
   bool getEBV() const;
     
   const zstring& getLocalName() const { return theLocal; }
@@ -425,9 +418,9 @@
   zstring show() const;
 
 protected:
-  QNameItem() 
+  QNameItem(store::SchemaTypeCode t = store::XS_QNAME) 
     :
-    AtomicItem(),
+    AtomicItem(t),
     theNormalizedQName(NULL),
     theIsInPool(true),
     thePosition(0),
@@ -439,9 +432,17 @@
   // These two constructors are for building QName items outside
   // of the pool (they point back to the normalized QName in the pool).
   // Zorba does not use them, but extensions to the simple store may.
-  QNameItem(const char* ns, const char* prefix, const char* local);
+  QNameItem(
+      store::SchemaTypeCode t,
+      const char* ns,
+      const char* prefix,
+      const char* local);
 
-  QNameItem(const zstring& ns, const zstring& prefix, const zstring& local);
+  QNameItem(
+      store::SchemaTypeCode t,
+      const zstring& ns,
+      const zstring& prefix,
+      const zstring& local);
 
   void free();
 
@@ -538,11 +539,12 @@
   friend class BasicItemFactory;
 
   NotationItem(
+     store::SchemaTypeCode t,
       const zstring& nameSpace,
       const zstring& prefix,
       const zstring& localName);
 
-  NotationItem(store::Item* qname);
+  NotationItem(store::SchemaTypeCode t, store::Item* qname);
 
 public:
   virtual ~NotationItem();
@@ -567,8 +569,6 @@
   const zstring& getLocalName() const { return theQName->getLocalName(); }
 
   zstring show() const;
-
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_NOTATION; }
 };
 
 
@@ -583,9 +583,14 @@
   zstring theValue;
 
 protected:
-  AnyUriItem(zstring& value) { theValue.take(value); }
+  AnyUriItem(store::SchemaTypeCode t, zstring& value)
+    : 
+    AtomicItem(t)
+  {
+    theValue.take(value);
+  }
 
-  AnyUriItem() {}
+  AnyUriItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   virtual AnyUriTypeCode getAnyUriTypeCode() const 
@@ -593,8 +598,6 @@
     return NON_SPECIALIZED_ANY_URI;
   }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_ANY_URI; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -719,24 +722,13 @@
     return STRUCTURAL_INFORMATION_ANY_URI;
   }
   
-  store::SchemaTypeCode getTypeCode() const
-  {
-    return store::XS_ANY_URI;
-  }
-
   store::Item* getType() const;
 
-  uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
-
-  bool equals(
-        const store::Item* item,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const;
-
-  long compare(
-        const Item* other,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const;
+  uint32_t hash(long tz = 0, const XQPCollator* c = 0) const;
+
+  bool equals(const store::Item* i, long tz = 0, const XQPCollator* c = 0) const;
+
+  long compare(const Item* i, long tz = 0, const XQPCollator* c = 0) const;
 
   // A structural URI is never empty.
   bool getEBV() const { return true; }
@@ -834,15 +826,21 @@
 protected:
   friend class BasicItemFactory;
 
-  StructuralAnyUriItem(zstring& value);
+  StructuralAnyUriItem(store::SchemaTypeCode t, zstring& value);
 
   StructuralAnyUriItem(
+      store::SchemaTypeCode t,
       ulong collectionId,
       const TreeId& treeId,
       store::StoreConsts::NodeKind nodeKind,
       const OrdPath& ordPath);
 
-  StructuralAnyUriItem() : theEncodedValue("") {}
+  StructuralAnyUriItem() 
+    :
+    AtomicItem(store::XS_ANY_URI),
+    theEncodedValue("")
+  {
+  }
 };
 
 
@@ -860,14 +858,17 @@
   zstring theValue;
 
 protected:
-  StringItem(zstring& value) { theValue.take(value); }
+  StringItem(store::SchemaTypeCode t, zstring& value)
+    :
+    AtomicItem(t)
+  {
+    theValue.take(value);
+  }
 
-  StringItem() {}
+  StringItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
 
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_STRING; }
-
   virtual store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -924,14 +925,14 @@
 
 public:
   bool equals(
-        store::Item const*,
-        long timezone = 0,
-        const XQPCollator* collator = 0 ) const;
+      store::Item const*,
+      long timezone = 0,
+      const XQPCollator* collator = 0 ) const;
 
   long compare( 
-        Item const* other,
-        long timezone = 0,
-        const XQPCollator* collator = 0) const;
+      Item const* other,
+      long timezone = 0,
+      const XQPCollator* collator = 0) const;
 
   bool getEBV() const;
 
@@ -967,12 +968,14 @@
 
 protected:
   StreamableStringItem(
+      store::SchemaTypeCode t,
       std::istream& aStream,
       StreamReleaser streamReleaser,
       bool seekable = false);
 
   StreamableStringItem(
-      store::Item_t& aStreamableDependent);
+      store::SchemaTypeCode t,
+      store::Item_t& streamableDependent);
 
   void materialize() const;
 };
@@ -986,11 +989,9 @@
   friend class BasicItemFactory;
 
 protected:
-  NormalizedStringItem(zstring& value) : StringItem(value) {}
+  NormalizedStringItem(store::SchemaTypeCode t, zstring& v) : StringItem(t, v) {}
 
 public:
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_NORMALIZED_STRING; }
-
   virtual store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1005,9 +1006,7 @@
   friend class BasicItemFactory;
 
 public:
-  TokenItem(zstring& value) : NormalizedStringItem(value) {}
-
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_TOKEN; }
+  TokenItem(store::SchemaTypeCode t, zstring& v) : NormalizedStringItem(t, v) {}
 
   virtual store::Item* getType() const;
 
@@ -1023,11 +1022,9 @@
   friend class BasicItemFactory;
 
 protected:
-  NMTOKENItem(zstring& value) : TokenItem(value) {}
+  NMTOKENItem(store::SchemaTypeCode t, zstring& v) : TokenItem(t, v) {}
 
 public:
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_NMTOKEN; }
-
   virtual store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1042,11 +1039,9 @@
   friend class BasicItemFactory;
 
 protected:
-  LanguageItem(zstring& value) : TokenItem(value) {}
+  LanguageItem(store::SchemaTypeCode t, zstring& v) : TokenItem(t, v) { }
 
 public:
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_LANGUAGE; }
-
   virtual store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1061,11 +1056,9 @@
   friend class BasicItemFactory;
 
 protected:
-  NameItem(zstring& value) : TokenItem(value) {}
+  NameItem(store::SchemaTypeCode t, zstring& v) : TokenItem(t, v) { }
 
 public:
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_NAME; }
-
   virtual store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1080,11 +1073,9 @@
   friend class BasicItemFactory;
 
 protected:
-  NCNameItem(zstring& value) : NameItem(value) {}
+  NCNameItem(store::SchemaTypeCode t, zstring& v) : NameItem(t, v) { }
 
 public:
-  virtual store::SchemaTypeCode getTypeCode() const { return store::XS_NCNAME; }
-
   virtual store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1099,11 +1090,9 @@
   friend class BasicItemFactory;
 
 protected:
-  IDItem(zstring& value) : NCNameItem(value) { }
+  IDItem(store::SchemaTypeCode t, zstring& v) : NCNameItem(t, v) { }
 
 public:
-  store::SchemaTypeCode getTypeCode() const { return store::XS_ID; }
-
   store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1117,11 +1106,9 @@
   friend class BasicItemFactory;
 
 protected:
-  IDREFItem(zstring& value) : NCNameItem(value) { }
+  IDREFItem(store::SchemaTypeCode t, zstring& v) : NCNameItem(t, v) { }
 
 public:
-  store::SchemaTypeCode getTypeCode() const { return store::XS_IDREF; }
-
   store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1135,11 +1122,9 @@
   friend class BasicItemFactory;
 
 protected:
-  ENTITYItem(zstring& value) : NCNameItem(value) { }
+  ENTITYItem(store::SchemaTypeCode t, zstring& v) : NCNameItem(t, v) { }
 
 public:
-  store::SchemaTypeCode getTypeCode() const { return store::XS_ENTITY; }
-
   store::Item* getType() const;
 
   virtual zstring show() const;
@@ -1157,9 +1142,14 @@
   DateTime theValue;
 
 protected:
-  DateTimeItem(const DateTime* aValue) : theValue(*aValue) { };
+  DateTimeItem(store::SchemaTypeCode t, const DateTime* v) 
+    :
+    AtomicItem(t),
+    theValue(*v)
+  {
+  }
 
-  DateTimeItem() { };
+  DateTimeItem(store::SchemaTypeCode t) : AtomicItem(t) { }
 
 public:
   const xs_dateTime& getDateTimeValue() const { return theValue; }
@@ -1178,21 +1168,19 @@
 
   const xs_gDay& getGDayValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const;
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
 
   bool equals(
-        const store::Item*,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const;
+      const store::Item*,
+      long timezone = 0,
+      const XQPCollator* collation = 0) const;
 
   long compare(
-        const Item* other,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const;
+      const Item* other,
+      long timezone = 0,
+      const XQPCollator* collation = 0) const;
 
   bool getEBV() const;
 
@@ -1217,9 +1205,14 @@
   Duration theValue;
 
 protected:
-  DurationItem(const xs_duration* aValue) : theValue(*aValue) { };
+  DurationItem(store::SchemaTypeCode t, const xs_duration* v)
+    :
+    AtomicItem(t),
+    theValue(*v)
+  {
+  }
 
-  DurationItem() {}
+  DurationItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   const xs_duration& getDurationValue() const;
@@ -1228,8 +1221,6 @@
 
   const xs_yearMonthDuration& getYearMonthDurationValue() const;
 
-  store::SchemaTypeCode getTypeCode() const;
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -1237,21 +1228,14 @@
     return theValue.hash();
   }
 
-  bool equals(
-        const store::Item* other,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const
+  bool equals(const store::Item* i, long tz = 0, const XQPCollator* c = 0) const
   {
-    return theValue == other->getDurationValue();
+    return theValue == i->getDurationValue();
   }
 
-
-  long compare(
-        const Item* other,
-        long timezone = 0,
-        const XQPCollator* aCollation = 0) const
+  long compare(const Item* i, long tz = 0, const XQPCollator* c = 0) const
   {
-    return theValue.compare(other->getDurationValue());
+    return theValue.compare(i->getDurationValue());
   }
 
   bool getEBV() const;
@@ -1277,9 +1261,14 @@
 	xs_double theValue;
 
 protected:
-	DoubleItem(const xs_double& aValue) : theValue( aValue ) {}
+	DoubleItem(store::SchemaTypeCode t, const xs_double& v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  DoubleItem() {}
+  DoubleItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
 	xs_double getDoubleValue() const { return theValue; }
@@ -1288,8 +1277,6 @@
 
   bool isPosOrNegInf() const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_DOUBLE; }
-
 	store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -1336,9 +1323,14 @@
   xs_float theValue;
 
 protected:
-  FloatItem(const xs_float& aValue) : theValue ( aValue ) {}
+  FloatItem(store::SchemaTypeCode t, const xs_float& v) 
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  FloatItem() {}
+  FloatItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_float getFloatValue() const { return theValue; }
@@ -1349,8 +1341,6 @@
 
   bool isPosOrNegInf() const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_FLOAT; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -1419,15 +1409,19 @@
 protected:
   xs_decimal theValue;
 
-  DecimalItem(const xs_decimal& aValue) : theValue(aValue) {}
+protected:
+  DecimalItem(store::SchemaTypeCode t, const xs_decimal& v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  DecimalItem() {}
+  DecimalItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_DECIMAL; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -1471,11 +1465,13 @@
 class IntegerItem : public AtomicItem
 {
 protected:
-  IntegerItem() {}
+  IntegerItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   virtual xs_decimal getDecimalValue() const = 0;
+
   virtual xs_integer getIntegerValue() const = 0;
+
   virtual xs_long getLongValue() const = 0;
 
   bool isNaN() const { return false; }
@@ -1494,9 +1490,14 @@
   xs_integer theValue;
 
 protected:
-  IntegerItemImpl(const xs_integer& aValue) : theValue ( aValue ) {}
+  IntegerItemImpl(store::SchemaTypeCode t, const xs_integer& v)
+    :
+    IntegerItem(t),
+    theValue(v)
+  {
+  }
 
-  IntegerItemImpl() {}
+  IntegerItemImpl(store::SchemaTypeCode t) : IntegerItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1515,8 +1516,6 @@
 
   void appendStringValue(zstring&) const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_INTEGER; }
-
   store::Item* getType() const;
 
   uint32_t hash(long = 0, const XQPCollator* aCollation = 0) const;
@@ -1547,9 +1546,14 @@
 protected:
   xs_nonPositiveInteger theValue;
 
-  NonPositiveIntegerItem(const xs_integer& aValue) : theValue(aValue) {}
+  NonPositiveIntegerItem(store::SchemaTypeCode t, const xs_integer& v)
+    :
+    IntegerItem(t),
+    theValue(v)
+  {
+  }
 
-  NonPositiveIntegerItem() {}
+  NonPositiveIntegerItem(store::SchemaTypeCode t) : IntegerItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1564,11 +1568,6 @@
 
   void appendStringValue(zstring&) const;
 
-  virtual store::SchemaTypeCode getTypeCode() const 
-  {
-    return store::XS_NON_POSITIVE_INTEGER;
-  }
-
   virtual store::Item* getType() const;
 
   uint32_t hash(long = 0, const XQPCollator* aCollation = 0) const;
@@ -1597,13 +1596,15 @@
   friend class BasicItemFactory;
 
 protected:
-  NegativeIntegerItem(const xs_integer& aValue) : NonPositiveIntegerItem(aValue) {}
+  NegativeIntegerItem(store::SchemaTypeCode t, const xs_integer& v)
+    :
+    NonPositiveIntegerItem(t, v)
+  {
+  }
 
-  NegativeIntegerItem() {}
+  NegativeIntegerItem(store::SchemaTypeCode t) : NonPositiveIntegerItem(t) {}
 
 public:
-  store::SchemaTypeCode getTypeCode() const { return store::XS_NEGATIVE_INTEGER; }
-
   store::Item* getType() const;
 
   zstring show() const;
@@ -1620,9 +1621,14 @@
 protected:
   xs_nonNegativeInteger theValue;
 
-  NonNegativeIntegerItem(const xs_nonNegativeInteger& aValue) : theValue(aValue) {}
+  NonNegativeIntegerItem(store::SchemaTypeCode t, const xs_nonNegativeInteger& v)
+    :
+    IntegerItem(t),
+    theValue(v)
+  {
+  }
 
-  NonNegativeIntegerItem() {}
+  NonNegativeIntegerItem(store::SchemaTypeCode t) : IntegerItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1639,11 +1645,6 @@
 
   void appendStringValue(zstring&) const;
 
-  virtual store::SchemaTypeCode getTypeCode() const 
-  {
-    return store::XS_NON_NEGATIVE_INTEGER;
-  }
-
   virtual store::Item* getType() const;
 
   uint32_t hash(long = 0, const XQPCollator* aCollation = 0) const;
@@ -1672,15 +1673,15 @@
   friend class BasicItemFactory;
 
 protected:
-  PositiveIntegerItem(const xs_positiveInteger& aValue) 
+  PositiveIntegerItem(store::SchemaTypeCode t, const xs_positiveInteger& v) 
     :
-    NonNegativeIntegerItem(aValue) { }
+    NonNegativeIntegerItem(t, v)
+  {
+  }
 
-  PositiveIntegerItem() {}
+  PositiveIntegerItem(store::SchemaTypeCode t) : NonNegativeIntegerItem(t) {}
 
 public:
-  store::SchemaTypeCode getTypeCode() const { return store::XS_POSITIVE_INTEGER; }
-
   store::Item* getType() const;
 
   zstring show() const;
@@ -1699,9 +1700,14 @@
   xs_long theValue;
 
 protected:
-  LongItem(xs_long aValue) : theValue(aValue) {}
+  LongItem(store::SchemaTypeCode t, xs_long v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  LongItem() {}
+  LongItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1712,8 +1718,6 @@
 
   xs_nonNegativeInteger getUnsignedIntegerValue() const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_LONG; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -1779,9 +1783,14 @@
   xs_int theValue;
 
 protected:
-  IntItem(xs_int aValue) : theValue(aValue) {}
+  IntItem(store::SchemaTypeCode t, xs_int v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  IntItem() {}
+  IntItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   bool isNaN() const { return false; }
@@ -1794,8 +1803,6 @@
 
   xs_int getIntValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_INT; }
-
   store::Item* getType( ) const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -1859,9 +1866,14 @@
   xs_short theValue;
 
 protected:
-  ShortItem(xs_short aValue)  : theValue(aValue) {}
+  ShortItem(store::SchemaTypeCode t, xs_short v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  ShortItem() {}
+  ShortItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1874,8 +1886,6 @@
 
   xs_short getShortValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_SHORT; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -1941,9 +1951,14 @@
   xs_byte theValue;
 
 protected:
-  ByteItem(xs_byte aValue) : theValue(aValue) {}
+  ByteItem(store::SchemaTypeCode t, xs_byte v) 
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  ByteItem() {}
+  ByteItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -1958,8 +1973,6 @@
 
   xs_byte getByteValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_BYTE; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -2025,9 +2038,14 @@
   xs_unsignedLong theValue;
 
 protected:
-  UnsignedLongItem(xs_unsignedLong aValue) : theValue(aValue) {}
+  UnsignedLongItem(store::SchemaTypeCode t, xs_unsignedLong v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  UnsignedLongItem() {}
+  UnsignedLongItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
  public:
   bool isNaN() const { return false; }
@@ -2040,8 +2058,6 @@
 
   xs_unsignedLong getUnsignedLongValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_UNSIGNED_LONG; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -2105,9 +2121,14 @@
   xs_unsignedInt theValue;
 
 protected:
-  UnsignedIntItem(xs_unsignedInt aValue) : theValue(aValue) {}
+  UnsignedIntItem(store::SchemaTypeCode t, xs_unsignedInt v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  UnsignedIntItem() {}
+  UnsignedIntItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   bool isNaN() const { return false; }
@@ -2124,8 +2145,6 @@
 
   xs_unsignedInt getUnsignedIntValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_UNSIGNED_INT; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -2196,9 +2215,14 @@
   xs_unsignedShort theValue;
 
 protected:
-  UnsignedShortItem(xs_unsignedShort aValue) : theValue(aValue) {}
+  UnsignedShortItem(store::SchemaTypeCode t, xs_unsignedShort v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  UnsignedShortItem() {}
+  UnsignedShortItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -2217,8 +2241,6 @@
 
   bool isNaN() const { return false; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_UNSIGNED_SHORT; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -2289,9 +2311,17 @@
   xs_unsignedByte theValue;
 
 protected:
-  UnsignedByteItem(xs_unsignedByte aValue) : theValue(aValue) {}
+  UnsignedByteItem(store::SchemaTypeCode t, xs_unsignedByte v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {}
 
-  UnsignedByteItem() : theValue(0) {}
+  UnsignedByteItem(store::SchemaTypeCode t) 
+    :
+    AtomicItem(t),
+    theValue(0)
+  {}
 
 public:
   xs_decimal getDecimalValue() const;
@@ -2312,8 +2342,6 @@
 
   bool isNaN() const { return false; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_UNSIGNED_BYTE; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const
@@ -2383,15 +2411,18 @@
   xs_boolean theValue;
 
 protected:
-  BooleanItem(xs_boolean aValue) : theValue(aValue) {}
+  BooleanItem(store::SchemaTypeCode t, xs_boolean v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  BooleanItem() {}
+  BooleanItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_boolean getBooleanValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_BOOLEAN; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
@@ -2435,14 +2466,24 @@
 
 protected:
   std::vector<char> theValue;
-  bool        theIsEncoded;
+  bool              theIsEncoded;
 
 protected:
-  Base64BinaryItem(bool aIsEncoded)
-    : theIsEncoded(aIsEncoded) {}
+  Base64BinaryItem(store::SchemaTypeCode t, bool aIsEncoded)
+    :
+    AtomicItem(t),
+    theIsEncoded(aIsEncoded)
+  {
+  }
 
-  Base64BinaryItem(const char* aValue, size_t aSize, bool aIsEncoded = true)
-    : theIsEncoded(aIsEncoded)
+  Base64BinaryItem(
+      store::SchemaTypeCode t,
+      const char* aValue,
+      size_t aSize,
+      bool aIsEncoded = true)
+    :
+    AtomicItem(t),
+    theIsEncoded(aIsEncoded)
   {
     theValue.reserve(aSize);
     theValue.insert(theValue.begin(), aValue, aValue + aSize);
@@ -2451,8 +2492,6 @@
 public:
   const char* getBase64BinaryValue(size_t& data) const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_BASE64BINARY; }
-
   store::Item* getType() const;
 
   bool isEncoded() const { return theIsEncoded; }
@@ -2496,25 +2535,28 @@
 protected:
   std::istream & theIstream;
 
-  bool theIsMaterialized;
-  bool theIsConsumed;
-  bool theIsSeekable;
+  bool           theIsMaterialized;
+  bool           theIsConsumed;
+  bool           theIsSeekable;
 
   StreamReleaser theStreamReleaser;
 
 protected:
   StreamableBase64BinaryItem(
+      store::SchemaTypeCode t,
       std::istream& aStream,
       StreamReleaser streamReleaser,
       bool seekable = false,
       bool is_encoded = false)
-    : Base64BinaryItem(is_encoded),
-      theIstream(aStream),
-      theIsMaterialized(false),
-      theIsConsumed(false),
-      theIsSeekable(seekable),
-      theStreamReleaser(streamReleaser)
-  {}
+    :
+    Base64BinaryItem(t, is_encoded),
+    theIstream(aStream),
+    theIsMaterialized(false),
+    theIsConsumed(false),
+    theIsSeekable(seekable),
+    theStreamReleaser(streamReleaser)
+  {
+  }
 
   void materialize() const;
 
@@ -2539,8 +2581,6 @@
 
   const char* getBase64BinaryValue(size_t&) const;
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_BASE64BINARY; }
-
   uint32_t hash(long timezone = 0, const XQPCollator* aCollation = 0) const;
 
   zstring getStringValue() const;
@@ -2564,15 +2604,18 @@
   xs_hexBinary theValue;
 
 protected:
-  HexBinaryItem(xs_hexBinary value) : theValue(value) {}
+  HexBinaryItem(store::SchemaTypeCode t, xs_hexBinary v)
+    :
+    AtomicItem(t),
+    theValue(v)
+  {
+  }
 
-  HexBinaryItem() {}
+  HexBinaryItem(store::SchemaTypeCode t) : AtomicItem(t) {}
 
 public:
   xs_hexBinary getHexBinaryValue() const { return theValue; }
 
-  store::SchemaTypeCode getTypeCode() const { return store::XS_HEXBINARY; }
-
   store::Item* getType() const;
 
   uint32_t hash(long timezone = 0, const XQPCollator* coll = 0) const;
@@ -2616,7 +2659,10 @@
   ZorbaException * theError;
 
 protected:
-  ErrorItem(ZorbaException* error) : theError(error) 
+  ErrorItem(ZorbaException* error) 
+    :
+    AtomicItem(store::XS_LAST),
+    theError(error) 
   {
     theUnion.itemKind = ERROR_;
   }

=== modified file 'src/store/naive/item.cpp'
--- src/store/naive/item.cpp	2012-12-14 13:23:51 +0000
+++ src/store/naive/item.cpp	2013-01-16 16:58:20 +0000
@@ -225,63 +225,8 @@
 }
 
 
-Item::ItemKind Item::getKind() const
-{
-  //if (theUnion.treeRCPtr == 0)
-  //  return UNKNOWN;
-
-  if ((reinterpret_cast<uint64_t>(theUnion.treeRCPtr) & 0x1) == 0)
-    return NODE;
-
-  return static_cast<ItemKind>(theUnion.itemKind);
-}
-
-
-bool Item::isNode() const
-{
-  return ((reinterpret_cast<uint64_t>(theUnion.treeRCPtr) & 0x1) == 0 &&
-          theUnion.treeRCPtr != 0);
-}
-
-
-bool Item::isAtomic() const
-{
-  return (theUnion.itemKind == ATOMIC); 
-}
-
-
-bool Item::isList() const
-{
-  return (theUnion.itemKind == LIST); 
-}
-
-
-bool Item::isPul() const
-{
-  return (theUnion.itemKind == PUL);
-}
-
-
-bool Item::isError() const
-{
-  return (theUnion.itemKind == ERROR_);
-}
-
-
-bool Item::isFunction() const
-{
-  return (theUnion.itemKind == FUNCTION);
-}
-
-
 #ifdef ZORBA_WITH_JSON
 
-bool Item::isJSONItem() const
-{
-  return (theUnion.itemKind == JSONIQ); 
-}
-
-
 bool Item::isJSONObject() const
 {
   return false;
@@ -334,10 +279,14 @@
 
 store::SchemaTypeCode Item::getTypeCode() const
 {
+  if (isAtomic())
+  {
+    return static_cast<SchemaTypeCode>(theUnion.itemKind >> 4);
+  }
+
   throw ZORBA_EXCEPTION(
     zerr::ZSTR0050_FUNCTION_NOT_IMPLEMENTED_FOR_ITEMTYPE,
-    ERROR_PARAMS( __FUNCTION__, typeid(*this).name() )
-  );
+    ERROR_PARAMS(__FUNCTION__, typeid(*this).name()));
 }
 
 

=== modified file 'src/store/naive/json_items.h'
--- src/store/naive/json_items.h	2013-01-08 05:02:54 +0000
+++ src/store/naive/json_items.h	2013-01-16 16:58:20 +0000
@@ -53,7 +53,7 @@
   SYNC_CODE(mutable RCLock  theRCLock;)
 
 public:
-  JSONNull() : AtomicItem() { }
+  JSONNull() : AtomicItem(store::JS_NULL) { }
 
   virtual ~JSONNull() {}
 

=== modified file 'src/store/naive/pul_primitives.cpp'
--- src/store/naive/pul_primitives.cpp	2013-01-08 08:34:08 +0000
+++ src/store/naive/pul_primitives.cpp	2013-01-16 16:58:20 +0000
@@ -202,14 +202,17 @@
   std::size_t numChildren = children.size();
   theNewChildren.resize(numChildren);
 
-  for (std::size_t i = 0; i < numChildren; i++)
+  for (csize i = 0; i < numChildren; ++i)
   {
     if (i > 0 &&
         children[i]->getNodeKind() == store::StoreConsts::textNode &&
-        theNewChildren[i-1]->getNodeKind() == store::StoreConsts::textNode)
+        theNewChildren[numNewChildren-1]->getNodeKind() == store::StoreConsts::textNode)
     {
-      TextNode* node1 = reinterpret_cast<TextNode*>(theNewChildren[i-1].getp());
-      TextNode* node2 = reinterpret_cast<TextNode*>(children[i].getp());
+      TextNode* node1 = 
+      reinterpret_cast<TextNode*>(theNewChildren[numNewChildren-1].getp());
+
+      TextNode* node2 = 
+      reinterpret_cast<TextNode*>(children[i].getp());
 
       zstring newText;
       newText.reserve(node1->getText().size() + node2->getText().size());
@@ -219,13 +222,15 @@
     }
     else
     {
-      theNewChildren[i].transfer(children[i]);
+      theNewChildren[numNewChildren].transfer(children[i]);
       ++numNewChildren;
     }
 
     if (theRemoveType == false)
     {
-      store::StoreConsts::NodeKind childKind = theNewChildren[i]->getNodeKind();
+      store::StoreConsts::NodeKind childKind = 
+      theNewChildren[numNewChildren-1]->getNodeKind();
+
       if (childKind == store::StoreConsts::elementNode ||
           childKind == store::StoreConsts::textNode)
         theRemoveType = true;

=== modified file 'src/store/naive/simple_index.cpp'
--- src/store/naive/simple_index.cpp	2012-09-19 21:16:15 +0000
+++ src/store/naive/simple_index.cpp	2013-01-16 16:58:20 +0000
@@ -117,8 +117,8 @@
 /*******************************************************************************
   TODO: proper initialization order is not guaranteed => use factory instead
 ********************************************************************************/
-store::Item_t IndexConditionImpl::theNegInf(new DecimalItem);
-store::Item_t IndexConditionImpl::thePosInf(new DecimalItem);
+store::Item_t IndexConditionImpl::theNegInf(new DecimalItem(store::XS_DECIMAL));
+store::Item_t IndexConditionImpl::thePosInf(new DecimalItem(store::XS_DECIMAL));
 
 
 /*******************************************************************************

=== modified file 'src/store/naive/simple_item_factory.cpp'
--- src/store/naive/simple_item_factory.cpp	2012-12-28 10:24:59 +0000
+++ src/store/naive/simple_item_factory.cpp	2013-01-16 16:58:20 +0000
@@ -50,8 +50,8 @@
   :
   theUriPool(uriPool),
   theQNamePool(qnPool),
-  theTrueItem(new BooleanItem(true)),
-  theFalseItem(new BooleanItem(false))
+  theTrueItem(new BooleanItem(store::XS_BOOLEAN, true)),
+  theFalseItem(new BooleanItem(store::XS_BOOLEAN, false))
 #ifdef ZORBA_WITH_JSON
   ,theNullItem(new json::JSONNull())
 #endif
@@ -105,7 +105,7 @@
 {
   zstring str = value;
   theUriPool->insert(str);
-  result =  new AnyUriItem(str);
+  result =  new AnyUriItem(store::XS_ANY_URI, str);
   return true;
 }
 
@@ -114,7 +114,7 @@
 {
   zstring str;
   theUriPool->insertc(value, str);
-  result = new AnyUriItem(str);
+  result = new AnyUriItem(store::XS_ANY_URI, str);
   return true;
 }
 
@@ -123,7 +123,7 @@
     store::Item_t& result,
     zstring& value)
 {
-  result =  new StructuralAnyUriItem(value);
+  result =  new StructuralAnyUriItem(store::XS_ANY_URI, value);
   return true;
 }
 
@@ -136,61 +136,63 @@
     const OrdPath& ordPath)
 {
   ZORBA_FATAL(nodeKind,"Unexpected node kind");
-  result = new StructuralAnyUriItem(collectionId, treeId, nodeKind, ordPath);
+
+  result = new StructuralAnyUriItem(store::XS_ANY_URI,
+                                    collectionId, treeId, nodeKind, ordPath);
   return true;
 }
 
 
 bool BasicItemFactory::createString(store::Item_t& result, zstring& value)
 {
-  result = new StringItem(value);
+  result = new StringItem(store::XS_STRING, value);
   return true;
 }
 
 
 bool BasicItemFactory::createStreamableString(
     store::Item_t& result,
-    std::istream &stream,
+    std::istream& stream,
     StreamReleaser streamReleaser,
     bool seekable) 
 {
-  result = new StreamableStringItem( stream, streamReleaser, seekable );
+  result = new StreamableStringItem(store::XS_STRING, stream, streamReleaser, seekable);
   return true;
 }
 
 bool BasicItemFactory::createSharedStreamableString(
-    store::Item_t &result,
-    store::Item_t &streamable_dependent)
+    store::Item_t& result,
+    store::Item_t& streamable_dependent)
 {
-  result = new StreamableStringItem( streamable_dependent );
+  result = new StreamableStringItem(store::XS_STRING, streamable_dependent);
   return true;
 }
 
 
 bool BasicItemFactory::createNormalizedString(store::Item_t& result, zstring& value)
 {
-  result = new NormalizedStringItem(value);
+  result = new NormalizedStringItem(store::XS_NORMALIZED_STRING, value);
   return true;
 }
 
 
 bool BasicItemFactory::createToken(store::Item_t& result, zstring& value )
 {
-  result = new TokenItem(value);
+  result = new TokenItem(store::XS_TOKEN, value);
   return true;
 }
 
 
 bool BasicItemFactory::createLanguage(store::Item_t& result, zstring& value )
 {
-  result = new LanguageItem(value);
+  result = new LanguageItem(store::XS_LANGUAGE, value);
   return true;
 }
 
 
 bool BasicItemFactory::createNMTOKEN(store::Item_t& result, zstring& value )
 {
-  result = new NMTOKENItem(value);
+  result = new NMTOKENItem(store::XS_NMTOKEN, value);
   return true;
 }
 
@@ -203,10 +205,10 @@
 
   //create VectorItem with all tokens
   std::vector<store::Item_t> typedValues;
-  for ( unsigned int i = 0; i < atomicTextValues.size() ; i++)
+  for (csize i = 0; i < atomicTextValues.size(); ++i)
   {
     store::Item_t resultItem;
-    if ( createNMTOKEN(resultItem, atomicTextValues[i]) )
+    if (createNMTOKEN(resultItem, atomicTextValues[i]))
     {
       typedValues.push_back(resultItem.getp());
     }
@@ -217,30 +219,30 @@
 }
 
 
-bool BasicItemFactory::createName(store::Item_t& result, zstring& value )
+bool BasicItemFactory::createName(store::Item_t& result, zstring& value)
 {
-  result = new NameItem(value);
+  result = new NameItem(store::XS_NAME, value);
   return true;
 }
 
 
 bool BasicItemFactory::createNCName(store::Item_t& result, zstring& value )
 {
-  result = new NCNameItem(value);
+  result = new NCNameItem(store::XS_NCNAME, value);
   return true;
 }
 
 
 bool BasicItemFactory::createID(store::Item_t& result, zstring& value )
 {
-  result = new IDItem(value);
+  result = new IDItem(store::XS_ID, value);
   return true;
 }
 
 
 bool BasicItemFactory::createIDREF(store::Item_t& result, zstring& value)
 {
-  result = new IDREFItem(value);
+  result = new IDREFItem(store::XS_IDREF, value);
   return true;
 }
 
@@ -253,10 +255,10 @@
 
   //create VectorItem with all tokens
   std::vector<store::Item_t> typedValues;
-  for ( unsigned int i = 0; i < atomicTextValues.size() ; i++)
+  for (csize i = 0; i < atomicTextValues.size(); i++)
   {
     store::Item_t resultItem;
-    if ( createIDREF(resultItem, atomicTextValues[i]) )
+    if (createIDREF(resultItem, atomicTextValues[i]))
     {
       typedValues.push_back(resultItem.getp());
     }
@@ -269,7 +271,7 @@
 
 bool BasicItemFactory::createENTITY(store::Item_t& result, zstring& value )
 {
-  result = new ENTITYItem(value);
+  result = new ENTITYItem(store::XS_ENTITY, value);
   return true;
 }
 
@@ -282,10 +284,10 @@
 
   //create VectorItem with all tokens
   std::vector<store::Item_t> typedValues;
-  for ( unsigned int i = 0; i < atomicTextValues.size() ; i++)
+  for (csize i = 0; i < atomicTextValues.size(); i++)
   {
     store::Item_t resultItem;
-    if ( createENTITY(resultItem, atomicTextValues[i]) )
+    if (createENTITY(resultItem, atomicTextValues[i]))
     {
       typedValues.push_back(resultItem.getp());
     }
@@ -298,7 +300,7 @@
 
 bool BasicItemFactory::createUntypedAtomic(store::Item_t& result, zstring& value)
 {
-  result = new UntypedAtomicItem(value);
+  result = new UntypedAtomicItem(store::XS_UNTYPED_ATOMIC, value);
   return true;
 }
 
@@ -307,28 +309,28 @@
     store::Item_t& result,
     const xs_double& value)
 {
-  result = new DoubleItem(value);
+  result = new DoubleItem(store::XS_DOUBLE, value);
   return true;
 }
 
 
 bool BasicItemFactory::createFloat(store::Item_t& result,  const xs_float& value)
 {
-  result = new FloatItem(value);
+  result = new FloatItem(store::XS_FLOAT, value);
   return true;
 }
 
 
 bool BasicItemFactory::createDecimal(store::Item_t& result, const xs_decimal& value)
 {
-  result = new DecimalItem(value);
+  result = new DecimalItem(store::XS_DECIMAL, value);
   return true;
 }
 
 
 bool BasicItemFactory::createInteger(store::Item_t& result, const xs_integer& value)
 {
-  result = new IntegerItemImpl( value );
+  result = new IntegerItemImpl(store::XS_INTEGER, value);
   return true;
 }
 
@@ -338,7 +340,7 @@
     const xs_integer& value)
 {
   ZORBA_ASSERT(value.sign() <= 0);
-  result = new NonPositiveIntegerItem( value );
+  result = new NonPositiveIntegerItem(store::XS_NON_POSITIVE_INTEGER, value);
   return true;
 }
 
@@ -348,7 +350,7 @@
     const xs_integer& value)
 {
   ZORBA_ASSERT(value.sign() < 0);
-  result = new NegativeIntegerItem(value);
+  result = new NegativeIntegerItem(store::XS_NEGATIVE_INTEGER, value);
   return true;
 }
 
@@ -357,7 +359,7 @@
     store::Item_t& result,
     const xs_nonNegativeInteger& value )
 {
-  result = new NonNegativeIntegerItem( value );
+  result = new NonNegativeIntegerItem(store::XS_NON_NEGATIVE_INTEGER, value);
   return true;
 }
 
@@ -368,81 +370,85 @@
     const xs_positiveInteger& value)
 {
   ZORBA_ASSERT(value.sign() > 0);
-  result = new PositiveIntegerItem( value );
+  result = new PositiveIntegerItem(store::XS_POSITIVE_INTEGER,value);
   return true;
 }
 
 
 bool BasicItemFactory::createLong(store::Item_t& result,  xs_long value)
 {
-  result = new LongItem(value);
+  result = new LongItem(store::XS_LONG, value);
   return true;
 }
 
 
 bool BasicItemFactory::createInt(store::Item_t& result,  xs_int value)
 {
-  result = new IntItem(value);
+  result = new IntItem(store::XS_INT, value);
   return true;
 }
 
 
 bool BasicItemFactory::createShort(store::Item_t& result,  xs_short value)
 {
-  result = new ShortItem(value);
+  result = new ShortItem(store::XS_SHORT, value);
   return true;
 }
 
 
 bool BasicItemFactory::createByte(store::Item_t& result,  xs_byte value)
 {
-  result = new ByteItem(value);
-  return true;
-}
-
-
-bool BasicItemFactory::createUnsignedLong(store::Item_t& result,
-                                          xs_unsignedLong value)
-{
-  result = new UnsignedLongItem(value);
-  return true;
-}
-
-
-bool BasicItemFactory::createUnsignedInt(store::Item_t& result,
-                                         xs_unsignedInt value)
-{
-  result = new UnsignedIntItem(value);
-  return true;
-}
-
-
-bool BasicItemFactory::createUnsignedShort(store::Item_t& result,
-                                           xs_unsignedShort value)
-{
-  result = new UnsignedShortItem(value);
-  return true;
-}
-
-
-bool BasicItemFactory::createUnsignedByte(store::Item_t& result,
-                                          xs_unsignedByte value)
-{
-  result = new UnsignedByteItem(value);
+  result = new ByteItem(store::XS_BYTE, value);
+  return true;
+}
+
+
+bool BasicItemFactory::createUnsignedLong(
+    store::Item_t& result,
+    xs_unsignedLong value)
+{
+  result = new UnsignedLongItem(store::XS_UNSIGNED_LONG, value);
+  return true;
+}
+
+
+bool BasicItemFactory::createUnsignedInt(
+   store::Item_t& result,
+   xs_unsignedInt value)
+{
+  result = new UnsignedIntItem(store::XS_UNSIGNED_INT, value);
+  return true;
+}
+
+
+bool BasicItemFactory::createUnsignedShort(
+    store::Item_t& result,
+    xs_unsignedShort value)
+{
+  result = new UnsignedShortItem(store::XS_UNSIGNED_SHORT, value);
+  return true;
+}
+
+
+bool BasicItemFactory::createUnsignedByte(
+    store::Item_t& result,
+    xs_unsignedByte value)
+{
+  result = new UnsignedByteItem(store::XS_UNSIGNED_BYTE, value);
   return true;
 }
 
 
 bool BasicItemFactory::createBoolean(store::Item_t& result, xs_boolean value)
 {
-  result = value?theTrueItem:theFalseItem;
+  result = (value ? theTrueItem : theFalseItem);
   return true;
 }
 
 
 bool BasicItemFactory::createDateTime(store::Item_t& result, const xs_dateTime* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_DATETIME, value);
   return true;
 }
 
@@ -452,7 +458,7 @@
     const xs_date* date,
     const xs_time* time)
 {
-  std::auto_ptr<DateTimeItem> dtin(new DateTimeItem());
+  std::auto_ptr<DateTimeItem> dtin(new DateTimeItem(store::XS_DATETIME));
   int err = DateTime::createDateTime(date, time, dtin->theValue);
   if (err == 0)
   {
@@ -482,7 +488,7 @@
 
   if (DateTime::createDateTime(year, month, day, hour, minute, second, &tz, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_DATETIME, &dt);
     return true;
   }
   else
@@ -508,7 +514,7 @@
 
   if (DateTime::createDateTime(year, month, day, hour, minute, second, &tz, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_DATETIME, &dt);
     return true;
   }
   else
@@ -528,7 +534,7 @@
 
   if (DateTime::parseDateTime(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_DATETIME, &dt);
     return true;
   }
   else
@@ -553,7 +559,7 @@
   {
     const xs_date& d = date->getDateValue();
     const xs_time& t = time->getTimeValue();
-    if (! createDateTime(result, &d, &t))
+    if (! createDateTime( result, &d, &t))
       throw XQUERY_EXCEPTION(err::FORG0008, ERROR_PARAMS(d, t));
 
     return true;
@@ -563,7 +569,7 @@
 
 bool BasicItemFactory::createDate(store::Item_t& result, const xs_date* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_DATE, value);
   return true;
 }
 
@@ -579,7 +585,7 @@
 
   if (DateTime::createDate(year, month, day, &tz, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_DATE, &dt);
     return true;
   }
   else
@@ -599,7 +605,7 @@
 
   if (DateTime::parseDate(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_DATE, &dt);
     return true;
   }
   else
@@ -612,7 +618,7 @@
 
 bool BasicItemFactory::createTime(store::Item_t& result, const xs_time* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_TIME, value);
   return true;
 }
 
@@ -626,7 +632,7 @@
 
   if (DateTime::parseTime(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_TIME, &dt);
     return true;
   }
   else
@@ -648,7 +654,7 @@
 
   if( DateTime::createTime(hour, minute, second, &tz, dt) == 0 )
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_TIME, &dt);
     return true;
   }
   else
@@ -671,7 +677,7 @@
 
   if(DateTime::createTime(hour, minute, second, &tz, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_TIME, &dt);
     return true;
   }
   else
@@ -684,7 +690,7 @@
 
 bool BasicItemFactory::createGDay(store::Item_t& result, const xs_gDay* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_GDAY, value);
   return true;
 }
 
@@ -698,7 +704,7 @@
 
   if (DateTime::parseGDay(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GDAY, &dt);
     return true;
   }
   else
@@ -715,7 +721,7 @@
 
   if (DateTime::createGDay(day, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GDAY, &dt);
     return true;
   }
   else
@@ -728,7 +734,7 @@
 
 bool BasicItemFactory::createGMonth(store::Item_t& result, const xs_gMonth* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_GMONTH, value);
   return true;
 }
 
@@ -742,7 +748,7 @@
 
   if (DateTime::parseGMonth(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GMONTH, &dt);
     return true;
   }
   else
@@ -759,7 +765,7 @@
 
   if(DateTime::createGMonth(month, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GMONTH, &dt);
     return true;
   }
   else
@@ -774,7 +780,7 @@
     store::Item_t& result,
     const xs_gMonthDay* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_GMONTH_DAY, value);
   return true;
 }
 
@@ -788,7 +794,7 @@
 
   if (DateTime::parseGMonthDay(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GMONTH_DAY, &dt);
     return true;
   }
   else
@@ -805,7 +811,7 @@
 
   if (DateTime::createGMonthDay(month, day, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GMONTH_DAY, &dt);
     return true;
   }
   else
@@ -818,7 +824,7 @@
 
 bool BasicItemFactory::createGYear(store::Item_t& result, const xs_gYear* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_GYEAR, value);
   return true;
 }
 
@@ -832,7 +838,7 @@
 
   if (DateTime::parseGYear(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GYEAR, &dt);
     return true;
   }
   else
@@ -849,7 +855,7 @@
 
   if(DateTime::createGYear(year, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GYEAR, &dt);
     return true;
   }
   else
@@ -864,7 +870,7 @@
     store::Item_t& result,
     const xs_gYearMonth* value)
 {
-  result = new DateTimeItem(value);
+  result = new DateTimeItem(store::XS_GYEAR_MONTH, value);
   return true;
 }
 
@@ -878,7 +884,7 @@
 
   if (DateTime::parseGYearMonth(str, strlen, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GYEAR_MONTH, &dt);
     return true;
   }
   else
@@ -898,7 +904,7 @@
 
   if (DateTime::createGYearMonth(year, month, dt) == 0)
   {
-    result = new DateTimeItem(&dt);
+    result = new DateTimeItem(store::XS_GYEAR_MONTH, &dt);
     return true;
   }
   else
@@ -913,7 +919,7 @@
     store::Item_t& result,
     xs_duration* value)
 {
-  result = new DurationItem(value);
+  result = new DurationItem(store::XS_DURATION, value);
   return true;
 }
 
@@ -926,7 +932,7 @@
   Duration d;
   if (Duration::parseDuration(str, strlen, d) == 0)
   {
-    result = new DurationItem(&d);
+    result = new DurationItem(store::XS_DURATION, &d);
     return true;
   }
 
@@ -945,7 +951,7 @@
     double  seconds)
 {
   Duration d(Duration::DURATION_FACET, years, months, days, hours, minutes, seconds);
-  result = new DurationItem(&d);
+  result = new DurationItem(store::XS_DURATION, &d);
   return true;
 }
 
@@ -954,7 +960,7 @@
     store::Item_t& result,
     xs_yearMonthDuration* value )
 {
-  result = new DurationItem(value);
+  result = new DurationItem(store::XS_YM_DURATION, value);
   return true;
 }
 
@@ -966,7 +972,7 @@
   Duration d;
   if (Duration::parseYearMonthDuration(str, strlen, d) == 0)
   {
-    result = new DurationItem(&d);
+    result = new DurationItem(store::XS_YM_DURATION, &d);
     return true;
   }
 
@@ -979,7 +985,7 @@
     store::Item_t& result,
     xs_dayTimeDuration* value)
 {
-  result = new DurationItem(value);
+  result = new DurationItem(store::XS_DT_DURATION, value);
   return true;
 }
 
@@ -992,7 +998,7 @@
   Duration d;
   if (Duration::parseDayTimeDuration(str, strlen, d) == 0)
   {
-    result = new DurationItem(&d);
+    result = new DurationItem(store::XS_DT_DURATION, &d);
     return true;
   }
 
@@ -1006,7 +1012,10 @@
     xs_base64Binary value)
 {
   const std::vector<char>& data = value.getData();
-  result = new Base64BinaryItem(data.size()!=0?&data[0]:0, data.size(), true);
+  result = new Base64BinaryItem(store::XS_BASE64BINARY,
+                                data.size() != 0 ? &data[0] : 0,
+                                data.size(),
+                                true);
   return true;
 }
 
@@ -1016,7 +1025,7 @@
     size_t size,
     bool encoded)
 {
-  result = new Base64BinaryItem(value, size, encoded);
+  result = new Base64BinaryItem(store::XS_BASE64BINARY, value, size, encoded);
   return true;
 }
 
@@ -1028,14 +1037,18 @@
     bool seekable,
     bool encoded)
 {
-  result = new StreamableBase64BinaryItem(aStream, aReleaser, seekable, encoded);
+  result = new StreamableBase64BinaryItem(store::XS_BASE64BINARY,
+                                          aStream,
+                                          aReleaser,
+                                          seekable,
+                                          encoded);
   return true;
 }
 
 
 bool BasicItemFactory::createHexBinary(store::Item_t& result,  xs_hexBinary value)
 {
-  result = new HexBinaryItem(value);
+  result = new HexBinaryItem(store::XS_HEXBINARY, value);
   return true;
 }
 
@@ -1046,7 +1059,7 @@
     zstring& prefix,
     zstring& local)
 {
-  result = new NotationItem(ns, prefix, local);
+  result = new NotationItem(store::XS_NOTATION, ns, prefix, local);
   return true;
 }
 
@@ -1068,14 +1081,14 @@
   else
     local = str;
 
-  result = new NotationItem(nsuri, prefix, local);
+  result = new NotationItem(store::XS_NOTATION, nsuri, prefix, local);
   return true;
 }
 
 
 bool BasicItemFactory::createNOTATION(store::Item_t& result, store::Item_t& qname)
 {
-  result = new NotationItem(qname);
+  result = new NotationItem(store::XS_NOTATION, qname);
   return true;
 }
 

=== modified file 'src/types/casting.cpp'
--- src/types/casting.cpp	2013-01-11 09:42:53 +0000
+++ src/types/casting.cpp	2013-01-16 16:58:20 +0000
@@ -1111,7 +1111,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::DATE_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createDate(result, &dt);
 }
 
 
@@ -1119,7 +1119,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::GYEARMONTH_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGYearMonth(result, &dt);
 }
 
 
@@ -1127,7 +1127,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::GYEAR_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGYear(result, &dt);
 }
 
 
@@ -1135,7 +1135,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::GMONTHDAY_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGMonthDay(result, &dt);
 }
 
 
@@ -1143,7 +1143,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::GDAY_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGDay(result, &dt);
 }
 
 
@@ -1151,7 +1151,7 @@
 {
   DateTime dt;
   aItem->getDateTimeValue().createWithNewFacet(DateTime::GMONTH_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGMonth(result, &dt);
 }
 
 
@@ -1187,7 +1187,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::DATETIME_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createDateTime(result, &dt);
 }
 
 
@@ -1195,7 +1195,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::GYEARMONTH_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGYearMonth(result, &dt);
 }
 
 
@@ -1203,7 +1203,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::GYEAR_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGYear(result, &dt);
 }
 
 
@@ -1211,7 +1211,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::GMONTHDAY_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGMonthDay(result, &dt);
 }
 
 
@@ -1219,7 +1219,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::GDAY_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGDay(result, &dt);
 }
 
 
@@ -1227,7 +1227,7 @@
 {
   DateTime dt;
   aItem->getDateValue().createWithNewFacet(DateTime::GMONTH_FACET, dt);
-  aFactory->createTime(result, &dt);
+  aFactory->createGMonth(result, &dt);
 }
 
 

=== added file 'test/rbkt/ExpQueryResults/zorba/updates/joel.xml.res'
--- test/rbkt/ExpQueryResults/zorba/updates/joel.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/updates/joel.xml.res	2013-01-16 16:58:20 +0000
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<root><a-text-node>this is some text! foo-1  foo-2  foo-3 </a-text-node><parent id="1"><child id="1"/><child id="2"/><child id="3"/></parent><parent id="2"><child id="4"/><child id="5"/></parent></root>

=== added file 'test/rbkt/Queries/zorba/updates/joel.xq'
--- test/rbkt/Queries/zorba/updates/joel.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/updates/joel.xq	2013-01-16 16:58:20 +0000
@@ -0,0 +1,18 @@
+
+declare variable $d :=
+<root>
+    <a-text-node>this is some text!</a-text-node>
+    <parent id="1">
+        <child id="1"/>
+        <child id="2"/>
+        <child id="3"/>
+    </parent>
+    <parent id="2">
+        <child id="4"/>
+        <child id="5"/>
+    </parent>
+</root>;
+
+insert nodes (text { " foo-1 " } , text { " foo-2 " } , text { " foo-3 " }) after $d//text();
+
+$d