chicagowarehouse 0.6.7 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d1ffe55091b2b8fac1433fc50fef9671530f206
-  data.tar.gz: 480006599cc1e0cf41dc81c939f708c23df47697
+  metadata.gz: 617a93de9123548ce062b11bc4cb19ece4848d9b
+  data.tar.gz: a643b9eca3d49d7fbdd41649f0715450161cf6d1
 SHA512:
-  metadata.gz: 7683d3c320d51fd44bc56e4071327a459b1484677c0c28221b156209a57a515d2a41198fc6f0e549aa4cda672e966c785f6de96df11cb2b5e2d8a081561bd25c
-  data.tar.gz: 805ac03ef39232f596cc8ce254d7d0cc7daace567f7bbb8ea7a1477077875f86f1705986381b05ae590d47eae3288055b45212ba471d27e719472895e2212cc4
+  metadata.gz: 034cada83703a2ba05965314f0e7fd27cac1f341e87dbe5b5b5ced687b270ce27c86b02caa2cdec565b074ea6b1fd5e7b7f854aa95d355c6407cee87eb325f81
+  data.tar.gz: 0ff262a34d32e4c80c99706ad6036370b3ca356d1a360c8fbe865c68baa69dcd2e33756a20b58b18eedf803a8855761a6903b63a61e1509e0da7b1fbb868561a

data/Gemfile

@@ -1,11 +1,12 @@
 source "http://rubygems.org"
 
-gem "sequel", ">= 4.7"
+gem "sequel", ">= 4.11"
 gem "sequel_migration_builder", ">= 0.4.3"
 gem "chronic"
 
 group :development do
   gem "mysql2"
+  gem "pg"
   gem "yard"
   gem "rspec", "~> 2.0"
   gem "bundler"

data/Rakefile

@@ -14,7 +14,7 @@ require 'rake'
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   gem.name              = "chicagowarehouse"
-  gem.version           = "0.6.7"
+  gem.version           = "0.6.8"
   gem.summary           = "Ruby Data Warehousing"
   gem.description       = "Simple Data Warehouse toolkit for ruby"
   gem.author            = "Roland Swingler"

data/chicagowarehouse.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: chicagowarehouse 0.6.7 ruby lib
+# stub: chicagowarehouse 0.6.8 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "chicagowarehouse"
-  s.version = "0.6.7"
+  s.version = "0.6.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Roland Swingler"]
-  s.date = "2014-09-18"
+  s.date = "2015-05-06"
   s.description = "Simple Data Warehouse toolkit for ruby"
   s.email = "roland.swingler@gmail.com"
   s.extra_rdoc_files = [
@@ -91,10 +91,11 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sequel>, [">= 4.7"])
+      s.add_runtime_dependency(%q<sequel>, [">= 4.11"])
       s.add_runtime_dependency(%q<sequel_migration_builder>, [">= 0.4.3"])
       s.add_runtime_dependency(%q<chronic>, [">= 0"])
       s.add_development_dependency(%q<mysql2>, [">= 0"])
+      s.add_development_dependency(%q<pg>, [">= 0"])
       s.add_development_dependency(%q<yard>, [">= 0"])
       s.add_development_dependency(%q<rspec>, ["~> 2.0"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
@@ -103,10 +104,11 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<flog>, [">= 0"])
       s.add_development_dependency(%q<timecop>, [">= 0"])
     else
-      s.add_dependency(%q<sequel>, [">= 4.7"])
+      s.add_dependency(%q<sequel>, [">= 4.11"])
       s.add_dependency(%q<sequel_migration_builder>, [">= 0.4.3"])
       s.add_dependency(%q<chronic>, [">= 0"])
       s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<pg>, [">= 0"])
       s.add_dependency(%q<yard>, [">= 0"])
       s.add_dependency(%q<rspec>, ["~> 2.0"])
       s.add_dependency(%q<bundler>, [">= 0"])
@@ -116,10 +118,11 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<timecop>, [">= 0"])
     end
   else
-    s.add_dependency(%q<sequel>, [">= 4.7"])
+    s.add_dependency(%q<sequel>, [">= 4.11"])
     s.add_dependency(%q<sequel_migration_builder>, [">= 0.4.3"])
     s.add_dependency(%q<chronic>, [">= 0"])
     s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<pg>, [">= 0"])
     s.add_dependency(%q<yard>, [">= 0"])
     s.add_dependency(%q<rspec>, ["~> 2.0"])
     s.add_dependency(%q<bundler>, [">= 0"])

data/lib/chicago/database/schema_generator.rb

@@ -3,10 +3,10 @@ module Chicago
     # A StarSchema Visitor which produces a hash similar to the hash
     # produced by Sequel.
     class SchemaGenerator
-      attr_writer :type_converter
+      attr_writer :database_strategy
       
-      def initialize(type_converter, generate_key_tables=true)
-        @type_converter = type_converter
+      def initialize(database_strategy, generate_key_tables=true)
+        @database_strategy = database_strategy
         @generate_key_tables = generate_key_tables
       end
       
@@ -29,7 +29,7 @@ module Chicago
       end
 
       def visit_column(column)
-        @type_converter.column_hash(column)
+        @database_strategy.column_hash(column)
       end
 
       alias :visit_measure :visit_column
@@ -40,9 +40,9 @@ module Chicago
       def basic_table(table)
         t = {
           :primary_key => [:id],
-          :table_options => @type_converter.table_options,
-          :indexes => @type_converter.indexes(table),
-          :columns => [@type_converter.id_column]
+          :table_options => @database_strategy.table_options,
+          :indexes => @database_strategy.indexes(table),
+          :columns => [@database_strategy.id_column]
         }
 
         t[:columns] += table.columns.reject(&:calculated?).

data/lib/chicago/schema/query_column.rb

@@ -92,7 +92,7 @@ module Chicago
         super
         @select_name = @column.name.qualify(@owner.name)
         @count_name  = @owner.original_key.name.qualify(@owner.name)
-        @group_name  = @owner.original_key.name.qualify(@owner.name)
+        @group_name  = @column.name.qualify(@owner.name)
       end
     end
     
@@ -223,11 +223,11 @@ module Chicago
       end
 
       def select_name
-        :if.sql_function({@pivoted_column.select_name => @value}, @column.select_name, @unit)
+        Sequel.case([[{@pivoted_column.select_name => @value}, @column.select_name]], @unit)
       end
 
       def count_name
-        :if.sql_function({@pivoted_column.select_name => @value}, @column.count_name, @unit)
+        Sequel.case([[{@pivoted_column.select_name => @value}, @column.count_name]], @unit)
       end
     end
   end

data/spec/database/schema_generator_spec.rb

@@ -41,7 +41,7 @@ describe Chicago::Database::SchemaGenerator do
     end
 
     it "should have a table type of MyISAM for mysql" do
-      subject.type_converter = Chicago::Database::MysqlStrategy.new
+      subject.database_strategy = Chicago::Database::MysqlStrategy.new
       subject.visit_fact(@fact)[:facts_sales][:table_options].should == {:engine => "myisam"}
     end
 
@@ -108,7 +108,7 @@ describe Chicago::Database::SchemaGenerator do
 
     it "should have a table type of MyISAM for mysql" do
       @dimension = @schema.define_dimension(:user)
-      subject.type_converter = Chicago::Database::MysqlStrategy.new
+      subject.database_strategy = Chicago::Database::MysqlStrategy.new
       subject.visit_dimension(@dimension)[:dimension_user][:table_options].should == {:engine => "myisam"}
     end
 

data/spec/query_spec.rb

@@ -101,7 +101,8 @@ describe Chicago::Query do
 
     it "selects a count" do
       @q.select({:column => "product", :op => "count"})
-      @q.dataset.sql.should =~ /COUNT\(DISTINCT `product`\.`original_id`\)/i
+      @q.dataset.opts[:select].
+        should == [:count.sql_function(:original_id.qualify(:product)).distinct.as("product.count".to_sym)] 
     end
   end
 
@@ -125,7 +126,7 @@ describe Chicago::Query do
     end
 
     it "selects from the correctly aliased table" do
-      @q.dataset.sql.should =~ /FROM `facts_sales` AS `sales`/
+      @q.dataset.sql.should == TEST_DB[:facts_sales.as(:sales)].sql
     end
 
     it "selects a qualified column" do
@@ -194,7 +195,8 @@ describe Chicago::Query do
 
     it "selects an explicit distinct count, via a dimension reference" do
       @q.select({:column => "sales.product.type", :op => "count"})
-      @q.dataset.sql.should =~ /COUNT\(DISTINCT `product`\.`type`\)/i
+      @q.dataset.opts[:select].
+        should == [:count.sql_function(:type.qualify(:product)).distinct.as("sales.product.type.count".to_sym)] 
     end
 
     it "selects the main identifier for a bare dimension" do
@@ -205,7 +207,8 @@ describe Chicago::Query do
 
     it "selects the count of a dimension" do
       @q.select({:column => "sales.product", :op => "count"})
-      @q.dataset.sql.should =~ /COUNT\(DISTINCT `product`\.`original_id`\)/i
+      @q.dataset.opts[:select].
+        should == [:count.sql_function(:original_id.qualify(:product)).distinct.as("sales.product.count".to_sym)] 
     end
 
     describe "pivots columns" do
@@ -217,13 +220,13 @@ describe Chicago::Query do
         }.to raise_error(Chicago::UnimplementedError)
       end
 
-      it "via IF, for a measure, by a boolean column" do
+      it "via CASE, for a measure, by a boolean column" do
         @q.select({ :column => "sales.total",
                     :op => "sum",
                     :pivot => "sales.product.flag"})
         @q.dataset.opts[:select].
-          should == [:sum.sql_function(:if.sql_function({:flag.qualify(:product) => true}, :total.qualify(:sales), 0)).as("sales.total:sales.product.flag.0.sum".to_sym),
-                     :sum.sql_function(:if.sql_function({:flag.qualify(:product) => false}, :total.qualify(:sales), 0)).as("sales.total:sales.product.flag.1.sum".to_sym)
+          should == [:sum.sql_function(Sequel.case([[{:flag.qualify(:product) => true}, :total.qualify(:sales)]], 0)).as("sales.total:sales.product.flag.0.sum".to_sym),
+                     :sum.sql_function(Sequel.case([[{:flag.qualify(:product) => false}, :total.qualify(:sales)]], 0)).as("sales.total:sales.product.flag.1.sum".to_sym)
                     ]
       end
 
@@ -240,8 +243,8 @@ describe Chicago::Query do
                     :op => "avg",
                     :pivot => "sales.product.flag"})
         @q.dataset.opts[:select].
-          should == [:avg.sql_function(:if.sql_function({:flag.qualify(:product) => true}, :total.qualify(:sales), nil)).as("sales.total:sales.product.flag.0.avg".to_sym),
-                     :avg.sql_function(:if.sql_function({:flag.qualify(:product) => false}, :total.qualify(:sales), nil)).as("sales.total:sales.product.flag.1.avg".to_sym)
+          should == [:avg.sql_function(Sequel.case([[{:flag.qualify(:product) => true}, :total.qualify(:sales)]], nil)).as("sales.total:sales.product.flag.0.avg".to_sym),
+                     :avg.sql_function(Sequel.case([[{:flag.qualify(:product) => false}, :total.qualify(:sales)]], nil)).as("sales.total:sales.product.flag.1.avg".to_sym)
                     ]
       end
 
@@ -249,18 +252,20 @@ describe Chicago::Query do
         @q.select({ :column => "sales.product",
                     :op => "count",
                     :pivot => "sales.product.flag"})
-        @q.dataset.sql.should =~ /count\(DISTINCT if\(\(`product`.`flag` IS TRUE\), `product`.`original_id`, NULL\)\) AS `sales.product:sales.product.flag.0.count`/
-        @q.dataset.sql.should =~ /count\(DISTINCT if\(\(`product`.`flag` IS FALSE\), `product`.`original_id`, NULL\)\) AS `sales.product:sales.product.flag.1.count`/
+        @q.dataset.opts[:select].
+          should == [:count.sql_function(Sequel.case([[{:flag.qualify(:product) => true}, :original_id.qualify(:product)]], nil)).distinct.as("sales.product:sales.product.flag.0.count".to_sym),
+                     :count.sql_function(Sequel.case([[{:flag.qualify(:product) => false}, :original_id.qualify(:product)]], nil)).distinct.as("sales.product:sales.product.flag.1.count".to_sym)
+                    ]
       end
 
-      it "should generate SQL pivots, via IF, for a measure, by a bounded integer" do
+      it "should generate SQL pivots, via CASE, for a measure, by a bounded integer" do
         @q.select({ :column => "sales.total",
                     :op => "sum",
                     :pivot => "sales.product.rating"})
         @q.dataset.opts[:select].size.should == 10
       end
 
-      it "should generate SQL pivots, via IF, for a measure, by a string with elements" do
+      it "should generate SQL pivots, via CASE, for a measure, by a string with elements" do
         @q.select({ :column => "sales.total",
                     :op => "sum",
                     :pivot => "sales.product.sale"})
@@ -271,14 +276,28 @@ describe Chicago::Query do
         @q.select({ :column => "sales.total",
                     :op => "sum",
                     :pivot => "sales.product.sale"})
-        @q.dataset.sql.should =~ /INNER JOIN `dimension_product` AS `product` ON \(`product`.`id` = `sales`.`product_dimension_id`\)/
+        @q.dataset.opts[:join].
+          should == [Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("product","id") => :product_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_product.as(:product))]
       end
 
       it "should join on the counted table when pivoting" do
         @q.select({ :column => "sales.product",
                     :op => "count",
                     :pivot => "sales.buyer.recent"})
-        @q.dataset.sql.should =~ /INNER JOIN `dimension_product` AS `product` ON \(`product`.`id` = `sales`.`product_dimension_id`\)/
+
+        @q.dataset.opts[:join].
+          should == [
+            Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("buyer","id") => :buyer_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_customer.as(:buyer)),
+            Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("product","id") => :product_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_product.as(:product))]
       end
 
       it "should not group on pivoted columns" do
@@ -299,11 +318,6 @@ describe Chicago::Query do
       @q.dataset.opts[:group].should == ['sales.product.manufacturer'.to_sym]
     end
 
-    it "groups on the original key instead of a main identifier column" do
-      @q.select 'sales.product.name'
-      @q.dataset.opts[:group].should == [:original_id.qualify(:product)]
-    end
-
     it "doesn't group on calculated columns" do
       @q.select :column =>'sales.total', :op => 'sum'
       @q.dataset.opts[:group].should be_nil
@@ -321,20 +335,29 @@ describe Chicago::Query do
 
     it "joins on the dimension table if selecting from the dimension" do
       @q.select("sales.order_ref", "sales.product.name")
-      @q.dataset.sql.
-        should =~ /INNER JOIN `dimension_product` AS `product` ON \(`product`.`id` = `sales`.`product_dimension_id`\)/
+      @q.dataset.opts[:join].
+        should == [Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("product","id") => :product_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_product.as(:product))]
     end
 
     it "joins on a roleplayed dimension table if selecting from the dimension" do
       @q.select("sales.order_ref", "sales.seller.name")
-      @q.dataset.sql.
-        should =~ /INNER JOIN `dimension_customer` AS `seller` ON \(`seller`.`id` = `sales`.`seller_dimension_id`\)/
+      @q.dataset.opts[:join].
+        should == [Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("seller","id") => :seller_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_customer.as(:seller))]
     end
 
     it "joins when counting dimensions" do
       @q.select({:column => "sales.product", :op => "count"})
-      @q.dataset.sql.
-        should =~ /INNER JOIN `dimension_product` AS `product` ON \(`product`.`id` = `sales`.`product_dimension_id`\)/
+      @q.dataset.opts[:join].
+        should == [Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("product","id") => :product_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_product.as(:product))]
     end
 
     it "joins on multiple tables" do
@@ -393,72 +416,92 @@ describe Chicago::Query do
     end
 
     it "joins a filter dimension" do
-      @q.filter({:column => "sales.product.sku", :value => "123", :op => :eq}).dataset.sql.
-        should =~ /INNER JOIN `dimension_product` AS `product` ON \(`product`.`id` = `sales`.`product_dimension_id`\)/
+      @q.filter({:column => "sales.product.sku", :value => "123", :op => :eq}).dataset.opts[:join].
+        should == [Sequel::SQL::JoinOnClause.new(
+                Sequel.expr(Sequel.qualify("product","id") => :product_dimension_id.qualify(:sales)),
+                :inner,
+                :dimension_product.as(:product))]
     end
 
     it "can filter based on greater than" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gt}).dataset.sql.should =~ /WHERE \(`product`\.`rating` > 2\)/
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gt}).dataset.opts[:where].
+        should == Sequel.expr(:rating.qualify(:product) > 2)
     end
 
     it "can filter based on greater than or equal" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gte}).dataset.sql.should =~ /WHERE \(`product`\.`rating` >= 2\)/
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gte}).dataset.opts[:where].
+        should == Sequel.expr(:rating.qualify(:product) >= 2)
     end
 
     it "can filter based on less than" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :lt}).dataset.sql.should =~ /WHERE \(`product`\.`rating` < 2\)/
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :lt}).dataset.opts[:where].
+        should == Sequel.expr(:rating.qualify(:product) < 2)
     end
 
     it "can filter based on less than or equal" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :lte}).dataset.sql.should =~ /WHERE \(`product`\.`rating` <= 2\)/
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :lte}).dataset.opts[:where].
+        should == Sequel.expr(:rating.qualify(:product) <= 2)
     end
 
     it "can filter multiple integers" do
-      @q.filter({:column => "sales.product.rating", :value => ["1", "2"], :op => :eq}).dataset.sql.should =~ /WHERE \(`product`\.`rating` IN \(1, 2\)\)/
+      @q.filter({:column => "sales.product.rating", :value => ["1", "2"], :op => :eq}).dataset.opts[:where].
+        should == Sequel.expr(:rating.qualify(:product) => [1, 2])
     end
 
     it "can filter based on not equal" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :ne}).dataset.sql.should =~ /WHERE \(`product`\.`rating` != 2\)/
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :ne}).dataset.opts[:where].
+        should == Sequel.~(Sequel.expr(:rating.qualify(:product) => 2))
     end
 
     it "can filter based on 2 comparisons" do
-      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gte}, {:column => "sales.product.rating", :value => "7", :op => :lt}).dataset.sql.should =~ /WHERE \(\(`product`\.`rating` >= 2\) AND \(`product`\.`rating` < 7\)\)/i
+      @q.filter({:column => "sales.product.rating", :value => "2", :op => :gte}, {:column => "sales.product.rating", :value => "7", :op => :lt}).dataset.opts[:where].
+        should == Sequel.&(Sequel.expr(:rating.qualify(:product) >= 2),Sequel.expr(:rating.qualify(:product) < 7))
     end
 
     it "can filter dates" do
-      @q.filter({:column => "sales.product.date", :value => "01/02/12", :op => :eq}).dataset.sql.should =~ /WHERE \(`product`\.`date` = '2012-02-01'\)/
+      @q.filter({:column => "sales.product.date", :value => "01/02/12", :op => :eq}).dataset.opts[:where].
+        should == Sequel.expr(:date.qualify(:product) => Date.new(year=2012,month=2,day=1))
     end
 
     it "can filter based on starts with" do
-      @q.filter({:column => "sales.product.sku", :value => "123", :op => :sw}).dataset.sql.should =~ /WHERE \(`product`\.`sku` LIKE '123%'( ESCAPE '.+')?\)/
+      @q.filter({:column => "sales.product.sku", :value => "123", :op => :sw}).dataset.opts[:where].
+        should == Sequel.ilike(:sku.qualify(:product), "123%")
     end
 
     it "can filter based on 'starts with' with multiple values" do
-      @q.filter({:column => "sales.product.sku", :value => ["123","AB"], :op => :sw}).dataset.sql.should =~ /WHERE \(\(`product`\.`sku` LIKE '123%'( ESCAPE '.+')?\) OR \(`product`\.`sku` LIKE 'AB%'( ESCAPE '.+')?\)\)/
+      @q.filter({:column => "sales.product.sku", :value => ["123","AB"], :op => :sw}).dataset.opts[:where].
+        should == Sequel.|(Sequel.ilike(:sku.qualify(:product), "123%"), Sequel.ilike(:sku.qualify(:product), "AB%"))
+
     end
 
     it "can filter based on not starts with" do
-      @q.filter({:column => "sales.product.sku", :value => "123", :op => :nsw}).dataset.sql.should =~ /WHERE \(`product`\.`sku` NOT LIKE '123%'( ESCAPE '.+')?\)/
+      @q.filter({:column => "sales.product.sku", :value => "123", :op => :nsw}).dataset.opts[:where].
+        should == Sequel.~(Sequel.ilike(:sku.qualify(:product), "123%"))
     end
 
     it "can filter based on 'not starts with' with multiple values" do
-      @q.filter({:column => "sales.product.sku", :value => ["123","AB"], :op => :nsw}).dataset.sql.should =~ /WHERE \(\(`product`\.`sku` NOT LIKE '123%'( ESCAPE '.+')?\) AND \(`product`\.`sku` NOT LIKE 'AB%'( ESCAPE '.+')?\)\)/
+      @q.filter({:column => "sales.product.sku", :value => ["123","AB"], :op => :nsw}).dataset.opts[:where].
+        should == Sequel.&(Sequel.~(Sequel.ilike(:sku.qualify(:product), "123%")), Sequel.~(Sequel.ilike(:sku.qualify(:product), "AB%")))
     end
 
     it "can filter based on contains" do
-      @q.filter({:column => "sales.product.sku", :value => "123", :op => :con}).dataset.sql.should =~ /WHERE \(`product`\.`sku` LIKE '%123%'( ESCAPE '.+')?\)/
+      @q.filter({:column => "sales.product.sku", :value => "123", :op => :con}).dataset.opts[:where].
+        should == Sequel.ilike(:sku.qualify(:product), "%123%")
     end
 
     it "can filter based on not contains" do
-      @q.filter({:column => "sales.product.sku", :value => "123", :op => :ncon}).dataset.sql.should =~ /WHERE \(`product`\.`sku` NOT LIKE '%123%'( ESCAPE '.+')?\)/
+      @q.filter({:column => "sales.product.sku", :value => "123", :op => :ncon}).dataset.opts[:where].
+        should == Sequel.~(Sequel.ilike(:sku.qualify(:product), "%123%"))
     end
 
     it "can filter based on multiple contains" do
-      @q.filter({:column => "sales.product.sku", :value => ["123", "AB", "foo"], :op => :con}).dataset.sql.should =~ /WHERE \(\(`product`\.`sku` LIKE '%123%'( ESCAPE '.+')?\) OR \(`product`\.`sku` LIKE '%AB%'( ESCAPE '.+')?\) OR \(`product`\.`sku` LIKE '%foo%'( ESCAPE '.+')?\)\)/
+      @q.filter({:column => "sales.product.sku", :value => ["123", "AB", "foo"], :op => :con}).dataset.opts[:where].
+        should == Sequel.|(Sequel.ilike(:sku.qualify(:product), "%123%"), Sequel.ilike(:sku.qualify(:product), "%AB%"), Sequel.ilike(:sku.qualify(:product), "%foo%"))
     end
 
-    it "can filter based on multiple contains" do
-      @q.filter({:column => "sales.product.sku", :value => ["123", "AB", "foo"], :op => :ncon}).dataset.sql.should =~ /WHERE \(\(`product`\.`sku` NOT LIKE '%123%'( ESCAPE '.+')?\) AND \(`product`\.`sku` NOT LIKE '%AB%'( ESCAPE '.+')?\) AND \(`product`\.`sku` NOT LIKE '%foo%'( ESCAPE '.+')?\)\)/
+    it "can filter based on multiple not contains" do
+      @q.filter({:column => "sales.product.sku", :value => ["123", "AB", "foo"], :op => :ncon}).dataset.opts[:where].
+        should == Sequel.&(Sequel.~(Sequel.ilike(:sku.qualify(:product), "%123%")), Sequel.~(Sequel.ilike(:sku.qualify(:product), "%AB%")), Sequel.~(Sequel.ilike(:sku.qualify(:product), "%foo%")))
     end
 
     it "does not join the base table when filtering" do
@@ -467,13 +510,13 @@ describe Chicago::Query do
     end
 
     it "filters in the having clause when a calculated column is filtered" do
-      @q.filter({:column => {:column => "sales.total", :op => "sum"}, :value => 2, :op => :eq}).dataset.
-        sql.should =~ /HAVING \(sum\(`sales`\.`total`\) = 2\)/
+      @q.filter({:column => {:column => "sales.total", :op => "sum"}, :value => 2, :op => :eq}).dataset.opts[:having].
+        should == Sequel.expr(:sum.sql_function(:total.qualify(:sales)) => 2)
     end
 
     it "filters in the having clause when a virtual calculated column is filtered" do
-      @q.filter({:column => "sales.vat", :value => 2, :op => :gte}).dataset.
-        sql.should =~ /HAVING \(\(sum\(`total`\) \* `vat_rate`\) >= 2\)/
+      @q.filter({:column => "sales.vat", :value => 2, :op => :gte}).dataset.opts[:having].
+        should == Sequel.expr(Sequel.*(:sum.sql_function(:total),:vat_rate) >= 2)
     end
 
     describe "#columns" do

data/spec/schema/query_column_spec.rb

@@ -134,12 +134,12 @@ describe Chicago::Schema::QueryColumn do
       subject.select_name.should == :bar.qualify(:foo)
     end
 
-    it "uses the original id in COUNT" do
+    it "uses the original_id in COUNT" do
       subject.count_name.should == :original_id.qualify(:foo)
     end
 
-    it "uses the original id in GROUP BY" do
-      subject.group_name.should == :original_id.qualify(:foo)
+    it "uses the column name in GROUP BY" do
+      subject.group_name.should == :bar.qualify(:foo)
     end
 
     it "delegates label to the decorated column" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chicagowarehouse
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors:
 - Roland Swingler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2015-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.11'
 - !ruby/object:Gem::Dependency
   name: sequel_migration_builder
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement