sql-maker 0.0.2 → 0.0.3

data/lib/sql/maker/quoting.rb

@@ -1,5 +1,6 @@
 # reference: ActiveRecord::ConnectionAdapter::Quoting
 require 'yaml'
+require 'bigdecimal'
 
 module SQL::Maker::Quoting
   # Quotes the value rather than column name to help prevent

data/lib/sql/maker/select.rb

@@ -302,7 +302,7 @@ class SQL::Maker::Select
     col, val = parse_args(*args)
     col = col.to_s
     if orig = self.select_map_reverse[col]
-      col = orig
+      col = orig.respond_to?(:as_sql) ? orig.as_sql : orig
     end
 
     self.having ||= self.new_condition()
@@ -332,214 +332,3 @@ class SQL::Maker::Select
     return quoted
   end
 end
-
-__END__
-
-=head1 NAME
-
-SQL::Maker::Select - dynamic SQL generator
-
-=head1 SYNOPSIS
-
-    sql = SQL::Maker::Select.new
-                                  .add_select('foo')
-                                  .add_select('bar')
-                                  .add_select('baz')
-                                  .add_from('table_name' => 't')
-                                  .as_sql
-    # => "SELECT foo, bar, baz FROM table_name t"
-
-=head1 DESCRIPTION
-
-=head1 METHODS
-
-=over 4
-
-=item C<< sql = stmt.as_sql(); >>
-
-Render the SQL string.
-
-=item C<< @bind = stmt.bind(); >>
-
-Get the bind variables.
-
-=item C<< stmt.add_select('*') >>
-
-=item C<< stmt.add_select(:col => alias) >>
-
-=item C<< stmt.add_select(\'COUNT(*)' => 'cnt') >>
-
-Add a new select term. It's automatically quoted.
-
-=item C<< stmt.add_from(table :Str | select :SQL::Maker::Select) : SQL::Maker::Select >>
-
-Add a new FROM clause. You can specify the table name or an instance of L<SQL::Maker::Select> for a sub-query.
-
-I<Return:> stmt itself.
-
-=item C<< stmt.add_join(:user => {:type => 'inner', :table => 'config', :condition => 'user.user_id = config.user_id'}); >>
-
-=item C<< stmt.add_join(:user => {:type => 'inner', :table => 'config', :condition => {'user.user_id' => 'config.user_id'}); >>
-
-=item C<< stmt.add_join(:user => {:type => 'inner', :table => 'config', :condition => ['user_id']}); >>
-
-Add a new JOIN clause. If you pass an arrayref for 'condition' then it uses 'USING'. If 'type' is omitted
-it falls back to plain JOIN.
-
-    stmt = SQL::Maker::Select.new
-    stmt.add_join(
-        :user => {
-            :type      => 'inner',
-            :table     => 'config',
-            :condition => 'user.user_id = config.user_id',
-        }
-    )
-    stmt.as_sql
-    # => 'FROM user INNER JOIN config ON user.user_id = config.user_id'
-
-    stmt = SQL::Maker::Select.new(:quote_char => '`', :name_sep => '.')
-    stmt.add_join(
-        :user => {
-            :type      => 'inner',
-            :table     => 'config',
-            :condition => {'user.user_id' => 'config.user_id'},
-        }
-    )
-    stmt.as_sql
-    # => 'FROM `user` INNER JOIN `config` ON `user`.`user_id` = `config`.`user_id`'
-
-    stmt = SQL::Maker::Select.new
-    stmt.add_select('name')
-    stmt.add_join(
-        :user => {
-            :type      => 'inner',
-            :table     => 'config',
-            :condition => ['user_id'],
-        }
-    )
-    stmt.as_sql
-    # => 'SELECT name FROM user INNER JOIN config USING (user_id)'
-
-    subquery = SQL::Maker::Select.new
-    subquery.add_select('*')
-    subquery.add_from( 'foo' )
-    subquery.add_where( 'hoge' => 'fuga' )
-    stmt = SQL::Maker::Select.new
-    stmt.add_join(
-        [ subquery, 'bar' ] => {
-            :type      => 'inner',
-            :table     => 'baz',
-            :alias     => 'b1',
-            :condition => 'bar.baz_id = b1.baz_id'
-        },
-    )
-    stmt.as_sql
-    # => "FROM (SELECT * FROM foo WHERE (hoge = ?)) bar INNER JOIN baz b1 ON bar.baz_id = b1.baz_id"
-
-=item C<< stmt.add_index_hint(:foo => {:type => 'USE', :list => ['index_hint']}); >>
-
-=item C<< stmt.add_index_hint(:foo => 'index_hint'); >>
-
-=item C<< stmt.add_index_hint(:foo => ['index_hint']); >>
-
-    stmt = SQL::Maker::Select.new
-    stmt.add_select('name')
-    stmt.add_from('user')
-    stmt.add_index_hint(:user => {:type => 'USE', :list => ['index_hint']})
-    stmt.as_sql
-    # => "SELECT name FROM user USE INDEX (index_hint)"
-
-=item C<< stmt.add_where('foo_id' => 'bar'); >>
-
-Add a new WHERE clause.
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .add_where('name' => 'john')
-                                 .add_where('type' => {:IN => %w/1 2 3/})
-                                 .as_sql
-    # => "SELECT c FROM foo WHERE (name = ?) AND (type IN (?, ?, ?))"
-
-=item C<< stmt.add_where_raw('id = ?', [1]) >>
-
-Add a new WHERE clause from raw placeholder string and bind variables.
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .add_where_raw('EXISTS(SELECT * FROM bar WHERE name = ?)' => ['john'])
-                                 .add_where_raw('type IS NOT NULL')
-                                 .as_sql
-    # => "SELECT c FROM foo WHERE (EXISTS(SELECT * FROM bar WHERE name = ?)) AND (type IS NOT NULL)"
-
-
-=item C<< stmt.set_where(condition) >>
-
-Set the WHERE clause.
-
-condition should be instance of L<SQL::Maker::Condition>.
-
-    cond1 = SQL::Maker::Condition.new.add("name" => "john")
-    cond2 = SQL::Maker::Condition.new.add("type" => {:IN => %w/1 2 3/})
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .set_where(cond1 & cond2)
-                                 .as_sql
-    # => "SELECT c FROM foo WHERE ((name = ?)) AND ((type IN (?, ?, ?)))"
-
-=item C<< stmt.add_order_by('foo'); >>
-
-=item C<< stmt.add_order_by({'foo' => 'DESC'}); >>
-
-Add a new ORDER BY clause.
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .add_order_by('name' => 'DESC')
-                                 .add_order_by('id')
-                                 .as_sql
-    # => "SELECT c FROM foo ORDER BY name DESC, id"
-
-=item C<< stmt.add_group_by('foo'); >>
-
-Add a new GROUP BY clause.
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .add_group_by('id')
-                                 .as_sql
-    # => "SELECT c FROM foo GROUP BY id"
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .add_group_by('id' => 'DESC')
-                                 .as_sql
-    # => "SELECT c FROM foo GROUP BY id DESC"
-
-=item C<< stmt.limit(30) >>
-
-=item C<< stmt.offset(5) >>
-
-Add LIMIT and OFFSET.
-
-    stmt = SQL::Maker::Select.new.add_select('c')
-                                 .add_from('foo')
-                                 .limit(30)
-                                 .offset(5)
-                                 .as_sql
-    # => "SELECT c FROM foo LIMIT 30 OFFSET 5"
-
-=item C<< stmt.add_having(:cnt => 2) >>
-
-Add a HAVING clause.
-
-#    stmt = SQL::Maker::Select.new.add_from('foo')
-#                                 .add_select(\'COUNT(*)' => 'cnt')
-#                                 .add_having(:cnt => 2)
-#                                 .as_sql
-#    # => "SELECT COUNT(*) AS cnt FROM foo HAVING (COUNT(*) = ?)"
-
-=back
-
-=head1 SEE ALSO
-
-L<Data::ObjectDriver::SQL>

data/lib/sql/maker/select_set.rb

@@ -76,119 +76,3 @@ class SQL::Maker::SelectSet
     self # method chain
   end
 end
-
-__END__
-
-=head1 NAME
-
-SQL::Maker::SelectSet - provides set functions
-
-=head1 SYNOPSIS
-
-    use SQL::Maker::SelectSet qw(union_all except)
-    s1 = SQL::Maker::Select .new()
-                                .add_select('foo')
-                                .add_from('t1')
-    s2 = SQL::Maker::Select .new()
-                                .add_select('bar')
-                                .add_from('t2')
-    union_all( s1, s2 ).as_sql
-    # =>
-    #  SQL::Maker::SelectSet.new_set(
-    #      :operator => 'UNION ALL',
-    #      :new_line => s1.new_line
-    #  ).add_statement(s1)
-    #   .add_statement(s2)
-    #   .as_sql
-    # => "SELECT foo FROM t1 UNION ALL SELECT bar FROM t2"
-    except( s1, s2 ).as_sql
-    # => SQL::Maker::SelectSet.new_set( :operator => 'EXCEPT', :new_line => s1.new_line )
-    #     .add_statement( s1 )
-    #     .add_statement( s2 )
-    #     .as_sql
-    # => "SELECT foo FROM t1 EXCEPT SELECT bar FROM t2"
-
-=head1 DESCRIPTION
-
-This module provides some set functions which return a SQL::Maker::SelectSet object
-inherited from L<SQL::Maker::Select>.
-
-=head1 FUNCTION
-
-=over 4
-
-=item C<< union(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<UNION>.
-
-=item C<< union_all(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<UNION ALL>.
-
-=item C<< intersect(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<INTERSECT>.
-
-=item C<< intersect_all(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<INTERSECT ALL>.
-
-=item C<< except(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<EXCEPT>.
-
-=item C<< except(select :SQL::Maker::Select | set :SQL::Maker::SelectSet) : SQL::Maker::SelectSet >>
-
-Tow statements are combined by C<EXCEPT ALL>.
-
-=back
-
-=head1 Class Method
-
-=over 4
-
-=item stmt = SQL::Maker::SelectSet.new( %args )
-
-opretaor is a set operator (ex. C<UNION>).
-one and another are SQL::Maker::Select object or SQL::Maker::SelectSet object.
-It returns a SQL::Maker::SelectSet object.
-
-The parameters are:
-
-=over 4
-
-=item new_line
-
-Default values is "\n".
-
-=item operator : Str
-
-The operator. This parameter is required.
-
-=back
-
-=back
-
-=head1 Instance Methods
-
-=over 4
-
-=item C<< sql = set.as_sql() : Str >>
-
-Returns a new select statement.
-
-=item C<< @bind = set.bind() : Array[Str] >>
-
-Returns bind variables.
-
-=item C<< set.add_statement(stmt : stmt.can('as_sql')) : SQL::Maker::SelectSet >>
-
-This method adds new statement object. C<< stmt >> must provides 'as_sql' method.
-
-I<Return Value> is the set itself.
-
-=back
-
-=head1 SEE ALSO
-
-L<SQL::Maker::Select>

data/lib/sql/query_maker.rb

@@ -161,6 +161,8 @@ class SQL::QueryMaker
       }, bind)
     end
 
+    # sql_raw('SELECT foo_id FROM bar WHERE t=44')
+    # sql_raw('SELECT foo_id FROM bar WHERE t=?', [44])
     def sql_raw(*args)
       sql, bind = parse_args(*args)
       return SQL::QueryMaker.new(nil, Proc.new { sql }, bind)
@@ -206,224 +208,3 @@ class SQL::QueryMaker
     label.to_s.split(/\./).map {|e| "`#{e}`"}.join('.')
   end
 end
-
-__END__
-
-=head1 NAME
-
-SQL::QueryMaker - helper functions for SQL query generation
-
-=head1 SYNOPSIS
-
-    query = sql_eq(:foo => v)
-    query.as_sql                 # `foo`=?
-    query.bind                   # (v)
-
-    query = sql_lt(:foo => v)
-    query.as_sql                 # `foo`<?
-    query.bind                   # (v)
-
-    query = sql_in(:foo => [
-        v1, v2, v3,
-    ])
-    query.as_sql                 # `foo` IN (?,?,?)
-    query.bind                   # (v1,v2,v3)
-
-    query = sql_and(:foo => [
-        sql_ge(min),
-        sql_lt(max)
-    ])
-    query.as_sql                 # `foo`>=? AND `foo`<?
-    query.bind                   # (min,max)
-
-    query = sql_and([
-        sql_eq(:foo => v1),
-        sql_eq(:bar => v2)
-    ]
-    query.as_sql                 # `foo`=? AND `bar`=?
-    query.bind                   # (v1,v2)
-
-    query = sql_and([
-        :foo => v1,
-        :bar => sql_lt(v2),
-    ])
-    query.as_sql                 # `foo`=? AND `bar`<?
-    query.bind                   # (v1,v2)
-
-=head1 DESCRIPTION
-
-This module concentrates on providing an expressive, concise way to declare SQL
-expressions by exporting carefully-designed functions.
-It is possible to use the module to generate SQL query conditions and pass them
-as arguments to other more versatile query builders such as L<SQL::Maker>.
-
-The functions exported by the module instantiate comparator objects that build
-SQL expressions when their C<as_sql> method are being invoked.
-There are two ways to specify the names of the columns to the comparator; to
-pass in the names as argument or to specify then as an argument to the
-C<as_sql> method.
-
-=head1 FUNCTIONS
-
-=head2 C<< sql_eq([column,] value) >>
-
-=head2 C<< sql_lt([column,] value) >>
-
-=head2 C<< sql_gt([column,] value) >>
-
-=head2 C<< sql_le([column,] value) >>
-
-=head2 C<< sql_ge([column,] value) >>
-
-=head2 C<< sql_like([column,] value) >>
-
-=head2 C<< sql_is_null([column]) >>
-
-=head2 C<< sql_is_not_null([column]) >>
-
-=head2 C<< sql_not([column]) >>
-
-=head2 C<< sql_between([column,] min_value, max_value) >>
-
-=head2 C<< sql_not_between([column,] min_value, max_value) >>
-
-=head2 C<< sql_in([column,] \@values) >>
-
-=head2 C<< sql_not_in([column,] \@values) >>
-
-Instantiates a comparator object that tests a column against given value(s).
-
-=head2 C<< sql_and([column,] \@conditions) >>
-
-=head2 C<< sql_or([$ column,] \@conditions) >>
-
-Aggregates given comparator objects into a logical expression.
-
-If specified, the column name is pushed down to the arguments when the
-C<as_sql> method is being called, as show in the second example below.
-
-    sql_and([                   # => `foo`=? AND `bar`<?
-        sql_eq("foo" => v1),
-        sql_lt("bar" => v2)
-    ])
-
-    sql_and("foo" => [          # => `foo`>=min OR `foo`<max
-        sql_ge(min),
-        sql_lt(max),
-    ])
-
-=head2 C<< sql_and(\%conditions) >>
-
-=head2 C<< sql_or(\%conditions) >>
-
-Aggregates given pairs of column names and comparators into a logical
-expression.
-
-The value part is composed of as the argument to the C<=> operator if it is
-not a blessed reference.
-
-    query = sql_and({
-        :foo => 'abc',
-        :bar => sql_lt(123),
-    })
-    query.as_sql             # => `foo`=? AND bar<?
-    query.bind               # => ('abc', 123)
-
-
-=head2 C<< sql_op([column,] op_sql, \@bind_values) >>
-
-Generates a comparator object that tests a column using the given SQL and
-values.  C<<@>> in the given SQL are replaced by the column name (specified
-either by the argument to the function or later by the call to the C<<as_sql>>
-method), and C<<?>> are substituted by the given bind values.
-
-=head2 C<< sql_raw(sql, @bind_values) >>
-
-Generates a comparator object from raw SQL and bind values.  C<<?>> in the
-given SQL are replaced by the bind values.
-
-=head2 C<< obj.as_sql() >>
-
-=head2 C<< obj.as_sql(column_name) >>
-
-=head2 C<< obj.as_sql(column_name, quote_identifier_cb) >>
-
-Compiles given comparator object and returns an SQL expression.
-Corresponding bind values should be obtained by calling the C<bind> method.
-
-The function optionally accepts a column name to which the comparator object
-should be bound; an error is thrown if the comparator object is already bound
-to another column.
-
-The function also accepts a callback for quoting the identifiers.  If omitted,
-the identifiers are quoted using C<`> after being splitted using C<.>; i.e. a
-column designated as C<foo.bar> is quoted as C<`foo`.`bar`>.
-
-=head2 C<< obj.bind() >>
-
-Returns a list of bind values corresponding to the SQL expression returned by
-the C<as_sql> method.
-
-=head1 CHEAT SHEET
-
-    IN:        sql_eq('foo' => 'bar')
-    OUT QUERY: '`foo` = ?'
-    OUT BIND:  ['bar']
-
-    IN:        sql_in('foo' => ['bar', 'baz'])
-    OUT QUERY: '`foo` IN (?,?)'
-    OUT BIND:  ['bar','baz']
-
-    IN:        sql_and([sql_eq('foo' => 'bar'), sql_eq('baz' => 123)])
-    OUT QUERY: '(`foo` = ?) AND (`baz` = ?)'
-    OUT BIND:  ['bar',123]
-
-    IN:        sql_and('foo' => [sql_ge(3), sql_lt(5)])
-    OUT QUERY: '(`foo` >= ?) AND (`foo` < ?)'
-    OUT BIND:  [3,5]
-
-    IN:        sql_or([sql_eq('foo' => 'bar'), sql_eq('baz' => 123)])
-    OUT QUERY: '(`foo` = ?) OR (`baz` = ?)'
-    OUT BIND:  ['bar',123]
-
-    IN:        sql_or('foo' => ['bar', 'baz'])
-    OUT QUERY: '(`foo` = ?) OR (`foo` = ?)'
-    OUT BIND:  ['bar','baz']
-
-    IN:        sql_is_null('foo')
-    OUT QUERY: '`foo` IS NULL'
-    OUT BIND:  []
-
-    IN:        sql_is_not_null('foo')
-    OUT QUERY: '`foo` IS NOT NULL'
-    OUT BIND:  []
-
-    IN:        sql_between('foo', 1, 2)
-    OUT QUERY: '`foo` BETWEEN ? AND ?'
-    OUT BIND:  [1,2]
-
-    IN:        sql_not('foo')
-    OUT QUERY: 'NOT `foo`'
-    OUT BIND:  []
-
-    IN:        sql_op('apples', 'MATCH (@) AGAINST (?)', ['oranges'])
-    OUT QUERY: 'MATCH (`apples`) AGAINST (?)'
-    OUT BIND:  ['oranges']
-
-    IN:        sql_raw('SELECT * FROM t WHERE id=?',123)
-    OUT QUERY: 'SELECT * FROM t WHERE id=?'
-    OUT BIND:  [123]
-
-    IN:        sql_in('foo' => [123,sql_raw('SELECT id FROM t WHERE cat=?',5)])
-    OUT QUERY: '`foo` IN (?,(SELECT id FROM t WHERE cat=?))'
-    OUT BIND:  [123,5]
-
-=head1 AUTHOR
-
-Natoshi Seo (Originally designed by Kazuho Oku as a Perl module)
-
-=head1 LICENSE
-
-This library is free software; you can redistribute it and/or modify it under the MIT License.
-
-=cut