Example usage for org.springframework.jdbc.core.metadata CallMetaDataProvider byPassReturnParameter

Introduction

In this page you can find the example usage for org.springframework.jdbc.core.metadata CallMetaDataProvider byPassReturnParameter.

Prototype

boolean byPassReturnParameter(String parameterName);

Source Link

Document

Should we bypass the return parameter with the specified name.

Usage

From source file:org.springframework.jdbc.core.metadata.CallMetaDataContext.java

/**
 * Reconcile the provided parameters with available metadata and add new ones where appropriate.
 *//*from  ww  w .j  av a  2  s. c o m*/
protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters) {
    CallMetaDataProvider provider = obtainMetaDataProvider();

    final List<SqlParameter> declaredReturnParams = new ArrayList<>();
    final Map<String, SqlParameter> declaredParams = new LinkedHashMap<>();
    boolean returnDeclared = false;
    List<String> outParamNames = new ArrayList<>();
    List<String> metaDataParamNames = new ArrayList<>();

    // Get the names of the meta data parameters
    for (CallParameterMetaData meta : provider.getCallParameterMetaData()) {
        if (meta.getParameterType() != DatabaseMetaData.procedureColumnReturn) {
            metaDataParamNames.add(lowerCase(meta.getParameterName()));
        }
    }

    // Separate implicit return parameters from explicit parameters...
    for (SqlParameter param : parameters) {
        if (param.isResultsParameter()) {
            declaredReturnParams.add(param);
        } else {
            String paramName = param.getName();
            if (paramName == null) {
                throw new IllegalArgumentException("Anonymous parameters not supported for calls - "
                        + "please specify a name for the parameter of SQL type " + param.getSqlType());
            }
            String paramNameToMatch = lowerCase(provider.parameterNameToUse(paramName));
            declaredParams.put(paramNameToMatch, param);
            if (param instanceof SqlOutParameter) {
                outParamNames.add(paramName);
                if (isFunction() && !metaDataParamNames.contains(paramNameToMatch)) {
                    if (!returnDeclared) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Using declared out parameter '" + paramName
                                    + "' for function return value");
                        }
                        setFunctionReturnName(paramName);
                        returnDeclared = true;
                    }
                }
            }
        }
    }
    setOutParameterNames(outParamNames);

    List<SqlParameter> workParams = new ArrayList<>();
    workParams.addAll(declaredReturnParams);

    if (!provider.isProcedureColumnMetaDataUsed()) {
        workParams.addAll(declaredParams.values());
        return workParams;
    }

    Map<String, String> limitedInParamNamesMap = new HashMap<>(this.limitedInParameterNames.size());
    for (String limitedParamName : this.limitedInParameterNames) {
        limitedInParamNamesMap.put(lowerCase(provider.parameterNameToUse(limitedParamName)), limitedParamName);
    }

    for (CallParameterMetaData meta : provider.getCallParameterMetaData()) {
        String paramName = meta.getParameterName();
        String paramNameToCheck = null;
        if (paramName != null) {
            paramNameToCheck = lowerCase(provider.parameterNameToUse(paramName));
        }
        String paramNameToUse = provider.parameterNameToUse(paramName);
        if (declaredParams.containsKey(paramNameToCheck)
                || (meta.getParameterType() == DatabaseMetaData.procedureColumnReturn && returnDeclared)) {
            SqlParameter param;
            if (meta.getParameterType() == DatabaseMetaData.procedureColumnReturn) {
                param = declaredParams.get(getFunctionReturnName());
                if (param == null && !getOutParameterNames().isEmpty()) {
                    param = declaredParams.get(getOutParameterNames().get(0).toLowerCase());
                }
                if (param == null) {
                    throw new InvalidDataAccessApiUsageException(
                            "Unable to locate declared parameter for function return value - "
                                    + " add a SqlOutParameter with name '" + getFunctionReturnName() + "'");
                } else if (paramName != null) {
                    setFunctionReturnName(paramName);
                }
            } else {
                param = declaredParams.get(paramNameToCheck);
            }
            if (param != null) {
                workParams.add(param);
                if (logger.isDebugEnabled()) {
                    logger.debug("Using declared parameter for '"
                            + (paramNameToUse != null ? paramNameToUse : getFunctionReturnName()) + "'");
                }
            }
        } else {
            if (meta.getParameterType() == DatabaseMetaData.procedureColumnReturn) {
                if (!isFunction() && !isReturnValueRequired() && paramName != null
                        && provider.byPassReturnParameter(paramName)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Bypassing metadata return parameter for '" + paramName + "'");
                    }
                } else {
                    String returnNameToUse = (StringUtils.hasLength(paramNameToUse) ? paramNameToUse
                            : getFunctionReturnName());
                    workParams.add(provider.createDefaultOutParameter(returnNameToUse, meta));
                    if (isFunction()) {
                        setFunctionReturnName(returnNameToUse);
                        outParamNames.add(returnNameToUse);
                    }
                    if (logger.isDebugEnabled()) {
                        logger.debug("Added metadata return parameter for '" + returnNameToUse + "'");
                    }
                }
            } else {
                if (paramNameToUse == null) {
                    paramNameToUse = "";
                }
                if (meta.getParameterType() == DatabaseMetaData.procedureColumnOut) {
                    workParams.add(provider.createDefaultOutParameter(paramNameToUse, meta));
                    outParamNames.add(paramNameToUse);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Added metadata out parameter for '" + paramNameToUse + "'");
                    }
                } else if (meta.getParameterType() == DatabaseMetaData.procedureColumnInOut) {
                    workParams.add(provider.createDefaultInOutParameter(paramNameToUse, meta));
                    outParamNames.add(paramNameToUse);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Added metadata in out parameter for '" + paramNameToUse + "'");
                    }
                } else {
                    if (this.limitedInParameterNames.isEmpty()
                            || limitedInParamNamesMap.containsKey(lowerCase(paramNameToUse))) {
                        workParams.add(provider.createDefaultInParameter(paramNameToUse, meta));
                        if (logger.isDebugEnabled()) {
                            logger.debug("Added metadata in parameter for '" + paramNameToUse + "'");
                        }
                    } else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Limited set of parameters " + limitedInParamNamesMap.keySet()
                                    + " skipped parameter for '" + paramNameToUse + "'");
                        }
                    }
                }
            }
        }
    }

    return workParams;
}

---