Example usage for java.sql DatabaseMetaData procedureColumnReturn

List of usage examples for java.sql DatabaseMetaData procedureColumnReturn

Introduction

In this page you can find the example usage for java.sql DatabaseMetaData procedureColumnReturn.

Prototype

int procedureColumnReturn

To view the source code for java.sql DatabaseMetaData procedureColumnReturn.

Click Source Link

Document

Indicates that the column stores return values.

Usage

From source file:com.netspective.axiom.sql.StoredProcedure.java

/**
 * Gets the stored procedure's metadata information from the database. This will search
 * all available catalogs and schemas. This method will ONLY return the metadata of the
 * stored procedure only when the <i>procedure-name</i> attribute is set in the XML declaration.
 *///from   w w  w .  j av  a 2  s.  com
public String getMetaData(ConnectionContext cc) throws NamingException, SQLException {
    // TODO : Using this metadata, we can determine what variables are in and out so that the developer doesn't even have to set it in XML
    // but currently the procedure-name attribute isn't required but the 'type' attribute is required. If we go the
    // metadata route we need to change some handling to accept setting the 'type' and if it's not set, we can use
    // the metadata to get the param type
    StringBuffer sb = new StringBuffer();
    if (procedureName != null && procedureName.length() > 0) {
        // Get DatabaseMetaData
        Connection connection = cc.getConnection();
        DatabaseMetaData dbmd = connection.getMetaData();
        ResultSet rs = dbmd.getProcedureColumns(null, null, procedureName, "%");
        // Printout table data
        while (rs.next()) {
            // Get procedure metadata
            String dbProcedureCatalog = rs.getString(1);
            String dbProcedureSchema = rs.getString(2);
            String dbProcedureName = rs.getString(3);
            String dbColumnName = rs.getString(4);
            short dbColumnReturn = rs.getShort(5);
            String dbColumnReturnTypeName = rs.getString(7);
            int dbColumnPrecision = rs.getInt(8);
            int dbColumnByteLength = rs.getInt(9);
            short dbColumnScale = rs.getShort(10);
            short dbColumnRadix = rs.getShort(11);
            String dbColumnRemarks = rs.getString(13);
            // Interpret the return type (readable for humans)
            String procReturn;
            switch (dbColumnReturn) {
            case DatabaseMetaData.procedureColumnIn:
                procReturn = "In";
                break;
            case DatabaseMetaData.procedureColumnOut:
                procReturn = "Out";
                break;
            case DatabaseMetaData.procedureColumnInOut:
                procReturn = "In/Out";
                break;
            case DatabaseMetaData.procedureColumnReturn:
                procReturn = "return value";
                break;
            case DatabaseMetaData.procedureColumnResult:
                procReturn = "return ResultSet";
            default:
                procReturn = "Unknown";
            }
            // Printout
            sb.append("Procedure: " + dbProcedureCatalog + "." + dbProcedureSchema + "." + dbProcedureName);
            sb.append("   ColumnName [ColumnType(ColumnPrecision)]: " + dbColumnName + " ["
                    + dbColumnReturnTypeName + "(" + dbColumnPrecision + ")]");
            sb.append("   ColumnReturns: " + procReturn + "(" + dbColumnReturnTypeName + ")");
            sb.append("   Radix: " + dbColumnRadix + ", Scale: " + dbColumnScale);
            sb.append("   Remarks: " + dbColumnRemarks);
        }
        rs.close();
        connection.close();
    }
    return sb.toString();
}

From source file:org.apache.cayenne.access.DbLoader.java

private ProcedureParameter loadProcedureParams(ResultSet columnsRS, String key, Procedure procedure)
        throws SQLException {
    String columnName = columnsRS.getString("COLUMN_NAME");

    // skip ResultSet columns, as they are not described in Cayenne
    // procedures yet...
    short type = columnsRS.getShort("COLUMN_TYPE");
    if (type == DatabaseMetaData.procedureColumnResult) {
        LOGGER.debug("skipping ResultSet column: " + key + "." + columnName);
    }//from  w ww.  j  ava  2  s  .  c  o  m

    if (columnName == null) {
        if (type == DatabaseMetaData.procedureColumnReturn) {
            LOGGER.debug("null column name, assuming result column: " + key);
            columnName = "_return_value";
            procedure.setReturningValue(true);
        } else {
            LOGGER.info("invalid null column name, skipping column : " + key);
            return null;
        }
    }

    int columnType = columnsRS.getInt("DATA_TYPE");

    // ignore precision of non-decimal columns
    int decimalDigits = -1;
    if (TypesMapping.isDecimal(columnType)) {
        decimalDigits = columnsRS.getShort("SCALE");
        if (columnsRS.wasNull()) {
            decimalDigits = -1;
        }
    }

    ProcedureParameter column = new ProcedureParameter(columnName);
    int direction = getDirection(type);
    if (direction != -1) {
        column.setDirection(direction);
    }

    column.setType(columnType);
    column.setMaxLength(columnsRS.getInt("LENGTH"));
    column.setPrecision(decimalDigits);

    column.setProcedure(procedure);
    return column;
}

