Example usage for org.springframework.jdbc.core SqlParameter getName

List of usage examples for org.springframework.jdbc.core SqlParameter getName

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.jdbc.core.*
  5. SqlParameter
  6. getName

Introduction

In this page you can find the example usage for org.springframework.jdbc.core SqlParameter getName.

Prototype

@Nullable
public String getName()

Source Link

Document

Return the name of the parameter, or null if anonymous.

Usage

From source file:org.codehaus.grepo.procedure.compile.ProcedureCompilationUtils.java

/**
 * @param in The annotation.//from   w ww  .  jav  a2s .  co  m
 * @param context The procedure execution context.
 * @return Returns the created descriptor.
 */
public static ProcedureParamDescriptor createParamDescriptor(In in, ProcedureExecutionContext context) {
    SqlParameter sp = null;
    if (in.scale() >= 0) {
        sp = new SqlParameter(in.name(), in.sqlType(), in.scale());
    } else if (StringUtils.isNotEmpty(in.typeName())) {
        sp = new SqlParameter(in.name(), in.sqlType(), in.typeName());
    } else {
        sp = new SqlParameter(in.name(), in.sqlType());
    }

    return new ProcedureParamDescriptor(sp.getName(), ProcedureParamType.IN, sp, in.index());
}

From source file:anyframe.core.query.impl.QueryServiceImpl.java

public ArrayList getQueryParams(String queryId) throws QueryServiceException {
    try {//from   w  w  w. j  a v a  2 s .c o  m
        IQueryInfo queryInfo = (IQueryInfo) getSqlRepository().getQueryInfos().get(queryId);

        List paramList = queryInfo.getSqlParameterList();

        ArrayList results = new ArrayList();
        for (int i = 0; i < paramList.size(); i++) {
            String[] params = new String[2];
            SqlParameter param = (SqlParameter) paramList.get(i);
            params[0] = param.getName();
            String paramTypeName = param.getTypeName();

            // param type? OTHER ? CURSOR? 
            // SqlOutParameter  param
            // type name?    API ?. ? ?
            // ? ?? ? .
            if (paramTypeName == null) {
                int type = param.getSqlType();
                paramTypeName = SQLTypeTransfer.getSQLTypeName(type);
            }

            params[1] = paramTypeName;
            results.add(params);
        }

        return results;
    } catch (Exception e) {
        throw new QueryServiceException(getMessageSource(), "error.query.common.checkparams",
                new Object[] { queryId }, e);
    }
}

From source file:org.codehaus.grepo.procedure.compile.ProcedureCompilationUtils.java

/**
 * @param out The annotation./*from   ww w .j a  v a  2s. co m*/
 * @param context The procedure execution context.
 * @return Returns the created descriptor.
 * @throws ConfigurationException in case of errors.
 */
