directiverecord 0.1.1 → 0.1.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTI2YTQyODBjY2FmMmJmYjgyNzZiNDVmOGRjMDA3MjBmNTA1MGQ0ZA==
+    MWExODBiMTQ1NGVmYjU5MmE1ZGI4ZGE2MGI4ZWY2OWNhYjc0YWM1Yw==
   data.tar.gz: !binary |-
-    YzQ5ODk1MzAxMWYxM2Q1ZDBmNTE4MjkwYTAyMTEyOTM1MjA4OGNlYQ==
+    OTM3ZTk5NDY0OTBiZDc5NDY1NTEyNjJjYjkyYjQ4ZTZkN2MyODUyMg==
 SHA512:
   metadata.gz: !binary |-
-    ZTEyNjY3NDVkMmQ1YzUzMTg2ZjU3MjdhZDdlYmY1YTk1NjUzMGU3ODdiODE1
-    YzdkMzUwYTU1ZDA1NmFmNDE0N2IxMDdlM2NmMTc0ZTZmODg2NTcyMDBlNTE2
-    ZjA2YTNiMTQ0MGU4N2E1MmE1MzkyOGJjMmY3YjU0YjU1NzI5NmE=
+    ZGQ1MzBhNTZkZGRjZmU2ODA5OGUyNDY1NDM0NmNhYzE5YWYxYTVjYTEyMWI3
+    OWQ0ODhiZDVjZjY2M2RiNGYxNTgxNjVlMWVkMzMzMTZlMjM4ZGRlZDRlYzFm
+    Njg5YWZjOGFhZjI4NTcwZGYyYTI0NjAyZWVjZGI1YWZkYmQyZTk=
   data.tar.gz: !binary |-
-    YmFmZWQ5Y2E3NDI4MjUzNzQ1ZTJkYzAwMjE1YmFhMmQ1ODM2ZmUyYzAzZTcw
-    ZTk0YmRlMzNlMThkZWFjOWEzMDcxZmI3YTU3ODFhYTRhMTlmYzRlOTNjM2Rl
-    ZDA4MmQ1ODc1YmUzMDMxODMxMmMzZjkzMDI0MmZhYzI0OGI0NWI=
+    NjFjNTE4ZmMzMWFkYjUxYzYzZDBhMmYzODA1N2FlODU3Mjg4NjFhNjI3ZDM4
+    ZjVhZGIyYzM3MjViMDQ4OTVmNjQwNzNlN2U4MjMyOTY1YTE3NDFiY2QzZDYw
+    ODBjMmMwOTQxNWI5ODAzYzE0NTNlMDg5NDRiMTUyMmRjZDBkNWI=

data/CHANGELOG.rdoc

@@ -1,5 +1,13 @@
 = DirectiveRecord CHANGELOG
 
+== Version 0.1.2 (January 21, 2015)
+
+* Downgraded ActiveRecord gem dependency to >= 3.2.13
+* Being able to specify the connection to query with
+* Ensuring option values to be arrays
+* Not making the path delimiter obligated (which implies denormalized data)
+* Added BigQuery support (denormalized data)! ^^
+
 == Version 0.1.1 (January 19, 2015)
 
 * Optimizing query when passing :optimize => true and having paths within the select statement

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/directiverecord.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = DirectiveRecord::VERSION
 
-  gem.add_dependency "activerecord", ">= 4.0"
+  gem.add_dependency "activerecord", ">= 3.2.13"
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "yard"

data/lib/directive_record/gem_ext/active_record/base.rb

@@ -2,11 +2,17 @@ module ActiveRecord
   class Base
 
     def self.to_qry(*args)
-      DirectiveRecord::Query.new(self).to_sql(*args)
+      DirectiveRecord::Query.new(self, extract_connection(args)).to_sql(*args)
     end
 
     def self.qry(*args)
-      connection.select_rows to_qry(*args)
+      extract_connection(args).select_rows to_qry(*args)
+    end
+
+  private
+
+    def self.extract_connection(args)
+      (args[-1][:connection] if args[-1].is_a?(Hash)) || connection
     end
 
   end

data/lib/directive_record/query.rb

@@ -1,11 +1,12 @@
 require "directive_record/query/sql"
 require "directive_record/query/mysql"
+require "directive_record/query/big_query"
 
 module DirectiveRecord
   module Query
 
-    def self.new(klass)
-      class_for(klass.connection.class.name.downcase).new(klass)
+    def self.new(klass, connection = nil)
+      class_for((connection || klass.connection).class.name.downcase).new(klass)
     end
 
   private
@@ -13,6 +14,8 @@ module DirectiveRecord
     def self.class_for(connection_class)
       if connection_class.include?("mysql")
         MySQL
+      elsif connection_class.include?("bigquery")
+        BigQuery
       else
         raise NotImplementedError, "Connection type not supported"
       end

data/lib/directive_record/query/big_query.rb

@@ -0,0 +1,60 @@
+module DirectiveRecord
+  module Query
+    class BigQuery < SQL
+
+    private
+
+      def aggregate_delimiter
+        "__"
+      end
+
+      def group_by_all_sql
+        "all_rows"
+      end
+
+      def normalize_from!(options)
+        period = options[:period]
+
+        options[:where].delete_if do |statement|
+          if statement.match(/^#{period} = '(\d{4}-\d{2}-\d{2})'$/)
+            begin_date, end_date = $1, $1
+          elsif statement.match(/^#{period} >= '(\d{4}-\d{2}-\d{2})' AND #{period} <= '(\d{4}-\d{2}-\d{2})'$/)
+            begin_date, end_date = $1, $2
+          end
+          if begin_date
+            dataset = ::BigQuery.connection.instance_variable_get(:@dataset) # TODO: fix this
+            options[:from] = (Date.parse(begin_date)..Date.parse(end_date)).collect do |date|
+              "[#{dataset}.#{base.table_name}_#{date.strftime("%Y%m%d")}]"
+            end
+            options[:from] = "\n  #{options[:from].join(",\n  ")}"
+          end
+        end
+      end
+
+      def prepend_base_alias!(options); end
+
+      def finalize_options!(options)
+        aliases = options[:aliases] || {}
+
+        options[:select].collect! do |string|
+          expression, select_alias = string.match(/^(.*) AS (.*)$/).try(:captures)
+          if select_alias
+            aliases[expression] = select_alias
+            options[:group_by].to_s.include?(expression) || !expression.match(/^\w+(\.\w+)*$/) ? string : "MAX(#{expression}) AS #{select_alias}"
+          else
+            string.match(/^\w+(\.\w+)*$/) ? "MAX(#{string})" : string
+          end
+        end if options[:group_by]
+
+        [:group_by, :having, :order_by].each do |key|
+          if value = options[key]
+            value = value.join ", "
+            aliases.each{|pattern, replacement| value.gsub! pattern, replacement}
+            options[key] = value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/directive_record/query/mysql.rb

@@ -22,11 +22,14 @@ module DirectiveRecord
 
       def finalize_options!(options)
         return unless options[:numerize_aliases]
+
+        aliases = options[:aliases] || {}
+
         [:group_by, :having, :order_by].each do |key|
-          if sql = options[key]
-            options[:aliases].each do |pattern, replacement|
-              sql.gsub! pattern, replacement
-            end
+          if value = options[key]
+            value = value.join ", "
+            aliases.each{|pattern, replacement| value.gsub! pattern, replacement}
+            options[key] = value
           end
         end
       end

data/lib/directive_record/query/sql.rb

@@ -7,9 +7,10 @@ module DirectiveRecord
       end
 
       def to_sql(*args)
-        options = extract_options(args)
+        options = to_options(args)
         validate_options! options
 
+        check_path_delimiter! options
         optimize_query! options
 
         prepare_options! options
@@ -20,14 +21,13 @@ module DirectiveRecord
         prepend_base_alias! options
         finalize_options! options
 
+        flatten_options! options
         compose_sql options
       end
 
     private
 
-      def path_delimiter
-        raise NotImplementedError
-      end
+      def path_delimiter; end
 
       def aggregate_delimiter
         raise NotImplementedError
@@ -57,18 +57,25 @@ module DirectiveRecord
         sql_alias
       end
 
-      def extract_options(args)
+      def to_options(args)
         options = args.extract_options!.deep_dup
         options.reverse_merge! :select => (args.empty? ? "*" : args)
+
+        [:select, :where, :group_by, :order_by].each do |key|
+          if value = options[key]
+            options[key] = [value].flatten
+          end
+        end
+
         options
       end
 
       def validate_options!(options)
-        options.assert_valid_keys :select, :where, :group_by, :order_by, :limit, :offset, :aggregates, :numerize_aliases, :optimize
+        options.assert_valid_keys :connection, :select, :where, :group_by, :order_by, :limit, :offset, :aggregates, :numerize_aliases, :period, :optimize
       end
 
       def optimize_query!(options)
-        select = [options[:select]].flatten
+        select = options[:select]
         if options[:optimize] && (select != %w(id)) && select.any?{|x| x.match(/^\w+(\.\w+)+$/)}
           ids = base.connection.select_values(to_sql(options.merge(:select => "id"))).uniq + [0]
           options[:where] = ["id IN (#{ids.join(", ")})"]
@@ -77,10 +84,26 @@ module DirectiveRecord
         end
       end
 
+      def check_path_delimiter!(options)
+        unless path_delimiter
+          normalize_group_by! options
+          [:select, :where, :having, :group_by, :order_by].each do |key|
+            if value = options[key]
+              value.collect! do |val|
+                base.reflections.keys.inject(val) do |v, association|
+                  v.gsub(/\b#{association}\.([a-z_\.]+)/) { "#{association}_#{$1.gsub(".", "_")}" }
+                end
+              end
+            end
+          end
+        end
+      end
+
       def prepare_options!(options); end
 
       def normalize_options!(options)
         normalize_select!(options)
+        normalize_from!(options)
         normalize_where!(options)
         normalize_group_by!(options)
         normalize_order_by!(options)
@@ -88,10 +111,9 @@ module DirectiveRecord
       end
 
       def normalize_select!(options)
-        select = to_array! options, :select
-        select.uniq!
+        options[:select].uniq!
 
-        options[:scales] = select.inject({}) do |hash, sql|
+        options[:scales] = options[:select].inject({}) do |hash, sql|
           if scale = column_for(sql).try(:scale)
             hash[sql] = scale
           end
@@ -117,15 +139,21 @@ module DirectiveRecord
             sql_alias = options[:aliases][prepend_base_alias(sql_alias || sql)] = "c#{array.size + 1}"
           end
 
+          options[:aliases][sql] = sql_alias if sql_alias
+
           array << [sql, sql_alias].compact.join(" AS ")
           array
         end
       end
 
+      def normalize_from!(options)
+        options[:from] = "#{base.table_name} #{base_alias}"
+      end
+
       def normalize_where!(options)
         regexp = /^\S+/
 
-        where, having = (to_array!(options, :where) || []).partition do |statement|
+        where, having = (options[:where] || []).partition do |statement|
           !options[:aggregated].keys.include?(statement.strip.match(regexp).to_s) &&
           statement.downcase.gsub(/((?<![\\])['"])((?:.(?!(?<![\\])\1))*.?)\1/, " ")
                             .scan(/([a-zA-Z_\.]+)?\s*(=|<=>|>=|>|<=|<|<>|!=|is|like|rlike|regexp|in|between|not|sounds|soundex)(\b|\s)/)
@@ -144,23 +172,27 @@ module DirectiveRecord
         end
 
         [:where, :having].each do |key|
-          value = options[key]
-          options[key] = (value.collect{|x| "(#{x})"}.join(" AND ") unless value.empty?)
+          if options[key].empty?
+            options.delete key
+          end
         end
       end
 
       def normalize_group_by!(options)
-        group_by = to_array! options, :group_by
-        group_by.clear.push(group_by_all_sql) if group_by == [:all]
+        if (group_by = options[:group_by]) == [:all]
+          group_by.replace [group_by_all_sql]
+        end
       end
 
       def normalize_order_by!(options)
         options[:order_by] ||= (options[:group_by] || []).collect do |path|
           direction = "DESC" if path.to_s == "date"
           "#{path} #{direction}".strip
-        end
+        end unless options[:select] == "COUNT(*)"
+
+        return unless options[:order_by]
 
-        to_array!(options, :order_by).collect! do |x|
+        options[:order_by].collect! do |x|
           segments = x.split " "
           direction = segments.pop if %w(asc desc).include?(segments[-1].downcase)
           path = segments.join " "
@@ -181,12 +213,6 @@ module DirectiveRecord
         options[:order_by].compact!
       end
 
-      def to_array!(options, key)
-        if value = options[key]
-          options[key] = [value].flatten
-        end
-      end
-
       def column_for(path)
         segments = path.split(".")
         column = segments.pop
@@ -251,14 +277,15 @@ module DirectiveRecord
       def prepend_base_alias!(options)
         [:select, :where, :group_by, :having, :order_by].each do |key|
           if value = options[key]
-            options[key] = prepend_base_alias value, options[:aliases]
+            value.collect! do |sql|
+              prepend_base_alias sql, options[:aliases]
+            end
           end
         end
       end
 
       def prepend_base_alias(sql, aliases = {})
         columns = base.columns_hash.keys
-        sql = sql.join ", " if sql.is_a?(Array)
         sql.gsub(/("[^"]*"|'[^']*'|`[^`]*`|[a-zA-Z_#{aggregate_delimiter}]+(\.[a-zA-Z_\*]+)*)/) do
           columns.include?($1) ? "#{base_alias}.#{$1}" : begin
             if (string = $1).match /^([a-zA-Z_\.]+)\.([a-zA-Z_\*]+)$/
@@ -273,8 +300,22 @@ module DirectiveRecord
 
       def finalize_options!(options); end
 
+      def flatten_options!(options)
+        [:select, :group_by, :order_by].each do |key|
+          if value = options[key]
+            options[key] = value.join(", ") if value.is_a?(Array)
+          end
+        end
+
+        [:where, :having].each do |key|
+          if value = options[key]
+            options[key] = value.collect{|x| "(#{x})"}.join(" AND ") if value.is_a?(Array)
+          end
+        end
+      end
+
       def compose_sql(options)
-        sql = ["SELECT #{options[:select]}", "FROM #{base.table_name} #{base_alias}", options[:joins]].compact
+        sql = ["SELECT #{options[:select]}", "FROM #{options[:from]}", options[:joins]].compact
 
         [:where, :group_by, :having, :order_by, :limit, :offset].each do |key|
           unless (value = options[key]).blank?

data/lib/directive_record/version.rb

@@ -1,7 +1,7 @@
 module DirectiveRecord
   MAJOR = 0
   MINOR = 1
-  TINY  = 1
+  TINY  = 2
 
   VERSION = [MAJOR, MINOR, TINY].join(".")
 end

data/test/unit/gem_ext/active_record/test_base.rb

@@ -10,7 +10,7 @@ module Unit
             it "initiates a DirectiveRecord::Query instance and returns the query SQL" do
               query = mock
               query.expects(:to_sql).with(:select => "city").returns("SELECT city FROM offices")
-              DirectiveRecord::Query.expects(:new).with(Office).returns(query)
+              DirectiveRecord::Query.expects(:new).with(Office, Office.connection).returns(query)
               assert_equal "SELECT city FROM offices", Office.to_qry(:select => "city")
             end
           end
@@ -22,6 +22,21 @@ module Unit
               assert_equal %w(NYC), Office.qry("city")
             end
           end
+
+          describe ".extract_connection" do
+            describe "when specified" do
+              it "returns the connection" do
+                assert_equal "connection", Office.send(:extract_connection, ["id", "name", {:connection => "connection"}])
+                assert_equal "connection", Office.send(:extract_connection, [{:connection => "connection"}])
+              end
+            end
+            describe "when not specified" do
+              it "returns the connection of the class" do
+                Office.expects(:connection).returns(class_connection = "class_connection")
+                assert_equal class_connection, Office.send(:extract_connection, ["id", "name"])
+              end
+            end
+          end
         end
 
       end

data/test/unit/query/test_big_query.rb

@@ -0,0 +1,72 @@
+require_relative "../../test_helper"
+
+module BigQuery
+  class Client
+  end
+end
+
+module Unit
+  module Query
+    class TestBigQuery < MiniTest::Test
+
+      describe DirectiveRecord::Query::BigQuery do
+        before do
+          (connection = BigQuery::Client.new).instance_variable_set(:@dataset, "my_stats")
+          BigQuery.expects(:connection).returns(connection).at_least_once
+        end
+
+        it "generates the expected SQL" do
+          assert_equal(
+            %Q{
+              SELECT MAX(id),
+                     SUM(order_details_quantity_ordered) AS sum__order_details_quantity_ordered,
+                     SUM(order_details_price_each) AS sum__order_details_price_each,
+                     SUM(order_details_quantity_ordered * order_details_price_each) AS price
+              FROM
+                [my_stats.orders_20150121]
+              GROUP BY id
+              ORDER BY price DESC
+            }.strip.gsub(/\s+/, " "),
+            Order.to_qry(
+              "id", "order_details_quantity_ordered", "order_details_price_each", "SUM(order_details_quantity_ordered * order_details_price_each) AS price",
+              :connection => BigQuery.connection,
+              :where => "order_date = '2015-01-21'",
+              :group_by => "id",
+              :order_by => "price DESC",
+              :period => "order_date",
+              :aggregates => {
+                "order_details_quantity_ordered" => :sum,
+                "order_details_price_each" => :sum
+              }
+            ).strip.gsub(/\s+/, " ")
+          )
+
+          assert_equal(
+            %Q{
+              SELECT MAX(id), SUM(order_details_quantity_ordered * order_details_price_each)
+              FROM
+                [my_stats.orders_20150115],
+                [my_stats.orders_20150116],
+                [my_stats.orders_20150117],
+                [my_stats.orders_20150118],
+                [my_stats.orders_20150119],
+                [my_stats.orders_20150120],
+                [my_stats.orders_20150121]
+              GROUP BY id
+              ORDER BY id
+            }.strip.gsub(/\s+/, " "),
+            Order.to_qry(
+              "id", "SUM(order_details.quantity_ordered * order_details.price_each)",
+              :connection => BigQuery.connection,
+              :where => "order_date >= '2015-01-15' AND order_date <= '2015-01-21'",
+              :group_by => "id",
+              :order_by => "id",
+              :period => "order_date"
+            ).strip.gsub(/\s+/, " ")
+          )
+        end
+      end
+
+    end
+  end
+end

data/test/unit/query/test_sql.rb

@@ -17,10 +17,8 @@ module Unit
         end
 
         describe "#path_delimiter" do
-          it "raises an NotImplementedError" do
-            assert_raises NotImplementedError do
-              @directive_query.send :path_delimiter
-            end
+          it "returns nil" do
+            assert_nil @directive_query.send(:path_delimiter)
           end
         end
 

data/test/unit/test_query.rb

@@ -7,7 +7,7 @@ module Unit
       describe ".new" do
         it "returns the appropriate query instance" do
           instance = mock
-          instance.expects(:new).with(Office).returns("SELECT * FROM offices")
+          instance.expects(:new).with(Office, nil).returns("SELECT * FROM offices")
           DirectiveRecord::Query.expects(:class_for).with("activerecord::connectionadapters::mysql2adapter").returns(instance)
           assert_equal "SELECT * FROM offices", DirectiveRecord::Query.new(Office)
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: directiverecord
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Paul Engel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-19 00:00:00.000000000 Z
+date: 2015-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 3.2.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 3.2.13
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +143,7 @@ files:
 - lib/directive_record/gem_ext/active_record/base.rb
 - lib/directive_record/gem_ext/active_record/relation.rb
 - lib/directive_record/query.rb
+- lib/directive_record/query/big_query.rb
 - lib/directive_record/query/mysql.rb
 - lib/directive_record/query/sql.rb
 - lib/directive_record/relation.rb
@@ -164,6 +165,7 @@ files:
 - test/test_helper/coverage.rb
 - test/unit/gem_ext/active_record/test_base.rb
 - test/unit/gem_ext/active_record/test_relation.rb
+- test/unit/query/test_big_query.rb
 - test/unit/query/test_mysql.rb
 - test/unit/query/test_sql.rb
 - test/unit/test_directive_record.rb
@@ -210,6 +212,7 @@ test_files:
 - test/test_helper/coverage.rb
 - test/unit/gem_ext/active_record/test_base.rb
 - test/unit/gem_ext/active_record/test_relation.rb
+- test/unit/query/test_big_query.rb
 - test/unit/query/test_mysql.rb
 - test/unit/query/test_sql.rb
 - test/unit/test_directive_record.rb