active_data_frame 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e1350ed7595307e7875b6430c24bab9a2fd90a2
-  data.tar.gz: 1d2f0c6eae0ddfb9ed4fa52d07526e7f9e47ec20
+  metadata.gz: 6e6c248d13e0f7f10933eca32158e4fb33a080e3
+  data.tar.gz: 28d52390deef35b8e582942612989f99e2026ed3
 SHA512:
-  metadata.gz: db812db474e0980059520b193b9c4fb67d36dbafaf865c28019ea247ab75b269ca26ccf4c6f146e1aec34897003c9f9a70be88550e002f2c514b4a3437ebce84
-  data.tar.gz: 2a2585b6f966cf5691f7d4d5155f8ea977f1f2f0213476ebdc88d3648d6511c71c743bc036ba2c4ba9b55e6610a817469e978b5c398dd6d642739fedfa2c8912
+  metadata.gz: 9fd95c152778f43ea9d3d3e09160a22ed355989b5fdc5e2cbbfb1f10b2290aab4db07d04344acb595f30f28a98eaf1282b4a461611ba6c5999b5a060fc60ae77
+  data.tar.gz: c0b32d8827258e8e8cf38e051758d8de8a1784bb2a4b19cdaada75af5b9b1541b3c45d15e6d2f033ca07ad1ec9422fc290c11b44e41fd2df5ef08b68bf805c47

data/README.md

@@ -1,9 +1,9 @@
 # ActiveDataFrame
 
-ActiveDataFrame allows efficient writing, reading, and analytical queries on large tables of numerical data. You can think of it as a persistent NumPy or NArray with good support for slicing
-and aggregates without needing to load the entire dataset into memory.
+ActiveDataFrame allows efficient writing, reading, and analytical queries on large tables of numerical data. You can think of it as a persistent NumPy or NArray with good support for slicing and aggregates without needing the entire dataset in memory.
 
 The library depends on ActiveRecord and currently supports the following relational databases:
+
 * PostgreSQL
 * MySQL
 * SQLite
@@ -24,16 +24,231 @@ Or install it yourself as:
 
     $ gem install active_data_frame
 
+## Examples
+
+### Using the generator
+
+    # Generate a new data frame named Statistic, with a datapoint type of double, and a block size of 100
+    $ rails generate active_data_frame:install Statistic double 100
+
+    # Then run migrations to create the underlying table
+    $ rake db:migrate
+
 ## Usage
+### Generator
+The easiest way to get started is to use the in-built generator to generate a new
+`ActiveDataFrame`. This will generate the required migrations for the data frame
+and generate a new module that you can include inside an `ActiveRecord` model to give it access to the frame.
+
+```
+    # Generate a new MeterReading data frame type, with a block type of
+    # double and a block size of 48 data points
+
+    $ rails generate active_data_frame:install MeterReading double 48
+
+    # Generate a new Dimension data frame type, with a block type of
+    # float and a block size of 10 data points.
+    # Inject the data-type for use into the Iris model
+
+    $ rails generate active_data_frame:install Dimension float 10 Iris
+
+    #
+    # Generate a new status data frame type with an integer block type
+    #
+    $ rails generate active_data_frame:install Status integer
+```
+
+### Writing to a data frame
+When you include a data frame in an ActiveRecord model, each instance of the model corresponds to a single row in the data frame. The columns are a series of points that stretch towards infinity in each direction.
+
+By default columns are indexed by integers, but you can set a static or dynamic column map so that you can easily have columns indexed by time, enum columns or use any other data type that serves as a useful index.
+
+You can write any number of data points to a row in the dataframe using #[]=
+
+        #E.g.
+        # Write to the row called readings from index 0. Here Sensor is the ActiveRecord model, readings is the name of the row
+        Sensor.first.readings[0] = 1,2,3
+
+        # Write to the row called readings from an offset at 1_000_000
+        Sensor.first.readings[1_000_000] = -10, -9, -8
+
+        #Writing to a row which has a column mapping applied, mapping times on integer indexes
+        MeterChannel.first.readings['2001-01-01'] = [1.3, 3.4]
+
+        #If you have enum columns you can use the #[enum_name]= setter instead.
+        Iris.first.dimensions.sepal_length = 5.3
+        Iris.first.dimensions.petal_width  = 4.3
+
+        # You can set data for multiple rows at once, by using the frame accessor on the model's class instead of an instance.
+
+        E.g.
+        # This sets the reading at index 1 to 5 for ALL sensors
+        Sensor.readings[1] = 5
+
+        # You can use AR queries to refine which set of rows you are updating at once.
+        # E.g.
+        MeterChannel.where("created_at < ?", "2001-01-01").readings['2001-01-01'] = [5,6,7]
+
+ActiveDataFrame supports very quick writing of 1000's of values for a single row at a time. Don't be afraid to write large arrays of data like this.
+
+### Reading from a data frame
+Reading from a data frame is similar to writing and uses the #[] method.
+You can read individual values, a range of values, and sparse selections of columns.
+
+        #E.g.
+        # Read a single value
+        Sensor.first.readings[0] # => Matrix(1x1)[...]
+
+        # Read a range of 3 values values
+        Sensor.first.readings[0...3] # => Matrix(1x3)[...]
+
+        # Read some non contiguous values and ranges
+        Sensor.first.readings[5, 10, 4..7, 9..10] = Matrix(1x8)[...]
+
+        #Reading from a row which has a column mapping that uses times
+        MeterChannel.first.readings['2001-01-01'...'2002-01-01'] = Matrix(1xM)[....]
+
+        #If you have enum columns you can use the #[enum_name] getter for single columns
+        Iris.first.dimensions.sepal_length
+        Iris.first.dimensions.petal_width
+
+        # And use symbols as column indices (this assumes a specific ordering of enum columns)
+        Iris.first.dimensions[:sepal_length...:petal_width]
+
+Similar to when writing data, you can also read data from multiple rows at once.
+Just use the active data frame accessor on the model class instead of a model instance. E.g.
+
+        Sensor.readings[0..5] # => Matrix(Nx5)
+
+
+### Deleting
+    You can use #clear(range_or_indices) to delete data.
+
+    Deleting data is equivalent to setting all data points to zero.
+    So the operation row[index] = [0, 0, 0, 0.....0] is equivalent
+    to the operation row.clear(index...end_index). ActiveDataFrame
+    will automatically trim empty blocks.
 
-TODO: Write usage instructions here
+### Batching
+If performing many small reads and writes from a data frame in a single atomic operation
+it makes sense to do this in a single transaction. Active Data Frame provides the `ActiveDataFrame::Database.batch do ... end` method. This method will not only ensure your operations occur in a single transaction, but also that they are sent to the underlying database adapter as a single command.
 
+### Analytical Queries
+Any read of a dataframe returns an RMatrix instance. An RMatrix supports a large number of
+statistical methods and list methods. (See the RMatrix readme for more details).
+E.g.
+
+        cpu_loads = CPU.first.loads['2001-01-01'..'2005-01-01']
+        puts cpu_loads.avg
+        puts cpu_loads.stddev
+        puts cpu_loads.max
+        # ... and many more
+
+However in some cases you are dealing with so much data it is not possible, or too slow to retreive all the data at once and manipulate in-memory. ActiveDataFrame supports performing a number of aggregate methods directly in the database. These are #avg, #min, #max and #sum. The syntax for this is almost identical to an ordinary read.
+
+        CPU.loads.avg['2001-01-01'...'2005-01-01'] # The average CPU load per period over all CPUS
+
+        CPU.where(manufacturer: :intel).loads.min['2001-01-01'...'2005-01-01'] # The minimum CPU load per period over all intel CPUS
+
+### Categorical data
+ActiveDataFrame provides a very basic abstraction for storing categorical data. This is done by storing categories as an integer data frame, and providing a map from integers to categories. The library will then allow you to use the category names in place of the raw underlying integers.
+E.g.
+
+    module HasStatus
+      include ActiveDataFrame::HasDataFrame('status', Blocks::StatusBlock, value_map: {
+        actual: 2,
+        estimated: 1,
+        unknown: 0
+      })
+    end
+
+    class CPU < ApplicationRecord
+      include HasStatus
+    end
+
+The CPU model above includes a dataframe with a status mapping. We can now do things like
+
+    CPU.first.status[0]    # => :unknown
+    CPU.first.status[0..5] # => [:unknown,:unknown,:unknown,:unknown,:unknown]
+
+    CPU.first.status[0] = :actual, :estimated
+    CPU.first.status[0..5] # => [:actual,:estimated,:unknown,:unknown,:unknown]
+
+### Time-series data
+We can use any datatype we like to index into a dataframe, so long as we can map it to an integer index. This makes active dataframes very well suited to storing large streams of interval data over time.
+
+For example we might define a mapping such that every half hour period in time corresponds to a colum in our dataframe. In the below example we might be counting the number of arrivals at an airport every half-hour.
+
+
+    module HasArrivals
+      include ActiveDataFrame::HasDataFrame('arrivals', Blocks::ArrivalBlock)
+      module ColumnMaps
+        def self.included(base)
+          base.arrivals_column_map Hash.new{|hash, time| ((time.to_time - Time.at(0)) / 1.hour).to_i rescue time.to_i }
+        end
+      end
+    end
+
+    class Airport < ApplicationRecord
+      include HasArrivals::ColumnMaps, HasArrivals
+    end
+
+Now we can use any value that implements #to_time to index into our dataframe. This supports both single indexes and ranges (...).
+E.g.
+
+    Airport.first.arrivals['2001-01-01'...'2002-01-01'] = Matrix(1xM)[....]
+
+
+### Column Mappings
+We can use any datatype we like to index into a dataframe, so long as we can map it to an integer index. See the section on Time-series data for one example of this. Columns can also be aliases to categories. An example of this is using ActiveDataFrame to model the classic Iris dataset.
+
+    class Iris < ApplicationRecord
+      include HasDimensions
+      dimension_column_names %i(sepal_length sepal_width petal_length petal_width)
+    end
+
+Here we have mapped the first four columns of our data frame to sepal_length, sepal_width, petal_length and petal_width.
+
+When using symbols as column names ActiveDataFrame provides some syntactic sugar for easily slicing and dicing frames.
+
+We can do things like:
+
+* Extract a slice of data:
+
+    `iris_results = Iris.where(species: :setosa).dimension[:sepal_width..:petal_length]`
+* Extract an entire column from a data-set using the column name:
+
+    `iris_results.sepal_width => V[[...]`]
+* Extract an entire column from a data-set using the column name:
+
+    `iris_results.sepal_width => V[[...]`]
+* Extract a single value from an instance:
+
+    `Iris.first.dimension.sepal_width.to_f`
+
+* Set one or more values for an instance or row at once:
+
+    `Iris.first.dimension.sepal_width = 13`
+    `Iris.all.dimension.petal_length = 5.2,6.3,5.4,1.1`
+
+### Configuration
+ActiveDataFrame supports project-wide configuration using
+
+    ActiveDataFrame.config do |config|
+      config.[config_option_name] = [config_value]
+    end
+
+Currently the following configuration options are supported:
+
+* `suppress_logs` The queries generated by ActiveDataFrame are quite verbose. If you would like to supress ActiveRecord logging for these queries, set this option to `true`
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+## Testing
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_data_frame. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/active_data_frame.gemspec

@@ -31,5 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-reporters', '~> 1.1', '>= 1.1.0'
   spec.add_development_dependency 'minitest-around', '0.4.1'
   spec.add_runtime_dependency     'activerecord', '~> 5.0'
-  spec.add_runtime_dependency     'rmatrix', '~> 0.1.15', '>=0.1.15'
+  spec.add_runtime_dependency     'rmatrix', '~> 0.1.17', '>=0.1.17'
 end

data/lib/active_data_frame/data_frame_proxy.rb

@@ -57,8 +57,12 @@ module ActiveDataFrame
     end
 
     def method_missing(name, *args, &block)
+      if name.to_s.ends_with?(?=)
+        is_assignment = true
+        name = name.to_s.gsub(/=$/,'').to_sym
+      end
       if column_name_map && column_map[name]
-        self[name]
+        is_assignment ? self.[]=(name, *args) : self[name]
       else
         super
       end

data/lib/active_data_frame/database.rb

@@ -15,15 +15,17 @@ module ActiveDataFrame
       else
         unless sql.empty?
           ActiveRecord::Base.transaction do
-            case ActiveRecord::Base.connection_config[:adapter]
-            when 'sqlite3'.freeze
-              ActiveRecord::Base.connection.raw_connection.execute_batch sql
-            when 'mysql2'
-              sql.split(';').reject{|x| x.strip.empty?}.each do |stmt|
-                ActiveRecord::Base.connection.execute(stmt)
+            ActiveDataFrame::DataFrameProxy.suppress_logs do
+              case ActiveRecord::Base.connection_config[:adapter]
+              when 'sqlite3'.freeze
+                ActiveRecord::Base.connection.raw_connection.execute_batch sql
+              when 'mysql2'
+                sql.split(';').reject{|x| x.strip.empty?}.each do |stmt|
+                  ActiveRecord::Base.connection.execute(stmt)
+                end
+              else
+                ActiveRecord::Base.connection.execute(sql)
               end
-            else
-              ActiveRecord::Base.connection.execute(sql)
             end
           end
         end
@@ -60,56 +62,16 @@ module ActiveDataFrame
     # Update block data for all blocks in a single call
     ##
     def bulk_update(existing)
-      ActiveDataFrame::DataFrameProxy.suppress_logs do
-        case ActiveRecord::Base.connection_config[:adapter]
-        when 'postgresql'.freeze
-          # Fast bulk update
-          updates = ''
-          existing.each do |period_index, (values, df_id)|
-            updates <<  "(#{df_id}, #{period_index}, #{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}),"
-          end
-          perform_update(updates)
-        else
-          ids = existing.map {|_, (_, id)| id}
-          updates = block_type::COLUMNS.map.with_index do |column, column_idx|
-            [column, "CASE period_index\n#{existing.map{|period_index, (values, _)| "WHEN #{period_index} then #{values[column_idx]}"}.join("\n")} \nEND\n"]
-          end.to_h
-          update_statement = updates.map{|cl, up| "#{cl} = #{up}" }.join(', ')
-          Database.execute("UPDATE #{block_type.table_name} SET #{update_statement} WHERE
-            #{block_type.table_name}.data_frame_id IN (#{ids.join(',')})
-            AND #{block_type.table_name}.data_frame_type = '#{data_frame_type.name}'
-            AND #{block_type.table_name}.period_index IN (#{existing.keys.join(', ')});
-            "
-          )
-        end
-      end
-    end
-
-    def bulk_delete(id, indices)
-      ActiveDataFrame::DataFrameProxy.suppress_logs do
-        block_type.where(data_frame_id: id, period_index: indices).delete_all
-      end
-    end
-
-    ##
-    # Insert block data for all blocks in a single call
-    ##
-    def bulk_insert(new_blocks, instance)
-      ActiveDataFrame::DataFrameProxy.suppress_logs do
-        inserts = ''
-        new_blocks.each do |period_index, (values)|
-          inserts << \
-          case ActiveRecord::Base.connection_config[:adapter]
-          when 'postgresql', 'mysql2' then "(#{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}, #{instance.id}, #{period_index}, '#{data_frame_type.name}'),"
-          else "(#{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}, #{instance.id}, #{period_index}, '#{data_frame_type.name}'),"
-          end
+      case ActiveRecord::Base.connection_config[:adapter]
+      when 'postgresql'.freeze
+        #
+        # PostgreSQL Supports the fast setting of multiple update values that differ
+        # per row from a temporary table.
+        #
+        updates = ''
+        existing.each do |period_index, (values, df_id)|
+          updates <<  "(#{df_id}, #{period_index}, #{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}),"
         end
-        perform_insert(inserts)
-      end
-    end
-
-    def perform_update(updates)
-      ActiveDataFrame::DataFrameProxy.suppress_logs do
         Database.execute(
           <<-SQL
           UPDATE #{block_type.table_name}
@@ -121,15 +83,68 @@ module ActiveDataFrame
             AND #{block_type.table_name}.data_frame_type = '#{data_frame_type.name}'
           SQL
         )
-        true
+      #
+      # For MySQL we use the ON DUPLICATE KEY UPDATE functionality.
+      # This relies on there being a unique index dataframe and period index
+      # on the blocks table.
+      # This tends to be faster than the general CASE based solution below
+      # but slower than the PostgreSQL solution above
+      #
+      when 'mysql2'.freeze
+        # Fast bulk update
+        updates, on_duplicate = "", ""
+        existing.each do |period_index, (values, df_id)|
+          updates << "(#{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}, #{df_id}, #{period_index}, '#{data_frame_type.name}'),"
+        end
+        on_duplicate = block_type::COLUMNS.map do |cname|
+          "#{cname}=VALUES(#{cname})"
+        end.join(", ")
+        stmt = <<-SQL
+          INSERT INTO #{block_type.table_name} (#{block_type::COLUMNS.join(',')},data_frame_id,period_index,data_frame_type)
+          VALUES #{updates[0..-2]}
+          ON DUPLICATE KEY UPDATE #{on_duplicate}
+        SQL
+        Database.execute(stmt)
+      else
+        #
+        # General CASE based solution for multiple differing updates
+        # set per row.
+        # We use a CASE statement per column which determines the column
+        # to set based on the period index
+        #
+        ids = existing.map {|_, (_, id)| id}
+        updates = block_type::COLUMNS.map.with_index do |column, column_idx|
+          [column, "CASE period_index\n#{existing.map{|period_index, (values, _)| "WHEN #{period_index} then #{values[column_idx]}"}.join("\n")} \nEND\n"]
+        end.to_h
+        update_statement = updates.map{|cl, up| "#{cl} = #{up}" }.join(', ')
+        Database.execute(<<-SQL
+          UPDATE #{block_type.table_name} SET #{update_statement} WHERE
+          #{block_type.table_name}.data_frame_id IN (#{ids.join(',')})
+          AND #{block_type.table_name}.data_frame_type = '#{data_frame_type.name}'
+          AND #{block_type.table_name}.period_index IN (#{existing.keys.join(', ')});
+        SQL
+        )
       end
     end
 
-    def perform_insert(inserts)
-      ActiveDataFrame::DataFrameProxy.suppress_logs do
-        sql = "INSERT INTO #{block_type.table_name} (#{block_type::COLUMNS.join(',')}, data_frame_id, period_index, data_frame_type) VALUES #{inserts[0..-2]}"
-        Database.execute sql
+    def bulk_delete(id, indices)
+      block_type.where(data_frame_id: id, period_index: indices).delete_all
+    end
+
+    ##
+    # Insert block data for all blocks in a single call
+    ##
+    def bulk_insert(new_blocks, instance)
+      inserts = ''
+      new_blocks.each do |period_index, (values)|
+        inserts << \
+        case ActiveRecord::Base.connection_config[:adapter]
+        when 'postgresql', 'mysql2' then "(#{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}, #{instance.id}, #{period_index}, '#{data_frame_type.name}'),"
+        else "(#{values.map{|v| v.inspect.gsub('"',"'") }.join(',')}, #{instance.id}, #{period_index}, '#{data_frame_type.name}'),"
+        end
       end
+      sql = "INSERT INTO #{block_type.table_name} (#{block_type::COLUMNS.join(',')}, data_frame_id, period_index, data_frame_type) VALUES #{inserts[0..-2]}"
+      Database.execute sql
     end
   end
 end

data/lib/active_data_frame/row.rb

@@ -21,7 +21,6 @@ module ActiveDataFrame
       end
 
       deleted_indices = []
-
       existing = blocks_between([bounds]).pluck(:data_frame_id, :period_index, *block_type::COLUMNS).map do |id, period_index, *block_values|
         [period_index, [block_values, id]]
       end.to_h
@@ -31,7 +30,10 @@ module ActiveDataFrame
         if existing[index]
           block = existing[index]
           block.first[left..right] = chunk.to_a
-          deleted_indices << index if block.first.all?(&:zero?)
+          if block.first.all?(&:zero?)
+            deleted_indices << index
+            existing.delete(index)
+          end
         elsif chunk.any?(&:nonzero?)
           new_blocks[index].first[left..right] = chunk.to_a
         end
@@ -49,7 +51,9 @@ module ActiveDataFrame
         get_bounds(range.first, range.exclude_end? ? range.end - 1 : range.end, index)
       end
 
-      existing = blocks_between(all_bounds).pluck(:period_index, *block_type::COLUMNS).map{|pi, *values| [pi, values]}.to_h
+      existing = self.class.suppress_logs{
+        blocks_between(all_bounds).pluck(:period_index, *block_type::COLUMNS).map{|pi, *values| [pi, values]}.to_h
+      }
       result   = M.blank(typecode: block_type::TYPECODE, columns: all_bounds.map(&:length).sum)
 
       iterate_bounds(all_bounds) do |index, left, right, cursor, size|

data/lib/active_data_frame/table.rb

@@ -42,7 +42,6 @@ module ActiveDataFrame
         col_cases = cases[col].sort_by(&:begin).reduce([]) do |agg, col_case|
           if agg.empty?
             agg << col_case
-            agg
           else
             if agg[-1].end.succ == col_case.begin
               agg[-1] = (agg[-1].begin..col_case.end)
@@ -96,9 +95,9 @@ module ActiveDataFrame
         ids = data_frame_type.pluck(:id)
         as_sql = blocks_between(
           all_bounds,
-          block_scope: data_frame_type.unscoped
-                                    .joins("LEFT JOIN #{block_type.table_name} ON #{data_frame_type.table_name}.id = #{block_type.table_name}.data_frame_id")
-
+          block_scope: data_frame_type.unscoped.where(
+            "#{data_frame_type.table_name}.id IN (SELECT id FROM (#{data_frame_type.select(:id).to_sql}) airport_ids)"
+          ).joins("LEFT JOIN #{block_type.table_name} ON #{data_frame_type.table_name}.id = #{block_type.table_name}.data_frame_id")
         ).where(
           block_type.table_name => {data_frame_type: data_frame_type.name }
         ).select(:period_index, :data_frame_id, *column_cases(case_map)).to_sql

data/lib/active_data_frame/version.rb

@@ -1,3 +1,3 @@
 module ActiveDataFrame
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/generators/active_data_frame/USAGE

@@ -0,0 +1,20 @@
+Description:
+    Generate a new data frame type, and optionally inject it into models that have such a data frame
+
+Example:
+
+    # Generate a new MeterReading data frame type, with a block type of
+    # double and a block size of 48 data points
+
+    rails generate active_data_frame:install MeterReading double 48
+
+    # Generate a new Dimension data frame type, with a block type of
+    # float and a block size of 10 data points.
+    # Inject the data-type for use into the Iris model
+
+    rails generate active_data_frame:install Dimension float 10 Iris
+
+    #
+    # Generate a new status data frame type with an integer block type
+    #
+    rails generate active_data_frame:install Status integer

data/lib/generators/active_data_frame/install_generator.rb

@@ -2,13 +2,11 @@ require 'rails/generators/active_record'
 
 module ActiveDataFrame
   class InstallGenerator < ActiveRecord::Generators::Base
-    desc "Generates a new data_frame type"
-
     STREAM_TYPES = %w(bit byte integer long float double)
     # Commandline options can be defined here using Thor-like options:
-    argument :type,    :type => :string, :default => 'float', :desc => "DataFrame type. One of(#{STREAM_TYPES*" ,"})"
-    argument :columns, :type => :numeric, :default => 512, :desc => "Number of columns"
-    argument :inject,     type: :array, default: []
+    argument :type,     type: :string,  default: 'float', desc: "DataFrame type. One of(#{STREAM_TYPES*" ,"})"
+    argument :columns,  type: :numeric, default: 512,     desc: "Number of columns"
+    argument :inject,   type: :array,   default: []
 
     def self.source_root
       @source_root ||= File.join(File.dirname(__FILE__), 'templates')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_data_frame
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-24 00:00:00.000000000 Z
+date: 2018-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -188,20 +188,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.15
+        version: 0.1.17
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.15
+        version: 0.1.17
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.15
+        version: 0.1.17
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.15
+        version: 0.1.17
 description: An active data frame helper
 email:
 - wc@pico.net.nz
@@ -230,6 +230,7 @@ files:
 - lib/active_data_frame/row.rb
 - lib/active_data_frame/table.rb
 - lib/active_data_frame/version.rb
+- lib/generators/active_data_frame/USAGE
 - lib/generators/active_data_frame/install_generator.rb
 - lib/generators/active_data_frame/templates/has_concern.rb
 - lib/generators/active_data_frame/templates/migration.rb