From source file:org.apache.cayenne.dbsync.reverse.dbload.ProcedureColumnLoader.java

private ProcedureParameter loadProcedureParams(ResultSet rs, String key, Procedure procedure)
        throws SQLException {
    String columnName = rs.getString("COLUMN_NAME");

    // skip ResultSet columns, as they are not described in Cayenne procedures yet...
    short type = rs.getShort("COLUMN_TYPE");
    if (type == DatabaseMetaData.procedureColumnResult) {
        LOGGER.debug("skipping ResultSet column: " + key + "." + columnName);
        return null;
    }/*from   w  ww.  j  av a 2s .  co  m*/

    if (columnName == null) {
        if (type == DatabaseMetaData.procedureColumnReturn) {
            LOGGER.debug("null column name, assuming result column: " + key);
            columnName = "_return_value";
            procedure.setReturningValue(true);
        } else {
            LOGGER.info("invalid null column name, skipping column : " + key);
            return null;
        }
    }

    int columnType = rs.getInt("DATA_TYPE");

    // ignore precision of non-decimal columns
    int decimalDigits = -1;
    if (TypesMapping.isDecimal(columnType)) {
        decimalDigits = rs.getShort("SCALE");
        if (rs.wasNull()) {
            decimalDigits = -1;
        }
    }

    ProcedureParameter column = new ProcedureParameter(columnName);
    column.setDirection(getDirection(type));
    column.setType(columnType);
    column.setMaxLength(rs.getInt("LENGTH"));
    column.setPrecision(decimalDigits);
    column.setProcedure(procedure);

    return column;
}

From source file:org.apache.ddlutils.task.DumpMetadataTask.java

/**
 * Dumps the contents of the indicated procedure.
 * // w w  w. ja  v  a2s  .  c o  m
 * @param xmlWriter     The xml writer to write to
 * @param metaData      The database metadata
 * @param catalogName   The catalog name
 * @param schemaName    The schema name
 * @param procedureName The procedure name
 */
