blazer 1.7.7 → 2.6.4

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

@@ -1,46 +1,58 @@
 module Blazer
   module Adapters
     class ElasticsearchAdapter < BaseAdapter
-      def run_statement(statement, comment)
+      def run_statement(statement, comment, bind_params)
         columns = []
         rows = []
         error = nil
 
         begin
-          header, body = statement.gsub(/\/\/.+/, "").strip.split("\n", 2)
-          body = JSON.parse(body)
-          body["timeout"] ||= data_source.timeout if data_source.timeout
-          response = client.msearch(body: [JSON.parse(header), body])["responses"].first
-          if response["error"]
-            error = response["error"]
-          else
-            hits = response["hits"]["hits"]
-            source_keys = hits.flat_map { |r| r["_source"].keys }.uniq
-            hit_keys = (hits.first.try(:keys) || []) - ["_source"]
-            columns = source_keys + hit_keys
-            rows =
-              hits.map do |r|
-                source = r["_source"]
-                source_keys.map { |k| source[k] } + hit_keys.map { |k| r[k] }
+          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
-        client.indices.get_aliases(name: "*").map { |k, v| [k, v["aliases"].keys] }.flatten.uniq.sort
+        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
-        %!// header\n{"index": "{table}"}\n\n// body\n{"query": {"match_all": {}}, "size": 10}!
+        "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

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

data/lib/blazer/adapters/mongodb_adapter.rb

@@ -7,7 +7,7 @@ module Blazer
         error = nil
 
         begin
-          documents = db.command({:$eval => "#{statement.strip}.toArray()"}).documents.first["retval"]
+          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
@@ -25,6 +25,10 @@ module Blazer
         "db.{table}.find().limit(10)"
       end
 
+      def quoting
+        :backslash_escape
+      end
+
       protected
 
       def client

data/lib/blazer/adapters/neo4j_adapter.rb

@@ -0,0 +1,62 @@
+module Blazer
+  module Adapters
+    class Neo4jAdapter < BaseAdapter
+      def run_statement(statement, comment, bind_params)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          result = session.query("#{statement} /*#{comment}*/", bind_params)
+          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
+          error = Blazer::VARIABLE_MESSAGE if error.include?("Invalid input '$'")
+        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
+
+      # https://neo4j.com/docs/cypher-manual/current/syntax/expressions/#cypher-expressions-string-literals
+      def quoting
+        :backslash_escape
+      end
+
+      def parameter_binding
+        proc do |statement, variables|
+          variables.each_key do |k|
+            statement = statement.gsub("{#{k}}") { "$#{k} " }
+          end
+          [statement, variables]
+        end
+      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

data/lib/blazer/adapters/opensearch_adapter.rb

@@ -0,0 +1,52 @@
+module Blazer
+  module Adapters
+    class OpensearchAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = client.transport.perform_request("POST", "_plugins/_sql", {}, {query: "#{statement} /*#{comment}*/"}).body
+          columns = response["schema"].map { |v| v["name"] }
+          # TODO typecast more types
+          # https://github.com/opensearch-project/sql/blob/main/docs/user/general/datatypes.rst
+          date_indexes = response["schema"].each_index.select { |i| response["schema"][i]["type"] == "timestamp" }
+          if columns.any?
+            rows = response["datarows"]
+            utc = ActiveSupport::TimeZone["Etc/UTC"]
+            date_indexes.each do |i|
+              rows.each do |row|
+                row[i] &&= utc.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
+
+      def quoting
+        # unknown
+      end
+
+      protected
+
+      def client
+        @client ||= OpenSearch::Client.new(url: settings["url"])
+      end
+    end
+  end
+end

data/lib/blazer/adapters/presto_adapter.rb

@@ -25,6 +25,15 @@ module Blazer
         "SELECT * FROM {table} LIMIT 10"
       end
 
+      def quoting
+        :single_quote_escape
+      end
+
+      # TODO support prepared statements - https://prestodb.io/docs/current/sql/prepare.html
+      # feature request for variables - https://github.com/prestodb/presto/issues/5918
+      def parameter_binding
+      end
+
       protected
 
       def client

data/lib/blazer/adapters/salesforce_adapter.rb

@@ -0,0 +1,50 @@
+module Blazer
+  module Adapters
+    class SalesforceAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        # remove comments manually
+        statement = statement.gsub(/--.+/, "")
+        # only supports single line /* */ comments
+        # regex not perfect, but should be good enough
+        statement = statement.gsub(/\/\*.+\*\//, "")
+
+        # remove trailing semicolon
+        statement = statement.sub(/;\s*\z/, "")
+
+        begin
+          response = client.query(statement)
+          rows = response.map { |r| r.to_hash.except("attributes").values }
+          columns = rows.any? ? response.first.to_hash.except("attributes").keys : []
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        # cache
+        @tables ||= client.describe.select { |r| r.queryable }.map(&:name)
+      end
+
+      def preview_statement
+        "SELECT Id FROM {table} LIMIT 10"
+      end
+
+      # https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_select_quotedstringescapes.htm
+      def quoting
+        :backslash_escape
+      end
+
+      protected
+
+      def client
+        @client ||= Restforce.new
+      end
+    end
+  end
+end

data/lib/blazer/adapters/snowflake_adapter.rb

@@ -0,0 +1,82 @@
+module Blazer
+  module Adapters
+    class SnowflakeAdapter < SqlAdapter
+      def initialize(data_source)
+        @data_source = data_source
+
+        @@registered ||= begin
+          require "active_record/connection_adapters/odbc_adapter"
+          require "odbc_adapter/adapters/postgresql_odbc_adapter"
+
+          ODBCAdapter.register(/snowflake/, ODBCAdapter::Adapters::PostgreSQLODBCAdapter) do
+            # Explicitly turning off prepared statements as they are not yet working with
+            # snowflake + the ODBC ActiveRecord adapter
+            def prepared_statements
+              false
+            end
+
+            # Quoting needs to be changed for snowflake
+            def quote_column_name(name)
+              name.to_s
+            end
+
+            private
+
+            # Override dbms_type_cast to get the values encoded in UTF-8
+            def dbms_type_cast(columns, values)
+              int_column = {}
+              columns.each_with_index do |c, i|
+                int_column[i] = c.type == 3 && c.scale == 0
+              end
+
+              float_column = {}
+              columns.each_with_index do |c, i|
+                float_column[i] = c.type == 3 && c.scale != 0
+              end
+
+              values.each do |row|
+                row.each_index do |idx|
+                  val = row[idx]
+                  if val
+                    if int_column[idx]
+                      row[idx] = val.to_i
+                    elsif float_column[idx]
+                      row[idx] = val.to_f
+                    elsif val.is_a?(String)
+                      row[idx] = val.force_encoding('UTF-8')
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        @connection_model =
+          Class.new(Blazer::Connection) do
+            def self.name
+              "Blazer::Connection::SnowflakeAdapter#{object_id}"
+            end
+            if data_source.settings["conn_str"]
+              establish_connection(adapter: "odbc", conn_str: data_source.settings["conn_str"])
+            elsif data_source.settings["dsn"]
+              establish_connection(adapter: "odbc", dsn: data_source.settings["dsn"])
+            end
+        end
+      end
+
+      def cancel(run_id)
+        # todo
+      end
+
+      # https://docs.snowflake.com/en/sql-reference/data-types-text.html#escape-sequences
+      def quoting
+        :backslash_escape
+      end
+
+      def parameter_binding
+        # TODO
+      end
+    end
+  end
+end