private void testUnsupportedOperations() throws Exception {
    Connection conn = getConnection();
    stat = conn.createStatement();
    stat.execute("create table test(id int, c clob, b blob)");
    stat.execute("insert into test values(1, 'x', x'00')");
    ResultSet rs = stat.executeQuery("select * from test order by id");
    rs.next();
    Clob clob = rs.getClob(2);
    byte[] data = IOUtils.readBytesAndClose(clob.getAsciiStream(), -1);
    assertEquals("x", new String(data, "UTF-8"));
    assertTrue(clob.toString().endsWith("'x'"));
    clob.free();
    assertTrue(clob.toString().endsWith("null"));

    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).truncate(0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).setAsciiStream(1);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).setString(1, "", 0, 1);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).position("", 0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).position((Clob) null, 0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, clob).getCharacterStream(1, 1);

    Blob blob = rs.getBlob(3);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, blob).truncate(0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, blob).setBytes(1, new byte[0], 0, 0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, blob).position(new byte[1], 0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, blob).position((Blob) null, 0);
    assertThrows(ErrorCode.FEATURE_NOT_SUPPORTED_1, blob).getBinaryStream(1, 1);
    assertTrue(blob.toString().endsWith("X'00'"));
    blob.free();
    assertTrue(blob.toString().endsWith("null"));

    stat.execute("drop table test");
    conn.close();
  }
Example #2
0
  static void read() throws SQLException, IOException {
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    try {
      conn = JdbcUtils.getConnection();
      // conn = JdbcUtilsSingle.getInstance().getConnection();
      st = conn.createStatement();
      rs = st.executeQuery("select text from textdemo");
      while (rs.next()) {
        Blob blob = rs.getBlob(1);
        InputStream in = blob.getBinaryStream();
        // reader = rs.getCharacterStream(1);
        File file = new File("JdbcUtils_bak.java");
        OutputStream out = new BufferedOutputStream(new FileOutputStream(file));

        byte[] buff = new byte[1024];
        for (int i = 0; (i = in.read(buff)) > 0; ) {
          out.write(buff, 0, i);
        }
        out.close();
        in.close();
      }
    } finally {
      JdbcUtils.free(rs, st, conn);
    }
  }
Example #3
0
  @Override
  public Article mapRow(ResultSet rs, int rowNum) throws SQLException {

    Article a = new Article();
    a.setId(rs.getInt("id"));
    a.setTitle(rs.getString("title"));

    Blob blob = rs.getBlob("content");
    int len = (int) blob.length();
    byte[] data = blob.getBytes(0, len);
    String content = new String(data);
    a.setContent(content);

    a.setCtime(rs.getTimestamp("ctime"));
    a.setUptime(rs.getTimestamp("uptime"));
    a.setTags(rs.getString("tags"));
    a.setCategory(rs.getString("category"));

    a.setAuthorId(rs.getInt("authorId"));
    a.setEditorId(rs.getInt("editorId"));
    a.setMediaId(rs.getInt("mediaId"));
    a.setPics(rs.getString("pics"));
    a.setExtra(rs.getString("extra"));

    return a;
  }
