java.sql.NClob Java Examples

@Override
public NClob createNClob() throws SQLException {
    checkOpen();
    try {
        return connection.createNClob();
    } catch (final SQLException e) {
        handleException(e);
        return null;
    }
}
 

/**
 * @see java.sql.CallableStatement#getNClob(java.lang.String)
 */
public NClob getNClob(String parameterName) throws SQLException {
    try {
        if (this.wrappedStmt != null) {
            return ((CallableStatement) this.wrappedStmt).getNClob(parameterName);
        } else {
            throw SQLError.createSQLException("No operations allowed after statement closed", SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
        }
    } catch (SQLException sqlEx) {
        checkAndFireConnectionError(sqlEx);
    }

    return null;
}
 

@Override
public NClob getNClob(int columnIndex) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
	innerResultSet.updateNClob(columnLabel, nClob);
}
 

public NClob getNClob(int arg0)
        throws SQLException {
    return getPhysCs().getNClob(arg0);
}
 

@Override
public void setNClob(String parameterName, NClob value) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public NClob getNClob(String columnLabel) throws SQLException {
  throw new SQLFeatureNotSupportedException();
}
 

/** {@inheritDoc} */
@Override public NClob getNClob(int colIdx) throws SQLException {
    ensureNotClosed();

    throw new SQLFeatureNotSupportedException("SQL-specific types are not supported.");
}
 

@Override
public NClob createNClob() throws SQLException {
  AssertionUtil.notYetImplemented();
  return null;
}
 

/** {@inheritDoc} */
@Override public void updateNClob(String colLb, NClob nClob) throws SQLException {
    ensureNotClosed();

    throw new SQLFeatureNotSupportedException("Updates are not supported.");
}
 

public NClob assemble(Serializable cached) {
	throw new UnsupportedOperationException( "Clobs are not cacheable" );
}
 

@Override
public void setNClob(String parameterName, NClob value) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

/**
 * Tests for ResultSet.updateNClob()
 * 
 * @throws Exception
 */
public void testUpdateNClob() throws Exception {
    createTable("testUpdateNChlob", "(c1 CHAR(10) PRIMARY KEY, c2 NATIONAL CHARACTER(10)) default character set sjis");
    Properties props1 = new Properties();
    props1.setProperty(PropertyKey.useServerPrepStmts.getKeyName(), "true"); // use server-side prepared statement
    props1.setProperty(PropertyKey.characterEncoding.getKeyName(), "UTF-8"); // ensure charset isn't utf8 here
    Connection conn1 = getConnectionWithProps(props1);
    PreparedStatement pstmt1 = conn1.prepareStatement("INSERT INTO testUpdateNChlob (c1, c2) VALUES (?, ?)");
    pstmt1.setString(1, "1");
    NClob nClob1 = conn1.createNClob();
    nClob1.setString(1, "aaa");
    pstmt1.setNClob(2, nClob1);
    pstmt1.execute();
    Statement stmt1 = conn1.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
    ResultSet rs1 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
    rs1.next();
    NClob nClob2 = conn1.createNClob();
    nClob2.setString(1, "bbb");
    rs1.updateNClob("c2", nClob2);
    rs1.updateRow();
    rs1.moveToInsertRow();
    rs1.updateString("c1", "2");
    NClob nClob3 = conn1.createNClob();
    nClob3.setString(1, "ccc");
    rs1.updateNClob("c2", nClob3);
    rs1.insertRow();
    ResultSet rs2 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
    rs2.next();
    assertEquals("1", rs2.getString("c1"));
    assertEquals("bbb", rs2.getNString("c2"));
    rs2.next();
    assertEquals("2", rs2.getString("c1"));
    assertEquals("ccc", rs2.getNString("c2"));
    pstmt1.close();
    stmt1.close();
    conn1.close();

    createTable("testUpdateNChlob", "(c1 CHAR(10) PRIMARY KEY, c2 CHAR(10)) default character set sjis"); // sjis field
    Properties props2 = new Properties();
    props2.setProperty(PropertyKey.useServerPrepStmts.getKeyName(), "true"); // use server-side prepared statement
    props2.setProperty(PropertyKey.characterEncoding.getKeyName(), "SJIS"); // ensure charset isn't utf8 here
    Connection conn2 = getConnectionWithProps(props2);
    PreparedStatement pstmt2 = conn2.prepareStatement("INSERT INTO testUpdateNChlob (c1, c2) VALUES (?, ?)");
    pstmt2.setString(1, "1");
    pstmt2.setString(2, "aaa");
    pstmt2.execute();
    Statement stmt2 = conn2.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
    ResultSet rs3 = stmt2.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
    rs3.next();
    NClob nClob4 = conn2.createNClob();
    nClob4.setString(1, "bbb");
    try {
        rs3.updateNClob("c2", nClob4); // field's charset isn't utf8
        fail();
    } catch (SQLException ex) {
        assertEquals("Can not call updateNClob() when field's character set isn't UTF-8", ex.getMessage());
    }
    rs3.close();
    pstmt2.close();
    stmt2.close();
    conn2.close();
}
 

