fluent-query-sql 0.9.0

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

@@ -0,0 +1,147 @@
+# 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 SELECT token.
+                     #
+                     
+                     class Select < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = :build)
+                            stack = [ ]
+                            unknown = [ ]
+                            fields = [ ]
+                            aliases = { }
+                            distinct = false
+                            
+                            result = "SELECT "
+                            processor = @_query.processor
+                            
+                            _class = self.unknown_token
+
+                            # Process subtokens
+                            
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+                                name = token.name
+
+                                # Known select process
+                                if (name == :select) or (name == :distinct)
+                                    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
+                                                elsif argument.hash?
+                                                    aliases.merge! 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
+
+                                distinct = (name == :distinct)
+                            end
+
+                            # Closes opened native token with unknown tokens
+                            if unknown.length > 0
+                                native = _class::new(@_driver, @_query, unknown)
+                                stack << native.render!
+                                unknown = [ ]
+                            end
+
+                            # process distinct
+                            if distinct
+                                result << "DISTINCT "
+                            end
+
+                            # Process stack with results
+                            
+                            first = true
+                                                        
+                            if not fields.empty?
+                                stack.unshift(fields.uniq)
+                            end
+                            
+                            if not aliases.empty?
+                                stack.unshift(aliases)
+                            end
+
+                            stack.each do |item|
+                                
+                                if item.array?
+                                    if not first
+                                        result << ", "
+                                    end
+                                    
+                                    result << processor.process_identifiers(item) 
+                                    first = false
+                                    
+                                elsif item.hash?
+                                    fields = [ ]
+                                    
+                                    item.each_pair do |key, value|
+                                        key = @_driver.quote_identifier(key)
+                                        value = @_driver.quote_identifier(value)
+                                        
+                                        fields << (key.to_s + " AS " + value.to_s)
+                                    end
+
+                                    if not first
+                                        result << ", "
+                                    end
+                                    
+                                    result << fields.join(", ")
+                                    first = false
+                                    
+                                elsif item.string?
+                                    if not first
+                                        result << ", "
+                                    end
+        
+                                    result << item
+                                    first = false
+                                    
+                                end
+                            end
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

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

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "fluent-query/drivers/exception"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+            
+                     ##
+                     # Generic SQL query SET token.
+                     #
+                     
+                     class Set < 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 = "SET "
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # SET token
+                                
+                                if token.name == :set
+                                    length = arguments.length
+
+                                    # Checks for arguments
+                                    if length > 0
+                                        if (length > 1) or (arguments.first.string?)
+                                            stack << processor.process_formatted(arguments, mode)
+                                        elsif arguments.first.hash?
+                                            stack << processor.process_hash(arguments.first, ", ", :assigning)
+                                        end
+                                    else
+                                        raise FluentQuery::Drivers::Exception::new("SET token expects Hash or formatted string as argument.")
+                                    end
+
+                                # Unknown tokens renders directly
+                                else
+                                    result << _class::new(@_driver, @_query, [token]).render!
+                                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/truncate.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "fluent-query/drivers/exception"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                                   
+                     ##
+                     # Generic SQL query TRUNCATE token.
+                     #
+                     
+                     class Truncate < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = nil)
+                            processor = @_query.processor
+                            result = "TRUNCATE TABLE "
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # FROM token
+                                
+                                if token.name == :truncate
+
+                                    # Checks for arguments
+                                    if (not arguments.first.symbol?)
+                                        raise FluentQuery::Drivers::Exception::new("Symbol argument expected for #truncate method.")
+                                    end
+
+                                    # Process
+                                    table = processor.quote_identifier(arguments.first)
+                                    result << table
+
+                                # Unknown tokens renders directly
+                                else
+                                    result << self.unknown_token::new(@_driver, @_query, [token]).render!
+                                end
+                                
+                            end
+
+                            result << " CASCADE"
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require "fluent-query/query"
+require "fluent-query/drivers/shared/tokens/sql"
+require "fluent-query/drivers/exception"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                
+                     ##
+                     # Generic SQL query UNION token.
+                     #
+                     
+                     class Union < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = nil)
+                            result = ""
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # SET token
+                                
+                                if token.name == :union
+                                    length = arguments.length
+
+                                    # Checks for arguments
+                                    if length >= 2
+                                        queries = [ ]
+
+                                        arguments.each do |argument|
+                                            if argument.string?
+                                                queries << argument
+                                            elsif argument.kind_of? FluentQuery::Query
+                                                queries << argument.build!
+                                            end
+                                        end
+                                        
+                                    else
+                                        raise FluentQuery::Drivers::Exception::new("UNION token expects at least two queries or strings as arguments.")
+                                    end
+                                end            
+                            end
+
+                            # Process stack with results
+                            queries.map! { |i| @_driver.quote_subquery(i) }
+                            result << queries.join(" UNION ")
+
+                            return result
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require "fluent-query/drivers/shared/tokens/sql"
+require "fluent-query/drivers/exception"
+require "hash-utils/object"   # >= 0.17.0
+
+module FluentQuery
+    module Drivers
+        module Shared
+            module Tokens
+                module SQL
+                
+                     ##
+                     # Generic SQL query UPDATE token.
+                     #
+                     
+                     class Update < FluentQuery::Drivers::Shared::Tokens::SQLToken
+
+                        ##
+                        # Renders this token.
+                        #
+
+                        public
+                        def render!(mode = nil)
+                        
+                            processor = @_query.processor
+                            result = "UPDATE "
+                        
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+
+                                # UPDATE token
+                                if token.name == :update
+
+                                    # Checks for arguments
+                                    if (not arguments.first.symbol?)
+                                        raise FluentQuery::Drivers::Exception::("Symbol arguments expected for #update method.")
+                                    end
+
+                                    # Process
+                                    table = processor.quote_identifier(arguments.first)
+                                    result << table
+
+                                # 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/where.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 WHERE token.
+                     #
+                     
+                     class Where < 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 = "WHERE "
+
+                            # Process subtokens
+                            
+                            @_subtokens.each do |token|
+                                arguments = token.arguments
+ 
+                                # Known process
+                                if token.name == :where
+                                    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