fluent-query-sql 0.9.0

data/lib/fluent-query/drivers/shared/tokens/sql/groupby.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                                    
+                     ##
+                     # Generic SQL query GROUP BY token.
+                     #
+                     
+                     class GroupBy < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = :build)
+                            stack = [ ]
+                            unknown = [ ]
+                            fields = [ ]
+                            aliases = { }
+                            distinct = false
+                            
+                            result = "GROUP BY "
+                            processor = @_query.processor
+                            
+                            _class = self.unknown_token
+
+                            # Process subtokens
+                            
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+                                name = token.name
+
+                                # Known select process
+                                if name == :groupBy
+                                    length = arguments.length
+                                    
+                                    if length > 0
+                                        first = arguments.first
+                                        
+                                        if first.symbol?
+                                            stack << arguments
+                                        elsif first.string?
+                                            stack << processor.process_formatted(arguments, mode)
+                                        else
+                                            arguments.each do |argument|
+                                                if argument.array?
+                                                    fields += argument
+                                                end                        
+                                            end
+                                        end
+                                    end
+
+                                    # Closes opened native token with unknown tokens
+                                    if unknown.length > 0
+                                        native = _class::new(@_driver, @_query, unknown)
+                                        stack << native.render!
+                                        unknown = [ ]
+                                    end
+
+                                # Unknowns arguments pushes to the general native token
+                                else
+                                    unknown << token
+                                end
+                            end
+
+                            # Closes opened native token with unknown tokens
+                            if unknown.length > 0
+                                native = _class::new(@_driver, @_query, unknown)
+                                stack << native.render!
+                                unknown = [ ]
+                            end
+
+                            # Process stack with results
+                            
+                            first = true
+                                                        
+                            if not fields.empty?
+                                stack.unshift(fields.uniq)
+                            end
+                            
+                            stack.each do |item|
+                                
+                                if item.array?
+                                    if not first
+                                        result << ", "
+                                    end
+                                    
+                                    result << processor.process_identifiers(item) 
+                                    first = false
+                                    
+                                elsif item.string?                            
+                                    if not first
+                                        result << ", "
+                                    end
+        
+                                    result << item.strip!
+                                    first = false
+                                    
+                                end
+                            end
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/fluent-query/drivers/shared/tokens/sql/having.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                                    
+                     ##
+                     # Generic SQL query HAVING token.
+                     #
+                     
+                     class Having < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = :build)
+                            _class = self.unknown_token
+                            
+                            stack = [ ]
+                            unknown = [ ]
+                            
+                            operator = @_driver.quote_operator(:and)
+                            processor = @_query.processor
+
+                            result = "HAVING "
+
+                            # Process subtokens
+                            
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+ 
+                                # Known process
+                                if token.name == :having
+                                    length = arguments.length
+                                    first = arguments.first
+                                    
+                                    if length > 0
+                                        if (length > 1) or (first.string?)
+                                            stack << processor.process_formatted(arguments, mode)
+                                        elsif first.array?
+                                            stack << first.join(operator)
+                                        elsif first.hash?
+                                            stack << processor.process_hash(first, operator)
+                                        end
+                                    end
+
+                                    # Closes opened native token with unknown tokens
+                                    if unknown.length > 0
+                                        native = _class::new(@_driver, @_query, unknown)
+                                        stack << native
+                                        unknown = [ ]
+                                    end
+
+                                # Unknowns arguments pushes to the general native token
+                                else
+                                    unknown << token
+                                end
+                                
+                            end
+
+                            # Closes opened native token with unknown tokens
+                            if unknown.length > 0
+                                native = _class::new(@_driver, @_query, unknown)
+                                stack << native
+                                unknown = [ ]
+                            end
+
+                            # Process stack with results
+                            first = true
+                            
+                            stack.each do |item|
+                                if item.kind_of? _class
+                                    result << item.render!
+                                elsif item.string?
+                                    if not first
+                                        result << operator << " "
+                                    else
+                                        first = false
+                                    end
+                                    
+                                    result << item
+                                end
+
+                                result << " "
+                            end
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/fluent-query/drivers/shared/tokens/sql/insert.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "fluent-query/drivers/exception"
+require "hash-utils/object"   # >= 0.17.0
+require "hash-utils/array"
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                
+                     ##
+                     # Generic SQL query INSERT token.
+                     #
+ 
+                     class Insert < FluentQuery::Drivers::Shared::Tokens::SQLToken
+                     
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = nil)
+                            processor = @_query.processor
+                            result = "INSERT INTO "
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # INSERT token
+                                if token.name == :insert
+
+                                    # Checks for arguments
+                                    if (not arguments.first.symbol?) or (not arguments.second.hash?)
+                                       raise FluentQuery::Drivers::Exception::new("Symbol and Hash arguments expected for #insert method.")
+                                    end
+
+                                    # Process
+                                    table = processor.quote_identifier(arguments.first)
+                                    fields = processor.process_identifiers(arguments.second.keys)
+                                    values = processor.process_array(arguments.second.values)
+                                    
+                                    result << table << " (" << fields << ") VALUES (" << values << ")"
+
+                                # Unknown tokens renders directly
+                                else
+                                    result = self.unknown_token::new(@_driver, @_query, token).render!
+                                end
+                            end
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/fluent-query/drivers/shared/tokens/sql/join.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                                    
+                     ##
+                     # Generic SQL query [LEFT|RIGHT|INNER|OUTER] JOIN token.
+                     #
+                     
+                     class Join < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = :build)
+                            stack = [ ]
+                            unknown = [ ]
+
+                            _class = self.unknown_token
+                            processor = @_query.processor
+                            result = ""
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # JOIN token
+                                if token.name == :join
+                                
+                                    original_name = token.original_name
+                                    stack << self._transform_token(original_name.to_s)
+                            
+                                    ##
+                                    
+                                    length = arguments.length
+                                    first = arguments.first
+                                    
+                                    if length > 0
+                                        if first.symbol?
+                                            stack << processor.process_identifiers(arguments)
+                                        elsif (length > 1) or (first.string?)
+                                            stack << processor.process_formatted(arguments, mode)
+                                        elsif first.hash?
+                                            t_name = first.keys.first
+                                            t_alias = first.values.first
+                                            stack << (processor.quote_identifier(t_name) + " AS " + processor.quote_identifier(t_alias))
+                                        end
+                                    end
+
+                                    # Closes opened native token with unknown tokens
+                                    if unknown.length > 0
+                                        native = _class::new(@_driver, @_query, unknown)
+                                        stack << native
+                                        unknown = [ ]
+                                    end
+
+                                # Unknown arguments pushes to the general native token
+                                else
+                                    unknown << token
+                                end
+                                
+                            end
+
+                            # Closes opened native token with unknown tokens
+                            if unknown.length > 0
+                                native = _class::new(@_driver, @_query, unknown)
+                                stack << native
+                                unknown = [ ]
+                            end
+
+                            # Process stack with results
+                            first = true
+                            
+                            stack.each do |item|
+                                if item.kind_of? _class
+                                    result << item.render!
+                                elsif item.string?               
+                                    result << item
+                                end
+
+                                result << " "
+                            end
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/fluent-query/drivers/shared/tokens/sql/orderby.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                
+                     ##
+                     # Generic SQL query ORDER BY token.
+                     #
+                     
+                     class OrderBy < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = :build)
+                            
+                            stack = [ ]
+                            custom = [ ]
+                            unknown = [ ]
+                            fields = [ ]
+                            distinct = false
+                            
+                            result = "ORDER BY "
+                            processor = @_query.processor
+                            _class = self.unknown_token
+
+
+                            # Process subtokens
+                            
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+                                name = token.name
+
+                                # Known select process
+                                if name == :orderBy
+                                    length = arguments.length
+                                    close_custom = false
+                                    
+                                    if length > 0
+                                        if (length > 1) or (arguments.first.string?)
+                                            value = processor.process_formatted(arguments, mode).dup
+                                            custom.push(value)
+
+                                            # Closes fields if they are set
+                                            if not fields.empty?
+                                                stack << (processor.process_identifiers(fields) << ", ")
+                                                fields = [ ]
+                                            end
+                                            
+                                        elsif arguments.first.array?
+                                            fields += arguments.first
+                                            close_custom = true
+                                            
+                                        elsif arguments.first.symbol?
+                                            fields += arguments
+                                            close_custom = true
+
+                                        end
+                                        
+                                        # Closes custom formulations if they are set
+                                        #  and it's required.
+                                        if close_custom and not custom.empty?
+                                            stack << (self._close_custom(custom) << ", ")
+                                            custom = [ ]
+                                        end
+                                    end
+
+                                    # Closes opened native token with unknown tokens
+                                    if unknown.length > 0
+                                        native = _class::new(@_driver, @_query, unknown)
+                                        stack << (native.render! + ", ")
+                                        unknown = [ ]
+                                    end
+
+                                # Unknowns arguments pushes to the general native token
+                                else
+                                    unknown << token
+
+                                    if not fields.empty?
+                                        stack << processor.process_identifiers(fields)
+                                        fields = [ ]
+                                    elsif not custom.empty?
+                                        stack << self._close_custom(custom)
+                                        custom = [ ]
+                                    end
+                                end
+                            end
+
+                            # Closes
+
+                                # Opened native token with unknown tokens
+                                if unknown.length > 0
+                                    native = _class::new(@_driver, @_query, unknown)
+                                    value = native.render!
+                                    unknown = [ ]
+
+                                    if (not fields.empty?) or (not custom.empty?)
+                                        value << ", "
+                                    end
+                                    
+                                    stack << value
+                                end
+
+                                # Fields list
+                                if not fields.empty?
+                                    value = processor.process_identifiers(fields)
+
+                                    if not custom.empty?
+                                        value << ", "
+                                    end
+
+                                    stack << value
+                                end
+
+                                # Custom list
+                                if not custom.empty?
+                                    stack << self._close_custom(custom)
+                                end
+
+                            # Process stack with results
+                            result << stack.join(" ")
+
+                            return result
+
+                        end
+
+                        ##
+                        # Closes array of custom (formatted) strings.
+                        #
+
+                        protected
+                        def _close_custom(custom)
+                            custom.join(", ")
+                        end
+                     end
+                 end
+             end
+         end
+     end
+ end
+