oinky 0.1.0

data/lib/oinky/compiler.rb

@@ -0,0 +1,106 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+module Oinky
+  # This is a duplicate definition.  It's here to decouple the compiler
+  # from the oinky gem.  The gem requires building a native extension, 
+  # whereas the compiler doesn't.  This way the compiler can be run
+  # right out of the source directory without build/install.
+  # Consistency of these definitions is assured in the Oinky gem.
+  column_types = [:variant, :bit, 
+                 :int8, :int16, :int32, :int64, 
+                 :uint8, :uint16, :uint32, :uint64, 
+                 :float32, :float64, 
+                 :datetime, :string].sort
+  ColumnTypes ||= column_types
+
+  # ColumnTypes may have been previously defined (by the gem)
+  # but if so, the definition should have been identical.
+  unless ColumnTypes == column_types 
+    raise OinkyException.new("Mismatched column types definition: " +
+                         "#{ColumnTypes.inspect} != #{column_types.inspect}")
+  end
+end
+
+require 'oinky/oc_builder'
+# Just preload all the languages we know about.  They are well namespaced
+# so there's no harm.
+require 'oinky/cpp_emitter'
+require 'oinky/rb_emitter'
+require 'oinky/modelbase'
+require 'oinky/dsl'
+
+# This is the oinky model compiler.  Given a model specification, it 
+# can generate a set of accessor classes and basic migration routines
+# in a target language.
+#
+# The purpose of this compiler is to permit the model to be defined 
+# exactly once, in one language.  It can generate code in any language.
+# There should be NO REASON WHATSOEVER to EVER MODIFY THE GENERATED CODE!!!
+# That is always the wrong thing to do.  Alter the generator if need be.
+
+module Oinky
+  module Model
+    class DerivedType
+      def initialize(basetype, instancetype)
+        @basetype = basetype
+        @instancetype = instancetype
+      end
+      def instance_type(lang)
+        return @instancetype if @instancetype.is_a? String
+        return @instancetype[lang]
+      end
+      def oinky_type
+        return @basetype if @basetype.is_a? Symbol
+        return @basetype.oinky_type
+      end
+      # This can be overriden by any derived type.  By default
+      # we just build from the base type.
+      def value_from_variant(src_exp, emitter)
+        emitter.value_from_variant(src_exp, oinky_type)
+      end
+    end
+
+    def self.generate(schema, ccls)
+      # Allow specification by class or symbol
+      ccls = ({:cpp=>Cpp, :CPP=>Cpp, :ruby=>Ruby, :rb=>Ruby}[ccls] || ccls)
+      ccls.new(schema).emit
+    end
+  end
+end
+
+=begin
+
+  class TableDefinition
+    def initialize(h)
+      @h = h
+    end
+
+    attr_reader :h
+  end
+
+  def self.define_table(h)
+    h[:indices] = (h[:indices] || h[:indexes] || [])
+    TableDefinition.new(h)
+  end
+
+  class Table
+    
+  end
+
+  class Model
+    class << self
+
+      def create_table(tablename)
+        
+      end
+    end
+  end
+
+end
+=end
+
+require 'oinky/cpp_emitter'
+

data/lib/oinky/cpp_emitter.rb

