Example usage for java.sql Statement getResultSet

List of usage examples for java.sql Statement getResultSet

  1. HOME
  2. Java
  3. java
  4. java.sql.*
  5. Statement
  6. getResultSet

Introduction

In this page you can find the example usage for java.sql Statement getResultSet.

Prototype

ResultSet getResultSet() throws SQLException;

Source Link

Document

Retrieves the current result as a ResultSet object.

Usage

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de rcuprer l'historique des termes synonymes d'un terme
 *
 * @param ds// w ww .ja va2s .  com
 * @param idTerm
 * @param idThesaurus
 * @param idLang
 * @return Objet class Concept
 */
public ArrayList<NodeEM> getNonPreferredTermsHistoriqueAll(HikariDataSource ds, String idTerm,
        String idThesaurus, String idLang) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    ArrayList<NodeEM> nodeEMList = null;

    try {
        // Get connection from pool
        conn = ds.getConnection();
        try {
            stmt = conn.createStatement();
            try {
                String query = "SELECT lexical_value, modified, source, status, hiden, action, username FROM non_preferred_term_historique, users"
                        + " WHERE id_term = '" + idTerm + "'" + " and id_thesaurus = '" + idThesaurus + "'"
                        + " and lang ='" + idLang + "'"
                        + " and non_preferred_term_historique.id_user=users.id_user"
                        + " order by modified DESC, lexical_value ASC";

                stmt.executeQuery(query);
                resultSet = stmt.getResultSet();
                if (resultSet != null) {
                    nodeEMList = new ArrayList<>();
                    while (resultSet.next()) {
                        NodeEM nodeEM = new NodeEM();
                        nodeEM.setLexical_value(resultSet.getString("lexical_value"));
                        nodeEM.setModified(resultSet.getDate("modified"));
                        nodeEM.setSource(resultSet.getString("source"));
                        nodeEM.setStatus(resultSet.getString("status"));
                        nodeEM.setHiden(resultSet.getBoolean("hiden"));
                        nodeEM.setAction(resultSet.getString("action"));
                        nodeEM.setIdUser(resultSet.getString("username"));
                        nodeEM.setLang(idLang);
                        nodeEMList.add(nodeEM);
                    }
                }

            } finally {
                stmt.close();
            }
        } finally {
            conn.close();
        }
    } catch (SQLException sqle) {
        // Log exception
        log.error("Error while getting NonPreferedTerm all historique of Term : " + idTerm, sqle);
    }

    return nodeEMList;
}

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de rcuprer la liste de idTermes des 
 * NonPreferredTerm (synonymes) pour un Thsaurus
 * // www . j  av a 2 s  .c  o  m
 * @param ds
 * @param idThesaurus
 * @return  ArrayList (idConcept, idTerm)
 */
public ArrayList<NodeTab2Levels> getAllIdOfNonPreferredTerms(HikariDataSource ds, String idThesaurus) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;

    ArrayList<NodeTab2Levels> tabIdNonPreferredTerm = new ArrayList<>();

    try {
        // Get connection from pool
        conn = ds.getConnection();
        try {
            stmt = conn.createStatement();
            try {
                String query = "SELECT DISTINCT preferred_term.id_concept," + " preferred_term.id_term FROM"
                        + " non_preferred_term, preferred_term WHERE"
                        + " preferred_term.id_term = non_preferred_term.id_term AND"
                        + " preferred_term.id_thesaurus = non_preferred_term.id_thesaurus"
                        + " and non_preferred_term.id_thesaurus = '" + idThesaurus + "'";

                stmt.executeQuery(query);
                resultSet = stmt.getResultSet();
                while (resultSet.next()) {
                    NodeTab2Levels nodeTab2Levels = new NodeTab2Levels();
                    nodeTab2Levels.setIdConcept(resultSet.getString("id_concept"));
                    nodeTab2Levels.setIdTerm(resultSet.getString("id_term"));
                    tabIdNonPreferredTerm.add(nodeTab2Levels);
                }

            } finally {
                stmt.close();
            }
        } finally {
            conn.close();
        }
    } catch (SQLException sqle) {
        // Log exception
        log.error("Error while getting All Id of NonPreferedTerm of Thesaurus : " + idThesaurus, sqle);
    }

    return tabIdNonPreferredTerm;
}

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de retourner toutes les traductions d'un concept
 *
 * @param ds/*ww w .j a va  2  s . c o m*/
 * @param idConcept
 * @param idThesaurus
 * @return Objet class NodeConceptTree
 */
