public void test_stat_1() throws Exception {
    Connection conn = dataSource.getConnection();

    String sql = "select 'x'";
    PreparedStatement stmt = conn.prepareStatement("select 'x'");

    JdbcSqlStat sqlStat = dataSource.getDataSourceStat().getSqlStat(sql);

    Assert.assertEquals(0, sqlStat.getInputStreamOpenCount());

    ResultSet rs = stmt.executeQuery();
    rs.next();
    rs.getAsciiStream("1");
    rs.getAsciiStream("2");
    rs.getAsciiStream("3");
    rs.close();
    stmt.close();

    conn.close();

    Assert.assertEquals(3, sqlStat.getInputStreamOpenCount());

    sqlStat.reset();
    Assert.assertEquals(0, sqlStat.getInputStreamOpenCount());
  }
Пример #2
0
 @Override
 public InputStream getAsciiStream(String columnName) throws JdbcException {
   try {
     return rSet.getAsciiStream(columnName);
   } catch (SQLException ex) {
     throw newJdbcException(ex);
   }
 }
 @Override
 public InputStream getAsciiStream(String columnName) throws SQLException {
   try {
     return _res.getAsciiStream(columnName);
   } catch (SQLException e) {
     handleException(e);
     return null;
   }
 }
Пример #4
0
  public TreeSet<ProcessQueryResult> getPetriNet(Object o) {
    TreeSet<ProcessQueryResult> ret = new TreeSet<ProcessQueryResult>();
    if (o instanceof PetriNet) {
      PetriNet q = (PetriNet) o;
      DataManager dm = DataManager.getInstance();
      String strSelectPetriNet = "select process_id, pnml from petrinet";
      ResultSet rs =
          dm.executeSelectSQL(strSelectPetriNet, 0, Integer.MAX_VALUE, dm.getFetchSize());
      try {
        while (rs.next()) {
          PetriNet c = null;
          if (dm.getDBName().equalsIgnoreCase("postgresql")
              || dm.getDBName().equalsIgnoreCase("mysql")) {
            String str = rs.getString("pnml");
            byte[] temp = str.getBytes();
            c = PetriNetUtil.getPetriNetFromPnmlBytes(temp);
          } else if (dm.getDBName().equalsIgnoreCase("derby")) {
            InputStream in = rs.getAsciiStream("pnml");
            PnmlImport pnml = new PnmlImport();
            PetriNetResult result = (PetriNetResult) pnml.importFile(in);
            c = result.getPetriNet();
            result.destroy();
            in.close();
          } else {
            System.out.println(dm.getDBName() + " unsupported");
            System.exit(-1);
          }
          long process_id = rs.getLong("process_id");

          if (Ullman4PetriNet.subGraphIsomorphism(q, c)) {
            ret.add(new ProcessQueryResult(process_id, 1));
          }
          c.destroyPetriNet();
        }
        java.sql.Statement stmt = rs.getStatement();
        rs.close();
        stmt.close();
      } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    return ret;
  }
Пример #5
0
  private void testClob() throws SQLException {
    trace("Test CLOB");
    ResultSet rs;
    String string;
    stat = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
    stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE CLOB)");
    stat.execute("INSERT INTO TEST VALUES(1,'Test')");
    stat.execute("INSERT INTO TEST VALUES(2,'Hello')");
    stat.execute("INSERT INTO TEST VALUES(3,'World!')");
    stat.execute("INSERT INTO TEST VALUES(4,'Hallo')");
    stat.execute("INSERT INTO TEST VALUES(5,'Welt!')");
    stat.execute("INSERT INTO TEST VALUES(6,NULL)");
    stat.execute("INSERT INTO TEST VALUES(7,NULL)");
    rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
    assertResultSetMeta(
        rs,
        2,
        new String[] {"ID", "VALUE"},
        new int[] {Types.INTEGER, Types.CLOB},
        new int[] {10, Integer.MAX_VALUE},
        new int[] {0, 0});
    rs.next();
    Object obj = rs.getObject(2);
    assertTrue(obj instanceof java.sql.Clob);
    string = rs.getString(2);
    assertTrue(string != null && string.equals("Test"));
    assertTrue(!rs.wasNull());
    rs.next();
    InputStreamReader reader = null;
    try {
      reader = new InputStreamReader(rs.getAsciiStream(2), "ISO-8859-1");
    } catch (Exception e) {
      assertTrue(false);
    }
    string = readString(reader);
    assertTrue(!rs.wasNull());
    trace(string);
    assertTrue(string != null && string.equals("Hello"));
    rs.next();
    try {
      reader = new InputStreamReader(rs.getAsciiStream("value"), "ISO-8859-1");
    } catch (Exception e) {
      assertTrue(false);
    }
    string = readString(reader);
    assertTrue(!rs.wasNull());
    trace(string);
    assertTrue(string != null && string.equals("World!"));
    rs.next();
    string = readString(rs.getCharacterStream(2));
    assertTrue(!rs.wasNull());
    trace(string);
    assertTrue(string != null && string.equals("Hallo"));
    rs.next();
    string = readString(rs.getCharacterStream("value"));
    assertTrue(!rs.wasNull());
    trace(string);
    assertTrue(string != null && string.equals("Welt!"));
    rs.next();
    assertTrue(rs.getCharacterStream(2) == null);
    assertTrue(rs.wasNull());
    rs.next();
    assertTrue(rs.getAsciiStream("Value") == null);
    assertTrue(rs.wasNull());

    assertTrue(rs.getStatement() == stat);
    assertTrue(rs.getWarnings() == null);
    rs.clearWarnings();
    assertTrue(rs.getWarnings() == null);
    assertEquals(ResultSet.FETCH_FORWARD, rs.getFetchDirection());
    assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());
    rs.next();
    stat.execute("DROP TABLE TEST");
  }
