docs: protected void validateValues(
  		SqlCall node,
  		RelDataType targetRowType,
  		final SqlValidatorScope scope) {
  		assert node.getKind() == SqlKind.VALUES;
  
  		final List<SqlNode> operands = node.getOperandList();
  		for (SqlNode operand : operands) {
  			if (!(operand.getKind() == SqlKind.ROW)) {
  				throw Util.needToImplement(
  					"Values function where operands are scalars");
  			}
  
  			SqlCall rowConstructor = (SqlCall) operand;
  			if (conformance.isInsertSubsetColumnsAllowed() && targetRowType.isStruct()
  				&& rowConstructor.operandCount() < targetRowType.getFieldCount()) {
  				targetRowType =
  					typeFactory.createStructType(
  						targetRowType.getFieldList()
  							.subList(0, rowConstructor.operandCount()));
  			} else if (targetRowType.isStruct()
  				&& rowConstructor.operandCount() != targetRowType.getFieldCount()) {
  				return;
  			}
  
  			inferUnknownTypes(
  				targetRowType,
  				scope,
  				rowConstructor);
  
  			if (targetRowType.isStruct()) {
  				for (Pair<SqlNode, RelDataTypeField> pair
  					: Pair.zip(rowConstructor.getOperandList(),
  					targetRowType.getFieldList())) {
  					if (!pair.right.getType().isNullable()
  						&& SqlUtil.isNullLiteral(pair.left, false)) {
  						throw newValidationError(node,
  							RESOURCE.columnNotNullable(pair.right.getName()));
  					}
  				}
  			}
  		}
  
  		for (SqlNode operand : operands) {
  			operand.validate(this, scope);
  		}
  
  		// validate that all row types have the same number of columns
  		//  and that expressions in each column are compatible.
  		// A values expression is turned into something that looks like
  		// ROW(type00, type01,...), ROW(type11,...),...
  		final int rowCount = operands.size();
  		if (rowCount >= 2) {
  			SqlCall firstRow = (SqlCall) operands.get(0);
  			final int columnCount = firstRow.operandCount();
  
  			// 1. check that all rows have the same cols length
  			for (SqlNode operand : operands) {
  				SqlCall thisRow = (SqlCall) operand;
  				if (columnCount != thisRow.operandCount()) {
  					throw newValidationError(node,
  						RESOURCE.incompatibleValueType(
  							SqlStdOperatorTable.VALUES.getName()));
  				}
  			}
  
  			// 2. check if types at i:th position in each row are compatible
  			for (int col = 0; col < columnCount; col++) {
  				final int c = col;
  				final RelDataType type =
  					typeFactory.leastRestrictive(
  						new AbstractList<RelDataType>() {
  							public RelDataType get(int row) {
  								SqlCall thisRow = (SqlCall) operands.get(row);
  								return deriveType(scope, thisRow.operand(c));
  							}
  
  							public int size() {
  								return rowCount;
  							}
  						});
  
  				if (null == type) {
  					throw newValidationError(node,
  						RESOURCE.incompatibleValueType(
  							SqlStdOperatorTable.VALUES.getName()));
  				}
  			}
  		}
  	}