fluent-query 0.9.0

data/lib/fluent-query/drivers/exception.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require "fluent-query/exception"
+
+module FluentQuery
+    module Drivers      
+         ##
+         # Represents general fluent exception.
+         #
+         
+         class Exception < FluentQuery::Exception
+         end
+     end
+ end

data/lib/fluent-query/drivers/result.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require "abstract"
+
+module FluentQuery
+    module Drivers
+    
+         ##
+         # Represents general driver result accessor.
+         #
+         
+         class Result
+             
+            ##
+            # Initializes result.
+            # 
+
+            public
+            def initialize
+                if self.instance_of? FluentQuery::Drivers::Result
+                    not_implemented
+                end
+            end
+
+            ##
+            # Returns all selected rows.
+            #
+
+            public
+            def all
+                not_implemented
+            end
+
+            ##
+            # Returns one row.
+            #
+
+            public
+            def one
+                not_implemented
+            end
+            
+            ##
+            # Returns first value of first row.
+            #
+
+            public
+            def single
+                not_implemented
+            end
+
+            ##
+            # Returns row as hash.
+            #
+
+            public
+            def hash
+                not_implemented
+            end
+
+            ##
+            # Handles iterating.
+            #
+
+            public
+            def each
+                not_implemented
+            end
+
+
+            ##
+            # Repeats the query leaded to the result.
+            #
+
+            public
+            def repeat!
+                not_implemented
+            end
+
+            ##
+            # Returns rows count.
+            #
+
+            public
+            def count
+                not_implemented
+            end
+
+            ##
+            # Frees result resources.
+            #
+
+            public
+            def free!
+                not_implemented
+            end
+         end             
+    end
+end

data/lib/fluent-query/exception.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module FluentQuery
+
+     ##
+     # Represents general fluent exception.
+     #
+     
+     class Exception < ::Exception
+     end
+     
+end

data/lib/fluent-query/queries/abstract.rb

@@ -0,0 +1,169 @@
+# encoding: utf-8
+require "fluent-query/queries/processor"
+require "abstract"
+
+module FluentQuery
+    module Queries
+    
+         ##
+         # Represents and abstract query.
+         #
+         
+         class Abstract
+         
+            ##
+            # Holds connection object.
+            #
+            
+            @connection
+            attr_reader :connection
+            
+            ##
+            # Holds appropriate query processor.
+            #
+            
+            @processor
+            
+            ##
+            # Constructor.
+            #
+
+            public
+            def initialize(connection)
+                @connection = connection
+            end
+            
+            ##
+            # Returns processor.
+            #
+
+            public
+            def processor
+                if not @processor
+                    driver = @connection.driver
+                    @processor = FluentQuery::Queries::Processor::new(driver)
+                end
+                
+                return @processor
+            end
+
+            ##
+            # Builds prepared query string to final form.
+            #
+            
+            public
+            def build(*args)
+                not_implemented
+            end
+            
+            alias :"build!" :build
+            
+            ##
+            # Executes query and returns result object.
+            #
+
+            public
+            def execute(*args)
+                @connection.execute(self.build(*args))
+            end
+            
+            alias :"execute!" :execute                
+            
+            ##
+            # Executes query and returns count of changed/inserted rows.
+            #
+            
+            public
+            def do(*args)
+                @connection.do(self.build(*args))
+            end
+            
+            alias :"do!" :do
+
+
+            ##
+            # Returns all selected rows.
+            #
+
+            public
+            def all(*args)
+                self.execute(*args).all
+            end
+
+
+            ##
+            # Returns one row.
+            #
+
+            public
+            def one(*args)
+                self.execute(*args).one
+            end
+
+            ##
+            # Returns all selected rows ordered according to datafield from it.
+            #
+
+            public
+            def assoc(*specification, &block)
+                self.execute.assoc(*specification, &block)
+            end
+
+            ##
+            # Returns first value of first row.
+            #
+
+            public
+            def single(*args)
+                self.execute(*args).single
+            end
+
+            ##
+            # Handles iterating.
+            #
+
+            public
+            def each(*args)
+                self.execute(*args).each do |item|
+                    yield item
+                end
+            end
+
+            ##
+            # Maps callback to array.
+            #
+
+            public
+            def map(*args, &block)
+                result = [ ]
+                
+                self.each(*args) do |item|
+                    result << block.call(item)
+                end
+
+                return result
+            end
+
+            ##
+            # Returns only rows for which block is true.
+            #
+
+            public
+            def find_all(*args, &block)
+                result = [ ]
+
+                self.each(*args) do |item|
+                    if block.call(item) === true
+                        result << block.call(item)
+                    end
+                end
+
+                return result
+            end
+            
+            alias :filter :find_all
+            
+         end
+     end
+ end
+

data/lib/fluent-query/queries/compiled.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require "fluent-query/queries/abstract"
+
+module FluentQuery
+    module Queries
+    
+         ##
+         # Compiled query.
+         #
+         
+         class Compiled < FluentQuery::Queries::Abstract
+            
+            ##
+            # Holds query in compiled form.
+            #
+            
+            @raw
+            attr_accessor :raw
+
+            ##
+            # Constructor.
+            #
+
+            public
+            def initialize(connection, query)
+                super(connection)
+                @raw = query.processor.compile(@connection.driver.build_query(query, :compile))
+            end
+            
+            ##
+            # Builds prepared query string to final form.
+            #
+            
+            public
+            def build(*args)
+                @raw.complete(*args)
+            end
+            
+            ##
+            # Returns all selected rows ordered according to datafield from it.
+            #
+
+            public
+            def assoc(specification, *args)
+                self.execute(*args).assoc(specification)
+            end
+            
+        end
+    end
+end
+

data/lib/fluent-query/queries/prepared.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require "fluent-query/queries/abstract"
+
+module FluentQuery
+    module Queries
+    
+         ##
+         # Compiled query.
+         #
+         
+         class Prepared < FluentQuery::Queries::Abstract
+            
+            ##
+            # Holds query in prepared form.
+            #
+            
+            @query
+
+            ##
+            # Constructor.
+            #
+
+            public
+            def initialize(connection, query)
+                super(connection)
+                @query = @connection.driver.prepare(query)
+            end
+            
+            ##
+            # Builds prepared query string to final form.
+            #
+            
+            public
+            def build(*args)
+                [@query, args]
+            end
+            
+            ##
+            # Returns all selected rows ordered according to datafield from it.
+            #
+
+            public
+            def assoc(specification, *args)
+                self.execute(*args).assoc(specification)
+            end
+            
+        end
+    end
+end
+

data/lib/fluent-query/queries/processor.rb

@@ -0,0 +1,392 @@
+# encoding: utf-8
+require "date"
+require "hash-utils/string"
+
+require "fluent-query/query"
+require "fluent-query/compiler"
+
+module FluentQuery
+    module Queries
+    
+         ##
+         # Query processor.
+         #
+         # Its primary aim is to dive processing methods from query object as is.
+         # In fact, defines something as processing session.
+         #
+         
+         class Processor
+         
+            ##
+            # Indicates column replacement to perform.
+            # (Flag.)
+            #
+            
+            COLUMN_REPLACEMENT = 2
+            
+            ##
+            # Indicates string replacement to perform.
+            # (Flag.)
+            #
+            
+            STRING_REPLACEMENT = 1
+            
+            ##
+            # Indicates formatting directive replacements to perform.
+            # (Flag.)
+            #
+            
+            FORMATTING_REPLACEMENT = 4
+
+            ##
+            # Describes formatting directive.
+            # @var Regexp
+            #
+
+            FORMATTING_DIRECTIVE = /%%(?:[islbfdt]|sql|and|or)(?:[^\w]|$)/
+
+            ##
+            # Describes column directive.
+            # @var Regexp
+            #
+
+            COLUMN_DIRECTIVE = /(?:^|\.|[^\'"\w\\])?\[(?:[\w\.]*[^\\\W])\](?:[^\'"\w]|\.|$)/  # problem is, it interpretes regex
+                                                                                        # from left to right, so if second
+                                                                                        # occurence is immedieately
+                                                                                        # it will not be matched -- that
+                                                                                        # is reason for ? in the begin section
+
+            ##
+            # Describes string directive.
+            # @var Regexp
+            #
+
+            STRING_DIRECTIVE = /(?:^|[^\\])"/
+
+            ##
+            # Holds simple column definition.
+            # @var Regexp
+            #
+
+            FORMATTING_DIRECTIVE_SIMPLE = /%%\w+/
+
+            ##
+            # Holds simple column definition.
+            #
+
+            COLUMN_DIRECTIVE_SIMPLE = /\[.+\]/
+
+            ##
+            # Final regexp for incremental fluent expanding.
+            #  (internal cache)
+
+            @__fluent_expander
+
+            ##
+            # Final regexp for incremental fluent replacing.
+            #  (internal cache)
+
+            @__fluent_replacer
+            
+            ##
+            # Driver upon which processor should work upon.
+            #
+
+            @driver
+            attr_reader :driver
+            
+            ##
+            # Compiler associated to this processor.
+            #
+            
+            @_compiler
+            
+            ##
+            # Constructs processor.
+            # @param MP_Fluent_Driver driver  Driver upon which processor should work upon.
+            #
+
+            public
+            def initialize(driver)
+                @driver = driver
+            end
+
+            ##
+            # Process array to some reasonable string form.
+            #
+            # Joins its elements and separates them by commas. Quotes strings
+            # by by-driver-defined string quoting and integers by integer quoting.
+            #
+
+            public
+            def process_array(array, glue = ",")
+                result = [ ]
+                
+                array.each do |item|
+                    result << self.quote_value(item)
+                end
+
+                return result.join(glue + " ")
+            end
+
+            ##
+            # Process hash to some reasonable string form.
+            #
+            # Joins its elements to name = value form and separates them
+            # by commas. Quotes string value by by-driver-defined string quoting
+            # and integers by integer quoting. Quotes name by identifiers quoting.
+            #
+            # Handles two modes:
+            #   * "assigning" which classicaly keeps for example the '=' operator,
+            #   * "comparing" which sets for example 'IS' operator for booleans.
+            #
+
+            public
+            def process_hash(hash, glue = ",", equality = :comparing)
+                result = [ ]
+                mode = equality
+                
+                hash.each_pair do |key, value|
+                    operator = @driver.quote_equality(value, mode)                        
+                    key = self.quote_identifier(key)
+                    value = self.quote_value(value)
+
+                    result << (key + " " + operator + " " + value)
+                end
+
+                return result.join(" " << glue << " ")
+            end
+
+            ##
+            # Quotes string by driver string quoting and integers by integer
+            # quoting. Other values are converted to string too and
+            # leaved unquoted.
+            #
+
+            public
+            def quote_value(value)
+
+                if (value.string?) or (value.symbol?)
+                    result = @driver.quote_string(value.to_s)
+                elsif value.kind_of? Integer
+                    result = @driver.quote_integer(value)
+                elsif value.array?
+                    result = "(" << self.process_array(value) << ")"    # TODO: question is, if we should do it here, if it's enough general just for processor
+                elsif value.kind_of? Float
+                    result = @driver.quote_float(value)
+                elsif (value.kind_of? TrueClass) or (value.kind_of? FalseClass)
+                    result = @driver.quote_boolean(value)
+                elsif (value.kind_of? Date) or (value.kind_of? DateTime)
+                    result = @driver.quote_date_time(value)
+                elsif value.nil?
+                    result = @driver.null
+                else
+                    result = value.to_s
+                end
+                
+                return result
+                
+            end
+
+            ##
+            # Quotes subquery by driver subquery quoting.
+            #
+
+            public
+            def quote_subquery(subquery)
+                if subquery.kind_of? FluentQuery::Query
+                    subquery = subquery.build!
+                end
+                
+                return @driver.quote_subquery(subquery)
+            end
+         
+            ##
+            # Quotes identifiers by identifier quoting.
+            #
+
+            public
+            def quote_identifier(identifier)
+                @driver.quote_identifier(identifier.to_s)
+            end
+
+            ##
+            # Quotes identifiers list.
+            #
+
+            public
+            def quote_identifiers(identifiers)
+                identifiers.map { |i| self.quote_identifier(i) }
+            end
+           
+            ##
+            # Processes identifier list to the string representation.
+            # Quotes them and joins them separated by commas.
+            #
+
+            public
+            def process_identifiers(identifiers)
+                self.quote_identifiers(identifiers).join(", ")
+            end
+
+            ##
+            # Processed strings with format definitions and data specifications.
+            #
+            # Mode can be :compile, :build or :finish. Compiling means building the 
+            # query without expanding the formatting directives. Finishing means
+            # building the prepared query.
+            #
+
+            public
+            def process_formatted(sequence, mode = :build)
+                count = sequence.length
+                i = 0
+                output = ""
+                                            
+                replacer_settings = self.class::COLUMN_REPLACEMENT | self.class::STRING_REPLACEMENT
+                expander_settings = self.class::FORMATTING_REPLACEMENT
+                
+                while i < count 
+                    item = sequence[i]
+                     
+                    ##
+                    
+                    if item.kind_of? String
+                        item = item.dup
+                    
+                        # Calls to each occurence of directive matching to directive
+                        #  finding expression directive processing. In each call increases
+                        #  sequence position counter so moves forward.
+
+                        if mode != :finish
+                            item.gsub!(self.replacer) do |directive| 
+                                directive.strip!
+                                self.process_directive(directive, nil, replacer_settings)
+                            end
+                        end
+                        
+                        if mode != :compile
+                            item.gsub!(self.expander) do |directive| 
+                                self.process_directive(directive, sequence[i += 1], expander_settings) 
+                            end
+                        end
+                        
+                        output << item
+
+                    elsif item.kind_of? Symbol
+                        output << self.quote_identifier(item)
+                        
+                    else
+                        output << item.to_s
+                        
+                    end
+
+                    output << " "
+                    i += 1
+                end
+
+                return output
+                
+            end
+
+            ##
+            # Processes fluent directive.
+            # Replacements is three bytes flag array.
+            #
+
+            public
+            def process_directive(directive, argument = nil, replacements = 7)
+                if (replacements & self.class::COLUMN_REPLACEMENT > 0) and (directive[0].ord == 91)           # "[", Column directive
+                    result = directive.gsub(self.class::COLUMN_DIRECTIVE_SIMPLE) { |value| self.quote_identifier(value[1..-2]) }
+                elsif (replacements & self.class::STRING_REPLACEMENT > 0) and (directive[-1].ord == 34)           # "\"", String directive
+                    result = directive.gsub('"', @driver.quote_string("").last)
+                elsif (replacements & self.class::FORMATTING_REPLACEMENT > 0) and (directive[0..1].to_sym == :"%%")   # Formatting directive
+                    result = directive.gsub(self.class::FORMATTING_DIRECTIVE_SIMPLE) { |value| self.process_formatting(value[2..-1], argument) }
+                else
+                    result = directive
+                end
+
+                return result
+            end
+
+            ##
+            # Processes formatting directive.
+            #
+
+            public
+            def process_formatting(directive, argument)
+                proc = self.compiler.compile_formatting(directive)
+                
+                if proc
+                    output = proc.call(argument)
+                else
+                    output = ""
+                end
+                
+                return output
+            end
+            
+            ##
+            # Returns NULL representation.
+            #
+
+            public
+            def null
+                @driver.null
+            end
+
+            ##
+            # Returns final fluent expander query.
+            #
+
+            public
+            def expander
+                if @__fluent_expander.nil?
+                    @__fluent_expander = self.class::FORMATTING_DIRECTIVE            
+                end
+
+                @__fluent_expander
+            end
+
+            ##
+            # Returns final fluent formatter query.
+            #
+
+            public
+            def replacer
+                if @__fluent_replacer.nil?
+                    parts = Array[self.class::COLUMN_DIRECTIVE, self.class::STRING_DIRECTIVE]
+
+                    result = ""
+                    result << "(?:(?:" << parts.join(")|(?:") << "))"
+                    
+                    @__fluent_replacer = Regexp::new(result)
+                end
+
+                @__fluent_replacer
+            end
+            
+            ##
+            # Returns compiler.
+            #
+            
+            def compiler
+                if @_compiler.nil?
+                    @_compiler = FluentQuery::Compiler::new(self)
+                end
+                
+                @_compiler
+            end
+            
+            ##
+            # Compiles the string.
+            #
+            
+            def compile(string)
+                self.compiler.compile(string)
+            end
+            
+         end
+     end
+ end
+