sqlyzer 0.1

data/lib/sqlyzer/associate.rb

@@ -0,0 +1,184 @@
+# SQLYZER Ruby Object serializer to SQL.
+# For more information visit http://sqlyzer.rubyforge.org
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+
+require 'sqlyzer/errors'
+
+module  Sqlyzer
+
+  module    Associate
+
+    public
+
+    class     Link
+      include Serializer
+
+      public
+
+      def     initialize(owner, key)
+        @source = owner.method key
+        @updated = {}
+        @current_var = get_current_var
+      end
+
+      protected
+
+      def     sql_table(table, keys, values)
+        super(table, keys, values) +
+        sql_alter_table_fk(
+          table,
+          SQL_LINK_FROM::SQL_CONTAINER_TABLE,
+          SQL_LINK_FROM_FK.keys,
+          SQL_LINK_FROM_FK.values
+        ) +
+        sql_alter_table_fk(
+          table,
+          SQL_LINK_TO::SQL_CONTAINER_TABLE,
+          SQL_LINK_TO_FK.keys,
+          SQL_LINK_TO_FK.values
+        )
+      end
+
+      def     set_current_item(item)
+        assertUnreached
+      end
+
+      private
+
+      def     get_current_var
+        @source.call
+      end
+
+      def     update_to_new_var(event, item)
+        @updated.each { |item, event|
+          set_current_item item
+          if event == :link_add
+            ::Handler::request self, :sql_insert
+          else
+            ::Handler::request self, :sql_delete
+          end
+        }
+        @updated.clear
+        @current_var = get_current_var
+      end
+
+      public
+
+      def     push(*items)
+        for item in items
+          @updated[item] = :link_add unless @current.include?(item)
+        end
+      end
+
+      def     pop(*items)
+        for item in items
+          @updated[item] = :link_del if @current.include?(item)
+        end
+      end
+
+      public
+
+      def     flush
+        update_to_new_var unless @updated.empty?
+      end
+
+      public
+
+      def     Link.make(from, to, owner, key)
+        idx = "#{from}_to_#{to}"
+        return @@klasses[idx] if @@klasses.include?(idx)
+      end
+
+    end
+
+    private
+
+    module    Keys
+
+      public
+
+      def     Keys.link(owner, key, klass)
+        if owner.const_defined?(:SQL_ASSOCIATE_VARS)
+          old = owner.const_get :SQL_ASSOCIATE_VARS
+          old[key] = klass
+          owner.const_set :SQL_ASSOCIATE_VARS, old
+        else
+          owner.const_set :SQL_ASSOCIATE_VARS, { key => klass }
+        end
+      end
+
+      public
+
+      def     sql_associate_keys
+        self.class::SQL_ASSOCIATE_KEYS
+      end
+
+      def     sql_associate_each(&block)
+        sql_associate_keys.each(&block)
+      end
+
+    end #~    Keys
+
+    public
+
+    module    One
+      include Keys
+
+      public
+
+      def     One.link(owner, key, klass)
+        Keys.link owner, key, klass
+      end
+
+      public
+
+      def   sql_associate_select
+      end
+
+      def   sql_associate_update
+      end
+
+      def   sql_associate_insert
+      end
+
+    end #~    One
+
+    module    Many
+      include Keys
+
+      public
+
+      def     Many.link(owner, key, klass)
+        Keys.link owner, key, klass
+      end
+
+      public
+
+      def   sql_associate_select
+      end
+
+      def   sql_associate_update
+      end
+
+      def   sql_associate_insert
+      end
+
+    end
+
+  end #~    Associate
+
+end #~ Sqlyzer

data/lib/sqlyzer/container.rb