public ArrayList<NodeTermTraduction> getAllTraductionsOfConcept(HikariDataSource ds, String idConcept,
        String idThesaurus) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    ArrayList<NodeTermTraduction> nodeTraductionsList = new ArrayList<>();

    try {
        // Get connection from pool
        conn = ds.getConnection();
        try {
            stmt = conn.createStatement();
            try {
                String query = "SELECT term.id_term, term.lexical_value, term.lang FROM"
                        + " term, preferred_term WHERE" + " term.id_term = preferred_term.id_term"
                        + " and term.id_thesaurus = preferred_term.id_thesaurus"
                        + " and preferred_term.id_concept = '" + idConcept + "'" + " and term.id_thesaurus = '"
                        + idThesaurus + "'" + " order by term.lexical_value";

                stmt.executeQuery(query);
                resultSet = stmt.getResultSet();
                while (resultSet.next()) {
                    NodeTermTraduction nodeTraductions = new NodeTermTraduction();
                    nodeTraductions.setLang(resultSet.getString("lang"));
                    nodeTraductions.setLexicalValue(resultSet.getString("lexical_value"));
                    nodeTraductionsList.add(nodeTraductions);
                }
            } finally {
                stmt.close();
            }
        } finally {
            conn.close();
        }
    } catch (SQLException sqle) {
        // Log exception
        log.error("Error while getting All Traductions of Concept  : " + idConcept, sqle);
    }
    return nodeTraductionsList;
}

From source file:org.apache.hive.jdbc.TestJdbcDriver2.java

private void doTestSelectAll(String tableName, int maxRows, int fetchSize) throws Exception {
    boolean isPartitionTable = tableName.equals(partitionedTableName);

    Statement stmt = con.createStatement();
    if (maxRows >= 0) {
        stmt.setMaxRows(maxRows);/*from www .j a va2s  .  com*/
    }
    if (fetchSize > 0) {
        stmt.setFetchSize(fetchSize);
        assertEquals(fetchSize, stmt.getFetchSize());
    }

    // JDBC says that 0 means return all, which is the default
    int expectedMaxRows = maxRows < 1 ? 0 : maxRows;

    assertNotNull("Statement is null", stmt);
    assertEquals("Statement max rows not as expected", expectedMaxRows, stmt.getMaxRows());
    assertFalse("Statement should not be closed", stmt.isClosed());

    ResultSet res;

    // run some queries
    res = stmt.executeQuery("select * from " + tableName);
    assertNotNull("ResultSet is null", res);
    assertTrue("getResultSet() not returning expected ResultSet", res == stmt.getResultSet());
    assertEquals("get update count not as expected", -1, stmt.getUpdateCount());
    int i = 0;

    ResultSetMetaData meta = res.getMetaData();
    int expectedColCount = isPartitionTable ? 3 : 2;
    assertEquals("Unexpected column count", expectedColCount, meta.getColumnCount());

    boolean moreRow = res.next();
    while (moreRow) {
        try {
            i++;
            assertEquals(res.getInt(1), res.getInt(tableName + ".under_col"));
            assertEquals(res.getInt(1), res.getInt("under_col"));
            assertEquals(res.getString(1), res.getString(tableName + ".under_col"));
            assertEquals(res.getString(1), res.getString("under_col"));
            assertEquals(res.getString(2), res.getString(tableName + ".value"));
            assertEquals(res.getString(2), res.getString("value"));
            if (isPartitionTable) {
                assertEquals(res.getString(3), partitionedColumnValue);
                assertEquals(res.getString(3), res.getString(partitionedColumnName));
                assertEquals(res.getString(3), res.getString(tableName + "." + partitionedColumnName));
            }
            assertFalse("Last result value was not null", res.wasNull());
            assertNull("No warnings should be found on ResultSet", res.getWarnings());
            res.clearWarnings(); // verifying that method is supported

            // System.out.println(res.getString(1) + " " + res.getString(2));
            assertEquals("getInt and getString don't align for the same result value",
                    String.valueOf(res.getInt(1)), res.getString(1));
            assertEquals("Unexpected result found", "val_" + res.getString(1), res.getString(2));
            moreRow = res.next();
        } catch (SQLException e) {
            System.out.println(e.toString());
            e.printStackTrace();
            throw new Exception(e.toString());
        }
    }

    // supposed to get 500 rows if maxRows isn't set
    int expectedRowCount = maxRows > 0 ? maxRows : 500;
    assertEquals("Incorrect number of rows returned", expectedRowCount, i);

    // should have no more rows
    assertEquals(false, moreRow);

    assertNull("No warnings should be found on statement", stmt.getWarnings());
    stmt.clearWarnings(); // verifying that method is supported

    assertNull("No warnings should be found on connection", con.getWarnings());
    con.clearWarnings(); // verifying that method is supported

    stmt.close();
    assertTrue("Statement should be closed", stmt.isClosed());
}

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de rcuprer l'historique des termes synonymes d'un terme  une date prcise
 *
 * @param ds// ww  w  . j  a  v a2  s .  com
 * @param idTerm
 * @param idThesaurus
 * @param idLang
 * @param date
 * @return Objet class Concept
 */