private void dumpProcedure(PrettyPrintingXmlWriter xmlWriter, final DatabaseMetaData metaData,
        final String catalogName, final String schemaName, final String procedureName) throws SQLException {
    performResultSetXmlOperation(xmlWriter, null, new ResultSetXmlOperation() {
        public ResultSet getResultSet() throws SQLException {
            return metaData.getProcedureColumns(catalogName, schemaName, procedureName, _columnPattern);
        }

        public void handleRow(PrettyPrintingXmlWriter xmlWriter, ResultSet result) throws SQLException {
            Set columns = getColumnsInResultSet(result);
            String columnName = result.getString("COLUMN_NAME");

            if ((columnName != null) && (columnName.length() > 0)) {
                xmlWriter.writeElementStart(null, "column");
                xmlWriter.writeAttribute(null, "name", columnName);
                if (columns.contains("COLUMN_TYPE")) {
                    try {
                        switch (result.getShort("COLUMN_TYPE")) {
                        case DatabaseMetaData.procedureColumnIn:
                            xmlWriter.writeAttribute(null, "type", "in parameter");
                            break;
                        case DatabaseMetaData.procedureColumnInOut:
                            xmlWriter.writeAttribute(null, "type", "in/out parameter");
                            break;
                        case DatabaseMetaData.procedureColumnOut:
                            xmlWriter.writeAttribute(null, "type", "out parameter");
                            break;
                        case DatabaseMetaData.procedureColumnReturn:
                            xmlWriter.writeAttribute(null, "type", "return value");
                            break;
                        case DatabaseMetaData.procedureColumnResult:
                            xmlWriter.writeAttribute(null, "type", "result column in ResultSet");
                            break;
                        default:
                            xmlWriter.writeAttribute(null, "type", "unknown");
                            break;
                        }
                    } catch (SQLException ex) {
                        log("Could not read the COLUMN_TYPE value for the column '" + columnName
                                + "' of procedure '" + procedureName + "' from the result set: "
                                + ex.getStackTrace(), Project.MSG_ERR);
                    }
                }

                addIntAttribute(xmlWriter, "typeCode", result, columns, "DATA_TYPE");
                addStringAttribute(xmlWriter, "type", result, columns, "TYPE_NAME");
                addIntAttribute(xmlWriter, "length", result, columns, "LENGTH");
                addIntAttribute(xmlWriter, "precision", result, columns, "PRECISION");
                addShortAttribute(xmlWriter, "short", result, columns, "SCALE");
                addShortAttribute(xmlWriter, "radix", result, columns, "RADIX");
                if (columns.contains("NULLABLE")) {
                    try {
                        switch (result.getInt("NULLABLE")) {
                        case DatabaseMetaData.procedureNoNulls:
                            xmlWriter.writeAttribute(null, "nullable", "false");
                            break;
                        case DatabaseMetaData.procedureNullable:
                            xmlWriter.writeAttribute(null, "nullable", "true");
                            break;
                        default:
                            xmlWriter.writeAttribute(null, "nullable", "unknown");
                            break;
                        }
                    } catch (SQLException ex) {
                        log("Could not read the NULLABLE value for the column '" + columnName
                                + "' of procedure '" + procedureName + "' from the result set: "
                                + ex.getStackTrace(), Project.MSG_ERR);
                    }
                }
                addStringAttribute(xmlWriter, "remarks", result, columns, "REMARKS");
            }
        }

        public void handleError(SQLException ex) {
            log("Could not read the columns for procedure '" + procedureName + "' from the result set: "
                    + ex.getStackTrace(), Project.MSG_ERR);
        }
    });
}

From source file:org.executequery.databasemediators.spi.DefaultStatementExecutor.java

/** <p>Executes the specified procedure.
 *
 *  @param  the SQL procedure to execute
 *  @return the query result//  w ww .  ja v  a 2s  . co m
 */
public SqlStatementResult execute(DatabaseExecutable databaseExecutable) throws SQLException {

    if (!prepared()) {

        return statementResult;
    }

    ProcedureParameter[] param = databaseExecutable.getParametersArray();
    Arrays.sort(param, new ProcedureParameterSorter());

    String procQuery = null;
    boolean hasOut = false;
    boolean hasParameters = (param != null && param.length > 0);

    List<ProcedureParameter> outs = null;
    List<ProcedureParameter> ins = null;

    if (hasParameters) {

        // split the params into ins and outs
        outs = new ArrayList<ProcedureParameter>();
        ins = new ArrayList<ProcedureParameter>();

        int type = -1;
        for (int i = 0; i < param.length; i++) {
            type = param[i].getType();
            if (type == DatabaseMetaData.procedureColumnIn || type == DatabaseMetaData.procedureColumnInOut) {

                // add to the ins list
                ins.add(param[i]);

            } else if (type == DatabaseMetaData.procedureColumnOut
                    || type == DatabaseMetaData.procedureColumnResult
                    || type == DatabaseMetaData.procedureColumnReturn
                    || type == DatabaseMetaData.procedureColumnUnknown
                    || type == DatabaseMetaData.procedureColumnInOut) {

                // add to the outs list
                outs.add(param[i]);

            }
        }

        char QUESTION_MARK = '?';
        String COMMA = ", ";

        // init the string buffer
        StringBuilder sb = new StringBuilder("{ ");
        if (!outs.isEmpty()) {

            // build the out params place holders
            for (int i = 0, n = outs.size(); i < n; i++) {

                sb.append(QUESTION_MARK);

                if (i < n - 1) {

                    sb.append(COMMA);
                }

            }

            sb.append(" = ");
        }

        sb.append(" call ");

        if (databaseExecutable.supportCatalogOrSchemaInFunctionOrProcedureCalls()) {

            String namePrefix = null;
            if (databaseExecutable.supportCatalogInFunctionOrProcedureCalls()) {

                namePrefix = databaseExecutable.getCatalogName();

            }
            if (databaseExecutable.supportSchemaInFunctionOrProcedureCalls()) {

                namePrefix = databaseExecutable.getSchemaName();

            }

            if (namePrefix != null) {

                sb.append(namePrefix).append('.');
            }
        }

        sb.append(databaseExecutable.getName()).append("( ");

        // build the ins params place holders
        for (int i = 0, n = ins.size(); i < n; i++) {
            sb.append(QUESTION_MARK);
            if (i < n - 1) {
                sb.append(COMMA);
            }
        }

        sb.append(" ) }");

        // determine if we have out params
        hasOut = !(outs.isEmpty());
        procQuery = sb.toString();
    } else {
        StringBuilder sb = new StringBuilder();
        sb.append("{ call ");

        if (databaseExecutable.getSchemaName() != null) {
            sb.append(databaseExecutable.getSchemaName()).append('.');
        }

        sb.append(databaseExecutable.getName()).append("( ) }");

        procQuery = sb.toString();
    }

    //Log.debug(procQuery);

    // null value literal
    String NULL = "null";

    // clear any warnings
    conn.clearWarnings();

    Log.info("Executing: " + procQuery);

    CallableStatement cstmnt = null;
    try {
        // prepare the statement
        cstmnt = conn.prepareCall(procQuery);
        stmnt = cstmnt;
    } catch (SQLException e) {
        handleException(e);
        statementResult.setSqlException(e);
        return statementResult;
    }

    // check if we are passing parameters
    if (hasParameters) {
        // the parameter index counter
        int index = 1;

        // the java.sql.Type value
        int dataType = -1;

        // the parameter input value
        String value = null;

        // register the out params
        for (int i = 0, n = outs.size(); i < n; i++) {
            //Log.debug("setting out at index: " + index);
            cstmnt.registerOutParameter(index, outs.get(i).getDataType());
            index++;
        }

        try {

            // register the in params
            for (int i = 0, n = ins.size(); i < n; i++) {

                ProcedureParameter procedureParameter = ins.get(i);
                value = procedureParameter.getValue();
                dataType = procedureParameter.getDataType();

                // try infer a type if OTHER
                if (dataType == Types.OTHER) {

                    // checking only for bit/bool for now

                    if (isTrueFalse(value)) {

                        dataType = Types.BOOLEAN;

                    } else if (isBit(value)) {

                        dataType = Types.BIT;
                        value = value.substring(2, value.length() - 1);
                    }

                }

                if (MiscUtils.isNull(value) || value.equalsIgnoreCase(NULL)) {

                    cstmnt.setNull(index, dataType);

                } else {

                    switch (dataType) {

                    case Types.TINYINT:
                        byte _byte = Byte.valueOf(value).byteValue();
                        cstmnt.setShort(index, _byte);
                        break;

                    case Types.SMALLINT:
                        short _short = Short.valueOf(value).shortValue();
                        cstmnt.setShort(index, _short);
                        break;

                    case Types.LONGVARCHAR:
                    case Types.CHAR:
                    case Types.VARCHAR:
                        cstmnt.setString(index, value);
                        break;

                    case Types.BIT:
                    case Types.BOOLEAN:

                        boolean _boolean = false;
                        if (NumberUtils.isNumber(value)) {

                            int number = Integer.valueOf(value);
                            if (number > 0) {

                                _boolean = true;
                            }

                        } else {

                            _boolean = Boolean.valueOf(value).booleanValue();
                        }

                        cstmnt.setBoolean(index, _boolean);
                        break;

                    case Types.BIGINT:
                        long _long = Long.valueOf(value).longValue();
                        cstmnt.setLong(index, _long);
                        break;

                    case Types.INTEGER:
                        int _int = Integer.valueOf(value).intValue();
                        cstmnt.setInt(index, _int);
                        break;

                    case Types.REAL:
                        float _float = Float.valueOf(value).floatValue();
                        cstmnt.setFloat(index, _float);
                        break;

                    case Types.NUMERIC:
                    case Types.DECIMAL:
                        cstmnt.setBigDecimal(index, new BigDecimal(value));
                        break;
                    /*
                                      case Types.DATE:
                                      case Types.TIMESTAMP:
                                      case Types.TIME:
                                        cstmnt.setTimestamp(index, new Timestamp( BigDecimal(value));
                    */
                    case Types.FLOAT:
                    case Types.DOUBLE:
                        double _double = Double.valueOf(value).doubleValue();
                        cstmnt.setDouble(index, _double);
                        break;

                    default:
                        cstmnt.setObject(index, value);

                    }

                }

                // increment the index
                index++;
            }

        } catch (Exception e) {

            statementResult.setOtherErrorMessage(e.getClass().getName() + ": " + e.getMessage());
            return statementResult;
        }

    }

    /*
    test creating function for postgres:
            
    CREATE FUNCTION concat_lower_or_upper(a text, b text, uppercase boolean DEFAULT false)
    RETURNS text
    AS
    $$
     SELECT CASE
        WHEN $3 THEN UPPER($1 || ' ' || $2)
        ELSE LOWER($1 || ' ' || $2)
        END;
    $$
    LANGUAGE SQL IMMUTABLE STRICT;
    */

    try {
        cstmnt.clearWarnings();
        boolean hasResultSet = cstmnt.execute();
        Map<String, Object> results = new HashMap<String, Object>();

        if (hasOut) {
            // incrementing index
            int index = 1;

            // return value from each registered out
            String returnValue = null;

            for (int i = 0; i < param.length; i++) {

                int type = param[i].getType();
                int dataType = param[i].getDataType();

                if (type == DatabaseMetaData.procedureColumnOut
                        || type == DatabaseMetaData.procedureColumnResult
                        || type == DatabaseMetaData.procedureColumnReturn
                        || type == DatabaseMetaData.procedureColumnUnknown
                        || type == DatabaseMetaData.procedureColumnInOut) {

                    switch (dataType) {

                    case Types.TINYINT:
                        returnValue = Byte.toString(cstmnt.getByte(index));
                        break;

                    case Types.SMALLINT:
                        returnValue = Short.toString(cstmnt.getShort(index));
                        break;

                    case Types.LONGVARCHAR:
                    case Types.CHAR:
                    case Types.VARCHAR:
                        returnValue = cstmnt.getString(index);
                        break;

                    case Types.BIT:
                    case Types.BOOLEAN:
                        returnValue = Boolean.toString(cstmnt.getBoolean(index));
                        break;

                    case Types.INTEGER:
                        returnValue = Integer.toString(cstmnt.getInt(index));
                        break;

                    case Types.BIGINT:
                        returnValue = Long.toString(cstmnt.getLong(index));
                        break;

                    case Types.REAL:
                        returnValue = Float.toString(cstmnt.getFloat(index));
                        break;

                    case Types.NUMERIC:
                    case Types.DECIMAL:
                        returnValue = cstmnt.getBigDecimal(index).toString();
                        break;

                    case Types.DATE:
                    case Types.TIME:
                    case Types.TIMESTAMP:
                        returnValue = cstmnt.getDate(index).toString();
                        break;

                    case Types.FLOAT:
                    case Types.DOUBLE:
                        returnValue = Double.toString(cstmnt.getDouble(index));
                        break;

                    }

                    if (returnValue == null) {
                        returnValue = "NULL";
                    }

                    results.put(param[i].getName(), returnValue);
                    index++;
                }

            }

        }

        if (!hasResultSet) {

            statementResult.setUpdateCount(cstmnt.getUpdateCount());

        } else {

            statementResult.setResultSet(cstmnt.getResultSet());
        }

        useCount++;
        statementResult.setOtherResult(results);

    } catch (SQLException e) {

        statementResult.setSqlException(e);

    } catch (Exception e) {

        statementResult.setMessage(e.getMessage());
    }

    return statementResult;
}

From source file:org.openadaptor.auxil.connector.jdbc.writer.AbstractSQLWriter.java

private static final String spTypeToString(int type) {
    String result;//from  w w  w.  ja v a  2  s .  c o m
    switch (type) {
    case DatabaseMetaData.procedureColumnUnknown: // 0
        result = "unknown";
        break;
    case DatabaseMetaData.procedureColumnIn: // 1
        result = "IN";
        break;
    case DatabaseMetaData.procedureColumnInOut: // 2
        result = "INOUT";
        break;
    case DatabaseMetaData.procedureColumnOut: //3
        result = "OUT";
        break;
    case DatabaseMetaData.procedureColumnReturn: // 4
        result = "RETURN";
        break;
    case DatabaseMetaData.procedureColumnResult: // 5
        result = "RESULT";
        break;
    default: //This *should* never arise
        result = "Illegal value for procedureColumn type";
        break;
    }
    return result;
}

From source file:org.seasar.dbflute.logic.jdbc.metadata.basic.DfProcedureExtractor.java

protected void setupProcedureColumnMetaInfo(DfProcedureMeta procedureMetaInfo, ResultSet columnRs)
        throws SQLException {
    final Set<String> uniqueSet = new HashSet<String>();
    while (columnRs.next()) {
        // /- - - - - - - - - - - - - - - - - - - - - - - -
        // same policy as table process about JDBC handling
        // (see DfTableHandler.java)
        // - - - - - - - - - -/

        final String columnName = columnRs.getString("COLUMN_NAME");

        // filter duplicated informations
        // because Oracle package procedure may return them
        if (uniqueSet.contains(columnName)) {
            continue;
        }//from  ww w. j  a v a2  s  .c om
        uniqueSet.add(columnName);

        final Integer procedureColumnType;
        {
            final String columnType = columnRs.getString("COLUMN_TYPE");
            final int unknowType = DatabaseMetaData.procedureColumnUnknown;
            if (Srl.is_NotNull_and_NotTrimmedEmpty(columnType)) {
                procedureColumnType = toInt("columnType", columnType);
            } else {
                procedureColumnType = unknowType;
            }
        }

        final int jdbcType;
        {
            int tmpJdbcType = Types.OTHER;
            String dataType = null;
            try {
                dataType = columnRs.getString("DATA_TYPE");
            } catch (RuntimeException ignored) { // pinpoint patch
                // for example, SQLServer throws an exception
                // if the procedure is a function that returns table type
                final String procdureName = procedureMetaInfo.getProcedureFullQualifiedName();
                log("*Failed to get data type: " + procdureName + "." + columnName);
                tmpJdbcType = Types.OTHER;
            }
            if (Srl.is_NotNull_and_NotTrimmedEmpty(dataType)) {
                tmpJdbcType = toInt("dataType", dataType);
            }
            jdbcType = tmpJdbcType;
        }

        final String dbTypeName = columnRs.getString("TYPE_NAME");

        // uses getString() to get null value
        // (getInt() returns zero when a value is no defined)
        final Integer columnSize;
        {
            final String precision = columnRs.getString("PRECISION");
            if (Srl.is_NotNull_and_NotTrimmedEmpty(precision)) {
                columnSize = toInt("precision", precision);
            } else {
                final String length = columnRs.getString("LENGTH");
                if (Srl.is_NotNull_and_NotTrimmedEmpty(length)) {
                    columnSize = toInt("length", length);
                } else {
                    columnSize = null;
                }
            }
        }
        final Integer decimalDigits;
        {
            final String scale = columnRs.getString("SCALE");
            if (Srl.is_NotNull_and_NotTrimmedEmpty(scale)) {
                decimalDigits = toInt("scale", scale);
            } else {
                decimalDigits = null;
            }
        }
        final String columnComment = columnRs.getString("REMARKS");

        final DfProcedureColumnMeta procedureColumnMetaInfo = new DfProcedureColumnMeta();
        procedureColumnMetaInfo.setColumnName(columnName);
        if (procedureColumnType == DatabaseMetaData.procedureColumnUnknown) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnUnknown);
        } else if (procedureColumnType == DatabaseMetaData.procedureColumnIn) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnIn);
        } else if (procedureColumnType == DatabaseMetaData.procedureColumnInOut) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnInOut);
        } else if (procedureColumnType == DatabaseMetaData.procedureColumnOut) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnOut);
        } else if (procedureColumnType == DatabaseMetaData.procedureColumnReturn) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnReturn);
        } else if (procedureColumnType == DatabaseMetaData.procedureColumnResult) {
            procedureColumnMetaInfo.setProcedureColumnType(DfProcedureColumnType.procedureColumnResult);
        } else {
            throw new IllegalStateException("Unknown procedureColumnType: " + procedureColumnType);
        }
        procedureColumnMetaInfo.setJdbcDefType(jdbcType);
        procedureColumnMetaInfo.setDbTypeName(dbTypeName);
        procedureColumnMetaInfo.setColumnSize(columnSize);
        procedureColumnMetaInfo.setDecimalDigits(decimalDigits);
        procedureColumnMetaInfo.setColumnComment(columnComment);
        procedureMetaInfo.addProcedureColumn(procedureColumnMetaInfo);
    }
    adjustProcedureColumnList(procedureMetaInfo);
}

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  om*/
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.wso2.carbon.dataservices.core.description.query.SQLQuery.java

