blazer 2.2.6

data/lib/blazer/adapters/base_adapter.rb

@@ -0,0 +1,53 @@
+module Blazer
+  module Adapters
+    class BaseAdapter
+      attr_reader :data_source
+
+      def initialize(data_source)
+        @data_source = data_source
+      end
+
+      def run_statement(statement, comment)
+        # the one required method
+      end
+
+      def tables
+        [] # optional, but nice to have
+      end
+
+      def schema
+        [] # optional, but nice to have
+      end
+
+      def preview_statement
+        "" # also optional, but nice to have
+      end
+
+      def reconnect
+        # optional
+      end
+
+      def cost(statement)
+        # optional
+      end
+
+      def explain(statement)
+        # optional
+      end
+
+      def cancel(run_id)
+        # optional
+      end
+
+      def cachable?(statement)
+        true # optional
+      end
+
+      protected
+
+      def settings
+        @data_source.settings
+      end
+    end
+  end
+end

data/lib/blazer/adapters/bigquery_adapter.rb

@@ -0,0 +1,68 @@
+module Blazer
+  module Adapters
+    class BigQueryAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          results = bigquery.query(statement)
+
+          # complete? was removed in google-cloud-bigquery 0.29.0
+          # code is for backward compatibility
+          if !results.respond_to?(:complete?) || results.complete?
+            columns = results.first.keys.map(&:to_s) if results.size > 0
+            rows = results.map(&:values)
+          else
+            error = Blazer::TIMEOUT_MESSAGE
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        table_refs.map { |t| "#{t.project_id}.#{t.dataset_id}.#{t.table_id}" }
+      end
+
+      def schema
+        table_refs.map do |table_ref|
+          {
+            schema: table_ref.dataset_id,
+            table: table_ref.table_id,
+            columns: table_columns(table_ref)
+          }
+        end
+      end
+
+      def preview_statement
+        "SELECT * FROM `{table}` LIMIT 10"
+      end
+
+      private
+
+      def bigquery
+        @bigquery ||= begin
+          require "google/cloud/bigquery"
+          Google::Cloud::Bigquery.new(
+            project: settings["project"],
+            keyfile: settings["keyfile"]
+          )
+        end
+      end
+
+      def table_refs
+        bigquery.datasets.map(&:tables).flat_map { |table_list| table_list.map(&:table_ref) }
+      end
+
+      def table_columns(table_ref)
+        schema = bigquery.service.get_table(table_ref.dataset_id, table_ref.table_id).schema
+        return [] if schema.nil?
+        schema.fields.map { |field| {name: field.name, data_type: field.type} }
+      end
+    end
+  end
+end

data/lib/blazer/adapters/cassandra_adapter.rb

@@ -0,0 +1,59 @@
+module Blazer
+  module Adapters
+    class CassandraAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = session.execute("#{statement} /*#{comment}*/")
+          rows = response.map { |r| r.values }
+          columns = rows.any? ? response.first.keys : []
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        session.execute("SELECT table_name FROM system_schema.tables WHERE keyspace_name = '#{keyspace}'").map { |r| r["table_name"] }
+      end
+
+      def schema
+        result = session.execute("SELECT keyspace_name, table_name, column_name, type, position FROM system_schema.columns WHERE keyspace_name = '#{keyspace}'")
+        result.map(&:values).group_by { |r| [r[0], r[1]] }.map { |k, vs| {schema: k[0], table: k[1], columns: vs.sort_by { |v| v[2] }.map { |v| {name: v[2], data_type: v[3]} }} }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      private
+
+      def cluster
+        @cluster ||= begin
+          require "cassandra"
+          options = {hosts: [uri.host]}
+          options[:port] = uri.port if uri.port
+          options[:username] = uri.user if uri.user
+          options[:password] = uri.password if uri.password
+          ::Cassandra.cluster(options)
+        end
+      end
+
+      def session
+        @session ||= cluster.connect(keyspace)
+      end
+
+      def uri
+        @uri ||= URI.parse(data_source.settings["url"])
+      end
+
+      def keyspace
+        @keyspace ||= uri.path[1..-1]
+      end
+    end
+  end
+end

data/lib/blazer/adapters/drill_adapter.rb

@@ -0,0 +1,28 @@
+module Blazer
+  module Adapters
+    class DrillAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          # remove trailing semicolon
+          response = drill.query(statement.sub(/;\s*\z/, ""))
+          rows = response.map { |r| r.values }
+          columns = rows.any? ? response.first.keys : []
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      private
+
+      def drill
+        @drill ||= ::Drill.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/druid_adapter.rb

@@ -0,0 +1,67 @@
+module Blazer
+  module Adapters
+    class DruidAdapter < BaseAdapter
+      TIMESTAMP_REGEX = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\z/
+
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        header = {"Content-Type" => "application/json", "Accept" => "application/json"}
+        timeout = data_source.timeout ? data_source.timeout.to_i : 300
+        data = {
+          query: statement,
+          context: {
+            timeout: timeout * 1000
+          }
+        }
+
+        uri = URI.parse("#{settings["url"]}/druid/v2/sql/")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = timeout
+
+        begin
+          response = JSON.parse(http.post(uri.request_uri, data.to_json, header).body)
+          if response.is_a?(Hash)
+            error = response["errorMessage"] || "Unknown error: #{response.inspect}"
+            if error.include?("timed out")
+              error = Blazer::TIMEOUT_MESSAGE
+            end
+          else
+            columns = (response.first || {}).keys
+            rows = response.map { |r| r.values }
+
+            # Druid doesn't return column types
+            # and no timestamp type in JSON
+            rows.each do |row|
+              row.each_with_index do |v, i|
+                if v.is_a?(String) && TIMESTAMP_REGEX.match(v)
+                  row[i] = Time.parse(v)
+                end
+              end
+            end
+          end
+         rescue => e
+           error = e.message
+         end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        result = data_source.run_statement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA NOT IN ('INFORMATION_SCHEMA') ORDER BY TABLE_NAME")
+        result.rows.map(&:first)
+      end
+
+      def schema
+        result = data_source.run_statement("SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA NOT IN ('INFORMATION_SCHEMA') ORDER BY 1, 2")
+        result.rows.group_by { |r| [r[0], r[1]] }.map { |k, vs| {schema: k[0], table: k[1], columns: vs.sort_by { |v| v[2] }.map { |v| {name: v[2], data_type: v[3]} }} }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+    end
+  end
+end

data/lib/blazer/adapters/elasticsearch_adapter.rb

@@ -0,0 +1,46 @@
+module Blazer
+  module Adapters
+    class ElasticsearchAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = client.xpack.sql.query(body: {query: "#{statement} /*#{comment}*/"})
+          columns = response["columns"].map { |v| v["name"] }
+          # Elasticsearch does not differentiate between dates and times
+          date_indexes = response["columns"].each_index.select { |i| response["columns"][i]["type"] == "date" }
+          if columns.any?
+            rows = response["rows"]
+            date_indexes.each do |i|
+              rows.each do |row|
+                row[i] = Time.parse(row[i])
+              end
+            end
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        indices = client.cat.indices(format: "json").map { |v| v["index"] }
+        aliases = client.cat.aliases(format: "json").map { |v| v["alias"] }
+        (indices + aliases).uniq.sort
+      end
+
+      def preview_statement
+        "SELECT * FROM \"{table}\" LIMIT 10"
+      end
+
+      protected
+
+      def client
+        @client ||= Elasticsearch::Client.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/influxdb_adapter.rb

@@ -0,0 +1,45 @@
+module Blazer
+  module Adapters
+    class InfluxdbAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = client.query(statement, denormalize: false).first
+          columns = result["columns"]
+          rows = result["values"]
+
+          # parse time columns
+          # current approach isn't ideal, but result doesn't include types
+          # another approach would be to check the format
+          time_index = columns.index("time")
+          if time_index
+            rows.each do |row|
+              row[time_index] = Time.parse(row[time_index]) if row[time_index]
+            end
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        client.list_series
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      protected
+
+      def client
+        @client ||= InfluxDB::Client.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/mongodb_adapter.rb

@@ -0,0 +1,39 @@
+module Blazer
+  module Adapters
+    class MongodbAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          documents = db.command({:$eval => "#{statement.strip}.toArray()", nolock: true}).documents.first["retval"]
+          columns = documents.flat_map { |r| r.keys }.uniq
+          rows = documents.map { |r| columns.map { |c| r[c] } }
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        db.collection_names
+      end
+
+      def preview_statement
+        "db.{table}.find().limit(10)"
+      end
+
+      protected
+
+      def client
+        @client ||= Mongo::Client.new(settings["url"], connect_timeout: 1, socket_timeout: 1, server_selection_timeout: 1)
+      end
+
+      def db
+        @db ||= client.database
+      end
+    end
+  end
+end

data/lib/blazer/adapters/neo4j_adapter.rb

@@ -0,0 +1,47 @@
+module Blazer
+  module Adapters
+    class Neo4jAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = session.query("#{statement} /*#{comment}*/")
+          columns = result.columns.map(&:to_s)
+          rows = []
+          result.each do |row|
+            rows << columns.map do |c|
+              v = row.send(c)
+              v = v.properties if v.respond_to?(:properties)
+              v
+            end
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        result = session.query("CALL db.labels()")
+        result.rows.map(&:first)
+      end
+
+      def preview_statement
+        "MATCH (n:{table}) RETURN n LIMIT 10"
+      end
+
+      protected
+
+      def session
+        @session ||= begin
+          require "neo4j/core/cypher_session/adaptors/http"
+          http_adaptor = Neo4j::Core::CypherSession::Adaptors::HTTP.new(settings["url"])
+          Neo4j::Core::CypherSession.new(http_adaptor)
+        end
+      end
+    end
+  end
+end