diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/FetchTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/FetchTests.java
index 498e3ec949..806f5525e9 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/FetchTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/FetchTests.java
@@ -69,6 +69,7 @@ import java.util.concurrent.TimeUnit;
 
 import org.jooq.Cursor;
 import org.jooq.Field;
+import org.jooq.FieldProvider;
 import org.jooq.Record;
 import org.jooq.Record1;
 import org.jooq.Record2;
@@ -1518,48 +1519,100 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T725,
 //        assertEquals(result, result2);
 
         // Check the data correctness
-        ResultSet rs = result.intoResultSet();
-        check0(rs);
+        ResultSet rs1 = result.intoResultSet();
+        check0(rs1);
 
-        assertTrue(rs.next());
-        check1(rs);
+        assertTrue(rs1.next());
+        check1(rs1, false);
 
-        assertFalse(rs.previous());
-        check0(rs);
+        assertFalse(rs1.previous());
+        check0(rs1);
 
-        assertFalse(rs.absolute(0));
-        check0(rs);
+        assertFalse(rs1.absolute(0));
+        check0(rs1);
 
-        assertTrue(rs.relative(1));
-        check1(rs);
+        assertTrue(rs1.relative(1));
+        check1(rs1, false);
 
-        assertFalse(rs.relative(-1));
-        check0(rs);
+        assertFalse(rs1.relative(-1));
+        check0(rs1);
 
-        assertTrue(rs.absolute(-4));
-        check1(rs);
+        assertTrue(rs1.absolute(-4));
+        check1(rs1, false);
 
-        assertFalse(rs.absolute(-5));
-        check0(rs);
+        assertFalse(rs1.absolute(-5));
+        check0(rs1);
 
-        assertTrue(rs.absolute(1));
-        check1(rs);
+        assertTrue(rs1.absolute(1));
+        check1(rs1, false);
 
-        rs.beforeFirst();
-        check0(rs);
+        rs1.beforeFirst();
+        check0(rs1);
 
-        assertTrue(rs.last());
-        check4(rs);
+        assertTrue(rs1.last());
+        check4(rs1);
 
-        rs.afterLast();
-        check5(rs);
+        rs1.afterLast();
+        check5(rs1);
 
-        assertTrue(rs.previous());
-        check4(rs);
+        assertTrue(rs1.previous());
+        check4(rs1);
 
-        assertFalse(rs.relative(1));
-        check5(rs);
+        assertFalse(rs1.relative(1));
+        check5(rs1);
 
+        checkMetaData(result, rs1);
+
+        // [#1923] Record.intoResultSet() is similar
+        // -----------------------------------------
+        B book = create().selectFrom(TBook()).where(TBook_ID().eq(1)).fetchOne();
+
+        ResultSet rs2 = book.intoResultSet();
+        check0(rs2);
+
+        assertTrue(rs2.next());
+        check1(rs2, true);
+
+        assertFalse(rs2.previous());
+        check0(rs2);
+
+        assertFalse(rs2.absolute(0));
+        check0(rs2);
+
+        assertTrue(rs2.relative(1));
+        check1(rs2, true);
+
+        assertFalse(rs2.relative(-1));
+        check0(rs2);
+
+        assertTrue(rs2.absolute(-1));
+        check1(rs2, true);
+
+        assertFalse(rs2.absolute(-2));
+        check0(rs2);
+
+        assertTrue(rs2.absolute(1));
+        check1(rs2, true);
+
+        rs2.beforeFirst();
+        check0(rs2);
+
+        assertTrue(rs2.last());
+        check1(rs2, true);
+
+        rs2.afterLast();
+        check5(rs2);
+
+        assertTrue(rs2.previous());
+        check1(rs2, true);
+
+        assertFalse(rs2.relative(1));
+        check5(rs2);
+
+        checkMetaData(book, rs2);
+    }
+
+    private void checkMetaData(FieldProvider result, ResultSet rs) throws SQLException {
         // Check the meta data
         ResultSetMetaData meta = rs.getMetaData();
         assertEquals(result.getFields().size(), meta.getColumnCount());
@@ -1630,12 +1683,12 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T725,
         catch (SQLException expected) {}
     }
 