public ArrayList<NodeEM> getNonPreferredTermsHistoriqueFromDate(HikariDataSource ds, String idTerm,
        String idThesaurus, String idLang, Date date) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    ArrayList<NodeEM> nodeEMList = null;

    try {
        // Get connection from pool
        conn = ds.getConnection();
        try {
            stmt = conn.createStatement();
            try {
                String query = "SELECT lexical_value, modified, source, status, hiden, action, username FROM non_preferred_term_historique, users"
                        + " WHERE id_term = '" + idTerm + "'" + " and id_thesaurus = '" + idThesaurus + "'"
                        + " and lang ='" + idLang + "'"
                        + " and non_preferred_term_historique.id_user=users.id_user" + " and modified <= '"
                        + date.toString() + "' order by modified, lexical_value ASC";

                stmt.executeQuery(query);
                resultSet = stmt.getResultSet();
                if (resultSet != null) {
                    nodeEMList = new ArrayList<>();
                    while (resultSet.next()) {
                        if (resultSet.getString("action").equals("DEL")) {
                            for (NodeEM nem : nodeEMList) {
                                if (nem.getLexical_value().equals(resultSet.getString("lexical_value"))
                                        && nem.getAction().equals("ADD")
                                        && nem.getStatus().equals(resultSet.getString("status"))) {
                                    nodeEMList.remove(nem);
                                    break;
                                }
                            }
                        } else {
                            NodeEM nodeEM = new NodeEM();
                            nodeEM.setLexical_value(resultSet.getString("lexical_value"));
                            nodeEM.setModified(resultSet.getDate("modified"));
                            nodeEM.setSource(resultSet.getString("source"));
                            nodeEM.setStatus(resultSet.getString("status"));
                            nodeEM.setHiden(resultSet.getBoolean("hiden"));
                            nodeEM.setAction(resultSet.getString("action"));
                            nodeEM.setIdUser(resultSet.getString("username"));
                            nodeEM.setLang(idLang);
                            nodeEMList.add(nodeEM);
                        }

                    }
                }

            } finally {
                stmt.close();
            }
        } finally {
            conn.close();
        }
    } catch (SQLException sqle) {
        // Log exception
        log.error("Error while getting NonPreferedTerm date historique of Term : " + idTerm, sqle);
    }

    return nodeEMList;
}

From source file:mom.trd.opentheso.bdd.helper.CandidateHelper.java

/**
 * $$$$$$$ deprecated $$$$$$$/*from  w ww .  j  a v  a 2  s .  c o  m*/
 * Cette fonction permet de rcuprer la liste des candidats
 * 
 * @param ds
 * @param idConcept
 * @param idThesaurus
 * @param idLang
 * @return Objet class NodeCandidatValue
 */
public NodeCandidatValue getThisCandidatList(HikariDataSource ds, String idConcept, String idThesaurus,
        String idLang) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    NodeCandidatValue nodeCandidatList = null;

    if (isTraductionExistOfCandidat(ds, idConcept, idThesaurus, idLang)) {
        try {
            // Get connection from pool
            conn = ds.getConnection();
            try {
                stmt = conn.createStatement();
                try {
                    String query = "SELECT DISTINCT term_candidat.lexical_value,"
                            + " concept_candidat.status FROM"
                            + " term_candidat, concept_term_candidat, concept_candidat"
                            + " WHERE concept_term_candidat.id_term = term_candidat.id_term"
                            + " and concept_term_candidat.id_concept = concept_candidat.id_concept"
                            + " and concept_term_candidat.id_concept ='" + idConcept + "'"
                            + " and term_candidat.lang = '" + idLang + "'"
                            + " and term_candidat.id_thesaurus = '" + idThesaurus + "'"
                            + " order by lexical_value DESC";

                    stmt.executeQuery(query);
                    resultSet = stmt.getResultSet();
                    if (resultSet != null) {

                        while (resultSet.next()) {
                            nodeCandidatList = new NodeCandidatValue();
                            nodeCandidatList.setValue(resultSet.getString("lexical_value"));
                            nodeCandidatList.setIdConcept(idConcept);
                            nodeCandidatList.setEtat(resultSet.getString("status"));
                            nodeCandidatList.setNbProp(getNbPropCandidat(ds, idThesaurus, idConcept));
                        }
                    }

                } finally {
                    stmt.close();
                }
            } finally {
                conn.close();
            }
        } catch (SQLException sqle) {
            // Log exception
            log.error("Error while getting Concept : " + idConcept, sqle);
        }
    } else {
        try {
            // Get connection from pool
            conn = ds.getConnection();
            try {
                stmt = conn.createStatement();
                try {
                    String query = "SELECT concept_candidat.id_concept," + " concept_candidat.status FROM"
                            + " concept_candidat" + " WHERE concept_candidat.id_concept ='" + idConcept + "'"
                            + " and concept_candidat.id_thesaurus = '" + idThesaurus + "'";

                    stmt.executeQuery(query);
                    resultSet = stmt.getResultSet();
                    if (resultSet != null) {
                        while (resultSet.next()) {
                            nodeCandidatList = new NodeCandidatValue();
                            nodeCandidatList.setValue("");
                            nodeCandidatList.setIdConcept(idConcept);
                            nodeCandidatList.setEtat(resultSet.getString("status"));
                            nodeCandidatList.setNbProp(getNbPropCandidat(ds, idThesaurus, idConcept));
                        }
                    }

                } finally {
                    stmt.close();
                }
            } finally {
                conn.close();
            }
        } catch (SQLException sqle) {
            // Log exception
            log.error("Error while getting Concept : " + idConcept, sqle);
        }

    }
    return nodeCandidatList;
}

From source file:org.kawanfw.sql.servlet.sql.ServerStatementRawExecute.java

/**
 * Execute the passed SQL Statement as execute(sql) and return: <br>
 * - The result set as a List of Maps for SELECT statements. <br>
 * - The return code for other statements
 * /*from w  w w.jav a 2s.com*/
 * @param sqlOrder
 *            the qsql order
 * @param sqlParms
 *            the sql parameters
 * @param out
 *            the output stream where to write to result set output
 * 
 * 
 * @throws SQLException
 */