@@ -0,0 +1,140 @@
+# SQLYZER Ruby Object serializer to SQL.
+# For more information visit http://sqlyzer.rubyforge.org
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+
+require 'sqlyzer/errors'
+require 'sqlyzer/parameters'
+
+module  Sqlyzer
+
+  #
+  #This Mixin is dedicated to Sql components registering for one class extended
+  #by Sqlyzer::Serializer.
+  #
+  #Here is the list of stored data :
+  #* name of the future Sql table (SQL_CONTAINER_TABLE),
+  #* primary keys of the future Sql table (SQL_CONTAINER_KEYS),
+  #* regular fields of the future Sql table (SQL_CONTAINER_VALUES).
+  #
+  module    Container
+
+    public
+
+    #
+    #Retreive chosen table identifier for current class.
+    #This method is reading the constant named SQL_CONTAINER_TABLE.
+    #
+    def     sql_container_table
+      self.class::SQL_CONTAINER_TABLE
+    end
+
+    #
+    #Retreive the list of registered Sqlyzer::Parameter::Default class (stored in
+    #a Sqlyzer::Parameter::List object) as current class primary keys.
+    #This method is reading the constant named SQL_CONTAINER_KEYS.
+    #
+    def     sql_container_keys
+      self.class::SQL_CONTAINER_KEYS
+    end
+
+    #
+    #Retreive the list of registered Sqlyzer::Parameter::Default class (stored in
+    #a Sqlyzer::Parameter::List object) as current class regular table fields.
+    #This method is reading the constant named SQL_CONTAINER_VALUES.
+    #
+    def     sql_container_values
+      self.class::SQL_CONTAINER_VALUES
+    end
+
+    protected
+    
+    #
+    #Yield the list of Sqlyzer::Parameter::Default classes registered as object 
+    #Sql keys.
+    #
+    #See also sql_container_keys.
+    #
+    def     sql_each_keys(&block)
+      sql_container_keys.each(&block)
+    end
+
+    #
+    #Yield the list of Sqlyzer::Parameter::Default classes registered as object 
+    #Sql values.
+    #
+    #See also sql_container_values.
+    #
+    def     sql_each_values(&block)
+      sql_container_values.each(&block)
+    end
+
+    private
+
+    #
+    #Called to define or redefine the _owner_ constant named _dest_ by concating
+    #the previous value of _dest_ with _source_ value.
+    #If _dest_ was not defined, it is initialized as a Sqlyzer::Parameter::List
+    #contained all _source_ items (but translated).
+    #
+    #See also Sqlyzer::Parameter::List.
+    #
+    def     Container.sql_container_has(owner, dest, source)
+      if owner.const_defined?(dest)
+        old = owner.const_get(dest)
+        owner.const_set(dest, old + source)
+      else
+        owner.const_set(dest, Parameter::List.new(source))
+      end
+    end
+
+    #
+    #Called to set a constant named _dest_ and containing _name_ (considered as
+    #a String) in _owner_ class.
+    #
+    def     Container.sql_container_set(owner, dest, name)
+      owner.const_set dest, name.to_s
+    end
+
+    public
+
+    #
+    #Register _data_ into _owner_ class as list of table primary keys.
+    #Call to this method will define or complete SQL_CONTAINER_KEYS constant.
+    #
+    def     Container.sql_has_keys(owner, data)
+      Container::sql_container_has owner, :SQL_CONTAINER_KEYS, data
+    end
+
+    #
+    #Register _data_ into _owner_ class as list of table regular fields.
+    #Call to this method will define or complete SQL_CONTAINER_VALUES constant.
+    #
+    def     Container.sql_has_values(owner, data)
+      Container::sql_container_has owner, :SQL_CONTAINER_VALUES, data
+    end
+
+    #
+    #Register _name_ into _owner_ class as the name of Sql table.
+    #Call to this method will define or redefine SQL_CONTAINER_TABLE constant.
+    #
+    def     Container.sql_set_table(owner, name)
+      Container::sql_container_set owner, :SQL_CONTAINER_TABLE, name.to_s.downcase
+    end
+
+  end     #~ Container
+
+end #~ Sqlyzer

data/lib/sqlyzer/create.rb

@@ -0,0 +1,189 @@
+# SQLYZER Ruby Object serializer to SQL.
+# For more information visit http://sqlyzer.rubyforge.org
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+
+require 'sqlyzer/errors'
+
+module  Sqlyzer
+
+  module  Sql
+
+    #
+    #Generate SQL commands for tables creation.
+    #
+    module    Create
+      
+      private
+      
+      #
+      #Generate a basic CREATE Sql command for given _type_ called _name_.
+      #
+      def     Create._sql_create(type, name)
+        "CREATE #{type.to_s.upcase} #{name} " +
+       (block_given? ? yield : '') +
+        ';'
+      end
+
+      #
+      #Generate a basic REPLACE Sql command for given _type_ called _name_.
+      #Concat block code return value if block given.
+      #      
+      def     Create._sql_replace(type, name)
+        "REPLACE #{type.to_s.upcase} #{name} " +
+       (block_given? ? yield : '') +
+        ';'
+      end
+      
+      #
+      #Generate a basic CREATE OR REPLACE Sql command for given _type_ called _name_.
+      #Concat block code return value if block given.      
+      #      
+      def     Create._sql_create_or_replace(type, name)
+        "CREATE OR REPLACE #{type.to_s.upcase} #{name} " +
+       (block_given? ? yield : '') +
+        ';'
+      end
+      
+      #
+      #Generate a basic ALTER Sql command for given _type_ called _name_.
+      #Concat block code return value if block given.      
+      #            
+      def     Create._sql_alter(type, name)
+        "ALTER #{type.to_s.upcase} #{name} " +
+       (block_given? ? yield : '') +
+        ';'
+      end
+      
+      #
+      #Generate a basic DROP Sql command for given _type_ called _name_.
+      #_opts_ will be added at the end of the command (before semicolon).
+      #Concat block code return value if block given.      
+      #            
+      def     Create._sql_drop(type, name, opts = '')
+        "DROP #{type.to_s.upcase} #{name} #{opts};"
+      end
+      
+      public
+      
+      #
+      #Create a new table called _name_, with Sqlyzer::Parameter::List _keys_ as 
+      #primary keys and values as regular fields.
+      #The fresh table may be optionally inherited from an other table call 
+      #_inherit_from_ if not nil.
+      #
+      def     sql_create_table(name, keys, values, inherit_from = nil)
+        Create::_sql_create('TABLE', name) {
+          content = keys.clone.concat(values)
+          content.collect! { |p|
+            "#{p}\t#{p.to_sql_type}\t NOT NULL"
+          }
+          if inherit_from
+            "(\n#{content.join ",\n"}\n) INHERITS (#{inherit_from})"
+          else
+            "(\n#{content.join ",\n"}\n)"
+          end
+        }
+      end
+      
+      #
+      #Generate a basic Sql ALTER command on table called _name_.
+      #Concat _block_ return value.
+      #
+      def     sql_alter_table(name, &block)
+        Create::_sql_alter('TABLE', name, &block)
+      end
+      
+      #
+      #Drop the table called _name_.
+      #The method will remove linked Sql objects if _cascade_ is true.
+      #
+      def     sql_drop_table(name, cascade = true)
+        if cascade
+          Create::_sql_drop('TABLE', name, 'CASCADE')
+        else
+          Create::_sql_drop('TABLE', name)
+        end
+      end
+      
+      public
+      
+      #
+      #Create an index on fields _keys_ from table called _name_.
+      #_keys_ is assumed to be a Sqlyzer::Parameter::List.
+      #
+      def     sql_create_table_index(name, keys)
+        Create::_sql_create('INDEX', "#{name.to_s.upcase}_PK") {
+          "ON #{name} (\n\t" +
+          keys.to_a.join(",\n\t") +
+          "\n)"
+        }
+      end
+      
+      #
+      #Create an unique index on primary keys _keys_ from table called _name_.
+      #_keys_ is assumed to be a Sqlyzer::Parameter::List.
+      #      
+      def     sql_create_table_unique_index(name, keys)
+        Create::_sql_create('UNIQUE INDEX', "#{name.to_s.upcase}_PK") {
+          "ON #{name} (\n\t" +
+          keys.to_a.join(",\n\t") +
+          "\n)"
+        }
+      end
+      alias   sql_create_table_index! sql_create_table_unique_index
+      
+      public
+      
+      #
+      #Generate a PRIMARY KEY constraint on fields _keys_ from table called _name_.
+      #_keys_ is assumed to be a Sqlyzer::Parameter::List.
+      #
+      def     sql_alter_table_pk(name, keys)
+        sql_alter_table(name) {
+          "ADD CONSTRAINT PK_#{name.to_s.upcase} PRIMARY KEY (\n\t" +
+          keys.to_a.join(",\n\t") +
+          "\n)"
+        }
+      end
+      alias   sql_alter_primary_key sql_alter_table_pk
+
+      #
+      #Generate a FOREIGN KEY constraint on fields _from_ from table called _source_ 
+      #to another called _dest_ on fields _to_.
+      #If _to_ is nil, assumed that the fields have the same name in both _source_
+      #and _dest_ tables.
+      #If _cascade_ is true, rows will be deleted on reference break.
+      #_from_ and _to_ are assumed to be a Sqlyzer::Parameter::List.
+      #
+      def     sql_alter_table_fk(source, dest, from, to = nil, cascade = true)
+        to = from unless to
+        cascade = cascade ? "CASCADE" : "RESTRICT"
+        sql_alter_table(source) {
+          "ADD CONSTRAINT FK_#{source.to_s.upcase}_TO_#{dest.to_s.upcase} FOREIGN KEY (\n\t" +
+          from.join(",\n\t") +
+          "\n) REFERENCES #{dest} (\n\t" +
+          to.join(",\n\t") +
+          "\n) ON UPDATE #{cascade} ON DELETE #{cascade}"
+        }
+      end
+      alias   sql_alter_foreign_key sql_alter_table_fk
+      
+    end #~ Create
+    
+  end #~ Sql
+  
+end #~ Sqlyzer