/* 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.error.Error;
import org.hsqldb.error.ErrorCode;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.HsqlArrayList;
import org.hsqldb.lib.HsqlList;
import org.hsqldb.lib.LongDeque;
import org.hsqldb.lib.OrderedHashSet;
import org.hsqldb.types.Type;
/**
* Parser for DML statements
*
* @author Fred Toussi (fredt@users dot sourceforge.net)
* @version 1.9.0
* @since 1.9.0
*/
public class ParserDML extends ParserDQL {
ParserDML(Session session, Scanner t) {
super(session, t);
}
/**
* Retrieves an INSERT Statement from this parse context.
*/
StatementDMQL compileInsertStatement(RangeVariable[] outerRanges) {
read();
readThis(Tokens.INTO);
boolean[] columnCheckList;
int[] columnMap;
int colCount;
Table table = readTableName();
boolean overridingUser = false;
boolean overridingSystem = false;
boolean assignsToIdentity = false;
columnCheckList = null;
columnMap = table.getColumnMap();
colCount = table.getColumnCount();
int position = getPosition();
if (!table.isInsertable() && !table.isTriggerInsertable()
&& !session.isProcessingScript) {
throw Error.error(ErrorCode.X_42545);
}
Table baseTable = table.isTriggerInsertable() ? table
: table.getBaseTable();
switch (token.tokenType) {
case Tokens.DEFAULT : {
read();
readThis(Tokens.VALUES);
Expression insertExpression = new Expression(OpTypes.ROW,
new Expression[]{});
insertExpression = new Expression(OpTypes.TABLE,
new Expression[]{
insertExpression });
columnCheckList = table.getNewColumnCheckList();
for (int i = 0; i < table.colDefaults.length; i++) {
if (table.colDefaults[i] == null
&& table.identityColumn != i) {
if (!table.getColumn(i).isGenerated()) {
throw Error.error(ErrorCode.X_42544);
}
}
}
StatementDMQL cs = new StatementInsert(session, table,
columnMap,
insertExpression,
columnCheckList,
compileContext);
return cs;
}
case Tokens.OPENBRACKET : {
int brackets = readOpenBrackets();
if (brackets == 1) {
boolean isQuery = false;
switch (token.tokenType) {
case Tokens.WITH :
case Tokens.SELECT :
case Tokens.TABLE : {
rewind(position);
isQuery = true;
break;
}
default :
}
if (isQuery) {
break;
}
OrderedHashSet columnNames = new OrderedHashSet();
readSimpleColumnNames(columnNames, table);
readThis(Tokens.CLOSEBRACKET);
colCount = columnNames.size();
columnMap = table.getColumnIndexes(columnNames);
if (token.tokenType != Tokens.VALUES
&& token.tokenType != Tokens.OVERRIDING) {
break;
}
// fall through
} else {
rewind(position);
break;
}
}
// fall through
case Tokens.OVERRIDING : {
if (token.tokenType == Tokens.OVERRIDING) {
read();
if (token.tokenType == Tokens.USER) {
read();
overridingUser = true;
} else if (token.tokenType == Tokens.SYSTEM) {
read();
overridingSystem = true;
} else {
unexpectedToken();
}
readThis(Tokens.VALUE);
if (token.tokenType != Tokens.VALUES) {
break;
}
}
}
// fall through
case Tokens.VALUES : {
read();
columnCheckList = table.getColumnCheckList(columnMap);
Expression insertExpressions =
XreadContextuallyTypedTable(colCount);
HsqlList unresolved =
insertExpressions.resolveColumnReferences(outerRanges,
null);
ExpressionColumn.checkColumnsResolved(unresolved);
insertExpressions.resolveTypes(session, null);
setParameterTypes(insertExpressions, table, columnMap);
if (table != baseTable) {
int[] baseColumnMap = table.getBaseTableColumnMap();
int[] newColumnMap = new int[columnMap.length];
ArrayUtil.projectRow(baseColumnMap, columnMap,
newColumnMap);
columnMap = newColumnMap;
}
Expression[] rowList = insertExpressions.nodes;
for (int j = 0; j < rowList.length; j++) {
Expression[] rowArgs = rowList[j].nodes;
for (int i = 0; i < rowArgs.length; i++) {
Expression e = rowArgs[i];
ColumnSchema column =
baseTable.getColumn(columnMap[i]);
if (column.isIdentity()) {
assignsToIdentity = true;
if (e.getType() != OpTypes.DEFAULT) {
if (table.identitySequence.isAlways()) {
if (!overridingUser && !overridingSystem) {
throw Error.error(ErrorCode.X_42543);
}
}
if (overridingUser) {
rowArgs[i] =
new ExpressionColumn(OpTypes.DEFAULT);
}
}
} else if (column.hasDefault()) {}
else if (column.isGenerated()) {
if (e.getType() != OpTypes.DEFAULT) {
throw Error.error(ErrorCode.X_42541);
}
} else {
if (e.getType() == OpTypes.DEFAULT) {
throw Error.error(ErrorCode.X_42544);
}
}
if (e.isUnresolvedParam()) {
e.setAttributesAsColumn(column, true);
}
}
}
if (!assignsToIdentity
&& (overridingUser || overridingSystem)) {
unexpectedTokenRequire(Tokens.T_OVERRIDING);
}
StatementDMQL cs = new StatementInsert(session, table,
columnMap,
insertExpressions,
columnCheckList,
compileContext);
return cs;
}
case Tokens.WITH :
case Tokens.SELECT :
case Tokens.TABLE : {
break;
}
default : {
throw unexpectedToken();
}
}
columnCheckList = table.getColumnCheckList(columnMap);
if (baseTable != null && table != baseTable) {
int[] baseColumnMap = table.getBaseTableColumnMap();
int[] newColumnMap = new int[columnMap.length];
ArrayUtil.projectRow(baseColumnMap, columnMap, newColumnMap);
columnMap = newColumnMap;
}
int enforcedDefaultIndex = table.getIdentityColumnIndex();
int overrideIndex = -1;
if (enforcedDefaultIndex != -1
&& ArrayUtil.find(columnMap, enforcedDefaultIndex) > -1) {
if (table.identitySequence.isAlways()) {
if (!overridingUser && !overridingSystem) {
throw Error.error(ErrorCode.X_42543);
}
}
if (overridingUser) {
overrideIndex = enforcedDefaultIndex;
}
} else if (overridingUser || overridingSystem) {
unexpectedTokenRequire(Tokens.T_OVERRIDING);
}
Type[] types = new Type[columnMap.length];
ArrayUtil.projectRow(baseTable.getColumnTypes(), columnMap, types);
QueryExpression queryExpression = XreadQueryExpression();
queryExpression.setReturningResult();
queryExpression.resolve(session, outerRanges, types);
if (colCount != queryExpression.getColumnCount()) {
throw Error.error(ErrorCode.X_42546);
}
StatementDMQL cs = new StatementInsert(session, table, columnMap,
columnCheckList,
queryExpression,
compileContext, overrideIndex);
return cs;
}
private static void setParameterTypes(Expression tableExpression,
Table table, int[] columnMap) {
for (int i = 0; i < tableExpression.nodes.length; i++) {
Expression[] list = tableExpression.nodes[i].nodes;
for (int j = 0; j < list.length; j++) {
if (list[j].isUnresolvedParam()) {
list[j].setAttributesAsColumn(
table.getColumn(columnMap[j]), true);
}
}
}
}
/**
* Creates a DELETE-type Statement from this parse context.
*/
StatementDMQL compileDeleteStatement(RangeVariable[] outerRanges) {
Expression condition = null;
boolean truncate = false;
boolean restartIdentity = false;
int statementType;
switch (token.tokenType) {
case Tokens.TRUNCATE : {
read();
readThis(Tokens.TABLE);
truncate = true;
statementType = StatementTypes.TRUNCATE;
break;
}
case Tokens.DELETE : {
read();
readThis(Tokens.FROM);
statementType = StatementTypes.DELETE_WHERE;
break;
}
default :
throw unexpectedToken();
}
RangeVariable[] rangeVariables = {
readSimpleRangeVariable(statementType) };
Table table = rangeVariables[0].getTable();
Table baseTable = table.getBaseTable();
if (truncate) {
if (table != baseTable) {
throw Error.error(ErrorCode.X_42545);
}
if (table.isTriggerDeletable()) {
// redundant
throw Error.error(ErrorCode.X_42545);
}
switch (token.tokenType) {
case Tokens.CONTINUE : {
read();
readThis(Tokens.IDENTITY);
break;
}
case Tokens.RESTART : {
read();
readThis(Tokens.IDENTITY);
restartIdentity = true;
break;
}
}
if (table.fkMainConstraints.length > 0) {
throw Error.error(ErrorCode.X_23504);
}
}
if (!truncate && token.tokenType == Tokens.WHERE) {
read();
condition = XreadBooleanValueExpression();
HsqlList unresolved =
condition.resolveColumnReferences(outerRanges, null);
unresolved = Expression.resolveColumnSet(rangeVariables,
rangeVariables.length, unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
condition.resolveTypes(session, null);
if (condition.isUnresolvedParam()) {
condition.dataType = Type.SQL_BOOLEAN;
}
if (condition.getDataType() != Type.SQL_BOOLEAN) {
throw Error.error(ErrorCode.X_42568);
}
}
if (baseTable == null) {
//
} else if (table != baseTable) {
QuerySpecification baseSelect =
((TableDerived) table).getQueryExpression().getMainSelect();
RangeVariable[] newRangeVariables =
(RangeVariable[]) ArrayUtil.duplicateArray(
baseSelect.rangeVariables);
newRangeVariables[0] = baseSelect.rangeVariables[0].duplicate();
Expression[] newBaseExprColumns =
new Expression[baseSelect.indexLimitData];
for (int i = 0; i < baseSelect.indexLimitData; i++) {
Expression e = baseSelect.exprColumns[i].duplicate();
newBaseExprColumns[i] = e;
e.replaceRangeVariables(baseSelect.rangeVariables,
newRangeVariables);
}
Expression baseQueryCondition = baseSelect.queryCondition;
if (baseQueryCondition != null) {
baseQueryCondition = baseQueryCondition.duplicate();
baseQueryCondition.replaceRangeVariables(rangeVariables,
newRangeVariables);
}
if (condition != null) {
condition =
condition.replaceColumnReferences(rangeVariables[0],
newBaseExprColumns);
}
rangeVariables = newRangeVariables;
condition = ExpressionLogical.andExpressions(baseQueryCondition,
condition);
}
if (condition != null) {
rangeVariables[0].addJoinCondition(condition);
RangeVariableResolver resolver =
new RangeVariableResolver(rangeVariables, null,
compileContext);
resolver.processConditions(session);
rangeVariables = resolver.rangeVariables;
}
StatementDMQL cs = new StatementDML(session, table, rangeVariables,
compileContext, restartIdentity,
statementType);
return cs;
}
/**
* Creates an UPDATE-type Statement from this parse context.
*/
StatementDMQL compileUpdateStatement(RangeVariable[] outerRanges) {
read();
Expression[] updateExpressions;
int[] columnMap;
boolean[] columnCheckList;
OrderedHashSet targetSet = new OrderedHashSet();
LongDeque colIndexList = new LongDeque();
HsqlArrayList exprList = new HsqlArrayList();
RangeVariable[] rangeVariables = {
readSimpleRangeVariable(StatementTypes.UPDATE_WHERE) };
Table table = rangeVariables[0].rangeTable;
Table baseTable = table.getBaseTable();
readThis(Tokens.SET);
readSetClauseList(rangeVariables, targetSet, colIndexList, exprList);
columnMap = new int[colIndexList.size()];
colIndexList.toArray(columnMap);
Expression[] targets = new Expression[targetSet.size()];
targetSet.toArray(targets);
for (int i = 0; i < targets.length; i++) {
this.resolveOuterReferencesAndTypes(outerRanges, targets[i]);
}
columnCheckList = table.getColumnCheckList(columnMap);
updateExpressions = new Expression[exprList.size()];
exprList.toArray(updateExpressions);
Expression condition = null;
if (token.tokenType == Tokens.WHERE) {
read();
condition = XreadBooleanValueExpression();
HsqlList unresolved =
condition.resolveColumnReferences(outerRanges, null);
unresolved = Expression.resolveColumnSet(rangeVariables,
rangeVariables.length, unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
condition.resolveTypes(session, null);
if (condition.isUnresolvedParam()) {
condition.dataType = Type.SQL_BOOLEAN;
}
if (condition.getDataType() != Type.SQL_BOOLEAN) {
throw Error.error(ErrorCode.X_42568);
}
}
resolveUpdateExpressions(table, rangeVariables, columnMap,
updateExpressions, outerRanges);
if (table != baseTable) {
QuerySpecification baseSelect =
((TableDerived) table).getQueryExpression().getMainSelect();
RangeVariable[] newRangeVariables =
(RangeVariable[]) ArrayUtil.duplicateArray(
baseSelect.rangeVariables);
newRangeVariables[0] = baseSelect.rangeVariables[0].duplicate();
Expression[] newBaseExprColumns =
new Expression[baseSelect.indexLimitData];
for (int i = 0; i < baseSelect.indexLimitData; i++) {
Expression e = baseSelect.exprColumns[i].duplicate();
newBaseExprColumns[i] = e;
e.replaceRangeVariables(baseSelect.rangeVariables,
newRangeVariables);
}
Expression baseQueryCondition = baseSelect.queryCondition;
if (baseQueryCondition != null) {
baseQueryCondition = baseQueryCondition.duplicate();
baseQueryCondition.replaceRangeVariables(rangeVariables,
newRangeVariables);
}
if (condition != null) {
condition =
condition.replaceColumnReferences(rangeVariables[0],
newBaseExprColumns);
}
for (int i = 0; i < updateExpressions.length; i++) {
updateExpressions[i] =
updateExpressions[i].replaceColumnReferences(
rangeVariables[0], newBaseExprColumns);
}
rangeVariables = newRangeVariables;
condition = ExpressionLogical.andExpressions(baseQueryCondition,
condition);
}
if (condition != null) {
rangeVariables[0].addJoinCondition(condition);
RangeVariableResolver resolver =
new RangeVariableResolver(rangeVariables, null,
compileContext);
resolver.processConditions(session);
rangeVariables = resolver.rangeVariables;
}
if (baseTable != null && table != baseTable) {
int[] baseColumnMap = table.getBaseTableColumnMap();
int[] newColumnMap = new int[columnMap.length];
ArrayUtil.projectRow(baseColumnMap, columnMap, newColumnMap);
columnMap = newColumnMap;
for (int i = 0; i < columnMap.length; i++) {
if (baseTable.colGenerated[columnMap[i]]) {
throw Error.error(ErrorCode.X_42513);
}
}
}
StatementDMQL cs = new StatementDML(session, targets, table,
rangeVariables, columnMap,
updateExpressions,
columnCheckList, compileContext);
return cs;
}
void resolveUpdateExpressions(Table targetTable,
RangeVariable[] rangeVariables,
int[] columnMap,
Expression[] colExpressions,
RangeVariable[] outerRanges) {
HsqlList unresolved = null;
int enforcedDefaultIndex = -1;
if (targetTable.hasIdentityColumn()
&& targetTable.identitySequence.isAlways()) {
enforcedDefaultIndex = targetTable.getIdentityColumnIndex();
}
for (int i = 0, ix = 0; i < columnMap.length; ix++) {
Expression expr = colExpressions[ix];
Expression e;
// no generated column can be updated
if (targetTable.colGenerated[columnMap[i]]) {
throw Error.error(ErrorCode.X_42513);
}
if (expr.getType() == OpTypes.ROW) {
Expression[] elements = expr.nodes;
for (int j = 0; j < elements.length; j++, i++) {
e = elements[j];
if (enforcedDefaultIndex == columnMap[i]) {
if (e.getType() != OpTypes.DEFAULT) {
throw Error.error(ErrorCode.X_42541);
}
}
if (e.isUnresolvedParam()) {
e.setAttributesAsColumn(
targetTable.getColumn(columnMap[i]), true);
} else if (e.getType() == OpTypes.DEFAULT) {
if (targetTable.colDefaults[columnMap[i]] == null
&& targetTable.identityColumn
!= columnMap[i]) {
throw Error.error(ErrorCode.X_42544);
}
} else {
unresolved = expr.resolveColumnReferences(outerRanges,
null);
unresolved =
Expression.resolveColumnSet(rangeVariables,
rangeVariables.length,
unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
unresolved = null;
e.resolveTypes(session, null);
}
}
} else if (expr.getType() == OpTypes.ROW_SUBQUERY) {
unresolved = expr.resolveColumnReferences(outerRanges, null);
unresolved = Expression.resolveColumnSet(rangeVariables,
rangeVariables.length, unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
expr.resolveTypes(session, null);
int count = expr.subQuery.queryExpression.getColumnCount();
for (int j = 0; j < count; j++, i++) {
if (enforcedDefaultIndex == columnMap[i]) {
throw Error.error(ErrorCode.X_42541);
}
}
} else {
e = expr;
if (enforcedDefaultIndex == columnMap[i]) {
if (e.getType() != OpTypes.DEFAULT) {
throw Error.error(ErrorCode.X_42541);
}
}
if (e.isUnresolvedParam()) {
e.setAttributesAsColumn(
targetTable.getColumn(columnMap[i]), true);
} else if (e.getType() == OpTypes.DEFAULT) {
if (targetTable.colDefaults[columnMap[i]] == null
&& targetTable.identityColumn != columnMap[i]) {
throw Error.error(ErrorCode.X_42544);
}
} else {
unresolved = expr.resolveColumnReferences(outerRanges,
null);
unresolved = Expression.resolveColumnSet(rangeVariables,
rangeVariables.length, unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
e.resolveTypes(session, null);
}
i++;
}
}
}
void readSetClauseList(RangeVariable[] rangeVars, OrderedHashSet targets,
LongDeque colIndexList, HsqlArrayList expressions) {
while (true) {
int degree;
if (token.tokenType == Tokens.OPENBRACKET) {
read();
int oldCount = targets.size();
readTargetSpecificationList(targets, rangeVars, colIndexList);
degree = targets.size() - oldCount;
readThis(Tokens.CLOSEBRACKET);
} else {
Expression target = XreadTargetSpecification(rangeVars,
colIndexList);
if (!targets.add(target)) {
ColumnSchema col = target.getColumn();
throw Error.error(ErrorCode.X_42579, col.getName().name);
}
degree = 1;
}
readThis(Tokens.EQUALS);
int position = getPosition();
int brackets = readOpenBrackets();
if (token.tokenType == Tokens.SELECT) {
rewind(position);
SubQuery sq = XreadSubqueryBody(false, OpTypes.ROW_SUBQUERY);
if (degree != sq.queryExpression.getColumnCount()) {
throw Error.error(ErrorCode.X_42546);
}
Expression e = new Expression(OpTypes.ROW_SUBQUERY, sq);
expressions.add(e);
if (token.tokenType == Tokens.COMMA) {
read();
continue;
}
break;
}
if (brackets > 0) {
rewind(position);
}
if (degree > 1) {
readThis(Tokens.OPENBRACKET);
Expression e = readRow();
readThis(Tokens.CLOSEBRACKET);
int rowDegree = e.getType() == OpTypes.ROW ? e.nodes.length
: 1;
if (degree != rowDegree) {
throw Error.error(ErrorCode.X_42546);
}
expressions.add(e);
} else {
Expression e = XreadValueExpressionWithContext();
expressions.add(e);
}
if (token.tokenType == Tokens.COMMA) {
read();
continue;
}
break;
}
}
/**
* Retrieves a MERGE Statement from this parse context.
*/
StatementDMQL compileMergeStatement(RangeVariable[] outerRanges) {
boolean[] insertColumnCheckList;
int[] insertColumnMap = null;
int[] updateColumnMap = null;
int[] baseUpdateColumnMap;
Table table;
RangeVariable targetRange;
RangeVariable sourceRange;
Expression mergeCondition;
Expression[] targets = null;
HsqlArrayList updateList = new HsqlArrayList();
Expression[] updateExpressions = Expression.emptyArray;
HsqlArrayList insertList = new HsqlArrayList();
Expression insertExpression = null;
read();
readThis(Tokens.INTO);
targetRange = readSimpleRangeVariable(StatementTypes.MERGE);
table = targetRange.rangeTable;
readThis(Tokens.USING);
sourceRange = readTableOrSubquery();
// parse ON search conditions
readThis(Tokens.ON);
mergeCondition = XreadBooleanValueExpression();
if (mergeCondition.getDataType() != Type.SQL_BOOLEAN) {
throw Error.error(ErrorCode.X_42568);
}
RangeVariable[] fullRangeVars = new RangeVariable[] {
sourceRange, targetRange
};
RangeVariable[] sourceRangeVars = new RangeVariable[]{ sourceRange };
RangeVariable[] targetRangeVars = new RangeVariable[]{ targetRange };
// parse WHEN clause(s) and convert lists to arrays
insertColumnMap = table.getColumnMap();
insertColumnCheckList = table.getNewColumnCheckList();
OrderedHashSet updateTargetSet = new OrderedHashSet();
OrderedHashSet insertColNames = new OrderedHashSet();
LongDeque updateColIndexList = new LongDeque();
readMergeWhen(updateColIndexList, insertColNames, updateTargetSet,
insertList, updateList, targetRangeVars, sourceRange);
if (insertList.size() > 0) {
int colCount = insertColNames.size();
if (colCount != 0) {
insertColumnMap = table.getColumnIndexes(insertColNames);
insertColumnCheckList =
table.getColumnCheckList(insertColumnMap);
}
insertExpression = (Expression) insertList.get(0);
setParameterTypes(insertExpression, table, insertColumnMap);
}
if (updateList.size() > 0) {
targets = new Expression[updateTargetSet.size()];
updateTargetSet.toArray(targets);
for (int i = 0; i < targets.length; i++) {
this.resolveOuterReferencesAndTypes(outerRanges, targets[i]);
}
updateExpressions = new Expression[updateList.size()];
updateList.toArray(updateExpressions);
updateColumnMap = new int[updateColIndexList.size()];
updateColIndexList.toArray(updateColumnMap);
}
if (updateExpressions.length != 0) {
Table baseTable = table.getBaseTable();
baseUpdateColumnMap = updateColumnMap;
if (table != baseTable) {
baseUpdateColumnMap = new int[updateColumnMap.length];
ArrayUtil.projectRow(table.getBaseTableColumnMap(),
updateColumnMap, baseUpdateColumnMap);
}
resolveUpdateExpressions(table, sourceRangeVars, updateColumnMap,
updateExpressions, outerRanges);
}
HsqlList unresolved = null;
unresolved = mergeCondition.resolveColumnReferences(fullRangeVars,
null);
ExpressionColumn.checkColumnsResolved(unresolved);
mergeCondition.resolveTypes(session, null);
if (mergeCondition.isUnresolvedParam()) {
mergeCondition.dataType = Type.SQL_BOOLEAN;
}
if (mergeCondition.getDataType() != Type.SQL_BOOLEAN) {
throw Error.error(ErrorCode.X_42568);
}
RangeVariableResolver resolver =
new RangeVariableResolver(fullRangeVars, mergeCondition,
compileContext);
resolver.processConditions(session);
fullRangeVars = resolver.rangeVariables;
if (insertExpression != null) {
unresolved =
insertExpression.resolveColumnReferences(sourceRangeVars,
unresolved);
ExpressionColumn.checkColumnsResolved(unresolved);
insertExpression.resolveTypes(session, null);
}
StatementDMQL cs = new StatementDML(session, targets, fullRangeVars,
insertColumnMap, updateColumnMap,
insertColumnCheckList,
mergeCondition, insertExpression,
updateExpressions, compileContext);
return cs;
}
/**
* Parses a WHEN clause from a MERGE statement. This can be either a
* WHEN MATCHED or WHEN NOT MATCHED clause, or both, and the appropriate
* values will be updated.
*
* If the var that is to hold the data is not null, then we already
* encountered this type of clause, which is only allowed once, and at least
* one is required.
*/
private void readMergeWhen(LongDeque updateColIndexList,
OrderedHashSet insertColumnNames,
OrderedHashSet updateTargetSet,
HsqlArrayList insertExpressions,
HsqlArrayList updateExpressions,
RangeVariable[] targetRangeVars,
RangeVariable sourceRangeVar) {
Table table = targetRangeVars[0].rangeTable;
int columnCount = table.getColumnCount();
readThis(Tokens.WHEN);
if (token.tokenType == Tokens.MATCHED) {
if (updateExpressions.size() != 0) {
throw Error.error(ErrorCode.X_42547);
}
read();
readThis(Tokens.THEN);
readThis(Tokens.UPDATE);
readThis(Tokens.SET);
readSetClauseList(targetRangeVars, updateTargetSet,
updateColIndexList, updateExpressions);
} else if (token.tokenType == Tokens.NOT) {
if (insertExpressions.size() != 0) {
throw Error.error(ErrorCode.X_42548);
}
read();
readThis(Tokens.MATCHED);
readThis(Tokens.THEN);
readThis(Tokens.INSERT);
// parse INSERT statement
// optional column list
int brackets = readOpenBrackets();
if (brackets == 1) {
readSimpleColumnNames(insertColumnNames, targetRangeVars[0]);
columnCount = insertColumnNames.size();
readThis(Tokens.CLOSEBRACKET);
brackets = 0;
}
readThis(Tokens.VALUES);
Expression e = XreadContextuallyTypedTable(columnCount);
if (e.nodes.length != 1) {
throw Error.error(ErrorCode.X_21000);
}
insertExpressions.add(e);
} else {
throw unexpectedToken();
}
if (token.tokenType == Tokens.WHEN) {
readMergeWhen(updateColIndexList, insertColumnNames,
updateTargetSet, insertExpressions,
updateExpressions, targetRangeVars, sourceRangeVar);
}
}
/**
* Retrieves a CALL Statement from this parse context.
*/
// to do call argument name and type resolution
StatementDMQL compileCallStatement(RangeVariable[] outerRanges,
boolean isStrictlyProcedure) {
read();
if (isIdentifier()) {
checkValidCatalogName(token.namePrePrefix);
RoutineSchema routineSchema =
(RoutineSchema) database.schemaManager.findSchemaObject(
token.tokenString,
session.getSchemaName(token.namePrefix),
SchemaObject.PROCEDURE);
if (routineSchema != null) {
read();
HsqlArrayList list = new HsqlArrayList();
readThis(Tokens.OPENBRACKET);
if (token.tokenType == Tokens.CLOSEBRACKET) {
read();
} else {
while (true) {
Expression e = XreadValueExpression();
list.add(e);
if (token.tokenType == Tokens.COMMA) {
read();
} else {
readThis(Tokens.CLOSEBRACKET);
break;
}
}
}
Expression[] arguments = new Expression[list.size()];
list.toArray(arguments);
Routine routine =
routineSchema.getSpecificRoutine(arguments.length);
compileContext.addProcedureCall(routine);
HsqlList unresolved = null;
for (int i = 0; i < arguments.length; i++) {
Expression e = arguments[i];
if (e.isUnresolvedParam()) {
e.setAttributesAsColumn(
routine.getParameter(i),
routine.getParameter(i).isWriteable());
} else {
int paramMode =
routine.getParameter(i).getParameterMode();
unresolved =
arguments[i].resolveColumnReferences(outerRanges,
unresolved);
if (paramMode
!= SchemaObject.ParameterModes.PARAM_IN) {
if (e.getType() != OpTypes.VARIABLE) {
throw Error.error(ErrorCode.X_42603);
}
}
}
}
ExpressionColumn.checkColumnsResolved(unresolved);
for (int i = 0; i < arguments.length; i++) {
arguments[i].resolveTypes(session, null);
if (!routine.getParameter(
i).getDataType().canBeAssignedFrom(
arguments[i].getDataType())) {
throw Error.error(ErrorCode.X_42561);
}
}
StatementDMQL cs = new StatementProcedure(session, routine,
arguments, compileContext);
return cs;
}
}
if (isStrictlyProcedure) {
throw Error.error(ErrorCode.X_42501, token.tokenString);
}
Expression expression = this.XreadValueExpression();
HsqlList unresolved = expression.resolveColumnReferences(outerRanges,
null);
ExpressionColumn.checkColumnsResolved(unresolved);
expression.resolveTypes(session, null);
// expression.paramMode = PARAM_OUT;
StatementDMQL cs = new StatementProcedure(session, expression,
compileContext);
return cs;
}
void resolveOuterReferencesAndTypes(RangeVariable[] rangeVars,
Expression e) {
HsqlList unresolved = e.resolveColumnReferences(rangeVars,
rangeVars.length, null, false);
unresolved = Expression.resolveColumnSet(rangeVars, rangeVars.length,
unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
e.resolveTypes(session, null);
}
}