-    private void check1(ResultSet rs) throws SQLException {
+    private void check1(ResultSet rs, boolean last) throws SQLException {
         assertFalse(rs.isClosed());
         assertFalse(rs.isBeforeFirst());
         assertFalse(rs.isAfterLast());
         assertTrue(rs.isFirst());
-        assertFalse(rs.isLast());
+        assertEquals(last, rs.isLast());
         assertEquals(1, rs.getRow());
 
         assertEquals(1, rs.getInt(1));
diff --git a/jOOQ/src/main/java/org/jooq/Record.java b/jOOQ/src/main/java/org/jooq/Record.java
index b9131444f6..4a9c68559b 100644
--- a/jOOQ/src/main/java/org/jooq/Record.java
+++ b/jOOQ/src/main/java/org/jooq/Record.java
@@ -39,6 +39,8 @@ package org.jooq;
 import java.beans.ConstructorProperties;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Proxy;
+import java.sql.ResultSet;
+import java.sql.Statement;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -541,6 +543,38 @@ public interface Record extends FieldProvider, Attachable {
      */
     <R extends Record> R into(Table<R> table);
 
+    /**
+     * Generate an in-memory JDBC {@link ResultSet} containing the data of this
+     * <code>Record</code>.
+     * <p>
+     * Use this as an adapter for JDBC-compliant code that expects a
+     * {@link ResultSet} to operate on, rather than a jOOQ {@link Result}. The
+     * returned <code>ResultSet</code> allows for the following behaviour
+     * according to the JDBC specification:
+     * <ul>
+     * <li> {@link ResultSet#CLOSE_CURSORS_AT_COMMIT}: The cursors (i.e.
+     * {@link Statement} object) are no longer available</li>
+     * <li> {@link ResultSet#CONCUR_READ_ONLY}: You cannot update the database
+     * through this <code>ResultSet</code>, as the underlying {@link Result}
+     * object does not hold any open database refences anymore</li>
+     * <li> {@link ResultSet#FETCH_FORWARD}: The fetch direction is forward only,
+     * and cannot be changed</li>
+     * <li> {@link ResultSet#TYPE_SCROLL_INSENSITIVE}: You can use any of the
+     * <code>ResultSet</code>'s scrolling methods, e.g. {@link ResultSet#next()}
+     * or {@link ResultSet#previous()}, etc.</li>
+     * </ul>
+     * <p>
+     * You may use {@link FactoryOperations#fetch(ResultSet)} to unwind this
+     * wrapper again.
+     * <p>
+     * This is the same as creating a new {@link Result} with this
+     * <code>Record</code> only, and then calling {@link Result#intoResultSet()}
+     * on that <code>Result</code>
+     *
+     * @return A wrapper JDBC <code>ResultSet</code>
+     */
+    ResultSet intoResultSet();
+
     /**
      * Map this record into a custom mapper callback
      *
diff --git a/jOOQ/src/main/java/org/jooq/Result.java b/jOOQ/src/main/java/org/jooq/Result.java
index a7e9bde762..c4c5b057d9 100644
--- a/jOOQ/src/main/java/org/jooq/Result.java
+++ b/jOOQ/src/main/java/org/jooq/Result.java
@@ -674,14 +674,6 @@ public interface Result<R extends Record> extends FieldProvider, List<R>, Attach
      */
     <H extends RecordHandler<R>> H into(H handler);
 
-    /**
-     * Map results into a custom mapper callback
-     *
-     * @param mapper The mapper callback
-     * @return The custom mapped records
-     */
-    <E> List<E> map(RecordMapper<? super R, E> mapper);
-
     /**
      * Generate an in-memory JDBC {@link ResultSet} containing the data of this
      * <code>Result</code>.
@@ -710,6 +702,14 @@ public interface Result<R extends Record> extends FieldProvider, List<R>, Attach
      */
     ResultSet intoResultSet();
 
+    /**
+     * Map results into a custom mapper callback
+     *
+     * @param mapper The mapper callback
+     * @return The custom mapped records
+     */
+    <E> List<E> map(RecordMapper<? super R, E> mapper);
+
     /**
      * Sort this result by one of its contained fields.
      * <p>
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java b/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
index 291b9d6a16..5411020a36 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
@@ -51,6 +51,7 @@ import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.sql.ResultSet;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -664,6 +665,13 @@ abstract class AbstractRecord extends AbstractStore implements Record {
         }
     }
 
+    @Override
+    public final ResultSet intoResultSet() {
+        ResultImpl<Record> result = new ResultImpl<Record>(getConfiguration(), getFieldProvider());
+        result.add(this);
+        return result.intoResultSet();
+    }
+
     @Override
     public final <E> E map(RecordMapper<Record, E> mapper) {
         return mapper.map(this);
diff --git a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
index cad516b2fc..f032d827e4 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
@@ -1025,6 +1025,11 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
         return handler;
     }
 
+    @Override
+    public final ResultSet intoResultSet() {
+        return new ResultSetImpl(this);
+    }
+
     @Override
     public final <E> List<E> map(RecordMapper<? super R, E> mapper) {
         List<E> result = new ArrayList<E>();
@@ -1036,11 +1041,6 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
         return result;
     }
 
-    @Override
-    public final ResultSet intoResultSet() {
-        return new ResultSetImpl(this);
-    }
-
     @Override
     public final <T extends Comparable<? super T>> Result<R> sortAsc(Field<T> field) {
         return sortAsc(field, new NaturalComparator<T>());