@@ -0,0 +1,311 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+require 'oinky/normalize.rb'
+
+module Oinky
+  module Model
+    class Cpp
+      def initialize(schema)
+        @schema = Oinky::Model.normalize_schema(schema)
+      end
+
+      def cppify(str)
+        str.gsub(/($[0-9])|[^a-z0-9A-Z_]/,'_')
+      end
+
+      def schemaname_to_ns(str) ; cppify(str) ; end
+      def tablename_to_groupname(str) ; cppify(str) ; end
+      def handle_from_tablename(str) ; "#{cppify(str)}_handle" ; end
+      def accessor_from_tablename(str) ; cppify(str) ; end
+
+      def make_datetime_expression(d)
+        "Oinky::datetime_t::compose(#{d.year-1900},#{d.month - 1},#{d.day - 1}," +
+          "#{d.hour},#{d.minute},#{d.second},#{(d.second_fraction * 1000000).to_i})"
+      end
+
+      def default_value_expression(coldef)
+        d = coldef[:default]
+        return "#{instance_type_expression(coldef[:type])}()" unless d
+        return d.inspect if d.is_a? String
+        return d.inspect if d.is_a? Fixnum
+        return make_datetime_expression(d) if d.is_a? DateTime
+        return d[:cpp]
+      end
+
+      def accessor_name(h)
+        return cppify(h[:accessor])
+      end
+
+      def index_column_name(col)
+        return col if col.is_a? String
+        return col.to_s if col.is_a? Symbol
+        return index_column_name(col[:name])
+      end
+      def index_column_ascending(col)
+        return col[:ascending] if col.is_a? Hash
+        # ascending is the default
+        return true
+      end
+
+      def instance_type_expression(type)
+        self.class.instance_type_expression(type)
+      end
+      def self.instance_type_expression(type)
+        case type
+        when :variant
+          return 'Oinky::variant_cv_t'
+        when :bit
+          return 'bool'
+        when :datetime
+          return 'Oinky::datetime_t'
+        when :string 
+          return 'Oinky::db_string'
+          #int
+        when :int8 
+          return 'int8_t'
+        when :int16
+          return 'int16_t'
+        when :int32
+          return 'int32_t'
+        when :int64
+          return 'int64_t'
+          #uint
+        when :uint8 
+          return 'uint8_t'
+        when :uint16
+          return 'uint16_t'
+        when :uint32
+          return 'uint32_t'
+        when :uint64
+          return 'uint64_t'
+          #float
+        when :float32
+          return 'float32_t'
+        when :float64
+          return 'float64_t'
+        else
+          # This must be a derived type.  It should support this method, to 
+          # give us an expression we can use in the target language.
+          return type.instance_type(self)
+        end
+      end
+
+      def value_from_variant(src,type)
+        self.class.value_from_variant(src,type)
+      end
+      def self.value_from_variant(src,type)
+        case type
+        when :variant
+          return src
+        when :bit
+          return "#{src}.bit_value()"
+        when :datetime
+          return "#{src}.dt_value()"
+        when :string 
+          return "#{src}.string_value()"
+          #int
+        when :int8 
+          return "(int8_t) #{src}.int_value()"
+        when :int16
+          return "(int16_t) #{src}.int_value()"
+        when :int32
+          return "(int32_t) #{src}.int_value()"
+        when :int64
+          return "#{src}.int_value()"
+          #uint
+        when :uint8 
+          return "(uint8_t) #{src}.uint_value()"
+        when :uint16
+          return "(uint16_t) #{src}.uint_value()"
+        when :uint32
+          return "(uint32_t) #{src}.uint_value()"
+        when :uint64
+          return "#{src}.uint_value()"
+          #float
+        when :float32
+          return "#{src}.f32_value()"
+        when :float64
+          return "#{src}.f64_value()"
+
+        else
+          # This must be a derived type.  It should support this method, to 
+          # give us an expression we can use in the target language.
+          return type.value_from_variant(src, self)
+        end
+      end
+
+      def type_code(h)
+        self.class.type_code(h)
+      end
+      def self.type_code(h)
+        h = h[:type].to_s
+        h[0] = h[0].upcase
+        return 'column_types::' + h
+      end
+
+      def make_index_name(idef)
+        cppify(idef[:name])
+      end
+      def make_index_handle_name(idef)
+        "_idx_handle__#{make_index_name(idef)}"
+      end
+      def make_table_classname(tn)
+        "CTable_#{cppify(tn)}"
+      end
+
+      def indices(t)
+        t[:indices] || t[:indexes] || []
+      end
+
+      #Generate a string, containing the C++ code for the model classes.
+      def emit
+        p = Oinky::Detail::Builder.new
+        ns = "namespace #{schemaname_to_ns(@schema[:name])}"
+        p.next("#{ns} {", "} //#{ns}") {
+          p << "using namespace Oinky;"
+          p << "using Oinky::Model::TableBase;"
+          p << "using Oinky::Model::SchemaBase;"
+          p << "using Oinky::db_t;"
+          p << ''
+          p << "class Schema;"
+          tables = @schema[:tables]
+          tables.each{|tn, t|
+#            struct_hdr = "struct #{tablename_to_groupname(t[:name])}"
+#            p << struct_hdr
+#            p.next("{", "}; //#{struct_hdr}") {
+            tbl_classname = make_table_classname(tn)
+            p << ''
+            p << "class #{tbl_classname} : public TableBase"
+            p.next("{", "}; //class #{tbl_classname}") {
+              p << "friend class Schema;"
+              p.write("public:", -1)
+              p.next("struct Row {", "}; //struct Row") {
+                maxw = t[:columns].max_by{|k,col| instance_type_expression(col[:type]).length}
+                maxwlen = maxw ? instance_type_expression(maxw[1][:type]).length : 0
+                t[:columns].each{|cn,col|
+                  if col[:description]
+                    col[:description].split("\n").each{|l|
+                      p << ("//  " + l)
+                    }
+                  end
+                  # The column name is the default value of the accessor name,
+                  # but it can be overridden
+                  p << Kernel.sprintf("%-#{maxwlen}s %s;",
+                                      instance_type_expression(col[:type]),
+                                      accessor_name(col))
+                }
+              }
+              p << ''
+              p.write("private:", -1)                
+              p << "typedef db_t::column_selector_t column_selector_t;"
+              p << 'column_selector_t row_selector;'
+              # index handles
+              indices(t).each {|iname, idef|
+                p << "const db_t::index_handle #{accessor_name(idef)};"
+              }
+              p << ''
+              # update_schema
+              p << 'static void up_schema(db_t::table_handle th)'
+              p.next('{','}') {
+                # Add columns
+                t[:columns].each{|cn, col|
+                  p << "TableBase::create_column_if(th, #{cn.inspect}, #{type_code(col)}, #{default_value_expression(col)});"
+                }
+                # Add indices
+                indices(t).each_with_index {|idef,idx|
+                  iname, idef = idef
+                  # Column definitions
+                  names = "idx_column_defs_#{idx}"
+                  columns = idef[:columns]
+                  p.next("static index_column_def #{names}[] = {", "};") {
+                    columns.each_with_index{|col, i|
+                      colname = index_column_name(col)
+                      ascending = index_column_ascending(col) ? 'true' : 'false'
+                      sep = (i == 0 ? '' : ',')
+                      p << "#{sep} { db_string(\"#{colname}\"), #{ascending} }"
+                    }
+                  }
+                  unique = idef[:unique] ? 'true' : 'false'
+                  p << "TableBase::create_index_if(th, #{iname.inspect}, #{unique}, #{names}, #{names}+#{columns.size} );"
+                }
+              }
+              p << ''
+              p << "template<typename CURSOR>"
+              p.next("void priv_row_from_cursor(Row &row, const CURSOR &crs) {", "}") {
+                # Don't presume that enumeration with index is a consistent
+                # ordering
+                indexed_cols = []
+                p.next("static const char *column_names[] = {","};") {
+                  t[:columns].each{|cn, col|
+                    p << "#{cn.inspect},"
+                    indexed_cols << col
+                  }
+                  p << 'NULL'
+                }
+                p.next("TableBase::check_init_row_accessor(", "") {
+                  p << "row_selector, "
+                  p << "column_names,"
+                  p << "column_names + #{t[:columns].count}"
+                  p << ");"
+                }
+                p.next("variant_cv_t *vals = (variant_cv_t *) ","") {
+                  p << "alloca(sizeof(variant_cv_t) * #{t[:columns].count});"
+                }
+                p << "crs.select(row_selector).copy_to(vals, #{t[:columns].count});"
+                p << "//  Select values into the target struct"
+                indexed_cols.each_with_index{|col,i|
+                  val = value_from_variant("vals[#{i}]", col[:type])
+                  p << "row.#{accessor_name(col)} = #{val};"
+                }
+              } # priv_row_from_cursor              
+              p.write("public:", -1)
+              # Constructor - initialize index handles.
+              p.next("#{tbl_classname}(db_t::table_handle _th, db_t &db) : TableBase(_th, db)","{}") {
+                indices(t).each {|iname, idef|
+                  p << ",#{accessor_name(idef)}(TableBase::get_index_handle(_th, \"#{iname}\"))"
+                }
+              }
+              # Row accessors
+              p << ''
+              p.next("void row_from_cursor(Row &row, const db_t::index_cursor_handle &crs) {", "}") {
+                p << "priv_row_from_cursor(row, crs);"
+              }
+              p.next("void row_from_cursor(Row &row, const db_t::table_cursor_handle &crs) {", "}") {
+                p << "priv_row_from_cursor(row, crs);"
+              }
+            } # class "#{tbl_classname}"
+          } # tables.each {}
+
+          p << ''
+          p << "class Schema : public SchemaBase"
+          p.next("{","}; //class Schema") {
+            p.next("static void up_schema(db_t &db) {","}") {
+              tables.each{|tn, t|
+                tbl_classname = make_table_classname(tn)
+                p << "#{tbl_classname}::up_schema(SchemaBase::get_table_handle(db, #{tn.inspect}));";
+              }
+            }
+            p << ''
+            p.write("public:", -1)
+            # Table accessors
+            tables.each {|tn, tdef|
+              tbl_classname = make_table_classname(tn)
+              p << "const #{tbl_classname} #{accessor_name(tdef)};"
+            }
+            p << ''
+            p.next("Schema(db_t &db) : SchemaBase(db, &up_schema)","{}") {
+              tables.each {|tn, tdef|
+                p << ",#{accessor_name(tdef)}(SchemaBase::get_table_handle(db, #{tn.inspect}), db)"
+              }              
+            }
+          }          
+        } # namespace <schemaname>
+        return p.format
+      end
+    end #class Cpp
+  end #module Model
+end
+

data/lib/oinky/dsl.rb

@@ -0,0 +1,167 @@
+# We don't strictly need to normalize here.  We'll do it
+# again in the emit phase.  However, normalize is also a 
+# syntax checker, so doing it early, as we're building the 
+# schema, makes error discovery more local and easier to diagnose.
+
+require 'oinky/normalize'
+
+module Oinky
+  module Model
+    module Internal
+      class IndexBuilder
+        def initialize(name, base = {})
+          @h = {
+            :name=>name.to_s, 
+            :columns=>(base[:columns] or []).clone,
+            :unique=>(base[:unique] or false)
+          }
+        end
+
+        def add_column(colname, ascending = true)
+          if colname.is_a? Hash
+            h = colname
+          else
+            h = {:name=>colname.to_s, :ascending=>ascending}
+          end
+          @h[:columns] << Oinky::Model.normalize_index_column_def(h)
+        end
+
+        def set_unique(val)
+          @h[:unique] = (val ? true : false)
+        end
+
+        def to_h
+          @h
+        end
+
+        # override name
+        def name(newname)
+          @h[:name] = newname.to_s
+        end
+      end
+
+      class TableBuilder
+        def initialize(base = {})
+          base = {:columns=>{}, :indices=>{}}.merge(base)
+          @h = {:columns=>base[:columns].clone, :indices=>base[:indices].clone}
+        end
+        Oinky::ColumnTypes.each {|ct|
+          define_method(ct) { |colname, h = {}|
+            add_column(colname, ct, h)
+          }
+        }
+        def add_column(colname, type, h = {})
+          v = {:type=>type}.merge(h)
+          k = colname.to_s
+          v = Oinky::Model.normalize_column_def(k,v)
+          @h[:columns][k] = v
+        end
+        def add_index(name, id = {:name=>name, :unique=>true, :columns=>[]})
+          k = name
+          if block_given?
+            s = IndexBuilder.new(name, id)
+            s.instance_eval &Proc.new
+            id = s.to_h
+            k = id[:name]
+          end
+          id = Oinky::Model.normalize_index_def(k,id)
+          id.delete(:name)
+          @h[:indices][k] = id
+        end
+        def to_h
+          @h
+        end
+
+        # override name
+        def name(newname)
+          @h[:name] = newname.to_s
+        end
+        def accessor(a)
+          @h[:accessor] = a.to_s
+        end
+      end
+
+      class SchemaBuilder
+        def initialize(name, base = {})
+          @h = {}
+          name = name.to_s
+          # clone 2 levels deep.  tabledef, not just tableset
+          base.each{|k,v|
+            if v.is_a? Hash
+
+              nv = {}
+              v.each{|k2,v2|
+                nv[k2] = v2.clone
+              }
+              @h[k] = nv
+            else
+              @h[k] = v
+            end
+          }
+          @h[:name] = name
+          @h[:version] ||= 1
+          @h[:tables] ||= {}
+        end
+
+        def create_table(tn, base = {})
+          if tn.is_a? Hash
+            base = tn
+            tn = tn[:name]
+          end
+          tn = tn.to_s
+          t = TableBuilder.new(base)
+          t.name tn
+          if block_given?
+            t.instance_eval &Proc.new
+          end
+          th = t.to_h
+          name = th[:name]
+          th = Oinky::Model.normalize_table_schema(name, th)
+          @h[:tables][name] = th
+          th
+        end
+
+        # override name
+        def name(newname)
+          @h[:name] = newname.to_s
+        end
+
+        def version(v)
+          @h[:version] = v
+        end
+
+        def classname(cn)
+          @h[:classname] = cn
+        end
+
+        def to_h
+          @h
+        end
+      end #module SchemaBuilder
+    end #module Internal
+
+    # Build an entire schema
+    def self.build_schema(name, base = {}, &b)
+      s = Internal::SchemaBuilder.new(name, base)
+      s.instance_eval &b
+      return s.to_h
+    end
+
+    # Build an entire schema, generate a ruby adapter class, and evaluate it
+    def self.build_schema_adapter(name, base = {}, &b)
+      s = build_schema(name, base, &b)
+      cls = eval Oinky::Model.generate(s, :ruby)
+      return cls
+    end
+
+    # Someone may want to create an unbound table-def and then reuse 
+    # it later in multiple schemas, or as a base definition for derived
+    # tables.
+    def self.build_table(name, base = {})
+      s = Internal::TableBuilder.new(base)
+      s.name(name)
+      s.instance_eval &Proc.new
+      s.to_h
+    end
+  end # Model
+end # Oinky