sql-maker 0.0.1

data/lib/sql/maker/condition.rb

@@ -0,0 +1,378 @@
+require 'sql/maker/util'
+require 'sql/query_maker'
+
+class SQL::Maker::Condition
+  include SQL::Maker::Util
+  attr_accessor :sql, :bind, :strict, :name_sep, :quote_char
+
+  def initialize(args = {})
+    @sql = args[:sql] || []
+    @bind = args[:bind] || []
+    @strict = args[:strict].nil? ? false : args[:strict]
+    @name_sep = args[:name_sep] || ''
+    @quote_char = args[:quote_char] || ''
+  end
+
+  def &(other)
+    self.compose_and(other)
+  end
+
+  def |(other)
+    self.compose_or(other)
+  end
+
+  def _quote(label)
+    quote_identifier(label, self.quote_char, self.name_sep)
+  end
+
+  # _make_term(:x => 1)
+  def _make_term(*args)
+    col, val = parse_args(*args)
+    col = col.to_s
+
+    if val.is_a?(SQL::QueryMaker)
+      return [val.as_sql(col, self.method(:_quote)), val.bind]
+    elsif self.strict
+      croak("can pass only SQL::QueryMaker as an argument in strict mode")
+    end
+
+    if val.is_a?(Array)
+      if val.first.is_a?(Hash)
+        # {'foo'=>[{'>' => 'bar'},{'<' => 'baz'}]} => (`foo` > ?) OR (`foo` < ?)
+        return self._make_or_term(col, 'OR', val)
+      else
+        # {'foo'=>['bar','baz']} => `foo` IN (?, ?)
+        return self._make_in_term(col, 'IN', val)
+      end
+    elsif val.is_a?(Hash)
+      op, v = val.each.first
+      op = op.upcase.to_s
+      if ( op == 'AND' || op == 'OR' ) && v.is_a?(Array)
+        # {'foo'=>[{'>' => 'bar'},{'<' => 'baz'}]} => (`foo` > ?) OR (`foo` < ?)
+        return self._make_or_term(col, op, v)
+      elsif ( op == 'IN' || op == 'NOT IN' )
+        return self._make_in_term(col, op, v)
+      elsif ( op == 'BETWEEN' ) && v.is_a?(Array)
+        croak("USAGE: make_term(foo => {BETWEEN => [a, b]})") if v.size != 2
+        return [self._quote(col) + " BETWEEN ? AND ?", v]
+      else
+        # make_term(foo => { '<' => \"DATE_SUB(NOW(), INTERVAL 3 DAY)"}) => 'foo < DATE_SUB(NOW(), INTERVAL 3 DAY)'
+        # return [self._quote(col) + " op " + v, []]
+        # make_term(foo => { '<' => 3 }) => foo < 3
+        return [self._quote(col) + " #{op} ?", [v]]
+      end
+    elsif val
+      # make_term(foo => "3") => foo = 3
+      return [self._quote(col) + " = ?", [val]]
+    else
+      # make_term(foo => nil) => foo IS NULL
+      return [self._quote(col) + " IS NULL", []]
+    end
+  end
+
+  def _make_or_term(col, op, values)
+    binds = []
+    terms = []
+    values.each do |v|
+      term, bind = self._make_term(col => v)
+      terms.push "(#{term})"
+      binds.push bind
+    end
+    term = terms.join(" #{op} ")
+    bind = binds.flatten
+    return [term, bind]
+  end
+
+  def _make_in_term(col, op, v)
+    if v.respond_to?(:as_sql)
+      # make_term(foo => { 'IN' => sql_raw('SELECT foo FROM bar') }) => foo IN (SELECT foo FROM bar)
+      term = "#{self._quote(col)} #{op} (#{v.as_sql})"
+      [term, v.bind]
+    elsif v.is_a?(Array)
+      if v.size == 0
+        if op == 'IN'
+          # make_term(foo => {'IN' => []}) => 0=1
+          return ['0=1', []]
+        else
+          # make_term(foo => {'NOT IN' => []}) => 1=1
+          return ['1=1', []]
+        end
+      else
+        # make_term(foo => { 'IN' => [1,2,3] }) => [foo IN (?,?,?), [1,2,3]]
+        term = "#{self._quote(col)} #{op} (#{(['?'] * v.size).join(', ')})"
+        return [term, v]
+      end
+    else
+      croad("_make_in_term: arguments must be either of query instance or array")
+    end
+  end
+
+  def add(*args)
+    term, bind = self._make_term(*args)
+    self.sql.push "(#{term})" if term
+    self.bind += array_wrap(bind) if bind
+
+    return self # for influent interface
+  end
+
+  def add_raw(*args)
+    term, bind = parse_args(*args)
+    self.sql.push "(#{term})"
+    self.bind += array_wrap(bind) if bind
+    return self
+  end
+
+  def compose_and(other)
+    if self.sql.empty?
+      if other.sql.empty?
+        return SQL::Maker::Condition.new
+      end
+      return SQL::Maker::Condition.new(
+        :sql => ['(' + other.as_sql() + ')'],
+        :bind => other.bind,
+      )
+    end
+    if other.sql.empty?
+      return SQL::Maker::Condition.new(
+        :sql => ['(' + self.as_sql() + ')'],
+        :bind => self.bind,
+      )
+    end
+
+    return SQL::Maker::Condition.new(
+      :sql => ['(' + self.as_sql() + ') AND (' + other.as_sql() + ')'],
+      :bind => self.bind + other.bind,
+    )
+  end
+
+  def compose_or(other)
+    if self.sql.empty?
+      if other.sql.empty?
+        return SQL::Maker::Condition.new
+      end
+      return SQL::Maker::Condition.new(
+        :sql => ['(' + other.as_sql() + ')'],
+        :bind => other.bind,
+      )
+    end
+    if other.sql.empty?
+      return SQL::Maker::Condition.new(
+        :sql => ['(' + self.as_sql() + ')'],
+        :bind => self.bind,
+      )
+    end
+
+    # return value is enclosed with '()'.
+    # because 'OR' operator priority less than 'AND'.
+    return SQL::Maker::Condition.new(
+      :sql => ['((' + self.as_sql() + ') OR (' + other.as_sql() + '))'],
+      :bind => self.bind + other.bind,
+    )
+  end
+
+  def as_sql
+    self.sql.join(' AND ')
+  end
+  alias_method :to_s, :as_sql
+end
+
+__END__
+
+=for test_synopsis
+my (sql, @bind)
+
+=head1 NAME
+
+SQL::Maker::Condition - condition object for SQL::Maker
+
+=head1 SYNOPSIS
+
+    my condition = SQL::Maker::Condition.new(
+        name_sep   => '.',
+        quote_char => '`',
+    )
+    condition.add('foo_id' => 3)
+    condition.add('bar_id' => 4)
+    sql = condition.as_sql() # (`foo_id`=?) AND (`bar_id`=?)
+    @bind = condition.bind()  # (3, 4)
+
+    # add_raw
+    my condition = SQL::Maker::Condition.new(
+        name_sep   => '.',
+        quote_char => '`',
+    )
+    condition.add_raw('EXISTS(SELECT * FROM bar WHERE name = ?)' => ['john'])
+    condition.add_raw('type IS NOT NULL')
+    sql = condition.as_sql() # (EXISTS(SELECT * FROM bar WHERE name = ?)) AND (type IS NOT NULL)
+    @bind = condition.bind()  # ('john')
+
+    # composite and
+    my other = SQL::Maker::Condition.new(
+        name_sep => '.',
+        quote_char => '`',
+    )
+    other.add('name' => 'john')
+    my $comp_and = condition & other
+    sql = $comp_and.as_sql() # ((`foo_id`=?) AND (`bar_id`=?)) AND (`name`=?)
+    @bind = $comp_and.bind()  # (3, 4, 'john')
+
+    # composite or
+    my $comp_or = condition | other
+    sql = $comp_and.as_sql() # ((`foo_id`=?) AND (`bar_id`=?)) OR (`name`=?)
+    @bind = $comp_and.bind()  # (3, 4, 'john')
+
+
+=head1 CONDITION CHEAT SHEET
+
+Here is a cheat sheet for conditions.
+
+    IN:        {'foo'=>'bar'}
+    OUT QUERY: '`foo` = ?'
+    OUT BIND:  ['bar']
+
+    IN:        {'foo'=>['bar','baz']}
+    OUT QUERY: '`foo` IN (?, ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo'=>{'IN' => ['bar','baz']}}
+    OUT QUERY: '`foo` IN (?, ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo'=>{'not IN' => ['bar','baz']}}
+    OUT QUERY: '`foo` NOT IN (?, ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo'=>{'!=' => 'bar'}}
+    OUT QUERY: '`foo` != ?'
+    OUT BIND:  ['bar']
+
+#    IN:        {'foo'=>\'IS NOT NULL'}
+#    OUT QUERY: '`foo` IS NOT NULL'
+#    OUT BIND:  []
+
+    IN:        {'foo'=>{'between' => ['1','2']}}
+    OUT QUERY: '`foo` BETWEEN ? AND ?'
+    OUT BIND:  ['1','2']
+
+    IN:        {'foo'=>{'like' => 'xaic%'}}
+    OUT QUERY: '`foo` LIKE ?'
+    OUT BIND:  ['xaic%']
+
+    IN:        {'foo'=>[{'>' => 'bar'},{'<' => 'baz'}]}
+    OUT QUERY: '(`foo` > ?) OR (`foo` < ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo'=>{:AND => [{'>' => 'bar'},{'<' => 'baz'}]}}
+    OUT QUERY: '(`foo` > ?) AND (`foo` < ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo'=>{:AND => ['foo','bar','baz']}}
+    OUT QUERY: '(`foo` = ?) AND (`foo` = ?) AND (`foo` = ?)'
+    OUT BIND:  ['foo','bar','baz']
+
+    IN:        {'foo_id'=>{'IN' => sql_raw('SELECT foo_id FROM bar WHERE t=?',44)}}
+    OUT QUERY: '`foo_id` IN (SELECT foo_id FROM bar WHERE t=?)'
+    OUT BIND:  [44]
+
+#    IN:        ['foo_id',\['MATCH (col1, col2) AGAINST (?)','apples']]
+#    OUT QUERY: '`foo_id` MATCH (col1, col2) AGAINST (?)'
+#    OUT BIND:  ['apples']
+
+    IN:        {'foo_id'=>nil}
+    OUT QUERY: '`foo_id` IS NULL'
+    OUT BIND:  []
+
+    IN:        {'foo_id'=>{'IN' => []}}
+    OUT QUERY: '0=1'
+    OUT BIND:  []
+
+    IN:        {'foo_id'=>{'NOT IN' => []}}
+    OUT QUERY: '1=1'
+    OUT BIND:  []
+
+#    IN:        ['foo_id', [123,sql_type(\3, SQL_INTEGER)]]
+#    OUT QUERY: '`foo_id` IN (?, ?)'
+#    OUT BIND:  (123, sql_type(\3, SQL_INTEGER))
+#
+#    IN:        ['foo_id', sql_type(\3, SQL_INTEGER)]
+#    OUT QUERY: '`foo_id` = ?'
+#    OUT BIND:  sql_type(\3, SQL_INTEGER)
+#
+#    IN:        ['created_on', { '>', \'DATE_SUB(NOW(), INTERVAL 1 DAY)' }]
+#    OUT QUERY: '`created_on` > DATE_SUB(NOW(), INTERVAL 1 DAY)'
+#    OUT BIND:  
+
+It is also possible to use the functions exported by C<SQL::QueryMaker> to define the conditions.
+
+    IN:        {'foo' => sql_in(['bar','baz'])}
+    OUT QUERY: '`foo` IN (?,?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo' => sql_lt(3)}
+    OUT QUERY: '`foo` < ?'
+    OUT BIND:  [3]
+
+    IN:        {'foo' => sql_not_in(['bar','baz'])}
+    OUT QUERY: '`foo` NOT IN (?,?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo' => sql_ne('bar')}
+    OUT QUERY: '`foo` != ?'
+    OUT BIND:  ['bar']
+
+    IN:        {'foo' => sql_is_not_null()}
+    OUT QUERY: '`foo` IS NOT NULL'
+    OUT BIND:  []
+
+    IN:        {'foo' => sql_between('1','2')}
+    OUT QUERY: '`foo` BETWEEN ? AND ?'
+    OUT BIND:  ['1','2']
+
+    IN:        {'foo' => sql_like('xaic%')}
+    OUT QUERY: '`foo` LIKE ?'
+    OUT BIND:  ['xaic%']
+
+    IN:        {'foo' => sql_or([sql_gt('bar'), sql_lt('baz')])}
+    OUT QUERY: '(`foo` > ?) OR (`foo` < ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo' => sql_and([sql_gt('bar'), sql_lt('baz')])}
+    OUT QUERY: '(`foo` > ?) AND (`foo` < ?)'
+    OUT BIND:  ['bar','baz']
+
+    IN:        {'foo_id' => sql_op('IN (SELECT foo_id FROM bar WHERE t=?)',[44])}
+    OUT QUERY: '`foo_id` IN (SELECT foo_id FROM bar WHERE t=?)'
+    OUT BIND:  [44]
+
+    IN:        {'foo_id' => sql_in([sql_raw('SELECT foo_id FROM bar WHERE t=?',44)])}
+    OUT QUERY: '`foo_id` IN ((SELECT foo_id FROM bar WHERE t=?))'
+    OUT BIND:  [44]
+
+    IN:        {'foo_id' => sql_op('MATCH (@) AGAINST (?)',['apples'])}
+    OUT QUERY: 'MATCH (`foo_id`) AGAINST (?)'
+    OUT BIND:  ['apples']
+
+    IN:        {'foo_id'=>sql_in([])}
+    OUT QUERY: '0=1'
+    OUT BIND:  []
+
+    IN:        {'foo_id'=>sql_not_in([])}
+    OUT QUERY: '1=1'
+    OUT BIND:  []
+
+#    IN:        ['foo_id', sql_type(\3, SQL_INTEGER)]
+#    OUT QUERY: '`foo_id` = ?'
+#    OUT BIND:  sql_type(\3, SQL_INTEGER)
+#
+#    IN:        ['foo_id', sql_in([sql_type(\3, SQL_INTEGER)])]
+#    OUT QUERY: '`foo_id` IN (?)'
+#    OUT BIND:  sql_type(\3, SQL_INTEGER)
+#
+#    IN:        ['created_on', sql_gt(sql_raw('DATE_SUB(NOW(), INTERVAL 1 DAY)')) ]
+#    OUT QUERY: '`created_on` > DATE_SUB(NOW(), INTERVAL 1 DAY)'
+#    OUT BIND:
+
+=head1 SEE ALSO
+
+L<SQL::Maker>
+

data/lib/sql/maker/error.rb

@@ -0,0 +1,3 @@
+class SQL::Maker
+  class Error < StandardError; end
+end

data/lib/sql/maker/helper.rb

@@ -0,0 +1,22 @@
+require 'sql/query_maker'
+require 'sql/maker/select_set'
+
+module SQL::Maker::Helper
+  # SQL::QueryMaker Helper
+  (%w[and or in not_in op raw] + SQL::QueryMaker::FNOP.keys).each do |fn|
+    method = "sql_#{fn}" # sql_and
+    define_method(method) do |*args|
+      SQL::QueryMaker.send(method, *args)
+    end
+    module_function method
+  end
+
+  # SQL::Maker::SelectSet Helper
+  SQL::Maker::SelectSet::FNOP.each do |fn|
+    method = "sql_#{fn}" # sql_union
+    define_method(method) do |*args|
+      SQL::Maker::SelectSet.send(method, *args)
+    end
+    module_function method
+  end
+end

data/lib/sql/maker/quoting.rb

@@ -0,0 +1,138 @@
+# reference: ActiveRecord::ConnectionAdapter::Quoting
+require 'yaml'
+
+module SQL::Maker::Quoting
+  # Quotes the value rather than column name to help prevent
+  # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+  def self.quote(value, column = nil)
+    case value
+    when String
+      value = value.to_s
+      return "'#{quote_string(value)}'" unless column
+
+      case column.type
+      when :integer then value.to_i.to_s
+      when :float then value.to_f.to_s
+      else
+        "'#{quote_string(value)}'"
+      end
+
+    when true, false
+      if column && column.type == :integer
+        value ? '1' : '0'
+      else
+        value ? quoted_true : quoted_false
+      end
+      # BigDecimals need to be put in a non-normalized form and quoted.
+    when nil        then "NULL"
+    when BigDecimal then value.to_s('F')
+    when Numeric    then value.to_s
+    when Date, Time then "'#{quoted_date(value)}'"
+    when Symbol     then "'#{quote_string(value.to_s)}'"
+    when Class      then "'#{value.to_s}'"
+    else
+      "'#{quote_string(YAML.dump(value))}'"
+    end
+  end
+
+  # Cast a +value+ to a type that the database understands. For example,
+  # SQLite does not understand dates, so this method will convert a Date
+  # to a String.
+  def self.type_cast(value, column)
+    return value.id if value.respond_to?(:quoted_id)
+
+    case value
+    when String
+      value = value.to_s
+      return value unless column
+
+      case column.type
+      when :integer then value.to_i
+      when :float then value.to_f
+      else
+        value
+      end
+
+    when true, false
+      if column && column.type == :integer
+        value ? 1 : 0
+      else
+        value ? 't' : 'f'
+      end
+      # BigDecimals need to be put in a non-normalized form and quoted.
+    when nil        then nil
+    when BigDecimal then value.to_s('F')
+    when Numeric    then value
+    when Date, Time then quoted_date(value)
+    when Symbol     then value.to_s
+    else
+      to_type = column ? " to #{column.type}" : ""
+      raise TypeError, "can't cast #{value.class}#{to_type}"
+    end
+  end
+
+  # Quotes a string, escaping any ' (single quote) and \ (backslash)
+  # characters.
+  def self.quote_string(s)
+    s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+  end
+
+  # # def quote_string(s)
+  # def self.define_quote_string
+  #   klass = self.singleton_class
+  #   return if klass.method_defined?(:quote_string)
+  #   if @driver == 'mysql' and defined?(Mysql2::Client)
+  #     klass.send(:define_method, :quote_string) do |s|
+  #       Mysql2::Client.escape(s) if s
+  #     end
+  #   elsif @driver == 'postgresql' and defined?(PG::Connection)
+  #     klass.send(:define_method, :quote_string) do |s|
+  #       PG::Connection.escape_string(s) if s
+  #     end
+  #   else
+  #     # Escape any ' (single quote) and \ (backslash)
+  #     # reference: ActiveRecord::ConnectionAdapter::Quoting
+  #     klass.send(:define_method, :quote_string) do |s|
+  #       s.gsub(/\\/, '\&\&').gsub(/'/, "''") if s # ' (for ruby-mode)
+  #     end
+  #   end
+  # end
+
+  # Quotes the column name. Defaults to no quoting.
+  def self.quote_column_name(column_name)
+    column_name
+  end
+
+  # Quotes the table name. Defaults to column name quoting.
+  def self.quote_table_name(table_name)
+    quote_column_name(table_name)
+  end
+
+  # Override to return the quoted table name for assignment. Defaults to
+  # table quoting.
+  #
+  # This works for mysql and mysql2 where table.column can be used to
+  # resolve ambiguity.
+  #
+  # We override this in the sqlite and postgresql adapters to use only
+  # the column name (as per syntax requirements).
+  def self.quote_table_name_for_assignment(table, attr)
+    quote_table_name("#{table}.#{attr}")
+  end
+
+  def self.quoted_true
+    "'t'"
+  end
+
+  def self.quoted_false
+    "'f'"
+  end
+
+  def self.quoted_date(value)
+    if value.is_a?(Time)
+      # ToDo: getutc support
+      value = value.getlocal
+    end
+    value.strftime("%Y-%m-%d %H:%M:%S") 
+  end
+end