rusql 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a381919b48060b9765e153ac4ccad6cd4c76489f
-  data.tar.gz: b9d6180ad19a5d30796b84211f89514e3336bc48
+  metadata.gz: 3adb1f9c5efd4c5bcd9b68068b29cd72feb2ab20
+  data.tar.gz: 9bffc7fe874eeaeae32f01a64d626d1ff112268c
 SHA512:
-  metadata.gz: e60d9ca5b6a00ed5db2fe942e10d61924a48f7b308869a766f15c1db9179c0adc199de170d9ac422de430076bada47f1fde991dd4879e5c48f87780754ab9de1
-  data.tar.gz: 27d0646cc1ec66b7e43126e86343211753d0090acd99d1d0567a6521a301fef1fc8b2f84f6926c038690aa0a6ac3ceac546b85090cf06429686673c969f4451a
+  metadata.gz: 41d27ede4646bb3635e26a27d41de33a70170477325eea98094ed222de8b9ef176de857514c73276e00bcb32d56f699259641b084a6da7c23ad980e58a935d67
+  data.tar.gz: e7f6cf7008ad2a8aaf4c3226ef4dcdca1b9a8abf9403633a2a478a4ce4d2458bc17b16b80b1746a67e1a1d7dc4fcde6bc86af3e805f1780871ea056d53ca5505

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/README.md

@@ -1,9 +1,5 @@
 # Rusql
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rusql`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -22,13 +18,34 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## Development
+Sample code:
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 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).
+```ruby
+class User < ActiveRecord::Base
+    extend Rusql
+
+    def self.fetch(id:)
+        users = table(:users)
+        groups = table(:groups)
+        group_users = table(:group_users)
+        
+        query = select( 
+                    users[:*],
+                    group_concat( groups[:name] ).as(:group_names)
+                ).
+                from( users ).
+                left_outer_join( group_users,   group_users[:user_id].equals( user[:id] ) ).
+                left_outer_join( groups,        groups[:identifier].equals( group_users[:group_id] ) ).
+                where(
+                    users[:id].equals(id).
+                    and( groups[:created_at].greater_than( 7.days.ago ) )
+                ).
+                limit(1)
+                
+        User.find_by_sql( query.to_s ).first
+    end
+end
+```
 
 ## Contributing
 

data/lib/rusql/query.rb

@@ -1,12 +1,5 @@
 module Rusql
   class Query
-    attr_reader :selectors
-    attr_reader :joins
-    attr_reader :from_table
-    attr_reader :condition
-    attr_reader :orders
-    attr_reader :limit
-
     def initialize(selectors)
       selectors.each do |selector|
         raise TypeException.new(Selector, selector.class) unless selector.is_a?(Selector)
@@ -17,62 +10,75 @@ module Rusql
       @orders = []
     end
 
+    def duplicate
+      new_one = Query.new(self.instance_variable_get(:@selectors))
+      new_one.instance_variable_set( :@condition,  self.instance_variable_get(:@condition)  )
+      new_one.instance_variable_set( :@from_table, self.instance_variable_get(:@from_table) )
+      new_one.instance_variable_set( :@joins,      self.instance_variable_get(:@joins)      )
+      new_one.instance_variable_set( :@limit,      self.instance_variable_get(:@limit)      )
+      new_one.instance_variable_set( :@orders,     self.instance_variable_get(:@orders)     )
+
+      new_one
+    end
+
     def select(*selectors)
       selectors.each do |selector|
         raise TypeException.new(Selector, selector.class) unless selector.is_a?(Selector)
       end
 
-      @selectors = selectors
+      new_one = self.duplicate
+      new_one.instance_variable_set(:@selectors, selectors)
 
-      self
+      new_one
     end
 
     def limit(c)
-      raise TypeException unless c.is_a?(Fixnum)
+      raise TypeException.new(Fixnum, c.class) unless c.is_a?(Fixnum)
 
-      @limit = c
+      new_one = self.duplicate
+      new_one.instance_variable_set(:@limit, c)
 
-      self
+      new_one
     end
 
     def from(t)
-      raise TypeException unless t.is_a?(Table)
+      raise TypeException.new(Table, t.class) unless t.is_a?(Table)
 
-      @from_table = t
+      new_one = self.duplicate
+      new_one.instance_variable_set(:@from_table, t)
 
-      self
+      new_one
     end
 
-    def inner_join(table,condition)
-      self.joins << Join.new(:inner_join, table, condition)
-
-      self
-    end
-
-    def outer_join(table,condition)
-      self.joins << Join.new(:outer_join, table, condition)
-
-      self
-    end
+    def join(join)
+      raise TypeException.new(Join, join.class) unless join.is_a?(Join)
 
-    def left_outer_join(table,condition)
-      self.joins << Join.new(:left_outer_join, table, condition)
+      new_one = self.duplicate
+      joins = new_one.instance_variable_get(:@joins)
+      joins << join
+      new_one.instance_variable_set(:@joins, joins)
 
-      self
+      new_one
     end
 
-    def right_outer_join(table,condition)
-      self.joins << Join.new(:right_outer_join, table, condition)
+    %i(inner_join outer_join left_outer_join right_outer_join).each do |jm|
+      define_method jm, Proc.new { |table, condition|
+        new_one = self.duplicate
+        joins = new_one.instance_variable_get(:@joins)
+        joins << Join.new(jm, table, condition)
+        new_one.instance_variable_set(:@joins, joins)
 
-      self
+        new_one
+      }
     end
 
     def where(condition)
       raise TypeException.new(Condition, condition.class) unless condition.is_a?(Condition)
 
-      @condition = condition
+      new_one = self.duplicate
+      new_one.instance_variable_set(:@condition, condition)
 
-      self
+      new_one
     end
 
     def order_by(*orders)
@@ -80,28 +86,29 @@ module Rusql
         raise TypeException.new(Order, o.class) unless o.is_a?(Order)
       end
 
-      @orders = orders
+      new_one = self.duplicate
+      new_one.instance_variable_set(:@orders, orders)
 
-      self
+      new_one
     end
 
     def to_s
-      join_part = self.joins.map{ |j| "\n#{j.to_s}" }.join
+      join_part = @joins.map{ |j| "\n#{j.to_s}" }.join
       where_part = "\nWHERE"
-      order_part = "\nORDER BY #{ self.orders.map(&:to_s).join(", ") }"
+      order_part = "\nORDER BY #{ @orders.map(&:to_s).join(", ") }"
 
-      if self.condition.is_a?(BasicCondition)
+      if @condition.is_a?(BasicCondition)
         where_part += " "
-        where_part += self.condition.to_s
-      elsif self.condition.is_a?(ComplexCondition)
+        where_part += @condition.to_s
+      elsif @condition.is_a?(ComplexCondition)
         where_part += "\n  "
-        where_part += self.condition.to_s
+        where_part += @condition.to_s
       end
 
       <<-EOS
 SELECT
-#{ self.selectors.map{ |s| "  #{s.to_s}" }.join(",\n") }
-FROM #{ self.from_table.to_s_for_aliasing }#{ (self.joins.length > 0) ? join_part : ""  }#{ self.condition.nil? ? "" : where_part }#{ self.orders.length > 0 ? order_part : "" }
+#{ @selectors.map{ |s| "  #{s.to_s}" }.join(",\n") }
+FROM #{ @from_table.to_s_for_aliasing }#{ (@joins.length > 0) ? join_part : ""  }#{ @condition.nil? ? "" : where_part }#{ @orders.length > 0 ? order_part : "" }
       EOS
     end
   end

data/lib/rusql/version.rb

@@ -1,3 +1,3 @@
 module Rusql
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rusql
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ajith Hussain