bio-ucsc-api 0.3.1 → 0.4.0

data/lib/bio-ucsc/susscr2/mrna.rb

@@ -12,25 +12,28 @@ module Bio
     module SusScr2
 
       class Mrna
+        include DBConnector
+        DBConnection.database "susScr2"
+
         KLASS = "Mrna"
         KLASS_S = "mrna"
 
         Bio::Ucsc::SusScr2::CHROMS.each do |chr|
           class_eval %!
             class #{chr[0..0].upcase + chr[1..-1]}_#{KLASS} < DBConnection
-              set_table_name "#{chr[0..0].downcase + chr[1..-1]}_#{KLASS_S}"
-              set_primary_key nil
-              set_inheritance_column nil
+              self.table_name = "#{chr[0..0].downcase + chr[1..-1]}_#{KLASS_S}"
+              self.primary_key = nil
+              self.inheritance_column = nil
 
-              def self.find_by_interval(interval, opt = {:partial => true})
+              def self.find_by_interval(interval, opt = {:partial => true}); interval = Bio::Ucsc::Gi.wrap(interval)
                 find_first_or_all_by_interval(interval, :first, opt)
               end
         
-              def self.find_all_by_interval(interval, opt = {:partial => true})
+              def self.find_all_by_interval(interval, opt = {:partial => true}); interval = Bio::Ucsc::Gi.wrap(interval)
                 find_first_or_all_by_interval(interval, :all, opt)
               end
 
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
+              def self.find_first_or_all_by_interval(interval, first_all, opt); interval =  Bio::Ucsc::Gi.wrap(interval)
                 zstart = interval.zero_start
                 zend   = interval.zero_end
                 if opt[:partial] == true
@@ -63,13 +66,13 @@ AND  (tEnd BETWEEN :zstart AND :zend))
           !
         end # each chromosome
 
-        def self.find_by_interval(interval, opt = {:partial => true})
+        def self.find_by_interval(interval, opt = {:partial => true}); interval = Bio::Ucsc::Gi.wrap(interval)
           chrom = interval.chrom[0..0].upcase + interval.chrom[1..-1]
           chr_klass = self.const_get("#{chrom}_#{KLASS}")
           chr_klass.__send__(:find_by_interval, interval, opt)
         end
 
-        def self.find_all_by_interval(interval, opt = {:partial => true})
+        def self.find_all_by_interval(interval, opt = {:partial => true}); interval = Bio::Ucsc::Gi.wrap(interval)
           chrom = interval.chrom[0..0].upcase + interval.chrom[1..-1]
           chr_klass = self.const_get("#{chrom}_#{KLASS}")
           chr_klass.__send__(:find_all_by_interval, interval, opt)

data/lib/bio-ucsc/table_class_detector.rb

@@ -1,7 +1,7 @@
 #
 # = table_class_detector.rb
 #
-# Copyright::   Copyright (C) 2011
+# Copyright::   Copyright (C) 2011, 2012
 #               MISHIMA, Hiroyuki
 #               <missy at be.to / hmishima at nagasaki-u.ac.jp> 
 # License::     The Ruby licence (Ryby's / GPLv2 dual)
@@ -24,13 +24,21 @@ module Bio
         ['HInv', 'NIAGene']
       COMMON_CLASS_METHODS = %!
         def self.find_by_interval(interval, opt = {:partial => true})
+          interval = Bio::Ucsc::Gi.wrap(interval)
           find_first_or_all_by_interval(interval, :first, opt)
         end
         
         def self.find_all_by_interval(interval, opt = {:partial => true})
+          interval = Bio::Ucsc::Gi.wrap(interval)
           find_first_or_all_by_interval(interval, :all, opt)
         end
       !
+      PARAMETERS = %!
+        { :chrom => interval.chrom,
+          :bins => interval.bin_all,
+          :zstart => interval.zero_start,
+          :zend => interval.zero_end, }
+      !
 
       def const_missing(sym)
         module_eval generic(sym)
@@ -39,35 +47,26 @@ module Bio
         case
         when (["bin", "tName", "tStart", "tEnd"] - col_names).empty?
           module_eval psl(sym, :bin => true)
