omf_oml 0.9.5 → 0.9.6

data/.gitignore

@@ -1,2 +1,3 @@
 .project
 pkg
+lib/omf_oml/BACKUP

data/lib/omf_oml/schema.rb

@@ -34,11 +34,20 @@ module OMF::OML
       'double precision' => :float,
       'text' => :string,
       'string' => :string,
+      'varargs' => :string,
       'date' => :date,
       'dateTime'.downcase => :dateTime, # should be 'datetime' but we downcase the string for comparison
       'timestamp' => :dateTime, # Postgreql specific, not sure if this works as it.
       'key' => :key,      
     }
+    
+    OML_INTERNALS = [
+      :oml_sender,
+      :oml_sender_id,
+      :oml_seq,
+      :oml_ts_client,
+      :oml_ts_server
+    ]
 
     def self.create(schema_description)
       if schema_description.kind_of? self
@@ -83,62 +92,13 @@ module OMF::OML
     end
     
     def insert_column_at(index, col)
-      if col.kind_of?(Symbol) || col.kind_of?(String)
-        col = [col]
-      end
-      if col.kind_of? Array
-        # should be [name, type]
-        if col.length == 1
-          col = {:name => col[0].to_sym, 
-                  :type => :string, 
-                  :title => col[0].to_s.split('_').collect {|s| s.capitalize}.join(' ')}
-        elsif col.length == 2
-          col = {:name => col[0].to_sym,
-                  :type => col[1].to_sym, 
-                  :title => col[0].to_s.split('_').collect {|s| s.capitalize}.join(' ')}
-        elsif col.length == 3
-          col = {:name => col[0].to_sym, :type => col[1].to_sym, :title => col[2]}
-        else
-          throw "Simple column schema should consist of [name, type, title] array, but found '#{col.inspect}'"
-        end
-      elsif col.kind_of? Hash
-        # ensure there is a :title property
-        unless col[:title]
-          col[:title] = col[:name].to_s.split('_').collect {|s| s.capitalize}.join(' ')
-        end
-      end
-      
-      # should normalize type
-      if type = col[:type]
-        unless type = ANY2TYPE[type.to_s.downcase]
-          warn "Unknown type definition '#{col[:type]}', default to 'string'"
-          type = :string
-        end
-      else
-        warn "Missing type definition in '#{col[:name]}', default to 'string' (#{col.inspect})"          
-        type = :string
-      end
-      col[:type] = type
-      
-      col[:type_conversion] = case type
-        when :string
-          lambda do |r| r end
-        when :key
-          lambda do |r| r end
-        when :integer 
-          lambda do |r| r.to_i end
-        when :float 
-          lambda do |r| r.to_f end
-        when :date 
-          lambda do |r| Date.parse(r) end
-        when :dateTime
-          lambda do |r| Time.parse(r) end
-        else raise "Unrecognized Schema type '#{type}'"
-      end
-                  
-      @schema.insert(index, col)
+      @schema.insert(index, _create_col_descr(col))       
     end
     
+    def replace_column_at(index, col)
+      @schema[index] = _create_col_descr(col)
+    end
+
     def each_column(&block)
       @schema.each do |c| 
         block.call(c) 
@@ -151,7 +111,7 @@ module OMF::OML
     # hrow - Hash describing a row
     # set_nil_when_missing - If true, set any columns not described in hrow to nil
     #
-    def hash_to_row(hrow, set_nil_when_missing = false, call_type_conversion = true)
+    def hash_to_row(hrow, set_nil_when_missing = false, call_type_conversion = false)
       #puts "HASH2A => #{hrow.inspect}"
       remove_first_col = false
       r = @schema.collect do |cdescr|
@@ -194,12 +154,22 @@ module OMF::OML
       describe.to_json(*opt)
     end
     
-    def clone()
+    def clone(exclude_oml_internals = false)
       c = self.dup
-      c.instance_variable_set('@schema', @schema.clone)
+      schema = @schema.clone
+      if exclude_oml_internals
+        schema = schema.select do |cd|
+          not OML_INTERNALS.include?(cd[:name])
+        end
+      end
+      c.instance_variable_set('@schema', schema)
       c
     end
     
