lims-core 3.2.3

data/lib/lims-core/persistence/sequel/migrations/add_audit_tables.rb

@@ -0,0 +1,147 @@
+module Lims::Core::Persistence::Sequel::Migrations
+  module AddAuditTables
+    def self.migration(exclude_tables={}, additional_tables_to_update=[])
+      [:schema_info, :sessions, :primary_keys].each do |table|
+        exclude_tables[table] = true
+      end
+      this = self
+      Proc.new do
+        next unless defined?(DB)
+        table_names = []
+        change do
+          if additional_tables_to_update.size == 0
+            # Create session table
+            create_table :sessions do
+              primary_key :id
+              String :user
+              String :backend_application_id
+              String :parameters, :text => true
+              boolean :success
+              timestamp :start_time
+              DateTime :end_time
+            end
+          end
+
+          #create migration session
+          self << <<-EOS
+          INSERT INTO sessions(user, backend_application_id)
+          VALUES('admin', 'lims-core');
+          EOS
+
+          session_id = DB[:sessions].order(:id).last[:id]
+
+          tables_to_update = additional_tables_to_update.size == 0 ? DB.tables : additional_tables_to_update
+          tables_to_update.each do |table_name|
+            next if exclude_tables.include?(table_name)  
+            table_names << table_name
+            table = DB[table_name]
+
+            # extend all tables with revision_id
+            if DB[table].columns.include?(:revision)  == false
+              alter_table table_name do             
+                add_column :revision,  Integer, :default => 1
+              end
+            end
+
+
+            # create history table
+            revision_table = "#{table_name}_revision"
+            self << <<-EOS
+            CREATE TABLE #{revision_table} AS
+            SELECT *, 'initial' AS `action`, #{session_id} as session_id
+            FROM #{table_name}
+            EOS
+
+            puts "adding key to #{revision_table}"
+            alter_table revision_table do
+              add_primary_key :internal_id
+              add_index [:id, :revision], :unique => true
+              add_index [:id, :session_id], :unique => true
+              add_foreign_key [:session_id], :sessions, :key => :id
+            end
+
+
+            # Create trigger              
+            trigger_name = "maintain_#{table_name}_on_insert"
+            self  << "DROP TRIGGER IF EXISTS #{trigger_name};"
+            trigger_code = <<-EOT
+
+            CREATE TRIGGER #{trigger_name}  AFTER INSERT ON  #{table_name}
+            FOR EACH ROW
+            BEGIN
+            #{this.insert_into_revision(table, revision_table, :insert)}
+            EOT
+
+            puts trigger_code
+            self << trigger_code
+
+            trigger_name = "maintain_#{table_name}_on_update"
+            self  << "DROP TRIGGER IF EXISTS #{trigger_name};"
+            trigger_code = <<-EOT
+
+            CREATE TRIGGER #{trigger_name}  BEFORE UPDATE ON  #{table_name}
+            FOR EACH ROW
+            BEGIN
+            # Update the revision number
+            SET NEW.revision = OLD.revision+1;
+            # Update the revision table
+            #{this.insert_into_revision(table, revision_table, :update)}
+            EOT
+
+            puts trigger_code
+            self << trigger_code
+
+            trigger_name = "maintain_#{table_name}_on_delete"
+            self  << "DROP TRIGGER IF EXISTS #{trigger_name};"
+            trigger_code = <<-EOT
+
+            CREATE TRIGGER #{trigger_name}  BEFORE DELETE ON  #{table_name}
+            FOR EACH ROW
+            BEGIN
+            #{this.insert_into_revision(table, revision_table, :delete)}
+            EOT
+
+            puts trigger_code
+            self << trigger_code
+          end
+
+          if additional_tables_to_update.size > 0
+            self << "DROP VIEW IF EXISTS revisions"
+          end
+
+          revision_tables = DB.tables.map { |table| table unless table.match(/revision/) }.compact
+          revision_tables -= exclude_tables.keys
+
+          view_code = "CREATE VIEW revisions AS " + revision_tables.map do |table_name|
+            revision_table = "#{table_name}_revision"
+            %Q{ SELECT '#{table_name}' AS revision_table,
+            id,
+            action,
+            session_id
+            FROM #{revision_table}
+
+          }
+          end.join(' UNION ')
+
+          puts view_code
+          self << view_code
+        end
+      end
+    end
+
+    def self.insert_into_revision(table, revision_table, type)
+      %Q{ INSERT INTO #{revision_table}                                 
+      SET #{
+        if type == :delete
+          'id = OLD.id, revision = OLD.revision+1'
+        else
+          table.columns.map { |c| "`#{c}` = NEW.#{c}" }.join(', ')
+        end
+      },
+      `action` = '#{type}',
+      `session_id` = @current_session_id;
+      END;
+      }
+    end
+  end
+end

data/lib/lims-core/persistence/sequel/migrations/initial.rb

@@ -0,0 +1,156 @@
+# This module should not be require on it's own.
+# Require migrations instead.
+
+module Lims::Core::Persistence::Sequel::Migrations
+  Initial = Proc.new do
+    change do
+      create_table :samples do
+        primary_key :id
+        String :name
+      end
+
+      create_table :oligos do
+        primary_key :id
+        String :sequence
+      end
+
+      create_table :aliquots do
+        primary_key :id
+        foreign_key :sample_id, :samples, :key => :id
+        foreign_key :tag_id, :oligos, :key => :id
+        Integer :quantity
+        String :type
+      end
+
+      create_table :flowcells do
+        primary_key :id
+        Integer :number_of_lanes
+      end
+
+      create_table :lanes do
+        #primary_key :flowcell_id, :position
+        primary_key :id
+        foreign_key :flowcell_id, :flowcells, :key => :id
+        Integer :position
+        foreign_key :aliquot_id, :aliquots, :key => :id
+      end
+
+      create_table :tubes do
+        primary_key :id
+      end
+
+      create_table :tube_aliquots do
+        primary_key :id
+        Integer :tube_id
+        foreign_key :aliquot_id, :aliquots, :key => :id
+      end
+
+      create_table :spin_columns do
+        primary_key :id
+      end
+
+      create_table :spin_column_aliquots do
+        primary_key :id
+        Integer :spin_column_id
+        foreign_key :aliquot_id, :aliquots, :key => :id
+      end
+
+      create_table :plates do
+        primary_key :id
+        Integer :number_of_rows
+        Integer :number_of_columns
+      end
+
+      create_table :wells do
+        primary_key :id
+        foreign_key :plate_id, :plates, :key => :id
+        Integer :position
+        foreign_key :aliquot_id, :aliquots, :key => :id
+      end
+
+      create_table :tube_racks do
+        primary_key :id
+        Integer :number_of_rows
+        Integer :number_of_columns
+      end
+
+      create_table :tube_rack_slots do
+        primary_key :id
+        foreign_key :tube_rack_id, :tube_racks, :key => :id
+        Integer :position
+        foreign_key :tube_id, :tubes, :key=> :id
+      end
+
+      create_table :tag_groups do
+        primary_key :id
+        String :name
+      end
+
+      create_table :tag_group_associations do
+        primary_key :id
+        foreign_key :tag_group_id, :tag_groups, :key => :id
+        Integer :position
+        foreign_key :oligo_id, :oligos, :key => :id
+      end
+
+      create_table :uuid_resources do
+        primary_key :id
+        String :uuid, :fixed => true, :size => 64
+        String :model_class
+        Integer :key
+      end
+
+      create_table :users do
+        primary_key :id
+      end
+
+      create_table :studies do
+        primary_key :id
+      end
+
+      create_table :orders do
+        primary_key :id
+        foreign_key :creator_id, :users, :key => :id
+
+        String :pipeline
+        String :parameters
+        String :status
+        blob :state
+        foreign_key :study_id, :studies, :key => :id
+        String :cost_code
+      end
+
+      create_table :items do
+        primary_key :id
+        foreign_key :order_id, :orders, :key => :id
+        String :role
+        foreign_key :resource_id, :uuid_resources, :key => :id
+        String :uuid, :fixed => true, :size => 64
+        String :status
+        Integer :iteration, :default => 0
+      end
+
+      create_table :searches do
+        primary_key :id
+        String :description
+        String :filter_type
+        String :model
+        blob :filter_parameters
+      end
+
+      create_table :labellables do
+        primary_key :id
+        String :name
+        String :type
+      end
+
+      create_table :labels do
+        primary_key :id
+        foreign_key :labellable_id, :labellables, :key => :id
+        String :type
+        String :position
+        String :value
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/sequel/persistor.rb

@@ -0,0 +1,200 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+require 'lims-core/persistence/identity_map'
+require 'active_support/inflector'
+require 'lims-core/persistence/sequel/filters'
+
+module Lims::Core
+  module Persistence
+    module Sequel
+      # Mixin giving extended the persistor classes with
+      # the Sequel (load/save) behavior.
+      module Persistor
+
+        include Filters
+
+        def self.included(klass)
+          klass.class_eval do
+            # @return [String] the name of SQL table.
+            def self.table_name
+              @table_name ||= parent_scope.name.split('::').last.pluralize.snakecase.to_sym
+            end
+            # The Sequel::Dataset.
+            # Corresponds to table.
+            # @param [Sequel::Session] session 
+            # @return [::Sequel::Dataset]
+            def self.dataset(session)
+              session.database[self.table_name]
+            end
+          end
+        end
+
+        def initialize(session_or_persistor, dataset=nil, *args, &block )
+          id_to_state, object_to_state = [nil, nil]
+          case session_or_persistor
+          when Sequel::Persistor
+            # We link the session and the identity map variables,
+            # so that object loaded via this persistor can be found (and their id)
+            # through the origial persistor.
+            # Hack to get those private variables.
+            session, identity_map_parameters  =  session_or_persistor.instance_eval do
+              [@session, [@id_to_state, @object_to_state]]
+            end
+            super(session, *args, &block)
+            @id_to_state , @object_to_state = identity_map_parameters
+          else Session
+            super(session_or_persistor, *args, &block)
+          end
+
+          @dataset = dataset || self.class.dataset(@session)
+        end
+
+        # @return  [String] the name of the table
+        def table_name
+          self.class.table_name
+        end
+
+
+        # The Sequel::Dataset.
+        # Corresponds to a table.
+        # @return [::Sequel::Dataset]
+        def dataset
+          @dataset
+        end
+
+
+        # Returns the number of object in the store
+        # @return [Fixnum]
+        def count
+          dataset.count
+        end
+
+        protected
+        # load a slice.
+        def for_each_in_slice(start, length)
+          return if length == 0
+          dataset.order(primary_key).limit(length, start).each do |h|
+            yield(h)
+          end
+        end
+
+        # The primary key 
+        # @return [Symbol]
+        def primary_key()
+          :id
+        end
+
+        def qualified_key
+          @qualified_key ||= ::Sequel.qualify(self.class.table_name, primary_key)
+        end
+
+        def bulk_load(ids, *params, &block)
+          dataset.filter(qualified_key => ids.map(&:id)).all(&block)
+        end
+        public :bulk_load
+
+        def ids_for(criteria)
+          dataset.select(qualified_key).filter(criteria).map { |h| h[primary_key] }
+
+        end
+
+        # Save a raw object, i.e. the object
+        # attributes excluding any associations.
+        # @param [Resource] object the object 
+        # @return [Fixnum, nil] the Id if save successful
+        def insert(state, *params)
+          # use prepared statement for everything
+          # We only need it at the moment as a workaround for saving the UUID
+          # So we might in the future either move it to a UuidResourcePersistor
+          # or cached it by attributes
+          # @todo benchmark against normal insert
+          attributes = filter_attributes_on_save(state.resource.attributes, *params)
+          dataset.insert(attributes).tap { |id| state.id = id }
+        end
+
+        def bulk_insert(states, *params)
+          #super(states, *params)
+          bulk_insert_multi(states, *params)
+          #bulk_insert_prepared(states, *params)
+        end
+        public :bulk_insert
+
+        def bulk_insert_prepared(states, *params)
+          # use prepared statement for everything
+          # We only need it at the moment as a workaround for saving the UUID
+          # So we might in the future either move it to a UuidResourcePersistor
+          # or cached it by attributes
+          # @todo benchmark against normal insert
+            attributes = filter_attributes_on_save(states.first.resource.attributes, *params)
+          statement_name = :"#{table_name}__save_raw"
+          dataset.prepare(:insert, statement_name, attributes.keys.mash { |k| [k, :"$#{k}"] })
+
+          states.each do |state|
+            attributes = filter_attributes_on_save(state.resource.attributes, *params)
+            @session.database.call(statement_name, attributes)
+          end
+        end
+
+        # @todo
+        def bulk_insert_multi(states, *params)
+          free_ids = get_next_available_ids(states.size)
+          states.inject(0) { |i,s| s.id = free_ids[i]; i+1 }
+          attributes = states.map { |state| filter_attributes_on_save(state.resource.attributes, *params).merge(primary_key => state.id) }
+          dataset.multi_insert(attributes)
+        end
+
+        def bulk_update_raw_attributes(attributes, *params)
+          return dataset.on_duplicate_key_update.multi_insert(attributes) if dataset.respond_to? :on_duplicate_key_update
+          attributes.each { |att| dataset.filter(primary_key => att.delete(primary_key)).update(att) }
+        end
+
+        def bulk_delete_raw(ids, *params)
+          dataset.filter(primary_key => ids).delete
+        end
+
+        def delete_raw(objec, id, *params)
+          id.tap do
+            dataset.filter(primary_key => id).delete
+          end
+        end
+
+        # Return a sequence of free ids, ready to be inserted.
+        # The last used id corresponding to each table is store in a special table.
+        # We need to lock the table to avoid to thread or process to 'use' the same ids.
+        # @param [Integer] quantity
+        # @return [Array<Integer>]
+        def get_next_available_ids(quantity = 1)
+          @session.lock(dataset.from(:primary_keys), true) do |primary_keys|
+            current_key_row = primary_keys.first(:table_name => table_name.to_s) 
+            if current_key_row
+              current_key = current_key_row[:current_key]
+            else
+              # We lock again primary keys and the dataset, because doing a new MySQL lock
+              # unlock the previous locked tables.
+              # Also we need to check again at this point if the primary_keys table has not
+              # been updated by another request. In fact, doing the lock below unlock first
+              # primary_keys table, and then lock it again with dataset table. If during this laps
+              # of time (between unlock and lock), another request try to initialize primary_keys table, 
+              # we could have duplicate rows.
+              current_key = @session.lock([primary_keys, dataset]) do |primary_keys_dataset, resource_dataset|
+                primary_key_row = primary_keys_dataset.first(:table_name => table_name.to_s)
+                if primary_key_row
+                  primary_key_row[:current_key]
+                else
+                  last_id = resource_dataset.max(primary_key) || 0
+                  primary_keys_dataset.insert(:table_name => table_name.to_s, :current_key => last_id)
+                  last_id
+                end
+              end
+            end
+
+            new_current_key = current_key + quantity
+            primary_keys.where(:table_name => table_name.to_s).update(:current_key => new_current_key)
+            (current_key+1..new_current_key).to_a
+          end
+        end
+      end
+    end
+  end
+end
+require 'lims-core/persistence/sequel/filters'