private boolean calculateBatchQuerySupport() throws DataServiceFault {
    Object[] resultMap;/*w w w  .  j  a v  a  2  s  .  com*/
    List<Connection> connections = new ArrayList<Connection>();
    if (this.getConfig().hasJDBCBatchUpdateSupport()) {
        if (this.getQueryType() == SQLQuery.DS_QUERY_TYPE_STORED_PROC) {
            try {
                resultMap = this.getStoredProcFuncProps(this.extractStoredProcName(true));
                ResultSet rs = (ResultSet) resultMap[1];
                connections.add((Connection) resultMap[0]);
                if (!rs.next()) {
                    resultMap = this.getStoredProcFuncProps(this.extractStoredProcName(false));
                    rs = (ResultSet) resultMap[1];
                    connections.add((Connection) resultMap[0]);
                    if (!rs.next()) {
                        throw new DataServiceFault("Cannot find metadata for the stored procedure");
                    }
                }
                /*
                 * stored procedures here can only have IN params and
                 * results which only returns an integer, which has the
                 * update count, all other situations are not supported for
                 * batch updates
                 */
                StoredProcMetadataCollection mdCollection = new StoredProcMetadataCollection(rs);
                for (StoredProcMetadataEntry entry : mdCollection.getEntries()) {
                    switch (entry.getColumnReturn()) {
                    case DatabaseMetaData.procedureColumnIn:
                        break;
                    case DatabaseMetaData.procedureColumnReturn:
                        if (!(entry.getColumnDataType() == Types.INTEGER
                                || entry.getColumnDataType() == Types.BIGINT
                                || entry.getColumnDataType() == Types.DECIMAL)) {
                            return false;
                        }
                        break;
                    default:
                        return false;
                    }
                }
                return true;
            } catch (Throwable e) {
                throw new DataServiceFault("Error in retrieving database metadata.");
            } finally {
                for (Connection aCon : connections) {
                    try {
                        aCon.close();
                    } catch (SQLException ignore) {
                    }
                }
            }
        } else {
            return true;
        }
    } else {
        return false;
    }
}

