ronin-sql 0.1.1 → 0.2.0

data/lib/ronin/code/sql/create_index.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,55 +21,25 @@
 #++
 #
 
-require 'ronin/code/sql/statement'
+require 'ronin/code/sql/create'
+require 'ronin/code/sql/on_clause'
 
 module Ronin
   module Code
     module SQL
-      class CreateIndex < Statement
+      class CreateIndex < Create
 
-        option :unqiue, "UNIQUE"
-        option :if_not_exists, "IF NOT EXISTS"
+        clause :on, OnClause
 
-        def initialize(style,index=nil,table=nil,columns={},&block)
-          @index = index
-          @table = table
-          @columns = columns
-
-          super(style,&block)
-        end
-
-        def index(field)
-          @index = field
-          return self
-        end
-
-        def table(field)
-          @table = field
-          return self
+        def initialize(dialect,index=nil,options={},&block)
+          super(dialect,'INDEX',index,options,&block)
         end
 
-        def column(name,type)
-          @columns[name.to_s] = type.to_s
+        def index(name)
+          @name = name
           return self
         end
 
-        def compile(dialect=nil,multiline=false)
-          format_columns = lambda {
-            @columns.map { |name,type|
-        "#{name} #{type}"
-          }
-          }
-
-          return compile_expr(keyword_create,unique?,keyword_index,if_not_exists?,@index,keyword_on,@table,compile_row(format_columns.call))
-        end
-
-        protected
-
-        keyword :create
-        keyword :index
-        keyword :on
-
       end
     end
   end

data/lib/ronin/code/sql/create_table.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,72 +21,25 @@
 #++
 #
 
-require 'ronin/code/sql/statement'
-require 'ronin/code/sql/select'
+require 'ronin/code/sql/create'
+require 'ronin/code/sql/fields_clause'
 
 module Ronin
   module Code
     module SQL
-      class CreateTable < Statement
+      class CreateTable < Create
 
-        option :temp, "TEMP"
-        option :if_not_exists, "IF NOT EXISTS"
+        clause :columns, FieldsClause
 
-        def initialize(style,table=nil,opts={:columns => {}, :not_null => {}, :as => nil},&block)
-          @table = table
-          @columns = opts[:columns]
-          @not_null = opts[:not_null]
-          @as = opts[:as]
-
-          super(style,&block)
+        def initialize(dialect,table=nil,options={},&block)
+          super(dialect,'TABLE',table,options,&block)
         end
 
-        def table(field)
-          @table = field
+        def table(name)
+          @name = name
           return self
         end
 
-        def as(table=nil,opts={:fields => nil, :where => nil},&block)
-          @as = Select.new(@style,table,opts,&block)
-          return self
-        end
-
-        def column(name,type,null=false)
-          name = name.to_s
-          @columns[name] = type.to_s
-          @not_null[name] = null
-          return self
-        end
-
-        def primary_key(field)
-          @primary_key = field
-          return self
-        end
-
-        def compile
-          format_columns = lambda {
-            @columns.map { |name,type|
-            if @not_null[name]
-          "#{name} #{type} NOT NULL"
-            else
-          "#{name} #{type}"
-            end
-          }
-          }
-
-          return compile_expr(keyword_create,temp?,keyword_table,if_not_exists?,@table,compile_row(format_columns.call))
-        end
-
-        protected
-
-        keyword :create
-        keyword :table
-        keyword :primary_key
-
-        def primary_key?
-          compile_expr(keyword_primary_key,@primary_key) if @primary_key
-        end
-
       end
     end
   end

data/lib/ronin/code/sql/create_view.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,44 +21,22 @@
 #++
 #
 
-require 'ronin/code/sql/statement'
-require 'ronin/code/sql/select'
+require 'ronin/code/sql/create'
 
 module Ronin
   module Code
     module SQL
-      class CreateView < Statement
+      class CreateView < Create
 
-        option :temp, "TEMP"
-        option :if_not_exists, "IF NOT EXISTS"
-
-        def initialize(style,view=nil,query=nil,&block)
-          @view = view
-          @query = query
-
-          super(style,&block)
-        end
-
-        def view(field)
-          @view = field
-          return self
+        def initialize(dialect,view=nil,options={},&block)
+          super(dialect,'VIEW',view,options,&block)
         end
 
-        def query(table=nil,opts={:fields => nil, :where => nil},&block)
-          @query = Select.new(@style,table,opts,&block)
+        def view(name)
+          @name = name
           return self
         end
 
-        def compile
-          compile_expr(keyword_create,temp?,keyword_view,if_not_exists?,@view,keyword_as,@query)
-        end
-
-        protected
-
-        keyword :create
-        keyword :view
-        keyword :as
-
       end
     end
   end