@Override
public NClob createNClob() throws SQLException {
	return inner.createNClob();
}
 

@Override
public void setNClob(int parameterIndex, NClob value) throws SQLException {
    ps.setNClob(parameterIndex, value);
}
 

@Override
public NClob getNClob(int columnIndex) throws SQLException {
    throw new SQLFeatureNotSupportedException();
}
 

@Override
public NClob getNClob(int columnIndex) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public NClob getNClob(String columnLabel) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateNClob(String columnLabel, NClob x) throws SQLException {
   logger.logf(level, "%s.updateNClob(%s, %s)", resultSetID, columnLabel, x);
   resultSet.updateNClob(columnLabel, x);
}
 

@Override
public NClob getNClob(String columnLabel) throws SQLException {
    return null;
}
 

@Override
public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public NClob createNClob() throws SQLException {
    throw new SQLFeatureNotSupportedException();
}
 

@Override
public void setNClob(int parameterIndex, NClob value) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
	throw new UnsupportedOperationException();

}
 

@Override
public void updateNClob(String columnLabel, NClob nClob) {
	throw new UnsupportedOperationException();
}
 

private void setParameter(PreparedStatement preparedStatement, Object[] args) throws
    SQLException {
  if (args == null || args.length == 0) {
    return;
  }
  for (int i = 0; i < args.length; i++) {
    Object arg = args[i];
    if (TypeUtil.isInt(arg)) {
      preparedStatement.setInt(i + 1, (Integer) arg);
    } else if (TypeUtil.isString(arg)) {
      preparedStatement.setString(i + 1, (String) arg);
    } else if (TypeUtil.isLong(arg)) {
      preparedStatement.setLong(i + 1, (Long) arg);
    } else if (TypeUtil.isDouble(arg)) {
      preparedStatement.setDouble(i + 1, (Double) arg);
    } else if (TypeUtil.isFloat(arg)) {
      preparedStatement.setFloat(i + 1, (Float) arg);
    } else if (TypeUtil.isBoolean(arg)) {
      preparedStatement.setBoolean(i + 1, (Boolean) arg);
    } else if (TypeUtil.isByte(arg)) {
      preparedStatement.setByte(i + 1, (Byte) arg);
    } else if (TypeUtil.isDate(arg)) {
      preparedStatement.setDate(i + 1, (Date) arg);
    } else if (TypeUtil.isShort(arg)) {
      preparedStatement.setShort(i + 1, (Short) arg);
    } else if (TypeUtil.isArray(arg)) {
      preparedStatement.setArray(i + 1, (Array) arg);
    } else if (TypeUtil.isInputStream(arg)) {
      preparedStatement.setAsciiStream(i + 1, (InputStream) arg);
    } else if (TypeUtil.isBigDecimal(arg)) {
      preparedStatement.setBigDecimal(i + 1, (BigDecimal) arg);
    } else if (TypeUtil.isBlob(arg)) {
      preparedStatement.setBlob(i + 1, (Blob) arg);
    } else if (TypeUtil.isBytes(arg)) {
      preparedStatement.setBytes(i + 1, (byte[]) arg);
    } else if (TypeUtil.isClob(arg)) {
      preparedStatement.setClob(i + 1, (Clob) arg);
    } else if (TypeUtil.isNClob(arg)) {
      preparedStatement.setNClob(i + 1, (NClob) arg);
    } else {
      throw new IllegalArgumentException(
          "Type:" + arg.getClass().getName() + " is not supported");
    }
  }
}
 

public void setNClob(int index, NClob value) throws SQLException{
  throw Util.notImplemented();
}
 

@Override
public NClob getNClob(int columnIndex) throws SQLException {
	throw new NotImplementedException();
}
 

public NClob getNClob(String parameterName) throws SQLException{
    return getCallableStatement().getNClob(parameterName);
}