KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > serversystem > SaveModeConnection


1 package com.daffodilwoods.daffodildb.server.serversystem;
2
3 import java.util.*;
4
5 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
6 import com.daffodilwoods.daffodildb.server.sessionsystem.*;
7 import com.daffodilwoods.daffodildb.server.sql99.*;
8 import com.daffodilwoods.daffodildb.server.sql99.common.*;
9 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqlcontrolstatement.*;
10 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqlsessionstatement.*;
11 import com.daffodilwoods.daffodildb.server.sql99.dcl.sqltransactionstatement.*;
12 import com.daffodilwoods.daffodildb.server.sql99.ddl.schemamanipulation.*;
13 import com.daffodilwoods.daffodildb.server.sql99.dml.*;
14 import com.daffodilwoods.daffodildb.server.sql99.dml.declarecursor.*;
15 import com.daffodilwoods.daffodildb.server.sql99.dql.execution.*;
16 import com.daffodilwoods.daffodildb.server.sql99.dql.listenerevents.*;
17 import com.daffodilwoods.daffodildb.server.sql99.dql.queryexpression.*;
18 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
19 import com.daffodilwoods.daffodildb.utils.parser.*;
20 import com.daffodilwoods.database.general.*;
21 import com.daffodilwoods.database.resource.*;
22
23 public class SaveModeConnection extends Connection {
24
25   private SaveModeHandler saveModeHandler;
26   private Object JavaDoc saveModeSessionId;
27
28   public SaveModeConnection(String JavaDoc databaseURL, _UserSession userSession,ServerSystem serverSystem) throws DException {
29     super(databaseURL, userSession, serverSystem);
30     saveModeSessionId = userSession.getSession().getSessionId();
31     Session session = (Session) userSession.getSession();
32     saveModeHandler = session.sessionDatabase.getSaveModeHandler(serverSystem.getDaffodilHome());
33   }
34
35   public Object JavaDoc execute(Object JavaDoc parsedQuery, int queryTimeOut, int type) throws
36       DException {
37     if (parsedQuery instanceof queryexpression) {
38       if(!userSession.getAutoCommit() ){
39         userSession.startTransaction() ;
40       }
41
42       int tp = getType();
43       queryexpression qurexp = (queryexpression) parsedQuery;
44       ServerSessionWrapper sersewr = new ServerSessionWrapper(this);
45       if(qurexp.isSimpleQuery(sersewr)){
46          if(type == IteratorConstants.UPDATABLE){
47             tp = IteratorConstants.UPDATABLE;
48          }
49       }else{
50          tp = IteratorConstants.NONSCROLLABLE;
51       }
52       sersewr.setType(tp);
53       _Executer executer = (_Executer) (qurexp).run(sersewr);
54       return executer.execute( (Object JavaDoc[])null);
55     }
56
57     if (parsedQuery instanceof SQLschemastatement) {
58       commit();
59       _ServerSession ss = getSystemServerSession();
60       if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
61           equalsIgnoreCase("Read Only"))
62         throw new DException("DSE1184", (Object JavaDoc[])null);
63       Object JavaDoc returnedObject = null;
64       _DataDictionary dd = getDataDictionary();
65       dd.lockDDL();
66       try {
67         try {
68           returnedObject = ( (SQLschemastatement) parsedQuery).run(this);
69         }
70         catch (DException ex) {
71           dd.restoreGeneratedKeys();
72           ss.rollback();
73           throw ex;
74         }
75          if(!(parsedQuery instanceof dropdatabasestatement))
76            ss.commit();
77       }
78       finally {
79         dd.releaseDDL();
80       }
81       saveModeHandler.write(saveModeSessionId,parsedQuery);
82       if (returnedObject == null)
83         return new Integer JavaDoc(Integer.MIN_VALUE);
84       return returnedObject;
85     }
86     if (parsedQuery instanceof SQLtransactionstatement) {
87       Object JavaDoc returnedObject = ( (SQLtransactionstatement) parsedQuery).run(this);
88       saveModeHandler.write(saveModeSessionId,parsedQuery);
89         return new Integer JavaDoc(Integer.MIN_VALUE);
90
91     }
92     if (parsedQuery instanceof SQLsessionstatement) {
93       _StatementExecutionContext sec = getStatementExecutionContext();
94       Object JavaDoc returnedObject = ( (SQLsessionstatement) parsedQuery).run(sec);
95         return new Integer JavaDoc(Integer.MIN_VALUE);
96     }
97
98     if (parsedQuery instanceof SQLdatastatement) {
99       if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
100           equalsIgnoreCase("Read Only"))
101         throw new DException("DSE1184", (Object JavaDoc[])null);
102       _StatementExecutionContext sec = getStatementExecutionContext();
103       _Executer executer = (_Executer) ( (SQLdatastatement) parsedQuery).run(
104           sec);
105       Object JavaDoc returnedObject = executer.execute( (_VariableValues)null);
106       saveModeHandler.write(saveModeSessionId,parsedQuery);
107       if (returnedObject == null)
108         return new Integer JavaDoc(Integer.MIN_VALUE);
109       return returnedObject;
110     }
111     if (parsedQuery instanceof SQLcontrolstatement) {
112       _StatementExecutionContext sec = getStatementExecutionContext();
113       _Executer executer = (_Executer) ( (SQLcontrolstatement) parsedQuery).run(
114           sec);
115       Object JavaDoc returnedObject = executer.execute( (_VariableValues)null);
116       if (returnedObject == null)
117         return new Integer JavaDoc(Integer.MIN_VALUE);
118       return returnedObject;
119     }
120
121     throw new DException("DSE531", null);
122   }
123
124   public Object JavaDoc execute(String JavaDoc query, int queryTimeOut, int type, int queryType,
125                         int autoGeneratedType, Object JavaDoc autoGenetatedValues) throws
126       DException {
127     try {
128       Object JavaDoc parsedQuery = Parser.parseQuery(query);
129       if (parsedQuery instanceof SQLdatastatement) {
130         if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
131             equalsIgnoreCase("Read Only"))
132           throw new DException("DSE1184", (Object JavaDoc[])null);
133         _StatementExecutionContext sec = getStatementExecutionContext();
134         sec.setAutoGeneratedInfo(autoGeneratedType, autoGenetatedValues);
135         _Executer executer = (_Executer) ( (SQLdatastatement) parsedQuery).run(
136             sec);
137         Object JavaDoc ob = executer.execute( (_VariableValues)null);
138         saveModeHandler.write(saveModeSessionId,parsedQuery);
139         return ob;
140       }
141       else{
142         if(queryType == _Connection.EXECUTE)
143           return execute(parsedQuery, queryTimeOut, type);
144         else
145           return executeUpdate(parsedQuery, queryTimeOut) ;
146       }
147     }
148     catch (DException de) {
149       throw de;
150     }
151     catch (RuntimeException JavaDoc de) {
152       throw de;
153     }
154   }
155
156   public Object JavaDoc executeUpdate(Object JavaDoc parsedObject, int queryTimeOut) throws
157       DException {
158     if (parsedObject instanceof SQLdatastatement) {
159       if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
160           equalsIgnoreCase("Read Only"))
161         throw new DException("DSE1184", (Object JavaDoc[])null);
162       _StatementExecutionContext sec = getStatementExecutionContext();
163       _Executer executer = (_Executer) ( (SQLdatastatement) parsedObject).run(
164           sec);
165       Object JavaDoc returnedObject = executer.execute( (_VariableValues)null);
166       saveModeHandler.write(saveModeSessionId,parsedObject);
167       if (returnedObject == null)
168         return new Integer JavaDoc(Integer.MIN_VALUE);
169       return returnedObject;
170     }
171     else if (parsedObject instanceof SQLschemastatement) {
172       commit();
173       _ServerSession ss = getSystemServerSession();
174       if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
175           equalsIgnoreCase("Read Only"))
176         throw new DException("DSE1184", (Object JavaDoc[])null);
177       Object JavaDoc returnedObject = null;
178       _DataDictionary dd = getDataDictionary();
179       dd.lockDDL();
180       try {
181         try {
182           returnedObject = ( (SQLschemastatement) parsedObject).run(this);
183         }
184         catch (DException ex) {
185           dd.restoreGeneratedKeys();
186           ss.rollback();
187           throw ex;
188         }
189         ss.commit();
190       }
191       finally {
192         dd.releaseDDL();
193       }
194       saveModeHandler.write(saveModeSessionId,parsedObject);
195       if (returnedObject == null)
196         return new Integer JavaDoc(Integer.MIN_VALUE);
197       return returnedObject;
198     }
199     throw new DException("DSE533", null);
200   }
201
202   public void setAutoCommit(boolean autoCommit0) throws DException {
203     if (userSession.getAutoCommit() != autoCommit0) {
204       if (userSession.getAutoCommit()== false)
205         commit();
206       userSession.setAutoCommit(autoCommit0) ;
207       saveModeHandler.write(saveModeSessionId,
208                             autoCommit0 ? SaveModeHandler.SETCOMMITON
209                             : SaveModeHandler.SETCOMMITOFF);
210     }
211   }
212
213   public _PreparedStatement getPreparedStatement(Object JavaDoc parsedQuery,String JavaDoc query,int type) throws DException{
214      if( parsedQuery instanceof queryexpression ){
215          queryexpression qurexp = (queryexpression)parsedQuery;
216          ServerSessionWrapper sersewr = new ServerSessionWrapper(this);
217          if(type == IteratorConstants.UPDATABLE)
218            if(!qurexp.isSimpleQuery(sersewr))
219              type = IteratorConstants.NONSCROLLABLE;
220           sersewr.setType(type);
221           _Executer executer = (_Executer) qurexp.run( sersewr );
222           ParameterMetaData parameterMetaData = new ParameterMetaData(query, qurexp.getParameterInfo());
223           Object JavaDoc[] parameters = qurexp.getParameters(this);
224          PreparedStatement preparedStatment = new PreparedStatement(executer,
225                                                     parameters == null
226                                                     ? 0 : parameters.length,parameterMetaData,query, verboseUser,this);
227          preparedStatment.setQueryType(PreparedStatement.queryexpression);
228          return preparedStatment;
229       }
230       if( parsedQuery instanceof SQLdatastatement ){
231           if( ((String JavaDoc)getUserSession().getTransactionAccessMode()).equalsIgnoreCase("Read Only"))
232               throw new DException("DSE1184", (Object JavaDoc[])null);
233
234           _StatementExecutionContext sec = getStatementExecutionContext();
235           SQLdatastatement sqldatastatement = (SQLdatastatement)parsedQuery;
236           Object JavaDoc[] parameters = sqldatastatement.getParameters(this);
237           _Executer executer = (_Executer) sqldatastatement.run( sec );
238           ParameterMetaData parameterMetaData = new ParameterMetaData(query, ((SQLdatachangestatement) parsedQuery).getParameterInfo());
239           SaveModePreparedStatement preparedStatment = new SaveModePreparedStatement(executer,
240                                                  parameters == null ? 0: parameters.length ,parameterMetaData ,query, verboseUser, saveModeHandler, saveModeSessionId, this);
241           preparedStatment.setQueryType(PreparedStatement.SQLdatastatement);
242           return preparedStatment;
243
244       }
245       if(parsedQuery instanceof SQLschemastatement ){
246           if( ((String JavaDoc)getUserSession().getTransactionAccessMode()).equalsIgnoreCase("Read Only"))
247               throw new DException("DSE1184", (Object JavaDoc[])null);
248           SaveModeNonPreparedStatement nps = new SaveModeNonPreparedStatement(this, (StatementExecuter)parsedQuery, verboseUser, saveModeHandler, saveModeSessionId);
249           nps.setQueryType(PreparedStatement.SQLschemastatement);
250           return nps;
251       }
252       if( parsedQuery instanceof SQLtransactionstatement ){
253           SaveModeNonPreparedStatement nps = new SaveModeNonPreparedStatement(this, (StatementExecuter)parsedQuery, verboseUser, saveModeHandler, saveModeSessionId);
254           nps.setQueryType(PreparedStatement.SQLtransactionstatement);
255           return nps;
256
257       }
258       if( parsedQuery instanceof SQLsessionstatement ){
259           NonPreparedStatement nps = new NonPreparedStatement(this, (StatementExecuter)parsedQuery, verboseUser);
260           nps.setQueryType(PreparedStatement.SQLsessionstatement);
261           return nps;
262       }
263       if( parsedQuery instanceof SQLcontrolstatement ){
264
265           _StatementExecutionContext sec = getStatementExecutionContext();
266           SQLcontrolstatement sqlcontrolstatement = (SQLcontrolstatement)parsedQuery;
267           Object JavaDoc[] parameters = sqlcontrolstatement.getParameters(this);
268           _Executer executer = (_Executer) sqlcontrolstatement.run( sec );
269           ParameterMetaData pmd = new ParameterMetaData(query,sqlcontrolstatement.getParameterInfo());
270           PreparedStatement preparedStatment = new PreparedStatement(executer,
271                                                  parameters == null ? 0: parameters.length ,pmd,query, verboseUser,this);
272           preparedStatment.setQueryType(PreparedStatement.callstatement);
273           return preparedStatment;
274
275       }
276     throw new DException("DSE565",new Object JavaDoc[]{"Query"});
277   }
278
279
280   public void commit() throws DException {
281     if (connectionStatus)
282       throw new DatabaseException("DSE279", null);
283     if ( ( (String JavaDoc) getUserSession().getTransactionAccessMode()).
284         equalsIgnoreCase("Read Only"))
285       throw new DException("DSE1184", (Object JavaDoc[])null);
286     if (commit) {
287       _StatementExecutionContext statementExecutionContext =
288           getStatementExecutionContext();
289       _TriggerExecutionContext triggerExecutionContext = new
290           TriggerExecutionContext();
291       statementExecutionContext.setTriggerExecutionContext(
292           triggerExecutionContext);
293       userSession.commit(statementExecutionContext);
294       userSession.getSavePointVector().clear();
295       saveModeHandler.write(saveModeSessionId,SaveModeHandler.COMMIT);
296     }
297   }
298
299   public void rollback() throws DException {
300     if (connectionStatus)
301       throw new DatabaseException("DSE279", null);
302     if (getUserSession().getTransactionAccessMode().equals("Read Only"))
303       throw new DException("DSE1184", (Object JavaDoc[])null);
304
305     if (commit) {
306       _StatementExecutionContext statementExecutionContext =
307           getStatementExecutionContext();
308       TriggerExecutionContext triggerExecutionContext = new
309           TriggerExecutionContext();
310       statementExecutionContext.setTriggerExecutionContext(
311           triggerExecutionContext);
312       userSession.rollback(statementExecutionContext);
313       userSession.getSavePointVector().clear();
314       saveModeHandler.write(saveModeSessionId,SaveModeHandler.ROLLBACK);
315     }
316   }
317
318   public String JavaDoc setSavePoint() throws DException {
319     String JavaDoc savepoint = "sp" + userSession.getSavePointVector().size();
320     setSavePoint(savepoint);
321     saveModeHandler.write(saveModeSessionId,SaveModeHandler.SETSAVEPOINT,savepoint);
322     return savepoint;
323   }
324
325   public void setSavePoint(String JavaDoc savepoint) throws DException {
326     ArrayList savePointVector = userSession.getSavePointVector();
327     if (!savePointVector.contains(savepoint)) {
328       userSession.addSavePoint(savepoint);
329       userSession.startSavePoint();
330       saveModeHandler.write(saveModeSessionId,SaveModeHandler.SETSAVEPOINT,savepoint);
331     }
332     else
333       throw new DException("DSE889", new Object JavaDoc[] {savepoint});
334   }
335
336   public void releaseSavePoint(String JavaDoc savepoint) throws DException {
337     ArrayList savePointVector = userSession.getSavePointVector();
338     int index = savePointVector.indexOf(savepoint);
339     if (index == -1)
340       throw new DException("DSE890", null);
341     userSession = commitUptoLevel(userSession, getStatementExecutionContext(),
342                                   savePointVector.size() - index);
343     saveModeHandler.write(saveModeSessionId,SaveModeHandler.RELEASESAVEPOINT,savepoint);
344   }
345
346   public void rollbackSavePoint(String JavaDoc savepoint) throws DException {
347     ArrayList userSavepointVector = userSession.getSavePointVector();
348     _StatementExecutionContext sec = getStatementExecutionContext();
349     if (savepoint != null) {
350       int index = userSavepointVector.indexOf(savepoint);
351       if (index < 0)
352         throw new DException("DSE877", null);
353       CommitToParentAndRollback(userSession, sec,
354                                 userSavepointVector.size() - index);
355       userSession.rollbackSavePoint(sec);
356       userSession.releaseLastSavePoint();
357     }
358     else {
359       CommitToParentAndRollback(userSession, sec,
360                                 userSavepointVector.size() + 1);
361       userSession.rollback(sec);
362     }
363     saveModeHandler.write(saveModeSessionId,SaveModeHandler.ROLLBACKSAVEPOINT,savepoint);
364   }
365
366   public void commitSavePoint() throws DException {
367     userSession.commitSavePoint(getStatementExecutionContext());
368     saveModeHandler.write(saveModeSessionId,SaveModeHandler.COMMITSAVEPOINT);
369   }
370
371   public void close() throws DException {
372     try {
373       userSession.rollback(getStatementExecutionContext());
374     }
375     catch (DException e) {}
376     connectionStatus = true;
377     serverSystem.close(databaseURL, this);
378     saveModeHandler.write(saveModeSessionId,SaveModeHandler.CLOSE);
379   }
380
381
382   public Object JavaDoc[] executeBatch(String JavaDoc query) throws DException{
383
384     Object JavaDoc[] parsedQuery = null;
385     try {
386       parsedQuery = (Object JavaDoc [])Parser.parseBatch(query);
387     }
388     catch (DException ex) {
389       PrintHandler.print(query, verboseUser, ex);
390       throw ex;
391     }
392     Object JavaDoc[] result = new Object JavaDoc[parsedQuery.length];
393     for (int i = 0; i < result.length; i++) {
394       PrintHandler.print(" " + parsedQuery[i].toString());
395        if( parsedQuery[i] instanceof insertstatement){
396           if(super.userSession.getTransactionAccessMode().equals("Read Only"))
397              throw new DException("DSE1184", (Object JavaDoc[])null);
398
399           insertstatement in = (insertstatement) parsedQuery[i];
400           _StatementExecutionContext sec = getStatementExecutionContext();
401           in.run( sec );
402           ParameterInfo[] parameterInfo = in.getParameterInfo();
403           if( parameterInfo != null && parameterInfo.length > 0){
404              ParameterMetaData parameterMetaData = new ParameterMetaData(query, parameterInfo);
405              QueryInfo qi = new QueryInfo(parsedQuery[i].toString(), QueryInfo.INSERT, parameterMetaData );
406              result[i] = qi;
407           }
408           else
409           {
410              QueryInfo qi = new QueryInfo(parsedQuery[i].toString(), QueryInfo.INSERT , null );
411              result[i] = qi;
412           }
413        }
414        else if( parsedQuery[i] instanceof updatestatementsearched){
415           if(super.userSession.getTransactionAccessMode().equals("Read Only"))
416              throw new DException("DSE1184", (Object JavaDoc[])null);
417           updatestatementsearched up = (updatestatementsearched) parsedQuery[i];
418           _StatementExecutionContext sec = getStatementExecutionContext();
419           up.run( sec );
420           ParameterInfo[] parameterInfo = up.getParameterInfo();
421           if( parameterInfo != null && parameterInfo.length > 0){
422              ParameterMetaData parameterMetaData = new ParameterMetaData(query, parameterInfo);
423              QueryInfo qu = new QueryInfo(parsedQuery[i].toString(), QueryInfo.UPDATE, parameterMetaData );
424              result[i] = qu;
425           }
426           else
427           {
428              QueryInfo qu = new QueryInfo(parsedQuery[i].toString(), QueryInfo.UPDATE, null );
429              result[i] = qu;
430           }
431
432        }
433        else if(parsedQuery[i] instanceof deletestatementsearched){
434           if(super.userSession.getTransactionAccessMode().equals("Read Only"))
435              throw new DException("DSE1184", (Object JavaDoc[])null);
436           deletestatementsearched ds = (deletestatementsearched) parsedQuery[i];
437           _StatementExecutionContext sec = getStatementExecutionContext();
438           ds.run( sec );
439           ParameterInfo[] parameterInfo = ds.getParameterInfo();
440           if( parameterInfo != null && parameterInfo.length > 0){
441              ParameterMetaData parameterMetaData = new ParameterMetaData(query, parameterInfo);
442              QueryInfo qd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.DELETE, parameterMetaData );
443              result[i] = qd;
444           }
445           else
446           {
447              QueryInfo qd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.DELETE, null );
448              result[i] = qd;
449           }
450        }
451        else if(parsedQuery[i] instanceof queryexpression){
452           queryexpression qs = (queryexpression) parsedQuery[i];
453           qs.checkSemantic( this,true );
454           ParameterInfo[] parameterInfo = qs.getParameterInfo();
455           if( parameterInfo != null && parameterInfo.length > 0 ){
456              ParameterMetaData parameterMetaData = new ParameterMetaData(query, parameterInfo);
457              QueryInfo qsd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.SELECT, parameterMetaData );
458              result[i] = qsd;
459           }
460           else
461           {
462              QueryInfo qsd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.SELECT, null );
463              result[i] = qsd;
464           }
465        }
466        else if(parsedQuery[i] instanceof SQLcontrolstatement){
467           SQLcontrolstatement cs = (SQLcontrolstatement) parsedQuery[i];
468           _StatementExecutionContext sec = getStatementExecutionContext();
469           cs.run(sec);
470           ParameterInfo[] parameterInfo = cs.getParameterInfo();
471           if( parameterInfo != null && parameterInfo.length > 0 ){
472              ParameterMetaData parameterMetaData = new ParameterMetaData(query, parameterInfo);
473              QueryInfo qsd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.CALLSTATEMENT, parameterMetaData );
474              result[i] = qsd;
475           }
476           else
477           {
478              QueryInfo qsd = new QueryInfo(parsedQuery[i].toString(), QueryInfo.CALLSTATEMENT, null );
479              result[i] = qsd;
480           }
481        }
482        else{
483            if( parsedQuery[i] instanceof SQLsessionstatement ){
484                _StatementExecutionContext sec = getStatementExecutionContext();
485                ((SQLsessionstatement)parsedQuery[i]).run( sec );
486            }else if (parsedQuery[i] instanceof SQLschemastatement ){
487              commit();
488              _ServerSession ss = getSystemServerSession();
489              _DataDictionary dd = getDataDictionary();
490              dd.lockDDL();
491             try {
492               try {
493                 ( (StatementExecuter) parsedQuery[i]).run(this);
494               }
495               catch (DException ex) {
496                 dd.restoreGeneratedKeys();
497                 ss.rollback();
498                 throw ex;
499               }
500               if(!(parsedQuery[i] instanceof dropdatabasestatement))
501                 ss.commit();
502             }
503             finally {
504               dd.releaseDDL();
505             }
506             saveModeHandler.write(saveModeSessionId, parsedQuery[i]);
507            }
508            else if(parsedQuery[i] instanceof SQLdatastatement) {
509              throw new DException("DSE8090",null);
510            }
511            else if(parsedQuery[i] instanceof declarecursor) {
512               declarecursor ds = (declarecursor) parsedQuery[i];
513               _StatementExecutionContext sec = getStatementExecutionContext();
514               ds.run( sec );
515            }
516            else if(parsedQuery[i] instanceof SQLtransactionstatement) {
517               SQLtransactionstatement sts = (SQLtransactionstatement) parsedQuery[i];
518               sts.run( this );
519               saveModeHandler.write(saveModeSessionId, parsedQuery[i]);
520            }
521            else
522              ( (StatementExecuter) parsedQuery[i]).run(this);
523            result[i] = new QueryInfo(parsedQuery[i].toString(), QueryInfo.OTHERS, null);
524        }
525     }
526     return result;
527   }
528
529   public SaveModeHandler getSaveModeHandler() {
530     return saveModeHandler;
531   }
532 }
533
Popular Tags