rel 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Michel Martens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,62 @@
+BANDICOOT(1)
+
+NAME
+      bandicoot -- Bandicoot client.
+
+SYNOPSIS
+      db = Bandicoot.new(<host>, <port>)
+      db.post(<bandicoot_fn_symbol>, <data>)
+      db.get(<bandicoot_fn_symbol>)
+
+DESCRIPTION
+      Bandicoot is a client library for the Bandicoot relational algebra
+      database.
+
+USAGE
+      Create a client:
+
+          db = Bandicoot.new
+
+      Bandicoot receives two parameters: host, which defaults to "localhost",
+      and port, which defaults to 12345. It will connect via HTTP to send POST
+      and GET requests to the server.
+
+      If we have this server side Bandicoot program:
+
+          # cat foo.b
+          rel Items {
+            id: int,
+            pid: int,
+            ts: long,
+          }
+
+          queue: Items;
+
+          fn push(i: Items) {
+            queue += i - queue project(id);
+          }
+
+          fn list(): Items {
+            return queue;
+          }
+
+      Then we can use Bandicoot as follows:
+
+          db.post(:push, some_csv)
+          db.get(:list)             #=> Returns an array of results
+
+      It also provides a model-like class for mapping Bandicoot rels:
+
+          class Item < Bandicoot::Rel
+            field :id, :int
+            field :pid, :int
+            field :ts, :long
+          end
+
+      Now you can do:
+
+          item = Item.new(id: 1, pid: 0, ts: 1310084883)
+          db.post(:push, item.to_csv)
+
+INSTALLATION
+      $ gem install bandicoot

data/Rakefile

@@ -0,0 +1,11 @@
+task :test do
+  require "cutest"
+
+  Cutest.run(Dir["test/*.rb"])
+end
+
+task :start do
+  exec "bandicoot start -p 12345 -d data/volume -c data/sample.b -s data/volume/sample"
+end
+
+task :default => :test

data/data/sample.b

@@ -0,0 +1,53 @@
+rel Items {
+  id: int,
+  pid: int,
+  ts: long,
+}
+
+rel Process {
+  pid: int
+}
+
+queue: Items;
+
+fn push(i: Items) {
+  queue += i - queue project(id);
+}
+
+fn list(): Items {
+  return queue;
+}
+
+fn in_process(): Items {
+  return queue select(pid != 0);
+}
+
+fn clear() {
+  queue -= queue;
+}
+
+fn fetch(p: Process): Items {
+
+  # Get the oldest free item.
+  q1 := queue select(pid == 0)
+              summary(id = min(id, 0),
+                      ts = min(ts, 0L));
+
+  # Mark the item with the process id.
+  q2 := q1 * p;
+
+  # Update the queue with the new item.
+  queue = queue - q1 extend(pid = 0) + q2;
+
+  # Return the updated record.
+  return q2;
+}
+
+# Remove an item from the queue.
+fn delete(i: Items) {
+  queue = queue - i;
+}
+
+fn recent(t: long): Items {
+  return queue select(ts > t);
+}

data/lib/rel.rb

@@ -0,0 +1,102 @@
+require "csv"
+require "net/http"
+require "uri"
+
+class Rel
+  VERSION = "0.0.1"
+
+  # Basic HTTP client that sends and receives CSV.
+  class Client
+    attr :http
+
+    def initialize(host, port)
+      @http = Net::HTTP.new(host, port)
+    end
+
+    def get(fn)
+      reply(http.get("/#{fn}"))
+    end
+
+    def post(fn, csv)
+      reply(http.post("/#{fn}", csv))
+    end
+
+    def reply(res)
+      unless res.code == "200"
+        raise RuntimeError, res.inspect
+      end
+
+      res.body
+    end
+  end
+
+  attr :client
+
+  def initialize(url = "http://localhost:12345")
+    url = URI.parse(url)
+    @client = Client.new(url.host, url.port)
+  end
+
+  def get(fn)
+    _csv_to_hashes(client.get(fn))
+  end
+
+  def post(fn, hashes)
+    _csv_to_hashes(client.post(fn, _hashes_to_csv(hashes.dup)))
+  end
+
+private
+
+  def _csv_to_hashes(csv)
+    rows = CSV.parse(csv)
+    head = rows.shift
+
+    rows.map do |row|
+      _row_to_hash(row, head)
+    end
+  end
+
+  def _hashes_to_csv(hashes)
+    first = hashes.shift
+
+    CSV.generate do |csv|
+      csv << first.keys
+      csv << first.values
+
+      hashes.each do |hash|
+        csv << hash.values
+      end
+    end
+  end
+
+  def _row_to_hash(row, head)
+    record = []
+
+    head.zip(row) do |field, value|
+      record << field
+      record << _cast(value, _type_of(field))
+    end
+
+    Hash[*record]
+  end
+
+  def _record_to_csv(record)
+    CSV.generate do |csv|
+      csv << record.keys
+      csv << record.values
+    end
+  end
+
+  def _type_of(field)
+    field.split(":").last
+  end
+
+  def _cast(value, type)
+    case type
+    when "int" then value.to_i
+    when "long" then value.to_i
+    when "real" then value.to_f
+    else value
+    end
+  end
+end

data/lib/rel/model.rb

@@ -0,0 +1,45 @@
+# Mapper for Bandicoot relations.
+class Rel
+  class Model
+    @@fields = Hash.new { |hash, key| hash[key] = {} }
+
+    def self.field(name, type)
+      @@fields[self.name][name] = type
+      attr_accessor name
+    end
+
+    def initialize(attrs = {})
+      attrs.each do |field, value|
+        name, type = field.to_s.split(":")
+        send(:"#{name}=", value)
+      end
+    end
+
+    def to_hash
+      record = []
+
+      header.zip(values) do |field, value|
+        record << field
+        record << value
+      end
+
+      Hash[*record]
+    end
+
+    def values
+      fields.map do |field, _|
+        send(field)
+      end
+    end
+
+    def header
+      fields.map do |field, type|
+        "#{field}:#{type}"
+      end
+    end
+
+    def fields
+      @@fields[self.class.name]
+    end
+  end
+end

data/rel.gemspec

@@ -0,0 +1,21 @@
+require "./lib/rel"
+
+Gem::Specification.new do |s|
+  s.name              = "rel"
+  s.version           = Rel::VERSION
+  s.summary           = "Bandicoot client."
+  s.description       = "Client for the Bandicoot relational algebra database."
+  s.authors           = ["Michel Martens"]
+  s.email             = ["michel@soveran.com"]
+  s.homepage          = "http://github.com/soveran/rel"
+
+  s.files = Dir[
+    "LICENSE",
+    "README*",
+    "Rakefile",
+    "lib/**/*.rb",
+    "*.gemspec",
+    "test/*.*",
+    "data/sample.b"
+  ]
+end

data/test/bandicoot.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require "rel"
+require "pp"
+
+db = Rel.new
+
+head = [["id:int", "pid:int", "ts:long"]]
+
+list_csv = CSV.generate do |csv|
+  csv << head.first
+  csv << [1, 0, 1310084883]
+  csv << [2, 0, 1310084888]
+end
+
+list = CSV.parse(list_csv)
+
+prepare do
+  db.get(:clear)
+end
+
+test "get" do
+  assert_equal head, CSV.parse(db.client.get(:list))
+end
+
+test "push items to the queue" do
+  assert_equal "", db.client.post(:push, list_csv)
+  assert_equal list_csv, db.client.get(:list)
+end
+
+test "primitive types in parameters" do
+  db.post("push", [{"id:int" => 1,
+                    "pid:int" => 1,
+                    "ts:long" => 100}])
+  db.post("push", [{"id:int" => 2,
+                    "pid:int" => 2,
+                    "ts:long" => 200}])
+
+  assert_equal 2, db.get("recent?t=150").first["id:int"]
+end

data/test/bandicoot_and_models.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require "rel"
+require "rel/model"
+
+class Item < Rel::Model
+  field :id, :int
+  field :pid, :int
+  field :ts, :long
+
+  def save(db)
+    db.post(:push, [to_hash])
+  end
+end
+
+db = Rel.new
+
+prepare do
+  db.get(:clear)
+end
+
+test "extending relations" do
+  item = Item.new(id: 1, pid: 0, ts: 1310084883)
+  item.save(db)
+
+  assert_equal item.to_hash, db.get(:list).first
+end

data/test/hash.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require "rel"
+
+db = Rel.new
+
+prepare do
+  db.get(:clear)
+end
+
+test do
+  db.post(:push, [{"id:int" => 1, "pid:int" => 2, "ts:long" => 3}])
+  assert_equal 1, db.get(:list).first["id:int"]
+end

data/test/model.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+
+require "rel"
+require "rel/model"
+
+class Item < Rel::Model
+  field :id, :int
+  field :pid, :int
+  field :ts, :long
+end
+
+class Other < Rel::Model
+  field :conflict, :string
+end
+
+item_hash = { "id:int" => 1, "pid:int" => 0, "ts:long" => 1310084883 }
+
+test "convert item to hash" do
+  item = Item.new
+  item.id = 1
+  item.pid = 0
+  item.ts = 1310084883
+  assert_equal item.to_hash, item_hash
+end
+
+test "create item from hash" do
+  item = Item.new(item_hash)
+  assert_equal item.to_hash, item_hash
+end
+
+test "mass assignment of attributes on creation" do
+  item = Item.new(id: 1, pid: 0, ts: 1310084883)
+  assert_equal item.to_hash, item_hash
+end
+
+test "shouldn't have conflicts with other classes" do
+  item = Item.new(id: 1, pid: 0, ts: 1310084883)
+  other = Other.new(conflict: "None")
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Michel Martens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-21 00:00:00.000000000 -07:00
+default_executable: 
+dependencies: []
+description: Client for the Bandicoot relational algebra database.
+email:
+- michel@soveran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README
+- Rakefile
+- lib/rel/model.rb
+- lib/rel.rb
+- rel.gemspec
+- test/bandicoot.rb
+- test/bandicoot_and_models.rb
+- test/hash.rb
+- test/model.rb
+- data/sample.b
+has_rdoc: true
+homepage: http://github.com/soveran/rel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Bandicoot client.
+test_files: []