sql-maker 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32ac24cfad827c72f15a9d677d0c7ea6a68317a2
-  data.tar.gz: 51e81c781768b04148522f9408777dd532b4c62b
+  metadata.gz: 32d150cb48d1dafd939ac1562fc6e7a31195172d
+  data.tar.gz: 749f497d5f5a1f5d38a1f1855e575725b862bf9a
 SHA512:
-  metadata.gz: 029d20d44324f0e04c82a68556301dfb31b18e09c3f2e633e9e00f3ab450dddccd8b04fb715af57e489d5bdb2aa81b5dc32980484037170cc2b6d9dfc381965b
-  data.tar.gz: 30e4544a8d797d4b36dd0bde3bd6d342ce9b1d7ca9e63c510930b5d97d5aef298a5f92752d49ac877879f82eacbf86ae1fe0bc5c840f05ca04401e6139961b85
+  metadata.gz: a474871843140b6871e998e583bfe4222a89dc43db85f4a121379438eaf80bb648a36749166f91da4fffa69e8eff9d103f278a39860bf78960eb06e7916c2405
+  data.tar.gz: 994cf90b1c734b301f7fb4c09bdedfe55a8c00bb5ec38530874be625c3f939d7f94c33cea071dae1b6062868d6e4dbcf21decd932978f86c10b8456e1ea517a3

data/.gitignore

@@ -7,7 +7,7 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
+#doc/
 lib/bundler/man
 pkg
 rdoc

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+gemfile:
+  - Gemfile

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.0.3 (2014/06/21)
+
+Fixes:
+
+* require BigDecimal for quoting
+
 ## 0.0.2 (2014/06/18)
 
 Enhancements:

data/Gemfile

@@ -2,3 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in sql-maker.gemspec
 gemspec
+gem 'coveralls', :require => false

data/README.md

@@ -5,10 +5,51 @@
 
 SQL Builder for Ruby
 
+## Installation
+
+Add the following to your `Gemfile`:
+
+```ruby
+gem 'sql-maker'
+```
+
+And then execute:
+
+```plain
+$ bundle
+```
+
+## Example
+
+```ruby
+require 'sql-maker'
+builder = SQL::Maker::Select.new(:quote_char => '"', :auto_bind => true)
+builder.add_select('id').add_from('books').add_where('books.id' => 1).as_sql
+#=> SELECT "id" FROM "books" WHERE "books"."id" = 1
+```
+
+To avoid quoting the column name, use `sql_raw`.
+
+```ruby
+require 'sql-maker'
+include SQL::Maker::Helper # adds sql_raw, etc
+builder = SQL::Maker::Select.new(:quote_char => '"', :auto_bind => true)
+builder.add_select(sql_raw('COUNT(*)')).add_from('books').as_sql
+# => SELECT COUNT(*) FROM "books"
+```
+
+## Further Reading
+
+Please see the [doc](./doc) directory.
+
 ## ChangeLog
 
 See [CHANGELOG.md](CHANGELOG.md) for details.
 
+## ToDo
+
+1. Support plugins
+
 ## Contributing
 
 1. Fork it
@@ -21,3 +62,11 @@ See [CHANGELOG.md](CHANGELOG.md) for details.
 
 Copyright (c) 2014 Naotoshi Seo. See [LICENSE.txt](LICENSE.txt) for details.
 
+## Acknowledgement
+
+Ruby SQL::Maker is a ruby port of following perl modules: 
+
+1. https://github.com/tokuhirom/SQL-Maker
+2. https://github.com/kazuho/SQL-QueryMaker
+
+Thank you very much!!!

data/doc/README.md

@@ -0,0 +1,8 @@
+# SQL::Maker - Index
+
+* [sql/maker.md](./sql/maker.md)
+* [sql/maker/select.md](./sql/maker/select.md)
+* [sql/maker/condition.md](./sql/maker/condition.md)
+* [sql/maker/helper.md](./sql/maker/helper.md)
+* [sql/maker/select_set.md](./sql/maker/select_set.md)
+* [sql/queyr_maker.md](./sql/maker.md)

data/doc/sql/maker.md

@@ -0,0 +1,314 @@
+# NAME
+
+SQL::Maker - Yet another SQL builder
+
+# SYNOPSIS
+
+    use SQL::Maker
+
+    builder = SQL::Maker.new(
+        :driver => 'SQLite', # or your favorite driver
+    )
+
+    # SELECT
+    sql, bind = builder.select(table, fields, where, opt)
+
+    # INSERT
+    sql, bind = builder.insert(table, values, opt)
+
+    # DELETE
+    sql, bind = builder.delete(table, where, opt)
+
+    # UPDATE
+    sql, bind = builder.update(table, set, where)
+    sql, bind = builder.update(table, set, where)
+
+# DESCRIPTION
+
+SQL::Maker is yet another SQL builder class.
+
+# METHODS
+
+
+
+## builder = SQL::Maker.new(args)
+
+Create new instance of SQL::Maker.
+
+Attributes are the following:
+
+
+
+### driver: Str
+
+Driver name is required. The driver type is needed to create SQL string.
+
+### quote_char: Str
+
+This is the character that a table or column name will be quoted with.
+
+Default: auto detect from driver.
+
+### name_sep: Str
+
+This is the character that separates a table and column name.
+
+Default: '.'
+
+### new_line: Str
+
+This is the character that separates a part of statements.
+
+Default: '\n'
+
+### strict: Bool
+
+In strict mode, all the expressions must be declared by using instances of SQL::QueryMaker
+
+Default: false
+
+
+
+## sql, bind = builder.select(table|tables, fields, where, opt)
+
+    sql, bind = builder.select('user', ['*'], {:name => 'john'}, {:order_by => 'user_id DESC'})
+    # =>
+    #   SELECT * FROM `user` WHERE (`name` = ?) ORDER BY user_id DESC
+    #   ['john']
+
+This method returns the SQL string and bind variables for a SELECT statement.
+
+
+
+### table
+
+Table name for the FROM clause as scalar or arrayref. You can specify the instance of SQL::Maker::Select for a sub-query.
+
+If you are using opt[:joins] >> this should be I<< undef since it's passed via the first join.
+
+### fields
+
+This is a list for retrieving fields from database.
+
+Each element of the fields is normally an array of column names.
+If you want to specify an alias of the field, you can use an array of hashes containing a pair
+of column and alias names (e.g. ['foo.id' => 'foo_id']).
+
+### where
+
+where clause from hash or array via SQL::Maker::Condition, or SQL::Maker::Condition object.
+
+### opt
+
+These are the options for the SELECT statement
+
+
+
+### opt[:prefix]
+
+This is a prefix for the SELECT statement.
+
+For example, you can provide the 'SELECT SQL_CALC_FOUND_ROWS '. It's useful for MySQL.
+
+Default Value: 'SELECT '
+
+### opt[:limit]
+
+This option adds a 'LIMIT n' clause.
+
+### opt[:offset]
+
+This option adds an 'OFFSET n' clause.
+
+### opt[:order_by]
+
+This option adds an ORDER BY clause
+
+You can write it in any of the following forms:
+
+    builder.select(..., {:order_by => 'foo DESC, bar ASC'})
+    builder.select(..., {:order_by => ['foo DESC', 'bar ASC']})
+    builder.select(..., {:order_by => {:foo => 'DESC'}})
+    builder.select(..., {:order_by => [{:foo => 'DESC'}, {:bar => 'ASC'}]})
+
+### opt[:group_by]
+
+This option adds a GROUP BY clause
+
+You can write it in any of the following forms:
+
+    builder.select(..., {:group_by => 'foo DESC, bar ASC'})
+    builder.select(..., {:group_by => ['foo DESC', 'bar ASC']})
+    builder.select(..., {:group_by => {:foo => 'DESC'}})
+    builder.select(..., {:group_by => [{:foo => 'DESC'}, {:bar => 'ASC'}]})
+
+### opt[:having]
+
+This option adds a HAVING clause
+
+### opt[:for_update]
+
+This option adds a 'FOR UPDATE" clause.
+
+### opt[:joins]
+
+This option adds a 'JOIN' via SQL::Maker::Select.
+
+You can write it as follows:
+
+    builder.select(nil, ..., {:joins => [[:user => {:table => 'group', :condition => 'user.gid = group.gid'}], ...]})
+
+### opt[:index_hint]
+
+This option adds an INDEX HINT like as 'USE INDEX' clause for MySQL via SQL::Maker::Select.
+
+You can write it as follows:
+
+    builder.select(..., { :index_hint => 'foo' })
+    builder.select(..., { :index_hint => ['foo', 'bar'] })
+    builder.select(..., { :index_hint => { :list => 'foo' })
+    builder.select(..., { :index_hint => { :type => 'FORCE', :list => ['foo', 'bar'] })
+
+
+
+
+
+## sql, bind = builder.insert(table, values, opt);
+
+    sql, bind = builder.insert(:user, {:name => 'john'})
+    # =>
+    #    INSERT INTO `user` (`name`) VALUES (?)
+    #    ['john']
+
+Generate an INSERT query.
+
+
+
+### table
+
+Table name
+
+### values
+
+These are the values for the INSERT statement.
+
+### opt
+
+These are the options for the INSERT statement
+
+
+
+### opt[:prefix]
+
+This is a prefix for the INSERT statement.
+
+For example, you can provide 'INSERT IGNORE INTO' for MySQL.
+
+Default Value: 'INSERT INTO'
+
+
+
+
+
+## sql, bind = builder.delete(table, where, opt)
+
+    sql, bind = builder.delete(table, where)
+    # =>
+    #    DELETE FROM `user` WHERE (`name` = ?)
+    #    ['john']
+
+Generate a DELETE query.
+
+
+
+### table
+
+Table name
+
+### where
+
+where clause from hash or array, or SQL::Maker::Condition object.
+
+### opt
+
+These are the options for the DELETE statement
+
+
+
+### opt[:using]
+
+This option adds a USING clause. It takes a scalar or an arrayref of table names as argument:
+
+    (sql, bind) = bulder.delete(table, where, { :using => 'group' })
+    # =>
+    #    DELETE FROM `user` USING `group` WHERE (`group`.`name` = ?)
+    #    ['doe']
+    bulder.delete(..., { :using => ['bar', 'qux'] })
+
+
+
+
+
+## sql, bind = builder.update(table, set, where)
+
+Generate a UPDATE query.
+
+    sql, bind = builder.update('user', ['name' => 'john', :email => 'john@example.com'], {:user_id => 3})
+    # =>
+    #    'UPDATE `user` SET `name` = ?, `email` = ? WHERE (`user_id` = ?)'
+    #    ['john','john@example.com',3]
+
+
+
+### table
+
+Table name
+
+### set
+
+Setting values.
+
+### where
+
+where clause from a hash or array, or SQL::Maker::Condition object.
+
+
+
+## select = builder.new_select(args)
+
+Create new instance of SQL::Maker::Select using the settings from builder.
+
+This method returns an instance of SQL::Maker::Select.
+
+## builder.new_condition()
+
+Create new SQL::Maker::Condition object from  builder  settings.
+
+## sql, bind = builder.where(where)
+
+Where clause from a hash or array, or SQL::Maker::Condition object.
+
+
+
+# PLUGINS
+
+SQL::Maker features a plugin system. Write the code as follows:
+
+    require 'sql/maker'
+    SQL::Maker.load_plugin('insert_multi')
+
+# FAQ
+
+
+
+### Why don't you use Arel or ActiveRecord?
+
+I wanted a query builder rather than ORM.
+
+I wanted simpler one than Arel.
+
+
+
+# SEE ALSO
+
+Perl version is located at https://github.com/tokuhirom/SQL-Maker

data/doc/sql/maker/condition.md

@@ -0,0 +1,186 @@
+# NAME
+
+SQL::Maker::Condition - condition object for SQL::Maker
+
+# 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')
+    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
+    comp_or = condition | other
+    sql = comp_and.as_sql # ((`foo_id`=?) AND (`bar_id`=?)) OR (`name`=?)
+    bind = comp_and.bind  # (3, 4, 'john')
+
+
+# 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'=>{'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'=>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',\['MATCH (col1, col2) AGAINST (?)','apples']]
+    # OUT QUERY: '`foo_id` MATCH (col1, col2) AGAINST (?)'
+    # OUT BIND:  ['apples']
+
+    # 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 SQL::Maker::Helper 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: