bio-sra 0.1.0

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/sra_download

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+require 'csv'
+require 'bio-commandeer'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bio-sra'
+
+SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = SCRIPT_NAME.gsub('.rb','')
+
+# Parse command line options into the options hash
+options = {
+  :logger => 'stderr',
+  :format => :sra,
+  :accessions_file => nil,
+  :download_all_from_study => false,
+  :treat_input_as_runs => false,
+  }
+o = OptionParser.new do |opts|
+  opts.banner = "
+Usage: #{SCRIPT_NAME} <SRA_ACCESSION>
+
+Download data from SRA \n"
+
+  opts.on('-f', "--file FILENAME", "Provide a file of accession numbers, separated by whitespace or commas [default: not used, use the first argument <SRA_ACCESSION>]") do |f|
+    options[:accessions_file] = f
+  end
+  opts.on("--format FORMAT", "format for download [default: 'sra']") do |f|
+    format_string_to_sym = {
+      'sralite' => :sralite, # no longer supported by NCBI?
+      'sra' => :sra,
+      }
+    options[:format] = format_string_to_sym[f]
+
+    if options[:format].nil?
+      raise "Unexpected file format specified '#{f}'. I require one of #{format_string_to_sym.keys.join(', ') }"
+    end
+  end
+  opts.on("--dry-run", "Don't download any instead print the URLs to download to the command line [default: not this, do download]") do
+    options[:dry_run] = true
+  end
+
+  # logger options
+  opts.separator "\nVerbosity:\n\n"
+  opts.on("-q", "--quiet", "Run quietly, set logging to ERROR level [default INFO]") do |q|
+    Bio::Log::CLI.trace('error')
+  end
+  opts.on("--logger filename",String,"Log to file [default #{options[:logger] }]") do | name |
+    options[:logger] = name
+  end
+  opts.on("--trace options",String,"Set log level [default INFO]. e.g. '--trace debug' to set logging level to DEBUG") do | s |
+    Bio::Log::CLI.trace(s)
+  end
+end
+o.parse!
+
+if options[:accessions_file].nil? and ARGV.length == 0
+  $stderr.puts o
+  exit 1
+end
+
+# Setup logging
+Bio::Log::CLI.logger(options[:logger]) #bio-logger defaults to STDERR not STDOUT, I disagree
+log = Bio::Log::LoggerPlus.new(LOG_NAME)
+Bio::Log::CLI.configure(LOG_NAME)
+
+almost_accessions = nil
+if options[:accessions_file]
+  log.debug "Reading SRA accessions from file #{options[:accessions_file] }"
+  almost_accessions = File.open(options[:accessions_file]).read.split(/[\s,]+/)
+else
+  almost_accessions = ARGV.collect{|r| r.split(/[\s,]+/)}.flatten
+end
+# Remove empty strings and extra digits at the end e.g. SRA029325.1 => SRA029325
+accessions = almost_accessions.reject{|a| a==''}.collect{|a| a.gsub(/\.\d+$/,'')}
+log.info "Read in #{accessions.length} accessions"
+
+# Do we need to connect to the database? Only yes if there are accessions that are not runs
+options[:treat_input_as_runs] = true
+accessions.each do |acc|
+  unless Bio::SRA::Accession.classify_accession_type(acc) == Bio::SRA::RUN
+    log.debug "Found accession number #{acc} that does not appear to be a run accession, so need to connect to database" if log.debug?
+    options[:treat_input_as_runs] = false
+    break
+  end
+end
+
+# Connect to the database if required
+log.info "Connecting to database.."
+Bio::SRA::Connection.connect unless options[:treat_input_as_runs]
+
+log.info "Collecting a list of runs to download.."
+runs = []
+accessions.each do |acc|
+  if options[:treat_input_as_runs]
+    runs.push [acc, acc]
+  else
+    acc_type = Bio::SRA::Accession.classify_accession_type(acc)
+
+    # Convert Run ActiveRecords into simple accessions
+    sra_runs = case acc_type
+    when Bio::SRA::RUN then
+      Bio::SRA::Tables::SRA.where(:run_accession => acc)
+    when Bio::SRA::EXPERIMENT then
+      Bio::SRA::Tables::SRA.where(:experiment_accession => acc)
+    when Bio::SRA::SAMPLE then
+      Bio::SRA::Tables::SRA.where(:sample_accession => acc)
+    when Bio::SRA::STUDY then
+      Bio::SRA::Tables::SRA.where(:study_accession => acc)
+    when Bio::SRA::SUBMISSION then
+      Bio::SRA::Tables::SRA.where(:submission_accession => acc)
+    else
+      raise "Programming error: unexpected accession type: #{acc_type}"
+    end
+
+      if sra_runs.empty?
+        log.warn "Unable to find accession number #{acc} in the metadata database, skipping"
+        next
+      else
+        log.debug "Found #{sra_runs.length} runs to download for accession number #{acc}"
+      end
+
+      sra_runs.each do |r|
+        runs.push [r.run_accession, acc]
+      end
+    end
+    end
+
+      # Remove duplicate runs
+      runs.uniq! do |run_acc|
+        run_acc[0]
+      end
+      log.info "Found #{runs.length} unique run files to download, downloading them now.."
+      num_skipped = 0
+      num_downloaded = 0
+      runs.each_with_index do |run_acc, index|
+        run = run_acc[0]
+        acc = run_acc[1]
+
+        download_path = "#{run}.#{options[:format] }"
+        log.debug "Downloading to #{download_path}"
+
+        if File.exist?(download_path)
+          log.debug "Skipping download of run #{download_path} since a file of that accession already exists"
+          num_skipped += 1
+          next
+        end
+
+        if run == acc
+          log.info "Downloading run #{run} (#{index+1}/#{runs.length})"
+        else
+          log.info "Downloading run #{run} from #{acc} (#{index+1}/#{runs.length})"
+        end
+
+        url = Bio::SRA::Accession.run_download_url(run, :format => options[:format])
+
+        num_downloaded += 1
+        if options[:dry_run]
+          puts url
+        else
+          `wget #{url.inspect}`
+        end
+      end
+      if options[:dry_run]
+        log.info "Finished printing #{num_downloaded} URLs, ignoring #{num_skipped} already downloaded"
+      else
+        log.info "Finished downloading #{num_downloaded}, ignoring #{num_skipped} already downloaded"
+      end

data/config/database.yml

@@ -0,0 +1,7 @@
+# SQLite version 3.x
+# gem install sqlite3
+default:
+  adapter: sqlite3
+  database: db/SRAmetadb.sqlite
+  pool: 5
+  timeout: 5000

data/lib/bio-sra.rb

@@ -0,0 +1,19 @@
+# Please require your code below, respecting the naming conventions in the
+# bioruby directory tree.
+#
+# For example, say you have a plugin named bio-plugin, the only uncommented
+# line in this file would be 
+#
+#   require 'bio/bio-plugin/plugin'
+#
+# In this file only require other files. Avoid other source code.
+require 'active_record'
+
+require 'bio-logger'
+Bio::Log::LoggerPlus.new('bio-sra')
+
+require 'bio/sra/connect'
+require 'bio/sra/sra'
+require 'bio/sra/tables'
+
+

data/lib/bio/sra/connect.rb

@@ -0,0 +1,39 @@
+module Bio
+  module SRA
+    def self.connect
+      Connection.connect
+    end
+      
+    class Connection < ActiveRecord::Base
+      self.abstract_class = true
+      
+      # Connect to a metadata database.
+      #
+      # * sra_metadb_path: a path to the gunzipped SRAmetadb.sqlite file which is the database. By default this is in the db/ directory of this gem, but that probably isn't where the db file is.
+      #
+      # You can download the file like so:
+      #
+      #    $ wget http://watson.nci.nih.gov/~zhujack/SRAmetadb.sqlite.gz
+      #    # gunzip SRAmetadb.sqlite.gz
+      def self.connect(sra_metadb_path=File.join(File.dirname(__FILE__),'..','..','..','db','SRAmetadb.sqlite'))
+        log = Bio::Log::LoggerPlus['bio-sra']
+        log.info "Attempting to connect to database #{sra_metadb_path}"
+        
+        # default:
+          # adapter: sqlite3
+          # database: db/SRAmetadb.sqlite
+          # pool: 5
+          # timeout: 5000
+          
+        options = {
+          :adapter => 'sqlite3',
+          :database => sra_metadb_path,
+          :pool => 5,
+          :timeout => 5000,
+        }
+        
+        establish_connection(options)
+      end
+    end
+  end
+end

data/lib/bio/sra/sra.rb

@@ -0,0 +1,152 @@
+module Bio
+  module SRA
+    SUBMISSION = 'submission'
+    STUDY = 'study'
+    SAMPLE = 'sample'
+    EXPERIMENT = 'experiment'
+    RUN = 'run'
+
+    class Accession
+      @@log = Bio::Log::LoggerPlus['bio-sra']
+
+      # valid_in_type <- c(SRA = "submission", ERA = "submission",
+      # DRA = "submission", SRP = "study", ERP = "study", DRP = "study",
+      # SRS = "sample", ERS = "sample", DRS = "sample", SRX = "experiment",
+      # ERX = "experiment", DRX = "experiment", SRR = "run",
+      # ERR = "run", DRR = "run")
+      ACCESSION_TO_TYPE = {
+        'SRA' => Bio::SRA::SUBMISSION,
+        'ERA' => Bio::SRA::SUBMISSION,
+        'DRA' => Bio::SRA::SUBMISSION,
+        'SRP' => Bio::SRA::STUDY,
+        'ERP' => Bio::SRA::STUDY,
+        'DRP' => Bio::SRA::STUDY,
+        'SRS' => Bio::SRA::SAMPLE,
+        'ERS' => Bio::SRA::SAMPLE,
+        'DRS' => Bio::SRA::SAMPLE,
+        'SRX' => Bio::SRA::EXPERIMENT,
+        'ERX' => Bio::SRA::EXPERIMENT,
+        'DRX' => Bio::SRA::EXPERIMENT,
+        'SRR' => Bio::SRA::RUN,
+        'ERR' => Bio::SRA::RUN,
+        'DRR' => Bio::SRA::RUN,
+      }
+
+      TYPE_TO_COLUMN = {
+        Bio::SRA::SUBMISSION => :submission_accession,
+        Bio::SRA::STUDY => :study_accession,
+        Bio::SRA::SAMPLE => :sample_accession,
+        Bio::SRA::EXPERIMENT => :experiment_accession,
+        Bio::SRA::RUN => :run_accession,
+      }
+
+      def self.classify_accession_type(accession)
+        type = ACCESSION_TO_TYPE[accession[0..2]]
+        if type.nil?
+          raise "Unrecognised accession string '#{accession}'"
+        end
+        @@log.debug "Classified #{accession} as SRA type '#{type}'" if @@log.debug?
+        return type
+      end
+
+      # Given an accession, return the column name it in the SRA table that contains it as a symbol.
+      # e.g. accession_to_column_name('SRR617581') => :run_accession
+      def self.accession_to_column_name(accession)
+        TYPE_TO_COLUMN[classify_accession_type(accession)]
+      end
+
+      def self.format_symbol_to_extension(format_symbol)
+        non_standard_extensions = {
+          :sralite => '.lite.sra',
+          :fastq_gz => '.fastq.gz',
+        }
+        style = format_symbol_to_standard_text format_symbol
+
+        # Default extension is the same as the format
+        style_extension = non_standard_extensions[format_symbol]
+        style_extension ||= ".#{style}"
+
+        return style_extension
+      end
+
+      def self.format_symbol_to_standard_text(format_symbol)
+        formats = {
+          :sralite => 'litesra',
+          :sra => 'sra',
+          :fastq_gz => 'fastq',
+          :sff => 'sff'
+        }
+        style = formats[format_symbol]
+        if style.nil?
+          raise "Unexpected download format detected #{format_symbol}, I need one of '#{formats.keys.join(', ')}'"
+        end
+        return style
+      end
+
+      # Return the URL where a run can be downloaded. Only works if the accession is a run accession e.g. SRR000002 or DRR000002. To get run accessions from other accession type e.g. SRP000002, try Bio::SRA::Sra
+      #
+      # Options:
+      # :source: either :ncbi (default), or :ebi
+      # :format: either :sralite (default if :source if :ncbi), :fastq_gz (default if :source is :ebi), :sra
+      # :layout: either :single (default), :paired1, or :paired2. :paired1 for the first half, :paired2 for the second half. Only required when :source => :ebi, otherwise not used
+      def self.run_download_url(run_accession, options={})
+        options ||= {}
+        options[:source] ||= :ncbi
+        if options[:source] == :ebi
+          options[:format] ||= :fastq
+          options[:layout] ||= :single
+        else
+          options[:format] ||= :sralite #default to sralite
+        end
+
+
+        type = classify_accession_type(run_accession)
+        unless type == Bio::SRA::RUN
+          raise "Unexpected type of accession for '#{run_accession}': Expected #{Bio::SRA::RUN} but was #{type}"
+        end
+
+        style = format_symbol_to_standard_text options[:format]
+        style_extension = format_symbol_to_extension options[:format]
+
+        if options[:source] == :ncbi
+          # e.g.
+          # ftp://ftp-trace.ncbi.nlm.nih.gov/sra/sra-instant/reads/ByRun/litesra/DRR/DRR000/DRR000002/DRR000002/DRR000002.lite.sra
+          [
+            "ftp://ftp-trace.ncbi.nlm.nih.gov/sra/sra-instant/reads/ByRun",
+            style,
+            run_accession[0..2],
+            run_accession[0..5],
+            run_accession,
+            "#{run_accession}#{style_extension}"
+          ].join('/')
+        elsif options[:source] == :ebi
+          unless style == 'fastq'
+            raise "Unexpected format for download detected #{options[:format]} in combination with :source => :ebi. Require :fastq_gz"
+          end
+          ok_layouts = [:single, :paired1, :paired2]
+          unless ok_layouts.include?(options[:layout])
+            raise "Unexpected layout for download detected #{options[:layout]} in combination with :source => :ebi. Require on of #{ok_layouts.join(', ')}."
+          end
+          # e.g. for paired ended
+          # ftp://ftp.sra.ebi.ac.uk/vol1/fastq/SRR069/SRR069027/SRR069027_1.fastq.gz
+          # e.g. for single end
+          # ftp://ftp.sra.ebi.ac.uk/vol1/fastq/SRR404/SRR404303/SRR404303.fastq.gz
+          most = [
+            'ftp://ftp.sra.ebi.ac.uk/vol1/',
+            style,
+            run_accession[0..5],
+            run_accession,
+          ]
+          if options[:layout] == :single
+            most.push "#{run_accession}#{style_extension}"
+          elsif options[:layout] == :format1
+            most.push "#{run_accession}_1#{style_extension}"
+          elsif options[:layout] == :format2
+            most.push "#{run_accession}_2#{style_extension}"
+          end
+          return most.join('/')
+        end
+      end
+    end
+  end
+end

data/lib/bio/sra/tables.rb

@@ -0,0 +1,467 @@
+module Bio
+  module SRA
+    module Tables
+      # > pp Bio::SRA::Tables::SRA.column_names
+      # ["sra_ID",
+      # "SRR_bamFile",
+      # "SRX_bamFile",
+      # "SRX_fastqFTP",
+      # "run_ID",
+      # "run_alias",
+      # "run_accession",
+      # "run_date",
+      # "updated_date",
+      # "spots",
+      # "bases",
+      # "run_center",
+      # "experiment_name",
+      # "run_url_link",
+      # "run_entrez_link",
+      # "run_attribute",
+      # "experiment_ID",
+      # "experiment_alias",
+      # "experiment_accession",
+      # "experiment_title",
+      # "study_name",
+      # "sample_name",
+      # "design_description",
+      # "library_name",
+      # "library_strategy",
+      # "library_source",
+      # "library_selection",
+      # "library_layout",
+      # "library_construction_protocol",
+      # "adapter_spec",
+      # "read_spec",
+      # "platform",
+      # "instrument_model",
+      # "instrument_name",
+      # "platform_parameters",
+      # "sequence_space",
+      # "base_caller",
+      # "quality_scorer",
+      # "number_of_levels",
+      # "multiplier",
+      # "qtype",
+      # "experiment_url_link",
+      # "experiment_entrez_link",
+      # "experiment_attribute",
+      # "sample_ID",
+      # "sample_alias",
+      # "sample_accession",
+      # "taxon_id",
+      # "common_name",
+      # "anonymized_name",
+      # "individual_name",
+      # "description",
+      # "sample_url_link",
+      # "sample_entrez_link",
+      # "sample_attribute",
+      # "study_ID",
+      # "study_alias",
+      # "study_accession",
+      # "study_title",
+      # "study_type",
+      # "study_abstract",
+      # "center_project_name",
+      # "study_description",
+      # "study_url_link",
+      # "study_entrez_link",
+      # "study_attribute",
+      # "related_studies",
+      # "primary_study",
+      # "submission_ID",
+      # "submission_accession",
+      # "submission_comment",
+      # "submission_center",
+      # "submission_lab",
+      # "submission_date"]
+      class SRA < Connection
+        self.table_name = 'sra'
+        self.primary_key = 'sra_ID'
+        
+        # Foreign keys
+        belongs_to :submission, :foreign_key => 'submission_ID', :class_name => 'Submission', :primary_key => 'submission_ID'
+        belongs_to :experiment, :foreign_key => 'experiment_ID', :class_name => 'Experiment', :primary_key => 'experiment_ID'
+        belongs_to :study, :foreign_key => 'study_ID', :class_name => 'Study', :primary_key => 'study_ID'
+        belongs_to :sample, :foreign_key => 'sample_ID', :class_name => 'Sample', :primary_key => 'sample_ID'
+        belongs_to :run, :foreign_key => 'run_ID', :class_name => 'Run', :primary_key => 'run_ID'
+
+        # named_scope for finding by an arbitrary SRA accession number e.g.
+        # SRA.accession('SRA049809').all #=> Array of SRA objects that are part of the SRA049809 submission
+        # SRA.accession('SRA049809').first #=> SRA object for the SRR404303 run (there is only 1 since this is a run accession)
+        scope :accession, lambda {|accession|
+          type = Bio::SRA::Accession.classify_accession_type(accession)
+          {:conditions => {"#{type}_accession".to_sym => accession}}
+        }
+        
+        # URLs of all the runs in this project
+        def study_download_urls(options = {})
+          SRA.where(:study_accession => study_accession).all.collect do |run|
+            run.download_url(options)
+          end
+        end
+
+        # Return the URL where this SRA entry can be downloaded
+        #        sraFileDir <- paste("ftp://ftp-trace.ncbi.nlm.nih.gov/sra/sra-instant/reads/ByExp/",
+        #      sraType, "/", substring(sra_acc$experiment[i], 1,
+        #          3), "/", substring(sra_acc$experiment[i], 1,
+        #          6), "/", sra_acc$experiment[i], "/", sra_acc$run[i],
+        #      "/", sep = "")
+        def download_url(options = {})
+          Bio::SRA::Accession.run_download_url(run_accession, options)
+        end
+      end
+
+      # pp Bio::SRA::Tables::Submission.column_names
+      # ["submission_ID",
+      # "submission_alias",
+      # "submission_accession",
+      # "submission_comment",
+      # "files",
+      # "broker_name",
+      # "center_name",
+      # "lab_name",
+      # "submission_date",
+      # "sra_link",
+      # "submission_url_link",
+      # "xref_link",
+      # "submission_entrez_link",
+      # "ddbj_link",
+      # "ena_link",
+      # "submission_attribute",
+      # "sradb_updated"]
+      class Submission < Connection
+        self.table_name = 'submission'
+        self.primary_key = 'submission_ID'
+        has_many :sras, :foreign_key => 'submission_ID', :class_name => 'SRA'
+      end
+
+      # pp Bio::SRA::Tables::Experiment.column_names
+      # ["experiment_ID",
+      # "bamFile",
+      # "fastqFTP",
+      # "experiment_alias",
+      # "experiment_accession",
+      # "broker_name",
+      # "center_name",
+      # "title",
+      # "study_name",
+      # "study_accession",
+      # "design_description",
+      # "sample_name",
+      # "sample_accession",
+      # "sample_member",
+      # "library_name",
+      # "library_strategy",
+      # "library_source",
+      # "library_selection",
+      # "library_layout",
+      # "targeted_loci",
+      # "library_construction_protocol",
+      # "spot_length",
+      # "adapter_spec",
+      # "read_spec",
+      # "platform",
+      # "instrument_model",
+      # "platform_parameters",
+      # "sequence_space",
+      # "base_caller",
+      # "quality_scorer",
+      # "number_of_levels",
+      # "multiplier",
+      # "qtype",
+      # "sra_link",
+      # "experiment_url_link",
+      # "xref_link",
+      # "experiment_entrez_link",
+      # "ddbj_link",
+      # "ena_link",
+      # "experiment_attribute",
+      # "submission_accession",
+      # "sradb_updated"]
+      class Experiment < Connection
+        self.table_name = 'experiment'
+        self.primary_key = 'experiment_ID'
+        has_many :sras, :foreign_key => 'experiment_ID', :class_name => 'SRA'
+      end
+
+      # pp Bio::SRA::Tables::Run.column_names
+      # ["run_ID",
+      # "bamFile",
+      # "run_alias",
+      # "run_accession",
+      # "broker_name",
+      # "instrument_name",
+      # "run_date",
+      # "run_file",
+      # "run_center",
+      # "total_data_blocks",
+      # "experiment_accession",
+      # "experiment_name",
+      # "sra_link",
+      # "run_url_link",
+      # "xref_link",
+      # "run_entrez_link",
+      # "ddbj_link",
+      # "ena_link",
+      # "run_attribute",
+      # "submission_accession",
+      # "sradb_updated"]
+      class Run < Connection
+        self.table_name = 'run'
+        self.primary_key = 'run_ID'
+        has_many :sras, :foreign_key => 'run_ID', :class_name => 'SRA'
+      end
+
+      # pp Bio::SRA::Tables::Sample.column_names
+      # ["sample_ID",
+      # "sample_alias",
+      # "sample_accession",
+      # "broker_name",
+      # "center_name",
+      # "taxon_id",
+      # "scientific_name",
+      # "common_name",
+      # "anonymized_name",
+      # "individual_name",
+      # "description",
+      # "sra_link",
+      # "sample_url_link",
+      # "xref_link",
+      # "sample_entrez_link",
+      # "ddbj_link",
+      # "ena_link",
+      # "sample_attribute",
+      # "submission_accession",
+      # "sradb_updated"]
+      class Sample < Connection
+        self.table_name = 'sample'
+        self.primary_key = 'sample_ID'
+        has_many :sras, :foreign_key => 'sample_ID', :class_name => 'SRA'
+      end
+      
+      # pp Bio::SRA::Tables::Study.column_names
+      # ["study_ID",
+      # "study_alias",
+      # "study_accession",
+      # "study_title",
+      # "study_type",
+      # "study_abstract",
+      # "broker_name",
+      # "center_name",
+      # "center_project_name",
+      # "study_description",
+      # "related_studies",
+      # "primary_study",
+      # "sra_link",
+      # "study_url_link",
+      # "xref_link",
+      # "study_entrez_link",
+      # "ddbj_link",
+      # "ena_link",
+      # "study_attribute",
+      # "submission_accession",
+      # "sradb_updated"]
+      class Study < Connection
+        self.table_name = 'study'
+        self.primary_key = 'study_ID'
+        has_many :sras, :foreign_key => 'study_ID', :class_name => 'SRA'
+      end
+
+      # > pp Bio::SRA::Tables::SRAFt.column_names
+      # ["SRR_bamFile",
+      # "SRX_bamFile",
+      # "SRX_fastqFTP",
+      # "run_ID",
+      # "run_alias",
+      # "run_accession",
+      # "run_date",
+      # "updated_date",
+      # "spots",
+      # "bases",
+      # "run_center",
+      # "experiment_name",
+      # "run_url_link",
+      # "run_entrez_link",
+      # "run_attribute",
+      # "experiment_ID",
+      # "experiment_alias",
+      # "experiment_accession",
+      # "experiment_title",
+      # "study_name",
+      # "sample_name",
+      # "design_description",
+      # "library_name",
+      # "library_strategy",
+      # "library_source",
+      # "library_selection",
+      # "library_layout",
+      # "library_construction_protocol",
+      # "adapter_spec",
+      # "read_spec",
+      # "platform",
+      # "instrument_model",
+      # "instrument_name",
+      # "platform_parameters",
+      # "sequence_space",
+      # "base_caller",
+      # "quality_scorer",
+      # "number_of_levels",
+      # "multiplier",
+      # "qtype",
+      # "experiment_url_link",
+      # "experiment_entrez_link",
+      # "experiment_attribute",
+      # "sample_ID",
+      # "sample_alias",
+      # "sample_accession",
+      # "taxon_id",
+      # "common_name",
+      # "anonymized_name",
+      # "individual_name",
+      # "description",
+      # "sample_url_link",
+      # "sample_entrez_link",
+      # "sample_attribute",
+      # "study_ID",
+      # "study_alias",
+      # "study_accession",
+      # "study_title",
+      # "study_type",
+      # "study_abstract",
+      # "center_project_name",
+      # "study_description",
+      # "study_url_link",
+      # "study_entrez_link",
+      # "study_attribute",
+      # "related_studies",
+      # "primary_study",
+      # "submission_ID",
+      # "submission_accession",
+      # "submission_comment",
+      # "submission_center",
+      # "submission_lab",
+      # "submission_date",
+      # "sradb_updated"]
+      class SRAFt < Connection
+        self.table_name = 'sra_ft'
+      end
+
+      # pp Bio::SRA::Tables::SRAFtContent.column_names
+      # ["docid",
+      # "c0SRR_bamFile",
+      # "c1SRX_bamFile",
+      # "c2SRX_fastqFTP",
+      # "c3run_ID",
+      # "c4run_alias",
+      # "c5run_accession",
+      # "c6run_date",
+      # "c7updated_date",
+      # "c8spots",
+      # "c9bases",
+      # "c10run_center",
+      # "c11experiment_name",
+      # "c12run_url_link",
+      # "c13run_entrez_link",
+      # "c14run_attribute",
+      # "c15experiment_ID",
+      # "c16experiment_alias",
+      # "c17experiment_accession",
+      # "c18experiment_title",
+      # "c19study_name",
+      # "c20sample_name",
+      # "c21design_description",
+      # "c22library_name",
+      # "c23library_strategy",
+      # "c24library_source",
+      # "c25library_selection",
+      # "c26library_layout",
+      # "c27library_construction_protocol",
+      # "c28adapter_spec",
+      # "c29read_spec",
+      # "c30platform",
+      # "c31instrument_model",
+      # "c32instrument_name",
+      # "c33platform_parameters",
+      # "c34sequence_space",
+      # "c35base_caller",
+      # "c36quality_scorer",
+      # "c37number_of_levels",
+      # "c38multiplier",
+      # "c39qtype",
+      # "c40experiment_url_link",
+      # "c41experiment_entrez_link",
+      # "c42experiment_attribute",
+      # "c43sample_ID",
+      # "c44sample_alias",
+      # "c45sample_accession",
+      # "c46taxon_id",
+      # "c47common_name",
+      # "c48anonymized_name",
+      # "c49individual_name",
+      # "c50description",
+      # "c51sample_url_link",
+      # "c52sample_entrez_link",
+      # "c53sample_attribute",
+      # "c54study_ID",
+      # "c55study_alias",
+      # "c56study_accession",
+      # "c57study_title",
+      # "c58study_type",
+      # "c59study_abstract",
+      # "c60center_project_name",
+      # "c61study_description",
+      # "c62study_url_link",
+      # "c63study_entrez_link",
+      # "c64study_attribute",
+      # "c65related_studies",
+      # "c66primary_study",
+      # "c67submission_ID",
+      # "c68submission_accession",
+      # "c69submission_comment",
+      # "c70submission_center",
+      # "c71submission_lab",
+      # "c72submission_date",
+      # "c73sradb_updated"]
+      class SRAFtContent < Connection
+        self.table_name = 'sra_ft_content'
+      end
+
+      # pp Bio::SRA::Tables::SRAFtSegDir.column_names
+      # ["level", "idx", "start_block", "leaves_end_block", "end_block", "root"]
+      class SRAFtSegDir < Connection
+        self.table_name = 'sra_ft_segdir'
+      end
+
+      # pp Bio::SRA::Tables::SRAFtSegments.column_names
+      # ["blockid", "block"]
+      class SRAFtSegments < Connection
+        self.table_name = 'sra_ft_segments'
+      end
+      
+      # pp Bio::SRA::Tables::MetaInfo.column_names
+      # ["name", "value"]
+      class MetaInfo < Connection
+        self.table_name = 'metaInfo'
+      end
+      
+      # This table holds information about each of the columns
+      # in this SRAmetadb database
+      #
+      # pp Bio::SRA::Tables::ColDesc.column_names
+      # ["col_desc_ID",
+      # "table_name",
+      # "field_name",
+      # "type",
+      # "description",
+      # "value_list",
+      # "sradb_updated"]
+      class ColDesc < Connection
+        self.table_name = 'col_desc'
+        self.primary_key = 'col_desc_ID'
+        self.inheritance_column = nil
+      end
+    end
+  end
+end