Examples of nexj.core.runtime.InstanceList

nexj.core.runtime.InstanceList
Interface for representing object instance lists, esp. association collections. Supports efficient membership checks and does not allow duplicate objects.

            {
               context.beginTransaction();
               context.getUnitOfWork().setRaw(true);


               long lCurrentTime = System.currentTimeMillis();
               InstanceList list = Query.createRead(timerClass, attributes,
                  (m_bDistributed) ? Pair.attribute("next").le(new Timestamp(lCurrentTime + m_lInterval)) : null,
                  orderBy, m_nBatchCount, 0, true, Query.SEC_NONE, context).read();


               for (int i = 0; i < list.size(); ++i)
               {
                  Instance timer = list.getInstance(i);
                  long lNextTimeout = ((Timestamp)timer.getValue("next")).getTime();


                  if (lNextTimeout <= lCurrentTime)
                  {
                     String sId = timer.getOID().getValue(0).toString();
                     TransferObject properties = new TransferObject(3);


                     properties.setValue("timer", sId);
                     properties.setValue(JMSSender.PROTECTED, Boolean.FALSE);


                     Object user = timer.getValue("principal");


                     if (user == null)
                     {
                        user = m_sDefaultUser;
                     }


                     if (user != null)
                     {
                        properties.setValue(JMSSender.USER, user);
                     }


                     if (s_logger.isDebugEnabled())
                     {
                        s_logger.debug("Timeout in timer \"" +  m_thisComponent.getName() +
                           "\", id=" + sId + "; forwarding to the message queue");
                     }


                     TransferObject tobj = new TransferObject(2);


                     tobj.setValue(JMSSender.BODY, ((Binary)timer.getValue("data")).toObject());
                     tobj.setValue(JMSSender.PROPERTIES, properties);


                     if (sendList == null)
                     {
                        sendList = new ArrayList(m_nBatchCount);
                     }


                     sendList.add(tobj);


                     long lPeriod = ((Number)timer.getValue("period")).longValue();


                     if (lPeriod <= 0)
                     {
                        timer.invoke("delete");
                     }
                     else
                     {
                        Timestamp tmStart = (Timestamp)timer.getValue("start");


                        lNextTimeout = tmStart.getTime() + lPeriod * ((lCurrentTime - tmStart.getTime()) / lPeriod + 1);
                        timer.setValue("next", new Timestamp(lNextTimeout));
                        reset(lNextTimeout, false);
                     }
                  }
                  else
                  {
                     reset(lNextTimeout, false);


                     break loop;
                  }
               }


               if (list.size() < m_nBatchCount)
               {
                  break;
               }


               if (sendList != null)

View Full Code Here

                        throw new InvalidDispatcherException(sDispatcherId);
                     }


                     // dispatch in bulk
                     Pair result = (Pair)dispatcherClass.invoke("dispatch", new Object[]{safety});
                     InstanceList deliverable = (InstanceList)result.getTail();


                     if (deliverable != null && !deliverable.isEmpty())
                     {
                        for (int i = 0; i < deliverable.size(); i++)
                        {
                           final Instance message = deliverable.getInstance(i);
                           final Instance queue = (Instance)message.getValue("queue");
                           final String sQueueName = (String)queue.getValue("name");
                           Number priority = (Number)queue.getValue("priority");


                           pushMessage((priority == null) ? 1000 : priority.intValue(), i, sDispatcherId, (sQueueName
                              .equals(m_sQueueName)) ? ObjectDispatchListener.DISPATCHER : ObjectDispatchListener.ANY,
                              new DispatcherMessage()
                              {
                                 public int getType()
                                 {
                                    return RECEIVE;
                                 }


                                 public Object[] getArgArray()
                                 {
                                    return new Object[]
                                    {
                                       message.getOID().toBinary(),
                                       sQueueName
                                    };
                                 }


                                 public void error(int nCause, Throwable t)
                                 {
                                 }


                                 public void respond(Object result)
                                 {
                                 }


                                 public String getDispatcherName()
                                 {
                                    return sDispatcherId;
                                 }
                              });
                        }
                     }


                     if (s_logger.isDebugEnabled())
                     {
                        s_logger.debug("Dispatcher returned with " + ((deliverable == null) ? 0 : deliverable.size())
                           + " messages available for delivery");


                        if (s_logger.isDumpEnabled())
                        {
                           s_logger.dump("Dispatcher will run again at " + result.getHead());

View Full Code Here

      boolean bSecured = context.isSecure();


      try
      {
         Metaclass dispatcherClass = m_metadata.getMetaclass("SysObjectQueueDispatcher");
         InstanceList messages = Query.createRead(m_metadata.getMetaclass("SysMessage"), m_messageLoadAttributes, Pair.attribute("").eq(oid),
            null, -1, 0, false, Query.SEC_NONE, context).read();


         Instance msg = (messages == null || messages.isEmpty()) ? null : messages.getInstance(0);


         if (msg == null)
         {
            return; // message doesn't exist, can't blacklist it.
         }

View Full Code Here

    * @param context the invocation context.
    * @return the message, null if not found.
    */
   protected Instance readMessage(OID oid, Pair attributes, InvocationContext context)
   {
      InstanceList messages = Query.createRead(m_metadata.getMetaclass("SysMessage"), attributes, Pair.attribute("").eq(oid),
         null, -1, 0, false, Query.SEC_NONE, context).read();


      Instance message = (messages == null || messages.isEmpty()) ? null : messages.getInstance(0);


      if (message != null)
      {
         boolean bWasSecured = context.isSecure();

View Full Code Here

      if (nPageSize <= 0)
      {
         nPageSize = nCount;
      }


      InstanceList instanceList = new InstanceArrayList();


      for (int i = 0; i < nCount; i += nPageSize)
      {
         InstanceList list = read(metaclass, attributes,
            Pair.list(Symbol.IN_P, Pair.list(Symbol.AT),
               sortedOIDList.subList(i, Math.min(i + nPageSize, nCount))));


         for (int k = 0; k < list.size(); ++k)
         {
            instanceList.add(list.getInstance(k), InstanceList.REPLACE);
         }
      }


      return instanceList;
   }

View Full Code Here

      List list = new ArrayList();


      for (int i = 0, n = resultList.size(); i < n; ++i)
      {
         Pair pair = (Pair)resultList.get(i);
         InstanceList ilist = (InstanceList)pair.getHead();


         if (s_logger.isDebugEnabled())
         {
            if (!ilist.isEmpty())
            {
               s_logger.debug("Exporting class \"" + ilist.getInstance(0).getMetaclass()
                  .getPersistenceRoot().getName() + "\"");
            }
         }


         list.addAll((List)RPCUtil.transfer(ilist, pair.getNext(), identityMap, RPCUtil.TF_ALL | RPCUtil.TF_LAZY));

View Full Code Here


                        if (attribute.isPersistent() &&
                           attribute.isCollection() &&
                           inst.getValueDirect(i) == Undefined.VALUE)
                        {
                           InstanceList list = new InstanceArrayList(0);


                           list.setLazy(false);
                           list.setAssociation(inst, attribute, true);
                           inst.setValueDirect(i, list);
                        }
                     }
                  }
                  else

View Full Code Here

      attributes = parse("(firstName lastName (qaUser name) (user name))");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"),
         parse("((firstName . #t)(lastName . #t))"), -1, 0, false, Query.SEC_NONE, m_context);


      InstanceList list = query.read();


      AssertUtil.assertEquals(getURL("readAssocWhere2.xml"), list, attributes);


      query.setMaxCount(1000000);


      Cursor cursor = query.openCursor();


      try
      {
         int i = 0;


         while ((instance = cursor.next()) != null)
         {
            assertSame(list.getInstance(i++), instance);
         }


         assertEquals(list.size(), i);
      }
      finally
      {
         cursor.close();
      }


      attributes = parse("(addresses)");
      cursor = Query.createRead(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), null, -1, 0, false, Query.SEC_NONE, m_context).openCursor();


      try
      {
         cursor.next();
         cursor.next();
         instance = cursor.next();
         assertEquals(2, ((InstanceList)instance.getValue("addresses")).size());
      }
      finally
      {
         cursor.close();
      }
      
      attributes = parse("(fullName)");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(any (= (@ addresses city) \"Toronto\"))"),
         parse("((firstName . #t)(lastName . #t)((@ addresses) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readAny.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(any (= (@ businessAddress3 city) \"Toronto\"))"),
         parse("((firstName . #t)(lastName . #t)((@ addresses) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readAny2.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(any (= (@) ()))"), parse("((firstName . #t)(lastName . #t)((@ addresses) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      assertEquals(0, query.read().size());


      attributes = parse("(name typeCode)");
      query = Query.createRead(getMetadata().getMetaclass("Principal"), attributes, null,
         parse("((name . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readPolymorphic.xml"), query.read(), attributes);
      
      attributes = parse("(fullName)");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(instance? (@) Patient)"),
         parse("((firstName . #t)(lastName . #t)((@ addresses) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readSubclass.xml"), query.read(), attributes);


      query  = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(and (instance? (@) Patient) (not (like? (@ lastName) \"[S]*\")))"),
         parse("((firstName . #t)(lastName . #t)((@ addresses) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readSubclass.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("Address"), null, 
         parse("(= typeEnum (oid \"address\" \"en\" \"Business\"))"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readEnum.xml"), query.read(), null);


      query = Query.createRead(getMetadata().getMetaclass("Address"), null, 
         parse("(= (@ typeEnum type) \"Business\")"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readEnum.xml"), query.read(), null);


      query = Query.createRead(getMetadata().getMetaclass("Address"), null, 
         parse("(and (= typeEnum (oid \"address\" \"en\" \"Business\")) (= (@ typeEnum type) \"Business\"))"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readEnum.xml"), query.read(), null);


      query = Query.createRead(getMetadata().getMetaclass("Address"), null, 
         parse("(and (= typeEnum (oid \"address\" \"en\" \"Business\")) (= (@ typeEnum type) \"1\"))"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      assertEquals(0, query.read().getCount());


      query = Query.createRead(getMetadata().getMetaclass("ExternalVisit"), null,
         parse("(= patient (oid #z00000000000000000000000000000006))"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readExternal.xml"), query.read(), null);


      query = Query.createRead(getMetadata().getMetaclass("Patient"), parse("(externalVisits)"),
         parse("(and (= firstName \"Sarah\") (= lastName \"Johnson\"))"),
         null, -1, 0, false, Query.SEC_NONE, m_context);
      assertEquals(3, ((InstanceList)query.read().getInstance(0).getValue("externalVisits")).size());


      // Comparison of LOB values, class is not important as long as the attribute is LOB


      Query.createRead(getMetadata().getMetaclass("SysRule"), parse("(name)"),
         parse("(= action \"test\")"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read();
      Query.createRead(getMetadata().getMetaclass("SysRule"), parse("(name)"),
         parse("(not (= action \"test\"))"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read();
      Query.createRead(getMetadata().getMetaclass("SysTimer"), parse("(period)"),
         parse("(= data #z0)"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read();
      Query.createRead(getMetadata().getMetaclass("SysTimer"), parse("(period)"),
         parse("(not (= data #z0))"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read();


      // Dynamic derived associations


      attributes = parse("(contact)");
      query = Query.createRead(getMetadata().getMetaclass("Address"), attributes,
         parse("(!= (@ contact (instance? (@) Patient) birthdate) ())"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readDynDerived.xml"), query.read(), attributes);


      attributes = parse("(lastName)");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(!= (@ (instance? (@) Patient) birthdate) ())"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readDynTypeCast.xml"), query.read(), attributes);


      list = Query.createRead(getMetadata().getMetaclass("Contact"), parse("(lastName)"),
         parse("(!= (@ addresses (= (@ country) \"Canada\") contact (= (@ firstName) \"Joe\") addresses) ())"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context).read();
      assertEquals(1, list.size());
      assertEquals("Joe", list.getInstance(0).getValue("firstName"));


      query = Query.createRead(getMetadata().getMetaclass("Visit"), null,
         parse("(= (@@ Address contact (instance? (@) Patient) visits) (oid #z00000000000000000000000000000008))"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readDynReverse.xml"), query.read(), null);


      // Calculated attributes 
      attributes = parse("(isTorontoBasedEmployee tax lastNameLengthPlus1 lastNameInitial)");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(= classCode \"CON\")"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCalculated.xml"), query.read(), attributes);


      attributes = parse("((businessAddress3 deletable))");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(= classCode \"CON\")"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCalculatedSubq.xml"), query.read(), attributes);


      Query.createRead(getMetadata().getMetaclass("Patient"), parse("(visibleDescription)"),
         null, null, 1, 0, false, Query.SEC_NONE, m_context);


      list = Query.createRead(getMetadata().getMetaclass("Contact"), null,
         Pair.attribute("visible"), null, -1, 0, false, Query.SEC_NONE, m_context).read();


      for (int i = 0; i < list.size(); ++i)
      {
         assertEquals(Boolean.TRUE, list.getInstance(i).getValue("visible"));
      }


      assertEquals(2, Query.createRead(getMetadata().getMetaclass("Contact"), null,
         parse("(and (= classCode \"CON\") (> (/ businessAddressCount 2) 0))"), null, -1, 0, false,
         Query.SEC_NONE, m_context).read().size());


      assertEquals(2, Query.createRead(getMetadata().getMetaclass("Address"), null,
         parse("(= (@@ User addresses) (oid #z00000000000000000000000000000001))"), null, -1, 0, false,
         Query.SEC_NONE, m_context).read().size());


      // Annotations
      attributes = parse("(firstName (: _fnLen (string-length (@ firstName))) (: _n 123) (: _ln (@ lastName)) (: _x2 (let ((x 2)) (* x x))) (: _f (lambda (x) 1)))");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(= classCode \"CON\")"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readAnnotations.xml"), query.read(), attributes);


      // Annotated queries with cached classes (no caching)
      attributes = parse("((: l (string-length (@ name))))");
      query = Query.createRead(getMetadata().getMetaclass("Country"), attributes, 
         null, parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readAnnotationsCached.xml"), query.read(), attributes);


      // Aggregate functions
      attributes = parse("(firstName lastName addressCount (: _countryCnt (count (@ addresses country))) " +
         "(: _uniqueCountryCnt (count (unique (@ addresses country)))) (: _nullCodeCnt (count (null? (@ addresses code)))) " +
         "(: _avg (average (string-length (@ addresses city)))) (: _min (minimum (string-length (@ addresses city)))) " +
         "(: _max (maximum (@ addresses city))) (: _sum (sum (string-length (@ addresses city)))))");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("(((@) . #t))"),
         -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readAggregate.xml"), query.read(), attributes);


      // Aggregate queries
      list = Query.createAggregate(getMetadata().getMetaclass("Contact"), null, 
         parse("(= classCode \"CON\")"), null, null, null, -1, 0, Query.SEC_NONE, m_context).read();
      assertEquals(1, list.size());
      instance = list.getInstance(0);
      assertEquals("Object", instance.getClassName());
      assertNull(instance.getOID());


      attributes = parse("((: c (count (@))) (: n 1))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), null, null, null, -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCountAll.xml"), query.read(), attributes);


      attributes = parse("((: c (* 2 (count (@)))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("((@))"), null, parse("(((@) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByIndentity.xml"), query.read(), attributes);


      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), parse("(classCode (: c (* 2 (count (@)))) (: n 1))"), 
         parse("(= classCode \"CON\")"), parse("(classCode)"), null, parse("((classCode . #t))"),
         -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByAttribute.xml"), query.read(),
         parse("((: classCode (@ classCode)) (: c (* 2 (count (@)))) (: n 1))"));


      attributes = parse("((: fnl (string-length (@ firstName))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("(classCode (string-length (@ firstName)))"), null,
         parse("((classCode . #t) ((string-length (@ firstName)) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByExpr.xml"), query.read(), attributes);


      attributes = parse("((: c (* 2 (count (@)))) (: ac (count (@ addresses))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("((@))"), null,
         parse("(((@) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByIdentityCountAssoc.xml"), query.read(), attributes);


      attributes = parse("((: classCode (@ classCode)) (: c (* 2 (count (@)))) (: ac (count (@ addresses))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("(classCode)"), parse("(> (count (@ addresses)) 1)"),
         parse("((classCode . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCountAssoc.xml"), query.read(), attributes);


      attributes = parse("((: c (* 2 (count (@)))) (: a (@ addresses)))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("((@) addresses)"), null,
         parse("((addresses . #t) ((@) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByAssoc.xml"), query.read(), attributes);


      query = Query.createAggregate(getMetadata().getMetaclass("Contact"),
         parse("(firstName (: c (count (@))))"), 
         parse("(= classCode \"CON\")"), parse("(firstName)"), null,
         parse("((firstName . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCase.xml"), query.read(),
         parse("((: firstName (@ firstName)) (: c (count (@))))"));


      attributes = parse("((: c (* 2 (count (@)))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Contact"), attributes, 
         parse("(= classCode \"CON\")"), parse("(addresses)"), null,
         parse("((addresses . #t))"), -1, 0, Query.SEC_NONE, m_context);
      cursor = query.openCursor();


      try
      {
         AssertUtil.assertEquals(getURL("readGroupByCursorCol.xml"), cursor.next(1024), attributes);
      }
      finally
      {
         cursor.close();
      }


      // Aggregate queries with cached classes (no caching)


      query = Query.createAggregate(getMetadata().getMetaclass("Country"), null, 
         null, null, null, null, -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCachedDefault.xml"), query.read(), null);


      attributes = parse("((: c (count (@))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Country"), attributes, 
         null, null, null, null, -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCachedCountAll.xml"), query.read(), attributes);


      attributes = parse("((: m (maximum (@ countryEnum name))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Address"), attributes, 
         null, parse("((@))"), null, parse("(((@) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByCachedAssoc.xml"), query.read(), attributes);


      attributes = parse("((: c (count (@))))");
      query = Query.createAggregate(getMetadata().getMetaclass("Address"), attributes, 
         null, parse("((@ countryEnum name))"), null, parse("(((@ countryEnum name) . #t))"), -1, 0, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readGroupByAssocCached.xml"), query.read(), attributes);


      // Nested aggregate functions
      try
      {
         Query.createAggregate(getMetadata().getMetaclass("Contact"), parse("((: ac (minimum (count (@ addresses)))))"),
            null, parse("((@))"), null, null, -1, 0, Query.SEC_NONE, m_context);
         fail("Expected InvalidQueryException");
      }
      catch (InvalidQueryException e)
      {
         assertEquals("err.persistence.nestedAggregate", e.getErrorCode());
      }


      // Unsupported expression
      try
      {
         Query.createAggregate(getMetadata().getMetaclass("Contact"), parse("((: fnl (sin (string-length (@ firstName)))))"),
            null, parse("(classCode (sin (string-length (@ firstName))))"), null, null, -1, 0, Query.SEC_NONE, m_context);
         fail("Expected InvalidQueryException");
      }
      catch (InvalidQueryException e)
      {
         assertEquals("err.persistence.unsupportedExpression", e.getErrorCode());
      }


      // Invalid having clause
      try
      {
         Query.createAggregate(getMetadata().getMetaclass("Contact"), null, null,
            parse("(addresses)"), parse("(> (@) (oid #z1))"), null, -1, 0, Query.SEC_NONE, m_context).read();
         fail("Expected InvalidQueryException");
      }
      catch (InvalidQueryException e)
      {
         assertEquals("err.persistence.ungroupedHaving", e.getErrorCode());
      }


      // Query macros
      assertEquals(2, Query.createRead(getMetadata().getMetaclass("Address"), null,
         parse("(and isQuery (= contact (oid #z00000000000000000000000000000001)))"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals("R", Query.createRead(getMetadata().getMetaclass("Address"), parse("(cityq)"),
         parse("(= contact (oid #z00000000000000000000000000000001))"),
         parse("((city . #t))"), -1, 0, false, Query.SEC_NONE, m_context).read().getInstance(0).getValue("cityq"));


      assertEquals("Richmond Hill", ((InstanceList)Query.createRead(getMetadata().getMetaclass("Contact"), parse("((addresses cityq))"),
         parse("(= (@) (oid #z00000000000000000000000000000001))"),
         parse("(((@ addresses city) . #t))"), -1, 0, false, Query.SEC_NONE, m_context)
         .read().getInstance(0).getValue("addresses")).getInstance(0).getValue("cityq"));


      // Class caching
      attributes = parse("(name)");
      query = Query.createRead(getMetadata().getMetaclass("Country"), attributes,
         parse("(= name \"Canada\")"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedInstance.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("Country"), attributes,
         parse("(= name \"Canada\")"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedInstance.xml"), query.read(), attributes);


      // Instance caching
      attributes = parse("(name country)");
      query = Query.createRead(getMetadata().getMetaclass("City"), attributes,
         parse("(= name \"Toronto\")"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedClass.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("City"), attributes,
         parse("(= name \"Toronto\")"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedClass.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("City"), attributes,
         parse("(= (@) (oid \"Toronto\"))"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedClass.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("City"), attributes,
         parse("(= (@) (oid \"Toronto1\"))"), null, -1, 0, false, Query.SEC_NONE, m_context);
      assertEquals(0, query.read().size());


      query = Query.createRead(getMetadata().getMetaclass("City"), attributes,
         parse("(like? name \"Toro*\")"), null, -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedClass.xml"), query.read(), attributes);


      attributes = parse("((countryEnum name) (cityEnum name country))");
      query = Query.createRead(getMetadata().getMetaclass("Address"), attributes,
         null, parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedJoin.xml"), query.read(), attributes);


      query = Query.createRead(getMetadata().getMetaclass("Address"), attributes,
         null, parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedJoin.xml"), query.read(), attributes);


      attributes = parse("((primaryAddress cityEnum))");
      query = Query.createRead(getMetadata().getMetaclass("Contact"), attributes,
         parse("(= (@ primaryAddress cityEnum name) \"Richmond Hill\")"),
         parse("(((@) . #t))"), -1, 0, false, Query.SEC_NONE, m_context);
      AssertUtil.assertEquals(getURL("readCachedMix.xml"), query.read(), attributes);
      
      // Wrong subclass
      query = Query.createRead(getMetadata().getMetaclass("Patient"), null,
         parse("(= (@) (oid #z00000000000000000000000000000001))"), null, -1, 0, false, Query.SEC_NONE, m_context);
      assertEquals(0, query.read().size());


      // Reverse assoc subclass, just create the query
      query = Query.createRead(getMetadata().getMetaclass("BusinessAddress"), null,
         parse("(= (@@ Contact addresses) '())"), null, -1, 0, false, Query.SEC_NONE, m_context);
      
      query = Query.createRead(getMetadata().getMetaclass("Principal"), null,
         parse("(= (@@ User) ())"), null, -1, 0, false, Query.SEC_NONE, m_context);


      // Overriden attribute type, just create the query
      query = Query.createRead(getMetadata().getMetaclass("Patient"), parse("((businessAddress2 main))"),
         null, null, -1, 0, false, Query.SEC_NONE, m_context);


      // SysReader with dispatch


      Instance r1 = new Instance(getMetadata().getMetaclass("SysReader"), Instance.NEW, m_context);


      r1.setValue("class", Symbol.define("Principal"));
      r1.setValue("attributes", parse("(name)"));
      r1.setValue("where", parse("(= name \"users\")"));
      r1.invoke("read");


      Instance r2 = new Instance(getMetadata().getMetaclass("SysReader"), Instance.NEW, m_context);


      r2.setValue("class", Symbol.define("UserGroupAssoc"));
      r2.setValue("attributes", parse("(user group)"));
      r2.setValue("orderBy", parse("(((@) . #t))"));
      
      InstanceList p = new InstanceArrayList();
      p.add(r1);
      r2.setValue("parents", p);
      
      List a = new ArrayList();
      a.add(parse("(ugassocs)"));
      r2.setValue("associations", a);
      r2.setValue("dispatchParent", r1);
      r2.setValue("dispatchAttribute", null);
      r2.setValue("dispatchValues", parse("(Group)"));
      
      AssertUtil.assertEquals(getURL("readFMDispatch1.xml"), r2.invoke("read"), parse("(user group)"));


      r2 = new Instance(getMetadata().getMetaclass("SysReader"), Instance.NEW, m_context);


      r2.setValue("class", Symbol.define("UserGroupAssoc"));
      r2.setValue("attributes", parse("(user group)"));
      r2.setValue("orderBy", parse("(((@) . #t))"));


      p = new InstanceArrayList();
      p.add(r1);
      r2.setValue("parents", p);


      a = new ArrayList();
      a.add(parse("(ugassocs)"));
      r2.setValue("associations", a);
      r2.setValue("dispatchParent", r1);
      r2.setValue("dispatchAttribute", parse("(typeCode)"));
      r2.setValue("dispatchValues", parse("(\"G\")"));


      AssertUtil.assertEquals(getURL("readFMDispatch2.xml"), r2.invoke("read"), parse("(user group)"));


      Instance r3 = new Instance(getMetadata().getMetaclass("SysReader"), Instance.NEW, m_context);


      r3.setValue("class", Symbol.define("Principal"));
      r3.setValue("attributes", parse("(name)"));
      r3.setValue("orderBy", parse("(((@ name) . #t))"));
      
      p = new InstanceArrayList();
      p.add(r1);
      r3.setValue("parents", p);
      
      a = new ArrayList();
      a.add(null);
      r3.setValue("associations", a);

View Full Code Here

   {
      UnitOfWork[] uowArray = new UnitOfWork[2];


      uowArray[0] = m_context.beginTransaction(false);


      InstanceList list =
         Query.createRead(getMetadata().getMetaclass("Contact"),
                          null, null, null, -1, 0, true, Query.SEC_NONE, m_context).read();


      int nTimeout = 1200; // the query timeout in seconds known to be greater than RDBMS setting
      long nStart = System.currentTimeMillis();


      try
      {
         uowArray[1] = m_context.beginTransaction(false);
         assertTrue(list.size() > 0); // need at least one to place lock on


         Query query = Query.createRead(getMetadata().getMetaclass("Contact"),
                                        null, Pair.attribute("").eq(list.get(0)),
                                        null, -1, 0, true, Query.SEC_NONE, m_context);


         query.setTimeout(nTimeout); // ensure query will terminate eventually
         query.read();
         fail(); // LockTimeoutException expected

View Full Code Here


      // Test async invocation on new instances
      getMetadata().getMetaclass("SysQueue").invoke("invoke", new Object[]{contact, Symbol.define("testAsync")});
      getMetadata().getMetaclass("SysQueue").invoke("invoke", new Object[]{contact, Symbol.define("testAsync"), new Object[]{"test"}});


      InstanceList list = (InstanceList)contact.getValue("addresses");
      Instance address = new Instance(getMetadata().getMetaclass("Address"), Instance.NEW, m_context);


      address.setValue("type", "Business");
      address.setValue("country", "USA");


      list.add(address);


      Instance cottage = Query.createRead(getMetadata().getMetaclass("AddressType"),
         parse("(type)"), parse("(and (= type \"Cottage\") (= locale \"en\"))"),
         null, -1, 0, false, Query.SEC_NONE, m_context).read().getInstance(0);


      address = new Instance(getMetadata().getMetaclass("Address"), Instance.NEW, m_context);


      address.setValue("typeEnum", cottage);
      address.setValue("country", "Canada");


      list.add(address);
      contact.setValue("primaryAddress", address);


      contact = new Instance(getMetadata().getMetaclass("Contact"), Instance.NEW, m_context);


      contact.setValue("firstName", "Ronnie");
      contact.setValue("lastName", "Dio");
      contact.setValue("readPrincipal", principal);
      contact.setValue("version", Primitive.ZERO_INTEGER);


      list = (InstanceList)contact.getValue("phones");
      Instance phone = new Instance(getMetadata().getMetaclass("Phone"), Instance.NEW, m_context);


      phone.setValue("type", "Business");
      phone.setValue("number", "(111) 222-3344");


      list.add(phone);
      commit();


      assertEquals(Primitive.ZERO_INTEGER, m_context.getMachine().getGlobalEnvironment().getVariable(Symbol.define("update-count")));
      assertEquals(Primitive.createInteger(2), m_context.getMachine().getGlobalEnvironment().getVariable(Symbol.define("commit-count")));
      
      assertEquals(7, Query.createRead(getMetadata().getMetaclass("Contact"), null,
         parse("(= classCode \"CON\")"), null, -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(2, Query.createRead(getMetadata().getMetaclass("Contact"), null,
         parse("(in? lastName \"Osbourne\" \"Dio\")"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      list = Query.createRead(getMetadata().getMetaclass("Contact"), null,
         parse("(= testCategory \"\")"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read();


      assertEquals(1, list.size());
      assertEquals("", list.getInstance(0).getValue("testCategory"));


      assertEquals(8, Query.createRead(getMetadata().getMetaclass("Contact"), null,
         parse("(null? testCategory)"), null, -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(1, Query.createRead(getMetadata().getMetaclass("Address"), null,
         parse("(and (= (@ contact firstName) \"Ozzy\") (= country \"USA\"))"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(1, Query.createRead(getMetadata().getMetaclass("Address"), null,
         parse("(and (= (@ contact firstName) \"Ozzy\") (= country \"Canada\"))"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(1, Query.createRead(getMetadata().getMetaclass("Phone"), null,
         parse("(= number \"(111) 222-3344\")"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      Instance ref = new Instance(getMetadata().getMetaclass("PrincipalRef2"), Instance.NEW, m_context);


      ref.setValue("name", "a");
      ref.setValue("count", Primitive.createInteger(3));


      ref = new Instance(getMetadata().getMetaclass("PrincipalRef2"), Instance.NEW, m_context);


      ref.setValue("name", "b");


      commit();


      m_context.removeInstance(ref);


      ref = Query.createRead(getMetadata().getMetaclass("PrincipalRef2"), null,
         parse("(= name \"b\")"), null, -1, 0, false, Query.SEC_NONE, m_context).read().getInstance(0);
      ref.setValue("count", Primitive.createInteger(7));


      commit();


      assertEquals(1, Query.createRead(getMetadata().getMetaclass("PrincipalRef2"), null,
         parse("(and (= name \"a\") (= count 3))"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(1, Query.createRead(getMetadata().getMetaclass("PrincipalRef2"), null,
         parse("(and (= name \"b\") (= count 7))"), null,
         -1, 0, false, Query.SEC_NONE, m_context).read().size());


      // KeyGenerator.MaxPlus1 and KeyGenerator.Counter test


      new Instance(getMetadata().getMetaclass("Max1Test"), Instance.NEW, m_context);
      new Instance(getMetadata().getMetaclass("Max1Test"), Instance.NEW, m_context);
      new Instance(getMetadata().getMetaclass("CounterTest"), Instance.NEW, m_context);
      new Instance(getMetadata().getMetaclass("CounterTest"), Instance.NEW, m_context);


      commit();


      assertEquals(2, Query.createRead(getMetadata().getMetaclass("Max1Test"), null,
         null, null, -1, 0, false, Query.SEC_NONE, m_context).read().size());


      assertEquals(2, Query.createRead(getMetadata().getMetaclass("CounterTest"), null,
         null, null, -1, 0, false, Query.SEC_NONE, m_context).read().size());


      // Test non-primitive initializer
      new Instance(getMetadata().getMetaclass("ContactWithInits"), Instance.NEW, m_context);


      commit();
      reset();


      list = Query.createRead(getMetadata().getMetaclass("ContactWithInits"),
         parse("((initAddress city))"), null, null, -1, 0, false, Query.SEC_NONE, m_context).read();


      assertEquals(1, list.size());
      assertEquals("Canada", ((Instance)list.getInstance(0).getValue("initAddress")).getValue("country"));


      // Duplicate unique constraint test
      m_context.setSecure(false);


      Instance wfqueue = new Instance(getMetadata().getMetaclass("SysWorkflowQueue"), Instance.NEW, m_context);


      wfqueue.setOID(new OID(new Object[]{Binary.parse("00000000000000000000000000000001")}));
      wfqueue.setValue("name", "custom");
      wfqueue.setValue("type", "WFLIFOQueue");
      wfqueue.setValue("caption", "LIFO");
      wfqueue.setValue("customized", Boolean.FALSE);


      m_context.setSecure(true);
      
      try
      {
         commit();
         fail("Expected DuplicateKeyException");
      }
      catch (DuplicateKeyException e)
      {
         assertEquals("err.persistence.duplicateKeyClass", e.getErrorCode());
         assertSame(wfqueue, e.getOIDHolder());
         assertEquals("SysWorkflowQueue", e.getClassName());
      }


      rollback();
      
      // Duplicate unique index test
      m_context.setSecure(false);


      wfqueue = new Instance(getMetadata().getMetaclass("SysWorkflowQueue"), Instance.NEW, m_context);
      wfqueue.setValue("name", "lifo");
      wfqueue.setValue("type", "WFLIFOQueue");
      wfqueue.setValue("caption", "LIFO");
      wfqueue.setValue("customized", Boolean.FALSE);


      m_context.setSecure(true);


      try
      {
         commit();
         fail("Expected DuplicateKeyException");
      }
      catch (DuplicateKeyException e)
      {
         assertEquals("err.persistence.duplicateKey", e.getErrorCode());
         assertSame(wfqueue, e.getOIDHolder());
         assertEquals("SysWorkflowQueue", e.getClassName());
      }


      rollback();


      // Composite data source
      metaclass = getMetadata().findMetaclass("CompositeVisit");


      if (metaclass != null)
      {
         Instance visit = new Instance(metaclass, Instance.NEW, m_context);


         visit.setValue("startDate", new Timestamp(0));
         visit.setValue("reason", "a");
         visit.setAnnotation(":shard", new Pair("DefaultRelationalDatabase"));


         visit = new Instance(metaclass, Instance.NEW, m_context);


         visit.setValue("startDate", new Timestamp(1000));
         visit.setValue("reason", "b");
         visit.setAnnotation(":shard", new Pair("ExternalRelationalDatabase"));


         commit();


         metaclass.setValue(":shard", new Pair("DefaultRelationalDatabase"));
         list = Query.createRead(metaclass, parse("(startDate endDate requests)"),
            parse("(and (= startDate #m1970-01-01) (= reason \"a\"))"), null, -1, 0,
            false, Query.SEC_NONE, m_context).read();


         assertEquals(1, list.size());


         metaclass.setValue(":shard", new Pair("ExternalRelationalDatabase"));
         list = Query.createRead(metaclass, parse("(startDate endDate requests)"),
            parse("(and (= startDate #m1970-01-01) (= reason \"a\"))"), null, -1, 0,
            false, Query.SEC_NONE, m_context).read();


         assertEquals(0, list.size());


         list = Query.createRead(metaclass, parse("(startDate endDate requests)"),
            parse("(and (= startDate #m1970-01-01T00:00:01) (= reason \"b\"))"), null, -1, 0,
            false, Query.SEC_NONE, m_context).read();


         assertEquals(1, list.size());


         metaclass = getMetadata().getMetaclass("CompositeVisit2");
         metaclass.setValue(":shard", new Pair("DefaultRelationalDatabase"));
         list = Query.createRead(metaclass, parse("(startDate endDate requests)"),
            parse("(and (= startDate #m1970-01-01) (= reason \"a\"))"), null, -1, 0,
            false, Query.SEC_NONE, m_context).read();


         assertEquals(1, list.size());
      }
   }

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of nexj.core.runtime.InstanceList

nexj.core.admin.etl.DataLoader

nexj.core.integration.format.object.ObjectMessageFormatterStrategy

nexj.core.integration.format.object.ObjectMessageFormatterTest

nexj.core.integration.format.object.ObjectMessageParserTest

nexj.core.meta.Attribute

nexj.core.persistence.file.FileAdapterTest

nexj.core.persistence.file.FileCursor

nexj.core.persistence.GenericCursor

nexj.core.persistence.GenericPersistenceAdapter

nexj.core.persistence.Query

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.