RowIterator findFkRef(Session paramSession, Object[] paramArrayOfObject) {
if ((paramArrayOfObject == null) || (ArrayUtil.hasNull(paramArrayOfObject, this.core.mainCols)))
return this.core.refIndex.emptyIterator();
PersistentStore localPersistentStore = this.core.refTable.getRowStore(paramSession);
return this.core.refIndex.findFirstRow(
paramSession, localPersistentStore, paramArrayOfObject, this.core.mainCols);
}
/**
* New method to find any referencing row for a foreign key (finds row in child table). If ON
* DELETE CASCADE is specified for this constraint, then the method finds the first row among the
* rows of the table ordered by the index and doesn't throw. Without ON DELETE CASCADE, the method
* attempts to finds any row that exists. If no row is found, null is returned. (fredt@users)
*
* @param session Session
* @param row array of objects for a database row
* @param delete should we allow 'ON DELETE CASCADE' or 'ON UPDATE CASCADE'
* @return iterator @
*/
RowIterator findFkRef(Session session, Object[] row, boolean delete) {
if (row == null || ArrayUtil.hasNull(row, core.mainCols)) {
return core.refIndex.emptyIterator();
}
PersistentStore store = session.sessionData.getRowStore(core.refTable);
return core.refIndex.findFirstRow(session, store, row, core.mainCols);
}
/**
* For the candidate table row, finds any referring node in the main table. This is used to check
* referential integrity when updating a node. We have to make sure that the main table still
* holds a valid main record. returns true If a valid row is found, false if there are null in the
* data Otherwise a 'INTEGRITY VIOLATION' Exception gets thrown.
*/
boolean checkHasMainRef(Session session, Object[] row) {
if (ArrayUtil.hasNull(row, core.refCols)) {
return false;
}
PersistentStore store = session.sessionData.getRowStore(core.mainTable);
boolean exists = core.mainIndex.exists(session, store, row, core.refCols);
if (!exists) {
String[] info = new String[] {core.refName.name, core.mainTable.getName().name};
throw Error.error(ErrorCode.X_23502, ErrorCode.CONSTRAINT, info);
}
return exists;
}
/**
* Checks for foreign key or check constraint violation when inserting a row into the child table.
*/
void checkInsert(Session session, Table table, Object[] row) {
switch (constType) {
case CHECK:
if (!isNotNull) {
checkCheckConstraint(session, table, row);
}
return;
case FOREIGN_KEY:
PersistentStore store = session.sessionData.getRowStore(core.mainTable);
if (ArrayUtil.hasNull(row, core.refCols)) {
if (core.matchType == OpTypes.MATCH_SIMPLE) {
return;
}
if (core.refCols.length == 1) {
return;
}
if (ArrayUtil.hasAllNull(row, core.refCols)) {
return;
}
// core.matchType == OpTypes.MATCH_FULL
} else if (core.mainIndex.exists(session, store, row, core.refCols)) {
return;
} else if (core.mainTable == core.refTable) {
// special case: self referencing table and self referencing row
int compare = core.mainIndex.compareRowNonUnique(row, core.refCols, row);
if (compare == 0) {
return;
}
}
String[] info = new String[] {core.refName.name, core.mainTable.getName().name};
throw Error.error(ErrorCode.X_23502, ErrorCode.CONSTRAINT, info);
}
}
void checkInsert(
Session paramSession, Table paramTable, Object[] paramArrayOfObject, boolean paramBoolean) {
switch (this.constType) {
case 3:
if (!this.isNotNull) checkCheckConstraint(paramSession, paramTable, paramArrayOfObject);
return;
case 0:
PersistentStore localPersistentStore = this.core.mainTable.getRowStore(paramSession);
if (ArrayUtil.hasNull(paramArrayOfObject, this.core.refCols)) {
if (this.core.matchType == 59) return;
if (this.core.refCols.length == 1) return;
if (!ArrayUtil.hasAllNull(paramArrayOfObject, this.core.refCols)) ;
} else if (this.core.mainIndex.existsParent(
paramSession, localPersistentStore, paramArrayOfObject, this.core.refCols)) {
return;
}
throw getException(paramArrayOfObject);
}
}
/**
* Check used before creating a new foreign key cosntraint, this method checks all rows of a table
* to ensure they all have a corresponding row in the main table.
*/
void checkReferencedRows(Session session, Table table, int[] rowColArray) {
Index mainIndex = getMainIndex();
PersistentStore store = session.sessionData.getRowStore(table);
RowIterator it = table.rowIterator(session);
while (true) {
Row row = it.getNextRow();
if (row == null) {
break;
}
Object[] rowData = row.getData();
if (ArrayUtil.hasNull(rowData, rowColArray)) {
if (core.matchType == OpTypes.MATCH_SIMPLE) {
continue;
}
} else if (mainIndex.exists(session, store, rowData, rowColArray)) {
continue;
}
if (ArrayUtil.hasAllNull(rowData, rowColArray)) {
continue;
}
String colValues = "";
for (int i = 0; i < rowColArray.length; i++) {
Object o = rowData[rowColArray[i]];
colValues += table.getColumnTypes()[i].convertToString(o);
colValues += ",";
}
String[] info = new String[] {getName().name, getMain().getName().name};
throw Error.error(ErrorCode.X_23502, ErrorCode.CONSTRAINT, info);
}
}