/* Copyright (c) 2001-2010, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hsqldb;
import org.hsqldb.HsqlNameManager.HsqlName;
import org.hsqldb.ParserDQL.CompileContext;
import org.hsqldb.error.Error;
import org.hsqldb.error.ErrorCode;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.HashSet;
import org.hsqldb.lib.OrderedHashSet;
import org.hsqldb.navigator.RangeIterator;
import org.hsqldb.navigator.RowIterator;
import org.hsqldb.navigator.RowSetNavigator;
import org.hsqldb.navigator.RowSetNavigatorClient;
import org.hsqldb.navigator.RowSetNavigatorDataChange;
import org.hsqldb.persist.PersistentStore;
import org.hsqldb.result.Result;
import org.hsqldb.result.ResultConstants;
import org.hsqldb.types.Type;
/**
* Implementation of Statement for DML statements.<p>
*
* @author Fred Toussi (fredt@users dot sourceforge.net)
* @version 2.0.0
* @since 1.9.0
*/
// support for MERGE statement originally contributed by Justin Spadea (jzs9783@users dot sourceforge.net)
public class StatementDML extends StatementDMQL {
Expression[] targets;
Expression updatableTableCheck;
RangeVariable checkRangeVariable;
boolean isTruncate;
public StatementDML(int type, int group, HsqlName schemaName) {
super(type, group, schemaName);
}
/**
* Instantiate this as a DELETE statement
*/
StatementDML(Session session, Table targetTable,
RangeVariable[] rangeVars, CompileContext compileContext,
boolean restartIdentity, int type) {
super(StatementTypes.DELETE_WHERE, StatementTypes.X_SQL_DATA_CHANGE,
session.getCurrentSchemaHsqlName());
this.targetTable = targetTable;
this.baseTable = targetTable.getBaseTable() == null ? targetTable
: targetTable
.getBaseTable();
this.targetRangeVariables = rangeVars;
this.restartIdentity = restartIdentity;
setDatabseObjects(session, compileContext);
checkAccessRights(session);
if (type == StatementTypes.TRUNCATE) {
isTruncate = true;
}
targetRangeVariables[0].addAllColumns();
}
/**
* Instantiate this as an UPDATE statement.
*/
StatementDML(Session session, Expression[] targets, Table targetTable,
RangeVariable rangeVars[], int[] updateColumnMap,
Expression[] colExpressions, boolean[] checkColumns,
CompileContext compileContext) {
super(StatementTypes.UPDATE_WHERE, StatementTypes.X_SQL_DATA_CHANGE,
session.getCurrentSchemaHsqlName());
this.targets = targets;
this.targetTable = targetTable;
this.baseTable = targetTable.getBaseTable() == null ? targetTable
: targetTable
.getBaseTable();
this.updateColumnMap = updateColumnMap;
this.updateExpressions = colExpressions;
this.updateCheckColumns = checkColumns;
this.targetRangeVariables = rangeVars;
setDatabseObjects(session, compileContext);
checkAccessRights(session);
setupChecks();
targetRangeVariables[0].addAllColumns();
}
/**
* Instantiate this as a MERGE statement.
*/
StatementDML(Session session, Expression[] targets,
RangeVariable[] targetRangeVars, int[] insertColMap,
int[] updateColMap, boolean[] checkColumns,
Expression mergeCondition, Expression insertExpr,
Expression[] updateExpr, CompileContext compileContext) {
super(StatementTypes.MERGE, StatementTypes.X_SQL_DATA_CHANGE,
session.getCurrentSchemaHsqlName());
this.targets = targets;
this.sourceTable = targetRangeVars[0].rangeTable;
this.targetTable = targetRangeVars[1].rangeTable;
this.baseTable = targetTable.getBaseTable() == null ? targetTable
: targetTable
.getBaseTable();
this.insertCheckColumns = checkColumns;
this.insertColumnMap = insertColMap;
this.updateColumnMap = updateColMap;
this.insertExpression = insertExpr;
this.updateExpressions = updateExpr;
this.targetRangeVariables = targetRangeVars;
this.condition = mergeCondition;
setDatabseObjects(session, compileContext);
checkAccessRights(session);
setupChecks();
}
/**
* Instantiate this as a CURSOR operation statement.
*/
StatementDML() {
super(StatementTypes.UPDATE_CURSOR, StatementTypes.X_SQL_DATA_CHANGE,
null);
}
void setupChecks() {
if (targetTable != baseTable) {
QuerySpecification select =
((TableDerived) targetTable).getQueryExpression()
.getMainSelect();
this.updatableTableCheck = select.checkQueryCondition;
this.checkRangeVariable = select.rangeVariables[0];
}
}
Result getResult(Session session) {
Result result = null;
switch (type) {
case StatementTypes.UPDATE_WHERE :
result = executeUpdateStatement(session);
break;
case StatementTypes.MERGE :
result = executeMergeStatement(session);
break;
case StatementTypes.DELETE_WHERE :
if (isTruncate) {
result = executeDeleteTruncateStatement(session);
} else {
result = executeDeleteStatement(session);
}
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "StatementDML");
}
return result;
}
// this fk references -> other : other read lock
void collectTableNamesForRead(OrderedHashSet set) {
if (baseTable.isView()) {
getTriggerTableNames(set, false);
} else if (!baseTable.isTemp()) {
for (int i = 0; i < baseTable.fkConstraints.length; i++) {
Constraint constraint = baseTable.fkConstraints[i];
if (type == StatementTypes.UPDATE_WHERE
|| type == StatementTypes.MERGE) {
if (ArrayUtil.haveCommonElement(constraint.getRefColumns(),
updateColumnMap)) {
set.add(
baseTable.fkConstraints[i].getMain().getName());
}
} else if (type == StatementTypes.INSERT) {
set.add(baseTable.fkConstraints[i].getMain().getName());
}
}
if (type == StatementTypes.UPDATE_WHERE
|| type == StatementTypes.MERGE) {
baseTable.collectFKReadLocks(updateColumnMap, set);
} else if (type == StatementTypes.DELETE_WHERE) {
baseTable.collectFKReadLocks(null, set);
}
getTriggerTableNames(set, false);
}
for (int i = 0; i < rangeVariables.length; i++) {
Table rangeTable = rangeVariables[i].rangeTable;
HsqlName name = rangeTable.getName();
if (rangeTable.isReadOnly() || rangeTable.isTemp()) {
continue;
}
if (name.schema == SqlInvariants.SYSTEM_SCHEMA_HSQLNAME) {
continue;
}
set.add(name);
}
for (int i = 0; i < subqueries.length; i++) {
if (subqueries[i].queryExpression != null) {
subqueries[i].queryExpression.getBaseTableNames(set);
}
}
for (int i = 0; i < routines.length; i++) {
set.addAll(routines[i].getTableNamesForRead());
}
}
void collectTableNamesForWrite(OrderedHashSet set) {
// other fk references this : if constraint trigger action : other write lock
if (baseTable.isView()) {
getTriggerTableNames(set, true);
} else if (!baseTable.isTemp()) {
set.add(baseTable.getName());
if (type == StatementTypes.UPDATE_WHERE
|| type == StatementTypes.MERGE) {
baseTable.collectFKWriteLocks(updateColumnMap, set);
} else if (type == StatementTypes.DELETE_WHERE) {
baseTable.collectFKWriteLocks(null, set);
}
getTriggerTableNames(set, true);
}
}
void getTriggerTableNames(OrderedHashSet set, boolean write) {
for (int i = 0; i < baseTable.triggerList.length; i++) {
TriggerDef td = baseTable.triggerList[i];
switch (type) {
case StatementTypes.INSERT :
if (td.getStatementType() == StatementTypes.INSERT) {
break;
}
continue;
case StatementTypes.UPDATE_WHERE :
if (td.getStatementType() == StatementTypes.UPDATE_WHERE) {
break;
}
continue;
case StatementTypes.DELETE_WHERE :
if (td.getStatementType() == StatementTypes.DELETE_WHERE) {
break;
}
continue;
case StatementTypes.MERGE :
if (td.getStatementType() == StatementTypes.INSERT
|| td.getStatementType()
== StatementTypes.UPDATE_WHERE) {
break;
}
continue;
default :
throw Error.runtimeError(ErrorCode.U_S0500,
"StatementDML");
}
if (td.routine != null) {
if (write) {
set.addAll(td.routine.getTableNamesForWrite());
} else {
set.addAll(td.routine.getTableNamesForRead());
}
}
}
}
/**
* Executes an UPDATE statement.
*
* @return Result object
*/
Result executeUpdateStatement(Session session) {
int count = 0;
Expression[] colExpressions = updateExpressions;
RowSetNavigatorDataChange rowset = new RowSetNavigatorDataChange();
Type[] colTypes = baseTable.getColumnTypes();
RangeIterator it = RangeVariable.getIterator(session,
targetRangeVariables);
while (it.next()) {
session.sessionData.startRowProcessing();
Row row = it.getCurrentRow();
Object[] data = row.getData();
Object[] newData = getUpdatedData(session, targets, baseTable,
updateColumnMap, colExpressions,
colTypes, data);
if (updatableTableCheck != null) {
it.setCurrent(newData);
boolean check = updatableTableCheck.testCondition(session);
if (!check) {
it.release();
throw Error.error(ErrorCode.X_44000);
}
}
rowset.addRow(session, row, newData, colTypes, updateColumnMap);
}
it.release();
/* debug 190
if (rowset.size() == 0) {
System.out.println(targetTable.getName().name + " zero update: session "
+ session.getId());
} else if (rowset.size() >1) {
System.out.println("multiple update: session "
+ session.getId() + ", " + rowset.size());
}
//* debug 190 */
rowset.beforeFirst();
count = update(session, baseTable, rowset);
if (count == 1) {
return Result.updateOneResult;
} else if (count == 0) {
return Result.updateZeroResult;
}
return new Result(ResultConstants.UPDATECOUNT, count);
}
static Object[] getUpdatedData(Session session, Expression[] targets,
Table targetTable, int[] columnMap,
Expression[] colExpressions,
Type[] colTypes, Object[] oldData) {
Object[] data = targetTable.getEmptyRowData();
System.arraycopy(oldData, 0, data, 0, data.length);
for (int i = 0, ix = 0; i < columnMap.length; ) {
Expression expr = colExpressions[ix++];
if (expr.getType() == OpTypes.ROW) {
Object[] values = expr.getRowValue(session);
for (int j = 0; j < values.length; j++, i++) {
int colIndex = columnMap[i];
Expression e = expr.nodes[j];
// transitional - still supporting null for identity generation
if (targetTable.identityColumn == colIndex) {
if (e.getType() == OpTypes.VALUE
&& e.valueData == null) {
continue;
}
}
if (e.getType() == OpTypes.DEFAULT) {
if (targetTable.identityColumn == colIndex) {
continue;
}
data[colIndex] =
targetTable.colDefaults[colIndex].getValue(
session);
continue;
}
data[colIndex] = colTypes[colIndex].convertToType(session,
values[j], e.dataType);
}
} else if (expr.getType() == OpTypes.ROW_SUBQUERY) {
Object[] values = expr.getRowValue(session);
for (int j = 0; j < values.length; j++, i++) {
int colIndex = columnMap[i];
Type colType =
expr.subQuery.queryExpression.getMetaData()
.columnTypes[j];
data[colIndex] = colTypes[colIndex].convertToType(session,
values[j], colType);
}
} else {
int colIndex = columnMap[i];
if (expr.getType() == OpTypes.DEFAULT) {
if (targetTable.identityColumn == colIndex) {
i++;
continue;
}
data[colIndex] =
targetTable.colDefaults[colIndex].getValue(session);
i++;
continue;
}
Object value = expr.getValue(session);
if (targets[i].getType() == OpTypes.ARRAY_ACCESS) {
data[colIndex] =
((ExpressionAccessor) targets[i]).getUpdatedArray(
session, (Object[]) data[colIndex], value, true);
} else {
data[colIndex] = colTypes[colIndex].convertToType(session,
value, expr.dataType);
}
i++;
}
}
return data;
}
/**
* Executes a MERGE statement.
*
* @return Result object
*/
Result executeMergeStatement(Session session) {
Type[] colTypes = baseTable.getColumnTypes();
Result resultOut = null;
RowSetNavigator generatedNavigator = null;
if (generatedIndexes != null) {
resultOut = Result.newUpdateCountResult(generatedResultMetaData,
0);
generatedNavigator = resultOut.getChainedResult().getNavigator();
}
int count = 0;
// data generated for non-matching rows
RowSetNavigatorClient newData = new RowSetNavigatorClient(8);
// rowset for update operation
RowSetNavigatorDataChange updateRowSet =
new RowSetNavigatorDataChange();
RangeVariable[] joinRangeIterators = targetRangeVariables;
// populate insert and update lists
RangeIterator[] rangeIterators =
new RangeIterator[joinRangeIterators.length];
for (int i = 0; i < joinRangeIterators.length; i++) {
rangeIterators[i] = joinRangeIterators[i].getIterator(session);
}
for (int currentIndex = 0; currentIndex >= 0; ) {
RangeIterator it = rangeIterators[currentIndex];
boolean beforeFirst = it.isBeforeFirst();
if (it.next()) {
if (currentIndex < joinRangeIterators.length - 1) {
currentIndex++;
continue;
}
} else {
if (currentIndex == 1 && beforeFirst
&& insertExpression != null) {
Object[] data =
getInsertData(session, colTypes,
insertExpression.nodes[0].nodes);
if (data != null) {
newData.add(data);
}
}
it.reset();
currentIndex--;
continue;
}
// row matches!
if (updateExpressions.length != 0) {
Row row = it.getCurrentRow(); // this is always the second iterator
Object[] data = getUpdatedData(session, targets, baseTable,
updateColumnMap,
updateExpressions, colTypes,
row.getData());
try {
updateRowSet.addRow(session, row, data, colTypes,
updateColumnMap);
} catch (HsqlException e) {
for (int i = 0; i < joinRangeIterators.length; i++) {
rangeIterators[i].reset();
}
throw Error.error(ErrorCode.X_21000);
}
}
}
for (int i = 0; i < joinRangeIterators.length; i++) {
rangeIterators[i].reset();
}
// run the transaction as a whole, updating and inserting where needed
// update any matched rows
if (updateExpressions.length != 0) {
count = update(session, baseTable, updateRowSet);
}
// insert any non-matched rows
if (newData.getSize() > 0) {
insertRowSet(session, generatedNavigator, newData);
count += newData.getSize();
}
if (insertExpression != null
&& baseTable.triggerLists[Trigger.INSERT_AFTER].length > 0) {
baseTable.fireTriggers(session, Trigger.INSERT_AFTER, newData);
}
if (resultOut == null) {
if (count == 1) {
return Result.updateOneResult;
}
return new Result(ResultConstants.UPDATECOUNT, count);
} else {
resultOut.setUpdateCount(count);
return resultOut;
}
}
void insertRowSet(Session session, RowSetNavigator generatedNavigator,
RowSetNavigator newData) {
PersistentStore store = baseTable.getRowStore(session);
RangeIterator checkIterator = null;
if (updatableTableCheck != null) {
checkIterator = checkRangeVariable.getIterator(session);
}
newData.beforeFirst();
if (baseTable.triggerLists[Trigger.INSERT_BEFORE_ROW].length > 0) {
while (newData.hasNext()) {
Object[] data = (Object[]) newData.getNext();
baseTable.fireTriggers(session, Trigger.INSERT_BEFORE_ROW,
null, data, null);
}
newData.beforeFirst();
}
while (newData.hasNext()) {
Object[] data = (Object[]) newData.getNext();
baseTable.insertSingleRow(session, store, data, null);
if (checkIterator != null) {
checkIterator.setCurrent(data);
boolean check = updatableTableCheck.testCondition(session);
if (!check) {
throw Error.error(ErrorCode.X_44000);
}
}
if (generatedNavigator != null) {
Object[] generatedValues = getGeneratedColumns(data);
generatedNavigator.add(generatedValues);
}
}
newData.beforeFirst();
while (newData.hasNext()) {
Object[] data = (Object[]) newData.getNext();
performIntegrityChecks(session, baseTable, null, data, null);
}
newData.beforeFirst();
if (baseTable.triggerLists[Trigger.INSERT_AFTER_ROW].length > 0) {
while (newData.hasNext()) {
Object[] data = (Object[]) newData.getNext();
baseTable.fireTriggers(session, Trigger.INSERT_AFTER_ROW,
null, data, null);
}
newData.beforeFirst();
}
}
Result insertSingleRow(Session session, PersistentStore store,
Object[] data) {
if (baseTable.triggerLists[Trigger.INSERT_BEFORE_ROW].length > 0) {
baseTable.fireTriggers(session, Trigger.INSERT_BEFORE_ROW, null,
data, null);
}
baseTable.insertSingleRow(session, store, data, null);
performIntegrityChecks(session, baseTable, null, data, null);
if (session.database.isReferentialIntegrity()) {
for (int i = 0, size = baseTable.fkConstraints.length; i < size;
i++) {
baseTable.fkConstraints[i].checkInsert(session, baseTable,
data, true);
}
}
if (baseTable.triggerLists[Trigger.INSERT_AFTER_ROW].length > 0) {
baseTable.fireTriggers(session, Trigger.INSERT_AFTER_ROW, null,
data, null);
}
if (baseTable.triggerLists[Trigger.INSERT_AFTER].length > 0) {
baseTable.fireTriggers(session, Trigger.INSERT_AFTER,
(RowSetNavigator) null);
}
return Result.updateOneResult;
}
Object[] getInsertData(Session session, Type[] colTypes,
Expression[] rowArgs) {
Object[] data = baseTable.getNewRowData(session);
session.sessionData.startRowProcessing();
for (int i = 0; i < rowArgs.length; i++) {
Expression e = rowArgs[i];
int colIndex = insertColumnMap[i];
if (e.opType == OpTypes.DEFAULT) {
if (baseTable.identityColumn == colIndex) {
continue;
}
if (baseTable.colDefaults[colIndex] != null) {
data[colIndex] =
baseTable.colDefaults[colIndex].getValue(session);
continue;
}
continue;
}
Object value = e.getValue(session);
Type type = colTypes[colIndex];
if (colTypes[colIndex] != e.dataType) {
value = type.convertToType(session, value, e.dataType);
}
data[colIndex] = value;
}
return data;
}
/**
* Highest level multiple row update method.<p>
*
* Following clauses from SQL Standard section 11.8 are enforced 9) Let ISS
* be the innermost SQL-statement being executed. 10) If evaluation of these
* General Rules during the execution of ISS would cause an update of some
* site to a value that is distinct from the value to which that site was
* previously updated during the execution of ISS, then an exception
* condition is raised: triggered data change violation. 11) If evaluation
* of these General Rules during the execution of ISS would cause deletion
* of a row containing a site that is identified for replacement in that
* row, then an exception condition is raised: triggered data change
* violation.
*
* @param session Session
* @param table Table
* @param updateList RowSetNavigatorDataChange
* @return int
*/
int update(Session session, Table table,
RowSetNavigatorDataChange navigator) {
int rowCount = navigator.getSize();
// set identity column where null and check columns
for (int i = 0; i < rowCount; i++) {
navigator.next();
Object[] data = navigator.getCurrentChangedData();
/**
* @todo 1.9.0 - make optional using database property -
* this means the identity column can be set to null to force
* creation of a new identity value
*/
table.setIdentityColumn(session, data);
table.setGeneratedColumns(session, data);
}
navigator.beforeFirst();
if (table.fkMainConstraints.length > 0) {
HashSet path = session.sessionContext.getConstraintPath();
for (int i = 0; i < rowCount; i++) {
Row row = navigator.getNextRow();
Object[] data = navigator.getCurrentChangedData();
performReferentialActions(session, table, navigator, row,
data, this.updateColumnMap, path);
path.clear();
}
navigator.beforeFirst();
}
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Object[] data = navigator.getCurrentChangedData();
int[] changedColumns = navigator.getCurrentChangedColumns();
Table currentTable = ((Table) row.getTable());
if (currentTable.triggerLists[Trigger.UPDATE_BEFORE_ROW].length
> 0) {
currentTable.fireTriggers(session, Trigger.UPDATE_BEFORE_ROW,
row.getData(), data, changedColumns);
currentTable.enforceRowConstraints(session, data);
}
}
if (table.isView) {
return rowCount;
}
navigator.beforeFirst();
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Table currentTable = ((Table) row.getTable());
int[] changedColumns = navigator.getCurrentChangedColumns();
session.addDeleteAction(currentTable, row, changedColumns);
}
navigator.beforeFirst();
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Object[] data = navigator.getCurrentChangedData();
Table currentTable = ((Table) row.getTable());
int[] changedColumns = navigator.getCurrentChangedColumns();
PersistentStore store = currentTable.getRowStore(session);
if (data == null) {
continue;
}
Row newRow = currentTable.insertSingleRow(session, store, data,
changedColumns);
// newRow.rowAction.updatedAction = row.rowAction;
}
navigator.beforeFirst();
OrderedHashSet extraUpdateTables = null;
boolean hasAfterRowTriggers =
table.triggerLists[Trigger.UPDATE_AFTER_ROW].length > 0;
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Table currentTable = ((Table) row.getTable());
Object[] changedData = navigator.getCurrentChangedData();
int[] changedColumns = navigator.getCurrentChangedColumns();
performIntegrityChecks(session, currentTable, row.getData(),
changedData, changedColumns);
if (currentTable != table) {
if (extraUpdateTables == null) {
extraUpdateTables = new OrderedHashSet();
}
extraUpdateTables.add(currentTable);
if (currentTable.triggerLists[Trigger.UPDATE_AFTER_ROW].length
> 0) {
hasAfterRowTriggers = true;
}
}
}
navigator.beforeFirst();
if (hasAfterRowTriggers) {
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Object[] changedData = navigator.getCurrentChangedData();
int[] changedColumns = navigator.getCurrentChangedColumns();
Table currentTable = ((Table) row.getTable());
currentTable.fireTriggers(session, Trigger.UPDATE_AFTER_ROW,
row.getData(), changedData,
changedColumns);
}
navigator.beforeFirst();
}
baseTable.fireTriggers(session, Trigger.UPDATE_AFTER, navigator);
if (extraUpdateTables != null) {
for (int i = 0; i < extraUpdateTables.size(); i++) {
Table currentTable = (Table) extraUpdateTables.get(i);
currentTable.fireTriggers(session, Trigger.UPDATE_AFTER,
navigator);
}
}
return rowCount;
}
/**
* Executes a DELETE statement.
*
* @return the result of executing the statement
*/
Result executeDeleteStatement(Session session) {
int count = 0;
RangeIterator it = RangeVariable.getIterator(session,
targetRangeVariables);
RowSetNavigatorDataChange navigator = new RowSetNavigatorDataChange();
while (it.next()) {
Row currentRow = it.getCurrentRow();
navigator.addRow(currentRow);
}
it.release();
if (navigator.getSize() > 0) {
count = delete(session, baseTable, navigator);
} else {
return Result.updateZeroResult;
}
if (count == 1) {
return Result.updateOneResult;
}
return new Result(ResultConstants.UPDATECOUNT, count);
}
Result executeDeleteTruncateStatement(Session session) {
PersistentStore store = targetTable.getRowStore(session);
RowIterator it = targetTable.getPrimaryIndex().firstRow(store);
try {
while (it.hasNext()) {
Row row = it.getNextRow();
session.addDeleteAction((Table) row.getTable(), row, null);
}
if (restartIdentity && targetTable.identitySequence != null) {
targetTable.identitySequence.reset();
}
} finally {
it.release();
}
return Result.updateOneResult;
}
/**
* Highest level multiple row delete method. Corresponds to an SQL
* DELETE.
*/
int delete(Session session, Table table,
RowSetNavigatorDataChange navigator) {
int rowCount = navigator.getSize();
navigator.beforeFirst();
if (table.fkMainConstraints.length > 0) {
HashSet path = session.sessionContext.getConstraintPath();
for (int i = 0; i < rowCount; i++) {
navigator.next();
Row row = navigator.getCurrentRow();
performReferentialActions(session, table, navigator, row,
null, null, path);
path.clear();
}
navigator.beforeFirst();
}
while (navigator.hasNext()) {
navigator.next();
Row row = navigator.getCurrentRow();
Object[] changedData = navigator.getCurrentChangedData();
int[] changedColumns = navigator.getCurrentChangedColumns();
Table currentTable = ((Table) row.getTable());
if (changedData == null) {
currentTable.fireTriggers(session, Trigger.DELETE_BEFORE_ROW,
row.getData(), null, null);
} else {
currentTable.fireTriggers(session, Trigger.UPDATE_BEFORE_ROW,
row.getData(), changedData,
changedColumns);
}
}
if (table.isView) {
return rowCount;
}
navigator.beforeFirst();
boolean hasUpdate = false;
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Object[] data = navigator.getCurrentChangedData();
Table currentTable = ((Table) row.getTable());
session.addDeleteAction(currentTable, row, null);
if (data != null) {
hasUpdate = true;
}
}
navigator.beforeFirst();
if (hasUpdate) {
for (int i = 0; i < navigator.getSize(); i++) {
Row row = navigator.getNextRow();
Object[] data = navigator.getCurrentChangedData();
Table currentTable = ((Table) row.getTable());
int[] changedColumns = navigator.getCurrentChangedColumns();
PersistentStore store = currentTable.getRowStore(session);
if (data == null) {
continue;
}
Row newRow = currentTable.insertSingleRow(session, store,
data, changedColumns);
// newRow.rowAction.updatedAction = row.rowAction;
}
navigator.beforeFirst();
}
OrderedHashSet extraUpdateTables = null;
OrderedHashSet extraDeleteTables = null;
boolean hasAfterRowTriggers =
table.triggerLists[Trigger.DELETE_AFTER_ROW].length > 0;
if (rowCount != navigator.getSize()) {
while (navigator.hasNext()) {
navigator.next();
Row row = navigator.getCurrentRow();
Object[] changedData = navigator.getCurrentChangedData();
int[] changedColumns = navigator.getCurrentChangedColumns();
Table currentTable = ((Table) row.getTable());
if (changedData != null) {
performIntegrityChecks(session, currentTable,
row.getData(), changedData,
changedColumns);
}
if (currentTable != table) {
if (changedData == null) {
if (currentTable.triggerLists[Trigger.DELETE_AFTER_ROW]
.length > 0) {
hasAfterRowTriggers = true;
}
if (extraDeleteTables == null) {
extraDeleteTables = new OrderedHashSet();
}
extraDeleteTables.add(currentTable);
} else {
if (currentTable.triggerLists[Trigger.UPDATE_AFTER_ROW]
.length > 0) {
hasAfterRowTriggers = true;
}
if (extraUpdateTables == null) {
extraUpdateTables = new OrderedHashSet();
}
extraUpdateTables.add(currentTable);
}
}
}
navigator.beforeFirst();
}
if (hasAfterRowTriggers) {
while (navigator.hasNext()) {
navigator.next();
Row row = navigator.getCurrentRow();
Object[] changedData = navigator.getCurrentChangedData();
Table currentTable = ((Table) row.getTable());
if (changedData == null) {
currentTable.fireTriggers(session,
Trigger.DELETE_AFTER_ROW,
row.getData(), null, null);
} else {
currentTable.fireTriggers(session,
Trigger.UPDATE_AFTER_ROW,
row.getData(), changedData,
null);
}
}
navigator.beforeFirst();
}
table.fireTriggers(session, Trigger.DELETE_AFTER, navigator);
if (extraUpdateTables != null) {
for (int i = 0; i < extraUpdateTables.size(); i++) {
Table currentTable = (Table) extraUpdateTables.get(i);
currentTable.fireTriggers(session, Trigger.UPDATE_AFTER,
navigator);
}
}
if (extraDeleteTables != null) {
for (int i = 0; i < extraDeleteTables.size(); i++) {
Table currentTable = (Table) extraDeleteTables.get(i);
currentTable.fireTriggers(session, Trigger.DELETE_AFTER,
navigator);
}
}
return rowCount;
}
static void performIntegrityChecks(Session session, Table table,
Object[] oldData, Object[] newData,
int[] updatedColumns) {
if (newData == null) {
return;
}
for (int i = 0, size = table.checkConstraints.length; i < size; i++) {
table.checkConstraints[i].checkInsert(session, table, newData,
oldData == null);
}
if (!session.database.isReferentialIntegrity()) {
return;
}
for (int i = 0, size = table.fkConstraints.length; i < size; i++) {
boolean check = oldData == null;
Constraint c = table.fkConstraints[i];
if (!check) {
check = ArrayUtil.haveCommonElement(c.getRefColumns(),
updatedColumns);
}
if (check) {
c.checkInsert(session, table, newData, oldData == null);
}
}
}
static void performReferentialActions(Session session, Table table,
RowSetNavigatorDataChange navigator,
Row row, Object[] data,
int[] changedCols, HashSet path) {
if (!session.database.isReferentialIntegrity()) {
return;
}
boolean delete = data == null;
for (int i = 0, size = table.fkMainConstraints.length; i < size; i++) {
Constraint c = table.fkMainConstraints[i];
int action = delete ? c.core.deleteAction
: c.core.updateAction;
if (!delete) {
if (!ArrayUtil.haveCommonElement(changedCols,
c.core.mainCols)) {
continue;
}
if (c.core.mainIndex.compareRowNonUnique(
session, row.getData(), data, c.core.mainCols) == 0) {
continue;
}
}
RowIterator refiterator = c.findFkRef(session, row.getData());
if (!refiterator.hasNext()) {
refiterator.release();
continue;
}
while (refiterator.hasNext()) {
Row refRow = refiterator.getNextRow();
Object[] refData = null;
/** @todo use MATCH */
if (c.core.refIndex.compareRowNonUnique(
session, refRow.getData(), row.getData(),
c.core.mainCols) != 0) {
break;
}
if (delete && refRow.getId() == row.getId()) {
continue;
}
switch (action) {
case SchemaObject.ReferentialAction.CASCADE : {
if (delete) {
if (navigator.addRow(refRow)) {
performReferentialActions(session,
c.core.refTable,
navigator, refRow,
null, null, path);
}
continue;
}
refData = c.core.refTable.getEmptyRowData();
System.arraycopy(refRow.getData(), 0, refData, 0,
refData.length);
for (int j = 0; j < c.core.refCols.length; j++) {
refData[c.core.refCols[j]] =
data[c.core.mainCols[j]];
}
break;
}
case SchemaObject.ReferentialAction.SET_NULL : {
refData = c.core.refTable.getEmptyRowData();
System.arraycopy(refRow.getData(), 0, refData, 0,
refData.length);
for (int j = 0; j < c.core.refCols.length; j++) {
refData[c.core.refCols[j]] = null;
}
break;
}
case SchemaObject.ReferentialAction.SET_DEFAULT : {
refData = c.core.refTable.getEmptyRowData();
System.arraycopy(refRow.getData(), 0, refData, 0,
refData.length);
for (int j = 0; j < c.core.refCols.length; j++) {
ColumnSchema col =
c.core.refTable.getColumn(c.core.refCols[j]);
refData[c.core.refCols[j]] =
col.getDefaultValue(session);
}
break;
}
case SchemaObject.ReferentialAction.NO_ACTION :
case SchemaObject.ReferentialAction.RESTRICT : {
if (navigator.containsDeletedRow(refRow)) {
continue;
}
int errorCode = c.core.deleteAction
== SchemaObject.ReferentialAction
.NO_ACTION ? ErrorCode.X_23504
: ErrorCode.X_23001;
String[] info = new String[] {
c.core.refName.name, c.core.refTable.getName().name
};
refiterator.release();
throw Error.error(null, errorCode,
ErrorCode.CONSTRAINT, info);
}
default :
continue;
}
refData = navigator.addRow(session, refRow, refData,
table.getColumnTypes(),
c.core.refCols);
if (!path.add(c)) {
continue;
}
performReferentialActions(session, c.core.refTable, navigator,
refRow, refData, c.core.refCols,
path);
path.remove(c);
}
refiterator.release();
}
}
}