KirbyBase 2.5

data/examples/kbserver_as_win32_service/kbserver_daemon.rb

@@ -0,0 +1,47 @@
+# Modified version of kbserver.rb for use as Windows Service.
+
+require 'kirbybase'
+require 'drb'
+require 'win32/service'
+include Win32
+
+OPTIONS = {}
+
+class KBServerDaemon < Daemon
+    def initialize
+        # NOTE:  Change this line to reflect where you want the log file to
+        #        reside.
+        @log = 'C:\logs\db_server_log.txt'
+        begin
+            # NOTE:  Change this line to reflect where the database tables
+            #        are located.
+            @db = KirbyBase.new do |x|
+                x.connect_type = :server
+                x.path = 'C:\data'
+            end 
+        rescue Exception => e
+            File.open(@log, "a+") { |fh| ft.puts "Error: #{e}" }
+            service_stop
+        end    
+    end
+    
+    def service_main
+        begin
+            # NOTE:  Change this line to reflect what port you want to 
+            #        listen on.
+            DRb.start_service('druby://:44444', @db)
+            DRb.thread.join
+        rescue StandardError, InterrupError => e
+            File.open(@log, "a+") { |fh| fh.puts "Error: #{e}" }
+            service_stop
+        end     
+    end
+    
+    def service_stop
+        DRb.stop_service
+        exit
+    end
+end
+
+d = KBServerDaemon.new
+d.mainloop

data/examples/kbserver_as_win32_service/kbserverctl.rb

@@ -0,0 +1,75 @@
+# Control script for the KBServer service.
+
+require 'optparse'
+require 'win32/service'
+include Win32
+
+# You will want to change these values.
+kbserver_home = 'C:\kbserver'
+kbserver_prog = kbserver_home + '\kbserver_daemon.rb'
+kbserver_svc = 'KirbyBaseServerSvc'
+kbserver_name = 'KirbyBase Database Server'
+
+OPTIONS = {}
+
+ARGV.options do |opts|
+    opts.on("-d",     "--delete",      "Delete the service") { 
+     OPTIONS[:delete] = true }
+    opts.on("-s",     "--start",       "Start the service") { 
+     OPTIONS[:start] = true }
+    opts.on("-x",     "--stop",        "Stop the service") { 
+     OPTIONS[:stop] = true }
+    opts.on("-i",     "--install",     "Install the service") { 
+     OPTIONS[:install] = true }
+    opts.on("-h",     "--help",        "Show this help message") { 
+     puts opts; exit }
+    opts.parse!
+end
+
+# Install the service.
+if OPTIONS[:install]
+    svc = Service.new
+    svc.create_service do |s|
+        s.service_name = kbserver_svc
+        s.display_name = kbserver_name
+        s.binary_path_name = 'c:\ruby\bin\ruby.exe ' + kbserver_prog
+        # This is required for now - bug in win32-service
+        s.dependencies = [] 
+    end
+    svc.close
+    puts "KirbyBase Server service installed"
+end    
+
+# Start the service.
+if OPTIONS[:start]
+    Service.start(kbserver_svc)
+    started = false
+    while started == false
+        s = Service.status(kbserver_svc)
+        started = true if s.current_state == "running"
+        break if started == true
+        puts "One moment, " + s.current_state
+        sleep 1
+    end
+    puts "KirbyBase Server service started"
+end
+
+# Stop the service.
+if OPTIONS[:stop]
+    begin
+        Service.stop(kbserver_svc)
+    rescue
+    end    
+    puts "KirbyBase Server service stopped"
+end
+
+# Delete the service.  Stop it first.
+if OPTIONS[:delete]
+    begin
+        Service.stop(kbserver_svc)
+    rescue
+    end
+    Service.delete(kbserver_svc)    
+    puts "KirbyBase Server service deleted"
+end
+

data/examples/link_many_test/link_many_test.rb

