finery 3.0.0

data/lib/blazer/adapters/base_adapter.rb

@@ -0,0 +1,76 @@
+module Blazer
+  module Adapters
+    class BaseAdapter
+      attr_reader :data_source
+
+      def initialize(data_source)
+        @data_source = data_source
+      end
+
+      def run_statement(statement, comment)
+        # required
+      end
+
+      def quoting
+        # required, how to quote variables
+        # :backslash_escape - single quote strings and convert ' to \' and \ to \\
+        # :single_quote_escape - single quote strings and convert ' to ''
+        # ->(value) { ... } - custom method
+      end
+
+      def parameter_binding
+        # optional, but recommended when possible for security
+        # if specified, quoting is only used for display
+        # :positional - ?
+        # :numeric - $1
+        # ->(statement, values) { ... } - custom 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
+
+      def supports_cohort_analysis?
+        false # optional
+      end
+
+      def cohort_analysis_statement(statement, period:, days:)
+        # optional
+      end
+
+      protected
+
+      def settings
+        @data_source.settings
+      end
+    end
+  end
+end

data/lib/blazer/adapters/bigquery_adapter.rb

@@ -0,0 +1,79 @@
+module Blazer
+  module Adapters
+    class BigQueryAdapter < BaseAdapter
+      def run_statement(statement, comment, bind_params)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          results = bigquery.query(statement, params: bind_params)
+
+          # 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.all.map(&:values)
+          else
+            error = Blazer::TIMEOUT_MESSAGE
+          end
+        rescue => e
+          error = e.message
+          error = Blazer::VARIABLE_MESSAGE if error.include?("Syntax error: Unexpected \"?\"")
+        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
+
+      # https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#string_and_bytes_literals
+      def quoting
+        :backslash_escape
+      end
+
+      # https://cloud.google.com/bigquery/docs/parameterized-queries
+      def parameter_binding
+        :positional
+      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,70 @@
+module Blazer
+  module Adapters
+    class CassandraAdapter < BaseAdapter
+      def run_statement(statement, comment, bind_params)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = session.execute("#{statement} /*#{comment}*/", arguments: bind_params)
+          rows = response.map { |r| r.values }
+          columns = rows.any? ? response.first.keys : []
+        rescue => e
+          error = e.message
+          error = Blazer::VARIABLE_MESSAGE if error.include?("no viable alternative at input '?'")
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        session.execute("SELECT table_name FROM system_schema.tables WHERE keyspace_name = #{data_source.quote(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 = #{data_source.quote(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
+
+      # https://docs.datastax.com/en/cql-oss/3.3/cql/cql_reference/escape_char_r.html
+      def quoting
+        :single_quote_escape
+      end
+
+      # https://docs.datastax.com/en/developer/nodejs-driver/3.0/features/parameterized-queries/
+      def parameter_binding
+        :positional
+      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/clickhouse_adapter.rb

@@ -0,0 +1,84 @@
+module Blazer
+  module Adapters
+    class ClickhouseAdapter < BaseAdapter
+      DATE_TIME_TYPES = ["DateTime", "DateTime(%s)", "DateTime64(%d, %s)"].freeze
+
+      def run_statement(statement, _comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = connection.select_all(statement)
+          unless result.data.blank?
+            date_time_columns = result.meta
+                                      .select { |column| column["type"].in?(DATE_TIME_TYPES) }
+                                      .map { |column| column["name"] }
+            columns = result.first.keys
+            rows = result.map { |row| convert_time_columns(row, date_time_columns).values }
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        connection.tables
+      end
+
+      def schema
+        statement = <<-SQL
+          SELECT table, name, type
+          FROM system.columns
+          WHERE database = currentDatabase()
+          ORDER BY table, position
+        SQL
+
+        response = connection.post(query: { query: statement, default_format: "CSV" })
+        response.body
+                .group_by { |row| row[0] }
+                .transform_values { |columns| columns.map { |c| { name: c[1], data_type: c[2] } } }
+                .map { |table, columns| { schema: "public", table: table, columns: columns } }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      def explain(statement)
+        connection.explain(statement)
+      end
+
+      protected
+
+      def connection
+        @connection ||= ClickHouse::Connection.new(config)
+      end
+
+      def config
+        @config ||= begin
+          uri = URI.parse(settings["url"])
+          options = {
+            scheme: uri.scheme,
+            host: uri.host,
+            port: uri.port,
+            username: uri.user,
+            password: uri.password,
+            database: uri.path.sub(/\A\//, ""),
+            ssl_verify: settings.fetch("ssl_verify", false)
+          }.compact
+          ClickHouse::Config.new(**options)
+        end
+      end
+
+      def convert_time_columns(row, date_time_columns)
+        time_values = row.slice(*date_time_columns).transform_values!(&:to_time)
+        row.merge(time_values)
+      rescue NoMethodError
+        row
+      end
+    end
+  end
+end

data/lib/blazer/adapters/drill_adapter.rb

@@ -0,0 +1,38 @@
+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
+
+      # https://drill.apache.org/docs/lexical-structure/#string
+      def quoting
+        :single_quote_escape
+      end
+
+      # https://issues.apache.org/jira/browse/DRILL-5079
+      def parameter_binding
+        # not supported
+      end
+
+      private
+
+      def drill
+        @drill ||= ::Drill.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/druid_adapter.rb

@@ -0,0 +1,102 @@
+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, bind_params)
+        require "json"
+        require "net/http"
+        require "uri"
+
+        columns = []
+        rows = []
+        error = nil
+
+        params =
+          bind_params.map do |v|
+            type =
+              case v
+              when Integer
+                "BIGINT"
+              when Float
+                "DOUBLE"
+              when ActiveSupport::TimeWithZone
+                v = (v.to_f * 1000).round
+                "TIMESTAMP"
+              else
+                "VARCHAR"
+              end
+            {type: type, value: v}
+          end
+
+        header = {"Content-Type" => "application/json", "Accept" => "application/json"}
+        timeout = data_source.timeout ? data_source.timeout.to_i : 300
+        data = {
+          query: statement,
+          parameters: params,
+          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
+            elsif error.include?("Encountered \"?\" at")
+              error = Blazer::VARIABLE_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
+
+      # https://druid.apache.org/docs/latest/querying/sql.html#identifiers-and-literals
+      # docs only mention double quotes
+      def quoting
+        :single_quote_escape
+      end
+
+      # https://druid.apache.org/docs/latest/querying/sql.html#dynamic-parameters
+      def parameter_binding
+        :positional
+      end
+    end
+  end
+end

data/lib/blazer/adapters/elasticsearch_adapter.rb

@@ -0,0 +1,61 @@
+module Blazer
+  module Adapters
+    class ElasticsearchAdapter < BaseAdapter
+      def run_statement(statement, comment, bind_params)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = client.transport.perform_request("POST", endpoint, {}, {query: "#{statement} /*#{comment}*/", params: bind_params}).body
+          columns = response["columns"].map { |v| v["name"] }
+          # Elasticsearch does not differentiate between dates and times
+          date_indexes = response["columns"].each_index.select { |i| ["date", "datetime"].include?(response["columns"][i]["type"]) }
+          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
+          error = Blazer::VARIABLE_MESSAGE if error.include?("mismatched input '?'")
+        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
+
+      # https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-lexical-structure.html#sql-syntax-string-literals
+      def quoting
+        :single_quote_escape
+      end
+
+      # https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-rest-params.html
+      def parameter_binding
+        :positional
+      end
+
+      protected
+
+      def endpoint
+        @endpoint ||= client.info["version"]["number"].to_i >= 7 ? "_sql" : "_xpack/sql"
+      end
+
+      def client
+        @client ||= Elasticsearch::Client.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/hive_adapter.rb

@@ -0,0 +1,55 @@
+module Blazer
+  module Adapters
+    class HiveAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = client.execute("#{statement} /*#{comment}*/")
+          columns = result.any? ? result.first.keys : []
+          rows = result.map(&:values)
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        client.execute("SHOW TABLES").map { |r| r["tab_name"] }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      # https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-StringsstringStrings
+      def quoting
+        :backslash_escape
+      end
+
+      # has variable substitution, but sets for session
+      # https://cwiki.apache.org/confluence/display/Hive/LanguageManual+VariableSubstitution
+      def parameter_binding
+      end
+
+      protected
+
+      def client
+        @client ||= begin
+          uri = URI.parse(settings["url"])
+          Hexspace::Client.new(
+            host: uri.host,
+            port: uri.port,
+            username: uri.user,
+            password: uri.password,
+            database: uri.path.sub(/\A\//, ""),
+            mode: uri.scheme.to_sym
+          )
+        end
+      end
+    end
+  end
+end

data/lib/blazer/adapters/ignite_adapter.rb

@@ -0,0 +1,64 @@
+module Blazer
+  module Adapters
+    class IgniteAdapter < BaseAdapter
+      def run_statement(statement, comment, bind_params)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = client.query("#{statement} /*#{comment}*/", bind_params, schema: default_schema, statement_type: :select, timeout: data_source.timeout)
+          columns = result.any? ? result.first.keys : []
+          rows = result.map(&:values)
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      def tables
+        sql = "SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema NOT IN ('INFORMATION_SCHEMA', 'SYS')"
+        result = data_source.run_statement(sql)
+        result.rows.reject { |row| row[1].start_with?("__") }.map do |row|
+          (row[0] == default_schema ? row[1] : "#{row[0]}.#{row[1]}").downcase
+        end
+      end
+
+      # TODO figure out error
+      # Table `__T0` can be accessed only within Ignite query context.
+      # def schema
+      #   sql = "SELECT table_schema, table_name, column_name, data_type, ordinal_position FROM information_schema.columns WHERE table_schema NOT IN ('INFORMATION_SCHEMA', 'SYS')"
+      #   result = data_source.run_statement(sql)
+      #   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]} }} }.sort_by { |t| [t[:schema] == default_schema ? "" : t[:schema], t[:table]] }
+      # end
+
+      def quoting
+        :single_quote_escape
+      end
+
+      # query arguments
+      # https://ignite.apache.org/docs/latest/binary-client-protocol/sql-and-scan-queries#op_query_sql
+      def parameter_binding
+        :positional
+      end
+
+      private
+
+      def default_schema
+        "PUBLIC"
+      end
+
+      def client
+        @client ||= begin
+          uri = URI(settings["url"])
+          Ignite::Client.new(host: uri.host, port: uri.port, username: uri.user, password: uri.password)
+        end
+      end
+    end
+  end
+end

data/lib/blazer/adapters/influxdb_adapter.rb

@@ -0,0 +1,57 @@
+module Blazer
+  module Adapters
+    class InfluxdbAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = client.query(statement, denormalize: false).first
+
+          if result
+            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
+          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
+
+      # https://docs.influxdata.com/influxdb/v1.8/query_language/spec/#strings
+      def quoting
+        :backslash_escape
+      end
+
+      def parameter_binding
+        # not supported
+      end
+
+      protected
+
+      def client
+        @client ||= InfluxDB::Client.new(url: settings["url"])
+      end
+    end
+  end
+end