public static ProcedureParamDescriptor createParamDescriptor(Out out, ProcedureExecutionContext context)
        throws ConfigurationException {
    SqlParameter sp = null;
    if (out.scale() >= 0) {
        sp = new SqlOutParameter(out.name(), out.sqlType(), out.scale());
    } else if (StringUtils.isNotEmpty(out.typeName())) {
        if (isResultHandlerSpecified(out.resultHandlerId(), out.resultHandler())) {
            // we have a result handler specified...
            Object resultHandler = retrieveResultHandler(context, out.resultHandlerId(), out.resultHandler());
            if (ClassUtils.isAssignableFrom(SqlReturnType.class, resultHandler.getClass())) {
                sp = new SqlOutParameter(out.name(), out.sqlType(), out.typeName(),
                        (SqlReturnType) resultHandler);
            } else {
                // unsupported/invalid result handler...
                throw new ConfigurationException(String.format(INVALID_RESULTHANDLER_ERROR1,
                        resultHandler.getClass(), SqlReturnType.class));
            }
        } else {
            sp = new SqlOutParameter(out.name(), out.sqlType(), out.typeName());
        }
    } else {
        if (isResultHandlerSpecified(out.resultHandlerId(), out.resultHandler())) {
            // we have a result handler specified...
            Object resultHandler = retrieveResultHandler(context, out.resultHandlerId(), out.resultHandler());
            if (ClassUtils.isAssignableFrom(RowMapper.class, resultHandler.getClass())) {
                sp = new SqlOutParameter(out.name(), out.sqlType(), (RowMapper<?>) resultHandler);
            } else if (ClassUtils.isAssignableFrom(RowCallbackHandler.class, resultHandler.getClass())) {
                sp = new SqlOutParameter(out.name(), out.sqlType(), (RowCallbackHandler) resultHandler);
            } else if (ClassUtils.isAssignableFrom(ResultSetExtractor.class, resultHandler.getClass())) {
                sp = new SqlOutParameter(out.name(), out.sqlType(), (ResultSetExtractor<?>) resultHandler);
            } else {
                // unsupported/invalid result handler...
                throw new ConfigurationException(
                        String.format(INVALID_RESULTHANDLER_ERROR3, resultHandler.getClass(), RowMapper.class,
                                RowCallbackHandler.class, ResultSetExtractor.class));
            }
        } else {
            sp = new SqlOutParameter(out.name(), out.sqlType());
        }
    }

    return new ProcedureParamDescriptor(sp.getName(), ProcedureParamType.OUT, sp, out.index());
}

From source file:org.codehaus.grepo.procedure.compile.ProcedureCompilationUtils.java

/**
 * @param inout The annotation./*  w  w  w.  j  a  va 2 s  .com*/
 * @param context The procedure execution context.
 * @return Returns the created descriptor.
 * @throws ConfigurationException in case of errors.
 */
public static ProcedureParamDescriptor createParamDescriptor(InOut inout, ProcedureExecutionContext context)
        throws ConfigurationException {
    SqlParameter sp = null;
    if (inout.scale() >= 0) {
        sp = new SqlInOutParameter(inout.name(), inout.sqlType(), inout.scale());
    } else if (StringUtils.isNotEmpty(inout.typeName())) {
        if (isResultHandlerSpecified(inout.resultHandlerId(), inout.resultHandler())) {
            // we have a result handler specified...
            Object resultHandler = retrieveResultHandler(context, inout.resultHandlerId(),
                    inout.resultHandler());
            if (ClassUtils.isAssignableFrom(SqlReturnType.class, resultHandler.getClass())) {
                sp = new SqlInOutParameter(inout.name(), inout.sqlType(), inout.typeName(),
                        (SqlReturnType) resultHandler);
            } else {
                // unsupported/invalid result handler...
                throw new ConfigurationException(String.format(INVALID_RESULTHANDLER_ERROR1,
                        resultHandler.getClass(), SqlReturnType.class));
            }
        } else {
            sp = new SqlInOutParameter(inout.name(), inout.sqlType(), inout.typeName());
        }
    } else {
        if (isResultHandlerSpecified(inout.resultHandlerId(), inout.resultHandler())) {
            // we have a result handler specified...
            Object resultHandler = retrieveResultHandler(context, inout.resultHandlerId(),
                    inout.resultHandler());
            if (ClassUtils.isAssignableFrom(RowMapper.class, resultHandler.getClass())) {
                sp = new SqlInOutParameter(inout.name(), inout.sqlType(), (RowMapper<?>) resultHandler);
            } else if (ClassUtils.isAssignableFrom(RowCallbackHandler.class, resultHandler.getClass())) {
                sp = new SqlInOutParameter(inout.name(), inout.sqlType(), (RowCallbackHandler) resultHandler);
            } else if (ClassUtils.isAssignableFrom(ResultSetExtractor.class, resultHandler.getClass())) {
                sp = new SqlInOutParameter(inout.name(), inout.sqlType(),
                        (ResultSetExtractor<?>) resultHandler);
            } else {
                // unsupported/invalid result handler...
                throw new ConfigurationException(
                        String.format(INVALID_RESULTHANDLER_ERROR3, resultHandler.getClass(), RowMapper.class,
                                RowCallbackHandler.class, ResultSetExtractor.class));
            }
        } else {
            sp = new SqlInOutParameter(inout.name(), inout.sqlType());
        }
    }
    return new ProcedureParamDescriptor(sp.getName(), ProcedureParamType.INOUT, sp, inout.index());
}

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  a v  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;
}

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

/**
 * Match input parameter values with the parameters declared to be used in the call.
 * @param parameterSource the input values
 * @return a Map containing the matched parameter names with the value taken from the input
 *//*  w  ww  .  java  2s  .  co m*/
public Map<String, Object> matchInParameterValuesWithCallParameters(SqlParameterSource parameterSource) {
    // For parameter source lookups we need to provide case-insensitive lookup support
    // since the database metadata is not necessarily providing case sensitive parameter names.
    Map<String, String> caseInsensitiveParameterNames = SqlParameterSourceUtils
            .extractCaseInsensitiveParameterNames(parameterSource);

    Map<String, String> callParameterNames = new HashMap<>(this.callParameters.size());
    Map<String, Object> matchedParameters = new HashMap<>(this.callParameters.size());
    for (SqlParameter parameter : this.callParameters) {
        if (parameter.isInputValueProvided()) {
            String parameterName = parameter.getName();
            String parameterNameToMatch = obtainMetaDataProvider().parameterNameToUse(parameterName);
            if (parameterNameToMatch != null) {
                callParameterNames.put(parameterNameToMatch.toLowerCase(), parameterName);
            }
            if (parameterName != null) {
                if (parameterSource.hasValue(parameterName)) {
                    matchedParameters.put(parameterName,
                            SqlParameterSourceUtils.getTypedValue(parameterSource, parameterName));
                } else {
                    String lowerCaseName = parameterName.toLowerCase();
                    if (parameterSource.hasValue(lowerCaseName)) {
                        matchedParameters.put(parameterName,
                                SqlParameterSourceUtils.getTypedValue(parameterSource, lowerCaseName));
                    } else {
                        String englishLowerCaseName = parameterName.toLowerCase(Locale.ENGLISH);
                        if (parameterSource.hasValue(englishLowerCaseName)) {
                            matchedParameters.put(parameterName, SqlParameterSourceUtils
                                    .getTypedValue(parameterSource, englishLowerCaseName));
                        } else {
                            String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(parameterName);
                            if (parameterSource.hasValue(propertyName)) {
                                matchedParameters.put(parameterName,
                                        SqlParameterSourceUtils.getTypedValue(parameterSource, propertyName));
                            } else {
                                if (caseInsensitiveParameterNames.containsKey(lowerCaseName)) {
                                    String sourceName = caseInsensitiveParameterNames.get(lowerCaseName);
                                    matchedParameters.put(parameterName,
                                            SqlParameterSourceUtils.getTypedValue(parameterSource, sourceName));
                                } else {
                                    logger.warn("Unable to locate the corresponding parameter value for '"
                                            + parameterName + "' within the parameter values provided: "
                                            + caseInsensitiveParameterNames.values());
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    if (logger.isDebugEnabled()) {
        logger.debug(
                "Matching " + caseInsensitiveParameterNames.values() + " with " + callParameterNames.values());
        logger.debug("Found match for " + matchedParameters.keySet());
    }
    return matchedParameters;
}

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

/**
 * Match input parameter values with the parameters declared to be used in the call.
 * @param inParameters the input values/*from  ww w  . j a  v  a  2 s .  c o m*/
 * @return a Map containing the matched parameter names with the value taken from the input
 */
public Map<String, ?> matchInParameterValuesWithCallParameters(Map<String, ?> inParameters) {
    CallMetaDataProvider provider = obtainMetaDataProvider();
    if (!provider.isProcedureColumnMetaDataUsed()) {
        return inParameters;
    }

    Map<String, String> callParameterNames = new HashMap<>(this.callParameters.size());
    for (SqlParameter parameter : this.callParameters) {
        if (parameter.isInputValueProvided()) {
            String parameterName = parameter.getName();
            String parameterNameToMatch = provider.parameterNameToUse(parameterName);
            if (parameterNameToMatch != null) {
                callParameterNames.put(parameterNameToMatch.toLowerCase(), parameterName);
            }
        }
    }

    Map<String, Object> matchedParameters = new HashMap<>(inParameters.size());
    for (String parameterName : inParameters.keySet()) {
        String parameterNameToMatch = provider.parameterNameToUse(parameterName);
        String callParameterName = callParameterNames.get(lowerCase(parameterNameToMatch));
        if (callParameterName == null) {
            if (logger.isDebugEnabled()) {
                Object value = inParameters.get(parameterName);
                if (value instanceof SqlParameterValue) {
                    value = ((SqlParameterValue) value).getValue();
                }
                if (value != null) {
                    logger.debug("Unable to locate the corresponding IN or IN-OUT parameter for \""
                            + parameterName + "\" in the parameters used: " + callParameterNames.keySet());
                }
            }
        } else {
            matchedParameters.put(callParameterName, inParameters.get(parameterName));
        }
    }

    if (matchedParameters.size() < callParameterNames.size()) {
        for (String parameterName : callParameterNames.keySet()) {
            String parameterNameToMatch = provider.parameterNameToUse(parameterName);
            String callParameterName = callParameterNames.get(lowerCase(parameterNameToMatch));
            if (!matchedParameters.containsKey(callParameterName)) {
                logger.warn("Unable to locate the corresponding parameter value for '" + parameterName
                        + "' within the parameter values provided: " + inParameters.keySet());
            }
        }
    }

    if (logger.isDebugEnabled()) {
        logger.debug("Matching " + inParameters.keySet() + " with " + callParameterNames.values());
        logger.debug("Found match for " + matchedParameters.keySet());
    }
    return matchedParameters;
}

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

public Map<String, ?> matchInParameterValuesWithCallParameters(Object[] parameterValues) {
    Map<String, Object> matchedParameters = new HashMap<>(parameterValues.length);
    int i = 0;/*from www.j  ava 2s  .c om*/
    for (SqlParameter parameter : this.callParameters) {
        if (parameter.isInputValueProvided()) {
            String parameterName = parameter.getName();
            matchedParameters.put(parameterName, parameterValues[i++]);
        }
    }
    return matchedParameters;
}

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

/**
 * Build the parameter binding fragment.
 * @param parameter call parameter/*from   w w w  .  j a  v a2s .  c  o m*/
 * @return parameter binding fragment
 * @since 4.2
 */
protected String createParameterBinding(SqlParameter parameter) {
    return (isNamedBinding() ? parameter.getName() + " => ?" : "?");
}

From source file:org.springframework.jdbc.core.simple.AbstractJdbcCall.java

/**
 * Add a declared parameter to the list of parameters for the call.
 * <p>Only parameters declared as {@code SqlParameter} and {@code SqlInOutParameter} will
 * be used to provide input values. This is different from the {@code StoredProcedure}
 * class which - for backwards compatibility reasons - allows input values to be provided
 * for parameters declared as {@code SqlOutParameter}.
 * @param parameter the {@link SqlParameter} to add
 *//*from w  w  w.  j  a v  a  2s . c om*/
public void addDeclaredParameter(SqlParameter parameter) {
    Assert.notNull(parameter, "The supplied parameter must not be null");
    if (!StringUtils.hasText(parameter.getName())) {
        throw new InvalidDataAccessApiUsageException(
                "You must specify a parameter name when declaring parameters for \"" + getProcedureName()
                        + "\"");
    }
    this.declaredParameters.add(parameter);
    if (logger.isDebugEnabled()) {
        logger.debug("Added declared parameter for [" + getProcedureName() + "]: " + parameter.getName());
    }
}