Example #4
0
 @Override
 public Object fetchBLOB(ResultSet rs, int column, EOAttribute attribute, boolean materialize)
     throws SQLException {
   NSData data = null;
   Blob blob = rs.getBlob(column);
   if (blob == null) {
     return null;
   }
   if (!materialize) {
     return blob;
   }
   InputStream stream = blob.getBinaryStream();
   try {
     int chunkSize = (int) blob.length();
     if (chunkSize == 0) {
       data = NSData.EmptyData;
     } else {
       data = new NSData(stream, chunkSize);
     }
   } catch (IOException e) {
     throw new JDBCAdaptorException(e.getMessage(), null);
   } finally {
     try {
       if (stream != null) stream.close();
     } catch (IOException e) {
       /* Nothing we can do */
     }
     ;
   }
   return data;
 }
  public String getValue(int idx) {
    String val = "";
    try {
      int cType = getColumnType(idx);

      if (cType == 2004) { // BLOB
        val = "BLOB";

        Blob blob = rs.getBlob(idx);
        if (blob == null) {
          val = null;
        } else {
          val = "BLOB size=" + blob.length();
        }

      } else val = rs.getString(idx);
    } catch (SQLException e) {
      val = e.getMessage();
      int cType = getColumnType(idx);
      System.err.print("Column type: " + cType);
    }

    if (val != null && val.endsWith(" 00:00:00.0")) val = val.substring(0, val.length() - 11);

    return val;
  }
  public void testUpdateExisting() throws Exception {
    Content content = addContent();

    byte[] bytes = new byte[1024];

    Blob data = new OutputBlob(new ByteArrayInputStream(bytes), bytes.length);

    Content newContent =
        new Content(
            content.getContentId(),
            nextLong(),
            randomString(),
            nextLong(),
            nextLong(),
            randomString(),
            randomString(),
            data,
            data.length());

    _persistence.update(newContent);

    Content existingContent = _persistence.findByPrimaryKey(newContent.getContentId());

    assertTrue(existingContent.equals(newContent));
  }
  public String getBlob(int idx) {
    String val = "";
    try {
      int cType = getColumnType(idx);

      if (cType == 2004) { // BLOB
        val = "BLOB";

        Blob blob = rs.getBlob(idx);
        if (blob == null) {
          val = null;
        } else {
          byte[] bdata = blob.getBytes(1, (int) blob.length());
          val = new String(bdata);
        }

      } else val = rs.getString(idx);
    } catch (SQLException e) {
      val = e.getMessage();
      int cType = getColumnType(idx);
      System.err.print("Column type: " + cType);
    }

    //		if (val != null && val.endsWith(" 00:00:00.0")) val = val.substring(0, val.length()-11);
    //		System.out.print("BLOB=" + val);
    return val;
  }
  @SuppressWarnings("unchecked")
  @Override
  public final T deserialize(Object value) {
    InputStream is = null;
    if (value instanceof Blob) {
      Blob blob = (Blob) value;
      try {
        is = blob.getBinaryStream();
      } catch (SQLException e) {
        throw new IciqlException(e);
      }
    } else if (value instanceof byte[]) {
      byte[] bytes = (byte[]) value;
      is = new ByteArrayInputStream(bytes);
    }

    try {
      T object = (T) new ObjectInputStream(is).readObject();
      return object;
    } catch (Exception e) {
      throw new IciqlException(e);
    } finally {
      if (is != null) {
        try {
          is.close();
        } catch (IOException e) {
          throw new IciqlException(e);
        }
      }
    }
  }
 private Reader getReader(Blob blob) throws SQLException, UnsupportedEncodingException {
   if (encoding == null) {
     return (new InputStreamReader(blob.getBinaryStream()));
   } else {
     return (new InputStreamReader(blob.getBinaryStream(), encoding));
   }
 }
  /*
   * (non-Javadoc)
   * @see org.datanucleus.store.rdbms.mapping.AbstractLargeBinaryRDBMSMapping#getObject(java.lang.Object,
   * int)
   */
  @Override
  public Object getObject(ResultSet rs, int param) {
    byte[] bytes = null;
    try {
      // Retrieve the bytes of the object directly
      bytes = rs.getBytes(param);
      if (bytes == null) {
        return null;
      }
    } catch (SQLException sqle) {
      try {
        // Retrieve the bytes using the Blob (if getBytes not supported e.g HSQLDB 2.0)
        Blob blob = rs.getBlob(param);
        if (blob == null) {
          return null;
        }
        bytes = blob.getBytes(1, (int) blob.length());
        if (bytes == null) {
          return null;
        }
      } catch (SQLException sqle2) {
        throw new NucleusDataStoreException(
            Localiser.msg("055002", "Object", "" + param, column, sqle2.getMessage()), sqle2);
      }
    }

    return getObjectForBytes(bytes, param);
  }
  /** 读取数据库带图片的一条记录 */
  @Test
  public void getImage() {
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;

    conn = JDBCUtils.getConnection();
    try {
      stmt = conn.createStatement();
      String sql = "select * from bt_user where id=1";
      rs = stmt.executeQuery(sql);
      if (rs.next()) {
        Blob blob = rs.getBlob("headimage");
        InputStream is = blob.getBinaryStream();
        String path = "D:\\work\\Workspaces\\day14_jdbc\\src\\cn\\itcast\\mysql\\bt\\mm2.jpg";
        OutputStream os = new FileOutputStream(path);
        byte[] buffer = new byte[1024];
        int len = -1;
        while ((len = is.read(buffer)) != -1) {
          os.write(buffer, 0, len);
        }
        // os.flush();
        os.close(); // close中有flush
        is.close();
      }
    } catch (SQLException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      JDBCUtils.closeResource(conn, stmt, rs);
    }
  }
Example #12
0
  /**
   * Returns the bytes from a result set
   *
   * @param res The ResultSet to read from
   * @param columnName The name of the column to read from
   * @return The byte value from the column
   */
  public byte[] getBytesFromBlob(Blob blob) throws SQLException {
    // read the bytes from an oracle blob
    // oracle.sql.BLOB blob = ((OracleResultSet) res).getBLOB(columnName);
    byte[] content = new byte[(int) blob.length()];
    content = blob.getBytes(1, (int) blob.length());

    return content;
  }
  public byte[] getBytes(Blob img) throws SQLException {

    byte[] imgData = null;

    imgData = img.getBytes(1, (int) img.length());

    return imgData;
  }
 public InputStream getBlobStream(int columnIndex) throws SQLException {
   Blob blob = resultSet.getBlob(columnIndex + 1);
   if (blob == null) {
     return null;
   } else {
     return blob.getBinaryStream();
   }
 }
 @Override
 public InputStream getBinaryStream(final int columnIndex) throws SQLException {
   final Blob blob = getBlob(columnIndex);
   if (blob == null) {
     return null;
   }
   return blob.getBinaryStream();
 }
  public void testUpdateNew() throws Exception {
    Content content = addContent();

    Blob data = content.getData();

    assertFalse(data.getClass().equals(OutputBlob.class));
    assertEquals(1024, data.length());
  }
 @Override
 protected byte[] getBlobAsBytes(ResultSet rs, int col) throws SQLException {
   if (_useBytesMethodsForBlob) {
     return rs.getBytes(col);
   } else {
     Blob dataAsBlob = rs.getBlob(col);
     return dataAsBlob.getBytes(1, (int) dataAsBlob.length());
   }
 }
  /**
   * Retrieves the byte position in the <code>BLOB</code> value designated by this <code>Blob</code>
   * object at which <code>pattern</code> begins. The search begins at position <code>start</code>.
   *
   * @param pattern the <code>Blob</code> object designating the <code>BLOB</code> value for which
   *     to search
   * @param start the position in the <code>BLOB</code> value at which to begin searching; the first
   *     position is 1
   * @return the position at which the pattern begins, else -1
   * @exception SQLException if there is an error accessing the <code>BLOB</code> value
   * @since JDK 1.2, HSQLDB 1.7.2
   */
  public long position(final Blob pattern, long start) throws SQLException {

    final byte[] ldata = data;
    final int dlen = ldata.length;

    if (start > dlen || pattern == null) {
      return -1;
    } else if (start < 1) {
      start = 0;
    } else {
      start--;
    }

    final long plen = pattern.length();

    if (plen == 0 || start > ((long) dlen) - plen) {
      return -1;
    }

    // by now, we know plen <= Integer.MAX_VALUE
    final int iplen = (int) plen;
    byte[] bap;

    if (pattern instanceof jdbcBlob) {
      bap = ((jdbcBlob) pattern).data;
    } else {
      bap = pattern.getBytes(1, iplen);
    }

    final int stop = dlen - iplen;
    final byte b0 = bap[0];

    outer_loop:
    for (int i = (int) start; i <= stop; i++) {
      if (ldata[i] != b0) {
        continue;
      }

      int len = iplen;
      int doffset = i;
      int poffset = 0;

      while (len-- > 0) {
        if (ldata[doffset++] != bap[poffset++]) {
          continue outer_loop;
        }
      }

      return i + 1;
    }

    return -1;
  }
Example #19
0
 public static String getBlobValue(ResultSet result, String strField)
     throws java.sql.SQLException {
   String strValueReturn = "";
   Blob blob = result.getBlob(strField);
   if (result.wasNull()) {
     strValueReturn = "";
   } else {
     int length = (int) blob.length();
     if (length > 0) strValueReturn = new String(blob.getBytes(1, length));
   }
   return strValueReturn;
 }
Example #20
0
 /**
  * Get value from given ResultSet at given index with given SQL type.
  *
  * @param rs The ResultSet to get the value from.
  * @param index The index of the value in the ResultSet.
  * @param sqlType The SQL type of the value.
  * @return The value.
  * @throws SQLException If a database access error occurs.
  */
 public static Object getValue(final ResultSet rs, final int index, final int sqlType)
     throws SQLException {
   switch (sqlType) {
     case Types.CHAR:
     case Types.VARCHAR:
     case Types.LONGVARCHAR:
       return rs.getString(index);
     case Types.DECIMAL:
     case Types.NUMERIC:
       return rs.getBigDecimal(index);
     case Types.INTEGER:
       int intVal = rs.getInt(index);
       return (rs.wasNull() ? null : new Integer(intVal));
     case Types.TIME:
       return rs.getTime(index, getCalendar());
     case Types.DATE:
       return rs.getDate(index);
     case Types.TIMESTAMP:
       return rs.getTimestamp(index, getCalendar());
     case Types.FLOAT:
     case Types.DOUBLE:
       double doubleVal = rs.getDouble(index);
       return (rs.wasNull() ? null : new Double(doubleVal));
     case Types.REAL:
       float floatVal = rs.getFloat(index);
       return (rs.wasNull() ? null : new Float(floatVal));
     case Types.SMALLINT:
       short shortVal = rs.getShort(index);
       return (rs.wasNull() ? null : new Short(shortVal));
     case Types.TINYINT:
       byte byteVal = rs.getByte(index);
       return (rs.wasNull() ? null : new Byte(byteVal));
     case Types.LONGVARBINARY:
     case Types.VARBINARY:
     case Types.BINARY:
       return rs.getBytes(index);
     case Types.BLOB:
       Blob blob = rs.getBlob(index);
       return (blob == null ? null : blob.getBinaryStream());
     case Types.CLOB:
       return rs.getClob(index);
     case Types.BIGINT:
       long longVal = rs.getLong(index);
       return (rs.wasNull() ? null : new Long(longVal));
     case Types.BIT:
       boolean boolVal = rs.getBoolean(index);
       return (rs.wasNull() ? null : new Boolean(boolVal));
     default:
       Object value = rs.getObject(index);
       return (rs.wasNull() ? null : value);
   }
 }
Example #21
0
 static final <T> T transform(
     TeiidVersion teiidVersion, Object value, Class<T> targetType, Class<?> runtimeType)
     throws SQLException {
   if (value == null || targetType.isAssignableFrom(value.getClass())) {
     return targetType.cast(value);
   }
   if (targetType == byte[].class) {
     if (value instanceof Blob) {
       Blob blob = (Blob) value;
       long length = blob.length();
       if (length > Integer.MAX_VALUE) {
         throw new SQLException(
             Messages.getString(Messages.JDBC.DataTypeTransformer_blob_too_big));
       }
       return targetType.cast(blob.getBytes(1, (int) length));
     } else if (value instanceof String) {
       return targetType.cast(((String) value).getBytes());
     } else if (value instanceof BinaryTypeImpl) {
       return targetType.cast(((BinaryTypeImpl) value).getBytesDirect());
     }
   } else if (targetType == String.class) {
     if (value instanceof SQLXML) {
       return targetType.cast(((SQLXML) value).getString());
     } else if (value instanceof Clob) {
       Clob c = (Clob) value;
       long length = c.length();
       if (length == 0) {
         // there is a bug in SerialClob with 0 length
         return targetType.cast(""); // $NON-NLS-1$
       }
       return targetType.cast(
           c.getSubString(1, length > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) length));
     }
   }
   try {
     DefaultDataTypeManager dataTypeManager = getDataTypeManager(teiidVersion);
     return (T)
         dataTypeManager.transformValue(
             dataTypeManager.convertToRuntimeType(value, true), runtimeType);
   } catch (Exception e) {
     String valueStr = value.toString();
     if (valueStr.length() > 20) {
       valueStr = valueStr.substring(0, 20) + "..."; // $NON-NLS-1$
     }
     String msg =
         Messages.getString(
             Messages.JDBC.DataTypeTransformer_Err_converting,
             valueStr,
             targetType.getSimpleName());
     throw new SQLException(msg, e);
   }
 }
Example #22
0
  /**
   * Converts a LOB to the equivalent Java type, i.e. <code>Clob</code> to <code>String</code> and
   * <code>Blob</code> to <code>byte[]</code>. If the value passed is not a LOB object, it is left
   * unchanged and no exception is thrown; the idea is to transparently convert only LOBs.
   *
   * @param value an object that may be a LOB
   * @return if the value was a LOB, the equivalent Java object, otherwise the original value
   * @throws SQLException if an error occurs while reading the LOB contents
   */
  public static Object convertLOB(Object value) throws SQLException {
    if (value instanceof Clob) {
      Clob c = (Clob) value;
      return c.getSubString(1, (int) c.length());
    }

    if (value instanceof Blob) {
      Blob b = (Blob) value;
      return b.getBytes(1, (int) b.length());
    }

    return value;
  }
