tupleslots!

we completely ditch the old HeapTuple code, that's way too icky to work with (not safe)

what we may consider at some point is something like a "tupleslot lite" which only carries
a heaptuple + bufferpin by-value, but for now we don't need that

Author: main--

build.rs

@@ -26,6 +26,8 @@ fn main() {
         writeln!(f, "const CACHEID_TYPEOID: i32 = {};", pgbuild::cacheid_typeoid()).unwrap();
 
         writeln!(f, "const RELATT_OFFSET: usize = {};", pgbuild::relatt_offset()).unwrap();
+        writeln!(f, "const RS_CBUF_OFFSET: usize = {};", pgbuild::rs_cbuf_offset()).unwrap();
+        writeln!(f, "const XS_CBUF_OFFSET: usize = {};", pgbuild::xs_cbuf_offset()).unwrap();
 
 
         assert_ne!(pgbuild::float4_byval(), 0);

pgbuild/src/gluedefs.c

@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <postgres.h>
 #include <access/skey.h>
+#include <access/relscan.h>
 #include <utils/syscache.h>
 #include <utils/rel.h>
 #include <setjmp.h>
@@ -18,3 +19,5 @@ uint32_t len_sigjmpbuf() { return sizeof(sigjmp_buf); }
 uint32_t cacheid_typeoid() { return TYPEOID; }
 
 uint32_t relatt_offset() { return offsetof(RelationData, rd_att); }
+uint32_t rs_cbuf_offset() { return offsetof(HeapScanDescData, rs_cbuf); }
+uint32_t xs_cbuf_offset() { return offsetof(IndexScanDescData, xs_cbuf); }

pgbuild/src/lib.rs

@@ -10,4 +10,6 @@ extern "C" {
 
     pub fn cacheid_typeoid() -> u32;
     pub fn relatt_offset() -> u32;
+    pub fn rs_cbuf_offset() -> u32;
+    pub fn xs_cbuf_offset() -> u32;
 }

src/heap.rs

@@ -2,48 +2,67 @@ use std::os::raw::c_void;
 use std::marker::PhantomData;
 use std::ptr;
 
+use alloc::MemoryContext;
 use types::Oid;
 use error;
-use Datum;
-use relation::{Relation, RawTupleDesc, GetTransactionSnapshot};
+use relation::{Relation, GetTransactionSnapshot};
 use tupledesc::{TupleDesc, RefTupleDesc};
+use tupleslot::{EmptyTupleSlot, TupleSlot};
 
-type HeapScanDesc = *mut c_void;
+#[repr(C)]
+struct HeapScanDescData {
+    _pad: [u8; ::RS_CBUF_OFFSET],
+    rs_cbuf: i32,
+}
+type HeapScanDesc = *mut HeapScanDescData;
 
+type HeapTupleData = c_void;
 extern "C" {
     fn heap_open(relation: Oid, lockmode: i32) -> *const Relation;
     fn relation_close(relation: *const Relation, lockmode: i32);
 
     fn heap_beginscan(relation: *const Relation, snapshot: *mut c_void, nkeys: i32, scankeys: *mut u8) -> HeapScanDesc;
     //fn heap_rescan(scan: HeapScanDesc, scankeys: *mut u8);
-    fn heap_getnext(scan: HeapScanDesc, direction: i32) -> *const HeapTupleData<'static>;
+    fn heap_getnext(scan: HeapScanDesc, direction: i32) -> *const HeapTupleData;
     fn heap_endscan(scan: HeapScanDesc);
 
-    fn heap_deform_tuple(tuple: *const HeapTupleData, desc: *const RawTupleDesc, values: *mut Datum, isnull: *mut bool);
+    //fn heap_deform_tuple(tuple: *const HeapTupleData, desc: *const RawTupleDesc, values: *mut Datum, isnull: *mut bool);
 }
 
+
+
 // FIXME private member
 pub struct Heap(pub(crate) *const Relation);
-pub struct HeapScan<'a> {
+pub struct RawHeapScan<'a> {
     ptr: HeapScanDesc,
-    tupledesc: *const RawTupleDesc,
     marker: PhantomData<&'a Heap>,
 }
 