-          const_get(sym)
         when (["bin", "tName", "tStart", "tEnd"] - col_names) == ["bin"]
           module_eval psl(sym, :bin => false)
-          const_get(sym)
 
         when (["bin", "chrom", "chromStart", "chromEnd"] - col_names).empty?
           module_eval bed(sym, :bin => true)
-          const_get(sym)
         when (["bin", "chrom", "chromStart", "chromEnd"] - col_names) == ["bin"]
           module_eval bed(sym, :bin => false)
-          const_get(sym)
 
         when (["bin", "chrom", "txStart", "txEnd"] - col_names).empty?
           module_eval genepred(sym, :bin => true)
-          const_get(sym)
         when (["bin", "chrom", "txStart", "txEnd"] - col_names) == ["bin"]
           module_eval genepred(sym, :bin => false)
-          const_get(sym)
 
         when (["bin", "genoName", "genoStart", "genoEnd"] - col_names).empty?
           module_eval rmsk(sym, :bin => true)
-          const_get(sym)
         when (["bin", "genoName", "genoStart", "genoEnd"] - col_names) == ["bin"]
           module_eval rmsk(sym, :bin => false)
-          const_get(sym)
-
-        else
-          const_get(sym)
         end
+        
+        const_get(sym)
       end
 
       # generic: tables without interval serarch supported
@@ -75,7 +74,7 @@ module Bio
       def generic(sym)
         %!
           class #{uphead(sym)} < DBConnection
-            set_table_name "#{downhead(sym)}"
+            self.table_name = "#{downhead(sym)}"
             #{delete_reserved_methods}
           end
         !
@@ -84,511 +83,287 @@ module Bio
       # PSL: Pattern Space Layout
       # interval search using tName/tStart/tEnd
       def psl(sym, opts={:bin => true})
