influx_query 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d265802226b7cd24ecfa9d979cf6545b2199ac1796d0c8c196857c4733cc48cf
+  data.tar.gz: 8756e0f15784bd7d90fcd11c0cfb53f80361e5db1c28e4a770f314efafb6ede3
+SHA512:
+  metadata.gz: b027c73985ec0c54c8b579344a65f85385d9ca7653728270715cf1183ba73d7cbd29bbbe54fc0b9fb123e6583ed7763c7dc38415590efdb4d898979fed89c2f1
+  data.tar.gz: b52f4ca54d4f823d069155bbcddaf857e69f5797b5f6a5d094251dd9c913d1ba4dfac9e93a91e2e2eb971d2f1315bd59e3ca8c554a1565961fdd8d901cd0800c

data/README.md

@@ -0,0 +1,152 @@
+### influx_query
+
+This is a gem that provides a minimal chainable DSL for InfluxDB.
+
+### Installation
+
+As usual, either
+
+```
+# in the gemfile
+gem 'influx_query'
+```
+
+or
+
+```
+# on the command line
+gem install influx_query
+```
+
+### Background
+
+However before going into the API it's important to understand the
+core concept behind how a query is built.
+
+The `InfluxDB::Client` gem has a method `query` that accepts a string
+as its first argument. Queries can of course be written as regular strings and passed to this, but if user-generated values are to be used in the queries, then it is unsafe to directly interpolate them.
+
+Thankfully, the `query` method can do parameterized queries using
+the `params` keyword. It looks like this:
+
+```
+influxdb_client.query(
+  "select * from things where foo=%{val} ;",
+  params: { val: "bar" }
+)
+```
+
+This gem abstracts this away and also makes a chainable dsl.
+
+### Usage
+
+This gem depends on [`influxdb-ruby`](https://github.com/influxdata/influxdb-ruby)
+but doesn't come with it included. You should require that gem separately and build
+an `InfluxDB::Client` instance using your credentials, as described in their README.
+
+Once you have such a client, you can initialize `InfluxQuery` -
+each instance handles only a single query.
+
+```
+client = InfluxDB::Client.new(host: "my_host.com")
+query = InfluxQuery.new(client: client, source: "things")
+
+# At any point, can call this to see the query
+puts query.finalize
+
+# This fires off "SELECT * FROM things":
+result = query.resolve
+
+```
+
+`#initialize` accepts some keyword opts in addition to `client` and also makes `attr_reader`s for them. However it is not necessary to manually read/write these since they all have default values set and
+are controlled by the chaining dsl.
+
+- `conditions`: an array of strings, such as `"foo = '%{val}'"`.
+  These are joined using `AND` when the query is evaluated.
+- `params`: the values which will be interpolated into the final query.
+- `select_columns`: an array of strings.
+  Defaults to `["*"]` and will stay that way unless manually altered.
+- `source`: string, the measurement to fetch data from, e.g. "things"s
+
+In between `#initialize` and `#resolve`, other methods can be called:
+
+**filter!**
+
+Args:
+
+1. is a key (used internally by `#params`).
+2. is a tag/field name.
+3. comparison operator
+4. value
+
+```
+query
+  .filter!(:start, "time", "<", "now() - 30d")
+  .filter!(:start, "time", ">", "now() - 15d")
+```
+
+This previous example has its functionality served by a helper method
+as well:
+
+**add_time_filters!**
+
+Args are just `start_time` and `end_time` keywords.
+
+```
+query
+  .add_time_filters!(
+    start_time: "now() - 30d",
+    end_time:   "now() - 15d"
+  )
+```
+
+Influx's SQL-like query language lacks a proper WHERE IN type clause, so
+we have to emulate it using something like `WHERE foo=1 OR foo=2 OR foo=3`.
+There's a method to help with this:
+
+**add_where_in_filter!**
+
+```
+query
+  .add_where_in_filter!(:foo, "foo", [1,2,3])
+```
+
+Moving on, these should be self explanatory
+
+**limit!**
+
+```
+query
+  .limit!(500)
+```
+
+**offset!**
+
+```
+query
+  .offset!(250)
+```
+
+**group by**
+
+```
+query
+  .group_by("foo")
+```
+
+### Advanced usage
+
+It is possible to use subqueries in conditions, if you manually push those condition strings into `#conditions`.
+
+It is possible to build subqueries using the chaining dsl, if you call
+`#finalize_subquery` instead of `#finalize`. This method is actually used by
+`#finalize` under the hood. Literally the only the difference is it doesn't
+insert a semicolon at the end. It's up to you to add parenthesis around the
+subquery as needed.
+
+If you have a subquery you want to include in the main FROM clause, manually set the `source` to point to it.
+
+Please feel free to send an email for help with this.
+maxpleaner@gmail.com
+

data/bin/influx_query

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'influx_query'
+class InfluxQuery::CLI < Thor
+  desc "test", "run tests"
+  def test
+    puts "No tests have been wrritten"
+    exit
+  end
+end
+InfluxQuery::CLI.start ARGV

data/lib/influx_query.rb

@@ -0,0 +1,124 @@
+class InfluxQuery
+
+  attr_reader :params, :conditions, :select_columns, :source, :client
+
+  def initialize(
+    source:, client:, conditions: nil, params: nil, select_columns: nil
+  )
+    @conditions     = conditions || []
+    @params         = params || {}
+    @select_columns = select_columns || ["*"]
+    @source         = source
+    @client         = client
+  end
+
+  def resolve
+    client.query finalize, params: params
+  end
+
+  def finalize
+    "#{finalize_subquery} ;"
+  end
+
+  def finalize_subquery
+    (
+      "select #{@select_columns.join(",")} " +
+      "from #{@source}" +
+      "#{finalize_conditions}"
+    ).tap do |str|
+      str << " GROUP BY %{group_by}" if @params[:group_by]
+      str << " LIMIT %{limit}" if @params[:limit]
+      str << " OFFSET %{offset}" if @params[:offset]
+    end
+  end
+
+  def finalize_conditions
+    return "" unless @conditions.any?
+    " where #{@conditions.join(" AND ")}"
+  end
+
+  def limit!(limit)
+    return self unless limit
+    limit = limit.to_i
+    raise(ArgumentError, "Cannot add a limit of 0") if limit.zero?
+    @params.merge! limit: limit
+    self
+  end
+
+  def offset!(offset)
+    return self unless offset
+    offset = offset.to_i
+    @params.merge! offset: offset
+    self
+  end
+
+  def group_by!(group_by)
+    return self unless group_by
+    @params.merge! group_by: group_by
+    self
+  end
+
+  def add_conditions!(properties, operator: "AND", wrap_clause: false)
+    clause = build_query_constraints(
+      properties: properties,
+      operator: operator
+    )
+    clause = "(#{clause})" if wrap_clause
+    @conditions.push clause
+    self
+  end
+
+  def add_where_in_filter!(param_key_base, col_name, vals)
+    return self unless vals.any?
+    properties = vals.map.with_index do |val, idx|
+      param_key = :"#{param_key_base}_#{idx}"
+      @params.merge! param_key => val
+      {
+        key: col_name,
+        operator: "=",
+        value: "%{#{param_key}}"
+      }
+    end
+    add_conditions!(properties, operator: "OR", wrap_clause: true)
+  end
+
+  # Most of the filters have the same structure.
+  def filter!(param_name, col_name, operator, val)
+    return self unless val
+    @params.merge!(param_name => val)
+    add_conditions! [{
+      key: col_name,
+      operator: operator,
+      value: "%{#{param_name}}"
+    }]
+  end
+
+  def add_time_filters!(start_date: nil, end_date: nil, **_opts)
+    start_date ||= (Time.now.utc - 7.days).beginning_of_day.to_i
+    end_date ||= Time.now.utc.end_of_day.to_i
+    @params.merge! start_date: start_date, end_date: end_date
+    add_conditions! [
+      { key: 'time', operator: ">=", value: "%{start_date}s" },
+      { key: 'time', operator: "<=", value: "%{end_date}s" }
+    ], operator: "AND"
+  end
+
+  def build_query_constraints(properties: [], operator: 'AND')
+    conditions = []
+    properties.each do |property|
+      # Influx requires different quotation types for different situations.
+      # no quotes are used here:
+      #   where time > 123123123s (s -> seconds)
+      # but single quotes are used here
+      #   where controller_action = 'sessions_controller#create'
+      value = if property[:value].is_a?(String) && property[:key] != 'time'
+        "'#{property[:value]}'"
+      else
+        property[:value]
+      end
+      conditions << "#{property[:key]} #{property[:operator]} #{value}"
+    end
+    conditions.join(" #{operator} ")
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module InfluxQuery
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: influx_query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- max pleaner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-26 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email: maxpleaner@gmail.com
+executables:
+- influx_query
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/influx_query
+- lib/influx_query.rb
+- lib/version.rb
+homepage: http://github.com/maxp-edcast/influx_query
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.3
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: query DSL for Influx
+test_files: []