terrazine 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1a24d3310a23b60eb51584c7fdcec61a03c2b58
-  data.tar.gz: 3be3456371d57ae8b67918d5d3b09a6447ff9194
+  metadata.gz: d761b9fb0ee69306c68a075791804e9394be557a
+  data.tar.gz: 7413cc5841e648c59fee3163ca2841273efecbc1
 SHA512:
-  metadata.gz: c5a940bf57c92d76934211d9f6bbcca8ec9ed0bd8e42f6f788feb817309c6dcf3edb1d3f567718d1c847c051efc992a85e89ff985b86969d2ae3a114ab80a58a
-  data.tar.gz: 92462094a13958703b45b35305b5cc1107db055119a0847cfd2a5a34bf59d63525be94d3309e4972985e24ad5926ab2b29addb916fd1e7732eebf2f7b457abed
+  metadata.gz: 15259c4c4f582b13fcbcbfeca042398d97cfe554abd96ae291f8e38c523e188a0b7954666c6940c4254ee92e8886071647551a6b52b759d9891f045f7d6c3113
+  data.tar.gz: 032c017527f3bdf2b44a7ee2a6b69c4ae5a62306cdc5a3f49fa43e2b224271d6668f75bf1d62419a32fc8fdf0e4fa5db1608260db0cc839a0105266a7ae3d2e5

data/Gemfile

@@ -1 +1,8 @@
+source 'https://rubygems.org'
+
 gem 'pg-hstore', '1.2.0'
+
+group :test do
+  gem 'pg', '1.0.0'
+  gem 'rspec'
+end

data/README.md

@@ -14,20 +14,51 @@ Get result and access any returned data rails like syntax.
 
 #### Realization
 This is my first gem and first close meeting with OOP... I would appreciate any help =)
-And sorry for my English =(
+And sorry for my English =(  
+
+#### Readiness
+Terrazine is not finished yet. Now it has allmost full SELECT builder, but with some limitations like:
+- awfull where syntax
+- bad join syntax
+- not all SQL functions supported  
+
+And now it supports only Postgresql.
 
 ## Detailed description
 
 ### Usage
-Describe whole data structure, or create `Constructor` instance and combine parts of data by it instance methods. Then send result to `Terrazine.send_request(structure||constructor, params = {})` and it will return you `Terrazine::Result` instance. (description will be soon)
+#### Initialization
+Add this line to the Gemfile  
+```ruby
+gem 'terrazine', '0.0.2'
+```  
+After server initialization set `Terrazine.config`. Now config accepts only `:connection` option. In the bright future will be added `:adapter` option support.  
+In rails you can set config with [after_initialize](https://apidock.com/rails/Rails/Configuration/after_initialize) and it will looks like:  
+
+UPD: On production, rails closing `PG::Connection` from `after_initialize`, as fast fix connection now can be `Proc` object which must return `PG::Connection`. Later i'll try to find better solution  
+```ruby
+# file config/application.rb
+module Name
+  class Application < Rails::Application
+  # ....
+    config.after_initialize do
+      Terrazine.config connection: -> { ActiveRecord::Base.connection.raw_connection }
+    end
+  # ....
+  end
+end
+```  
+#### Workflow
+- Describe whole data structure, or create `Constructor` instance and combine parts of data by it instance methods. 
+- Send result to `Terrazine.send_request(structure||constructor, params = {})` 
+- Rejoice at the `::Result`
 
 ### Constructor
 You can create Constructor instance by calling `Terrazine.new_constructor`. It optional accepts data structure.  
-
 ```ruby
 constructor = Terrazine.new_constructor
 constructor_2 = Terrazine.new_constructor from: :calls
-```
+```  
 #### Instance methods
 Instance methods write or combine data inside constructor instance.
 Not finished methods - just rewrites structure without combination with existing data.  
@@ -42,90 +73,209 @@ Not finished methods - just rewrites structure without combination with existing
 - [x] build_sql
 
 ### Data Structures
+You can take a look on more detailed examples in `spec/constructor_spec.rb`
 
-#### Select
-Accepts 
+#### Common patterns
+###### SQL Function
+Structure:
+- `Array`
+  - first element - `Symbol` that begins from _ - `:_nullif`
+  - arguments
+    - [columns](#columns)  
+
+```ruby
+[:_count, [:_nullif, :row, [:_params, 'mrgl']]] # TODO: param?
+# => ['COUNT(NULLIF(row, $1))', ['mrgl']]
+```  
+[Detailed Functions description](#sql-functions).  
+###### Columns
+Possible structures:
+- `String`
+  - if it locted in the `Hash` with table alias, table alias will be added to it
+  - if there is no table alias it will be returned to the builder as it is.
+- `Symbol` - just parsed to string
+- `Hash`
+  - key - table alias||name
+  - value - [columns](#columns)
+- [SQL function](#sql-function)
+- `Array` - holder of any possible structures  
+```ruby
+['name', {u: ['role', 'u.phone, m.rating', :field]}]
+# => 'name, u.role, u.phone, m.rating, u.field'
+```  
+[Detailed Select description](#select)
+###### Tables
+Possible structures:
 - `String` || `Symbol`
-- `Hash` represents column alias - 'AS' (if key begins from `_`) OR table alias that will join to the values table prefix OR another data structure(present keyword `:select`).
-- Another `Constructor` or `Hash` representing data structure
-- `Array` can contain all of the above structures OR in case of first symbol/string begins from `_` it will represent SQL function  
+- [SQL function](#sql-function)
+- `Array`
+  - if there is no `Array` inside it will be joined `structure.join ' '`
+  - otherwise it will be recursive mapped  
 ```ruby
+['users u', [:_values, ...], [:masters, :m]]
+'users u, (VALUES...), masters m'
+```   
+###### Conditions
+Not finished yet...
+Column can be described as `:u__name => 'u.name'` or `:name`
+Possible structures:
+- `String` passes as it is
+- `Hash` represent sql `=` or `IN` if value is `Array`. TODO: `IS` in case of `nil` or `false`
+  - `Symbol` - column name
+  - `Array` - only as value! will be placed in querry params `($1)`.
+  - `String` - will be placed in querry params
+- `Array`
+  - first element - `Symbol` operator representation, by default `:and`
+    - `eq` - `=`
+    - `or`, `and`
+    - `in`
+    - `not`
+    - `like`, `ilike`
+    - `reg` - `~`, `reg_i` - `~*`, `reg_f` - `!~`, `reg_fi` - `!~*`
+  - arguments
+- `Array` - holder of any possible structures  
+```ruby
+[[:not, 'z = 13'],
+ [:or, 'mrgl = 2', 'rgl = 22'],
+ [:or, 'rgl = 12', 'zgl = lol']]
+# => 'NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = lol)'
+[{ role: 'manager', id: [0, 1, 153] },
+ [:not, [:like, :u__name, 'Aeonax']]]
+#=> 'role = $1 AND id IN ($2) AND NOT u.name LIKE $3', ['manager', [0, 1, 153], 'Aeonax']
+```  
+###### Sub Querry
+Possible structures:
+- `Constructor` instance
+- `Hash` with `:select` value  
+
+#### Select
+Possible structures:
+- [columns](#columns)
+- [sub querry](#sub-query)
+- [SQL function](#sql-function)
+- `Array` with combination of possible structures.  
+```ruby
+# String
 constructor.select "name, email"
+# Symbol
 constructor.select :birthdate
+# Array as columns
+constructor.select [:phone, 'role']
+# Array as SQL function
+constructor.select [:_nullif, :row, :value]
+# Hash with column alias(`AS`) as key and any available for `select` value
+constructor.select _missed_calls_count:
+                     { select: [:_count, [:_nullif, :connected, :true]],
+                       from: [:calls, :c],
+                       where: ['c.client_id = u.id',
+                               ['direction = ?', 0]]}
+# Hash with table alias as key and any available for `select` values
 constructor.select m: [:common_rating, :work_rating, { _master_id: :id }]
-constructor.select { _missed_calls_count: { select: [:_count, [:_nullif, :connected, :true]],
-                                           from: [:calls, :c],
-                                           where: ['c.client_id = u.id',
-                                                   ['direction = ?', 0]]} }
+# You can take a look of resulted data structure. In future, perhaps, Constructor will be more complicated and it will merge hashes...
 constructor.structure
-# => { select: ['name, email', :birthdate,
-#               { m: [:common_rating, :work_rating, { _master_id: :id }] },
+# => { select: ['name, email', :birthdate, :phone, 'role',
+#               [:_nullif, :row, :value],
 #               { _missed_calls_count: { select: [:_count, [:_nullif, :connected, :true]],
 #                                        from: [:calls, :c],
 #                                        where: ['c.client_id = u.id',
-#                                                ['direction = ?', 0]]} }] }
+#                                                ['direction = ?', 0]]} }] },
+#               { m: [:common_rating, :work_rating, { _master_id: :id }] }
 
 constructor.build_sql
-# => ['SELECT name, email, birthdate, m.common_rating, m.work_rating, m.id AS master_id,
+# => ['SELECT name, email, birthdate, phone, role, NULLIF(row, value), m.common_rating, m.work_rating, m.id AS master_id,
 #             (SELECT COUNT(NULLIF(connected, TRUE))
 #              FROM calls c
 #              WHERE c.client_id = u.id AND direction = $1) AS missed_calls_count',
 #     0]
-```
+```  
+
+##### Distinct Select
+To specify distinct select you should add to your data structure `:distinct` value:
+- `true`
+- [columns](#columns)  
+Or with `Constructor` instance methods:
+- `.distinct`
+  - distinct structure - optional
+- `.distinct_select`
+  - [select](#select) structure
+  - distinct structure - optional
+In constructor methods `distinct: true` passed by default  
+```ruby
+# as data
+distinct: true, select: true
+# => 'SELECT DISTINCT * '
+# OR via constructor
+constructor.distinct_select([:id, :name]).build_sql # => 'SELECT DISTINCT id, name'
+# OR
+constructor.distinct_select([:id, :name], :phone).build_sql # => 'SELECT DISTINCT ON(phone) id, name '
+```  
 
 #### From
-Accepts
-- `String` || `Symbol`
-- `Array` can contains table_name and table_alias OR `VALUES` OR both  
+Possible structures:
+- [table representation](#tables)
+- [SQL functions](#sql-functions)
+- `Array` with combination of possible structures.  
 ```ruby
-from 'table_name table_alias' || :table_name
-from [:table_name, :table_alias]
-from [[:table_name, :table_alias], [:_values, [1, 2], :values_name, [*values_column_names]]]
-from [:mrgl, [:_values, [1, 2], :rgl, [:zgl, :gl]]]
-```
+from: 'table_name table_alias' || :table_name
+from: [:table_name, :table_alias]
+# => 'FROM table_name table_alias '
+from: [:_values, [1, 2], :rgl, [:zgl, :gl]]
+# => 'FROM (VALUES(1, 2)) AS rgl (zgl, gl)'
+from: [[:table_name, :table_alias], [:_values, [1, 2], :values_name, [*values_column_names]]]
+# => 'FROM table_name table_alias, (VALUES(1, 2)) AS values_name (v_c_1, v_c_2)'
+```  
 I do not like the `from` syntax, but how it can be made more convenient...?
 
 #### Join
-Accpets
-- `String`
-- `Array`:
-First element same as `from` first element - table name or `Array` of table_name and table_alias, then `Hash` with keys:
-  - on - conditions(description will be bellow)
-  - options - optional contains `Symbol` or `String` of join type... rename to type?  
-
-`Array` can be nested  
-```ruby
-join 'users u ON u.id = m.user_id'
-join ['users u ON u.id = m.user_id',
-      'skills s ON u.id = s.user_id']
-join [[:user, :u], { on: 'rgl = 123' }]
-join [[[:user, :u], { option: :full, on: [:or, 'mrgl = 2', 'rgl = 22'] }],
-      [:master, { on: ['z = 12', 'mrgl = 12'] }]]
-```
+Possible structures:
+- `String` - just passed in to `JOIN #{structure} `
+- `Array` with values(same order):
+  - [table representation](#tables)
+  - `Hash`
+    - `:on` - [conditions](#conditions)
+    - `:option` - optional - contains `Symbol` or `String` of join type... rename to type?
+- `Array` with combination of possible structures.  
+```ruby
+join: 'users u ON u.id = m.user_id'
+join: ['users u ON u.id = m.user_id',
+       'skills s ON u.id = s.user_id']
+join: [[:user, :u], { on: 'rgl = 123' }]
+# => 'JOIN users u ON rgl = 123'
+join: [[[:user, :u], { option: :full, on: [:or, 'mrgl = 2', 'rgl = 22'] }],
+       [:master, { on: ['z = 12', 'mrgl = 12'] }]]
+# => 'FULL JOIN user u ON mrgl = 2 OR rgl = 22 JOIN master ON z = 12 AND mrgl = 12'
+```  
 
-#### Conditions
-Current conditions implementation is sux... -_- Soon i'll change it.  
-Now it accepts `String` or `Array`.  
-First element of array is `Symbol` representation of join condition - `:or || :and` or by default `:and`.  
-```ruby
-conditions 'mrgl = 12'
-conditions ['z = 12', 'mrgl = 12']
-conditions ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']]
-conditions [:or, ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']],
-                 [:or, 'rgl = 12', 'zgl = lol']]
-conditions [['NOT z = 13',
-            [:or, 'mrgl = 2', 'rgl = 22']],
-            [:or, 'rgl = 12', 'zgl = lol']]
-# => 'NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = lol)'
-```
+#### Order
+Possible structures:
+- `String`, `Symbol` just insert it in `"ORDER BY #{structure} "`
+- [SQL function](#sql-function)
+- `Hash`
+  - key - previsious possible structures.
+  - value - options representation
+    - `Symbol` - `:last || :first || :asc || :desc`
+    - `String` - `'<' || '>'` or smthng else that passed in to `USING`
+    - `Array` - with symbols inside
+- `Array` - any possible structures  
+```ruby
+order: 'z.amount DESC' || :name
+# => 'ORDER BY z.amount DESC ' || 'ORDER BY name '
+order: [:name, [:_case ...], { amount: [:first, :desc] }]
+# => 'ORDER BY name, CASE ..., amount DESC NULLS FIRST '
+```  
 
 #### With
 ```ruby
-with [:alias_name, { select: true, from: :users}]
-with [[:alias_name, { select: true, from: :users}],
-      [:alias_name_2, { select: {u: [:name, :email]},
+with: [:alias_name, { select: true, from: :users}]
+with: [[:alias_name, { select: true, from: :users}],
+       [:alias_name_2, { select: {u: [:name, :email]},
                         from: :rgl}]]
-```
+# => 'WITH alias_name (SELECT * FROM users ), alias_name_2 (...) '
+# OR
+with name: { select: true },
+     another_name: { select: :mrgl }
+# => 'WITH name AS (SELECT * ), another_name AS (SELECT mrgl ) '
+```  
 
 #### Union
 ```ruby
@@ -133,8 +283,27 @@ union: [{ select: true, from: [:o_list, [:_values, [1], :al, [:master]]] },
         { select: true, from: [:co_list, [:_values, [0, :FALSE, :TRUE, 0],
                                                     :al, [:rating, :rejected,
                                                           :payment, :master]]] }]
+'SELECT ... UNION SELECT ...'
+```  
+
+#### SQL Functions
+##### Params
+Pass argument as params to adapter  
+```ruby
+[:_values, [:_params, 'mrgl', true, 'rgl'], :z, [:f_1, :f_2, :f_3]]
+['(VALUES($1, $2, $3) AS z (f_1, f_2, f_3))', ['mrgl', true, 'rgl']]
 ```
 
+##### Values
+Second and third arguments are nesessary right now, but in furure i'll do them optional.
+Arguments:
+- array of values, can be nested
+- `AS` name
+- column names  
+```ruby
+[:_values, [{u: [:name, :phone]}, :role, [:_params, 'rgl']], :z, [:n, :p, :r, :m]]
+# => '(VALUES(u.name, u.phone, role, $1) AS z (n, p, r, m))'
+```
 ### Result representation
 #### ::Row
 Result row - allow accessing data by field name via method - `row.name # => "mrgl"` or get hash representation with `row.to_h`
@@ -156,7 +325,7 @@ After initialize `PG::Result` cleared
 - `:presenter_options`
 
 #### ::Presenter
-Used in `result.present(options = {})` - it represents data as `Hash` or `Array`. options are merged with `result.options[:presenter_options]`
+Used in `result.present(options = {})` for data representation as `Hash` or `Array`. Options are merged with `result.options[:presenter_options]`  
 Data will be presented as `Array` if `rows > 1` or `options[:array]` present.
 ##### Available options
 - `array` - if querry returns only one row, but on client you await for array of data.
@@ -164,19 +333,38 @@ Data will be presented as `Array` if `rows > 1` or `options[:array]` present.
   - `Proc` - it will call proc with row as argument, and! then pass it to modifier_presentation again
   - `::Result` - it will call `modifier.present`
   - any else will be returned without changes
+- `delete` - (will be soon) - Symbol, String or Array representing keys that must be deleted from result data.
 
 ## TODO:
-- [ ] Parse data like arrays, booleans, nil to SQL
-- [ ] Relocate functions builder in to class, finally I found how it can be done nice=))
-- [ ] meditate about structure supporting another databases(now supports only postgress)
+Except this todo's there is a lot commented todo's inside project.-_-
+- [x] Parse data like arrays, booleans, nil to SQL. (:_params function -\_-)
+- [x] Relocate functions builder in to class, finally I found how it can be done nice=))
 - [ ] should I bother with extra spaces?
+- [ ] logger in config
+- [ ] Insert
+- [ ] Update
+- [ ] Delete
 
 ### Tests
+- [ ] Normal structure!!!!
 - [ ] Constructor + Builder
 - [ ] Result
 - [ ] Request
 
-### Think of a better data structure for
+### Meditate
+- [ ] builder structure... another possibility to split it?
 - [ ] from
 - [ ] join !!!
-- [ ] where !!!!!! Support for rails like syntax with hash?
+- [x] where !!!!!! Supporting rails like syntax with hash?
+- [ ] supporting another databases
+
+## Updates:
+#### 0.0.3
+- Expand predicates syntax
+- added support of multiple rows for `VALUES`
+- `ORDER` structure
+- scary tests-_-
+
+## Contact
+You can write me your suggestions for improving the syntax, wishes, things that you think are missing here.  
+My [email](mailto:aeonax.liar@gmail.com), [Ruby On Rails slack](https://rubyonrails-link.slack.com/messages/D8W1WSRAP)

data/circle.yml

@@ -0,0 +1,11 @@
+machine:
+  ruby:
+    version: 2.3.1
+
+checkout:
+  post:
+    - bundle
+
+test:
+  override:
+    - bundle exec rspec

data/lib/terrazine.rb

@@ -28,12 +28,19 @@ module Terrazine
     Constructor.new structure
   end
 
-  def self.build_sql(structure)
+  def self.build_sql(structure, options = {})
     case structure
-    when Hash
-      new_constructor(structure).build_sql
+    when Hash # , Array
+      new_constructor(structure).build_sql options
     when Constructor
-      structure.build_sql
+      structure.build_sql options
+    when Array
+      # TODO!!!!!
+      if structure.first.is_a?(String) && structure.second.is_a?(Array)
+        structure
+      else
+        new_constructor(structure).build_sql options
+      end
     when String
       structure
     else