data/lib/ronin/code/sql/default_values_clause.rb

@@ -0,0 +1,38 @@
+#
+#--
+# Ronin SQL - A Ronin library providing support for SQL related security
+# tasks.
+#
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/code/sql/default_values_clause'
+
+module Ronin
+  module Code
+    module SQL
+      class DefaultValuesClause < Clause
+
+        def emit
+          emit_token('DEFAULT VALUES')
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/delete.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -22,40 +22,25 @@
 #
 
 require 'ronin/code/sql/statement'
+require 'ronin/code/sql/from_clause'
+require 'ronin/code/sql/where_clause'
 
 module Ronin
   module Code
     module SQL
       class Delete < Statement
 
-        def initialize(style,table=nil,where_expr=nil,&block)
-          @table = table || everything
-          @where = where_expr
+        clause :from, FromClause
+        clause :where, WhereClause
 
-          super(style,&block)
-        end
-
-        def from(table)
-          @table = table
-          return self
-        end
+        def initialize(dialect,options={},&block)
+          @table = options[:table]
 
-        def where(expr)
-          @where = expr
-          return self
+          super(dialect,options,&block)
         end
 
-        def compile
-          compile_expr(keyword_delete,@table,where?)
-        end
-
-        protected
-
-        keyword :delete, 'DELETE FROM'
-        keyword :where
-
-        def where?
-          compile_expr(keyword_where,@where) if @where
+        def emit
+          emit_token('DELETE FROM') + emit_value(@table)
         end
 
       end

data/lib/ronin/code/sql/desc.rb

@@ -0,0 +1,38 @@
+#
+#--
+# Ronin SQL - A Ronin library providing support for SQL related security
+# tasks.
+#
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/code/sql/modifier'
+
+module Ronin
+  module Code
+    module SQL
+      class Asc < Modifier
+
+        def initialize(expr)
+          super(expr,'DESC')
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/dialect.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007 Hal Brodigan (postmodern at users.sourceforge.net)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern at users.sourceforge.net)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -22,7 +22,10 @@
 #
 
 require 'ronin/code/sql/exceptions/unknown_dialect'
+require 'ronin/code/sql/exceptions/unknown_statement'
+require 'ronin/code/sql/exceptions/unknown_clause'
 require 'ronin/code/sql/function'
+require 'ronin/code/symbol_table'
 require 'ronin/extensions/meta'
 
 module Ronin
@@ -30,130 +33,247 @@ module Ronin
     module SQL
       class Dialect
 
-        # The style to use
-        attr_reader :style
+        # Symbol Table for the dialect
+        attr_reader :symbols
 
-        def initialize(style)
-          @style = style
+        # Statements used within the dialect
+        attr_reader :statements
+
+        #
+        # Creates a new Dialect object connected to the specified
+        # _program_.
+        #
+        def initialize(symbols={})
+          @symbols = SymbolTable.new(symbols)
+          @statements = []
         end
 
+        #
+        # Returns the Hash of defined SQL dialects.
+        #
         def Dialect.dialects
           @@dialects ||= {}
         end
 
+        #
+        # Returns +true+ if there is a SQL Dialect defined with the
+        # specified _name_, returns +false+ otherwise.
+        #
         def Dialect.has_dialect?(name)
           Dialect.dialects.has_key?(name.to_sym)
         end
 
-        def Dialect.get_dialect(name)
+        #
+        # Returns the SQL Dialect defined with the specified _name_. If no
+        # such SQL Dialect exists, an UnknownDialect exception will be
+        # raised.
+        #
+        def Dialect.get(name)
           name = name.to_sym
 
           unless Dialect.has_dialect?(name)
-            raise(UnknownDialect,"unknown dialect #{name.dump}",caller)
+            raise(UnknownDialect,"unknown dialect #{name}",caller)
           end
 
           return Dialect.dialects[name]
         end
 
-        def expresses?(name)
-          public_methods.include?(name.to_s)
+        #
+        # Returns the Hash of defined Statements within the Dialect.
+        #
+        def self.statements
+          @@statements ||= {}
+        end
+
+        def self.has_statement?(name)
+          self.statements.has_key?(name.to_sym)
         end
 
-        def express(name,*args,&block)
-          unless expresses?(name)
-            raise(NameError,"undefined method '#{name}' for #{self}",caller)
+        def self.clauses
+          all_clauses = {}
+
+          self.statements.each do |stmt|
+            all_clauses.merge!(stmt.clauses)
           end
 
-          return send(name,*args,&block)
+          return all_clauses
         end
 
-        def field(name)
-          field_cache[name.to_sym]
+        def self.has_clause?(name)
+          self.statements.each_value do |stmt|
+            return true if stmt.has_clause?(name)
+          end
+
+          return false
         end
 