Пример #6
0
	public InputStream getAsciiStream(String columnName) throws SQLException {
		return rs.getAsciiStream(columnName);
	}
Пример #7
0
	public InputStream getAsciiStream(int columnIndex) throws SQLException {
		return rs.getAsciiStream(columnIndex);
	}
Пример #8
0
  /**
   * demonstration of bug fix #482109 - inserting Integers and Strings with
   * PreparedStatement.setObject() did not work; String, Integer and Array types are inserted and
   * retrieved<b>
   *
   * <p>demonstration of retrieving values using different getXXX methods
   */
  public void testInsertObject() {

    Object stringValue = null;
    Object integerValue = null;
    Object arrayValue = null;
    Object bytearrayValue = null;
    Object stringValueResult = null;
    Object integerValueResult = null;
    Object arrayValueResult = null;
    boolean wasNull = false;
    String message = "DB operation completed";

    try {
      String sqlString =
          "DROP TABLE PREFERENCE IF EXISTS;"
              + "CREATE CACHED TABLE PREFERENCE ("
              + "User_Id INTEGER NOT NULL, "
              + "Pref_Name VARCHAR(30) NOT NULL, "
              + "Pref_Value OBJECT NOT NULL, "
              + "DateCreated DATETIME DEFAULT NOW NOT NULL, "
              + "PRIMARY KEY(User_Id, Pref_Name) )";

      stmnt.execute(sqlString);

      sqlString =
          "INSERT INTO PREFERENCE "
              + "(User_Id,Pref_Name,Pref_Value,DateCreated) "
              + "VALUES (?,?,?,current_timestamp)";

      PreparedStatement ps = connection.prepareStatement(sqlString);

      // initialise
      stringValue = "String Value for Preference 1";
      integerValue = new Integer(1000);
      arrayValue =
          new Double[] {
            new Double(1),
            new Double(Double.NaN),
            new Double(Double.NEGATIVE_INFINITY),
            new Double(Double.POSITIVE_INFINITY)
          };
      bytearrayValue =
          new byte[] {
            1, 2, 3, 4, 5, 6,
          };

      // String as Object
      ps.setInt(1, 1);
      ps.setString(2, "String Type Object 1");

      // fredt - in order to store Strings in OBJECT columns setObject should
      // explicitly be called with a Types.OTHER type
      //            ps.setObject(3, stringValue); will throw an exception
      ps.setObject(3, stringValue, Types.OTHER);
      ps.execute();

      // Integer as Object
      ps.setInt(1, 2);
      ps.setString(2, "Integer Type Object 2");

      //            ps.setObject(3, integerValue, Types.OTHER); should work too
      ps.setObject(3, integerValue);
      ps.execute();

      // Array as object
      ps.setInt(1, 3);
      ps.setString(2, "Array Type Object 3");
      /*
      ps.setCharacterStream(
          2, new java.io.StringReader("Array Type Object 3"), 19);
      */

      // ps.setObject(3, arrayValue, Types.OTHER); should work too
      ps.setObject(3, arrayValue);
      ps.execute();

      // byte arrray as object
      ps.setInt(1, 3);
      ps.setString(2, "byte Array Type Object 3");
      /*
      ps.setCharacterStream(
          2, new java.io.StringReader("byte Array Type Object 3"), 19);
      */

      // ps.setObject(3, bytearrayValue); will fail
      // must use this to indicate we are inserting into an OTHER column
      ps.setObject(3, bytearrayValue, Types.OTHER);
      ps.execute();

      ResultSet rs = stmnt.executeQuery("SELECT * FROM PREFERENCE");
      boolean result = rs.next();

      // a string can be retrieved as a String or a stream
      // as Unicode string
      String str = rs.getString(2);

      System.out.println(str);

      // as Unicode stream
      InputStream is = rs.getUnicodeStream(2);
      int c;

      while ((c = is.read()) > -1) {
        c = is.read();

        System.out.print((char) c);
      }

      System.out.println();

      // as ASCII stream, ignoring the high order bytes
      is = rs.getAsciiStream(2);

      while ((c = is.read()) > -1) {
        System.out.print((char) c);
      }

      System.out.println();

      // JAVA 2 specific
      // as character stream via a Reader
      /*
      Reader re = rs.getCharacterStream(2);

      while ((c = re.read()) > -1) {
          System.out.print((char) c);
      }
      */

      // retrieving objects inserted into the third column
      stringValueResult = rs.getObject(3);

      rs.next();

      integerValueResult = rs.getObject(3);

      rs.next();

      arrayValueResult = rs.getObject(3);

      // how to check if the last retrieved value was null
      wasNull = rs.wasNull();

      // cast objects to original types - will throw if type is wrong
      String castStringValue = (String) stringValueResult;
      Integer castIntegerValue = (Integer) integerValueResult;
      Double[] castDoubleArrayValue = (Double[]) arrayValueResult;

      {
        sqlString = "DELETE FROM PREFERENCE WHERE user_id = ?";

        PreparedStatement st = connection.prepareStatement(sqlString);

        st.setString(1, "2");

        int ret = st.executeUpdate();

        // here, ret is equal to 1, that is expected
        // conn.commit(); // not needed, as far as AUTO_COMMIT is set to TRUE
        st.close();

        st = connection.prepareStatement("SELECT user_id FROM PREFERENCE WHERE user_id=?");

        st.setString(1, "2");

        rs = st.executeQuery();

        while (rs.next()) {
          System.out.println(rs.getString(1));
        }
      }
    } catch (SQLException e) {
      System.out.println(e.getMessage());
    } catch (IOException e1) {
    }

    /*
    boolean success = stringValue.equals(stringValueResult)
                      && integerValue.equals(integerValueResult)
                      && java.util.Arrays.equals((Double[]) arrayValue,
                          (Double[]) arrayValueResult);
    */
    boolean success = true;

    assertEquals(true, success);
  }
  private void testClob(Connection conn) throws SQLException {
    trace("testClob");
    Statement stat = conn.createStatement();
    PreparedStatement prep;
    ResultSet rs;
    stat.execute("CREATE TABLE T_CLOB(ID INT PRIMARY KEY,V1 CLOB,V2 CLOB)");
    StringBuilder asciiBuffer = new StringBuilder();
    int len = getLength();
    for (int i = 0; i < len; i++) {
      asciiBuffer.append((char) ('a' + (i % 20)));
    }
    String ascii1 = asciiBuffer.toString();
    String ascii2 = "Number2 " + ascii1;
    prep = conn.prepareStatement("INSERT INTO T_CLOB VALUES(?,?,?)");

    prep.setInt(1, 1);
    prep.setString(2, null);
    prep.setNull(3, Types.CLOB);
    prep.executeUpdate();

    prep.clearParameters();
    prep.setInt(1, 2);
    prep.setAsciiStream(2, null, 0);
    prep.setCharacterStream(3, null, 0);
    prep.executeUpdate();

    prep.clearParameters();
    prep.setInt(1, 3);
    prep.setCharacterStream(2, new StringReader(ascii1), ascii1.length());
    prep.setCharacterStream(3, null, 0);
    prep.setAsciiStream(3, new ByteArrayInputStream(ascii2.getBytes()), ascii2.length());
    prep.executeUpdate();

    prep.clearParameters();
    prep.setInt(1, 4);
    prep.setNull(2, Types.CLOB);
    prep.setString(2, ascii2);
    prep.setCharacterStream(3, null, 0);
    prep.setNull(3, Types.CLOB);
    prep.setString(3, ascii1);
    prep.executeUpdate();

    prep.clearParameters();
    prep.setInt(1, 5);
    prep.setObject(2, new StringReader(ascii1));
    prep.setObject(3, new StringReader(ascii2), Types.CLOB, 0);
    prep.executeUpdate();

    rs = stat.executeQuery("SELECT ID, V1, V2 FROM T_CLOB ORDER BY ID");

    rs.next();
    assertEquals(1, rs.getInt(1));
    assertTrue(rs.getCharacterStream(2) == null && rs.wasNull());
    assertTrue(rs.getAsciiStream(3) == null && rs.wasNull());

    rs.next();
    assertEquals(2, rs.getInt(1));
    assertTrue(rs.getString(2) == null && rs.wasNull());
    assertTrue(rs.getString(3) == null && rs.wasNull());

    rs.next();
    assertEquals(3, rs.getInt(1));
    assertEquals(ascii1, rs.getString(2));
    assertEquals(ascii2, rs.getString(3));

    rs.next();
    assertEquals(4, rs.getInt(1));
    assertEquals(ascii2, rs.getString(2));
    assertEquals(ascii1, rs.getString(3));

    rs.next();
    assertEquals(5, rs.getInt(1));
    assertEquals(ascii1, rs.getString(2));
    assertEquals(ascii2, rs.getString(3));

    assertFalse(rs.next());
    assertTrue(prep.getWarnings() == null);
    prep.clearWarnings();
    assertTrue(prep.getWarnings() == null);
    assertTrue(conn == prep.getConnection());
  }
Пример #10
0
 public InputStream getAsciiStream(String arg0) throws SQLException {
   return current.getAsciiStream(arg0);
 }