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

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

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

Introduction

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

Prototype

public int getSqlType()

Source Link

Document

Return the SQL type of the parameter.

Usage

From source file:org.hxzon.util.db.springjdbc.StatementCreatorUtils.java

/**
 * Set the value for a parameter. The method used is based on the SQL type
 * of the parameter and we can handle complex types like arrays and LOBs.
 * @param ps the prepared statement or callable statement
 * @param paramIndex index of the parameter we are setting
 * @param param the parameter as it is declared including type
 * @param inValue the value to set//from   w  w  w .  jav  a  2  s .  co  m
 * @throws SQLException if thrown by PreparedStatement methods
 */
public static void setParameterValue(PreparedStatement ps, int paramIndex, SqlParameter param, Object inValue)
        throws SQLException {

    setParameterValueInternal(ps, paramIndex, param.getSqlType(), param.getTypeName(), param.getScale(),
            inValue);
}

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

public ArrayList getQueryParams(String queryId) throws QueryServiceException {
    try {//  w w w  .  j av a2s  .  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.springframework.jdbc.core.metadata.CallMetaDataContext.java

/**
 * Reconcile the provided parameters with available metadata and add new ones where appropriate.
 *//* w ww .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;
}

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

/**
 * Delegate method to perform the actual call processing.
 *//*from w  w  w .  j  a  va  2  s.  c  o m*/
private Map<String, Object> executeCallInternal(Map<String, ?> args) {
    CallableStatementCreator csc = getCallableStatementFactory().newCallableStatementCreator(args);
    if (logger.isDebugEnabled()) {
        logger.debug("The following parameters are used for call " + getCallString() + " with " + args);
        int i = 1;
        for (SqlParameter param : getCallParameters()) {
            logger.debug(i + ": " + param.getName() + ", SQL type " + param.getSqlType() + ", type name "
                    + param.getTypeName() + ", parameter class [" + param.getClass().getName() + "]");
            i++;
        }
    }
    return getJdbcTemplate().call(csc, getCallParameters());
}

From source file:org.springframework.jdbc.core.StatementCreatorUtils.java

/**
 * Set the value for a parameter. The method used is based on the SQL type
 * of the parameter and we can handle complex types like arrays and LOBs.
 * @param ps the prepared statement or callable statement
 * @param paramIndex index of the parameter we are setting
 * @param param the parameter as it is declared including type
 * @param inValue the value to set//from   w  w w  .j  a  v  a2 s  .  co  m
 * @throws SQLException if thrown by PreparedStatement methods
 */
public static void setParameterValue(PreparedStatement ps, int paramIndex, SqlParameter param,
        @Nullable Object inValue) throws SQLException {

    setParameterValueInternal(ps, paramIndex, param.getSqlType(), param.getTypeName(), param.getScale(),
            inValue);
}

From source file:org.springframework.jdbc.object.RdbmsOperation.java

/**
 * Validate the parameters passed to an execute method based on declared parameters.
 * Subclasses should invoke this method before every {@code executeQuery()}
 * or {@code update()} method./*from   ww w  . jav  a2 s . c om*/
 * @param parameters parameters supplied (may be {@code null})
 * @throws InvalidDataAccessApiUsageException if the parameters are invalid
 */
protected void validateParameters(@Nullable Object[] parameters) throws InvalidDataAccessApiUsageException {
    checkCompiled();
    int declaredInParameters = 0;
    for (SqlParameter param : this.declaredParameters) {
        if (param.isInputValueProvided()) {
            if (!supportsLobParameters()
                    && (param.getSqlType() == Types.BLOB || param.getSqlType() == Types.CLOB)) {
                throw new InvalidDataAccessApiUsageException(
                        "BLOB or CLOB parameters are not allowed for this kind of operation");
            }
            declaredInParameters++;
        }
    }
    validateParameterCount((parameters != null ? parameters.length : 0), declaredInParameters);
}

From source file:org.springframework.jdbc.object.RdbmsOperation.java

/**
 * Validate the named parameters passed to an execute method based on declared parameters.
 * Subclasses should invoke this method before every {@code executeQuery()} or
 * {@code update()} method./* w w w .  jav a  2 s.  c om*/
 * @param parameters parameter Map supplied (may be {@code null})
 * @throws InvalidDataAccessApiUsageException if the parameters are invalid
 */
protected void validateNamedParameters(@Nullable Map<String, ?> parameters)
        throws InvalidDataAccessApiUsageException {
    checkCompiled();
    Map<String, ?> paramsToUse = (parameters != null ? parameters : Collections.<String, Object>emptyMap());
    int declaredInParameters = 0;
    for (SqlParameter param : this.declaredParameters) {
        if (param.isInputValueProvided()) {
            if (!supportsLobParameters()
                    && (param.getSqlType() == Types.BLOB || param.getSqlType() == Types.CLOB)) {
                throw new InvalidDataAccessApiUsageException(
                        "BLOB or CLOB parameters are not allowed for this kind of operation");
            }
            if (param.getName() != null && !paramsToUse.containsKey(param.getName())) {
                throw new InvalidDataAccessApiUsageException("The parameter named '" + param.getName()
                        + "' was not among the parameters supplied: " + paramsToUse.keySet());
            }
            declaredInParameters++;
        }
    }
    validateParameterCount(paramsToUse.size(), declaredInParameters);
}