colincasey-sequel 2.10.1 → 2.10.2

data/spec/sequel_core/dataset_spec.rb

@@ -703,6 +703,10 @@ context "Dataset#literal" do
     @dataset.literal("a\\'bc").should == "'a\\\\''bc'"
   end
   
+  specify "should escape blobs as strings by default" do
+    @dataset.literal('abc'.to_sequel_blob).should == "'abc'"
+  end
+
   specify "should literalize numbers properly" do
     @dataset.literal(1).should == "1"
     @dataset.literal(1.5).should == "1.5"
@@ -734,13 +738,19 @@ context "Dataset#literal" do
   
   specify "should literalize Time properly" do
     t = Time.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
+    @dataset.literal(t).should == s
+  end
+  
+  specify "should literalize DateTime properly" do
+    t = DateTime.now
+    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
     @dataset.literal(t).should == s
   end
   
   specify "should literalize Date properly" do
     d = Date.today
-    s = d.strftime("DATE '%Y-%m-%d'")
+    s = d.strftime("'%Y-%m-%d'")
     @dataset.literal(d).should == s
   end
   
@@ -998,6 +1008,21 @@ context "Dataset#unordered" do
   end
 end
 
+context "Dataset#with_sql" do
+  setup do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+  
+  specify "should remove use static sql" do
+    @dataset.with_sql('SELECT 1 FROM test').sql.should == 'SELECT 1 FROM test'
+  end
+  
+  specify "should keep row_proc and transform" do
+    @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
+    @dataset.with_sql('SELECT 1 FROM test').instance_variable_get(:@transform).should == @dataset.instance_variable_get(:@transform)
+  end
+end
+
 context "Dataset#order_by" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -3450,32 +3475,3 @@ context "Sequel::Dataset#each" do
     end
   end
 end
-
-context Sequel::Dataset::UnsupportedIntersectExcept do
-  before do
-    @ds = Sequel::Dataset.new(nil).from(:items)
-    @ds2 = Sequel::Dataset.new(nil).from(:i)
-    @ds.extend(Sequel::Dataset::UnsupportedIntersectExcept)
-  end
-
-  specify "should raise an error if INTERSECT or EXCEPT is USED" do
-    @ds.union(@ds2).sql.should == 'SELECT * FROM items UNION SELECT * FROM i'
-    proc{@ds.intersect(@ds2)}.should raise_error(Sequel::Error)
-    proc{@ds.except(@ds2)}.should raise_error(Sequel::Error)
-  end
-end
-
-context Sequel::Dataset::UnsupportedIntersectExceptAll do
-  before do
-    @ds = Sequel::Dataset.new(nil).from(:items)
-    @ds2 = Sequel::Dataset.new(nil).from(:i)
-    @ds.extend(Sequel::Dataset::UnsupportedIntersectExceptAll)
-  end
-
-  specify "should raise an error if INTERSECT or EXCEPT is USED" do
-    @ds.intersect(@ds2).sql.should == 'SELECT * FROM items INTERSECT SELECT * FROM i'
-    @ds.except(@ds2).sql.should == 'SELECT * FROM items EXCEPT SELECT * FROM i'
-    proc{@ds.intersect(@ds2, true)}.should raise_error(Sequel::Error)
-    proc{@ds.except(@ds2, true)}.should raise_error(Sequel::Error)
-  end
-end

data/spec/sequel_model/base_spec.rb

@@ -417,3 +417,69 @@ describe Sequel::Model, ".strict_param_setting" do
     proc{@c.new(:z=>1)}.should_not raise_error
   end
 end
+
+describe Sequel::Model, ".[] optimization" do
+  setup do
+    @c = Class.new(Sequel::Model(:a))
+    @c.instance_eval do
+      def simple_table
+        @simple_table
+      end
+    end
+  end
+
+  it "should set simple_pk to the literalized primary key column name if a single primary key" do
+    @c.simple_pk.should == 'id'
+    @c.set_primary_key :b
+    @c.simple_pk.should == 'b'
+    @c.set_primary_key :b__a.identifier
+    @c.simple_pk.should == 'b__a'
+  end
+
+  it "should have simple_pk be blank if compound or no primary key" do
+    @c.no_primary_key
+    @c.simple_pk.should == nil
+    @c.set_primary_key :b, :a
+    @c.simple_pk.should == nil
+  end
+
+  it "should have simple table set if passed a Symbol to set_dataset" do
+    @c.set_dataset :a
+    @c.simple_table.should == 'a'
+    @c.set_dataset :b
+    @c.simple_table.should == 'b'
+    @c.set_dataset :b__a
+    @c.simple_table.should == 'b.a'
+  end
+
+  it "should have simple_table = nil if passed a dataset to set_dataset" do
+    @c.set_dataset @c.db[:a]
+    @c.simple_table.should == nil
+  end
+
+  it "should have simple_table superclasses setting if inheriting" do
+    @c.set_dataset :a
+    Class.new(@c).simple_table.should == 'a'
+    @c.instance_variable_set(:@simple_table, nil)
+    Class.new(@c).simple_table.should == nil
+    @c.instance_variable_set(:@simple_table, "'b'")
+    Class.new(@c).simple_table.should == "'b'"
+  end
+
+  it "should have simple_table = nil if inheriting and sti_key is set" do
+    @c.set_sti_key :x
+    Class.new(@c).simple_table.should == nil
+  end
+
+  it "should use Dataset#with_sql if simple_table and simple_pk are true" do
+    @c.set_dataset :a
+    @c.dataset.should_receive(:with_sql).and_return(@c.dataset)
+    @c[1]
+  end
+
+  it "should not use Dataset#with_sql if either simple_table or simple_pk is nil" do
+    @c.set_dataset @c.dataset
+    @c.dataset.should_not_receive(:with_sql)
+    @c[1]
+  end
+end

data/spec/sequel_model/spec_helper.rb

@@ -73,6 +73,9 @@ class << Sequel::Model
     @db_schema = {}
     cols.each{|c| @db_schema[c] = {}}
   end
+  def simple_table
+    nil
+  end
 end
 
 Sequel::Model.db = MODEL_DB = MockDatabase.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: colincasey-sequel
 version: !ruby/object:Gem::Version 
-  version: 2.10.1
+  version: 2.10.2
 platform: ruby
 authors: 
 - Jeremy Evans

data/lib/sequel_core/dataset/stored_procedures.rb

@@ -1,75 +0,0 @@
-module Sequel 
-  class Dataset
-    module StoredProcedureMethods
-      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
-      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
-      
-      # The name of the stored procedure to call
-      attr_accessor :sproc_name
-      
-      # Call the prepared statement
-      def call(*args, &block)
-        @sproc_args = args
-        case @sproc_type
-        when :select, :all
-          all(&block)
-        when :first
-          first
-        when :insert
-          insert
-        when :update
-          update
-        when :delete
-          delete
-        end
-      end
-      
-      # Programmer friendly string showing this is a stored procedure,
-      # showing the name of the procedure.
-      def inspect
-        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
-      end
-      
-      # Set the type of the sproc and override the corresponding _sql
-      # method to return the empty string (since the result will be
-      # ignored anyway).
-      def sproc_type=(type)
-        @sproc_type = type
-        meta_def("#{sql_query_type}_sql"){|*a| ''}
-      end
-      
-      private
-      
-      # The type of query (:select, :insert, :delete, :update).
-      def sql_query_type
-        SQL_QUERY_TYPE[@sproc_type]
-      end
-    end
-  
-    module StoredProcedures
-      # For the given type (:select, :first, :insert, :update, or :delete),
-      # run the database stored procedure with the given name with the given
-      # arguments.
-      def call_sproc(type, name, *args)
-        prepare_sproc(type, name).call(*args)
-      end
-      
-      # Transform this dataset into a stored procedure that you can call
-      # multiple times with new arguments.
-      def prepare_sproc(type, name)
-        sp = clone
-        prepare_extend_sproc(sp)
-        sp.sproc_type = type
-        sp.sproc_name = name
-        sp
-      end
-      
-      private
-      
-      # Extend the dataset with the stored procedure methods.
-      def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
-      end
-    end
-  end
-end

data/lib/sequel_core/dataset/unsupported.rb

@@ -1,43 +0,0 @@
-class Sequel::Dataset
-  # This module should be included in the dataset class for all databases that
-  # don't support INTERSECT or EXCEPT.
-  module UnsupportedIntersectExcept
-    # Raise an Error if EXCEPT is used
-    def except(ds, all=false)
-      raise(Sequel::Error, "EXCEPT not supported")
-    end
-
-    # Raise an Error if INTERSECT is used
-    def intersect(ds, all=false)
-      raise(Sequel::Error, "INTERSECT not supported")
-    end
-    
-    private
-    
-    # Since EXCEPT and INTERSECT are not supported, and order shouldn't matter
-    # when UNION is used, don't worry about parantheses.  This may potentially
-    # give incorrect results if UNION ALL is used.
-    def select_compounds_sql(sql, opts)
-      return unless opts[:compounds]
-      opts[:compounds].each do |type, dataset, all|
-        sql << " #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)}"
-      end
-    end
-  end
-
-  # This module should be included in the dataset class for all databases that
-  # don't support INTERSECT ALL or EXCEPT ALL.
-  module UnsupportedIntersectExceptAll
-    # Raise an Error if EXCEPT is used
-    def except(ds, all=false)
-      raise(Sequel::Error, "EXCEPT ALL not supported") if all
-      super(ds)
-    end
-
-    # Raise an Error if INTERSECT is used
-    def intersect(ds, all=false)
-      raise(Sequel::Error, "INTERSECT ALL not supported") if all
-      super(ds)
-    end
-  end
-end