-        case opts[:bin]
-        when true
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
-
-              where = <<-SQL
-    tName = :chrom
-AND bin in (:bins)
-AND ((tStart BETWEEN :zstart AND :zend)
- OR (tEnd BETWEEN :zstart AND :zend)
- OR (tStart <= :zstart AND tEnd >= :zend))
-                SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :bins => gi.bin_all,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-              where = <<-SQL
-     tName = :chrom
-AND bin in (:bins)
-AND ((tStart BETWEEN :zstart AND :zend)
-AND  (tEnd BETWEEN :zstart AND :zend))
-                SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :bins => gi.bin_all,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-
-                if opt[:partial] == true
-                  where = <<-SQL
-    tName = :chrom
-AND bin in (:bins)
-AND ((tStart BETWEEN :zstart AND :zend)
- OR (tEnd BETWEEN :zstart AND :zend)
- OR (tStart <= :zstart AND tEnd >= :zend))
-                  SQL
-                else
-                  where = <<-SQL
-    tName = :chrom 
-AND bin in (:bins)
-AND ((tStart BETWEEN :zstart AND :zend)
-AND  (tEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end
-                cond = {
+        if opts[:bin]
+          chrom_bin = "tName = :chrom AND bin in (:bins) "
+        else
+          chrom_bin = "tName = :chrom "
+        end
+
+        %!
+          class #{uphead(sym)} < DBConnection
+            self.table_name = "#{downhead(sym)}"
+            #{delete_reserved_methods}
+            #{COMMON_CLASS_METHODS}
+
+            def self.with_interval(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                  "(tStart BETWEEN :zstart AND :zend) " +
+                  "OR (tEnd BETWEEN :zstart AND :zend) " +
+                  "OR (tStart <= :zstart AND tEnd >= :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.with_interval_excl(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                  "(tStart BETWEEN :zstart AND :zend)" +
+                  "AND (tEnd BETWEEN :zstart AND :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.find_first_or_all_by_interval(interval, first_all, opt)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              zstart = interval.zero_start
+              zend   = interval.zero_end
+
+              if opt[:partial] == true
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                    "(tStart BETWEEN :zstart AND :zend) " +
+                    "OR (tEnd BETWEEN :zstart AND :zend) " +
+                    "OR (tStart <= :zstart AND tEnd >= :zend) )"
+              else
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                    "(tStart BETWEEN :zstart AND :zend) " +
+                    "AND (tEnd BETWEEN :zstart AND :zend) )"
+              end
+              cond = {
                 :chrom => interval.chrom,
                 :bins  => Ucsc::UcscBin.bin_all(zstart, zend),
                 :zstart => zstart,
-                :zend => zend,
-              }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
+                :zend => zend,}
+              self.find(first_all,
+                        { :select => "*",
+                          :conditions => [where, cond], })
             end
-          !
-        when false
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
-
-              where = <<-SQL
-         tName = :chrom
-  AND ((tStart BETWEEN :zstart AND :zend)
-  OR   (tEnd BETWEEN :zstart AND :zend)
-  OR   (tStart <= :zstart AND tEnd >= :zend))
-                  SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-              where = <<-SQL
-        tName = :chrom
-  AND ((tStart BETWEEN :zstart AND :zend)
-  AND  (tEnd BETWEEN :zstart AND :zend))
-                  SQL
-               scope(:with_interval_excl,
-                     Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-             
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-        tName = :chrom
-  AND ((tStart BETWEEN :zstart AND :zend)
-  OR   (tEnd BETWEEN :zstart AND :zend)
-  OR   (tStart <= :zstart AND tEnd >= :zend))
-                  SQL
-                else
-                  where = <<-SQL
-        tName  = :chrom
-  AND ((tStart BETWEEN :zstart AND :zend)
-  AND  (tEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end 
-                cond = {
-                  :chrom => interval.chrom,
-                  :zstart => zstart,
-                  :zend => zend,
-                }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
-            end
-          !
-        end # case opts[:bin]
+          end
+        !
       end # def psl
 
       # BED: Browser Extensible Description format
       # interval search using chrom/chromStart/chromEnd
       def bed(sym, opts={:bin => true})
-        case opts[:bin]
-        when true
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
+        if opts[:bin]
+          chrom_bin = "chrom = :chrom AND bin in (:bins) "
+        else
+          chrom_bin = "chrom = :chrom "
+        end
+
+        %!
+          class #{uphead(sym)} < DBConnection
+            self.table_name = "#{downhead(sym)}"
+            #{delete_reserved_methods}
+            #{COMMON_CLASS_METHODS}
  
-              where = <<-SQL
-    chrom = :chrom
- AND bin in (:bins)
- AND ((chromStart BETWEEN :zstart AND :zend)
-  OR (chromEnd BETWEEN :zstart AND :zend)
-  OR (chromStart <= :zstart AND chromEnd >= :zend))
-                SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :bins => gi.bin_all,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-              where = <<-SQL
-     chrom = :chrom 
- AND bin in (:bins)
- AND ((chromStart BETWEEN :zstart AND :zend)
- AND  (chromEnd BETWEEN :zstart AND :zend))
-                SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :bins => gi.bin_all,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-
-                if opt[:partial] == true
-                  where = <<-SQL
-    chrom = :chrom
-AND bin in (:bins)
-AND ((chromStart BETWEEN :zstart AND :zend)
- OR (chromEnd BETWEEN :zstart AND :zend)
- OR (chromStart <= :zstart AND chromEnd >= :zend))
-                SQL
-                else
-                  where = <<-SQL
-    chrom = :chrom 
-AND bin in (:bins)
-AND ((chromStart BETWEEN :zstart AND :zend)
-AND  (chromEnd BETWEEN :zstart AND :zend))
-                SQL
-                end
-                cond = {
+            def self.with_interval(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                  "(chromStart BETWEEN :zstart AND :zend)" +
+                  "OR (chromEnd BETWEEN :zstart AND :zend)" +
+                  "OR (chromStart <= :zstart AND chromEnd >= :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.with_interval_excl(interval)
+                interval = Bio::Ucsc::Gi.wrap(interval)
+                where(
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                    "(chromStart BETWEEN :zstart AND :zend) " +
+                    "AND (chromEnd BETWEEN :zstart AND :zend) )",
+                  #{PARAMETERS})
+            end
+
+            def self.find_first_or_all_by_interval(interval, first_all, opt); interval =  Bio::Ucsc::Gi.wrap(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              zstart = interval.zero_start
+              zend   = interval.zero_end
+
+              if opt[:partial] == true
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                    "(chromStart BETWEEN :zstart AND :zend) " +
+                    "OR (chromEnd BETWEEN :zstart AND :zend) " +
+                    "OR (chromStart <= :zstart AND chromEnd >= :zend) )"
+              else
+                where =
+                 "#{chrom_bin}" +
+                 "AND ( " +
+                   "(chromStart BETWEEN :zstart AND :zend)" +
+                   "AND (chromEnd BETWEEN :zstart AND :zend))"
+              end
+              cond = {
                 :chrom => interval.chrom,
                 :bins  => Ucsc::UcscBin.bin_all(zstart, zend),
                 :zstart => zstart,
-                :zend => zend,
-              }          
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
-            end
-          !
-        when false
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
-
-              where = <<-SQL
-         chrom = :chrom
-  AND ((chromStart BETWEEN :zstart AND :zend)
-  OR   (chromEnd BETWEEN :zstart AND :zend)
-  OR   (chromStart <= :zstart AND chromEnd >= :zend))
-                SQL
-                scope(:with_interval,
-                      Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                            :zstart => gi.zero_start,
-                                                            :zend => gi.zero_end,}]}})
-              where = <<-SQL
-        chrom = :chrom 
-  AND ((chromStart BETWEEN :zstart AND :zend)
-  AND  (chromEnd BETWEEN :zstart AND :zend))
-                SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-        chrom = :chrom
-  AND ((chromStart BETWEEN :zstart AND :zend)
-  OR   (chromEnd BETWEEN :zstart AND :zend)
-  OR   (chromStart <= :zstart AND chromEnd >= :zend))
-                  SQL
-                else
-                  where = <<-SQL
-        chrom = :chrom 
-  AND ((chromStart BETWEEN :zstart AND :zend)
-  AND  (chromEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end 
-                cond = {
-                  :chrom => interval.chrom,
-                  :zstart => zstart,
-                  :zend => zend,
-                }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
+                :zend => zend, }          
+              self.find(first_all,
+                        { :select => "*",
+                          :conditions => [where, cond], })
             end
-          !
-        end # case opts[:bin]
+          end
+        !
       end # def bed
  
       # genePred: Gene and gene-prediction features
       # interval search using chrom/txStart/txEnd
       def genepred(sym, opts={:bin => true})
-        case opts[:bin]
-        when true
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS} 
-
-              where = <<-SQL
-      chrom = :chrom
-AND   bin in (:bins)
-AND ((txStart BETWEEN :zstart AND :zend)
- OR  (txEnd BETWEEN :zstart AND :zend)
- OR  (txStart <= :zstart AND txEnd >= :zend))
-                SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :bins => gi.bin_all,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-
-               where = <<-SQL
-      chrom = :chrom 
-AND   bin in (:bins)
-AND ((txStart BETWEEN :zstart AND :zend)
-AND  (txEnd BETWEEN :zstart AND :zend))
-                  SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :bins => gi.bin_all,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-      chrom = :chrom
-AND   bin in (:bins)
-AND ((txStart BETWEEN :zstart AND :zend)
- OR  (txEnd BETWEEN :zstart AND :zend)
- OR  (txStart <= :zstart AND txEnd >= :zend))
-                SQL
-                else
-                where = <<-SQL
-      chrom = :chrom
-AND   bin in (:bins)
-AND ((txStart BETWEEN :zstart AND :zend)
-AND  (txEnd BETWEEN :zstart AND :zend))
-                SQL
-                end
-                cond = {
+        if opts[:bin]
+          chrom_bin = "chrom = :chrom AND bin in (:bins) "
+        else
+          chrom_bin = "chrom = :chrom "
+        end
+
+        %!
+          class #{uphead(sym)} < DBConnection
+            self.table_name = "#{downhead(sym)}"
+            #{delete_reserved_methods}
+            #{COMMON_CLASS_METHODS} 
+
+            def self.with_interval(interval)
+             interval = Bio::Ucsc::Gi.wrap(interval)
+             where(
+               "#{chrom_bin}" +
+               "AND ( " +
+                 "(txStart BETWEEN :zstart AND :zend) " +
+                 "OR (txEnd BETWEEN :zstart AND :zend) " +
+                 "OR (txStart <= :zstart AND txEnd >= :zend) )",
+               #{PARAMETERS})
+            end
+
+            def self.with_interval_excl(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                  "(txStart BETWEEN :zstart AND :zend) " +
+                  "AND  (txEnd BETWEEN :zstart AND :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.find_first_or_all_by_interval(interval, first_all, opt); interval =  Bio::Ucsc::Gi.wrap(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              zstart = interval.zero_start
+              zend   = interval.zero_end
+              if opt[:partial] == true
+                where = 
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                  "(txStart BETWEEN :zstart AND :zend)" +
+                  "OR (txEnd BETWEEN :zstart AND :zend)" +
+                  "OR (txStart <= :zstart AND txEnd >= :zend))"
+              else
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                  "(txStart BETWEEN :zstart AND :zend)" +
+                  "AND (txEnd BETWEEN :zstart AND :zend) )"
+              end
+              cond = {
                 :chrom  => interval.chrom,
                 :bins   => Bio::Ucsc::UcscBin.bin_all(zstart, zend),
                 :zstart => zstart,
                 :zend   => zend,
               }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
+              self.find(first_all,
+                        { :select => "*",
+                          :conditions => [where, cond], })
             end
-          !
-        when false
-          %! 
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
-
-              where = <<-SQL
-       chrom = :chrom
-AND ((txStart BETWEEN :zstart AND :zend)
- OR   (txEnd BETWEEN :zstart AND :zend)
- OR   (txStart <= :zstart AND txEnd >= :zend))
-              SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end}]}})
-              where = <<-SQL
-        chrom = :chrom 
-  AND ((txStart BETWEEN :zstart AND :zend)
-  AND  (txEnd BETWEEN :zstart AND :zend))
-              SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-       chrom = :chrom
-AND ((txStart BETWEEN :zstart AND :zend)
- OR   (txEnd BETWEEN :zstart AND :zend)
- OR   (txStart <= :zstart AND txEnd >= :zend))
-                  SQL
-                else
-                  where = <<-SQL
-        chrom = :chrom 
-  AND ((txStart BETWEEN :zstart AND :zend)
-  AND  (txEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end
-                cond = {
-                  :chrom => interval.chrom,
-                  :zstart => zstart,
-                  :zend => zend,
-                }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })-u
-              end
-            end
-          !
-        end # case opts[:bin]
+          end
+        !
       end # def genepred
 
       # rmsk: Repeatmasker .out file
       # interval search using genoName/genoStart/genoEnd
       def rmsk(sym, opts={:bin => true})
-        case opts[:bin]
-        when true
-          %!
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS}
+        if opts[:bin]
+          chrom_bin = "genoName = :chrom AND bin in (:bins) "
+        else
+          chrom_bin = "genoName = :chrom "
+        end
+
+        %!
+          class #{uphead(sym)} < DBConnection
+            self.table_name = "#{downhead(sym)}"
+            #{delete_reserved_methods}
+            #{COMMON_CLASS_METHODS}
  
-              where = <<-SQL
-      genoName = :chrom
-AND   bin in (:bins)
-AND ((genoStart BETWEEN :zstart AND :zend)
- OR  (genoEnd BETWEEN :zstart AND :zend)
- OR  (genoStart <= :zstart AND genoEnd >= :zend))
-                SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :bins => gi.bin_all,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-              where = <<-SQL
-      genoName = :chrom
-AND   bin in (:bins)
-AND ((genoStart BETWEEN :zstart AND :zend)
-AND  (genoEnd BETWEEN :zstart AND :zend))
-                  SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :bins => gi.bin_all,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-      genoName = :chrom
-AND   bin in (:bins)
-AND ((genoStart BETWEEN :zstart AND :zend)
- OR  (genoEnd BETWEEN :zstart AND :zend)
- OR  (genoStart <= :zstart AND genoEnd >= :zend))
-                  SQL
-                else
-                where = <<-SQL
-      genoName = :chrom
-AND   bin in (:bins)
-AND ((genoStart BETWEEN :zstart AND :zend)
-AND  (genoEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end
-                cond = {
+            def self.with_interval(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                "(genoStart BETWEEN :zstart AND :zend)" +
+                "OR (genoEnd BETWEEN :zstart AND :zend)" +
+                "OR (genoStart <= :zstart AND genoEnd >= :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.with_interval_excl(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              where(
+                "#{chrom_bin}" +
+                "AND ( " +
+                "(genoStart BETWEEN :zstart AND :zend)" +
+                "AND (genoEnd BETWEEN :zstart AND :zend) )",
+                #{PARAMETERS})
+            end
+
+            def self.find_first_or_all_by_interval(interval, first_all, opt); interval =  Bio::Ucsc::Gi.wrap(interval)
+              interval = Bio::Ucsc::Gi.wrap(interval)
+              zstart = interval.zero_start
+              zend   = interval.zero_end
+              if opt[:partial] == true
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                  "(genoStart BETWEEN :zstart AND :zend) " +
+                  "OR (genoEnd BETWEEN :zstart AND :zend) " +
+                  "OR (genoStart <= :zstart AND genoEnd >= :zend) )"
+              else
+                where =
+                  "#{chrom_bin}" +
+                  "AND ( " +
+                  "(genoStart BETWEEN :zstart AND :zend) " +
+                  "AND (genoEnd BETWEEN :zstart AND :zend) )"
+              end
+              cond = {
                 :chrom  => interval.chrom,
                 :bins   => Bio::Ucsc::UcscBin.bin_all(zstart, zend),
                 :zstart => zstart,
                 :zend   => zend,
               }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
-            end
-          !
-        when false
-          %! 
-            class #{uphead(sym)} < DBConnection
-              set_table_name "#{downhead(sym)}"
-              #{delete_reserved_methods}
-              #{COMMON_CLASS_METHODS} 
-
-              where = <<-SQL
-       genoName = :chrom
-AND ((genoStart BETWEEN :zstart AND :zend)
- OR   (genoEnd BETWEEN :zstart AND :zend)
- OR   (genoStart <= :zstart AND genoEnd >= :zend))
-                SQL
-              scope(:with_interval,
-                    Proc.new{|gi|{:conditions => [where, {:chrom => gi.chrom,
-                                                          :bins => gi.bin_all,
-                                                          :zstart => gi.zero_start,
-                                                          :zend => gi.zero_end,}]}})
-              where = <<-SQL
-       genoName = :chrom
-  AND ((genoStart BETWEEN :zstart AND :zend)
-  AND  (genoEnd BETWEEN :zstart AND :zend))
-                SQL
-              scope(:with_interval_excl,
-                    Proc.new{|gi|{:conditions => [where,{:chrom => gi.chrom,
-                                                         :zstart => gi.zero_start,
-                                                         :zend => gi.zero_end,}]}})
-
-              def self.find_first_or_all_by_interval(interval, first_all, opt)
-                zstart = interval.zero_start
-                zend   = interval.zero_end
-                if opt[:partial] == true
-                  where = <<-SQL
-       genoName = :chrom
-AND ((genoStart BETWEEN :zstart AND :zend)
- OR   (genoEnd BETWEEN :zstart AND :zend)
- OR   (genoStart <= :zstart AND genoEnd >= :zend))
-                  SQL
-                else
-                  where = <<-SQL
-       genoName = :chrom
-  AND ((genoStart BETWEEN :zstart AND :zend)
-  AND  (genoEnd BETWEEN :zstart AND :zend))
-                  SQL
-                end
-                cond = {
-                  :chrom => interval.chrom,
-                  :zstart => zstart,
-                  :zend => zend,
-                }
-                self.find(first_all,
-                          { :select => "*",
-                            :conditions => [where, cond], })
-              end
+              self.find(first_all,
+                        { :select => "*",
+                          :conditions => [where, cond], })
             end
-          !
-        end # case opts[:bin]
+          end
+        !
       end # def rmsk
 
       private
 
+      #
+      # This hack works only for ActiveRecord version <=3.0
+      #
       def delete_reserved_methods
         codes = Array.new
-        codes << "set_primary_key nil"
-        codes << "set_inheritance_column nil"
-        RESERVED_METHODS.each do |reserved|
-          codes << "columns_hash.delete('#{reserved}')"
+        unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR > 0
+          codes << "include SafeAttributes"
+          RESERVED_METHODS.each do |reserved|
+            codes << "bad_attribute_names :#{reserved}"
+          end
         end
         codes.join("\n")
       end