Many fixes :

  * remove old-style lanbda functions
  * fix many occurences of ponylang/ponyc#1983
  * fixes in the batch mechanism

Author: lisael

Makefile

@@ -1,6 +1,6 @@
 PKG=pg
 BUILD_DIR=build
-PONYC=ponyc
+PONYC=/usr/local/bin/ponyc
 PONY_SRC=$(shell find . -name "*.pony")
 BIN_DIR=$(BUILD_DIR)/release
 BIN=$(BIN_DIR)/example

README.md

@@ -25,6 +25,7 @@ of this PoC is to experiment user-facing API and internal design alternatives.
 
 ### Needed in the proof of concept
 
+- Cursors (prevents from loading the entire dataset of a result)
 - Prepared statements
 - Codecs for values
   - binary values first
@@ -43,7 +44,6 @@ of this PoC is to experiment user-facing API and internal design alternatives.
 - Get and set connection parameters (these are currently fetched from the
   server but not exposed on the API)
 - Transaction Management
-- Cursors (prevents from loading the entire dataset of a result)
 - Support logical decoding (I've already wrote a C/Python library for
   that, it's heavily asynchronous, it'll be a pleasure to do this in pony)
 

example/main.pony

@@ -1,8 +1,7 @@
 """
 main.pony
-
-
 """
+
 use "pg"
 use "pg/codec"
 use "pg/introspect"
@@ -34,34 +33,38 @@ class User
 
 
 class BlogEntryRecordNotify is FetchNotify
-  var entries: (Array[BlogEntry val] trn | Array[BlogEntry val] val) = recover trn Array[BlogEntry val] end
+  var entries: Array[BlogEntry val] trn = recover trn Array[BlogEntry val] end
   let view: BlogEntriesView tag
   let logger: Logger[String val] val
+
   new iso create(v: BlogEntriesView tag, out: OutStream) =>
     view = v
     logger = StringLogger(Warn, out)
 
-  fun ref descirption(desc: RowDescription) => None
-  fun size(): USize => 10
+  fun ref descirption(desc: RowDescription) =>
+    logger.log("Got description")
+
+  fun size(): USize => 1000
+
   fun ref batch(b: Array[Record val] val, next: FetchNotifyNext val) =>
-    logger(Fine) and  logger.log("Fetch entries")
-    if b.size() == size() then
-      try
-        for r in b.values() do
-          let e = recover val BlogEntry(
-            r(0) as I32,
-            2, 3
-            /*r(1) as I32,*/
-            /*r(2) as I32*/
-          ) end
-          Debug.out(e.string())
-          (entries as Array[BlogEntry val] trn).push(e)
-        end
+    logger.log("Fetch entries")
+    try
+      for r in b.values() do
+        // logger.log((r(0) as I32).string())
+        let e = recover val BlogEntry(
+          r(0) as I32,
+          2, 3
+          //r(1) as I32,
+          //r(2) as I32
+        ) end
+        // logger.log(e.string())
+        entries.push(e)
       end
-      next(None)
     end
+    next(None)
+
   fun ref record(r: Record val) =>
-    Debug.out(".")
+    logger.log(".")
     try
        let e = recover val BlogEntry(
           r(0) as I32,
@@ -74,19 +77,20 @@ class BlogEntryRecordNotify is FetchNotify
 
     end
   fun ref stop() =>
-    try
-      entries = recover val entries as Array[BlogEntry val] trn end
-      view.entries(entries)
-    end
+    logger.log("stop")
+    let entries' = entries = recover trn Array[BlogEntry val] end
+    view.entries(consume val entries')
 
 
 class UserRecordNotify is FetchNotify
   let entries: Array[BlogEntry] = Array[BlogEntry]
   let view: BlogEntriesView tag
   let logger: Logger[String val] val
+
   new create(v: BlogEntriesView tag, out: OutStream) =>
     view = v
     logger = StringLogger(Fine, out)
+
   fun ref descirption(desc: RowDescription) => None
 
   fun ref batch(b: Array[Record val] val, next: FetchNotifyNext val) =>
@@ -103,6 +107,7 @@ class UserRecordNotify is FetchNotify
     try
       view.user(recover User(r("id") as I32) end)
     end
+
   fun ref stop() => None
 
 
@@ -122,24 +127,27 @@ actor BlogEntriesView
       Debug("fetch_entries")
       (_conn as Connection).fetch(
         /*"SELECT 1 as user_id, 2, 3 UNION ALL SELECT 4 as user_id, 5, 6 UNION ALL SELECT 7 as user_id, 8, 9",*/
-        "SELECT generate_series(0,100)",
+        "SELECT generate_series(0,10000)",
         recover BlogEntryRecordNotify(this, out) end)
     end
 
   be fetch_user() =>
+    logger.log("fetch_user")
     try
       (_conn as Connection).fetch(
         "SELECT 1 as id",
         recover UserRecordNotify(this, out) end)
     end
 
   be user(u: User iso) =>
+    logger.log("got user #" + u.id.string())
     _user = recover val consume u end
     Debug.out("###")
     fetch_entries()
 
   be render(entries': Array[BlogEntry val] val) =>
     Debug.out("render")
+    logger.log("render")
     try logger.log(entries'.size().string() + " " + entries'(0).string()) end
     /*logger.log(entries'.size().string())*/
     try (_conn as Connection).release() end
@@ -151,62 +159,62 @@ actor BlogEntriesView
   be apply(conn: Connection tag) =>
     _conn = conn
     fetch_user()
-    _entries.next[BlogEntriesView](recover this~render() end)
+    _entries.next[None](recover this~render() end)
 
 
 actor Main
   let session: Session
   let _env: Env
+  let logger: Logger[String val] val
 
   new create(env: Env) =>
     _env = env
-    let logger = StringLogger(Fine, env.out)
-    session = Session(env where user="macflytest",
-                   password=EnvPasswordProvider(env),
-                   database="macflytest")
+    logger = StringLogger(Fine, env.out)
+    session = Session(env where password=EnvPasswordProvider(env))
     let that = recover tag this end
-    """
     session.execute("SELECT generate_series(0,1)",
              recover val
-              lambda(r: Rows val)(that) =>
+              {(r: Rows val)(that) =>
                 that.raw_count(r)
                 None
-              end
+              }
              end)
 
     session.execute("SELECT 42, 24 as foo;;",
              recover val
-              lambda(r: Rows val)(that) =>
-                  that.raw_handler(r)
-              end
+               {(r: Rows val)(that) =>
+                 that.raw_handler(r)
+               }
              end)
 
 
     session.execute("SELECT $1, $2 as foo",
                     recover val
-                      lambda(r: Rows val)(that) =>
+                      {(r: Rows val)(that) =>
                         that.execute_handler(r)
-                      end
+                      }
                     end,
-                   recover val [as PGValue: I32(70000), I32(-100000)] end)
-    """
+                   recover val [as PGValue: I32(70000); I32(-100000)] end)
+
+  
     let p = session.connect(recover val
-      lambda(c: Connection tag)(env) =>
+      {(c: Connection tag)(env) =>
         BlogEntriesView(env.out)(c)
-      end
+      }
     end) 
 
+
   be raw_count(rows: Rows val) =>
-    _env.out.print(rows.size().string())
+    logger.log("rows: " + rows.size().string())
 
   be raw_handler(rows: Rows val) =>
     for row in rows.values() do
-      try Debug.out(row(0) as I32) end
-      try Debug.out(row("foo") as I32) end
+      try logger.log((row(0) as I32).string()) end
+      try logger.log((row("foo") as I32).string()) end
     end
 
   be execute_handler(rows: Rows val) =>
     for row in rows.values() do
-      try Debug.out(row(0) as I32) end
-      try Debug.out(row("foo") as I32) end
+      try logger.log((row(0) as I32).string()) end
+      try logger.log((row("foo") as I32).string()) end
     end

pg/codec/registry.pony

@@ -56,6 +56,7 @@ primitive DecodeText
   fun apply(type_oid: I32, value: Array[U8] val): PGValue ? =>
     match type_oid
     | 23 => String.from_array(value).i32()
+    //| 23 => I32(1)
     else
       Debug.out("Unknown type OID: " + type_oid.string()); error
     end
@@ -69,6 +70,7 @@ primitive DecodeBinary
         result = (result << 8) + i.i32()
       end
       result
+      // I32(1)
     else
       Debug.out("Unknown type OID: " + type_oid.string()); error
     end