@@ -0,0 +1,70 @@
+# This script demonstrates how to link a field in the table to a subset
+# of records from another table (i.e. a "one to many" link in database
+# lingo).
+
+# In this example, we have an order table and an order_item table.  Each
+# record in the order table represents a customer order.  The order_item
+# table holds the detail items for each order. We create a one-to-many link
+# between the order table and the order_item table by providing extra
+# information about the order.items field when we create the order table.
+
+require 'kirbybase'
+
+db = KirbyBase.new
+
+# To run as a client in a multi-user environment, uncomment next line.
+# Also, make sure kbserver.rb is running.
+#db = KirbyBase.new do |d|
+#    d.connect_type = :client
+#    d.host = 'localhost'
+#    d.port = 44444
+#end
+
+# If table exists, delete it.
+db.drop_table(:order) if db.table_exists?(:order)
+db.drop_table(:order_item) if db.table_exists?(:order_item)
+
+# Create an order item table.  This is the child table to the order table.
+# Create child table before creating parent table so that KirbyBase can
+# take advantage of any indexes.
+order_item_tbl = db.create_table(:order_item,
+ :item_id, :Integer,
+ :order_id, :Integer,
+ :descr, :String,
+ :qty, :Integer,
+ :price, :Float
+)
+
+# Create a table.  We are telling KirbyBase that the items field is
+# to be linked to the order_item table by comparing the order.order_id
+# field to the order_item.order_id field.  By specifying :Link_many, we are
+# telling KirbyBase to make this a one-to-many link.  The result of this is
+# that when you do a select, the items field of the order table is going to
+# hold a reference to a ResultSet (i.e. Array) holding all order_item
+# records whose order_id field match the order_id field in the order record.
+order_tbl = db.create_table(:order,
+ :order_id, :Integer,
+ :customer, :String,
+ :items, {:DataType=> :ResultSet, :Link_many=> [:order_id, :order_item,
+ :order_id]}
+)
+
+# Insert some order records.
+order_tbl.insert({:order_id=>345, :customer=>'Ford'})
+order_tbl.insert({:order_id=>454, :customer=>'Microsoft'})
+order_tbl.insert({:order_id=>17, :customer=>'Boeing'})
+
+# Insert some order item records.
+order_item_tbl.insert(1,345,'Steel',30,19.99)
+order_item_tbl.insert(2,345,'Glass',5,4.15)
+order_item_tbl.insert(5,454,'Floppies',750000,0.5)
+order_item_tbl.insert(3,17,'Wheels',200,2500.0)
+order_item_tbl.insert(4,17,'Wings',25,1000000.0)
+
+# Print all orders.  Under each order print all items in that order.
+order_tbl.select.each do |r|
+    puts '%3d %s' % [r.order_id, r.customer]
+    r.items.each { |i|
+        puts "\t%d %15s %6d %10.2f" % [i.item_id, i.descr, i.qty, i.price]
+    }
+end

data/examples/lookup_field_test/lookup_field_test.rb

@@ -0,0 +1,55 @@
+# This script demonstrates how to link a field in the table to an entire
+# record from another table (i.e. a "one to one" relationship in database
+# lingo).
+
+# In the example below, we have a department table.  For each department
+# record, the manager field is actually a reference to a record from the
+# person table. This allows us to reference the linked person record
+# through the manager field.
+
+require 'kirbybase'
+
+db = KirbyBase.new
+
+# To run as a client in a multi-user environment, uncomment next line.
+# Also, make sure kbserver.rb is running.
+#db = KirbyBase.new do |d|
+#    d.connect_type = :client
+#    d.host = 'localhost'
+#    d.port = 44444
+#end
+
+# If tables exists, delete them.
+db.drop_table(:department) if db.table_exists?(:department)
+db.drop_table(:person) if db.table_exists?(:person)
+
+# Create a person table. Create lookup table first before the table that
+# uses the lookup table, so that KirbyBase can take advantage of any
+# indexes.
+person_tbl = db.create_table(:person,
+ :person_id, :String,
+ :name, :String,
+ :phone, :String
+)
+
+# Insert some person records.
+person_tbl.insert('000-13-5031', 'John Smith', '512.555.1234')
+person_tbl.insert('010-10-9999', 'Jane Doe', '313.724.4230')
+
+# Create a table.  We are telling KirbyBase that the manager field is
+# to be linked to the person table.
+department_tbl = db.create_table(:department,
+ :dept_id, :Integer,
+ :dept_name, :String,
+ :manager, {:DataType=>:String, :Lookup=>[:person, :person_id]})
+
+# Insert some department records.
+department_tbl.insert(345, 'Payroll', '000-13-5031')
+department_tbl.insert(442, 'Accounting', '010-10-9999')
+
+# Print department info.  Notice how we also print info from the linked
+# person record.
+department_tbl.select.each do |r|
+    puts "\n%s %s %s %s %s" % [r.dept_id, r.dept_name,
+     r.manager.person_id, r.manager.name, r.manager.phone]
+end

data/examples/lookup_field_test/lookup_field_test_2.rb

@@ -0,0 +1,62 @@
+# This script demonstrates how to link a field in the table to an entire
+# record from another table (sometimes called a "lookup table").  This
+# script is different from 'lookup_field_test.rb' because it shows how to
+# use the "lookup_key" table attribute to make it easier to define a
+# Lookup field.
+
+# In the example below, we have a department table.  For each department
+# record, the manager field is actually a reference to a record from the
+# person table. This allows us to reference the linked person record
+# through the manager field.
+
+require 'kirbybase'
+
+db = KirbyBase.new
+
+# To run as a client in a multi-user environment, uncomment next line.
+# Also, make sure kbserver.rb is running.
+#db = KirbyBase.new do |d|
+#    d.connect_type = :client
+#    d.host = 'localhost'
+#    d.port = 44444
+#end
+
+# If tables exists, delete them.
+db.drop_table(:department) if db.table_exists?(:department)
+db.drop_table(:person) if db.table_exists?(:person)
+
+# Create a person table. Create lookup table first before the table that
+# uses the lookup table, so that KirbyBase can take advantage of any
+# indexes.  Also, we want to create the lookup table first so that we can
+# define a lookup key.  We do this by adding a :Key entry to the field type
+# has and assigning true to it's value.
+person_tbl = db.create_table(:person,
+ :person_id, {:DataType=>:String, :Key=>true},
+ :name, :String,
+ :phone, :String
+)
+
+# Insert some person records.
+person_tbl.insert('000-13-5031', 'John Smith', '512.555.1234')
+person_tbl.insert('010-10-9999', 'Jane Doe', '313.724.4230')
+
+# Create a table.  We are telling KirbyBase that the manager field is
+# to be linked to the person table.  Notice that in this example, since we
+# want the manager field in this table to be linked to the person_id in the
+# person table, which is that table's lookup key field, all we have to
+# specify here is the name of the lookup table, :person.
+department_tbl = db.create_table(:department,
+ :dept_id, :Integer,
+ :dept_name, :String,
+ :manager, {:DataType=>:String, :Lookup=>:person})
+
+# Insert some department records.
+department_tbl.insert(345, 'Payroll', '000-13-5031')
+department_tbl.insert(442, 'Accounting', '010-10-9999')
+
+# Print department info.  Notice how we also print info from the linked
+# person record.
+department_tbl.select.each do |r|
+    puts "\n%s %s %s %s %s" % [r.dept_id, r.dept_name,
+     r.manager.person_id, r.manager.name, r.manager.phone]
+end

data/examples/lookup_field_test/the_hal_fulton_feature_test.rb

@@ -0,0 +1,69 @@
+# This script demonstrates how to link a field in the table to an entire
+# record from another table (sometimes called a "lookup table").  This
+# script is different from 'lookup_field_test_2.rb' because it shows how to
+# define a Lookup field in an even easier way, by just specifying the
+# lookup table as the field type for the lookup field.  KirbyBase will
+# determine the field type for the lookup field by looking at the field
+# type of the key field of the lookup table.  This is a feature that Hal
+# Fulton has been asking for so I named it in honor of him.  :)
+
+# In the example below, we have a department table.  For each department
+# record, the manager field is actually a reference to a record from the
+# person table. This allows us to reference the linked person record
+# through the manager field.
+
+require 'kirbybase'
+
+db = KirbyBase.new
+
+# To run as a client in a multi-user environment, uncomment next line.
+# Also, make sure kbserver.rb is running.
+#db = KirbyBase.new do |d|
+#    d.connect_type = :client
+#    d.host = 'localhost'
+#    d.port = 44444
+#end
+
+# If tables exists, delete them.
+db.drop_table(:department) if db.table_exists?(:department)
+db.drop_table(:person) if db.table_exists?(:person)
+
+# Create a person table. Create lookup table first before the table that
+# uses the lookup table, so that KirbyBase can take advantage of any
+# indexes.  Also, we want to create the lookup table first so that we can
+# define a lookup key.  We do this by adding a :Key entry to the field type
+# has and assigning true to it's value.
+person_tbl = db.create_table(:person,
+ :person_id, {:DataType=>:String, :Key=>true},
+ :name, :String,
+ :phone, :String
+)
+
+# Insert some person records.
+person_tbl.insert('000-13-5031', 'John Smith', '512.555.1234')
+person_tbl.insert('010-10-9999', 'Jane Doe', '313.724.4230')
+
+# Create a table.  We are telling KirbyBase that the manager field is
+# to be linked to the person table.  Notice that in this example, since we
+# want the manager field in this table to be linked to the person_id in the
+# person table, which is that table's lookup key field, all we have to
+# specify here is the name of the lookup table, :person.  We don't even
+# have to specify the field type for the :manager field, because
+# KirbyBase will look at the field type definition for :person.person_id
+# to automatically assign :manager the same field type (i.e. :String).
+
+department_tbl = db.create_table(:department,
+ :dept_id, :Integer,
+ :dept_name, :String,
+ :manager, :person)
+
+# Insert some department records.
+department_tbl.insert(345, 'Payroll', '000-13-5031')
+department_tbl.insert(442, 'Accounting', '010-10-9999')
+
+# Print department info.  Notice how we also print info from the linked
+# person record.
+department_tbl.select.each do |r|
+    puts "\n%s %s %s %s %s" % [r.dept_id, r.dept_name,
+     r.manager.person_id, r.manager.name, r.manager.phone]
+end

data/examples/many_to_many_test/many_to_many_test.rb

@@ -0,0 +1,65 @@
+# This script demonstrates how you could do many-to-many relationships in 
+# KirbyBase.
+
+require 'kirbybase'
+
+db = KirbyBase.new
+
+# Delete tables if they already exist.
+db.drop_table(:author) if db.table_exists?(:author)
+db.drop_table(:book) if db.table_exists?(:book)
+db.drop_table(:book_author) if db.table_exists?(:book_author)
+
+# Create author table.  Notice how we are creating a one-to-many link to
+# the book_author table.
+author_tbl = db.create_table(:author,
+ :author_id, :Integer, :name, :String,
+ :books, {:DataType=>:ResultSet, 
+          :Link_many=>[:author_id, :book_author, :author_id]}
+)
+
+# Create book table.  Notice how we are creating a one-to-many link to
+# the book_author table.
+book_tbl = db.create_table(:book,
+ :book_id, :Integer, :title, :String,
+ :authors, {:DataType=>:ResultSet, 
+            :Link_many=>[:book_id, :book_author, :book_id]}
+)
+
+# Create join table that will connect author table and book table.
+book_author_tbl = db.create_table(:book_author, :book_id, :Integer,
+ :author_id, :Integer)
+
+# Insert some author records.
+author_tbl.insert(1, 'Jules Verne', nil)
+author_tbl.insert(2, 'Margaret Weis', nil)
+author_tbl.insert(3, 'Tracy Hickman', nil)
+
+# Insert some book records.
+book_tbl.insert(1, 'Voyage to the Bottom of the Sea', nil)
+book_tbl.insert(2, 'From the Earth to the Moon', nil)
+book_tbl.insert(3, 'Dragons of Winter Night', nil)
+book_tbl.insert(4, 'The Nightmare Lands', nil)
+
+# Insert some records into the book_author table that will link the book
+# table to the author table.
+book_author_tbl.insert(1, 1)
+book_author_tbl.insert(2, 1)
+book_author_tbl.insert(3, 2)
+book_author_tbl.insert(3, 3)
+book_author_tbl.insert(4, 2)
+book_author_tbl.insert(4, 3)
+
+
+# Show all book titles written by Jules Verne.
+author_tbl.select { |r| r.name == 'Jules Verne' 
+ }.first.books.each { |b| 
+    puts book_tbl.select { |r| r.book_id == b.book_id }.first.title
+}
+puts
+
+# Show the authors of "The Nightmare Lands".
+book_tbl.select { |r| r.title == 'The Nightmare Lands' 
+ }.first.authors.each { |a| 
+    puts author_tbl.select { |r| r.author_id == a.author_id }.first.name
+}