private void testUpdateResetRead() throws SQLException {
    Connection conn = getConnection();
    Statement stat =
        conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
    stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
    stat.execute("INSERT INTO TEST VALUES(1, 'Hello')");
    stat.execute("INSERT INTO TEST VALUES(2, 'World')");
    ResultSet rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
    rs.next();
    rs.updateInt(1, 10);
    rs.updateRow();
    rs.next();

    rs.updateString(2, "Welt");
    rs.cancelRowUpdates();
    rs.updateString(2, "Welt");

    rs.updateRow();
    rs.beforeFirst();
    rs.next();
    assertEquals(10, rs.getInt(1));
    assertEquals("Hello", rs.getString(2));
    rs.next();
    assertEquals(2, rs.getInt(1));
    assertEquals("Welt", rs.getString(2));

    assertFalse(rs.isClosed());
    rs.close();
    assertTrue(rs.isClosed());

    conn.close();
  }
Esempio n. 2
0
 /**
  * @Description: 在源库中查找最新的期号
  *
  * @author songjia
  * @date Feb 15, 2016 3:29:13 PM
  * @return
  */
 public SrcDataBean getRecordByIssueNumber(String issueNumber) {
   Connection srcConn = ConnectSrcDb.getSrcConnection();
   PreparedStatement pstmt = null;
   SrcDataBean srcDataBean = null;
   String sql =
       "SELECT issue_number,no1,no2,no3 FROM "
           + App.srcNumberTbName
           + " WHERE ISSUE_NUMBER = '"
           + issueNumber
           + "'";
   try {
     pstmt = (PreparedStatement) srcConn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery();
     while (rs.next()) {
       srcDataBean = new SrcDataBean();
       srcDataBean.setIssueId(rs.getString(1));
       srcDataBean.setNo1(rs.getInt(2));
       srcDataBean.setNo2(rs.getInt(3));
       srcDataBean.setNo3(rs.getInt(4));
     }
     if (rs != null && !rs.isClosed()) {
       rs.close();
     }
   } catch (SQLException e) {
     LogUtil.error(e.getMessage(), "sima");
   }
   return srcDataBean;
 }
  @Override
  public NotificationGroup processSingleResultAllColumns(ResultSet resultSet) {

    try {
      if ((resultSet == null) || resultSet.isClosed()) {
        return null;
      }

      Integer id = resultSet.getInt("ID");
      if (resultSet.wasNull()) id = null;

      String name = resultSet.getString("NAME");
      if (resultSet.wasNull()) name = null;

      String uppercaseName = resultSet.getString("UPPERCASE_NAME");
      if (resultSet.wasNull()) uppercaseName = null;

      String emailAddresses = resultSet.getString("EMAIL_ADDRESSES");
      if (resultSet.wasNull()) emailAddresses = null;

      NotificationGroup notificationGroup =
          new NotificationGroup(id, name, uppercaseName, emailAddresses);

      return notificationGroup;
    } catch (Exception e) {
      logger.error(e.toString() + System.lineSeparator() + StackTrace.getStringFromStackTrace(e));
      return null;
    }
  }
  public List<Produit> getAllProduit() {
    Connection conn = new ConnectionInit().getCon();
    ResultSet rs = null;
    List<Produit> prods = new ArrayList<Produit>();

    String sql = "SELECT * FROM aphrodis.produit";
    try {
      rs = conn.createStatement().executeQuery(sql);
      while (rs.next()) {
        Produit prod = new Produit(rs.getInt(1), rs.getString(2), rs.getDouble(3));
        prods.add(prod);
      }
      return prods;
    } catch (SQLException ex) {
      Logger.getLogger(ProduitDAOImpl.class.getName()).log(Level.SEVERE, null, ex);
      return null;
    } finally {
      try {
        if (!rs.isClosed()) {
          rs.close();
        }
        if (!conn.isClosed()) {
          conn.close();
        }
      } catch (SQLException ex) {
        Logger.getLogger(ProduitDAOImpl.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
  }
 public Produit getProduitById(int id) {
   Connection conn = new ConnectionInit().getCon();
   ResultSet rs = null;
   Produit produit = null;
   String sql = "SELECT * FROM aphrodis.produit WHERE id = '" + id + "'";
   try {
     rs = conn.createStatement().executeQuery(sql);
     while (rs.next()) {
       produit = new Produit(rs.getInt(1), rs.getString(2), rs.getDouble(3));
     }
     return produit;
   } catch (SQLException ex) {
     Logger.getLogger(ProduitDAOImpl.class.getName()).log(Level.SEVERE, null, ex);
     return null;
   } finally {
     try {
       if (!rs.isClosed()) {
         rs.close();
       }
       if (!conn.isClosed()) {
         conn.close();
       }
     } catch (SQLException ex) {
       Logger.getLogger(UserDAOImpl.class.getName()).log(Level.SEVERE, null, ex);
     }
   }
 }
Esempio n. 6
0
  public ResultSet executePreparedStatement() {
    try {
      if ((connection_ == null) || (preparedStatement_ == null)) {
        return null;
      }

      if (results_ != null) {
        if (!results_.isClosed()) {
          logger.error(
              "Cannot execute PreparedStatement - DatabaseInterface already has an open ResultSet");
          return null;
        }
      }

      setPreparedStatementParameters();

      boolean result = preparedStatement_.execute();

      if (result) {
        results_ = preparedStatement_.getResultSet();
      }

      didPreparedStatementExecuteSuccessfully_ = true;
      return results_;
    } catch (Exception e) {
      didPreparedStatementExecuteSuccessfully_ = false;
      logger.error(e.toString() + System.lineSeparator() + StackTrace.getStringFromStackTrace(e));
      return null;
    }
  }
Esempio n. 7
0
  public boolean executeBatchPreparedStatement() {
    try {
      if ((connection_ == null) || (preparedStatement_ == null)) {
        return false;
      }

      if (results_ != null) {
        if (!results_.isClosed()) {
          logger.error(
              "Cannot execute PreparedStatement - DatabaseInterface already has an open ResultSet");
          return false;
        }
      }

      int[] results = preparedStatement_.executeBatch();

      if (results == null || (results.length == 0)) {
        logger.warn("PreparedStatement_ExecuteBatch command did not execute any statements");
      } else {
        for (int resultIndex : results) {
          if (results[resultIndex] == PreparedStatement.EXECUTE_FAILED) {
            logger.error("PreparedStatement executeBatch failed");
            return false;
          }
        }
      }
      return true;
    } catch (Exception e) {
      logger.error(e.toString() + System.lineSeparator() + StackTrace.getStringFromStackTrace(e));
      return false;
    }
  }
Esempio n. 8
0
 @Override
 public List<Map<String, String>> getTableNames(
     RDBMSConnection rdbmsConnection, String tableSearchString) {
   List<Map<String, String>> returnList = new LinkedList<Map<String, String>>();
   Connection connection = null;
   ResultSet rs = null;
   try {
     connection = getSQLConnection(rdbmsConnection);
     rs = connection.getMetaData().getTables(null, null, "%" + tableSearchString + "%", null);
     while (rs.next()) {
       Map<String, String> rowResults = new HashMap<String, String>();
       rowResults.put("schema", rs.getString("TABLE_SCHEM"));
       rowResults.put("catalog", rs.getString("TABLE_CAT"));
       rowResults.put("name", rs.getString("TABLE_NAME"));
       rowResults.put("type", rs.getString("TABLE_TYPE"));
       returnList.add(rowResults);
       if (returnList.size() == 10) break;
     }
   } catch (ClassNotFoundException e) {
     logger.error("Probably JDBC driver is not found", e);
   } catch (SQLException e) {
     logger.error("An error occured during establishing connection and getting table names", e);
   } finally {
     try {
       if (connection != null && !connection.isClosed()) connection.close();
       if (rs != null && !rs.isClosed()) rs.close();
     } catch (SQLException e) {
       logger.error("Error occurred when closing sql objects", e);
     }
   }
   return returnList;
 }
Esempio n. 9
0
 @Override
 public List<String> getSampleValues(RDBMSInformationTarget rdbmsInformationTarget) {
   List<String> returnList = new LinkedList<String>();
   Connection connection = null;
   Statement statement = null;
   ResultSet rs = null;
   try {
     connection = getSQLConnection(rdbmsInformationTarget.getRdbmsConnection());
     statement = connection.createStatement();
     rs = getValues(rdbmsInformationTarget, statement, null);
     while (rs.next()) {
       Object obj = rs.getObject(1);
       String stringValue = obj.toString();
       returnList.add(stringValue);
       if (returnList.size() == 10) break;
     }
   } catch (ClassNotFoundException e) {
     logger.error("Probably JDBC driver is not found", e);
   } catch (SQLException e) {
     logger.error("An error occured during establishing connection and getting sample values", e);
   } finally {
     try {
       if (connection != null && !connection.isClosed()) connection.close();
       if (statement != null && !statement.isClosed()) statement.close();
       if (rs != null && !rs.isClosed()) rs.close();
     } catch (SQLException e) {
       logger.error("Error occurred when closing sql objects", e);
     }
   }
   return returnList;
 }
Esempio n. 10
0
 public static void closeResultSet(ResultSet res) {
   try {
     if ((res != null) && (res.isClosed() == false)) res.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Esempio n. 11
0
 /**
  * @Description: 在源库中查找最新的预测计划,并保证期号在预测范围内,否则报错
  *
  * @author [email protected]
  * @date Feb 15, 2016 3:29:13 PM
  * @return
  */
 public Fast3SiMa getSiMaYuceRecordByIssueCode(String issueNumber) {
   Connection srcConn = ConnectSrcDb.getSrcConnection();
   PreparedStatement pstmt = null;
   Fast3SiMa data = null;
   String sql =
       "SELECT ID,YUCE_ISSUE_START,YUCE_ISSUE_STOP,DROWN_PLAN,DROWN_CYCLE,DROWN_ISSUE_NUMBER  FROM "
           + App.simaTbName
           + " WHERE "
           + issueNumber
           + " BETWEEN YUCE_ISSUE_START AND YUCE_ISSUE_STOP   ORDER BY ID DESC LIMIT 1";
   try {
     pstmt = (PreparedStatement) srcConn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery();
     while (rs.next()) {
       data = new Fast3SiMa();
       data.setId(rs.getInt(1));
       data.setYuceIssueStart(rs.getString(2));
       data.setYuceIssueStop(rs.getString(3));
       data.setDrownPlan(rs.getString(4));
       data.setDrownCycle(rs.getInt(5));
       data.setDrownIssueNumber(rs.getString(6));
     }
     if (rs != null && !rs.isClosed()) {
       rs.close();
     }
   } catch (SQLException e) {
     LogUtil.error(e.getMessage(), "sima");
   }
   return data;
 }
 /**
  * Executes a prepared statement.
  *
  * @param signature Parsed statement
  * @return as specified by {@link java.sql.Statement#execute(String)}
  * @throws java.sql.SQLException if a database error occurs
  */
 protected boolean executeInternal(Meta.Signature signature) throws SQLException {
   ResultSet resultSet = executeQueryInternal(signature);
   // user may have cancelled the query
   if (resultSet.isClosed()) {
     return false;
   }
   return true;
 }
 @Override
 public boolean isClosed() throws SQLException {
   try {
     return _res.isClosed();
   } catch (SQLException e) {
     handleException(e);
     return false;
   }
 }
 @Override
 public ResultSet executeQuery(final String sql) throws SQLException {
   if (null != currentResultSet && !currentResultSet.isClosed()) {
     currentResultSet.close();
   }
   currentResultSet =
       ResultSetFactory.getResultSet(generateExecutor(sql).executeQuery(), mergeContext);
   return currentResultSet;
 }
Esempio n. 15
0
 public boolean isResultSetValid() {
   try {
     if ((results_ == null) || results_.isClosed()) {
       return false;
     } else {
       return true;
     }
   } catch (Exception e) {
     logger.error(e.toString() + System.lineSeparator() + StackTrace.getStringFromStackTrace(e));
     return false;
   }
 }
Esempio n. 16
0
 public void closeTResultSet() {
   if (LOG.isDebugEnabled())
     LOG.debug(serverWorkerName + ". T2 rs.close(" + stmtLabel + ") begin");
   try {
     if (rs != null && rs.isClosed() == false) {
       if (LOG.isDebugEnabled()) LOG.debug(serverWorkerName + ". T2 rs before close ");
       rs.close();
       if (LOG.isDebugEnabled()) LOG.debug(serverWorkerName + ". T2 rs after close ");
     }
   } catch (Exception e) {
   }
   rs = null;
   if (LOG.isDebugEnabled()) LOG.debug(serverWorkerName + ". T2 rs.close(" + stmtLabel + ") end");
 }
Esempio n. 17
0
 public int getNumberOfCharacters(int accountId) {
   PreparedStatement preparedStatement;
   int characters = 0;
   try {
     preparedStatement =
         databaseConnection.preparedStatement(
             "SELECT * FROM characters WHERE \"accountId\"=" + accountId + "");
     ResultSet resultSet = preparedStatement.executeQuery();
     while (resultSet.next() && !resultSet.isClosed()) characters++;
   } catch (SQLException e) {
     e.printStackTrace();
   }
   return characters;
 }
Esempio n. 18
0
  public static List<? extends Object> getObjectsByParam(
      String sql,
      Object[] param,
      Connection con,
      int offset,
      int limit,
      String myOrderBy,
      JDBCMapper mapper) {
    if (offset < 0) {
      offset = 0;
      logger.warn("negative offset not allowed on server side. reset to 0.");
    }

    if (limit > MAX_BATCH_SIZE) {
      limit = MAX_BATCH_SIZE;
      logger.warn(
          "limit larger than max_batch_size not allowed on server side. reset to "
              + MAX_BATCH_SIZE);
    }

    ArrayList<Object> objects = new ArrayList<Object>();
    String limitClause = getLimitRange(offset, limit);
    String orderBy = "";
    if (myOrderBy == null) {
      orderBy = " order by name ";
    } else {
      orderBy = myOrderBy;
    }

    PreparedStatement statement = null;
    try {
      statement = con.prepareStatement(sql + orderBy + limitClause);
      SqlUtil.bindParameters(statement, param);
      ResultSet rs = statement.executeQuery();
      while (rs.next()) {
        Object c = mapper.getObject(rs);
        logger.info("got object: " + c);
        objects.add(c);
      }
      if (rs != null && !rs.isClosed()) {
        rs.close();
      }
      return objects;
    } catch (Exception e) {
      logger.error("", e);
      return objects;
    } finally {
      SqlUtil.closeResources(null, statement);
    }
  }
Esempio n. 19
0
  protected ResultSet getResultSet() throws SQLException {
    // Get the soft ref and check it is still available
    ResultSet sql_set = mResult.get();
    if (sql_set == null || sql_set.isClosed()) {
      // Get the result set of the query
      sql_set = executeQuery();

      // Set the cursor to the right position
      if (sql_set != null) {
        initResultSet(sql_set);
      }
    }

    return sql_set;
  }
Esempio n. 20
0
 @Override
 public void close() {
   try {
     if (dataRS != null && !dataRS.isClosed()) {
       dataRS.close();
     }
     if (dataSt != null && !dataSt.isClosed()) {
       dataSt.close();
     }
     if (dataConn != null && !dataConn.isClosed()) {
       dataConn.close();
     }
   } catch (SQLException e) {
     throw new RuntimeException(e);
   }
 }
Esempio n. 21
0
 /**
  * @Description: 根据期号在源数据库中获取记录
  *
  * @author [email protected]
  * @date Feb 15, 2016 4:24:40 PM
  * @param issueId
  * @return
  */
 public List<SrcDataBean> getYucePool(String issueCode) {
   Connection srcConn = ConnectSrcDb.getSrcConnection();
   List<SrcDataBean> srcList = new ArrayList<SrcDataBean>();
   PreparedStatement pstmt = null;
   String startDay = DateUtil.getNextNDay(-7);
   // System.out.println("开始日期"+startDay);
   String endDay = DateUtil.getNextNDay(-1);
   // System.out.println("结束日期"+endDay);
   String code1 = DateUtil.getNextIssueCodeByCurrentIssue(issueCode);
   String code2 = DateUtil.getNextIssueCodeByCurrentIssue(code1);
   String code3 = DateUtil.getNextIssueCodeByCurrentIssue(code2);
   String sql =
       "SELECT issue_number,no1,no2,no3 FROM "
           + App.srcNumberTbName
           + " WHERE substr(ISSUE_NUMBER,1,6) between '"
           + startDay
           + "' and '"
           + endDay
           + "' AND substr(ISSUE_NUMBER,8) IN ('"
           + code1
           + "','"
           + code2
           + "','"
           + code3
           + "') ORDER BY ISSUE_NUMBER DESC";
   // System.out.println(sql);
   try {
     pstmt = (PreparedStatement) srcConn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery();
     while (rs.next()) {
       SrcDataBean srcDataBean = new SrcDataBean();
       srcDataBean.setIssueId(rs.getString(1));
       srcDataBean.setNo1(rs.getInt(2));
       srcDataBean.setNo2(rs.getInt(3));
       srcDataBean.setNo3(rs.getInt(4));
       srcList.add(srcDataBean);
     }
     if (rs != null && !rs.isClosed()) {
       rs.close();
     }
   } catch (SQLException e) {
     e.printStackTrace();
     LogUtil.error(e.getMessage(), "sima/");
   }
   // System.out.println(srcList.size());
   return srcList;
 }
  private void checkPrepareBindExecuteFetch(Connection connection) throws SQLException {
    final String sql = "select cast(? as integer) * 3 as c, 'x' as x\n" + "from (values (1, 'a'))";
    final PreparedStatement ps = connection.prepareStatement(sql);
    final ResultSetMetaData metaData = ps.getMetaData();
    assertEquals(2, metaData.getColumnCount());
    assertEquals("C", metaData.getColumnName(1));
    assertEquals("X", metaData.getColumnName(2));
    try {
      final ResultSet resultSet = ps.executeQuery();
      fail("expected error, got " + resultSet);
    } catch (SQLException e) {
      assertThat(e.getMessage(), equalTo("exception while executing query: unbound parameter"));
    }

    final ParameterMetaData parameterMetaData = ps.getParameterMetaData();
    assertThat(parameterMetaData.getParameterCount(), equalTo(1));

    ps.setInt(1, 10);
    final ResultSet resultSet = ps.executeQuery();
    assertTrue(resultSet.next());
    assertThat(resultSet.getInt(1), equalTo(30));
    assertFalse(resultSet.next());
    resultSet.close();

    ps.setInt(1, 20);
    final ResultSet resultSet2 = ps.executeQuery();
    assertFalse(resultSet2.isClosed());
    assertTrue(resultSet2.next());
    assertThat(resultSet2.getInt(1), equalTo(60));
    assertThat(resultSet2.wasNull(), is(false));
    assertFalse(resultSet2.next());
    resultSet2.close();

    ps.setObject(1, null);
    final ResultSet resultSet3 = ps.executeQuery();
    assertTrue(resultSet3.next());
    assertThat(resultSet3.getInt(1), equalTo(0));
    assertThat(resultSet3.wasNull(), is(true));
    assertFalse(resultSet3.next());
    resultSet3.close();

    ps.close();
    connection.close();
  }
Esempio n. 23
0
  public void test_1() throws Exception {
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setUrl("jdbc:mysql://10.20.153.104:3306/druid2");
    dataSource.setUsername("root");
    dataSource.setPassword("root");

    Connection conn = dataSource.getConnection();
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT 1");
    rs.next();

    conn.close();

    Assert.assertEquals(true, stmt.isClosed());
    Assert.assertEquals(true, rs.isClosed());

    rs.close();
    stmt.close();

    dataSource.close();
  }
Esempio n. 24
0
  /** Get the ID of the data set of metadata for a SHA 256 hash of an APK. */
  private long getMetadataId(String sha256Hash) {
    connectToDatabase();

    String sqlStatementGetMetadataIdFromHash = QueryBuilder.getQueryToGetMetadataIdFromSha256Hash();
    try {
      PreparedStatement preparedStatement =
          databaseConnection.prepareStatement(sqlStatementGetMetadataIdFromHash);
      preparedStatement.setString(1, sha256Hash);
      ResultSet resultSet = preparedStatement.executeQuery();
      long id = -1;
      if (!resultSet.isClosed()) {
        id = resultSet.getLong(1);
        resultSet.close();
      }
      preparedStatement.close();
      return id;

    } catch (SQLException e) {
      e.printStackTrace();
    }

    return -1;
  }
  @BeforeClass
  public static void setUpObjects() throws Exception {
    // (Note: Can't use JdbcTest's connect(...) for this test class.)

    connection = new Driver().connect("jdbc:drill:zk=local", JdbcAssert.getDefaultProperties());

    plainStatement = connection.createStatement();
    preparedStatement = connection.prepareStatement("VALUES 'PreparedStatement query'");

    try {
      connection.prepareCall("VALUES 'CallableStatement query'");
      fail("Test seems to be out of date.  Was prepareCall(...) implemented?");
    } catch (SQLException | UnsupportedOperationException e) {
      // Expected.
    }
    try {
      connection.createArrayOf("INTEGER", new Object[0]);
      fail("Test seems to be out of date.  Were arrays implemented?");
    } catch (SQLException | UnsupportedOperationException e) {
      // Expected.
    }

    resultSet = plainStatement.executeQuery("VALUES 'plain Statement query'");
    resultSet.next();

    resultSetMetaData = resultSet.getMetaData();
    databaseMetaData = connection.getMetaData();

    // Self-check that member variables are set:
    assertFalse("Test setup error", connection.isClosed());
    assertFalse("Test setup error", plainStatement.isClosed());
    assertFalse("Test setup error", preparedStatement.isClosed());
    assertFalse("Test setup error", resultSet.isClosed());
    // (No ResultSetMetaData.isClosed() or DatabaseMetaData.isClosed():)
    assertNotNull("Test setup error", resultSetMetaData);
    assertNotNull("Test setup error", databaseMetaData);
  }
Esempio n. 26
0
 @Override
 public void close() throws IOException {
   try {
     if (resultSet != null && !resultSet.isClosed()) {
       resultSet.close();
     }
   } catch (SQLException e) {
     e.printStackTrace();
   }
   try {
     if (stmt != null && !stmt.isClosed()) {
       stmt.close();
     }
   } catch (SQLException e) {
     e.printStackTrace();
   }
   try {
     if (connection != null && !connection.isClosed()) {
       connection.close();
     }
   } catch (SQLException e) {
     e.printStackTrace();
   }
 }
Esempio n. 27
0
 protected String getIdentifier(
     RDBMSInformationTarget rdbmsInformationTarget, Connection connection) throws SQLException {
   ResultSet rs = null;
   String identifier = null;
   try {
     rs =
         connection
             .getMetaData()
             .getPrimaryKeys(
                 rdbmsInformationTarget.getCatalogName(),
                 rdbmsInformationTarget.getSchemaName(),
                 rdbmsInformationTarget.getTableName());
     if (rs.next()) {
       identifier = rs.getString("COLUMN_NAME");
       if (rs.next()) // currently we do not support more than one pk;
       return null;
     }
     return identifier;
   } catch (SQLException e) {
     throw e;
   } finally {
     if (rs != null && !rs.isClosed()) rs.close();
   }
 }
Esempio n. 28
0
 /**
  * @Description: 在源库中查找最新的期号
  *
  * @author [email protected]
  * @date Feb 15, 2016 3:29:13 PM
  * @return
  */
 public boolean hasRecordByIssueNumber(String issueNumber, String tbName) {
   Connection srcConn = ConnectSrcDb.getSrcConnection();
   boolean flag = false;
   int count = 0;
   PreparedStatement pstmt = null;
   String sql =
       "SELECT count(*) count FROM " + tbName + " where issue_number = '" + issueNumber + "'";
   try {
     pstmt = (PreparedStatement) srcConn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery();
     while (rs.next()) {
       count = rs.getInt(1);
     }
     if (count > 0) {
       flag = true;
     }
     if (rs != null && !rs.isClosed()) {
       rs.close();
     }
   } catch (SQLException e) {
     LogUtil.error(e.getMessage(), "sima");
   }
   return flag;
 }
Esempio n. 29
0
  public void enumerateFun(final Integer rdbmsInformationTargetId, AbstractEntity entity) {
    final RDBMSObjectEnumProxy enumProxy = getEnumProxy(entity);
    if (enumProxy == null) return;

    Connection connection = null;
    Statement statement = null;
    ResultSet rs = null;
    try {
      final RDBMSInformationTarget rdbmsInformationTarget =
          transactionTemplate.execute(
              new TransactionCallback<RDBMSInformationTarget>() {
                @Override
                public RDBMSInformationTarget doInTransaction(TransactionStatus arg0) {
                  rdbmsConnectionDAO.startProcess(rdbmsInformationTargetId);
                  return rdbmsConnectionDAO.getInformationTargetById(rdbmsInformationTargetId);
                }
              });
      entity = enumProxy.refresh(rdbmsInformationTarget, entity);

      connection = getSQLConnection(rdbmsInformationTarget.getRdbmsConnection());
      final String identifier = getIdentifier(rdbmsInformationTarget, connection);
      Boolean incrementalEnum = (identifier != null);
      if (!incrementalEnum) {
        transactionTemplate.execute(
            new TransactionCallbackWithoutResult() {
              @Override
              protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                rdbmsConnectionDAO.deleteValues(rdbmsInformationTarget);
              }
            });
        enumProxy.truncate(rdbmsInformationTarget, entity);
      }
      statement = connection.createStatement();
      rs = getValues(rdbmsInformationTarget, statement, identifier);
      while (rs.next()) {
        Object obj = rs.getObject(1);
        String stringValue = obj.toString();

        Boolean isValid = enumProxy.isValid(rdbmsInformationTarget, entity, stringValue);
        if (!isValid) continue;
        final int stringHashCode = stringValue.hashCode();

        Boolean valueIsAlreadyStored =
            transactionTemplate.execute(
                new TransactionCallback<Boolean>() {
                  @Override
                  public Boolean doInTransaction(TransactionStatus arg0) {
                    return rdbmsConnectionDAO.hasValue(rdbmsInformationTarget, stringHashCode);
                  }
                });

        if (!incrementalEnum && valueIsAlreadyStored) continue;

        RDBMSEnumeratedValue ev = null;
        String idValue = null;
        if (incrementalEnum) {
          Object idObj = rs.getObject(2);
          idValue = idObj.toString();
          final String idValueF = idValue;
          ev =
              transactionTemplate.execute(
                  new TransactionCallback<RDBMSEnumeratedValue>() {
                    @Override
                    public RDBMSEnumeratedValue doInTransaction(TransactionStatus arg0) {
                      return rdbmsConnectionDAO.getValue(rdbmsInformationTarget, idValueF);
                    }
                  });

          if (ev == null && valueIsAlreadyStored) continue;
          if (ev != null && ev.getHashCode() == stringHashCode)
            continue; // we already have this value
          valueIsAlreadyStored =
              transactionTemplate.execute(
                  new TransactionCallback<Boolean>() {
                    @Override
                    public Boolean doInTransaction(TransactionStatus arg0) {
                      return rdbmsConnectionDAO.hasOtherValue(
                          rdbmsInformationTarget, stringHashCode, idValueF);
                    }
                  });
        }

        if (valueIsAlreadyStored && ev != null && ev.getId() != null) {
          final RDBMSEnumeratedValue evF = ev;
          transactionTemplate.execute(
              new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                  rdbmsConnectionDAO.remove(evF);
                }
              });
          enumProxy.delete(rdbmsInformationTarget, entity, idValue);
          continue;
        }

        if (ev == null) {
          ev = new RDBMSEnumeratedValue();
          ev.setInformationTarget(rdbmsInformationTarget);
          ev.setOriginalId(idValue);
        }

        ev.setHashCode(stringHashCode);
        if (enumProxy.shouldStoreValue()) ev.setString(stringValue);
        {
          final RDBMSEnumeratedValue evF = ev;
          transactionTemplate.execute(
              new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                  rdbmsConnectionDAO.save(evF);
                }
              });
        }
        enumProxy.save(rdbmsInformationTarget, entity, idValue, stringValue);
      }
    } catch (ClassNotFoundException e) {
      logger.error("Probably JDBC driver is not found", e);
    } catch (SQLException e) {
      logger.error(
          "An error occured during establishing connection and getting results of query", e);
    } finally {
      transactionTemplate.execute(
          new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus arg0) {
              rdbmsConnectionDAO.finalizeProcess(rdbmsInformationTargetId);
            }
          });
      try {
        if (connection != null && !connection.isClosed()) connection.close();
        if (statement != null && !statement.isClosed()) statement.close();
        if (rs != null && !rs.isClosed()) rs.close();
      } catch (SQLException e) {
        logger.error("Error occurred when closing sql objects", e);
      }
    }
  }
Esempio n. 30
0
  /** @param args */
  public static void main(String[] args) {
    Connection connection = null;
    Statement stmt = null;
    ResultSet result = null;
    try {
      long startTime = System.currentTimeMillis();

      connection = DbConnectionManager.getConnection();
      stmt = connection.createStatement();

      // ex.setTable("Example");
      result = stmt.executeQuery("SELECT * FROM User u,UserInfo ui WHERE ui.userId=u.id LIMIT 4");

      while (result.next()) {
        System.out.println(
            "id=" + result.getString("u.id") + " name=" + result.getString("u.name"));
      }

      long finishTime = System.currentTimeMillis();
      long hours = (finishTime - startTime) / 1000 / 60 / 60;
      long minutes = (finishTime - startTime) / 1000 / 60 - hours * 60;
      long seconds = (finishTime - startTime) / 1000 - hours * 60 * 60 - minutes * 60;

      System.out.println(finishTime - startTime);
      System.out.println("expends:   " + hours + ":" + minutes + ":" + seconds);
    } catch (SQLException e) {
      e.printStackTrace();
      System.out.println("SQLException:" + e.getMessage());
    } finally {
      try {
        System.out.println("finally befon");

        System.out.println("result:" + result.isClosed());
        System.out.println("stmt:" + stmt.isClosed());
        System.out.println("connection:" + connection.isClosed());
      } catch (SQLException e1) {
        e1.printStackTrace();
      }

      //			try {
      //				if (result != null) {
      //					result.close();
      //				}
      //			} catch (SQLException e) {
      //				e.printStackTrace();
      //			}

      try {
        if (stmt != null) {
          stmt.close();
        }
      } catch (SQLException e) {
        e.printStackTrace();
      }

      try {
        if (connection != null) connection.close();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }

    try {
      System.out.println("end");

      System.out.println("result:" + result.isClosed());
      System.out.println("stmt:" + stmt.isClosed());
      System.out.println("connection:" + connection);
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }