activecube 0.1.0

data/lib/activecube/query/item.rb

@@ -0,0 +1,22 @@
+module Activecube::Query
+  class Item
+
+    include ChainAppender
+
+    attr_reader :cube, :key, :definition
+    def initialize cube, key, definition
+      @key = key
+      @cube = cube
+      @definition = definition
+    end
+
+    def required_column_names
+      definition.class.column_names || []
+    end
+
+    def alias! new_key
+      self.class.new cube, new_key, definition
+    end
+
+  end
+end

data/lib/activecube/query/limit.rb

@@ -0,0 +1,17 @@
+module Activecube
+  module Query
+    class Limit
+
+      attr_reader :argument, :option
+      def initialize argument, option
+        @argument = argument
+        @option = option
+      end
+
+      def append_query _cube_query, _table, query
+        query.send(option,argument)
+      end
+
+    end
+  end
+end

data/lib/activecube/query/measure.rb

@@ -0,0 +1,40 @@
+module Activecube::Query
+  class Measure < Item
+
+    attr_reader :selectors
+
+    def initialize cube, key, definition, selectors = []
+      super cube, key, definition
+      @selectors = selectors
+    end
+
+    def required_column_names
+      ((definition.class.column_names || []) + selectors.map(&:required_column_names)).flatten.uniq
+    end
+
+    def when *args
+      append *args, @selectors, Selector, cube.selectors
+    end
+
+    def alias! new_key
+      self.class.new cube, new_key, definition, selectors
+    end
+
+    def condition_query arel_table, cube_query
+      condition = nil
+      selectors.each do |selector|
+        condition = condition ?
+                        condition.and(selector.expression(arel_table, cube_query)) :
+                        selector.expression(arel_table, cube_query)
+      end
+      condition
+    end
+
+    def append_query cube_query, table, query
+      attr_alias = "`#{key.to_s}`"
+      expr = definition.expression table, self, cube_query
+      query.project expr.as(attr_alias)
+    end
+
+  end
+end

data/lib/activecube/query/or_selector.rb

@@ -0,0 +1,20 @@
+module Activecube
+  module Query
+    class OrSelector < Selector
+
+      attr_reader :selectors
+      def initialize selectors
+        @selectors = selectors
+      end
+
+      def append_query cube_query, table, query
+        expr = nil
+        selectors.each do |s|
+          expr = expr ? expr.or(s.expression table, cube_query) : s.expression(table, cube_query)
+        end
+        query.where(expr)
+      end
+
+    end
+  end
+end

data/lib/activecube/query/ordering.rb

@@ -0,0 +1,17 @@
+module Activecube
+  module Query
+    class Ordering
+
+      attr_reader :argument, :direction
+      def initialize argument, direction
+        @argument = argument
+        @direction = direction
+      end
+
+      def append_query _cube_query, _table, query
+        query.order(::Arel.sql(argument.to_s).send(direction))
+      end
+
+    end
+  end
+end

data/lib/activecube/query/selector.rb

@@ -0,0 +1,84 @@
+module Activecube::Query
+  class Selector < Item
+
+    OPERATORS = ['eq','ne','gt','lt','ge','le','in','not_in']
+    ARRAY_OPERATORS = ['in','not_in']
+
+    class Operator
+
+      attr_reader :operation, :argument
+
+      def initialize operation, argument
+        @operation = operation
+        @argument = argument
+      end
+
+      def expression left, right
+        left.send(operation, right)
+      end
+
+      def eql?(other)
+        return other.kind_of?(Operator) &&
+            self.operation==other.operation &&
+            self.argument == other.argument
+      end
+
+      def == other
+        eql? other
+      end
+
+      def hash
+        self.operation.hash + self.argument.hash
+      end
+
+    end
+
+    attr_reader :operator
+    def initialize cube, key, definition, operator = nil
+      super cube, key, definition
+      @operator = operator
+    end
+
+    OPERATORS.each do |method|
+      define_method(method) do |*args|
+        if ARRAY_OPERATORS.include? method
+          @operator = Operator.new(method, args)
+        else
+          raise ArgumentError, "Unexpected size of arguments" unless args.size==1
+          @operator = Operator.new(method, args.first)
+        end
+        self
+      end
+    end
+
+    def alias! new_key
+      self.class.new cube, new_key, definition, operator
+    end
+
+    def append_query cube_query, table, query
+      query.where(expression table, cube_query)
+    end
+
+    def expression arel_table, cube_query
+      definition.expression arel_table, self, cube_query
+    end
+
+    def eql?(other)
+      return other.kind_of?(Selector) &&
+          self.cube==other.cube &&
+          self.operator == other.operator &&
+          self.definition.class == other.definition.class
+    end
+
+    def == other
+      eql? other
+    end
+
+    def hash
+      self.definition.class.hash + self.operator.hash
+    end
+
+  end
+end
+
+Arel::Nodes::SqlLiteral

data/lib/activecube/query/slice.rb

@@ -0,0 +1,57 @@
+module Activecube::Query
+  class Slice < Item
+
+    attr_reader :field, :modifier
+    def initialize cube, key, dimension, field = nil, modifier = nil
+      super cube, key, dimension
+      @field = field
+      @modifier = modifier
+      field_methods! if field.try(:definition).kind_of?(Hash)
+    end
+
+    def [] key
+      unless (definition.kind_of? Activecube::Dimension) && !self.field && (field = definition.class.fields[key])
+        raise "Field #{key} is not defined for #{definition.name}"
+      end
+      Slice.new cube, key, definition, field
+    end
+
+    def alias! new_key
+      self.class.new cube, new_key, definition, field, modifier
+    end
+
+    def dimension_class
+      definition.class
+    end
+
+    def append_query _cube_query, table, query
+
+      attr_alias = "`#{key.to_s}`"
+      expr = field ? Arel.sql( modifier || field.definition ) : table[dimension_class.column_name]
+      query = query.project(expr.as(attr_alias))
+
+      if identity = dimension_class.identity
+        query = query.project(table[identity]).group(table[identity])
+      else
+        query = query.group(attr_alias).order(attr_alias)
+      end
+
+      query
+    end
+
+    private
+
+    def field_methods!
+      field.definition.each_pair do |k,v|
+        if v.kind_of? Proc
+          define_singleton_method k, ((proc {|x| @modifier = x; self}) << v)
+        elsif v.kind_of? String
+          define_singleton_method k do @modifier = v; self end
+        else
+          raise "Unexpected type #{k.class.name} for definition of #{name}[#{k}]"
+        end
+      end
+    end
+
+  end
+end

data/lib/activecube/query_methods.rb

@@ -0,0 +1,11 @@
+module Activecube
+  module QueryMethods
+
+    [:slice, :measure, :when].each do |method|
+      define_method(method) do |*args|
+        Query::CubeQuery.new(self).send method, *args
+      end
+    end
+
+  end
+end

data/lib/activecube/selector.rb

@@ -0,0 +1,11 @@
+module Activecube
+  class Selector
+    extend DimensionDefinitionMethods
+
+    def expression arel_table, selector, _cube_query
+      op = selector.operator
+      op.expression arel_table[self.class.column_name.to_sym], op.argument
+    end
+
+  end
+end

data/lib/activecube/version.rb

@@ -0,0 +1,3 @@
+module Activecube
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: activecube
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aleksey Studnev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |-
+  Activecube is the library to make multi-dimensional queries to data.Cube, dimensions, metrics and selectors are defined in the Model, similary to ActiveRecord.
+  Activecube uses Rails ActiveRecord in implementation. In particular, you have to define all tables, used in Activecube, as ActiveRecord tables.
+email:
+- astudnev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/workspace.xml"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activecube.gemspec
+- bin/console
+- bin/setup
+- lib/activecube.rb
+- lib/activecube/active_record_extension.rb
+- lib/activecube/base.rb
+- lib/activecube/clickhouse/metric/count.rb
+- lib/activecube/clickhouse/metric/sum.rb
+- lib/activecube/cube_definition.rb
+- lib/activecube/dimension.rb
+- lib/activecube/dimension_definition_methods.rb
+- lib/activecube/field.rb
+- lib/activecube/metric.rb
+- lib/activecube/processor/composer.rb
+- lib/activecube/processor/index.rb
+- lib/activecube/processor/measure_tables.rb
+- lib/activecube/processor/optimizer.rb
+- lib/activecube/processor/table.rb
+- lib/activecube/query/chain_appender.rb
+- lib/activecube/query/cube_query.rb
+- lib/activecube/query/item.rb
+- lib/activecube/query/limit.rb
+- lib/activecube/query/measure.rb
+- lib/activecube/query/or_selector.rb
+- lib/activecube/query/ordering.rb
+- lib/activecube/query/selector.rb
+- lib/activecube/query/slice.rb
+- lib/activecube/query_methods.rb
+- lib/activecube/selector.rb
+- lib/activecube/version.rb
+homepage: https://github.com/bitquery/activecube
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Multi-Dimensional Queries with Rails
+test_files: []