private void executeStatement(OutputStream out) throws SQLException, IOException {

    String sqlOrder = statementHolder.getSqlOrder();

    // sqlOrder = HtmlConverter.fromHtml(sqlOrder);

    // Should never be called?
    if (statementHolder.isDoExtractResultSetMetaData()) {
        sqlOrder = DbVendorManager.addLimit1(sqlOrder, connection);
    }

    Statement statement = null;

    try {

        if (!SqlConfiguratorCall.allowExecute(sqlConfigurator, username, connection)) {
            String ipAddress = request.getRemoteAddr();

            SqlConfiguratorCall.runIfStatementRefused(sqlConfigurator, username, connection, ipAddress,
                    sqlOrder, new Vector<Object>());

            String message = Tag.PRODUCT_SECURITY + " [" + "{Statement not authorized for execute}"
                    + "{sql order : " + sqlOrder + "}" + "]";

            throw new SecurityException(message);
        }

        statement = connection.createStatement();
        ServerSqlUtil.setStatementProperties(statement, statementHolder);

        debug("before ServerPreparedStatementParameters");

        boolean isAllowed = sqlConfigurator.allowStatementAfterAnalysis(username, connection, sqlOrder,
                new Vector<Object>());

        if (!isAllowed) {

            String ipAddress = request.getRemoteAddr();

            SqlConfiguratorCall.runIfStatementRefused(sqlConfigurator, username, connection, ipAddress,
                    sqlOrder, new Vector<Object>());

            String message = Tag.PRODUCT_SECURITY + " [" + "{Statement not authorized}" + "{sql order: "
                    + sqlOrder + "}]";

            throw new SecurityException(message);
        }

        debug("before statement.execute(sqlOrder)");
        debug("sqlOrder: " + sqlOrder);

        ServerSqlUtil.setMaxRowsToReturn(statement, sqlConfigurator);

        boolean isResultSet = false;

        boolean usesAutoGeneratedKeys = false;

        if (statementHolder.getAutoGeneratedKeys() != -1) {
            isResultSet = statement.execute(sqlOrder, statementHolder.getAutoGeneratedKeys());
            usesAutoGeneratedKeys = true;
        } else if (statementHolder.getColumnIndexesAutogenerateKeys().length != 0) {
            isResultSet = statement.execute(sqlOrder, statementHolder.getColumnIndexesAutogenerateKeys());
            usesAutoGeneratedKeys = true;
        } else if (statementHolder.getColumnNamesAutogenerateKeys().length != 0) {
            isResultSet = statement.execute(sqlOrder, statementHolder.getColumnNamesAutogenerateKeys());
            usesAutoGeneratedKeys = true;
        } else {
            debug("before isResultSet = statement.execute(sqlOrder);");
            isResultSet = statement.execute(sqlOrder);
        }

        debug("isResultSet          :" + isResultSet);
        debug("usesAutoGeneratedKeys: " + usesAutoGeneratedKeys);

        if (isResultSet) {
            ResultSet rs = statement.getResultSet();

            try {

                //br.write(TransferStatus.SEND_OK + CR_LF);
                ServerSqlManager.writeLine(out, TransferStatus.SEND_OK);

                ResultSetWriter resultSetWriter = new ResultSetWriter(request, out, commonsConfigurator,
                        fileConfigurator, sqlConfigurator, username, sqlOrder, statementHolder);

                resultSetWriter.write(rs);
            } finally {
                if (rs != null)
                    rs.close();
            }
        } else {

            debug("int rc = statement.getUpdateCount();");
            int rc = statement.getUpdateCount();

            //br.write(TransferStatus.SEND_OK + CR_LF);
            //br.write("getUpdateCount=" + rc + CR_LF);
            ServerSqlManager.writeLine(out, TransferStatus.SEND_OK);
            ServerSqlManager.writeLine(out, "getUpdateCount=" + rc);

            if (usesAutoGeneratedKeys) {
                ResultSet rs = statement.getGeneratedKeys();

                try {
                    ResultSetWriter resultSetWriter = new ResultSetWriter(request, out, commonsConfigurator,
                            fileConfigurator, sqlConfigurator, username, sqlOrder, statementHolder);
                    resultSetWriter.write(rs);
                } finally {
                    if (rs != null)
                        rs.close();
                }
            }
        }

    } catch (SQLException e) {
        ServerLogger.getLogger().log(Level.WARNING, Tag.PRODUCT_PRODUCT_FAIL + CR_LF + "Statement: " + sqlOrder
                + CR_LF + "- sql order: " + sqlOrder + CR_LF + "- exception: " + e.toString());
        throw e;
    } finally {
        IOUtils.closeQuietly(out);

        if (statement != null) {
            statement.close();
        }
    }
}

From source file:com.alibaba.wasp.jdbc.TestPreparedStatement.java

public void testDataTypes() throws SQLException {
    conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
    conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
    Statement stat = conn.createStatement();
    PreparedStatement prep;//from   w ww  . j av  a  2s .c om
    ResultSet rs;
    trace("Create tables");
    stat.execute("CREATE TABLE T_INT(ID INT PRIMARY KEY,VALUE INT)");
    stat.execute("CREATE TABLE T_VARCHAR(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
    stat.execute("CREATE TABLE T_DECIMAL_0(ID INT PRIMARY KEY,VALUE DECIMAL(30,0))");
    stat.execute("CREATE TABLE T_DECIMAL_10(ID INT PRIMARY KEY,VALUE DECIMAL(20,10))");
    stat.execute("CREATE TABLE T_DATETIME(ID INT PRIMARY KEY,VALUE DATETIME)");
    prep = conn.prepareStatement("INSERT INTO T_INT VALUES(?,?)", ResultSet.TYPE_FORWARD_ONLY,
            ResultSet.CONCUR_READ_ONLY);
    prep.setInt(1, 1);
    prep.setInt(2, 0);
    prep.executeUpdate();
    prep.setInt(1, 2);
    prep.setInt(2, -1);
    prep.executeUpdate();
    prep.setInt(1, 3);
    prep.setInt(2, 3);
    prep.executeUpdate();
    prep.setInt(1, 4);
    prep.setNull(2, Types.INTEGER);
    prep.executeUpdate();
    prep.setInt(1, 5);
    prep.setBigDecimal(2, new BigDecimal("0"));
    prep.executeUpdate();
    prep.setInt(1, 6);
    prep.setString(2, "-1");
    prep.executeUpdate();
    prep.setInt(1, 7);
    prep.setObject(2, new Integer(3));
    prep.executeUpdate();
    prep.setObject(1, "8");
    // should throw an exception
    prep.setObject(2, null);
    // some databases don't allow calling setObject with null (no data type)
    prep.executeUpdate();
    prep.setInt(1, 9);
    prep.setObject(2, -4, Types.VARCHAR);
    prep.executeUpdate();
    prep.setInt(1, 10);
    prep.setObject(2, "5", Types.INTEGER);
    prep.executeUpdate();
    prep.setInt(1, 11);
    prep.setObject(2, null, Types.INTEGER);
    prep.executeUpdate();
    prep.setInt(1, 12);
    prep.setBoolean(2, true);
    prep.executeUpdate();
    prep.setInt(1, 13);
    prep.setBoolean(2, false);
    prep.executeUpdate();
    prep.setInt(1, 14);
    prep.setByte(2, (byte) -20);
    prep.executeUpdate();
    prep.setInt(1, 15);
    prep.setByte(2, (byte) 100);
    prep.executeUpdate();
    prep.setInt(1, 16);
    prep.setShort(2, (short) 30000);
    prep.executeUpdate();
    prep.setInt(1, 17);
    prep.setShort(2, (short) (-30000));
    prep.executeUpdate();
    prep.setInt(1, 18);
    prep.setLong(2, Integer.MAX_VALUE);
    prep.executeUpdate();
    prep.setInt(1, 19);
    prep.setLong(2, Integer.MIN_VALUE);
    prep.executeUpdate();

    assertTrue(stat.execute("SELECT * FROM T_INT ORDER BY ID"));
    rs = stat.getResultSet();
    assertResultSetOrdered(rs,
            new String[][] { { "1", "0" }, { "2", "-1" }, { "3", "3" }, { "4", null }, { "5", "0" },
                    { "6", "-1" }, { "7", "3" }, { "8", null }, { "9", "-4" }, { "10", "5" }, { "11", null },
                    { "12", "1" }, { "13", "0" }, { "14", "-20" }, { "15", "100" }, { "16", "30000" },
                    { "17", "-30000" }, { "18", "" + Integer.MAX_VALUE }, { "19", "" + Integer.MIN_VALUE }, });

    prep = conn.prepareStatement("INSERT INTO T_DECIMAL_0 VALUES(?,?)");
    prep.setInt(1, 1);
    prep.setLong(2, Long.MAX_VALUE);
    prep.executeUpdate();
    prep.setInt(1, 2);
    prep.setLong(2, Long.MIN_VALUE);
    prep.executeUpdate();
    prep.setInt(1, 3);
    prep.setFloat(2, 10);
    prep.executeUpdate();
    prep.setInt(1, 4);
    prep.setFloat(2, -20);
    prep.executeUpdate();
    prep.setInt(1, 5);
    prep.setFloat(2, 30);
    prep.executeUpdate();
    prep.setInt(1, 6);
    prep.setFloat(2, -40);
    prep.executeUpdate();

    rs = stat.executeQuery("SELECT VALUE FROM T_DECIMAL_0 ORDER BY ID");
    checkBigDecimal(rs, new String[] { "" + Long.MAX_VALUE, "" + Long.MIN_VALUE, "10", "-20", "30", "-40" });
}

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de rcuprer les termes synonymes suivant un
 * id_term et son thsaurus et sa langue sous forme de classe NodeEM
 *
 * @param ds/*from   ww  w . ja  va 2 s  . co  m*/
 * @param idTerm
 * @param idThesaurus
 * @return Objet class Concept
 */
public ArrayList<NodeEM> getAllNonPreferredTerms(HikariDataSource ds, String idTerm, String idThesaurus) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    ArrayList<NodeEM> nodeEMList = null;

    try {
        // Get connection from pool
        conn = ds.getConnection();
        try {
            stmt = conn.createStatement();
            try {
                String query = "SELECT non_preferred_term.lexical_value," + " non_preferred_term.created,"
                        + " non_preferred_term.modified," + " non_preferred_term.source,"
                        + " non_preferred_term.status," + " non_preferred_term.hiden,"
                        + " non_preferred_term.lang" + " FROM term, non_preferred_term WHERE"
                        + " term.id_term = non_preferred_term.id_term AND"
                        + " term.lang = non_preferred_term.lang AND"
                        + " term.id_thesaurus = non_preferred_term.id_thesaurus"
                        + " and non_preferred_term.id_term = '" + idTerm + "'"
                        + " and non_preferred_term.id_thesaurus = '" + idThesaurus + "'"
                        + " order by lexical_value ASC";

                stmt.executeQuery(query);
                resultSet = stmt.getResultSet();
                if (resultSet != null) {
                    nodeEMList = new ArrayList<>();
                    while (resultSet.next()) {
                        NodeEM nodeEM = new NodeEM();
                        nodeEM.setLexical_value(resultSet.getString("lexical_value"));
                        nodeEM.setCreated(resultSet.getDate("created"));
                        nodeEM.setModified(resultSet.getDate("modified"));
                        nodeEM.setSource(resultSet.getString("source"));
                        nodeEM.setStatus(resultSet.getString("status"));
                        nodeEM.setHiden(resultSet.getBoolean("hiden"));
                        nodeEM.setLang(resultSet.getString("lang"));
                        nodeEMList.add(nodeEM);
                    }
                }

            } finally {
                stmt.close();
            }
        } finally {
            conn.close();
        }
    } catch (SQLException sqle) {
        // Log exception
        log.error("Error while getting NonPreferedTerm of Term : " + idTerm, sqle);
    }

    return nodeEMList;
}

From source file:mom.trd.opentheso.bdd.helper.TermHelper.java

/**
 * Cette fonction permet de rcuprer un Term par son id et son thsaurus et
 * sa langue sous forme de classe Term (sans les relations)
 *
 * @param ds//  w  w w . j a  va  2  s. com
 * @param idConcept
 * @param idThesaurus
 * @param idLang
 * @return Objet class Concept
 */
public Term getThisTerm(HikariDataSource ds, String idConcept, String idThesaurus, String idLang) {

    Connection conn;
    Statement stmt;
    ResultSet resultSet;
    Term term = null;

    if (isTraductionExistOfConcept(ds, idConcept, idThesaurus, idLang)) {
        try {
            // Get connection from pool
            conn = ds.getConnection();
            try {
                stmt = conn.createStatement();
                try {
                    String query = "SELECT term.* FROM term, preferred_term"
                            + " WHERE preferred_term.id_term = term.id_term"
                            + " and preferred_term.id_thesaurus = term.id_thesaurus"
                            + " and preferred_term.id_concept ='" + idConcept + "'" + " and term.lang = '"
                            + idLang + "'" + " and term.id_thesaurus = '" + idThesaurus + "'"
                            + " order by lexical_value DESC";

                    /* query = "select * from term where id_concept = '"
                     + idConcept + "'"
                     + " and id_thesaurus = '" + idThesaurus + "'"
                     + " and lang = '" + idLang + "'"
                     + " and prefered = true";*/
                    stmt.executeQuery(query);
                    resultSet = stmt.getResultSet();
                    if (resultSet != null) {
                        resultSet.next();
                        term = new Term();
                        term.setId_term(resultSet.getString("id_term"));
                        term.setLexical_value(resultSet.getString("lexical_value"));
                        term.setLang(idLang);
                        term.setId_thesaurus(idThesaurus);
                        term.setCreated(resultSet.getDate("created"));
                        term.setModified(resultSet.getDate("modified"));
                        term.setSource(resultSet.getString("source"));
                        term.setStatus(resultSet.getString("status"));
                        term.setContributor(resultSet.getInt("contributor"));
                        term.setCreator(resultSet.getInt("creator"));
                    }

                } finally {
                    stmt.close();
                }
            } finally {
                conn.close();
            }
        } catch (SQLException sqle) {
            // Log exception
            log.error("Error while getting Concept : " + idConcept, sqle);
        }
    } else {
        try {
            // Get connection from pool
            conn = ds.getConnection();
            try {
                stmt = conn.createStatement();
                try {
                    String query = "select * from concept where id_concept = '" + idConcept + "'"
                            + " and id_thesaurus = '" + idThesaurus + "'";

                    stmt.executeQuery(query);
                    resultSet = stmt.getResultSet();
                    if (resultSet.next()) {
                        term = new Term();
                        term.setId_term("");
                        term.setLexical_value("");
                        term.setLang(idLang);
                        term.setId_thesaurus(idThesaurus);
                        term.setCreated(resultSet.getDate("created"));
                        term.setModified(resultSet.getDate("modified"));
                        term.setStatus(resultSet.getString("status"));
                    }

                } finally {
                    stmt.close();
                }
            } finally {
                conn.close();
            }
        } catch (SQLException sqle) {
            // Log exception
            log.error("Error while getting Concept : " + idConcept, sqle);
        }

    }

    return term;
}