+    def to_s
+      "OmlSchema: #{@schema.map {|c| "#{c[:name]}:#{c[:type]}"}.join(', ')}"
+    end
+    
     protected
     
     # schema_description - Array containing [name, type*] for every column in table
@@ -214,6 +184,65 @@ module OMF::OML
       debug "schema: '#{describe.inspect}'"
       
     end
+    
+    # Create a column descriptor from whatever is given by user
+    #
+    def _create_col_descr(col)
+      if col.kind_of?(Symbol) || col.kind_of?(String)
+        col = [col]
+      end
+      if col.kind_of? Array
+        # should be [name, type]
+        if col.length == 1
+          col = {:name => col[0].to_sym, 
+                  :type => :string, 
+                  :title => col[0].to_s.split('_').collect {|s| s.capitalize}.join(' ')}
+        elsif col.length == 2
+          col = {:name => col[0].to_sym,
+                  :type => col[1].to_sym, 
+                  :title => col[0].to_s.split('_').collect {|s| s.capitalize}.join(' ')}
+        elsif col.length == 3
+          col = {:name => col[0].to_sym, :type => col[1].to_sym, :title => col[2]}
+        else
+          throw "Simple column schema should consist of [name, type, title] array, but found '#{col.inspect}'"
+        end
+      elsif col.kind_of? Hash
+        # ensure there is a :title property
+        unless col[:title]
+          col[:title] = col[:name].to_s.split('_').collect {|s| s.capitalize}.join(' ')
+        end
+      end
+      
+      # should normalize type
+      if type = col[:type]
+        tn = type.to_s.split('(')[0] # take care of types like varargs(..)
+        unless type = ANY2TYPE[type.to_s.downcase]
+          warn "Unknown type definition '#{tn}', default to 'string'"
+          type = :string
+        end
+      else
+        warn "Missing type definition in '#{col[:name]}', default to 'string' (#{col.inspect})"          
+        type = :string
+      end
+      col[:type] = type
+      
+      col[:type_conversion] = case type
+        when :string
+          lambda do |r| r end
+        when :key
+          lambda do |r| r end
+        when :integer 
+          lambda do |r| r.to_i end
+        when :float 
+          lambda do |r| r.to_f end
+        when :date 
+          lambda do |r| Date.parse(r) end
+        when :dateTime
+          lambda do |r| Time.parse(r) end
+        else raise "Unrecognized Schema type '#{type}'"
+      end
+      col
+    end
   end # OmlSchema
   
 end

data/lib/omf_oml/sql_row.rb

@@ -1,5 +1,6 @@
 
 require 'omf_oml/tuple'
+require 'omf_oml/table'
 
 module OMF::OML
         
@@ -15,19 +16,20 @@ module OMF::OML
     # 
     # Create a representation of a row in a database. Can be used to fill a table.
     #
-    # table_name - name table in respective SQL database
-    # schema_raw - a hash returned by the sequel library's #schema method
-    # db_opts - Enough information to open a Sequel database adapter
-    # source - Reference to the SqlSource which created this instance
-    # opts:  
+    # @param [String] sql_table_name - name of SQL table in respective SQL database
+    # @param [OmlSchema] schema - the schema describing the tuple
+    # @param [Sequel] db - Database 
+    # @param [Hash] opts:  
     #   - offset: Ignore first +offset+ rows. If negative or zero serve +offset+ rows initially
     #   - limit: Number of rows to fetch each time [1000]
     #   - check_interval: Interval in seconds when to check for new data. If 0, only run once.
+    #   - query_interval: Interval between consecutive queries when processing large result set.
     #
-    def initialize(table_name, schema_raw, db_opts, source, opts = {})
-      @sname = table_name
-      @db_opts = db_opts
-      @source = source
+    def initialize(sql_table_name, schema, db, opts = {})
+      @sname = sql_table_name
+      @schema = schema
+      raise "Expected OmlSchema but got '#{schema.class}" unless schema.is_a? OmlSchema
+      @db = db
       
       unless @offset = opts[:offset]
         @offset = 0
@@ -37,12 +39,11 @@ module OMF::OML
       
       @check_interval = opts[:check_interval]
       @check_interval = 0 unless @check_interval
+      @query_interval = opts[:query_interval]
       
-
       @on_new_vector_proc = {}
 
-      schema = parse_schema(schema_raw)
-      super table_name, schema 
+      super opts[:name] || sql_table_name, schema 
     end
     
     
@@ -60,10 +61,11 @@ module OMF::OML
       end
     end
     
-    # Return the elements of the vector as an array
-    def to_a(include_oml_internals = false)
-      a = @schema.hash_to_row(@row, false, false) # don't need type conversion as sequel is doing this for us
-      include_oml_internals ? a : a[4 .. -1]
+    # Return the elements of the row as an array using the 
+    # associated schema or 'schema' if non-nil.
+    #
+    def to_a(schema = nil)
+      a = (schema || @schema).hash_to_row(@row) # don't need type conversion as sequel is doing this for us
     end
     
     # Return an array including the values for the names elements
@@ -72,9 +74,10 @@ module OMF::OML
     def select(*col_names)
       r = @row
       col_names.collect do |n|
-        p = @vprocs[n]
-        #puts "#{n}::#{p}"
-        p ? p.call(r) : nil
+        unless @row.key? n
+          raise "Unknown column name '#{n}'"
+        end 
+        @row[n]
       end
     end
         
@@ -98,79 +101,54 @@ module OMF::OML
       run() unless @on_new_vector_proc.empty?
     end
 
-    # Create and return an +OmlTable+ which captures this tuple stream
-    #
-    # The argument to this method are either a list of columns to 
-    # to capture in the table, or an array of column names and
-    # an option hash  or just 
-    # the option hash to be provided to the +OmlTable+ constructor.
+    # Return a table which will capture the content of this tuple stream.
     #
-    # If a block is provided, any arriving tuple is executed by the block
-    # which is expected to return an array which is added to the table
-    # or nil in which case nothing is added. If a selector array is given the 
-    # block is called with an array of values in the order of the columns
-    # listed in the selector. Otherwise, the block is called directly 
-    # with the tuple.
+    # @param [string] name - Name to use for returned table
+    # @param [Hash] opts Options to be passed on to Table constructor
+    # @opts [boolean] opts :include_oml_internals If true will also include OML header columns
+    # @opts [OmlSchema] opts :schema use specific schema for table (Needs to be a subset of the tuples schema)
     #
-    # opts:
-    #   :schema - use this schema instead for the table
-    #   :name   - name to use for table
-    #   ....    - remaining options to be passed to table constructur
-    #
-    def capture_in_table(*args, &block)
-      if args.length == 1
-        if args[0].kind_of?(Array)
-          select = args[0]
-        elsif args[0].kind_of?(Hash)
-          opts = args[0]
+    def to_stream(opts = {}, &block)
+      unless schema = opts.delete(:schema)
+        include_oml_internals = (opts[:include_oml_internals] != false)
+        schema = self.schema.clone(!include_oml_internals)
+        if include_oml_internals
+          # replace sender_id by sender ... see _run_once
+          schema.replace_column_at 0, :oml_sender
         end
-      elsif args.length == 2 && args[1].kind_of?(Hash)
-        select = args[0]
-        opts = args[1]
-      else
-        opts = {}
-        select = args
       end
-      
-      if (tschema = opts.delete(:schema))
-        # unless tschema[0].kind_of? Hash
-          # tschema = tschema.collect do |cname| {:name => cname} end
-        # end 
-      else
-        tschema = select.collect do |cname| {:name => cname} end
-      end
-      tname = opts.delete(:name) || stream_name
-      t = OMF::OML::OmlTable.new(tname, tschema, opts)
-      if block
-        self.on_new_tuple() do |v|
-          #puts "New vector(#{tname}): #{v.schema.inspect} ---- #{v.select(*select).size} <#{v.select(*select).join('|')}>"
-          if select
-            row = block.call(v.select(*select))
-          else
-            row = block.call(v)
-          end             
-          if row
-            raise "Expected kind of Array, but got '#{row.inspect}'" unless row.kind_of?(Array)
-            t.add_row(row)
-          end  
-        end
-      else
-        self.on_new_tuple() do |v|
-          #puts "New vector(#{tname}): #{v.select(*select).join('|')}"
-          t.add_row(v.select(*select))   
-        end
+      self.on_new_tuple(rand()) do |t|
+        #v = t.to_a(schema)
+        v = t.row
+        block.arity == 1 ? block.call(v) : block.call(v, schema)
       end
-      t
+      schema
     end
-    
+
+    # Return a table which will capture the content of this tuple stream.
+    #
+    # @param [string] name - Name to use for returned table
+    # @param [Hash] opts Options to be passed on to Table constructor
+    # @opts [boolean] opts :include_oml_internals If true will also include OML header columns
+    # @opts [OmlSchema] opts :schema use specific schema for table (Needs to be a subset of the tuples schema)
+    #
     def to_table(name = nil, opts = {})
       unless name
         name = @sname
       end
-      t = OMF::OML::OmlTable.new(name, self.schema)
-      include_oml_internals = opts[:include_oml_internals] || true
-      self.on_new_tuple() do |v|
-        r = v.to_a(include_oml_internals)
+      unless schema = opts.delete(:schema)
+        include_oml_internals = (opts[:include_oml_internals] != false)
+        schema = self.schema.clone(!include_oml_internals)
+        if include_oml_internals
+          # replace sender_id by sender ... see _run_once
+          schema.replace_column_at 0, :oml_sender
+        end
+      end
+      t = OMF::OML::OmlTable.new(name, schema, opts)
+      #puts ">>>>SCHEMA>>> #{schema.inspect}"
+      self.on_new_tuple(t) do |v|
+        r = v.to_a(schema)
+        #puts r.inspect
         t.add_row(r)   
       end
       t
@@ -178,32 +156,6 @@ module OMF::OML
 
 
     protected
-        
-    def parse_schema(raw)
-      #puts ">> PARSE SCHEMA"
-      sd = raw.collect do |col| 
-        name, opts = col
-        #puts col.inspect
-        {:name => name, :type => opts[:db_type]}
-      end
-      # Query we are using is adding the 'oml_sender_name' to the front of the table
-      sd.insert(0, :name => :oml_sender, :type => :string)
-      OmlSchema.new(sd)
-    end
-    
-    # override
-    def process_schema(schema)
-      i = 0
-      @vprocs = {}
-      schema.each_column do |col|
-        name = col[:name]
-        j = i + 0
-        puts "SCHEMA: '#{name.inspect}'-#{j}"
-        l = @vprocs[name] = lambda do |r| r[j] end
-        @vprocs[i - 4] = l if i > 4
-        i += 1
-      end
-    end
     
     def run(in_thread = true)
       return if @running
@@ -224,10 +176,8 @@ module OMF::OML
     private
     
     def _run
-      @db = Sequel.connect(@db_opts)
-      
       if @check_interval <= 0
-        _run_once
+        while _run_once; end
       else
         @running = true
         while (@running)
@@ -256,8 +206,6 @@ module OMF::OML
         @offset = 0 if @offset < 0
       end
       @db["SELECT _senders.name as oml_sender, #{t}.* FROM #{t} INNER JOIN _senders ON (_senders.id = #{t}.oml_sender_id) LIMIT #{@limit} OFFSET #{@offset};"].each do |r|
-      #@db["SELECT _senders.name as oml_sender, #{t}.* FROM #{t} JOIN _senders WHERE #{t}.oml_sender_id = _senders.id LIMIT #{@limit} OFFSET #{@offset};"].each do |r|
-        #puts "ROW>>> #{r.inspect}"
         @row = r
         @on_new_vector_proc.each_value do |proc|
           proc.call(self)
@@ -265,27 +213,13 @@ module OMF::OML
         row_cnt += 1
       end
       @offset += row_cnt
-      debug "Read #{row_cnt}/#{@offset} rows from '#{@sname}'" if row_cnt > 0
-      row_cnt >= @limit # there could be more to read     
+      debug "Read #{row_cnt} (total #{@offset}) rows from '#{@sname}'" if row_cnt > 0
+      if more_to_read = row_cnt >= @limit # there could be more to read
+        sleep @query_interval if @query_interval # don't hammer database
+      end 
+      more_to_read    
     end
     
-    # def _statement
-      # unless @stmt
-        # db = @db = SQLite3::Database.new(@db_file)
-        # @db.type_translation = true   
-        # table_name = t = @sname  
-        # if @offset < 0
-          # cnt = db.execute("select count(*) from #{table_name};")[0][0].to_i
-          # #debug "CNT: #{cnt}.#{cnt.class} offset: #{@offset}"
-          # @offset = cnt + @offset # @offset was negative here
-          # debug("Initial offset #{@offset} in '#{table_name}' with #{cnt} rows")
-          # @offset = 0 if @offset < 0
-        # end
-        # #@stmt = db.prepare("SELECT * FROM #{table_name} LIMIT ? OFFSET ?;")
-        # @stmt = db.prepare("SELECT _senders.name, #{t}.* FROM #{t} JOIN _senders WHERE #{t}.oml_sender_id = _senders.id LIMIT ? OFFSET ?;")
-      # end
-      # @stmt
-    # end
   end # OmlSqlRow
 
 

data/lib/omf_oml/sql_source.rb

@@ -8,13 +8,21 @@ require 'omf_oml/sql_row'
 
 module OMF::OML
 
-  # This class fetches the content of an sqlite3 database and serves it as multiple
+  # This class fetches the content of an SQL database and serves it as multiple
   # OML streams.
   #
   # After creating the object, the @run@ method needs to be called to
   # start producing the streams.
   #
   class OmlSqlSource < OMF::Common::LObject
+    
+    # Sequel adaptors sometimes don't return a :type identifier,
+    # but always return the :db_type. This is a list of maps which may not work
+    # for all adaptors
+    # 
+    FALLBACK_MAPPING = {
+      'UNSIGNED INTEGER' => :integer
+    }
 
     # db_opts - Options used to create a Sequel adapter
     #
@@ -41,13 +49,58 @@ module OMF::OML
         @on_new_stream_procs.delete key
       end
     end
+    
+    # Return a table (more precisely an OmlTable instance) fed from 
+    # the content of a table 'table_name' in this database.
+    #
+    # table_name - Name of table in the SQL database
+    # opts - 
+    #   :include_oml_internals - Include OML 'header' columns [true]
+    #   :name - name used for returned OML Table [table_name]
+    #   All other options defined for OmlSqlRow#new
+    #
+    def create_table(table_name, opts = {})
+      tn = opts.delete(:name) || table_name
+      schema = _schema_for_table(table_name)
+      r = OmlSqlRow.new(table_name, schema, @db, opts)
+      r.to_table(tn, opts)
+    end
+    
+    # Call 'block' for every row in 'table_name' table.
+    #
+    # table_name - Name of table in the SQL database
+    # opts - 
+    #   :include_oml_internals[boolean] - Include OML 'header' columns [true]
+    #   :schema[Schema] Schema to use for creating row
+    #   All other options defined for OmlSqlRow#new
+    #
+    def create_stream(table_name, opts = {}, &block)
+      rschema = opts.delete(:schema)
+      schema = _schema_for_table(table_name)
+      r = OmlSqlRow.new(table_name, schema, @db, opts)
+      ropts = {}
+      ropts[:schema] = rschema if rschema
+      r.to_stream(ropts, &block)
+    end
+
+    #
+    # Run a query on the database and return the result as an OmlTable. The provided schema 
+    # needs to describe the SQL queries result set. Unfortunately we can only do very little
+    # sanity checks here
+    #
+    def query(sql, table_name, schema)
+      tbl = OmlTable.create(table_name, schema)
+      @db.fetch(sql).each do |row|
+        tbl << schema.hash_to_row(row)
+      end
+      tbl
+    end
 
     # Start checking the database for tables and create a new stream
     # by calling the internal +report_new_table+ method.
     # If +check_every+ > 0 continue checking every +check_every+ seconds
     # for new tables in the database, otherwise it's only checked once
     #
-    #
     def run(check_every = -1)
       if check_every <= 0
         run_once()
@@ -67,6 +120,8 @@ module OMF::OML
       end
     end
 
+    protected
+
     def run_once()
       debug "Finding tables #{@db.tables}"
       # first find tables
@@ -83,7 +138,6 @@ module OMF::OML
     end
 
 
-    protected
 
     # THis method is being called for every table detected in the database.
     # It creates a new +OmlSqlRow+ object with +opts+ as the only argument.
@@ -95,7 +149,9 @@ module OMF::OML
     def report_new_table(table_name)
       unless table =  @tables[table_name] # check if already reported before
         debug "Found table: #{table_name}"
-        table = @tables[table_name] = OmlSqlRow.new(table_name, @db.schema(table_name), @db_opts, self, @row_opts)
+        schema = _schema_for_table(table_name)
+        table = @tables[table_name] = OmlSqlRow.new(table_name, schema, @db, @row_opts)
+        #table = @tables[table_name] = OmlSqlRow.new(table_name, @db.schema(table_name), @db_opts, self, @row_opts)
         @on_new_stream_procs.each_value do |proc|
           proc.call(table)
         end
@@ -103,6 +159,20 @@ module OMF::OML
       table
     end
     
+    def _schema_for_table(table_name)
+      begin
+        schema_descr = @db.schema(table_name).map do |col_name, cd|
+          unless type = cd[:type] || FALLBACK_MAPPING[cd[:db_type]]
+            warn "Can't find ruby type for database type '#{cd[:db_type]}'"
+          end
+          {name: col_name, type: type}
+        end
+        #puts "SCHEMA_DESCR>>>> #{schema_descr}"
+        schema = OmlSchema.new(schema_descr)
+      rescue Sequel::Error => ex
+        raise "Problems reading schema of table '#{table_name}'. Does it exist? (#{@db.tables})"
+      end
+    end
   end
   
 

data/lib/omf_oml/table.rb

@@ -43,7 +43,9 @@ module OMF::OML
       #@endpoint = endpoint
       @name = tname
       @schema = OmlSchema.create(schema)
+      @add_index = false
       unless @schema.name_at(0) == :__id__
+        @add_index = true
         @schema.insert_column_at(0, [:__id__, 'int'])
       end
       @opts = opts
@@ -100,6 +102,14 @@ module OMF::OML
       end
     end
     
+    def on_row_added(key, &block)
+      on_content_changed(key) do |action, rows|
+        if action == :added
+          rows.each {|r| block.call(r)}
+        end
+      end
+    end
+    
     # NOTE: +on_row_added+ callbacks are done within the monitor. 
     #
     def add_row(row, needs_casting = false)
@@ -110,6 +120,10 @@ module OMF::OML
       end
     end
     
+    def <<(row)
+      add_row(row)
+    end
+    
     # Return a new table which shadows this table but only contains
     # rows with unique values in the column 'col_name' and of these the 
     # latest added rows to this table.
@@ -164,6 +178,12 @@ module OMF::OML
       st
     end
     
+    # Return table as an array of rows
+    #
+    def to_a
+      @rows.dup
+    end
+    
     def describe()
       rows
     end
@@ -177,6 +197,7 @@ module OMF::OML
     # NOT synchronized
     #
     def _add_row(row, needs_casting = false)
+      throw "Expected array, but got '#{row}'" unless row.is_a?(Array)
       if needs_casting
         row = @schema.cast_row(row, true)
       end
@@ -186,12 +207,12 @@ module OMF::OML
       end
       return nil unless row 
 
-      row.insert(0, @row_id += 1)
+      row.insert(0, @row_id += 1) if @add_index
       _add_row_finally(row)
     end
     
-    # Finally add 'row' to internal storage. This would be hte method to
-    # overide in sub classes as this is thread safe and all other pre-storage
+    # Finally add 'row' to internal storage. This would be the method to
+    # override in sub classes as this is thread safe and all other pre-storage
     # test have been performed. Should return the row added, or nil if nothing
     # was ultimately added.
     #

data/lib/omf_oml/version.rb

@@ -1,6 +1,6 @@
 
 module OMF
   module OML
-    VERSION = '0.9.5'
+    VERSION = '0.9.6'
   end
 end

data/omf_oml.gemspec

@@ -22,5 +22,6 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
 #  s.add_development_dependency "minitest", "~> 2.11.3"
-  s.add_runtime_dependency "sqlite3", "~> 1.3.6"
+  #s.add_runtime_dependency "sqlite3", "~> 1.3.6"
+  s.add_runtime_dependency 'sequel', '~> 3.45'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omf_oml
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-18 00:00:00.000000000 Z
+date: 2013-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '3.45'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '3.45'
 description: ! "Glue functionality between OMF and OMF related libraries, such as
   OMF Web and Labwiki, and\n    OML."
 email: