| /* |
| |
| Derby - Class org.apache.derby.impl.sql.compile.MatchingClauseNode |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to you under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derby.impl.sql.compile; |
| |
| import java.lang.reflect.Modifier; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import org.apache.derby.catalog.types.DefaultInfoImpl; |
| import org.apache.derby.iapi.error.StandardException; |
| import org.apache.derby.iapi.reference.ClassName; |
| import org.apache.derby.iapi.reference.SQLState; |
| import org.apache.derby.iapi.services.classfile.VMOpcode; |
| import org.apache.derby.iapi.services.compiler.LocalField; |
| import org.apache.derby.iapi.services.compiler.MethodBuilder; |
| import org.apache.derby.iapi.services.context.ContextManager; |
| import org.apache.derby.iapi.services.io.FormatableBitSet; |
| import org.apache.derby.shared.common.sanity.SanityManager; |
| import org.apache.derby.iapi.sql.ResultColumnDescriptor; |
| import org.apache.derby.iapi.sql.ResultDescription; |
| import org.apache.derby.iapi.sql.compile.CompilerContext; |
| import org.apache.derby.iapi.sql.compile.IgnoreFilter; |
| import org.apache.derby.iapi.sql.compile.Visitor; |
| import org.apache.derby.iapi.sql.dictionary.ColumnDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.ColumnDescriptorList; |
| import org.apache.derby.iapi.sql.dictionary.DataDictionary; |
| import org.apache.derby.iapi.sql.dictionary.TableDescriptor; |
| import org.apache.derby.iapi.sql.execute.ConstantAction; |
| import org.apache.derby.iapi.sql.execute.NoPutResultSet; |
| import org.apache.derby.iapi.types.DataTypeDescriptor; |
| import org.apache.derby.iapi.types.DataValueDescriptor; |
| |
| /** |
| * Node representing a WHEN MATCHED or WHEN NOT MATCHED clause |
| * in a MERGE statement. |
| * |
| */ |
| |
| public class MatchingClauseNode extends QueryTreeNode |
| { |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // CONSTANTS |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| private static final String CURRENT_OF_NODE_NAME = "$MERGE_CURRENT"; |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // STATE |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| // |
| // Filled in by the constructor. |
| // |
| private ValueNode _matchingRefinement; |
| private ResultColumnList _updateColumns; |
| private ResultColumnList _insertColumns; |
| private ResultColumnList _insertValues; |
| |
| // |
| // Filled in at bind() time. |
| // |
| |
| // the INSERT/UPDATE/DELETE statement of this WHEN [ NOT ] MATCHED clause |
| private DMLModStatementNode _dml; |
| |
| // the columns in the temporary conglomerate which drives the INSERT/UPDATE/DELETE |
| private ResultColumnList _thenColumns; |
| |
| // |
| // Filled in at generate() time. |
| // |
| private int _clauseNumber; |
| private String _actionMethodName; |
| private String _resultSetFieldName; |
| private String _rowMakingMethodName; |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // CONSTRUCTORS/FACTORY METHODS |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Constructor called by factory methods. |
| */ |
| private MatchingClauseNode |
| ( |
| ValueNode matchingRefinement, |
| ResultColumnList updateColumns, |
| ResultColumnList insertColumns, |
| ResultColumnList insertValues, |
| ContextManager cm |
| ) |
| throws StandardException |
| { |
| super( cm ); |
| |
| _matchingRefinement = matchingRefinement; |
| _updateColumns = updateColumns; |
| _insertColumns = insertColumns; |
| _insertValues = insertValues; |
| } |
| |
| /** Make a WHEN MATCHED ... THEN UPDATE clause */ |
| static MatchingClauseNode makeUpdateClause |
| ( |
| ValueNode matchingRefinement, |
| ResultColumnList updateColumns, |
| ContextManager cm |
| ) |
| throws StandardException |
| { |
| return new MatchingClauseNode( matchingRefinement, updateColumns, null, null, cm ); |
| } |
| |
| /** Make a WHEN MATCHED ... THEN DELETE clause */ |
| static MatchingClauseNode makeDeleteClause |
| ( |
| ValueNode matchingRefinement, |
| ContextManager cm |
| ) |
| throws StandardException |
| { |
| return new MatchingClauseNode( matchingRefinement, null, null, null, cm ); |
| } |
| |
| /** Make a WHEN NOT MATCHED ... THEN INSERT clause */ |
| static MatchingClauseNode makeInsertClause |
| ( |
| ValueNode matchingRefinement, |
| ResultColumnList insertColumns, |
| ResultColumnList insertValues, |
| ContextManager cm |
| ) |
| throws StandardException |
| { |
| return new MatchingClauseNode( matchingRefinement, null, insertColumns, insertValues, cm ); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // ACCESSORS |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** Return true if this is a WHEN MATCHED ... UPDATE clause */ |
| boolean isUpdateClause() { return (_updateColumns != null); } |
| |
| /** Return true if this is a WHEN NOT MATCHED ... INSERT clause */ |
| boolean isInsertClause() { return (_insertValues != null); } |
| |
| /** Return true if this is a WHEN MATCHED ... DELETE clause */ |
| boolean isDeleteClause() { return !( isUpdateClause() || isInsertClause() ); } |
| |
| /** |
| * Return the list of columns which form the rows of the ResultSet which drive |
| * the INSERT/UPDATE/DELETE actions. |
| */ |
| ResultColumnList getThenColumns() { return _thenColumns; } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // bind() BEHAVIOR CALLED BY MergeNode |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** Bind this WHEN [ NOT ] MATCHED clause against the parent MergeNode */ |
| void bind |
| ( |
| DataDictionary dd, |
| MergeNode mergeNode, |
| FromList fullFromList, |
| FromBaseTable targetTable |
| ) |
| throws StandardException |
| { |
| // |
| // Although the SQL Standard allows subqueries in the WHEN [ NOT ] MATCHED clauses, |
| // we don't support them yet. That is because code-generation for those clauses breaks |
| // if they contain subqueries. That, in turn, is because we don't completely optimize those |
| // clauses. If we improve Derby so that we do completely optimize the WHEN [ NOT ] MATCHED clauses, |
| // then we can consider enabling subqueries in them. |
| // |
| forbidSubqueries(); |
| |
| _thenColumns = new ResultColumnList( getContextManager() ); |
| |
| if ( isDeleteClause() ) { bindDelete( dd, fullFromList, targetTable ); } |
| if ( isUpdateClause() ) { bindUpdate( dd, mergeNode, fullFromList, targetTable ); } |
| if ( isInsertClause() ) { bindInsert( dd, mergeNode, fullFromList, targetTable ); } |
| } |
| |
| /** Bind the optional refinement condition in the MATCHED clause */ |
| void bindRefinement( MergeNode mergeNode, FromList fullFromList ) throws StandardException |
| { |
| if ( _matchingRefinement != null ) |
| { |
| FromList fromList = fullFromList; |
| |
| // |
| // For an INSERT action, the WHEN NOT MATCHED refinement can only |
| // mention columns in the source table. |
| // |
| if ( isInsertClause() ) |
| { |
| fromList = new FromList( getOptimizerFactory().doJoinOrderOptimization(), getContextManager() ); |
| fromList.addElement( fullFromList.elementAt( MergeNode.SOURCE_TABLE_INDEX ) ); |
| } |
| |
| mergeNode.bindExpression( _matchingRefinement, fromList ); |
| } |
| } |
| |
| /** Collect the columns mentioned by expressions in this MATCHED clause */ |
| void getColumnsInExpressions |
| ( |
| MergeNode mergeNode, |
| HashMap<String,ColumnReference> drivingColumnMap |
| ) |
| throws StandardException |
| { |
| if ( _matchingRefinement != null ) |
| { |
| mergeNode.getColumnsInExpression( drivingColumnMap, _matchingRefinement, ColumnReference.MERGE_UNKNOWN ); |
| } |
| |
| if ( isUpdateClause() ) |
| { |
| TableName targetTableName = mergeNode.getTargetTable().getTableName(); |
| |
| // |
| // Get all columns mentioned on both sides of SET operators in WHEN MATCHED ... THEN UPDATE clauses. |
| // We need the left side because UPDATE needs before and after images of columns. |
| // We need the right side because there may be columns in the expressions there. |
| // |
| for ( ResultColumn rc : _updateColumns ) |
| { |
| mergeNode.getColumnsInExpression( drivingColumnMap, rc.getExpression(), ColumnReference.MERGE_UNKNOWN ); |
| |
| ColumnReference leftCR = new ColumnReference( rc.getName(), targetTableName, getContextManager() ); |
| mergeNode.addColumn( drivingColumnMap, leftCR, ColumnReference.MERGE_TARGET ); |
| } |
| } |
| else if ( isInsertClause() ) |
| { |
| // get all columns mentioned in the VALUES subclauses of WHEN NOT MATCHED ... THEN INSERT clauses |
| for ( ResultColumn rc : _insertValues ) |
| { |
| mergeNode.getColumnsInExpression( drivingColumnMap, rc.getExpression(), ColumnReference.MERGE_UNKNOWN ); |
| } |
| } |
| else if ( isDeleteClause() ) |
| { |
| // add all of the THEN columns |
| mergeNode.getColumnsFromList( drivingColumnMap, _thenColumns, ColumnReference.MERGE_TARGET ); |
| } |
| } |
| |
| //////////////// |
| // |
| // BIND UPDATE |
| // |
| //////////////// |
| |
| /** Bind a WHEN MATCHED ... THEN UPDATE clause */ |
| private void bindUpdate |
| ( |
| DataDictionary dd, |
| MergeNode mergeNode, |
| FromList fullFromList, |
| FromBaseTable targetTable |
| ) |
| throws StandardException |
| { |
| ResultColumnList setClauses = realiasSetClauses( targetTable ); |
| bindSetClauses( mergeNode, fullFromList, targetTable, setClauses ); |
| |
| TableName tableName = targetTable.getTableNameField(); |
| FromList selectFromList = fullFromList; |
| |
| SelectNode selectNode = new SelectNode |
| ( |
| setClauses, |
| selectFromList, |
| null, // where clause |
| null, // group by list |
| null, // having clause |
| null, // window list |
| null, // optimizer plan override |
| getContextManager() |
| ); |
| _dml = new UpdateNode( tableName, selectNode, this, getContextManager() ); |
| |
| _dml.bindStatement(); |
| |
| // |
| // Don't add USAGE privilege on user-defined types. |
| // |
| boolean wasSkippingTypePrivileges = getCompilerContext().skipTypePrivileges( true ); |
| |
| // |
| // Split the update row into its before and after images. |
| // |
| ResultColumnList beforeColumns = new ResultColumnList( getContextManager() ); |
| ResultColumnList afterColumns = new ResultColumnList( getContextManager() ); |
| ResultColumnList fullUpdateRow = getBoundSelectUnderUpdate().getResultColumns(); |
| |
| // the full row is the before image, the after image, and a row location |
| int rowSize = fullUpdateRow.size() / 2; |
| |
| // split the row into before and after images |
| for ( int i = 0; i < rowSize; i++ ) |
| { |
| ResultColumn origBeforeRC = fullUpdateRow.elementAt( i ); |
| ResultColumn origAfterRC = fullUpdateRow.elementAt( i + rowSize ); |
| ResultColumn beforeRC = origBeforeRC.cloneMe(); |
| ResultColumn afterRC = origAfterRC.cloneMe(); |
| |
| beforeColumns.addResultColumn( beforeRC ); |
| afterColumns.addResultColumn( afterRC ); |
| } |
| |
| buildThenColumnsForUpdate( fullFromList, targetTable, fullUpdateRow, beforeColumns, afterColumns ); |
| |
| getCompilerContext().skipTypePrivileges( wasSkippingTypePrivileges ); |
| } |
| |
| /** |
| * <p> |
| * Due to discrepancies in how names are resolved by SELECT and UPDATE, |
| * we have to force the left side of SET clauses to use the same table identifiers |
| * as the right sides of the SET clauses. |
| * </p> |
| */ |
| private ResultColumnList realiasSetClauses |
| ( |
| FromBaseTable targetTable |
| ) |
| throws StandardException |
| { |
| ResultColumnList rcl = new ResultColumnList( getContextManager() ); |
| for ( int i = 0; i < _updateColumns.size(); i++ ) |
| { |
| ResultColumn setRC = _updateColumns.elementAt( i ); |
| TableName tableName = targetTable.getTableName(); |
| ColumnReference newTargetColumn = new ColumnReference |
| ( |
| setRC.getReference().getColumnName(), |
| tableName, |
| getContextManager() |
| ); |
| newTargetColumn.setMergeTableID( ColumnReference.MERGE_TARGET ); |
| ResultColumn newRC = new ResultColumn |
| ( |
| newTargetColumn, |
| setRC.getExpression(), |
| getContextManager() |
| ); |
| rcl.addResultColumn( newRC ); |
| } |
| |
| return rcl; |
| } |
| |
| /** |
| * <p> |
| * Get the bound SELECT node under the dummy UPDATE node. |
| * This may not be the source result set of the UPDATE node. That is because a ProjectRestrictNode |
| * may have been inserted on top of it by DEFAULT handling. This method |
| * exists to make the UPDATE actions of MERGE statements behave like ordinary |
| * UPDATE statements in this situation. The behavior is actually wrong. See |
| * DERBY-6414. Depending on how that bug is addressed, we may be able |
| * to remove this method eventually. |
| * </p> |
| */ |
| private ResultSetNode getBoundSelectUnderUpdate() |
| throws StandardException |
| { |
| ResultSetNode candidate = _dml.resultSet; |
| |
| while ( candidate != null ) |
| { |
| if ( candidate instanceof SelectNode ) { return candidate; } |
| else if ( candidate instanceof SingleChildResultSetNode ) |
| { |
| candidate = ((SingleChildResultSetNode) candidate).getChildResult(); |
| } |
| else { break; } |
| } |
| |
| // don't understand what's going on |
| throw StandardException.newException( SQLState.NOT_IMPLEMENTED ); |
| } |
| |
| /** Bind the SET clauses of an UPDATE action */ |
| private void bindSetClauses |
| ( |
| MergeNode mergeNode, |
| FromList fullFromList, |
| FromTable targetTable, |
| ResultColumnList setClauses |
| ) |
| throws StandardException |
| { |
| // needed to make the UpdateNode bind |
| setClauses.replaceOrForbidDefaults( targetTable.getTableDescriptor(), _updateColumns, true ); |
| |
| bindExpressions( setClauses, fullFromList ); |
| |
| // |
| // For column resolution later on, columns on the left side |
| // of SET operators are associated with the TARGET table. |
| // |
| for ( int i = 0; i < _updateColumns.size(); i++ ) |
| { |
| ResultColumn rc = _updateColumns.elementAt( i ); |
| ColumnReference cr = rc.getReference(); |
| cr.setMergeTableID( ColumnReference.MERGE_TARGET ); |
| } |
| |
| // Now associate the columns on the right side of SET operators. |
| List<ColumnReference> colRefs = getColumnReferences( _updateColumns ); |
| for ( ColumnReference cr : colRefs ) |
| { |
| mergeNode.associateColumn( fullFromList, cr, ColumnReference.MERGE_UNKNOWN ); |
| } |
| } |
| |
| /** |
| * <p> |
| * Construct the row in the temporary table which drives an UPDATE action. |
| * Unlike a DELETE, whose temporary row is just a list of copied columns, the |
| * temporary row for UPDATE may contain complex expressions which must |
| * be code-generated later on. |
| * </p> |
| */ |
| private void buildThenColumnsForUpdate |
| ( |
| FromList fullFromList, |
| FromTable targetTable, |
| ResultColumnList fullRow, |
| ResultColumnList beforeRow, |
| ResultColumnList afterValues |
| ) |
| throws StandardException |
| { |
| TableDescriptor td = targetTable.getTableDescriptor(); |
| HashSet<String> changedColumns = getChangedColumnNames(); |
| HashSet<String> changedGeneratedColumns = getChangedGeneratedColumnNames( td, changedColumns ); |
| |
| _thenColumns = fullRow.copyListAndObjects(); |
| |
| // |
| // Here we set up for the evaluation of expressions in the temporary table |
| // which drives the INSERT action. If we were actually generating the dummy SELECT |
| // for the DML action, the work would normally be done there. But we don't generate |
| // that SELECT. So we do the following here: |
| // |
| // 1) If a column has a value specified in the WHEN [ NOT ] MATCHED clause, then we use it. |
| // There is some special handling to make the DEFAULT value work for identity columns. |
| // |
| // 2) Otherwise, if the column has a default, then we plug it in. |
| // |
| for ( int i = 0; i < _thenColumns.size(); i++ ) |
| { |
| ResultColumn origRC = _thenColumns.elementAt( i ); |
| |
| boolean isAfterColumn = (i >= beforeRow.size()); |
| |
| // skip the final RowLocation column of an UPDATE |
| boolean isRowLocation = isRowLocation( origRC ); |
| ValueNode origExpr = origRC.getExpression(); |
| |
| if ( isRowLocation ) { continue; } |
| |
| String columnName = origRC.getName(); |
| ColumnDescriptor cd = td.getColumnDescriptor( columnName ); |
| boolean changed = false; |
| |
| // |
| // This handles the case that a GENERATED BY DEFAULT identity column is being |
| // set to the keyword DEFAULT. This causes the UPDATE action of a MERGE statement |
| // to have the same wrong behavior as a regular UPDATE statement. See derby-6414. |
| // |
| if ( cd.isAutoincrement() && (origRC.getExpression() instanceof NumericConstantNode) ) |
| { |
| DataValueDescriptor numericValue = ((NumericConstantNode) origRC.getExpression()).getValue(); |
| |
| if ( numericValue == null ) |
| { |
| ResultColumn newRC = makeAutoGenRC( targetTable, origRC, i+1 ); |
| newRC.setVirtualColumnId( origRC.getVirtualColumnId() ); |
| _thenColumns.setElementAt( newRC, i ); |
| |
| continue; |
| } |
| } |
| |
| // |
| // VirtualColumnNodes are skipped at code-generation time. This can result in |
| // NPEs when evaluating generation expressions. Replace VirtualColumnNodes with |
| // UntypedNullConstantNodes, except for identity columns, which require special |
| // handling below. |
| // |
| if ( !origRC.isAutoincrement() && (origRC.getExpression() instanceof VirtualColumnNode) ) |
| { |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| } |
| |
| // |
| // Generated columns need special handling. The value needs to be recalculated |
| // under the following circumstances: |
| // |
| // 1) It's the after image of the column |
| // |
| // 2) AND the statement causes the value to change. |
| // |
| // Otherwise, the value should be set to whatever is in the row coming out |
| // of the driving left join. |
| // |
| if ( cd.hasGenerationClause() ) |
| { |
| if ( isAfterColumn && changedGeneratedColumns.contains( columnName ) ) |
| { |
| // Set the expression to something that won't choke ResultColumnList.generateEvaluatedRow(). |
| // The value will be a Java null at execution time, which will cause the value |
| // to be re-generated. |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| } |
| else |
| { |
| ColumnReference cr = new ColumnReference |
| ( columnName, targetTable.getTableName(), getContextManager() ); |
| origRC.setExpression( cr ); |
| |
| // remove the column descriptor in order to turn off hasGenerationClause() |
| origRC.setColumnDescriptor( null, null ); |
| } |
| |
| continue; |
| } |
| |
| if ( isAfterColumn ) |
| { |
| for ( int ic = 0; ic < beforeRow.size(); ic++ ) |
| { |
| ResultColumn icRC = beforeRow.elementAt( ic ); |
| |
| if ( columnName.equals( icRC.getName() ) ) |
| { |
| ResultColumn newRC = null; |
| |
| // replace DEFAULT for a generated or identity column |
| ResultColumn valueRC = afterValues.elementAt( ic ); |
| |
| if ( valueRC.wasDefaultColumn() || (valueRC.getExpression() instanceof UntypedNullConstantNode ) ) |
| { |
| if ( !cd.isAutoincrement() ) |
| { |
| // |
| // Eliminate column references under identity columns. They |
| // will mess up the code generation. |
| // |
| ValueNode expr = origRC.getExpression(); |
| if ( expr instanceof ColumnReference ) |
| { |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| } |
| continue; |
| } |
| |
| newRC = makeAutoGenRC( targetTable, origRC, i+1 ); |
| } |
| else |
| { |
| newRC = valueRC.cloneMe(); |
| newRC.setType( origRC.getTypeServices() ); |
| } |
| |
| newRC.setVirtualColumnId( origRC.getVirtualColumnId() ); |
| _thenColumns.setElementAt( newRC, i ); |
| changed = true; |
| break; |
| } |
| } |
| } |
| |
| // plug in defaults if we haven't done so already |
| if ( !changed ) |
| { |
| DefaultInfoImpl defaultInfo = (DefaultInfoImpl) cd.getDefaultInfo(); |
| |
| if ( (defaultInfo != null) && !defaultInfo.isGeneratedColumn() && !cd.isAutoincrement() ) |
| { |
| _thenColumns.setDefault( origRC, cd, defaultInfo ); |
| changed = true; |
| } |
| } |
| |
| // set the result column name correctly for buildThenColumnSignature() |
| ResultColumn finalRC = _thenColumns.elementAt( i ); |
| finalRC.setName( cd.getColumnName() ); |
| |
| // |
| // Turn off the autogenerated bit for identity columns so that |
| // ResultColumnList.generateEvaluatedRow() doesn't try to compile |
| // code to generate values for the before images in UPDATE rows. |
| // This logic will probably need to be revisited as part of fixing derby-6414. |
| // |
| finalRC.resetAutoincrementGenerated(); |
| } // end loop through _thenColumns |
| } |
| |
| /** Get the names of the columns explicitly changed by SET clauses */ |
| private HashSet<String> getChangedColumnNames() |
| throws StandardException |
| { |
| HashSet<String> result = new HashSet<String>(); |
| |
| for ( int i = 0; i < _updateColumns.size(); i++ ) |
| { |
| String columnName = _updateColumns.elementAt( i ).getName(); |
| result.add( columnName ); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * <p> |
| * Get the names of the generated columns which are changed |
| * by the UPDATE statement. These are the generated columns which |
| * match one of the following conditions: |
| * </p> |
| * |
| * <ul> |
| * <li>Are explicitly mentioned on the left side of a SET clause.</li> |
| * <li>Are built from other columns which are explicitly mentioned on the left side of a SET clause.</li> |
| * </ul> |
| */ |
| private HashSet<String> getChangedGeneratedColumnNames |
| ( |
| TableDescriptor targetTableDescriptor, |
| HashSet<String> changedColumnNames // columns which are explicitly mentioned on the left side of a SET clause |
| ) |
| throws StandardException |
| { |
| HashSet<String> result = new HashSet<String>(); |
| |
| for ( ColumnDescriptor cd : targetTableDescriptor.getColumnDescriptorList() ) |
| { |
| if ( !cd.hasGenerationClause() ) { continue; } |
| |
| if ( changedColumnNames.contains( cd.getColumnName() ) ) |
| { |
| result.add( cd.getColumnName() ); |
| continue; |
| } |
| |
| String[] referencedColumns = cd.getDefaultInfo().getReferencedColumnNames(); |
| |
| for ( String referencedColumnName : referencedColumns ) |
| { |
| if ( changedColumnNames.contains( referencedColumnName ) ) |
| { |
| result.add( referencedColumnName ); |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| |
| //////////////// |
| // |
| // BIND DELETE |
| // |
| //////////////// |
| |
| /** Bind a WHEN MATCHED ... THEN DELETE clause */ |
| private void bindDelete |
| ( |
| DataDictionary dd, |
| FromList fullFromList, |
| FromBaseTable targetTable |
| ) |
| throws StandardException |
| { |
| // |
| // Don't add any privileges until we bind the DELETE. |
| // |
| IgnoreFilter ignorePermissions = new IgnoreFilter(); |
| getCompilerContext().addPrivilegeFilter( ignorePermissions ); |
| |
| FromBaseTable deleteTarget = new FromBaseTable |
| ( targetTable.getTableNameField(), null, null, null, getContextManager() ); |
| FromList dummyFromList = new FromList( getContextManager() ); |
| dummyFromList.addFromTable( deleteTarget ); |
| dummyFromList.bindTables( dd, new FromList( getOptimizerFactory().doJoinOrderOptimization(), getContextManager() ) ); |
| |
| CurrentOfNode currentOfNode = CurrentOfNode.makeForMerge |
| ( CURRENT_OF_NODE_NAME, deleteTarget, getContextManager() ); |
| FromList fromList = new FromList( getContextManager() ); |
| fromList.addFromTable( currentOfNode ); |
| SelectNode selectNode = new SelectNode |
| ( |
| null, |
| fromList, /* FROM list */ |
| null, /* WHERE clause */ |
| null, /* GROUP BY list */ |
| null, /* having clause */ |
| null, /* window list */ |
| null, /* optimizer plan override */ |
| getContextManager() |
| ); |
| _dml = new DeleteNode( targetTable.getTableNameField(), selectNode, this, getContextManager() ); |
| |
| // ready to add permissions |
| getCompilerContext().removePrivilegeFilter( ignorePermissions ); |
| |
| _dml.bindStatement(); |
| |
| buildThenColumnsForDelete(); |
| } |
| |
| /** |
| * <p> |
| * Construct the signature of the temporary table which drives the |
| * INSERT/UPDATE/DELETE action. |
| * </p> |
| */ |
| private void buildThenColumnsForDelete() |
| throws StandardException |
| { |
| ResultColumnList dmlSignature = _dml.resultSet.getResultColumns(); |
| for ( int i = 0; i < dmlSignature.size(); i++ ) |
| { |
| ResultColumn origRC = dmlSignature.elementAt( i ); |
| ResultColumn newRC; |
| ValueNode expression = origRC.getExpression(); |
| |
| if ( expression instanceof ColumnReference ) |
| { |
| ColumnReference cr = (ColumnReference) ((ColumnReference) expression).getClone(); |
| newRC = new ResultColumn( cr, cr, getContextManager() ); |
| } |
| else |
| { |
| newRC = origRC.cloneMe(); |
| } |
| _thenColumns.addResultColumn( newRC ); |
| } |
| } |
| |
| //////////////// |
| // |
| // BIND INSERT |
| // |
| //////////////// |
| |
| /** Bind a WHEN NOT MATCHED ... THEN INSERT clause */ |
| private void bindInsert |
| ( |
| DataDictionary dd, |
| MergeNode mergeNode, |
| FromList fullFromList, |
| FromBaseTable targetTable |
| ) |
| throws StandardException |
| { |
| ResultColumnList selectList = new ResultColumnList( getContextManager() ); |
| for ( int i = 0; i < _insertValues.size(); i++ ) |
| { |
| ResultColumn rc = _insertValues.elementAt( i ); |
| selectList.addResultColumn( rc.cloneMe() ); |
| } |
| selectList.replaceOrForbidDefaults( targetTable.getTableDescriptor(), _insertColumns, true ); |
| |
| bindExpressions( selectList, fullFromList ); |
| |
| bindInsertValues( fullFromList, targetTable ); |
| |
| // the VALUES clause may not mention columns in the target table |
| FromList sourceTableFromList = new FromList( getOptimizerFactory().doJoinOrderOptimization(), getContextManager() ); |
| sourceTableFromList.addElement( fullFromList.elementAt( MergeNode.SOURCE_TABLE_INDEX ) ); |
| bindExpressions( _insertValues, sourceTableFromList ); |
| |
| SelectNode selectNode = new SelectNode |
| ( |
| selectList, // select list |
| fullFromList, |
| null, // where clause |
| null, // group by list |
| null, // having clause |
| null, // window list |
| null, // optimizer plan override |
| getContextManager() |
| ); |
| _dml = new InsertNode |
| ( |
| targetTable.getTableNameField(), |
| _insertColumns, |
| selectNode, |
| this, // in NOT MATCHED clause |
| null, // targetProperties |
| null, // order by cols |
| null, // offset |
| null, // fetch first |
| false, // has JDBC limit clause |
| getContextManager() |
| ); |
| |
| _dml.bindStatement(); |
| |
| buildThenColumnsForInsert( fullFromList, targetTable, _dml.resultSet.getResultColumns(), _insertColumns, _insertValues ); |
| } |
| |
| /** Bind the values in the INSERT list */ |
| private void bindInsertValues |
| ( |
| FromList fullFromList, |
| FromTable targetTable |
| ) |
| throws StandardException |
| { |
| TableDescriptor td = targetTable.getTableDescriptor(); |
| |
| // construct a full insert column list if insert columns weren't specified |
| if ( _insertColumns == null ) { _insertColumns = buildFullColumnList( td ); } |
| |
| if ( _insertColumns.size() != _insertValues.size() ) |
| { |
| throw StandardException.newException( SQLState.LANG_DB2_INVALID_COLS_SPECIFIED ); |
| } |
| |
| // forbid illegal values for identity columns |
| for ( int i = 0; i <_insertValues.size(); i++ ) |
| { |
| ResultColumn rc = _insertValues.elementAt( i ); |
| String columnName = _insertColumns.elementAt( i ).getName(); |
| ValueNode expr = rc.getExpression(); |
| ColumnDescriptor cd = td.getColumnDescriptor( columnName ); |
| |
| // if the column isn't in the table, this will be sorted out when we bind |
| // the InsertNode |
| if ( cd == null ) { continue; } |
| |
| // DEFAULT is the only value allowed for a GENERATED ALWAYS AS IDENTITY column |
| if ( cd.isAutoincAlways() && !(expr instanceof DefaultNode) ) |
| { |
| throw StandardException.newException( SQLState.LANG_AI_CANNOT_MODIFY_AI, columnName ); |
| } |
| |
| // NULL is illegal as the value for any identity column |
| if ( cd.isAutoincrement() && (expr instanceof UntypedNullConstantNode) ) |
| { |
| throw StandardException.newException( SQLState.LANG_NULL_INTO_NON_NULL, columnName ); |
| } |
| } |
| |
| // needed to make the SelectNode bind |
| _insertValues.replaceOrForbidDefaults( targetTable.getTableDescriptor(), _insertColumns, true ); |
| bindExpressions( _insertValues, fullFromList ); |
| } |
| |
| /** |
| * <p> |
| * Build the full column list for a table. |
| * </p> |
| */ |
| private ResultColumnList buildFullColumnList( TableDescriptor td ) |
| throws StandardException |
| { |
| ResultColumnList result = new ResultColumnList( getContextManager() ); |
| ColumnDescriptorList cdl = td.getColumnDescriptorList(); |
| int cdlSize = cdl.size(); |
| |
| for ( int index = 0; index < cdlSize; index++ ) |
| { |
| ColumnDescriptor colDesc = cdl.elementAt( index ); |
| ColumnReference columnRef = new ColumnReference( colDesc.getColumnName(), null, getContextManager() ); |
| ResultColumn resultColumn = new ResultColumn |
| ( |
| columnRef, |
| null, |
| getContextManager() |
| ); |
| |
| result.addResultColumn( resultColumn ); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * <p> |
| * Construct the row in the temporary table which drives an INSERT action. |
| * Unlike a DELETE, whose temporary row is just a list of copied columns, the |
| * temporary row for INSERT may contain complex expressions which must |
| * be code-generated later on. |
| * </p> |
| */ |
| private void buildThenColumnsForInsert |
| ( |
| FromList fullFromList, |
| FromTable targetTable, |
| ResultColumnList fullRow, |
| ResultColumnList insertColumns, |
| ResultColumnList insertValues |
| ) |
| throws StandardException |
| { |
| // |
| // Don't add USAGE privilege on user-defined types just because we're |
| // building the THEN columns. |
| // |
| boolean wasSkippingTypePrivileges = getCompilerContext().skipTypePrivileges( true ); |
| TableDescriptor td = targetTable.getTableDescriptor(); |
| |
| _thenColumns = fullRow.copyListAndObjects(); |
| |
| // |
| // Here we set up for the evaluation of expressions in the temporary table |
| // which drives the INSERT action. If we were actually generating the dummy SELECT |
| // for the DML action, the work would normally be done there. But we don't generate |
| // that SELECT. So we do the following here: |
| // |
| // 1) If a column has a value specified in the WHEN [ NOT ] MATCHED clause, then we use it. |
| // There is some special handling to make the DEFAULT value work for identity columns. |
| // |
| // 2) Otherwise, if the column has a default, then we plug it in. |
| // |
| for ( int i = 0; i < _thenColumns.size(); i++ ) |
| { |
| ResultColumn origRC = _thenColumns.elementAt( i ); |
| |
| String columnName = origRC.getName(); |
| ColumnDescriptor cd = td.getColumnDescriptor( columnName ); |
| boolean changed = false; |
| |
| // |
| // VirtualColumnNodes are skipped at code-generation time. This can result in |
| // NPEs when evaluating generation expressions. Replace VirtualColumnNodes with |
| // UntypedNullConstantNodes, except for identity columns, which require special |
| // handling below. |
| // |
| if ( !origRC.isAutoincrement() && (origRC.getExpression() instanceof VirtualColumnNode) ) |
| { |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| } |
| |
| if ( cd.hasGenerationClause() ) |
| { |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| continue; |
| } |
| |
| for ( int ic = 0; ic < insertColumns.size(); ic++ ) |
| { |
| ResultColumn icRC = insertColumns.elementAt( ic ); |
| |
| if ( columnName.equals( icRC.getName() ) ) |
| { |
| ResultColumn newRC = null; |
| |
| // replace DEFAULT for a generated or identity column |
| ResultColumn valueRC = insertValues.elementAt( ic ); |
| |
| if ( valueRC.wasDefaultColumn() || (valueRC.getExpression() instanceof UntypedNullConstantNode ) ) |
| { |
| if ( !cd.isAutoincrement() ) |
| { |
| // |
| // Eliminate column references under identity columns. They |
| // will mess up the code generation. |
| // |
| ValueNode expr = origRC.getExpression(); |
| if ( expr instanceof ColumnReference ) |
| { |
| origRC.setExpression( new UntypedNullConstantNode( getContextManager() ) ); |
| } |
| continue; |
| } |
| |
| newRC = makeAutoGenRC( targetTable, origRC, i+1 ); |
| } |
| else |
| { |
| newRC = valueRC.cloneMe(); |
| newRC.setType( origRC.getTypeServices() ); |
| } |
| |
| newRC.setVirtualColumnId( origRC.getVirtualColumnId() ); |
| _thenColumns.setElementAt( newRC, i ); |
| changed = true; |
| break; |
| } |
| } |
| |
| // plug in defaults if we haven't done so already |
| if ( !changed ) |
| { |
| DefaultInfoImpl defaultInfo = (DefaultInfoImpl) cd.getDefaultInfo(); |
| |
| if ( (defaultInfo != null) && !defaultInfo.isGeneratedColumn() && !cd.isAutoincrement() ) |
| { |
| _thenColumns.setDefault( origRC, cd, defaultInfo ); |
| changed = true; |
| } |
| } |
| |
| // set the result column name correctly for buildThenColumnSignature() |
| ResultColumn finalRC = _thenColumns.elementAt( i ); |
| finalRC.setName( cd.getColumnName() ); |
| |
| } // end loop through _thenColumns |
| |
| getCompilerContext().skipTypePrivileges( wasSkippingTypePrivileges ); |
| } |
| |
| /** |
| * <p> |
| * Make a ResultColumn for an identity column which is being set to the DEFAULT |
| * value. This special ResultColumn will make it through code generation so that it |
| * will be calculated when the INSERT/UPDATE action is run. |
| * </p> |
| */ |
| private ResultColumn makeAutoGenRC |
| ( |
| FromTable targetTable, |
| ResultColumn origRC, |
| int virtualColumnID |
| ) |
| throws StandardException |
| { |
| String columnName = origRC.getName(); |
| ColumnReference autoGenCR = new ColumnReference( columnName, targetTable.getTableName(), getContextManager() ); |
| ResultColumn autoGenRC = new ResultColumn( autoGenCR, null, getContextManager() ); |
| VirtualColumnNode autoGenVCN = new VirtualColumnNode( targetTable, autoGenRC, virtualColumnID, getContextManager() ); |
| ResultColumn newRC = new ResultColumn( autoGenCR, autoGenVCN, getContextManager() ); |
| |
| // set the type so that buildThenColumnSignature() will function correctly |
| newRC.setType( origRC.getTypeServices() ); |
| |
| return newRC; |
| } |
| |
| |
| ///////////////// |
| // |
| // BIND MINIONS |
| // |
| ///////////////// |
| |
| /** Boilerplate for binding a list of ResultColumns against a FromList */ |
| private void bindExpressions( ResultColumnList rcl, FromList fromList ) |
| throws StandardException |
| { |
| CompilerContext cc = getCompilerContext(); |
| final int previousReliability = cc.getReliability(); |
| |
| boolean wasSkippingTypePrivileges = cc.skipTypePrivileges( true ); |
| cc.setReliability( previousReliability | CompilerContext.SQL_IN_ROUTINES_ILLEGAL ); |
| |
| try { |
| rcl.bindExpressions |
| ( |
| fromList, |
| new SubqueryList( getContextManager() ), |
| new ArrayList<AggregateNode>() |
| ); |
| } |
| finally |
| { |
| // Restore previous compiler state |
| cc.setReliability( previousReliability ); |
| cc.skipTypePrivileges( wasSkippingTypePrivileges ); |
| } |
| } |
| |
| /** |
| * <p> |
| * Forbid subqueries in WHEN [ NOT ] MATCHED clauses. |
| * </p> |
| */ |
| private void forbidSubqueries() |
| throws StandardException |
| { |
| forbidSubqueries( _matchingRefinement ); |
| forbidSubqueries( _updateColumns ); |
| forbidSubqueries( _insertColumns ); |
| forbidSubqueries( _insertValues ); |
| } |
| private void forbidSubqueries( ResultColumnList rcl ) |
| throws StandardException |
| { |
| if ( rcl != null ) |
| { |
| for ( int i = 0; i < rcl.size(); i++ ) |
| { |
| forbidSubqueries( rcl.elementAt( i ) ); |
| } |
| } |
| } |
| private void forbidSubqueries( ValueNode expr ) |
| throws StandardException |
| { |
| if ( expr != null ) |
| { |
| CollectNodesVisitor<SubqueryNode> getSubqueries = |
| new CollectNodesVisitor<SubqueryNode>(SubqueryNode.class); |
| expr.accept( getSubqueries ); |
| if ( getSubqueries.getList().size() > 0 ) |
| { |
| throw StandardException.newException( SQLState.LANG_NO_SUBQUERIES_IN_MATCHED_CLAUSE ); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // optimize() BEHAVIOR |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * <p> |
| * Optimize the INSERT/UPDATE/DELETE action. |
| * </p> |
| */ |
| void optimize() throws StandardException |
| { |
| _dml.optimizeStatement(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // generate() BEHAVIOR |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| ConstantAction makeConstantAction( ActivationClassBuilder acb ) |
| throws StandardException |
| { |
| // generate the clause-specific refinement |
| String refinementName = null; |
| if ( _matchingRefinement != null ) |
| { |
| MethodBuilder userExprFun = acb.newUserExprFun(); |
| |
| _matchingRefinement.generateExpression( acb, userExprFun ); |
| userExprFun.methodReturn(); |
| |
| // we are done modifying userExprFun, complete it. |
| userExprFun.complete(); |
| |
| refinementName = userExprFun.getName(); |
| } |
| |
| return getGenericConstantActionFactory().getMatchingClauseConstantAction |
| ( |
| getClauseType(), |
| refinementName, |
| buildThenColumnSignature(), |
| _rowMakingMethodName, |
| _resultSetFieldName, |
| _actionMethodName, |
| _dml.makeConstantAction() |
| ); |
| } |
| private int getClauseType() |
| { |
| if ( isUpdateClause() ) { return ConstantAction.WHEN_MATCHED_THEN_UPDATE; } |
| else if ( isInsertClause() ) { return ConstantAction.WHEN_NOT_MATCHED_THEN_INSERT; } |
| else { return ConstantAction.WHEN_MATCHED_THEN_DELETE; } |
| } |
| |
| /** |
| * <p> |
| * Build the signature of the row which will go into the temporary table. |
| * </p> |
| */ |
| private ResultDescription buildThenColumnSignature() |
| throws StandardException |
| { |
| ResultColumnDescriptor[] cells = _thenColumns.makeResultDescriptors(); |
| |
| return getLanguageConnectionContext().getLanguageFactory().getResultDescription( cells, "MERGE" ); |
| } |
| |
| /** |
| * <p> |
| * Generate a method to invoke the INSERT/UPDATE/DELETE action. This method |
| * will be called at runtime by MatchingClauseConstantAction.executeConstantAction(). |
| * </p> |
| */ |
| void generate |
| ( |
| ActivationClassBuilder acb, |
| ResultColumnList selectList, |
| ResultSetNode generatedScan, |
| HalfOuterJoinNode hojn, |
| int clauseNumber |
| ) |
| throws StandardException |
| { |
| _clauseNumber = clauseNumber; |
| |
| adjustMatchingRefinement( selectList, generatedScan ); |
| |
| generateInsertUpdateRow( acb, selectList, generatedScan, hojn ); |
| |
| _actionMethodName = "mergeActionMethod_" + _clauseNumber; |
| |
| MethodBuilder mb = acb.getClassBuilder().newMethodBuilder |
| ( |
| Modifier.PUBLIC, |
| ClassName.ResultSet, |
| _actionMethodName |
| ); |
| mb.addThrownException(ClassName.StandardException); |
| |
| remapConstraints(); |
| |
| // now generate the action into this method |
| _dml.generate( acb, mb ); |
| |
| mb.methodReturn(); |
| mb.complete(); |
| } |
| |
| /** |
| * <p> |
| * Re-map ColumnReferences in constraints to point into the row from the |
| * temporary table. This is where the row will be stored when constraints |
| * are being evaluated. |
| * </p> |
| */ |
| private void remapConstraints() |
| throws StandardException |
| { |
| if( isDeleteClause()) { return; } |
| else |
| { |
| ValueNode checkConstraints = isInsertClause() ? |
| ((InsertNode) _dml).checkConstraints : |
| ((UpdateNode) _dml).checkConstraints; |
| |
| if ( checkConstraints != null ) |
| { |
| List<ColumnReference> colRefs = getColumnReferences( checkConstraints ); |
| for ( ColumnReference cr : colRefs ) |
| { |
| cr.getSource().setResultSetNumber( NoPutResultSet.TEMPORARY_RESULT_SET_NUMBER ); |
| } |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * Adds a field to the generated class to hold the ResultSet of "then" rows |
| * which drive the INSERT/UPDATE/DELETE action. Generates code to push |
| * the contents of that field onto the stack. |
| * </p> |
| */ |
| void generateResultSetField( ActivationClassBuilder acb, MethodBuilder mb ) |
| throws StandardException |
| { |
| _resultSetFieldName = "mergeResultSetField_" + _clauseNumber; |
| |
| // make the field public so we can stuff it at execution time |
| LocalField resultSetField = acb.newFieldDeclaration( Modifier.PUBLIC, ClassName.NoPutResultSet, _resultSetFieldName ); |
| |
| // |
| // At runtime, MatchingClauseConstantAction.executeConstantAction() |
| // will stuff the resultSetField with the temporary table which collects |
| // the rows relevant to this action. We want to push the value of resultSetField |
| // onto the stack, where it will be the ResultSet argument to the constructor |
| // of the actual INSERT/UPDATE/DELETE action. |
| // |
| mb.getField( resultSetField ); |
| } |
| |
| /** |
| * <p> |
| * Generate a method to build a row for the temporary table for INSERT/UPDATE actions. |
| * The method stuffs each column in the row with the result of the corresponding |
| * expression built out of columns in the current row of the driving left join. |
| * The method returns the stuffed row. |
| * </p> |
| */ |
| private void generateInsertUpdateRow |
| ( |
| ActivationClassBuilder acb, |
| ResultColumnList selectList, |
| ResultSetNode generatedScan, |
| HalfOuterJoinNode hojn |
| ) |
| throws StandardException |
| { |
| // point expressions in the temporary row at the columns in the |
| // result column list of the driving left join. |
| adjustThenColumns( selectList, generatedScan, hojn ); |
| |
| _rowMakingMethodName = "mergeRowMakingMethod_" + _clauseNumber; |
| |
| MethodBuilder mb = acb.getClassBuilder().newMethodBuilder |
| ( |
| Modifier.PUBLIC, |
| ClassName.ExecRow, |
| _rowMakingMethodName |
| ); |
| mb.addThrownException(ClassName.StandardException); |
| |
| _thenColumns.generateEvaluatedRow( acb, mb, false, true ); |
| } |
| |
| /** |
| * <p> |
| * Point the column references in the matching refinement at the corresponding |
| * columns returned by the driving left join. |
| * </p> |
| */ |
| private void adjustMatchingRefinement |
| ( |
| ResultColumnList selectList, |
| ResultSetNode generatedScan |
| ) |
| throws StandardException |
| { |
| if ( _matchingRefinement != null ) |
| { |
| useGeneratedScan( selectList, generatedScan, _matchingRefinement ); |
| } |
| } |
| |
| /** |
| * <p> |
| * Point the column references in the temporary row at the corresponding |
| * columns returned by the driving left join. |
| * </p> |
| */ |
| private void adjustThenColumns |
| ( |
| ResultColumnList selectList, |
| ResultSetNode generatedScan, |
| HalfOuterJoinNode hojn |
| ) |
| throws StandardException |
| { |
| ResultColumnList leftJoinResult = generatedScan.getResultColumns(); |
| |
| useGeneratedScan( selectList, generatedScan, _thenColumns ); |
| |
| // |
| // For an UPDATE action, the final column in the temporary row is the |
| // RowLocation. Point it at the last column in the row returned by the left join. |
| // |
| int lastRCSlot = _thenColumns.size() - 1; |
| ResultColumn lastRC = _thenColumns.elementAt( lastRCSlot ); |
| |
| if ( isRowLocation( lastRC ) ) |
| { |
| ResultColumn lastLeftJoinRC = leftJoinResult.elementAt( leftJoinResult.size() - 1 ); |
| ValueNode value = lastLeftJoinRC.getExpression(); |
| String columnName = lastLeftJoinRC.getName(); |
| ColumnReference rowLocationCR = new ColumnReference |
| ( columnName, hojn.getTableName(), getContextManager() ); |
| |
| rowLocationCR.setSource( lastLeftJoinRC ); |
| |
| ResultColumn rowLocationRC = new ResultColumn( columnName, rowLocationCR, getContextManager() ); |
| |
| _thenColumns.removeElementAt( lastRCSlot ); |
| _thenColumns.addResultColumn( rowLocationRC ); |
| } |
| } |
| |
| /** |
| * <p> |
| * Point a node's ColumnReferences into the row returned by the driving left join. |
| * </p> |
| */ |
| private void useGeneratedScan |
| ( |
| ResultColumnList selectList, |
| ResultSetNode generatedScan, |
| QueryTreeNode node |
| ) |
| throws StandardException |
| { |
| ResultColumnList leftJoinResult = generatedScan.getResultColumns(); |
| |
| for ( ColumnReference cr : getColumnReferences( node ) ) |
| { |
| ResultColumn leftJoinRC = leftJoinResult.elementAt( getSelectListOffset( selectList, cr ) - 1 ); |
| cr.setSource( leftJoinRC ); |
| } |
| } |
| |
| /** |
| * <p> |
| * Find a column reference in the SELECT list of the driving left join |
| * and return its 1-based offset into that list. Returns -1 if the column |
| * can't be found. |
| * </p> |
| */ |
| private int getSelectListOffset( ResultColumnList selectList, ValueNode thenExpression ) |
| throws StandardException |
| { |
| int selectCount = selectList.size(); |
| |
| if ( thenExpression instanceof ColumnReference ) |
| { |
| ColumnReference thenCR = (ColumnReference) thenExpression; |
| String thenCRName = thenCR.getColumnName(); |
| int thenCRMergeTableID = getMergeTableID( thenCR ); |
| |
| // loop through the SELECT list to find this column reference |
| for ( int sidx = 0; sidx < selectCount; sidx++ ) |
| { |
| ResultColumn selectRC = selectList.elementAt( sidx ); |
| ValueNode selectExpression = selectRC.getExpression(); |
| ColumnReference selectCR = selectExpression instanceof ColumnReference ? |
| (ColumnReference) selectExpression : null; |
| |
| if ( selectCR != null ) |
| { |
| if ( |
| ( getMergeTableID( selectCR ) == thenCRMergeTableID) && |
| thenCRName.equals( selectCR.getColumnName() ) |
| ) |
| { |
| return sidx + 1; |
| } |
| } |
| } |
| |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.THROWASSERT |
| ( |
| "Can't find select list column corresponding to " + thenCR.getSQLColumnName() + |
| " with merge table id = " + thenCRMergeTableID |
| ); |
| } |
| } |
| else if ( thenExpression instanceof CurrentRowLocationNode ) |
| { |
| // |
| // There is only one RowLocation in the SELECT list, the row location for the |
| // tuple from the target table. The RowLocation is always the last column in |
| // the SELECT list. |
| // |
| return selectCount; |
| } |
| |
| return -1; |
| } |
| |
| /** Find the MERGE table id of the indicated column */ |
| private int getMergeTableID( ColumnReference cr ) |
| { |
| int mergeTableID = cr.getMergeTableID(); |
| |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.ASSERT |
| ( |
| ( (mergeTableID == ColumnReference.MERGE_SOURCE) || (mergeTableID == ColumnReference.MERGE_TARGET) ), |
| "Column " + cr.getSQLColumnName() + " has illegal MERGE table id: " + mergeTableID |
| ); |
| } |
| |
| return mergeTableID; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // Visitable BEHAVIOR |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Accept the visitor for all visitable children of this node. |
| * |
| * @param v the visitor |
| * |
| * @exception StandardException on error |
| */ |
| @Override |
| void acceptChildren(Visitor v) |
| throws StandardException |
| { |
| super.acceptChildren( v ); |
| |
| if ( _matchingRefinement != null ) { _matchingRefinement.accept( v ); } |
| if ( _updateColumns != null ) { _updateColumns.accept( v ); } |
| if ( _insertColumns != null ) { _insertColumns.accept( v ); } |
| if ( _insertValues != null ) { _insertValues.accept( v ); } |
| |
| if ( _dml != null ) { _dml.accept( v ); } |
| } |
| |
| /** |
| * Prints the sub-nodes of this object. See QueryTreeNode.java for |
| * how tree printing is supposed to work. |
| * |
| * @param depth The depth of this node in the tree |
| */ |
| @Override |
| void printSubNodes( int depth ) |
| { |
| if (SanityManager.DEBUG) |
| { |
| super.printSubNodes( depth ); |
| |
| if ( _matchingRefinement != null ) |
| { |
| printLabel( depth, "matchingRefinement: " ); |
| _matchingRefinement.treePrint( depth + 1 ); |
| } |
| |
| if ( _updateColumns != null ) |
| { |
| printLabel( depth, "updateColumns: " ); |
| _updateColumns.treePrint( depth + 1 ); |
| } |
| |
| if ( _insertColumns != null ) |
| { |
| printLabel( depth, "insertColumns: " ); |
| _insertColumns.treePrint( depth + 1 ); |
| } |
| |
| if ( _insertValues != null ) |
| { |
| printLabel( depth, "insertValues: " ); |
| _insertValues.treePrint( depth + 1 ); |
| } |
| } |
| } |
| |
| /** |
| * Convert this object to a String. See comments in QueryTreeNode.java |
| * for how this should be done for tree printing. |
| * |
| * @return This object as a String |
| */ |
| @Override |
| public String toString() |
| { |
| if ( isUpdateClause() ) { return "UPDATE"; } |
| else if ( isInsertClause() ) { return "INSERT"; } |
| else { return "DELETE"; } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////// |
| // |
| // MINIONS |
| // |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| /** Get a list of column references in an expression */ |
| private List<ColumnReference> getColumnReferences( QueryTreeNode expression ) |
| throws StandardException |
| { |
| CollectNodesVisitor<ColumnReference> getCRs = |
| new CollectNodesVisitor<ColumnReference>(ColumnReference.class); |
| |
| expression.accept(getCRs); |
| |
| return getCRs.getList(); |
| } |
| |
| /** Return true if the ResultColumn represents a RowLocation */ |
| private boolean isRowLocation( ResultColumn rc ) throws StandardException |
| { |
| if ( rc.getExpression() instanceof CurrentRowLocationNode ) { return true; } |
| |
| DataTypeDescriptor dtd = rc.getTypeServices(); |
| if ( (dtd != null) && (dtd.getTypeId().isRefTypeId()) ) { return true; } |
| |
| return false; |
| } |
| |
| @Override |
| public boolean referencesSessionSchema() throws StandardException { |
| return referencesSessionSchema(_matchingRefinement) |
| || referencesSessionSchema(_updateColumns) |
| || referencesSessionSchema(_insertColumns) |
| || referencesSessionSchema(_insertValues); |
| } |
| |
| private static boolean referencesSessionSchema(QueryTreeNode node) |
| throws StandardException { |
| return node != null && node.referencesSessionSchema(); |
| } |
| } |
