influxdb-arel 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93f531a5801d11ca235b597b784dbbaa4913c095
+  data.tar.gz: 3dee249e2b4273d429e5c368c80e5d36ad093255
+SHA512:
+  metadata.gz: 2166d603b4dfc1be19b9513298968f24b712c75459e775f518c6a013439e95849ce629fd3594aea6f943c7e1a82c22de8d48de8868893125f423acf656cf6af7
+  data.tar.gz: 5f34262b49084e14b4ac57f380eb0c873f8ff9955dd653a7ebf6ed694812c88fa67f772cc59e953a4aab0c3f26653e202cbb879c0fb22463349f00e926083968

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--backtrace
+--order random

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - 2.1.2
+  - 2.1.3
+  - rbx-2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in influxdb-arel.gemspec
+gemspec
+
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 undr
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,350 @@
+# Influxdb::Arel
+
+Influxdb::Arel is a SQL AST manager for Influxdb dialect. It simplifies the generation of complex SQL queries.
+
+[![Build Status](https://travis-ci.org/undr/influxdb-arel.svg?branch=master)](https://travis-ci.org/undr/influxdb-arel) [![Code Climate](https://codeclimate.com/github/undr/influxdb-arel/badges/gpa.svg)](https://codeclimate.com/github/undr/influxdb-arel)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'influxdb-arel'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install influxdb-arel
+```
+
+## Usage
+
+### Introduction
+
+At start you should create a table which you will work with:
+
+```ruby
+events = Influxdb::Arel::Table.new(:events)
+events.to_sql
+# => SELECT * FROM events
+```
+
+You can use both string and symbol as table name:
+
+```ruby
+Influxdb::Arel::Table.new('events') == Influxdb::Arel::Table.new(:events)
+# => true
+```
+
+You will get the same result.
+
+If you want to use convenient shortcuts, such as `10.h.ago` or `1.w.time` you should require file with core extensions
+
+```ruby
+require 'influxdb/arel/core_extensions'
+
+1.h
+# => #<Influxdb::Arel::Nodes::Duration:0x00000102143a68 @left=1, @right="h">
+
+1.h.to_sql
+# => "1h"
+
+1.h.time
+# => #<Influxdb::Arel::Nodes::Time:0x0000010282f728 @expr=#<Influxdb::Arel::Nodes::Duration:0x0000010282f868 @left=1, @right="h">>
+
+1.h.time.to_sql
+# => "time(1h)"
+
+1.h.ago.to_sql
+# => "(now() - 1h)"
+
+1.h.since.to_sql
+# => "(now() + 1h)"
+
+'time(1s)'.to_arel == Influxdb::Arel::Nodes::SqlLiteral.new('time(1s)')
+# => true
+
+'time(1s)'.to_influxdb_arel == Influxdb::Arel::Nodes::SqlLiteral.new('time(1s)')
+# => true
+
+:events.to_arel == Influxdb::Arel::Table.new('events')
+# => true
+
+:events.to_influxdb_arel == Influxdb::Arel::Table.new('events')
+# => true
+
+'MEAN(value)'.as('user_events')
+# => #<Influxdb::Arel::Nodes::As:0x00000101218f70 @left="MEAN(value)", @right="user_events">
+
+'MEAN(value)'.as('user_events').to_sql
+# => "MEAN(value) AS user_events"
+
+:events.as('user_events')
+# => #<Influxdb::Arel::Nodes::TableAlias:0x0000010180f8c0 @left=#<Influxdb::Arel::Table:0x0000010180f938 @name="events">, @right="user_events">
+
+:events.as('user_events').to_sql
+# => "events AS user_events"
+```
+
+### Setting of table names
+
+There are several ways to set another table name to table object. You should call `from` method:
+
+- With strings or symbols
+
+```ruby
+events.from('events', :errors).to_sql
+# => SELECT * FROM events, errors
+```
+
+- With table objects
+
+```ruby
+events.from(Influxdb::Arel::Table.new(:errors)).to_sql
+# => SELECT * FROM errors
+```
+
+- With sql literal objects
+
+```ruby
+events.from(Influxdb::Arel::Nodes::SqlLiteral.new('errors')).to_sql
+# => SELECT * FROM errors
+```
+
+- With table aliases
+
+*There will be only a table name without alias in result SQL because aliases are used only when joining tables*
+
+```ruby
+events.from(events.as('user_errors')).to_sql
+# => SELECT * FROM errors
+```
+
+- With regexp object
+
+```ruby
+events.from(/.*/).to_sql
+# => SELECT * FROM /.*/
+```
+
+### Joining tables
+
+You can join two tables using `join` method.
+
+It will join two first tables from tables list if method is called without argument
+
+```ruby
+table = Influxdb::Arel::Table.new('table')
+table.from('table1', 'table2').join.to_sql
+# => SELECT * FROM table1 INNER JOIN table2
+```
+
+It will change nothing if method is called without argument and tables list contains less than two table.
+
+```ruby
+table.join.to_sql
+# => SELECT * FROM table
+```
+
+It will join first table from tables list with given table if argument exists.
+
+```ruby
+table.join('table2').to_sql
+# => SELECT * FROM table INNER JOIN table2
+```
+
+```ruby
+table.from('table1', 'table2').join('table3').to_sql
+# => SELECT * FROM table1 INNER JOIN table3
+```
+
+Also, you can define alias for each joined table. It would be useful for self joining table.
+
+```ruby
+table.from(table.as(:table_one)).join(table.as(:table_two)).to_sql
+# => SELECT * FROM table AS table_one INNER JOIN table AS table_two
+```
+
+Chaining this method will replace previous join definition.
+
+```ruby
+table1 = Influxdb::Arel::Table.new('table')
+table.join(table1).join(table1.as('alias')).to_sql
+# => SELECT * FROM table INNER JOIN table1 AS alias
+```
+
+### Merging tables
+
+You can merge tables using `merge` method.
+
+It will merge two first tables from tables list if method is called without argument.
+
+```ruby
+table = Influxdb::Arel::Table.new('table')
+table.from('table1', 'table2').merge.to_sql
+# => SELECT * FROM table1 MERGE table2
+```
+
+It will change nothing if method is called without argument and tables list contains less than two table.
+
+```ruby
+table.merge.to_sql
+# => SELECT * FROM table
+```
+
+It will merge first table from tables list with given table if argument exists.
+
+```ruby
+table.merge('table2').to_sql
+# => SELECT * FROM table MERGE table2
+
+table.from('table1', 'table2').merge('table3').to_sql
+# => SELECT * FROM table1 MERGE table3
+```
+
+Chaining this method will replace previous merge definition.
+
+```ruby
+table.megre('table1').merge('table2').to_sql
+# => SELECT * FROM table MERGE table2
+```
+
+### Grouping of results
+
+Grouping of results by specified columns or expressions, such as `time(10m)`:
+
+```ruby
+table = Influxdb::Arel::Table.new('table')
+table.group(table.time(10.m), table[:host]).to_sql
+# => SELECT * FROM table GROUP BY time(10m), host
+```
+
+If you want to fill intervals with no data you should call `fill` method:
+
+```ruby
+table.group(10.m.time, table[:host]).fill(0).to_sql
+# => SELECT * FROM table GROUP BY time(10m), host fill(0)
+```
+
+Chaining this method will add expression to the grouping set.
+
+```ruby
+table.group(table.time(10.m)).group(:host).to_sql
+# => SELECT * FROM table GROUP BY time(10m), host
+```
+
+### Ordering of results
+
+Yo can set the ordering of results using `order` method
+
+Possible values:
+
+* `:asc`- Default value. Results will be sorted by ascending order.
+* `'asc'`- Results will be sorted by ascending order.
+* `:desc`- Results will be sorted by descending order.
+* `'desc'`- Results will be sorted by descending order.
+
+```ruby
+table = Influxdb::Arel::Table.new('table')
+table.order(:desc).to_sql
+table.order('desc').to_sql
+# => SELECT * FROM table ORDER DESC
+
+table.order(:asc).to_sql
+table.order('asc').to_sql
+# => SELECT * FROM table ORDER ASC
+```
+
+As well it's possible to use `asc` and `desc` methods
+
+```ruby
+table.where(table[:time].lteq(Time.now)).asc.to_sql
+# => SELECT * FROM table WHERE time <= 1412137303000000 ORDER ASC
+table.where(table[:time].lteq(Time.now)).desc.to_sql
+# => SELECT * FROM table WHERE time <= 1412137303000000 ORDER DESC
+```
+
+Chaining this methods will replace previous order definition.
+
+```ruby
+table.where(table[:time].lteq(Time.now)).asc.desc.to_sql
+# => SELECT * FROM table WHERE time <= 1412137303000000 ORDER DESC
+```
+
+### Query conditions
+
+You can specify conditions for selection query using `where` method
+
+```ruby
+table = Influxdb::Arel::Table.new('table')
+table.where(table[:name].eq('Undr')).to_sql
+# => SELECT * FROM table WHERE name = 'Undr'
+```
+
+```ruby
+table.where(table[:name].eq('Undr').or(table[:name].eq('Andrei'))).to_sql
+# => SELECT * FROM table WHERE name = 'Undr' OR name = 'Andrei'
+```
+
+Chaining this method will add expression to the condition set. They will join using `AND` boolean expression.
+
+```ruby
+table.where(table[:name].eq('Undr')).where(table[:time].lt(10.h.ago).to_sql
+# => SELECT * FROM table WHERE name = 'Undr' AND time < (now() - 10h)
+```
+
+
+### SELECT clause
+
+You can specify columns or expressions for SELECT clause using `column` method. By default, it's `*`.
+
+```ruby
+table = Influxdb::Arel::Table.new('cpu_load')
+table.to_sql
+# => SELECT * FROM cpu_load
+
+table.column((table[:system] + table[:user]).as(:sum)).to_sql
+# => SELECT (system + user) AS sum FROM cpu_load
+
+table.column(
+  table[:idle].mean.as(:idle_mean),
+  table[:user].mean.as(:user_mean)
+).group(1.d.time).to_sql
+# => SELECT MEAN(idle) AS idle_mean, MEAN(user) AS user_mean FROM cpu_load GROUP BY time(1d)
+```
+
+It might be convenient to use aliases for complex expressions, such as functions or some mathematical expressions. Also the aliasing needed when joining tables. For example:
+
+```ruby
+alias1 = table.as('table1')
+alias2 = table.as('table2')
+table.from(alias1, alias2).
+  column(alias1[:idle], alias2[:idle]).
+  join.to_sql
+# => SELECT table1.idle, table2.idle FROM table AS table1 INNER JOIN table AS table2
+```
+
+### Limits
+
+You can set a limit for a result set
+
+```ruby
+table = Influxdb::Arel::Table.new('cpu_load')
+table.take(100).to_sql
+# => SELECT * FROM cpu_load LIMIT 100
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/undr/influxdb-arel/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/influxdb-arel.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'influxdb/arel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "influxdb-arel"
+  spec.version       = Influxdb::Arel::VERSION
+  spec.authors       = ["undr"]
+  spec.email         = ["undr@yandex.ru"]
+  spec.summary       = %q{Influxdb SQL AST manager.}
+  spec.description   = %q{Influxdb::Arel is a SQL AST manager for Influxdb dialect.}
+  spec.homepage      = "https://github.com/undr/influxdb-arel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end