Example #23
0
  private String getBase64OfBlob(java.sql.Blob b) {
    byte[] imageBytes = null;
    String imageEncoded64 = "";
    try {
      imageBytes = b.getBytes(1, (int) b.length());
      byte[] intermediate = Base64.encodeBase64(imageBytes);
      imageEncoded64 = new String(intermediate);

    } catch (SQLException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return imageEncoded64;
  }
  /**
   * {@collect.stats} Constructs a <code>SerialBlob</code> object that is a serialized version of
   * the given <code>Blob</code> object.
   *
   * <p>The new <code>SerialBlob</code> object is initialized with the data from the <code>Blob
   * </code> object; therefore, the <code>Blob</code> object should have previously brought the SQL
   * <code>BLOB</code> value's data over to the client from the database. Otherwise, the new <code>
   * SerialBlob</code> object will contain no data.
   *
   * @param blob the <code>Blob</code> object from which this <code>SerialBlob</code> object is to
   *     be constructed; cannot be null.
   * @throws SerialException if an error occurs during serialization
   * @throws SQLException if the <code>Blob</code> passed to this to this constructor is a <code>
   *     null</code>.
   * @see java.sql.Blob
   */
  public SerialBlob(Blob blob) throws SerialException, SQLException {

    if (blob == null) {
      throw new SQLException("Cannot instantiate a SerialBlob " + "object with a null Blob object");
    }

    len = blob.length();
    buf = blob.getBytes(1, (int) len);
    this.blob = blob;

    // if ( len < 10240000)
    // len = 10240000;
    origLen = len;
  }
Example #25
0
  /**
   * * bolob转为byte
   *
   * @param blob
   * @return
   * @throws Exception
   */
  public static byte[] blob2ByteArr(Blob blob) {

    byte[] b = null;
    try {
      if (blob != null) {
        long in = 0;
        b = blob.getBytes(in, (int) (blob.length()));
      }
    } catch (Exception e) {
      e.printStackTrace();
    }

    return b;
  }
Example #26
0
  @Test
  public void testStreaming() throws Exception {
    WSExecutionFactory ef = new WSExecutionFactory();
    MetadataFactory mf =
        new MetadataFactory(
            "vdb",
            1,
            "x",
            SystemMetadata.getInstance().getRuntimeTypeMap(),
            new Properties(),
            null);
    ef.getMetadata(mf, null);
    Procedure p = mf.getSchema().getProcedure(WSExecutionFactory.INVOKE_HTTP);
    assertEquals(7, p.getParameters().size());

    TransformationMetadata tm =
        RealMetadataFactory.createTransformationMetadata(mf.asMetadataStore(), "vdb");
    RuntimeMetadataImpl rm = new RuntimeMetadataImpl(tm);
    WSConnection mockConnection = Mockito.mock(WSConnection.class);
    Dispatch<Object> mockDispatch = mockDispatch();
    DataSource mock = Mockito.mock(DataSource.class);
    ByteArrayInputStream baos = new ByteArrayInputStream(new byte[100]);
    Mockito.stub(mock.getInputStream()).toReturn(baos);
    Mockito.stub(mockDispatch.invoke(Mockito.any(DataSource.class))).toReturn(mock);
    Mockito.stub(
            mockConnection.createDispatch(
                Mockito.any(String.class),
                Mockito.any(String.class),
                Mockito.any(Class.class),
                Mockito.any(Service.Mode.class)))
        .toReturn(mockDispatch);
    CommandBuilder cb = new CommandBuilder(tm);

    Call call = (Call) cb.getCommand("call invokeHttp('GET', null, null, true)");
    BinaryWSProcedureExecution pe =
        new BinaryWSProcedureExecution(
            call, rm, Mockito.mock(ExecutionContext.class), ef, mockConnection);
    pe.execute();
    List<?> result = pe.getOutputParameterValues();

    Blob b = (Blob) result.get(0);
    assertEquals(100, ObjectConverterUtil.convertToByteArray(b.getBinaryStream()).length);
    try {
      ObjectConverterUtil.convertToByteArray(b.getBinaryStream());
      fail();
    } catch (SQLException e) {
      // should only be able to read once
    }
  }
  public void testBlobA() {

    try {
      String ddl0 = "DROP TABLE BLOBTEST IF EXISTS";
      String ddl1 = "CREATE TABLE BLOBTEST(ID IDENTITY, BLOBFIELD BLOB(1000))";

      statement.execute(ddl0);
      statement.execute(ddl1);
    } catch (SQLException e) {
      e.printStackTrace();
    }

    try {
      String dml0 = "insert into blobtest(blobfield) values(?)";
      String dql0 = "select * from blobtest;";
      PreparedStatement ps = connection.prepareStatement(dml0);
      byte[] data = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
      Blob blob = new JDBCBlob(data);

      ps.setBlob(1, blob);
      ps.executeUpdate();

      data[4] = 50;
      blob = new JDBCBlob(data);

      ps.setBlob(1, blob);
      ps.executeUpdate();
      ps.close();

      ps = connection.prepareStatement(dql0);

      ResultSet rs = ps.executeQuery();

      rs.next();

      Blob blob1 = rs.getBlob(2);

      rs.next();

      Blob blob2 = rs.getBlob(2);
      byte[] data1 = blob1.getBytes(1, 10);
      byte[] data2 = blob2.getBytes(1, 10);

      assertTrue(data1[4] == 5 && data2[4] == 50);
    } catch (SQLException e) {
      e.printStackTrace();
    }
  }
Example #28
0
  public Feed(int id, String name, Blob icon, int unread) {
    this.id = id;
    this.name = name;

    try {
      this.icon = Base64.getEncoder().encodeToString(icon.getBytes(1, (int) icon.length()));

      if (this.icon.equals("") == false) {
        this.icon = "background-image: url(data:image/png;base64," + this.icon + ");";
      }
    } catch (SQLException e) {
      e.printStackTrace();
    }

    this.unread = unread;
  }
  @Override
  public void releaseResources() {
    log.trace("Releasing JDBC resources");

    for (Map.Entry<Statement, Set<ResultSet>> entry : xref.entrySet()) {
      if (entry.getValue() != null) {
        closeAll(entry.getValue());
      }
      close(entry.getKey());
    }
    xref.clear();

    closeAll(unassociatedResultSets);

    if (blobs != null) {
      for (Blob blob : blobs) {
        try {
          blob.free();
        } catch (SQLException e) {
          log.debugf("Unable to free JDBC Blob reference [%s]", e.getMessage());
        }
      }
      blobs.clear();
    }

    if (clobs != null) {
      for (Clob clob : clobs) {
        try {
          clob.free();
        } catch (SQLException e) {
          log.debugf("Unable to free JDBC Clob reference [%s]", e.getMessage());
        }
      }
      clobs.clear();
    }

    if (nclobs != null) {
      for (NClob nclob : nclobs) {
        try {
          nclob.free();
        } catch (SQLException e) {
          log.debugf("Unable to free JDBC NClob reference [%s]", e.getMessage());
        }
      }
      nclobs.clear();
    }
  }
Example #30
0
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
      long id = rs.getLong("userId");

      if (isCacheEnabled() && lookupCache(cacheManager) != null) {
        Element element;
        if ((element = lookupCache(cacheManager).get(DbUtils.hashCodeCacheKeyFor(id))) != null) {
          log.debug("Cache hit on map for User " + id);
          return (User) element.getObjectValue();
        }
      }

      User user = new UserImpl();
      user.setUserId(id);
      user.setActive(rs.getBoolean("active"));
      user.setAdmin(rs.getBoolean("admin"));
      user.setExternal(rs.getBoolean("external"));
      user.setFullName(rs.getString("fullName"));
      user.setInternal(rs.getBoolean("internal"));
      user.setLoginName(rs.getString("loginName"));
      user.setPassword(rs.getString("password"));
      user.setEmail(rs.getString("email"));

      try {
        Blob roleblob = rs.getBlob("roles");
        if (roleblob != null) {
          if (roleblob.length() > 0) {
            byte[] rbytes = roleblob.getBytes(1, (int) roleblob.length());
            String s1 = new String(rbytes);
            String[] roles = s1.split(",");
            user.setRoles(roles);
          }
        }
        if (!isLazy()) {
          user.setGroups(listGroupsByUserId(id));
        }
      } catch (IOException e) {
        e.printStackTrace();
      }

      if (isCacheEnabled() && lookupCache(cacheManager) != null) {
        lookupCache(cacheManager).put(new Element(DbUtils.hashCodeCacheKeyFor(id), user));
      }

      return user;
    }