From source file:ro.nextreports.designer.dbviewer.DefaultDBViewer.java

public List<DBProcedureColumn> getProcedureColumns(String schema, String catalog, String procedure)
        throws NextSqlException {
    Connection con;/*  ww w  .  j a  va 2s.  c o m*/
    List<DBProcedureColumn> columns = new ArrayList<DBProcedureColumn>();
    String schemaName;

    try {
        con = Globals.getConnection();
        if (schema == null) {
            schemaName = Globals.getConnection().getMetaData().getUserName();
        } else {
            schemaName = schema;
        }
    } catch (Exception e) {
        throw new NextSqlException("Could not retrieve connection.", e);
    }

    ResultSet rs = null;
    Statement stmt = null;
    try {
        DatabaseMetaData dbmd = con.getMetaData();
        rs = dbmd.getProcedureColumns(catalog, schema, procedure, null);
        while (rs.next()) {
            String name = rs.getString("COLUMN_NAME");
            int returnType = rs.getShort("COLUMN_TYPE");
            String retType;
            if (DatabaseMetaData.procedureColumnIn == returnType) {
                retType = ProcUtil.IN;
            } else if (DatabaseMetaData.procedureColumnOut == returnType) {
                retType = ProcUtil.OUT;
            } else if (DatabaseMetaData.procedureColumnInOut == returnType) {
                retType = ProcUtil.INOUT;
            } else if (DatabaseMetaData.procedureColumnReturn == returnType) {
                retType = ProcUtil.VAL;
            } else {
                retType = ProcUtil.OTHER;
            }
            String dataType = rs.getString("TYPE_NAME");
            int length = rs.getInt("LENGTH");
            int precision = rs.getInt("PRECISION");
            int scale = rs.getInt("SCALE");
            DBProcedureColumn col = new DBProcedureColumn(schema, procedure, name, retType, dataType, length,
                    precision, scale);
            columns.add(col);
        }
        return columns;
    } catch (SQLException e) {
        LOG.error(e.getMessage(), e);
        e.printStackTrace();
        throw new NextSqlException("SQL Exception: " + e.getMessage(), e);
    } finally {
        closeResultSet(rs);
        closeStatement(stmt);
    }
}