+pub struct HeapScan<'alloc, 'h> {
+    raw: RawHeapScan<'h>,
+    slot: EmptyTupleSlot<'alloc, RefTupleDesc<'h>>,
+}
+
 impl Heap {
     pub fn open(oid: Oid) -> Heap {
         unsafe {
             error::convert_postgres_error(|| Heap(heap_open(oid, 1)) )
         }
     }
 
-    pub fn scan(&self) -> HeapScan {
+    pub fn scan<'alloc, 'h>(&'h self, alloc: &'alloc MemoryContext<'alloc>) -> HeapScan<'alloc, 'h> {
+        HeapScan {
+            raw: self.scan_raw(),
+            slot: EmptyTupleSlot::create(self.tuple_desc(), alloc),
+        }
+    }
+
+    pub fn scan_raw<'a>(&'a self) -> RawHeapScan<'a> {
         error::convert_postgres_error(|| {
             unsafe {
                 let snap = GetTransactionSnapshot();
-                HeapScan {
+                RawHeapScan {
                     ptr: heap_beginscan(self.0, snap, 0, ptr::null_mut()),
-                    tupledesc: (*self.0).td,
                     marker: PhantomData,
                 }
             }
@@ -57,77 +76,36 @@ impl Heap {
     }
 }
 
-
-
-// TODO: verify in build that C compiler is capable of aligning
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct ItemPointerData {
-    foo: [u8; 6]
-}
-
-
-#[repr(C)]
-struct HeapTupleHeader {
-    pad: [u8; 22],
-    //pad: [u8; RELATT_OFFSET],
-    t_hoff: u8,
-    // tail ...
-}
-
-pub struct HeapTuple<'a> {
-    pub(crate) data: HeapTupleData<'a>,
-    pub(crate) tupledesc: *const RawTupleDesc,
-}
-
-// FIXME: make private
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub(crate) struct HeapTupleData<'a> {
-    t_len: u32,
-    t_self: ItemPointerData,
-    t_tableOid: Oid,
-    t_data: &'a HeapTupleHeader,
-}
-
-
-impl<'a> HeapTuple<'a> {
-    pub fn deform(&self) -> Vec<Option<Datum<'a>>> {
+impl<'alloc, 'h> HeapScan<'alloc, 'h> {
+    pub fn next<'a>(&'a mut self) -> Option<TupleSlot<'alloc, 'a, 'h, RefTupleDesc<'h>>> {
         unsafe {
-            error::convert_postgres_error(|| {
-                let natts = (*self.tupledesc).natts as usize;
-                let mut vals: Vec<Datum> = Vec::with_capacity(natts);
-                let mut flags: Vec<bool> = Vec::with_capacity(natts);
-                vals.set_len(natts);
-                flags.set_len(natts);
-
-                heap_deform_tuple(&self.data, self.tupledesc, vals.as_mut_ptr(), flags.as_mut_ptr());
-
-                vals.into_iter().zip(flags).map(|(v, f)| if f { None } else { Some(v) }).collect()
-            })
+            match self.raw.next() {
+                None => None,
+                Some(tuple) => {
+                    let buffer = (*self.raw.ptr).rs_cbuf;
+                    Some(self.slot.store_tuple(tuple, buffer))
+                }
+            }
         }
     }
 }
 
-impl<'a> Iterator for HeapScan<'a> {
-    type Item = HeapTuple<'a>;
+impl<'a> Iterator for RawHeapScan<'a> {
+    type Item = *const HeapTupleData;
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
             let tuple = error::convert_postgres_error(|| heap_getnext(self.ptr, 1));
             if tuple.is_null() {
                 None
             } else {
-                Some(HeapTuple {
-                    data: *tuple,
-                    tupledesc: self.tupledesc,
-                })
+                Some(tuple)
             }
         }
     }
 }
 
-impl<'a> Drop for HeapScan<'a> {
+impl<'a> Drop for RawHeapScan<'a> {
     fn drop(&mut self) {
         unsafe {
             error::convert_postgres_error_dtor(|| heap_endscan(self.ptr))
@@ -142,31 +120,3 @@ impl Drop for Heap {
         }
     }
 }
-/*
-pub fn do_index_scan(rel: Oid, idx: Oid) -> i32 {
-    let mut counter = 0;
-    unsafe {
-        let heap = heap_open(rel, 1);
-        let index = index_open(idx, 1);
-
-        let btint4cmp = 184;
-        let mut keybuf = [0u8; ::LEN_SCANKEYDATA];
-        ScanKeyInit(keybuf.as_mut_ptr(), 1, 3, btint4cmp, 4);
-
-        let snap = GetTransactionSnapshot();
-        assert!(!snap.is_null());
-        let scan = index_beginscan(heap, index, snap, 1, 0);
-        index_rescan(scan, keybuf.as_mut_ptr(), 1, ptr::null_mut(), 0);
-        loop {
-            let thing = index_getnext(scan, 1);
-            if thing.is_null() { break; }
-            counter += 1;
-        }
-        index_endscan(scan);
-
-        index_close(index, 1);
-        relation_close(heap, 1);
-    }
-    counter
-}
-*/

src/index.rs

@@ -1,25 +1,35 @@
 use std::os::raw::c_void;
 use std::marker::PhantomData;
 use std::{ptr, mem};
+
 use types::Oid;
 use error;
-use heap::{Heap, HeapTuple, HeapTupleData};
+use heap::Heap;
 use relation::{Relation, GetTransactionSnapshot};
+use alloc::MemoryContext;
+use tupledesc::RefTupleDesc;
+use tupleslot::{EmptyTupleSlot, TupleSlot};
 
-type IndexScanDesc = *mut c_void;
+#[repr(C)]
+struct IndexScanDescData {
+    _pad: [u8; ::XS_CBUF_OFFSET],
+    xs_cbuf: i32,
+}
+type IndexScanDesc = *mut IndexScanDescData;
 extern "C" {
     fn index_open(relation: Oid, lockmode: i32 /* set to 1 */) -> *const Relation;
     fn index_close(relation: *const Relation, lockmode: i32);
     fn index_beginscan(heap: *const Relation, index: *const Relation, snapshot: *mut c_void /* null */, nkeys: i32, norderbys: i32) -> IndexScanDesc;
     // afaik orderbys are broken and unused
     fn index_rescan(scan: IndexScanDesc, scankeys: *const ScanKey, nkeys: i32, orderbys: *mut u8, norderbys: i32);
-    fn index_getnext(scan: IndexScanDesc, direction: i32) -> *mut HeapTupleData<'static>; // returns HeapTuple
+    fn index_getnext(scan: IndexScanDesc, direction: i32) -> *mut c_void;
     //fn index_getnext_tid(scan: IndexScanDesc, direction: i32) -> *mut c_void; // returns ItemPointer
     fn index_endscan(scan: IndexScanDesc);
 
     fn ScanKeyInit(entry: *mut ScanKey, attr_num: u16, strat_num: u16, regproc: u32, arg: usize);
 }
 
+
 #[repr(C)]
 pub struct ScanKey {
     _pad: [u8; ::LEN_SCANKEYDATA],
@@ -45,36 +55,52 @@ impl ScanKey {
 // FIXME: validate index structure (postgres does not guard against invalid scankeys,
 //        most importantly column id needs to be valid or things break horribly)
 
-pub struct IndexScan<'a> {
+pub struct RawIndexScan<'a> {
     ptr: IndexScanDesc,
     marker: PhantomData<&'a Index>,
-    heap: &'a Heap,
 }
-impl<'a> Iterator for IndexScan<'a> {
-    type Item = HeapTuple<'a>;
+impl<'a> Iterator for RawIndexScan<'a> {
+    type Item = *const c_void;
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
             let tuple = error::convert_postgres_error(|| index_getnext(self.ptr, 1));
             if tuple.is_null() {
                 None
             } else {
-                Some(HeapTuple {
-                    data: *tuple,
-                    tupledesc: (*self.heap.0).td,
-                })
+                Some(tuple)
             }
         }
     }
 }
-impl<'a> Drop for IndexScan<'a> {
+impl<'a> Drop for RawIndexScan<'a> {
     fn drop(&mut self) {
         unsafe {
             error::convert_postgres_error_dtor(|| index_endscan(self.ptr))
         }
     }
 }
 
+
+pub struct IndexScan<'alloc, 'a> {
+    raw: RawIndexScan<'a>,
+    slot: EmptyTupleSlot<'alloc, RefTupleDesc<'a>>,
+}
+
+impl<'alloc, 'a> IndexScan<'alloc, 'a> {
+    pub fn next<'b>(&'b mut self) -> Option<TupleSlot<'alloc, 'b, 'a, RefTupleDesc<'a>>> {
+        unsafe {
+            match self.raw.next() {
+                None => None,
+                Some(tuple) => {
+                    let buffer = (*self.raw.ptr).xs_cbuf;
+                    Some(self.slot.store_tuple(tuple, buffer))
+                }
+            }
+        }
+    }
+}
+
 pub struct Index(*const Relation);
 impl Index {
     pub fn open(oid: Oid) -> Index {
@@ -83,7 +109,17 @@ impl Index {
         }
     }
 
-    pub fn scan<'a>(&'a self, heap: &'a Heap, scankeys: &'a [ScanKey]) -> IndexScan<'a> {
+    pub fn scan<'alloc, 'a>(&'a self,
+                            heap: &'a Heap,
+                            scankeys: &'a [ScanKey],
+                            alloc: &'alloc MemoryContext<'alloc>) -> IndexScan<'alloc, 'a> {
+        IndexScan {
+            raw: self.scan_raw(heap, scankeys),
+            slot: EmptyTupleSlot::create(heap.tuple_desc(), alloc),
+        }
+    }
+
+    pub fn scan_raw<'a>(&'a self, heap: &'a Heap, scankeys: &'a [ScanKey]) -> RawIndexScan<'a> {
         assert!(scankeys.len() <= 1);
 
         unsafe {
@@ -94,10 +130,9 @@ impl Index {
                 let intlen = scankeys.len() as i32;
                 let scan = index_beginscan(heap.0, self.0, snap, intlen, 0);
                 index_rescan(scan, scankeys.as_ptr(), intlen, ptr::null_mut(), 0);
-                IndexScan {
+                RawIndexScan {
                     ptr: scan,
                     marker: PhantomData,
-                    heap,
                 }
             })
         }