KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > serversystem > dmlvalidation > triggersystem > TriggerTable


1 package com.daffodilwoods.daffodildb.server.serversystem.dmlvalidation.triggersystem;
2
3 import java.util.*;
4
5 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
6 import com.daffodilwoods.daffodildb.server.datasystem.utility.*;
7 import com.daffodilwoods.daffodildb.server.serversystem.*;
8 import com.daffodilwoods.daffodildb.server.serversystem.triggerInfo.*;
9 import com.daffodilwoods.daffodildb.server.sql99.*;
10 import com.daffodilwoods.daffodildb.server.sql99.common.*;
11 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
12 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.*;
13 import com.daffodilwoods.daffodildb.server.sql99.expression.expressionprimary.*;
14 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
15 import com.daffodilwoods.database.general.*;
16 import com.daffodilwoods.database.resource.*;
17 import com.daffodilwoods.database.utility.*;
18 import com.daffodilwoods.daffodildb.server.sessionsystem._UserSessionTable;
19 import com.daffodilwoods.daffodildb.server.sessionsystem.sessioncondition.SessionConditionReferences;
20
21 /**
22  *
23  * <p>Title: Trigger Table</p>
24  * <p>Description: </p>
25  * Objective of the TriggerTable is to fire (After/Before) Row level Triggers
26  * when the respective call is made.
27  */

28
29 /**
30  *
31  * <p>Title: Trigger Table</p>
32  * <p>Description: </p>
33  * Triggertable main purpose is to fire (After/Before) triggers from their triggerDescriptors
34  */

35 public class TriggerTable implements _TriggerTable {
36
37    private _TriggerCharacteristics triggerCharactersitics;
38    private QualifiedIdentifier tableName;
39    TableDetails tableDetails;
40
41    /**
42     * used to construct a trigger table with the given arguments.
43     * @param tCharactersitics instance of _triggerCharacteristics to get the triggers that are to be fired.
44     * @param tName name of the table.
45     * @throws DException
46     */

47    public TriggerTable(_TriggerCharacteristics tCharactersitics, QualifiedIdentifier tName) throws DException {
48       triggerCharactersitics = tCharactersitics;
49       tableName = tName;
50       tableDetails = new TableDetails();
51       tableDetails.setTableName(new String JavaDoc[] {tableName.catalog, tableName.schema, tableName.name});
52    }
53
54    /**
55     * Used to Fire the row level after insert Trigger with SEC and after Insert Trigger fetched from its Charactersitics.
56     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
57     * and set variable values.
58     * @throws DException
59     */

60
61    public void FireAfterInsertRowLevelTriggers(_StatementExecutionContext statementExecutionContext) throws DException {
62       FireTrigger(statementExecutionContext.getServerSession().getAfterInsertTrigger(tableName,triggerCharactersitics ,statementExecutionContext.getChildStatementExecutionContext() ) , statementExecutionContext,false);
63    }
64
65    /**
66     * Used to Fire the after update row level Trigger with SEC and the after Update
67     * Triggers for cloumn indexes fetched from trigger Charactersitics.
68     * @param columns columns on which update is performed.
69     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
70     * and set variable values.
71     * @throws DException
72     */

73
74    public void FireAfterUpdateRowLevelTriggers(int[] columns, _StatementExecutionContext statementExecutionContext) throws DException {
75       FireTrigger(statementExecutionContext.getServerSession().getAfterUpdateTrigger(tableName,triggerCharactersitics,statementExecutionContext.getChildStatementExecutionContext() ,columns ), statementExecutionContext,false);
76    }
77
78    /**
79     * Used to Fire the after delete row level Trigger with SEC and after Delete Triggers
80     * fetched from trigger Charactersitics.
81     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
82     * and set variable values.
83     * @throws DException
84     */

85
86    public void FireAfterDeleteRowLevelTriggers(_StatementExecutionContext statementExecutionContext) throws DException {
87       FireTrigger(statementExecutionContext.getServerSession().getAfterDeleteTrigger( tableName,triggerCharactersitics ,statementExecutionContext.getChildStatementExecutionContext() ), statementExecutionContext,false);
88    }
89
90    /**
91     * Used to Fire the before insert row level Trigger with SEC and before Insert Triggers
92     * fetched from trigger charactersitics.
93     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
94     * and set variable values.
95     * @throws DException
96     */

97
98    public void FireBeforeInsertRowLevelTriggers(_StatementExecutionContext statementExecutionContext) throws DException {
99       FireTrigger(statementExecutionContext.getServerSession().getBeforeInsertTrigger(tableName,triggerCharactersitics ,statementExecutionContext.getChildStatementExecutionContext() ), statementExecutionContext,true);
100
101    }
102
103    /**
104     * used to Fire the before update row level Trigger with SEC and before update Triggers
105     * for column indexes fetched from trigger charactersitics.
106     * @param columns columns for which the update is performed
107     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
108     * and set variable values.
109     * @throws DException
110     */

111
112    public void FireBeforeUpdateRowLevelTriggers(int[] columns, _StatementExecutionContext statementExecutionContext) throws DException {
113       FireTrigger(statementExecutionContext.getServerSession().getBeforeUpdateTrigger(tableName,triggerCharactersitics ,statementExecutionContext.getChildStatementExecutionContext() ,columns), statementExecutionContext,true);
114    }
115
116    /**
117     * Used to Fire the before delete row level Trigger with SEC and before Delete Triggers
118     * fetched from trigger Charactersitics.
119     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
120     * and set variable values.
121     * @throws DException
122     */

123
124    public void FireBeforeDeleteRowLevelTriggers(_StatementExecutionContext statementExecutionContext) throws DException {
125       FireTrigger(statementExecutionContext.getServerSession().getBeforeDeleteTrigger(tableName,triggerCharactersitics ,statementExecutionContext.getChildStatementExecutionContext() ), statementExecutionContext,false);
126    }
127
128    /**
129     *
130       It Executes all the statements from the Trigger Descriptors one by one and add the corresponding event
131       in the sec. Trigger Descriptors contains the Triggers (after or before update/delete/insert),
132       tec(TriggerExecutionContext) is made here so that , (after/before)trigger execution does not fall into a endless loop
133     * @param triggerDescriptors an array of triggers that are to be fired.
134     * @param statementExecutionContext instance of StatementExecutionContext to get the record version
135     * and set variable values.
136     * @throws DException
137     */

138
139    private void FireTrigger(_Triggers[] triggers, _StatementExecutionContext statementExecutionContext,boolean isBefore) throws DException {
140        if ( ( (StatementExecutionContext) statementExecutionContext).getTriggerCount() > 30){
141           throw new DException("DSE5582", null);
142         }
143
144         if (triggers == null)
145           return;
146
147        RecordVersion recordVersion = statementExecutionContext.getRecordVersion();
148        _VariableValues tvv = null;
149        int triggerDesLength = triggers.length;
150        ArrayList referenceList1 = new ArrayList();
151          ArrayList valuelist1 = new ArrayList();
152         ArrayList afterExecuteRefList = new ArrayList();
153        for (int i = 0; i < triggerDesLength; i++) {
154           String JavaDoc newAlias = triggers[i].getNewAliasName();
155           String JavaDoc oldAlias = triggers[i].getOldAliasName();
156           tvv = new TriggerVariableValues(recordVersion, newAlias, oldAlias, statementExecutionContext.getServerSession());
157           booleanvalueexpression bve = triggers[i].getCondition() ;
158           if (bve != null) {
159              tvv = initializeVariableValues(triggers[i].getReferences() , statementExecutionContext.getServerSession(), recordVersion, newAlias, oldAlias);
160              if (bve.run(tvv).hashCode() != 0) {
161                 continue;
162              }
163           }
164           _Statement[] statements = triggers[i].getStatements() ;
165           _VariableValues vv = null;
166           _StatementExecutionContext sec = triggers[i].getStatementExecutionContext() ;
167
168           for (int j = 0; j < statements.length; j++) {
169              ( (StatementExecutionContext) statementExecutionContext).addTriggerCount();
170              try {
171                 _Executer executer = null;
172                 sec.setUserRight(false);
173                 sec.setRecordVersion(statementExecutionContext.getRecordVersion());
174                 sec.setAutoCommit(false);
175                 _Reference[] references = statements[j].getReferences();
176                 executer = statements[j].getExecuter() ;
177                 vv = new VariableValues(references, sec.getServerSession());
178                 if (references != null) {
179                    Object JavaDoc[] values = getValues(references, recordVersion, oldAlias, newAlias);
180                    if (isBefore) {
181                      referenceList1.addAll(Arrays.asList(references));
182                      valuelist1.addAll(Arrays.asList(values));
183                    }
184
185                    vv.setConditionVariableValue(references, values, 1);
186                 }
187                 sec.setVariableValues(vv);
188                 executer.execute(vv);
189                 if(isBefore)
190                 afterExecuteRefList.add(vv.getReferenceAndValuePair());
191              } catch (DException dde) {
192
193                 if(dde.getDseCode().equalsIgnoreCase("DSE8139"))
194                     throw new DException("DSE8139", new Object JavaDoc[]{dde});
195                 if (dde.getDseCode().equalsIgnoreCase("DSE5582")){
196                    throw new DException("DSE5582", null);}
197                 if (dde.getDseCode().equalsIgnoreCase("DSE5583"))
198                    throw new DException("DSE5583", null);
199                 throw new TriggerException("DSE1274", new Object JavaDoc[] {tableName.getName(), triggers[i].getTriggerType(),dde.getMessage()});
200
201              }
202              finally {
203                 ( (StatementExecutionContext) statementExecutionContext).subTriggerCount();
204              }
205           }
206        }
207        if (isBefore) {
208          ArrayList referenceList = new ArrayList();
209          ArrayList valuelist = new ArrayList();
210
211          for (int i = 0; i < referenceList1.size(); i++) {
212            _Reference reference = (_Reference )referenceList1.get(i);
213            Object JavaDoc val = valuelist1.get(i);
214            for(int j = 0; j < afterExecuteRefList.size(); j++){
215              Object JavaDoc[][] afterExecuteRef = (Object JavaDoc[][] )afterExecuteRefList.get(j);
216              for (int k = 0; k < afterExecuteRef.length; k++) {
217                if (reference == afterExecuteRef[k][0]) {
218                  if (!val.equals( afterExecuteRef[k][1])) {
219                    referenceList.add(reference);
220                    valuelist.add( afterExecuteRef[k][1]);
221                  }
222                }
223              }
224          }
225          }
226              if(referenceList.size() > 0){
227                int length = referenceList.size();
228                int[] colIndex = new int[length];
229                Object JavaDoc[] values = valuelist.toArray();
230                _ColumnCharacteristics cc = statementExecutionContext.getColumnCharacteristics(tableName);
231                for(int j= 0 ;j <referenceList.size();j++ ){
232                  colIndex[j] = cc.getColumnIndex( ( (_Reference) referenceList.get(j)).
233                                                  getColumn());
234                }
235                _Iterator iterator = statementExecutionContext.getServerSession().getIndexTable(tableName).
236                      getDefaultIterator();
237                  boolean iter = iterator.seek(recordVersion.getCurrentRecord().
238                                               getObject(SystemFields.rowId));
239                  Object JavaDoc invalidSessionId = iterator.getColumnValues(SessionConditionReferences.invalidSessionIdReference_4) ;
240                  while(!invalidSessionId.equals(SystemFields.maxIntegerValue)){
241                     iterator.next();
242                    invalidSessionId = iterator.getColumnValues(SessionConditionReferences.invalidSessionIdReference_4) ;
243                  }
244                _UserSessionTable userSessiontable = statementExecutionContext.
245                    getUserSession().getUserSessionTable(tableName);
246                userSessiontable.update(iterator, colIndex, values);
247              }
248            }
249
250
251
252     }
253
254
255    public Object JavaDoc[] getValues(_Reference[] references, RecordVersion recordVersion, String JavaDoc oldAlias, String JavaDoc newAlias) throws DException {
256       Object JavaDoc[] values = new Object JavaDoc[references.length];
257       for (int k = 0; k < references.length; k++) {
258          String JavaDoc column = references[k].getColumn();
259          String JavaDoc tableName = null;
260          try {
261             tableName = references[k].getTriggerTableAlias();
262          } catch (DException de) {
263             throw new TriggerException("DSE1303", new Object JavaDoc[] {column, tableDetails.getQualifiedTableName()});
264          }
265          if (tableName == null || tableName.equalsIgnoreCase("new") || tableName.equalsIgnoreCase(newAlias)) {
266             values[k] = recordVersion.getCurrentRecord().getObject(column);
267          }
268          if (tableName.equalsIgnoreCase("old") || tableName.equalsIgnoreCase(oldAlias)) {
269             values[k] = recordVersion.getPreviousRecord().getObject(column);
270          }
271       }
272       return values;
273    }
274
275
276    private void setDataTypeAndSizeForReferences(_Reference[] ref, _ColumnCharacteristics cc) throws DException {
277       if (ref != null) {
278          int len = ref.length;
279          String JavaDoc[] clms = cc.getColumnNames();
280          for (int i = 0; i < len; i++) {
281             String JavaDoc name = null;
282             try {
283                name = ref[i].getColumn();
284             } catch (Exception JavaDoc E) {
285                continue;
286             }
287             if (P.indexOfIgnoreCase(clms, name) != -1) {
288                int type = cc.getColumnType(cc.getColumnIndex(name));
289                ( (ColumnDetails) ref[i]).setDatatype(type);
290                ( (ColumnDetails) ref[i]).setSize(cc.getSize(cc.getColumnIndex(name)));
291             } else {
292             }
293          }
294       }
295    }
296
297    private Object JavaDoc[][] getSubQueryIteratorMapping(_Reference[] references, _ServerSession object) throws DException {
298       int length = references.length;
299       ArrayList aList = new ArrayList(length);
300       for (int i = 0; i < length; i++) {
301          if (references[i].getReferenceType() == com.daffodilwoods.daffodildb.server.sql99.common.SimpleConstants.SUBQUERY) {
302             _Iterator iterator = ( (com.daffodilwoods.daffodildb.server.sql99.expression.expressionprimary.subquery) references[i]).getSelectIterator(object);
303             aList.add(new Object JavaDoc[] {references[i], iterator}); // make provision of getting _SelectIterator from _Executer
304
}
305       }
306       return (Object JavaDoc[][]) aList.toArray(new Object JavaDoc[0][]);
307    }
308
309    private _VariableValues initializeVariableValues(_Reference[] references, _ServerSession serverSession, RecordVersion recVersion, String JavaDoc newAlias, String JavaDoc oldAlias) throws DException {
310       if (references != null && checkForSubQuery(references)) {
311          Object JavaDoc[][] subQueryIteratorMapping = getSubQueryIteratorMapping(references, serverSession);
312          _Reference[] ref1 = getSimpleReferences(references);
313          _VariableValues vv = new SubQueryVariableValues(ref1, subQueryIteratorMapping, serverSession);
314          if (ref1 != null) {
315             vv.setConditionVariableValue(ref1, getValues(ref1, recVersion, oldAlias, newAlias), 0);
316          }
317          return vv;
318       }
319       return new TriggerVariableValues(recVersion, oldAlias, newAlias, serverSession);
320    }
321
322    private boolean checkForSubQuery(_Reference[] references) throws DException {
323       if (references != null) {
324          int length = references.length;
325          for (int i = 0; i < length; i++)
326             if (references[i].getReferenceType() == com.daffodilwoods.daffodildb.server.sql99.common.SimpleConstants.SUBQUERY)
327                return true;
328       }
329       return false;
330    }
331
332    private _Reference[] getSimpleReferences(_Reference[] references) throws DException {
333       int length = references.length;
334       ArrayList aList = new ArrayList(length);
335       for (int i = 0; i < length; i++) {
336          if (references[i].getReferenceType() != com.daffodilwoods.daffodildb.server.sql99.common.SimpleConstants.SUBQUERY) {
337             aList.add(references[i]); // make provision of getting _SelectIterator from _Executer
338
}
339       }
340       return aList.size() == 0 ? null : (_Reference[]) aList.toArray(new _Reference[0]);
341    }
342
343    private void getAllReferencesIncludingSubQuery(ArrayList aList, _Reference[] references) throws DException {
344       if (references == null)
345          return;
346       for (int i = 0; i < references.length; i++) {
347          if (references[i] instanceof subquery) {
348             TableDetails[] td = ( (subquery) references[i])._queryexpression0.getAllTableDetails();
349             aList.add(references[i]);
350             getAllReferencesIncludingSubQuery(aList, ( (subquery) references[i])._queryexpression0.getReferences(td));
351          } else
352             aList.add(references[i]);
353       }
354    }
355
356
357    public _Reference[] checkColumnsValidityAsReference(ColumnDetails[] columns, TableDetails tableDetails, _ServerSession serverSession) throws DException {
358       ArrayList aList = new ArrayList(5);
359       if (columns != null) {
360          SetColumnProperties.setTableNamesAndDatatypesOfAllColumns(serverSession, columns, new TableDetails[] {tableDetails}
361              , aList, new ArrayList());
362          for (int i = 0, length = aList.size(); i < length; i++)
363             ( (ColumnDetails) aList.get(i)).setUnderLyingReference(true);
364          return aList.size() > 0 ? (_Reference[]) aList.toArray(new _Reference[0]) : null;
365       }
366       return null;
367    }
368
369  /*
370
371   Method written below doesn't used now
372
373
374    private void FireTrigger(_Trigger[] triggerDescriptors, _StatementExecutionContext statementExecutionContext) throws DException {
375     if ( ( (StatementExecutionContext) statementExecutionContext).getTriggerCount() > 30)
376        throw new DException("DSE5582", null);
377     if (triggerDescriptors == null)
378        return;
379     Object[] values = null;
380     _Reference[] references = null;
381     RecordVersion recordVersion = statementExecutionContext.getRecordVersion();
382     _VariableValues tvv = null;
383     _ColumnCharacteristics cc = statementExecutionContext.getColumnCharacteristics(tableName);
384     int triggerDesLength = triggerDescriptors.length;
385     for (int i = 0; i < triggerDesLength; i++) {
386        String newAlias = triggerDescriptors[i].getNewAliasName();
387        String oldAlias = triggerDescriptors[i].getOldAliasName();
388        tvv = new TriggerVariableValues(recordVersion, newAlias, oldAlias);
389        booleanvalueexpression bve = triggerDescriptors[i].getSearchCondition();
390        if (bve != null) {
391           ColumnDetails[] columnDetails = bve.getColumnDetails();
392           _ServerSession serversession = statementExecutionContext.getServerSession();
393           checkColumnsValidityAsReference(columnDetails, tableDetails, serversession);
394           bve.checkSemantic(serversession);
395           ArrayList aList = new ArrayList(5);
396           getAllReferencesIncludingSubQuery(aList, bve.getReferences(new TableDetails[] {tableDetails}));
397           int size = aList.size();
398           _Reference[] ref = size == 0 ? null : (_Reference[]) aList.toArray(new _Reference[size]);
399           setDataTypeAndSizeForReferences(ref, cc);
400           tvv = initializeVariableValues(ref, statementExecutionContext.getServerSession(), recordVersion, newAlias, oldAlias);
401           if (bve.run(tvv).hashCode() != 0) {
402              continue;
403           }
404        }
405        SQLexecutablestatement[] statements = triggerDescriptors[i].getStatement();
406        _VariableValues vv = null;
407        _StatementExecutionContext sec = null;
408        for (int j = 0; j < statements.length; j++) {
409           ( (StatementExecutionContext) statementExecutionContext).addTriggerCount();
410           try {
411              _Executer executer = null;
412              sec = statementExecutionContext.getChildStatementExecutionContext();
413              sec.setUserRight(false);
414              sec.setRecordVersion(statementExecutionContext.getRecordVersion());
415              sec.setAutoCommit(false);
416              if (statements[j] instanceof SQLdatachangestatement) {
417                 references = ( (SQLdatachangestatement) statements[j]).checkSemantic(sec.getServerSession());
418                 if (references != null)
419                    setDataTypeAndSizeForReferences(references, cc);
420                 executer = ( (_Executer) ( (SQLdatachangestatement) statements[j]).run(sec));
421              }
422              if (statements[j] instanceof SQLcontrolstatement) {
423                 references = ( (SQLcontrolstatement) statements[j]).checkSemantic(sec.getServerSession());
424                 if (references != null)
425                    setDataTypeAndSizeForReferences(references, cc);
426                 executer = ( (_Executer) ( (SQLcontrolstatement) statements[j]).run(sec));
427              }
428              vv = new VariableValues(references, sec.getServerSession());
429              if (references != null) {
430                 values = getValues(references, recordVersion, oldAlias, newAlias);
431                 vv.setConditionVariableValue(references, values, 1);
432              }
433              sec.setVariableValues(vv);
434              executer.execute(vv);
435           } catch (DException dde) {
436              if(dde.getDseCode().equalsIgnoreCase("DSE8139"))
437                  throw new DException("DSE8139", new Object[]{dde});
438              if (dde.getDseCode().equalsIgnoreCase("DSE5582"))
439                 throw new DException("DSE5582", null);
440              if (dde.getDseCode().equalsIgnoreCase("DSE5583"))
441                 throw new DException("DSE5583", null);
442              throw new TriggerException("DSE1274", new Object[] {tableName.getName(), triggerDescriptors[i].getTriggerType()});
443           } finally {
444              ( (StatementExecutionContext) statementExecutionContext).subTriggerCount();
445           }
446        }
447     }
448  }*/

449
450 }
451
Popular Tags