Java > Open Source Codes > org > enhydra > shark > instancepersistence > DODSPersistentManager


1 package org.enhydra.shark.instancepersistence;
2
3 import java.math.BigDecimal ;
4 import java.util.*;
5
6 import org.enhydra.dods.DODS;
7 import org.enhydra.shark.api.RootException;
8 import org.enhydra.shark.api.SharkTransaction;
9 import org.enhydra.shark.api.internal.instancepersistence.*;
10 import org.enhydra.shark.api.internal.working.CallbackUtilities;
11 import org.enhydra.shark.instancepersistence.data.*;
12 import org.enhydra.shark.transaction.SharkDODSTransaction;
13 import org.enhydra.shark.utilities.MiscUtilities;
14 import org.enhydra.shark.utilities.dods.DODSUtilities;
15
16 import com.lutris.appserver.server.sql.DBTransaction;
17 import com.lutris.dods.builder.generator.query.QueryBuilder;
18
19
20 /**
21  * Used to save, restore or delete relevant engine objects from database, using
22  * DODS persistent layer.
23  *
24  * @author Sasa Bojanic
25  * @version 1.0
26  */
27 public class DODSPersistentManager implements PersistentManagerInterface {
28
29    protected static final String LOG_CHANNEL="Persistence";
30    protected static final int RESOURCE_TYPE_OBJECT=0;
31    protected static final int PROCESS_DEFINITION_TYPE_OBJECT=1;
32    protected static final int PROCESS_TYPE_OBJECT=2;
33    protected static final int ACTIVITY_TYPE_OBJECT=3;
34    protected static final int ASSIGNMENT_TYPE_OBJECT=4;
35
36    protected static final String [] activityAndProcessStates={"open.running",
37          "open.not_running.not_started","open.not_running.suspended",
38          "closed.completed", "closed.terminated", "closed.aborted"};
39
40
41    protected static final short DB_TYPE_BOOLEAN=0;
42    protected static final short DB_TYPE_LONG=1;
43    protected static final short DB_TYPE_DOUBLE=2;
44    protected static final short DB_TYPE_VCHAR=3;
45    protected static final short DB_TYPE_DATE=4;
46    protected static final short DB_TYPE_BLOB=5;
47
48    protected static final int MAX_VCHAR_SIZE_LIMIT=4000;
49
50    protected static int max_vchar_size=4000;
51
52    protected CallbackUtilities cus;
53    protected boolean deleteFinishedProcesses=false;
54    protected Map _prStates;
55    protected Map _acStates;
56
57    protected List _prClosedStatesBigDecimals;
58    protected List _actClosedStatesBigDecimals;
59    protected List _actOpenStatesBigDecimals;
60
61    protected boolean usingStandardVariableDataModel=true;
62    
63    public void configure (CallbackUtilities cus) throws RootException {
64       this.cus=cus;
65       String del=cus.getProperty("DODSPersistentManager.deleteFinishedProcesses","false");
66       deleteFinishedProcesses=new Boolean (del).booleanValue();
67       String shtd=cus.getProperty("DatabaseManager.DB.sharkdb.Connection.ShutDownString","");
68       String mvc=cus.getProperty("DODSPersistentManager.maxVARCHARSize","4000");
69       try {
70          max_vchar_size=Integer.parseInt(mvc);
71          if (max_vchar_size>MAX_VCHAR_SIZE_LIMIT || max_vchar_size<1) {
72             max_vchar_size=MAX_VCHAR_SIZE_LIMIT;
73             cus.warn("Invalid value "+mvc+" for property DODSPersistentManager.maxVARCHARSize. Using default value "+max_vchar_size);
74          }
75       } catch (Exception e) {
76          cus.warn("Invalid value "+mvc+" for property DODSPersistentManager.maxVARCHARSize. Using default value "+max_vchar_size);
77       }
78       
79       if (shtd.equals("SHUTDOWN")) {
80          cus.info(LOG_CHANNEL,"DODSPersistentManager -> Adding shutdown hook for HSQL DB");
81          Runtime.getRuntime().addShutdownHook(
82             new Thread () {
83                public void run() {
84                   try {
85                      org.enhydra.dods.DODS.shutdown();
86                   } catch (Throwable thr) {
87                      thr.printStackTrace();
88                   }
89                }
90             }
91          );
92       }
93       usingStandardVariableDataModel=new Boolean (cus.getProperty("DODSPersistentManager.useStandardVariableDataModel","true")).booleanValue();
94       
95       _prStates = new HashMap();
96       _acStates = new HashMap();
97       _prClosedStatesBigDecimals = new ArrayList();
98       _actClosedStatesBigDecimals = new ArrayList();
99       _actOpenStatesBigDecimals = new ArrayList();
100
101       try {
102          try {
103             DODSUtilities.init(cus.getProperties());
104          }
105          catch (Throwable ex) {
106             ex.printStackTrace();
107          }
108          initActivityAndProcessStatesTable();
109          cus.info("DODSPersistentManager -> manager configured - working with DB "+cus.getProperty("DatabaseManager.DB.sharkdb.Connection.Url"));
110          cus.info("DODSPersistentManager -> - using DB Driver "+cus.getProperty("DatabaseManager.DB.sharkdb.JdbcDriver"));
111          cus.info("DODSPersistentManager -> - persisting String variables into BLOB for sizes greater than "+max_vchar_size);
112       }
113       catch (Throwable tr) {
114          tr.printStackTrace();
115          cus.error(LOG_CHANNEL,"Problem with registering database manager with DODS !", new RootException(tr));
116          throw new RootException("Problem with registering database manager with DODS !",tr);
117       }
118    }
119
120    /**
121     * Fills the state table with possible activity and process states. For now,
122     * the 'keyValue' and the 'name' attribute of state record has the same value,
123     * but in the future, if the names of states changes, it will be very easy
124     * to change this table entries without affecting other tables.
125     * NOTE: When new names are introduced, the getPersistentXXX that use it
126     * also has to be changed
127     */
128    protected void initActivityAndProcessStatesTable () throws PersistenceException {
129       DBTransaction t=null;
130       try {
131          t = DODS.getDatabaseManager().createTransaction();
132          for (int i=0; i<activityAndProcessStates.length; i++) {
133             String state=activityAndProcessStates[i];
134             ProcessStateDO psDO=getPersistedProcessStateObject(state,true,t);
135             if (!psDO.isPersistent()) {
136                psDO.setKeyValue(state);
137             }
138             psDO.setName(state);
139             psDO.save(t);
140             BigDecimal bd=psDO.get_OId().toBigDecimal();
141             _prStates.put(state, bd);
142             if (state.startsWith("closed.")) {
143                _prClosedStatesBigDecimals.add(bd);
144             }
145             ActivityStateDO asDO=getPersistedActivityStateObject(state,true,t);
146             if (!asDO.isPersistent()) {
147                asDO.setKeyValue(state);
148             }
149             asDO.setName(state);
150             asDO.save(t);
151
152             BigDecimal bda=asDO.get_OId().toBigDecimal();
153             _acStates.put(state, bda);
154             if (state.startsWith("closed.")) {
155                _actClosedStatesBigDecimals.add(bda);
156             } else {
157                _actOpenStatesBigDecimals.add(bda);
158             }
159          }
160          t.commit();
161       }
162       catch (Throwable thr) {
163          throw new PersistenceException(thr);
164       }
165       finally {
166          try {
167             t.release();
168          } catch (Exception ex) {}
169       }
170    }
171
172    public void shutdownDatabase () throws PersistenceException {
173       try {
174          DODS.shutdown();
175       }
176       catch (Throwable tr) {
177          cus.error(LOG_CHANNEL,"Database is not properly shudown !", new RootException(tr));
178          throw new PersistenceException("Database is not properly shudown !",tr);
179       }
180    }
181
182    public void persist (ProcessMgrPersistenceInterface pm,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
183       try {
184          ProcessDefinitionDO DO=null;
185          if (isInitialPersistence) {
186             DO=ProcessDefinitionDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
187          } else {
188             DO=getPersistedObject(pm,ti);
189          }
190          // when these attributes are persisted - they never change
191 if (isInitialPersistence) {
192             DO.setName(pm.getName());
193             DO.setPackageId(pm.getPackageId());
194             DO.setProcessDefinitionId(pm.getProcessDefinitionId());
195             DO.setProcessDefinitionVersion(pm.getVersion());
196             DO.setProcessDefinitionCreated(pm.getCreated());
197          }
198          DO.setState(pm.getState());
199          ((SharkDODSTransaction)ti).store(DO);
200          //DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
201 //(((SharkDODSTransaction)ti).getDODSTransaction()).write();
202 cus.info(LOG_CHANNEL,"ProcessDefinition[packageId="+pm.getPackageId()+",id="+pm.getProcessDefinitionId()+"] persisted");
203       }
204       catch (Throwable tr) {
205          cus.error(LOG_CHANNEL,"Persisting of ProcessDefinition "+pm.getProcessDefinitionId()+" failed");
206          throw new PersistenceException("Persisting of ProcessDefinition "
207                                            + pm.getProcessDefinitionId()
208                                            +" failed", tr);
209       }
210    }
211
212    public void persist (ProcessPersistenceInterface pr,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
213       try {
214          ProcessDO DO=null;
215          if (isInitialPersistence) {
216             DO=ProcessDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
217          } else {
218             DO=getPersistedObject(pr,ti);
219          }
220          // when these attributes are persisted - they never change
221 if (isInitialPersistence) {
222             DO.setId(pr.getId());
223             DO.setProcessDefinition(getPersistedProcessMgrObject(pr.getProcessMgrName(),ti));
224             //ProcessRequesterDO rDO = getProcessRequester(pr.getId(),ti);
225 ProcessRequesterDO rDO = ProcessRequesterDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
226             rDO.setId(pr.getId());
227             if (pr.getActivityRequesterId()!=null) {
228                rDO.setActivityRequester(getPersistedActivityObject(pr.getActivityRequesterId(),ti));
229             }
230             rDO.setResourceRequester(getPersistedResourceObject(pr.getResourceRequesterId(),ti));
231             DO.setPDefName(pr.getProcessMgrName());
232             DO.setActivityRequesterId(pr.getActivityRequesterId());
233             DO.setActivityRequesterProcessId(pr.getActivityRequestersProcessId());
234             DO.setResourceRequesterId(pr.getResourceRequesterId());
235             ((SharkDODSTransaction)ti).store(rDO);
236          }
237          DO.setExternalRequesterClassName(pr.getExternalRequesterClassName());
238
239          //System.out.println("Going to persist process by filling DO "+DO);
240 DO.setName(pr.getName());
241          DO.setDescription(pr.getDescription());
242          DO.setPriority(pr.getPriority());
243          DO.oid_setState((BigDecimal )_prStates.get(pr.getState()));
244          DO.setCreated(pr.getCreatedTime());
245          DO.setStarted(pr.getStartedTime());
246          DO.setLastStateTime(pr.getLastStateTime());
247          DO.setLimitTime(pr.getLimitTime());
248          ((SharkDODSTransaction)ti).store(DO);
249          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
250 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
251 cus.info(LOG_CHANNEL,"Process[id="+pr.getId()+"] persisted");
252       }
253       catch (Throwable tr) {
254          cus.error(LOG_CHANNEL,"Persisting of Process "+pr.getId()+" failed");
255          throw new PersistenceException("Persisting of Process "
256                                            + pr.getId()
257                                            +" failed", tr);
258       }
259    }
260
261    public void persist (ActivityPersistenceInterface act,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
262       try {
263          //if (act.getActivityDefinitionId().equals("seeFirstRes")) System.out.println("HHH1");
264 ActivityDO DO=null;
265          if (isInitialPersistence) {
266             DO=ActivityDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
267          } else {
268             DO=getPersistedObject(act,ti);
269          }
270          //if (act.getActivityDefinitionId().equals("seeFirstRes")) System.out.println("HHH2");
271 // when these attributes are persisted - they never change
272 if (isInitialPersistence) {
273             DO.setId(act.getId());
274             DO.setActivitySetDefinitionId(act.getActivitySetDefinitionId());
275             DO.setActivityDefinitionId(act.getActivityDefinitionId());
276             DO.setPDefName(act.getProcessMgrName());
277             DO.setProcess(getPersistedProcessObject(act.getProcessId(),ti));
278             DO.setProcessId(act.getProcessId());
279             String bActId=act.getBlockActivityId();
280             if (bActId!=null) {
281                //DO.setBlockActivity(getPersistedActivityObject(bActId,ti));
282 DO.setBlockActivityId(bActId);
283             }
284          }
285          DO.setPerformer(act.getSubflowProcessId());
286          DO.setIsPerformerAsynchronous(act.isSubflowAsynchronous());
287          DO.setName(act.getName());
288          DO.setDescription(act.getDescription());
289          DO.setPriority(act.getPriority());
290          if (!isInitialPersistence && DO.getResourceId()!=act.getResourceUsername()) {
291             DO.setTheResource(getPersistedResourceObject(act.getResourceUsername(),ti));
292             DO.setResourceId(act.getResourceUsername());
293          }
294          DO.oid_setState((BigDecimal )_acStates.get(act.getState()));
295          DO.setLastStateTime(act.getLastStateTime());
296          DO.setLimitTime(act.getLimitTime());
297          DO.setAccepted(act.getAcceptedTime());
298          DO.setActivated(act.getActivatedTime());
299
300          ((SharkDODSTransaction)ti).store(DO);
301          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
302 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
303 cus.info(LOG_CHANNEL,"Activity[id="+act.getId()+",definitionId="+act.getActivityDefinitionId()+"] persisted");
304       }
305       catch (Throwable tr) {
306          cus.error(LOG_CHANNEL,"Persisting of Activity "+act.getId()+" failed");
307          throw new PersistenceException("Persisting of Activity "
308                                            + act.getId()
309                                            +" failed",tr);
310       }
311    }
312
313    public void persist (ResourcePersistenceInterface res,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
314       try {
315          ResourceDO DO=null;
316          if (isInitialPersistence) {
317             DO=ResourceDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
318          } else {
319             DO=getPersistedObject(res,ti);
320          }
321          // when this attribute is persisted - it is never changed
322 if (isInitialPersistence) {
323             DO.setUsername(res.getUsername());
324             DO.setName(res.getName());
325          }
326          ((SharkDODSTransaction)ti).store(DO);
327          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
328 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
329 cus.info(LOG_CHANNEL,"Resource[username="+res.getUsername()+"] persisted");
330       }
331       catch (Throwable tr) {
332          cus.error(LOG_CHANNEL,"Persisting of Resource "+res.getUsername()+" failed");
333          throw new PersistenceException("Persisting of Resource "
334                                            + res.getUsername()+" failed", tr);
335       }
336    }
337
338    public void persist (AssignmentPersistenceInterface ass,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
339       try {
340          AssignmentDO DO=null;
341          if (isInitialPersistence) {
342             DO=AssignmentDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
343          } else {
344             DO=getPersistedObject(ass,ti);
345          }
346 // System.out.println("IIP="+isInitialPersistence+", DO="+DO);
347 // when this attribute is persisted - it is never changed
348 if (isInitialPersistence) {
349             DO.setActivity(getPersistedActivityObject(ass.getActivityId(),ti));
350             DO.setCNT(getNextDecId("_assignment_"));
351             DO.setActivityId(ass.getActivityId());
352             DO.setActivityProcessId(ass.getProcessId());
353             DO.setActivityProcessDefName(ass.getProcessMgrName());
354          }
355          DO.setIsValid(ass.isValid());
356          DO.setIsAccepted(ass.isAccepted());
357          if (ass.getResourceUsername()!=DO.getResourceId()) {
358             DO.setResourceId(ass.getResourceUsername());
359             DO.setTheResource(getPersistedResourceObject(ass.getResourceUsername(),ti));
360          }
361          ((SharkDODSTransaction)ti).store(DO);
362          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
363 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
364 cus.info(LOG_CHANNEL,"Assignment[activityId="+ass.getActivityId()+", username="+ass.getResourceUsername()+"] persisted");
365       }
366       catch (Throwable tr) {
367          cus.error(LOG_CHANNEL,"Persisting of Assignment failed");
368          throw new PersistenceException("Persisting of Assignment failed", tr);
369       }
370    }
371
372    public void persist (AssignmentPersistenceInterface ass,String oldResUname,SharkTransaction ti) throws PersistenceException {
373       try {
374          AssignmentDO DO=getPersistedAssignmentObject(ass.getActivityId(),oldResUname,ti);
375          DO.setTheResource(getPersistedResourceObject(ass.getResourceUsername(),ti));
376          DO.setResourceId(ass.getResourceUsername());
377          DO.setIsValid(ass.isValid());
378          DO.setIsAccepted(ass.isAccepted());
379          ((SharkDODSTransaction)ti).store(DO);
380          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
381 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
382 cus.info(LOG_CHANNEL,"Assignment[activityId="+ass.getActivityId()+", username="+ass.getResourceUsername()+"] persisted");
383       }
384       catch (Throwable tr) {
385          cus.error(LOG_CHANNEL,"Persisting of Assignment failed");
386          throw new PersistenceException("Persisting of Assignment failed", tr);
387       }
388    }
389
390    public void persist (ProcessVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
391       if (usingStandardVariableDataModel) {
392          persistVariablesBLOB(var, isInitialPersistence, ti);
393       } else {
394          persistVariablesWOB(var, isInitialPersistence, ti);
395       }
396    }
397    
398    protected void persistVariablesBLOB (ProcessVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
399       try {
400          ProcessDataDO DO=null;
401          if (isInitialPersistence) {
402             DO=ProcessDataDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
403          } else {
404             DO=getPersistedObject(var,ti);
405          }
406          // when this attribute is persisted - it is never changed
407 if (isInitialPersistence) {
408             DO.setProcess(getPersistedProcessObject(var.getProcessId(),ti));
409             DO.setVariableDefinitionId(var.getDefinitionId());
410          }
411
412          Object vv=var.getValue();
413          boolean isBLOB=false;
414          boolean wasBLOB=false;
415          if (vv instanceof Boolean ) {
416             DO.setVariableValueBOOL(((Boolean )vv).booleanValue());
417             DO.setVariableType(DODSPersistentManager.DB_TYPE_BOOLEAN);
418          } else if (vv instanceof Long ) {
419             DO.setVariableValueLONG(((Long )vv).longValue());
420             DO.setVariableType(DODSPersistentManager.DB_TYPE_LONG);
421          } else if (vv instanceof String ) {
422             String sv=(String )vv;
423             if (sv.length()<=max_vchar_size) {
424                DO.setVariableValueVCHAR(sv);
425                wasBLOB=true;
426                DO.setVariableType(DODSPersistentManager.DB_TYPE_VCHAR);
427             } else {
428                DO.setVariableValueVCHAR(null);
429                isBLOB=true;
430             }
431          } else if (vv instanceof Double ) {
432             DO.setVariableValueDBL(((Double )vv).doubleValue());
433             DO.setVariableType(DODSPersistentManager.DB_TYPE_DOUBLE);
434          } else if (vv instanceof java.util.Date ) {
435             DO.setVariableValueDATE(new java.sql.Timestamp (((java.util.Date )vv).getTime()));
436             DO.setVariableType(DODSPersistentManager.DB_TYPE_DATE);
437          } else if (vv==null) {
438             short vt=DO.getVariableType();
439             if (vt==DODSPersistentManager.DB_TYPE_DATE) {
440                DO.setVariableValueDATE(null);
441             } else if (vt==DODSPersistentManager.DB_TYPE_VCHAR) {
442                DO.setVariableValueVCHAR(null);
443             } else {
444                DO.setVariableValue(null);
445                DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
446             }
447          } else {
448             isBLOB=true;
449          }
450
451          if (isBLOB) {
452             DO.setVariableValue(MiscUtilities.serialize(vv));
453             DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
454          }
455          if (wasBLOB) {
456             DO.setVariableValue(null);
457          }
458          
459          ((SharkDODSTransaction)ti).store(DO);
460          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
461 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
462 cus.info(LOG_CHANNEL,"ProcessVariable[processId="+var.getProcessId()+", definitionId="+var.getDefinitionId()+"] persisted");
463       }
464       catch (Throwable tr) {
465          cus.error(LOG_CHANNEL,"Persisting of ProcessVariable failed");
466          throw new PersistenceException("Persisting of ProcessVariable failed", tr);
467       }
468    }
469       
470    protected void persistVariablesWOB (ProcessVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
471       try {
472          ProcessDataWOBDO DO=null;
473          if (isInitialPersistence) {
474             DO=ProcessDataWOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
475          } else {
476             DO=getPersistedObject2(var,ti);
477          }
478          // when this attribute is persisted - it is never changed
479 if (isInitialPersistence) {
480             DO.setProcess(getPersistedProcessObject(var.getProcessId(),ti));
481             DO.setVariableDefinitionId(var.getDefinitionId());
482          }
483
484          Object vv=var.getValue();
485          boolean isBLOB=false;
486          boolean wasBLOB=false;
487          if (vv instanceof Boolean ) {
488             DO.setVariableValueBOOL(((Boolean )vv).booleanValue());
489             DO.setVariableType(DODSPersistentManager.DB_TYPE_BOOLEAN);
490          } else if (vv instanceof Long ) {
491             DO.setVariableValueLONG(((Long )vv).longValue());
492             DO.setVariableType(DODSPersistentManager.DB_TYPE_LONG);
493          } else if (vv instanceof String ) {
494             String sv=(String )vv;
495             if (sv.length()<=max_vchar_size) {
496                DO.setVariableValueVCHAR(sv);
497                wasBLOB=true;
498                DO.setVariableType(DODSPersistentManager.DB_TYPE_VCHAR);
499             } else {
500                DO.setVariableValueVCHAR(null);
501                isBLOB=true;
502             }
503          } else if (vv instanceof Double ) {
504             DO.setVariableValueDBL(((Double )vv).doubleValue());
505             DO.setVariableType(DODSPersistentManager.DB_TYPE_DOUBLE);
506          } else if (vv instanceof java.util.Date ) {
507             DO.setVariableValueDATE(new java.sql.Timestamp (((java.util.Date )vv).getTime()));
508             DO.setVariableType(DODSPersistentManager.DB_TYPE_DATE);
509          } else if (vv==null) {
510             short vt=DO.getVariableType();
511             if (vt==DODSPersistentManager.DB_TYPE_DATE) {
512                DO.setVariableValueDATE(null);
513             } else if (vt==DODSPersistentManager.DB_TYPE_VCHAR) {
514                DO.setVariableValueVCHAR(null);
515             } else {
516                ProcessDataBLOBDO bDO=null;
517                if (isInitialPersistence) {
518                   bDO=ProcessDataBLOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
519                } else {
520                   bDO=getPersistedObject(DO, ti);
521                }
522                bDO.setProcessDataWOB(DO);
523                bDO.setVariableValue(null);
524                DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
525                ((SharkDODSTransaction)ti).store(bDO);
526             }
527          } else {
528             isBLOB=true;
529          }
530
531          if (isBLOB) {
532             ProcessDataBLOBDO bDO=null;
533             if (isInitialPersistence) {
534                bDO=ProcessDataBLOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
535             } else {
536                bDO=getPersistedObject(DO, ti);
537             }
538             bDO.setProcessDataWOB(DO);
539             bDO.setVariableValue(MiscUtilities.serialize(vv));
540             DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
541             ((SharkDODSTransaction)ti).store(bDO);
542          }
543 // if (wasBLOB) {
544 // DO.setVariableValue(null);
545 // }
546
547          ((SharkDODSTransaction)ti).store(DO);
548          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
549 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
550 cus.info(LOG_CHANNEL,"ProcessVariable[processId="+var.getProcessId()+", definitionId="+var.getDefinitionId()+"] persisted");
551       }
552       catch (Throwable tr) {
553          cus.error(LOG_CHANNEL,"Persisting of ProcessVariable failed");
554          throw new PersistenceException("Persisting of ProcessVariable failed", tr);
555       }
556    }
557
558    public void persist (ActivityVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
559       if (usingStandardVariableDataModel) {
560          persistVariablesBLOB(var, isInitialPersistence, ti);
561       } else {
562          persistVariablesWOB(var, isInitialPersistence, ti);
563       }
564    }
565
566    public void persistVariablesBLOB (ActivityVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
567       try {
568          ActivityDataDO DO=null;
569          if (isInitialPersistence) {
570             DO=ActivityDataDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
571          } else {
572             DO=getPersistedObject(var,ti);
573          }
574          // when this attribute is persisted - it is never changed
575 if (isInitialPersistence) {
576             DO.setActivity(getPersistedActivityObject(var.getActivityId(),ti));
577             DO.setVariableDefinitionId(var.getDefinitionId());
578          }
579
580          Object vv=var.getValue();
581          boolean isBLOB=false;
582          boolean wasBLOB=false;
583          if (vv instanceof Boolean ) {
584             DO.setVariableValueBOOL(((Boolean )vv).booleanValue());
585             DO.setVariableType(DODSPersistentManager.DB_TYPE_BOOLEAN);
586          } else if (vv instanceof Long ) {
587             DO.setVariableValueLONG(((Long )vv).longValue());
588             DO.setVariableType(DODSPersistentManager.DB_TYPE_LONG);
589          } else if (vv instanceof String ) {
590             String sv=(String )vv;
591             if (sv.length()<=max_vchar_size) {
592                DO.setVariableValueVCHAR(sv);
593                wasBLOB=true;
594                DO.setVariableType(DODSPersistentManager.DB_TYPE_VCHAR);
595             } else {
596                DO.setVariableValueVCHAR(null);
597                isBLOB=true;
598             }
599          } else if (vv instanceof Double ) {
600             DO.setVariableValueDBL(((Double )vv).doubleValue());
601             DO.setVariableType(DODSPersistentManager.DB_TYPE_DOUBLE);
602          } else if (vv instanceof java.util.Date ) {
603             DO.setVariableValueDATE(new java.sql.Timestamp (((java.util.Date )vv).getTime()));
604             DO.setVariableType(DODSPersistentManager.DB_TYPE_DATE);
605          } else if (vv==null) {
606             short vt=DO.getVariableType();
607             if (vt==DODSPersistentManager.DB_TYPE_DATE) {
608                DO.setVariableValueDATE(null);
609             } else if (vt==DODSPersistentManager.DB_TYPE_VCHAR) {
610                DO.setVariableValueVCHAR(null);
611             } else {
612                DO.setVariableValue(null);
613                DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
614             }
615          } else {
616             isBLOB=true;
617          }
618
619          if (isBLOB) {
620             DO.setVariableValue(MiscUtilities.serialize(vv));
621             DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
622          }
623          if (wasBLOB) {
624             DO.setVariableValue(null);
625          }
626
627          DO.setIsResult(var.isResultVariable());
628          ((SharkDODSTransaction)ti).store(DO);
629          //if (DO.isDirty()) DO.save(((SharkDODSTransaction)ti).getDODSTransaction());
630 //if (DO.isVirgin()) {(((SharkDODSTransaction)ti).getDODSTransaction()).write();}
631 cus.info(LOG_CHANNEL,"ActivityVariable[activityId="+var.getActivityId()+", definitionId="+var.getDefinitionId()+"] persisted");
632       }
633       catch (Throwable tr) {
634          cus.error(LOG_CHANNEL,"Persisting of ActivityVariable failed");
635          throw new PersistenceException("Persisting of ActivityVariable failed", tr);
636       }
637    }
638    
639    public void persistVariablesWOB (ActivityVariablePersistenceInterface var,boolean isInitialPersistence,SharkTransaction ti) throws PersistenceException {
640       try {
641          ActivityDataWOBDO DO=null;
642          if (isInitialPersistence) {
643             DO=ActivityDataWOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
644          } else {
645             DO=getPersistedObject2(var,ti);
646          }
647          // when this attribute is persisted - it is never changed
648 if (isInitialPersistence) {
649             DO.setActivity(getPersistedActivityObject(var.getActivityId(),ti));
650             DO.setVariableDefinitionId(var.getDefinitionId());
651          }
652
653          Object vv=var.getValue();
654          boolean isBLOB=false;
655          boolean wasBLOB=false;
656          if (vv instanceof Boolean ) {
657             DO.setVariableValueBOOL(((Boolean )vv).booleanValue());
658             DO.setVariableType(DODSPersistentManager.DB_TYPE_BOOLEAN);
659          } else if (vv instanceof Long ) {
660             DO.setVariableValueLONG(((Long )vv).longValue());
661             DO.setVariableType(DODSPersistentManager.DB_TYPE_LONG);
662          } else if (vv instanceof String ) {
663             String sv=(String )vv;
664             if (sv.length()<=max_vchar_size) {
665                DO.setVariableValueVCHAR(sv);
666                wasBLOB=true;
667                DO.setVariableType(DODSPersistentManager.DB_TYPE_VCHAR);
668             } else {
669                DO.setVariableValueVCHAR(null);
670                isBLOB=true;
671             }
672          } else if (vv instanceof Double ) {
673             DO.setVariableValueDBL(((Double )vv).doubleValue());
674             DO.setVariableType(DODSPersistentManager.DB_TYPE_DOUBLE);
675          } else if (vv instanceof java.util.Date ) {
676             DO.setVariableValueDATE(new java.sql.Timestamp (((java.util.Date )vv).getTime()));
677             DO.setVariableType(DODSPersistentManager.DB_TYPE_DATE);
678          } else if (vv==null) {
679             short vt=DO.getVariableType();
680             if (vt==DODSPersistentManager.DB_TYPE_DATE) {
681                DO.setVariableValueDATE(null);
682             } else if (vt==DODSPersistentManager.DB_TYPE_VCHAR) {
683                DO.setVariableValueVCHAR(null);
684             } else {
685                ActivityDataBLOBDO bDO=null;
686                if (isInitialPersistence) {
687                   bDO=ActivityDataBLOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
688                } else {
689                   bDO=getPersistedObject(DO, ti);
690                }
691                bDO.setActivityDataWOB(DO);
692                bDO.setVariableValue(null);
693                DO.setVariableType(DODSPersistentManager.DB_TYPE_BLOB);
694                ((SharkDODSTransaction)ti).store(bDO);
695             }
696          } else {
697             isBLOB=true;
698          }
699
700          if (isBLOB) {
701             ActivityDataBLOBDO bDO=null;
702             if (isInitialPersistence) {
703                bDO=ActivityDataBLOBDO.createVirgin(((SharkDODSTransaction)ti).getDODSTransaction());
7