-        protected
+        def has_statement?(name)
+          self.class.has_statement?(name)
+        end
 
-        def self.dialect(name)
+        def statement(name,*arguments,&block)
+          name = name.to_sym
+
+          unless has_statement?(name)
+            raise(UnknownStatement,"unknown statement #{name} in #{dialect} dialect",caller)
+          end
+
+          return self.class.statements[name].new(self,*arguments,&block)
+        end
+
+        def enqueue_statement(name,*arguments,&block)
+          stmt = statement(name,*arguments,&block)
+
+          @statements << stmt
+          return stmt
+        end
+
+        def has_clause?(name)
+          self.class.has_clause?(name)
+        end
+
+        def clause(name,*arguments)
           name = name.to_sym
 
-          class_def(:name) { name }
+          self.class.statements.each do |stmt|
+            if stmt.has_cluase?(name)
+              return stmt.clauses[name].new(*arguments)
+            end
+          end
+
+          raise(UnknownClause,"unknown clause #{name}",caller)
+        end
+
+        def symbol(name)
+          sym = @symbols.symbol(name)
+          sym.value ||= name
+
+          return sym
+        end
+
+        def field(name)
+          sym = @symbols.symbol(name)
+          sym.value ||= Field.new(@symbols,name)
+
+          return sym
+        end
+
+        def all
+          Token.new('*')
+        end
+
+        def id
+          field('id')
+        end
+
+        def each_token(&block)
+          @statements.each do |stmt|
+            stmt.emit.each(&block)
+
+            block.call(Token.separator)
+          end
 
-          Dialect.dialects[name] = self
           return self
         end
 
-        def self.keyword(name,value=name.to_s.upcase)
-          name = name.to_s.downcase
+        protected
+
+        #
+        # Defines a SQL Dialect with the specified _name_.
+        #
+        def self.dialect(name)
+          name = name.to_sym
+
+          class_def(:dialect) { name }
 
-          class_def("keyword_#{name}") { keyword(value) }
+          Dialect.dialects[name.to_sym] = self
           return self
         end
 
+        #
+        # Defines various SQL primitives with the specified _names_.
+        #
         def self.primitives(*names)
           names.each do |name|
             name = name.to_s.downcase
 
-            class_def(name) { keyword(name) }
+            class_def(name) { Token.new(name) }
           end
 
           return self
         end
 
+        #
+        # Defines a SQL data-type with the specified _name_ and given
+        # _options_.
+        #
         def self.data_type(name,options={})
           name = name.to_s.downcase
-          type_name = name.upcase.to_sym
-
-          if options[:length]==true
-            class_def(name) do |length|
-              if length
-                "#{type_name}(#{length})"
-              else
-                type_name
-              end
+          type_name = name.upcase
+          supports_length = options[:length]
+
+          class_def(name) do |length|
+            if (supports_length && length)
+              Token.new("#{type_name}(#{length})")
+            else
+              Token.new(type_name)
             end
-          else
-            class_def(name) { type_name }
           end
 
           return self
         end
 
-        def self.function(*names)
+        #
+        # Defines various SQL function with the specified _names_.
+        #
+        def self.functions(*names)
           names.each do |name|
-            class_def(name) do |field|
-              Function.new(@style,name,field)
+            class_def(name) do |*fields|
+              Function.new(name,*fields)
             end
           end
 
           return self
         end
 
+        #
+        # Defines various SQL aggregate functions with the specified
+        # _names_.
+        #
         def self.aggregators(*names)
-          function(*names)
+          names.each do |name|
+            class_def(name) do |field|
+              Function.new(name,field)
+            end
+          end
+
+          return self
         end
 
-        def self.command(name,base)
+        #
+        # Defines an SQL statement with the specified _name_ and _base_
+        # class.
+        #
+        def self.statement(name,base)
+          name = name.to_sym
+
+          self.statements[name] = base
+
           class_eval %{
-            def #{name}(*args,&block)
-              #{base}.new(@style,*args,&block)
+            def #{name}(*arguments,&block)
+              enqueue_statement(:#{name},*arguments,&block)
             end
           }
 
           return self
         end
 
-        def keyword(value)
-          keyword_cache[value.to_sym]
-        end
-
-        private
-
-        def keyword_cache
-          @keyword_cache ||= Hash.new { |hash,key| hash[key] = Keyword.new(@style,key) }
-        end
+        def method_missing(name,*arguments,&block)
+          if (arguments.empty? && block.nil?)
+            return field(name)
+          end
 
-        def field_cache
-          @field_cache ||= Hash.new { |hash,key| hash[key] = Field.new(@style,key) }
+          raise(NoMethodError,name.id2name)
         end
 
       end