sqlconstructor 0.1

data/lib/sqlerrors.rb

@@ -0,0 +1,15 @@
+
+##################################################################################
+#   List of error messages
+##################################################################################
+
+ERR_INVALID_COL_NAME        = "Invalid column name."
+ERR_INVALID_RULES           = "No valid syntax rules found for dialect"
+ERR_NUMERIC_VALUE_EXPECTED  = "Numeric argument value expected."
+ERR_UNKNOWN_DIALECT         = "Unimplemented SQL dialect specified"
+ERR_UNKNOWN_METHOD          = "Unknown method called"
+ERR_UNKNOWN_OPERATOR_TYPE   = "Unknown conditional operator type."
+ERR_VALUES_NUM_MISMATCH     = "Number of values provided mismatches the number of requested columns."
+ERR_WHERE_INVALID_ARGS      = "Hash expected in .where() arguments."
+ERR_WHERE_LIKE_INVALID_ARGS = "Hash with scalar values expected in .where() arguments."
+ERR_NAME_NOT_FOUND          = "Could not find named clause by the name"

data/lib/sqlexporter.rb

@@ -0,0 +1,125 @@
+
+##############################################################################################
+#   This class implements the interface for exprting SQLConstructor objects to strings.
+##############################################################################################
+class SQLExporter
+
+    attr_accessor :dialect, :tidy
+    attr_reader :separator
+
+     # defaults to 'mysql'
+    DEFAULT_DIALECT = 'mysql'
+
+    #############################################################################
+    #   Class constructor. Called with two optional arguments - dialect and tidy.
+    #   Dialect determines the translator class (e.g., Exporter_mysql, 
+    #   Exporter_informix etc). Tidy determines whether the output should be
+    #   formatted and human-readable.
+    #############################################################################
+    def initialize ( dialect = DEFAULT_DIALECT, tidy = false )
+        dialect ||= DEFAULT_DIALECT
+        dialect_class = "Exporter_" + dialect.to_s
+        begin
+            @translator = SQLExporter.const_get( dialect_class ).new( tidy )
+        rescue
+            raise NameError, ERR_UNKNOWN_DIALECT + ": " + dialect.to_s
+        end
+        @dialect, @tidy = dialect, tidy
+        @separator = @translator.separator
+    end
+
+    #############################################################################
+    #   The main method to export the obj to string. Calls the @translator's 
+    #   export method.
+    #############################################################################
+    def export ( obj )
+        string = @translator.export obj
+        string = @separator + "(" + string + ")"  if obj.inline
+        return string
+    end
+
+
+  ######################################################################################### 
+  #   The exporter class of a 'generic' sql dialect. This should be the parent for
+  #   all dialect-specific exporter classes.
+  ######################################################################################### 
+    class Exporter_generic
+
+        attr_reader :separator
+
+        #############################################################################
+        #   Class constructor.
+        #############################################################################
+        def initialize ( tidy )
+            @tidy = tidy
+            @separator = @tidy ? "\n" : " "
+        end
+
+        #############################################################################
+        #   exports a string with a query from object.
+        #   this method should be called from a child class with defined constant
+        #   arrays [select|delete|update|insert]_syntax. methods defined in the array 
+        #   are called in the specified order for the object obj.
+        #############################################################################
+        def export ( obj )
+            rules_const_name = obj.class.name.sub( /^.+?::Basic([^_]+).+/, '\1' ).upcase + "_SYNTAX"
+            begin
+                rules = self.class.const_get( rules_const_name.to_sym )
+            rescue NameError
+                raise NameError, ERR_INVALID_RULES + " '" + self.send( :dialect ) + "'"
+            end
+            string = ""
+            rules.each do |rule|
+                if rule.is_a? String
+                    string += rule + @separator
+                elsif rule.is_a? Symbol
+                    res = self.send( rule, obj ).to_s
+                    string += res
+                    string += @separator  if ! res.empty?
+                end
+            end
+            return string
+        end
+
+        #############################################################################
+        #   Generic representation of the JOIN clause
+        #############################################################################
+        def gen_joins ( obj )
+            arr_joins = [ ]
+            if obj.gen_joins 
+                arr_joins = obj.gen_joins.map { |join|  join.to_s }
+            end
+            return arr_joins.join( @separator )
+        end
+
+        #############################################################################
+        #   Construct an expression string for an object's attribute defined in
+        #   in the METHODS constant array.
+        #############################################################################
+        def method_missing ( method, *args )
+            obj = args[0]
+            return ''  if ! obj.is_a? SQLObject
+            result = ""
+            _attr = obj.send method
+            if _attr.is_a? Array
+                result += _attr.join @separator
+            elsif _attr
+                result += _attr.to_s
+            end
+ 
+            return result
+        end
+
+    end
+
+end
+
+##################################################################################################
+##################################################################################################
+#   Include dialect-specific classes from ./dialects/exporter/  :
+#   This should be done after SQLExporter is defined.
+##################################################################################################
+##################################################################################################
+
+Dir[ DIALECTS_PATH + "/*-exporter.rb"].each { |file|  require file }
+ 

data/lib/sqlobject.rb

@@ -0,0 +1,284 @@
+
+###############################################################################################
+###   Main class for all objects. All other entities should inherit this class.
+###############################################################################################
+class SQLObject
+
+    attr_accessor :alias, :separator, :name, :inline
+
+    ##########################################################################
+    #   Do we really need a constructor here?
+    ##########################################################################
+    def initialize
+        @string = nil
+        @alias  = nil
+        @name   = nil
+        @inline = nil
+    end
+
+    ##########################################################################
+    #   Set object's name for further named processing
+    ##########################################################################
+    def _name ( name )
+        @name = name.to_s
+        return self
+    end
+
+    ##########################################################################
+    #   Store string representation in @string after the first call
+    ##########################################################################
+    def to_s
+        return @string  if @string
+        @string = self.to_s
+    end
+
+    ##########################################################################
+    #   attr_reader for @string, actually an alias to to_s().
+    ##########################################################################
+    def _string
+        to_s
+    end
+
+    ##########################################################################
+    #   attr_writer for @string
+    ##########################################################################
+    def _string= ( val )
+        @string = val
+    end
+
+    ##########################################################################
+    #   Convert values to the corresponding internal data types
+    ##########################################################################
+    def self.get ( *list )
+        list.map! do |expr|
+            if expr.is_a? SQLObject
+                 # inline queries go in parens:
+                if expr.class == SQLConstructor || expr.is_a?( SQLConstructor::GenericQuery )
+                    expr.inline = true
+                end
+                expr
+            elsif expr.is_a? Array or expr.is_a? Range
+                SQLValList.new *expr.to_a
+            elsif expr.is_a? Hash
+                SQLAliasedList.new expr
+            elsif expr.is_a? Symbol
+                SQLColumn.new( expr )
+            else
+                SQLValue.new( expr )
+            end
+        end
+
+         # Return array or scalar, depending on the number of function arguments
+        list.length == 1  ?  list[0]  :  list
+    end
+
+#    ##########################################################################
+#    #   Convert a hash of { obj => alias, ... } to an array of SQLObjects
+#    #   with defined @alias attribute.
+#    ##########################################################################
+#    def self.getWithAliases( *list )
+#        new_list = [ ]
+#         # If list is a hash of objects with aliases:
+#        if list.length == 1 && list[0].is_a?( Hash )
+#            list.each do |src, _alias|
+#                obj = SQLObject.get src
+#                obj.alias = _alias
+#                new_list << obj
+#            end
+#         # If list is an array of objects:
+#        else
+#            new_list = list.map { |src|  SQLObject.get src }
+#        end
+#        return new_list
+#    end 
+
+end
+
+
+###############################################################################################
+###   Class representing SQL columns
+###############################################################################################
+class SQLColumn < SQLObject
+
+    def initialize ( col = nil )
+        @name = col.is_a?( SQLColumn )  ?  col.name  :  col #_prepareName( col )
+    end
+
+    ##########################################################################
+    def to_s
+        @name.to_s
+    end
+
+  private
+
+    ##########################################################################
+    #   Prepare column name (remove all non-alphanumeric/underscore characters)
+    ##########################################################################
+    def _prepareName ( name )
+        name.to_s.gsub /[\W]/, ''
+    end
+  
+end
+
+
+###############################################################################################
+###   Class representing SQL scalar values
+###############################################################################################
+class SQLValue < SQLObject
+
+    def initialize ( val = nil )
+        @value = val.is_a?( SQLValue )  ?  val.value  :  _escape( val )
+    end
+
+    ##########################################################################
+    def to_s
+        @value
+    end
+ 
+  private
+
+    ##########################################################################
+    # DERIVED FROM https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+    ##########################################################################
+    def _escape ( val )
+        case val
+            when String     then "'#{_quoteString(val.to_s)}'"
+            when true       then 'TRUE'
+            when false      then 'FALSE'
+            when nil        then "NULL"
+            when Numeric, Time then val.to_s
+            when Symbol     then "'#{_quoteString(val.to_s)}'"
+            when Class      then "'#{val.to_s}'"
+            else
+                "'#{quoteString( val.to_s )}'"
+        end
+    end
+
+    ##########################################################################
+    # FROM https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+    # Quotes a string, escaping any ' (single quote) and \ (backslash)
+    # characters.
+    ##########################################################################
+    def _quoteString ( str )
+        str.gsub( /\\/, '\&\&' ).gsub( /'/, "''" ) # ' (for ruby-mode)
+    end
+
+end
+
+
+###############################################################################################
+###   Class container - a list of SQLValue scalars
+###############################################################################################
+class SQLValList < SQLObject
+    def initialize ( *list )
+        @list = list.map { |item|  SQLObject.get item }
+    end
+
+    def << ( list )
+        list.map! { |item|  SQLObject.get item }
+        @list += list
+    end
+
+    def to_s
+        return @string  if @string
+        @string = "(" + @list.join( "," ) + ")"
+    end
+end
+
+
+###############################################################################################
+###   Class container - a list of SQLObjects with aliases
+###############################################################################################
+class SQLAliasedList < SQLObject
+    attr_writer :no_commas
+
+    def initialize ( *list )
+        @list = _getList *list
+    end
+
+    def << ( *list )
+        @list += _getList *list
+        return self 
+    end
+ 
+    def push ( *list )
+        @list += _getList( *list )
+    end
+
+    def length
+        @list.length
+    end
+
+    def each ( &block )
+        @list.each &block
+    end
+
+    def delete_if ( &block )
+        @list.delete_if &block
+    end
+ 
+    def [] (i)
+        @list[i]
+    end
+
+    def find ( &block )
+        @list.find &block
+    end
+
+    def select ( &block )
+        @list.each &block
+    end
+
+    def each_with_index ( &block )
+        @list.each_with_index &block
+    end
+
+    def to_s
+        return @string  if @string
+        arr = @list.map { |obj|  obj.to_s + ( obj.alias  ? " " + obj.alias.to_s  : "" ) }
+        list_separator = @no_commas  ? ""  : ","
+        @string = arr.join list_separator
+    end
+
+  private
+
+    def _getList ( *list )
+        new_list = [ ]
+         # If list is a hash of objects with aliases:
+        if list.length == 1 && list[0].is_a?( Hash )
+            new_list += _hash2array list[0]
+         # If list is an array of objects:
+        else
+            new_list = list.map { |src|  SQLObject.get src }
+        end
+    end
+
+    def _hash2array ( hash )
+        list = [ ]
+        hash.each do |item, _alias|
+            obj = SQLObject.get item
+            obj.alias = _alias
+            list << obj
+        end
+        return list
+    end
+
+end
+  
+
+###############################################################################################
+###
+###############################################################################################
+class SQLCondList < SQLObject
+    def initialize ( hash = { } )
+        @hash = Hash[ hash.map{ |k,v|  [ SQLObject.get( k ), SQLObject.get( v ) ] } ]
+    end
+
+    def << ( new_hash )
+        @hash.merge! new_hash
+    end
+
+    def to_s
+        @hash.map{ |k,v| k.to_s + "=" + v.to_s }.join( "," )
+    end
+end

data/test/queries.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'sqlconstructor'
+
+class SQLConstructorTest < Test::Unit::TestCase
+
+    def test_select1
+        assert_equal "SELECT\n col1,col2\nFROM table1\nJOIN table3 USE INDEX (col1)\nON \n(col1 = ccc1)\nJOIN table4,table5\nON \n(col2 = ccc2  AND col3 = 5)\nWHERE \n(col1 = 123  AND col2 IN ('value1','value2','@\#$%^')  AND \n(c1 = 5  AND c2 < 6  OR  (c1 = 3  AND c2 IN (1,2,3,4,5)  AND s1 = 'somestring')))\nLIMIT 100\nUNION\nSELECT\n baz\nFROM table2\nUNION\nSELECT\n fooz\nFROM table5\nLIMIT 20\n\n", 
+                     select1
+    end
+
+    def test_select2
+        assert_equal "SELECT\n t.id,t.tag,c.title category\nFROM tags2Articles t2a\nINNER JOIN tags t\nON \n(t.id = t2a.idTag)\nINNER JOIN categories c\nON \n(t.tagCategory = c.id)\nINNER JOIN \n(SELECT\n a.id\nFROM articles a\nJOIN tags2articles ta\nON \n(a.id = ta.idArticle)\nJOIN tags tsub\nON \n(ta.idTag = tsub.id)\nWHERE \n(tsub.id IN (12,13,16))\nGROUP BY a.id\nHAVING \n(COUNT(DISTINCT tsub.id) = 3)\n) asub\nON \n(t2a.idArticle = asub.id)\n",
+                     select2
+    end
+
+    def test_insert1
+        assert_equal "INSERT\nINTO table2\n SELECT\n name,CONCAT('blah=',ID)\nFROM table1\n\n",
+                     insert1
+    end
+
+    def test_delete1
+        assert_equal "DELETE\nFROM keywords\nWHERE \n(keyword_id IN \n(SELECT\n id\nFROM \n(SELECT\n k.keyword id\nFROM keywords k\nWHERE \n(k.keyword_type = 'CAMPAIGN'  AND k.keyword != 'Airtel'  AND k.keyword != 'Nokia'  AND k.keyword != 'Micromax'  AND k.keyword NOT IN \n(SELECT\nDISTINCT\n keyword_id\nFROM customer_analysis\n))\nORDER BY k.keyword_id\n) a\n))\n",
+                     delete1
+    end
+
+    def test_update1
+        assert_equal "UPDATE\n guest g\nSET link_id=\n(SELECT\n MAX(h.host_id)\nFROM guest_data d\nINNER JOIN host_data h\nON \n(d.guest_nm = hhost_nm)\nWHERE \n(d.guest_id = g.guest_id)\nGROUP BY h.venue_nm\nHAVING \n(COUNT(*) = 1)\n)\nWHERE \n(g.guest_id IN \n(SELECT\n d.guest_id\nFROM guest_data d\nINNER JOIN host_data h\nON \n(d.guest_nm = hhost_nm)\nGROUP BY h.venue_nm\nHAVING \n(COUNT(*) = 1)\n))\n",
+                     update1
+    end
+ 
+    def select1
+        sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        sql.select(:col1,:col2).from(:table1).where.eq(:col1, 123).and.in(:col2,["value1","value2","@#\$%^"])
+        sql.limit( 100 )
+        sql.union._name("u1").select(:baz).from(:table2)
+        c2 = SQLConditional.new.eq(:c1,3).and.in(:c2,[1,2,3,4,5]).and.eq(:s1,'somestring')
+        c1 = SQLConditional.new.eq(:c1,5).and.lt(:c2,6).or.is(c2)
+        sql.where.and.is(c1)
+        sql.join( :table3 )._name('j1').on.eq( :col1, :ccc1 ).use_index( :col1 )
+        sql.join( :table4,:table5 )._name('j2').on.eq( :col2, :ccc2).and.eq( :col3, 5 )
+        sql.union._name("u2").select(:fooz).from(:table5).limit( 20 )
+        sql.to_s
+    end
+
+    def select2
+        sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        sql.select( :"t.id",:"t.tag",:"c.title" => :category ).from( :tags2Articles => :t2a )
+        sql.inner_join( :tags => :t ).on.eq(:"t.id", :"t2a.idTag" )
+        sql.inner_join( :categories => :c ).on.eq( :"t.tagCategory", :"c.id" )
+        inner_sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        inner_sql.select( :"a.id" ).from( :articles => :a )
+        inner_sql.join( :tags2articles => :ta ).on.eq( :"a.id", :"ta.idArticle" )
+        inner_sql.join( :tags => :tsub ).on.eq( :"ta.idTag", :"tsub.id" )
+        inner_sql.where.in( :"tsub.id", [12,13,16] ).group_by( :"a.id" ).
+                  having.eq( :"COUNT(DISTINCT tsub.id)", 3 )
+        sql.inner_join( inner_sql => 'asub' ).on.eq( :"t2a.idArticle", :"asub.id" )
+        sql.to_s
+    end
+
+    def insert1
+        sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        sql.insert.into(:table2).select(:name, :"CONCAT('blah=',ID)").from(:table1)
+        sql.to_s
+    end
+
+    def delete1
+        sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        inner_sel3 = SQLConstructor.new( :tidy => true, :dialect => 'mysql' ).select( :keyword_id ).distinct.from( :customer_analysis )
+        inner_sel2 = SQLConstructor.new( :tidy => true, :dialect => 'mysql' ).select( :"k.keyword" => :id ).from( :keywords => :k ).
+                     where.eq( :"k.keyword_type", "CAMPAIGN" ).and.ne( :"k.keyword", "Airtel" ).
+                     and.ne( :"k.keyword", "Nokia" ).and.ne( :"k.keyword", "Micromax" ).
+                     and.not_in( :"k.keyword", inner_sel3 ).order_by( :"k.keyword_id" )
+        inner_sel1 = SQLConstructor.new( :tidy => true, :dialect => 'mysql' ).select( :id ).from( inner_sel2 => :a )
+        sql.delete.from( :keywords ).where.in( :keyword_id, inner_sel1 )
+        sql.to_s
+    end
+
+    def update1
+        sql = SQLConstructor.new( :tidy => true, :dialect => 'mysql' )
+        in_sel1 = SQLConstructor.new( :tidy => true )
+        in_sel1.select( :"MAX(h.host_id)" ).from( :guest_data => :d ).
+                  inner_join( :host_data => :h ).on.eq( :"d.guest_nm", :hhost_nm ).where. 
+                  eq( :"d.guest_id", :"g.guest_id" ).group_by( :"h.venue_nm" ).having.eq( :"COUNT(*)", 1 )
+        in_sel2 = SQLConstructor.new( :dialect => 'mysql', :tidy => true )
+        in_sel2.select( :"d.guest_id" ).from( :guest_data => :d ).
+                  inner_join( :host_data => :h ).on.eq( :"d.guest_nm", :hhost_nm ).
+                  group_by( :"h.venue_nm" ).having.eq( :"COUNT(*)", 1 )
+        sql.update( :guest => :g ).set( :link_id => in_sel1).where.in( :"g.guest_id", in_sel2 )
+        sql.to_s
+    end
+ 
+end