native-query 0.9.0

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "native-query"
+  gem.homepage = "http://github.com/martinkozak/native-query"
+  gem.license = "MIT"
+  gem.summary = 'Cool way how to speak with database server. It\'s ellegant and very ruby SQL query helper which works by similar way as Arel or another ORM selecting logic. It\'s derived from Dibi database layer in its ideas, so is much more simple and (of sure) much more KISS, readable and straightforward.'
+  gem.email = "martinkozak@martinkozak.net"
+  gem.authors = ["Martin Kozák"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/lib/native-query/join.rb

@@ -0,0 +1,318 @@
+# encoding: utf-8
+require "native-query/query"
+require "hash-utils/object"   # >= 0.17.0
+require "hash-utils/array"
+require "hash-utils/string"   # >= 0.18.0
+
+module NativeQuery
+
+    ##
+    # Represents join request.
+    #
+     
+    class Join
+    
+        ##
+        # Indicates table to join from.
+        #
+        
+        @original
+    
+        ##
+        # Indicates table to join.
+        #
+        
+        @table
+        
+        ##
+        # Indicates fields for select.
+        #
+        
+        @fields
+        
+        ##
+        # Holds joins specifiaction.
+        #
+        
+        @joins
+        attr_reader :joins
+        
+        ##
+        # Holds join conditions.
+        #
+        
+        @where
+        
+        ##
+        # Indicates type of joining.
+        # Possible values are:
+        #
+        #  * :indirect for M:N relation,
+        #  * :direct for 1:N relation
+        #
+        
+        @type
+        
+        ##
+        # Contains indirect joining manual specification.
+        #
+        
+        @indirect
+        
+        ##
+        # Holds specificarion of direct joining.
+        #
+        
+        @direct
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(original, table)
+            @table = table
+            @original = original
+            @fields = [ ]
+            @where = [ ]
+            @joins = [ ]
+            @type = :direct
+            
+            @indirect_source = original
+        end
+        
+        ##
+        # Sets hash for select from joined table.
+        # Without arguments returns fields list. 
+        #
+        
+        def fields(*args)
+            if args.empty?
+                result = { }
+                @fields.each do |i|
+                    if not i.kind_of? Hash
+                        i = {i => i}
+                    end
+                    
+                    i.each_pair do |from, to|
+                        result[__fix_field(from)] = @table.to_s << "_" << to.to_s
+                    end
+                end
+                
+                return result
+            else
+                @fields += args
+                return self
+            end
+        end
+        
+        ##
+        # Selects where conditions to load.
+        #
+        
+        def where(*args)
+            @where << args
+            return self
+        end
+        
+        ##
+        # Indicates indirect joining. (M:N)
+        #
+        
+        def indirect(*args)
+            @type = :indirect
+            if args.first.array? and (args.first.first == :backward) and (args.first.second.array?)
+                @indirect = args.first
+            else
+                @indirect = args
+            end
+            
+            return self
+        end
+        
+        ##
+        # Indicates direct joining. (1:M)
+        #
+        
+        def direct(*args)
+            @type = :direct
+            if args.first.array? and (args.first.first == :backward) and (args.first.second.array?)
+                @direct = args.first
+            else
+                @direct = args
+            end
+            
+            return self
+        end
+        
+        ##
+        # Indicates backward joining.
+        #
+        
+        def backward(*args)
+            [:backward, args]
+        end
+           
+        ##
+        # Builds ON join string.
+        #
+        
+        def build
+            result = nil
+            
+            case @type
+                when :indirect
+                    result = __indirect
+                when :direct
+                    result = __direct
+            end
+            
+            return result
+        end
+        
+        ##
+        # Return wheres.
+        #
+        
+        def wheres
+            self._fix_where
+        end
+        
+        ##
+        # Calls mapping to joins specification. Call name is name of 
+        # the target table.
+        #
+        # Block works by the same way as query, but for join. But 
+        # intra-join calls doesn't work because it returns Query too.
+        #
+        
+        def method_missing(sym, *args, &block)
+            join = self.class::new(@table, sym)
+
+            if args and not args.empty?
+                join.fields(*args)
+            end
+
+            join.instance_eval(&block)
+            @joins << join
+            
+            return self
+        end
+        
+        ##
+        # Fixes field name. Joins table name if SQL table joining
+        # required.
+        #
+        
+        private
+        def __fix_field(name, formatted = false)
+            NativeQuery::Query::fix_field(name, @table, formatted)
+        end
+
+        
+        ##
+        # Fixes where specification(s) if it's hash with symbol key.
+        #
+        
+        protected
+        def _fix_where
+            NativeQuery::Query::fix_conditions(@where) do |args|
+                args.each do |i|
+                    __fix_field(i)
+                end
+            end
+        end
+        
+        ##
+        # Builds indirect join.
+        #
+        
+        private
+        def __indirect
+
+            if (@indirect.first == :backward) and (@indirect.second.array?)
+                backward = true
+                indirect = @indirect.second
+            else
+                backward = false
+                indirect = @indirect
+            end
+            
+            ##
+            
+            result = { }
+            to = @table.to_s
+            from = @original.to_s
+            arg1, arg2, arg3 = indirect
+
+            # automatic joining
+            if indirect.empty?
+                from.swap_with(to) if backward
+                through = from + "_" + to
+                joining_table = through.to_sym
+                result[joining_table] = "[" << from << ".id] = [" << through << "." << from << "_id]"
+                result[@table] = "[" << through << "." << to << "_id] = [" << to << ".id]"
+                
+            # standard specification (semiautomatic joining)
+            elsif arg1.symbol? and arg2.hash?
+                through = arg1.to_s
+                joining_table = arg1
+                result[joining_table] = "[" << from << "." << arg2.keys.first.to_s << "] = [" << through << "." << from << "_id]"
+                result[@table] = "[" << through << "." << to << "_id] = [" << to << "." << arg2.values.first.to_s << "]"
+                
+            # fluent query specification (manual joining)
+            elsif arg1.symbol? and arg2.string? and arg3.string?
+                joining_table = arg1
+                result[joining_table] = arg2
+                result[@table] = arg3
+            
+            # error
+            else
+                raise Exception::new("Symbol and Hash or Symbol and two Strings expected.")
+                
+            end
+            
+            return result
+        end
+        
+        ##
+        # Builds direct join.
+        #
+        
+        private
+        def __direct
+            
+            if (@direct.first == :backward) and (@direct.second.array?)
+                backward = true
+                direct = @direct.second
+            else
+                backward = false
+                direct = @direct
+            end
+            
+            ##
+            
+            empty = direct.empty?
+            direct = direct.first
+            from = @original.to_s
+            to = @table.to_s
+            result = { }
+            
+            # automatic joining
+            if empty
+                from.swap_with(to) if backward
+                result[@table] = "[" << from << ".id] = [" << to << "." << from << "_id]"
+            # manual joining
+            elsif direct.hash?
+                result[@table] = "[" << from << "." << direct.keys.first.to_s << "] = [" << to << "." << direct.values.first.to_s << "]"
+            # special joining
+            elsif direct.string?
+                result[@table] = direct
+            # error
+            else
+                raise Exception::new("Hash or String expected.")
+            end
+            
+            return result
+        end            
+    end
+end

data/lib/native-query/model.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+require "fluent-query/connection"
+require "native-query/query"
+
+module NativeQuery
+
+    ##
+    # Represents instance of ORM model.
+    #
+     
+    class Model
+    
+        ##
+        # Brings database connection object.
+        #
+        
+        @connection
+        
+        ##
+        # Brings driver setting.
+        #
+        
+        @driver
+        
+        ##
+        # Brings database connection configuration setting.
+        #
+        
+        @configuration
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(driver, configuration)
+            @driver = driver
+            @configuration = configuration
+        end
+        
+        ##
+        # Returns connection.
+        #
+        
+        def connection
+            if not @connection
+                @connection = FluentQuery::Connection::new(@driver, @configuration) 
+            end
+            
+            @connection    # returns
+        end
+        
+        ##
+        # Maps missing calls to tables.
+        #
+        # Arguments are expected to be field names, so given to 
+        # field query method.
+        #
+        
+        def method_missing(sym, *args, &block)
+            query = Query::new(self.connection, sym)
+            
+            if args and not args.empty?
+                query.fields(*args)
+            end
+            
+            if block
+                result = query.instance_eval(&block)
+            else
+                result = query
+            end
+
+            return result
+        end
+        
+    end
+end

data/lib/native-query/query.rb

@@ -0,0 +1,430 @@
+# encoding: utf-8
+
+require "native-query/result"
+require "native-query/join"
+require "hash-utils/object"
+require "hash-utils/array"
+require "hash-utils/hash"
+
+module NativeQuery
+    
+    ##
+    # Represents ORM query.
+    #
+     
+    class Query
+    
+        ##
+        # Brings database connection object.
+        #
+        
+        @connection
+        
+        ##
+        # Indicates upon which table query works.
+        #
+        
+        @table
+        
+        ##
+        # Holds list of fields to load.
+        #
+        
+        @fields
+        
+        ##
+        # Holds list of where conditions.
+        #
+        
+        @where
+        
+        ##
+        # Holds list of having conditions.
+        #
+        
+        @having
+                
+        ##
+        # Holds order specification.
+        #
+        
+        @order
+        
+        ##
+        # Joins for the query.
+        #
+        
+        @joins
+        
+        ##
+        # Indicates limit to load.
+        #
+        
+        @limit
+        
+        ##
+        # Indicates offset to load.
+        #
+        
+        @offset
+        
+        ##
+        # Holds group by settings.
+        #
+        
+        @group
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(connection, table, &block)
+            @connection = connection
+            @table = table
+            @fields = [ ]
+            @where = [ ]
+            @having = [ ]
+            @joins = [ ]
+            @order = [ ]
+            @group = [ ]
+        end
+        
+        ##
+        # Calls mapping to joins specification. Call name is name of 
+        # the target table.
+        #
+        # Block works by the same way as query, but for join. But 
+        # intra-join calls doesn't work because it returns Query too.
+        #
+        
+        def method_missing(sym, *args, &block)
+            join = Join::new(@table, sym)
+
+            if args and not args.empty?
+                join.fields(*args)
+            end
+            
+            if not block.nil?
+                join.instance_eval(&block)
+            end
+            
+            @joins << join
+            return self
+        end
+        
+        ##
+        # Selects fields which to load.
+        #
+        
+        def fields(*args)
+            @fields += args
+            return self
+        end
+        
+        ##
+        # Selects where conditions to load.
+        #
+        
+        def where(*args)
+            @where << args
+            return self
+        end
+
+        ##
+        # Selects having conditions to load.
+        #
+        
+        def having(*args)
+            @having << args
+            return self
+        end
+                
+        ##
+        # Selects fields for ordering according them.
+        # Default order is :asc.
+        #
+        # Expects [:<field>, [:asc|:desc]]+ arguments.
+        # 
+        
+        def order(*args)
+            @order += args
+            return self
+        end
+        
+        ##
+        # Sets limit to load.
+        #
+        
+        def limit(limit)
+            @limit = limit
+            return self
+        end
+         
+        ##
+        # Sets offset to load.
+        #
+        
+        def offset(offset)
+            @offset = offset
+            return self
+        end 
+        
+        ##
+        # Sets group by to load.
+        #
+        
+        def group(*fields)
+            @group = fields
+            return self
+        end
+
+        ##
+        # Returns result object.
+        #
+        
+        def get
+            
+            # Builds query
+            
+                # Process joins
+                join_fields, wheres, append_joins = self._process_joins
+                
+                # Checkouts regular fields
+                if @joins.empty?
+                    fields = @fields
+                    hashes = [ ]
+                    group = @group
+                else
+                    fields = @fields.map { |i| __fix_field(i) } 
+                    hashes = fields.reject { |i| not i.hash? }
+                    fields -= hashes
+                end
+                
+                
+                query = @connection.query
+                
+                if not fields.empty?
+                    query.select(fields)
+                end
+                
+                if not join_fields.empty?
+                    query.select(join_fields)
+                end
+                
+                if not hashes.empty?
+                    hashes.each do |hash|
+                        query.select(hash)
+                    end
+                end
+
+
+                query.from(@table)
+
+                # Appends joins
+                append_joins.call(query)
+                
+                # Where conditions
+                wheres += self._fix_where
+                wheres.each { |i| query.where(*i) }
+                
+                # Where conditions
+                havings = self._fix_having
+                havings.each { |i| query.having(*i) }
+                  
+                # Grouping, ordering and having settings
+                self._process_grouping(query)
+                self._process_ordering(query)
+                
+                # Limit and offset
+                if not @limit.nil?
+                    query.limit(@limit)
+                end
+                
+                if not @offset.nil?
+                    query.offset(@offset)
+                end
+
+            # Returns
+            return Result::new(query)
+            
+        end
+        
+        ##
+        # Builds itself to string.
+        #
+        
+        def build
+            self.get.query.build
+        end
+        
+        alias :"build!" :build
+        
+        ##
+        # Process joins.
+        #
+        
+        protected
+        def _process_joins
+            fields = { }
+            wheres = [ ]
+            specs = { }
+            joins = [ ]
+            
+            new_joins = @joins.dup
+            add_joins = [ ]
+            
+            # Agregates subjoins (e.g. joins from joins)
+            while not new_joins.empty?
+                new_joins.each do |join|
+                    add_joins += join.joins
+                end
+                
+                joins += new_joins
+                new_joins = add_joins
+                add_joins = [ ]
+            end
+
+            # Process joins
+            joins.each do |join|
+                fields.merge! join.fields
+                wheres += join.wheres
+                specs.merge! join.build
+            end
+            
+            callback = Proc::new do |query|
+                specs.each_pair do |join, on|
+                    query.join(join).on(on)
+                end
+            end
+            
+            return fields, wheres, callback
+        end
+        
+        ##
+        # Process ordering settngs.
+        #
+        
+        protected
+        def _process_ordering(query)
+            # Ordering settings
+            if not @order.nil?
+                @order.each do |i|
+                    case i
+                        when :asc
+                            query.asc
+                        when :desc
+                            query.desc
+                        else
+                            if i.array?
+                                query.orderBy("[" << i.first.to_s << "." << i.second.to_s << "]")
+                            else
+                                query.orderBy(__fix_field(i, true))
+                            end
+                    end
+                end
+            end
+        end
+        
+        
+        ##
+        # Process ordering settngs.
+        #
+        
+        protected
+        def _process_grouping(query)
+            # Grouping settings
+            @group.each do |i|
+                if i.array?
+                    query.groupBy("[" << i.first.to_s << "." << i.second.to_s << "]")
+                else
+                    query.groupBy(__fix_field(i, true))
+                end
+            end
+        end
+        
+        ##
+        # Fixes field name. Joins table name if SQL table joining
+        # required.
+        #
+        
+        private
+        def __fix_field(name, formatted = false)
+            if not @joins.empty?
+                result = self.class::fix_field(name, @table, formatted)
+            else
+                result = name
+            end
+            
+            return result
+        end
+        
+        ##
+        # Fixes field name. Joins table name if SQL table joining
+        # required.
+        #
+        
+        def self.fix_field(name, table, formatted = false)
+            if name.hash?
+                result = name.map_keys { |k| self.fix_field(k, table, formatted) }
+            else
+                result = table.to_s + "." + name.to_s
+            end
+            
+            if formatted
+                result = "[" << result << "]"
+            end
+            
+            return result
+        end
+        
+        ##
+        # Fixes where specification(s) if it's hash with symbol key.
+        #
+        
+        protected
+        def _fix_where
+            Query::fix_conditions(@where) do |args|
+                args.each do |i|
+                    __fix_field(i)
+                end
+            end
+        end
+
+        ##
+        # Fixes having specification(s) if it's hash with symbol key.
+        #
+        
+        protected
+        def _fix_having
+            Query::fix_conditions(@having) do |args|
+                args.each do |i|
+                    __fix_field(i)
+                end
+            end
+        end
+        
+        ##
+        # Fixes where specification(s) if it's hash with symbol key.
+        # Block is fixer.
+        #
+        
+        def self.fix_conditions(where, &block)
+            where.map do |specification|
+                if specification.hash?
+                    new = specification.map_keys do |k|
+                        if k.symbol?
+                            block.call(k)
+                        else
+                            k
+                        end
+                    end
+                else
+                    new = specification
+                end
+                
+                new  # returns
+            end
+        end
+        
+      end
+end