finery 3.0.0

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

@@ -0,0 +1,54 @@
+module Blazer
+  module Adapters
+    class PrestoAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          columns, rows = client.run("#{statement} /*#{comment}*/")
+          columns = columns.map(&:name)
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        _, rows = client.run("SHOW TABLES")
+        rows.map(&:first)
+      end
+
+      def preview_statement
+        "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
+        @client ||= begin
+          uri = URI.parse(settings["url"])
+          query = uri.query ? CGI::parse(uri.query) : {}
+          Presto::Client.new(
+            server: "#{uri.host}:#{uri.port}",
+            catalog: uri.path.to_s.sub(/\A\//, ""),
+            schema: query["schema"] || "public",
+            user: uri.user,
+            http_debug: false
+          )
+        end
+      end
+    end
+  end
+end

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

data/lib/blazer/adapters/soda_adapter.rb

@@ -0,0 +1,105 @@
+module Blazer
+  module Adapters
+    class SodaAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        require "json"
+        require "net/http"
+        require "uri"
+
+        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/, "")
+
+        # remove whitespace
+        statement = statement.squish
+
+        uri = URI(settings["url"])
+        uri.query = URI.encode_www_form("$query" => statement)
+
+        req = Net::HTTP::Get.new(uri)
+        req["X-App-Token"] = settings["app_token"] if settings["app_token"]
+
+        options = {
+          use_ssl: uri.scheme == "https",
+          open_timeout: 3,
+          read_timeout: 30
+        }
+
+        begin
+          # use Net::HTTP instead of soda-ruby for types and better error messages
+          res = Net::HTTP.start(uri.hostname, uri.port, options) do |http|
+            http.request(req)
+          end
+
+          if res.is_a?(Net::HTTPSuccess)
+            body = JSON.parse(res.body)
+
+            columns = JSON.parse(res["x-soda2-fields"])
+            column_types = columns.zip(JSON.parse(res["x-soda2-types"])).to_h
+
+            columns.reject! { |f| f.start_with?(":@") }
+            # rows can be missing some keys in JSON, so need to map by column
+            rows = body.map { |r| columns.map { |c| r[c] } }
+
+            columns.each_with_index do |column, i|
+              # nothing to do for boolean
+              case column_types[column]
+              when "number"
+                # check if likely an integer column
+                if rows.all? { |r| r[i].to_i == r[i].to_f }
+                  rows.each do |row|
+                    row[i] = row[i].to_i
+                  end
+                else
+                  rows.each do |row|
+                    row[i] = row[i].to_f
+                  end
+                end
+              when "floating_timestamp"
+                # check if likely a date column
+                if rows.all? { |r| r[i].end_with?("T00:00:00.000") }
+                  rows.each do |row|
+                    row[i] = Date.parse(row[i])
+                  end
+                else
+                  utc = ActiveSupport::TimeZone["Etc/UTC"]
+                  rows.each do |row|
+                    row[i] = utc.parse(row[i])
+                  end
+                end
+              end
+            end
+          else
+            error = JSON.parse(res.body)["message"] rescue "Bad response: #{res.code}"
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def preview_statement
+        "SELECT * LIMIT 10"
+      end
+
+      def tables
+        ["all"]
+      end
+
+      # https://dev.socrata.com/docs/datatypes/text.html
+      def quoting
+        :single_quote_escape
+      end
+    end
+  end
+end

data/lib/blazer/adapters/spark_adapter.rb

@@ -0,0 +1,14 @@
+module Blazer
+  module Adapters
+    class SparkAdapter < HiveAdapter
+      def tables
+        client.execute("SHOW TABLES").map { |r| r["tableName"] }
+      end
+
+      # https://spark.apache.org/docs/latest/sql-ref-literals.html
+      def quoting
+        :backslash_escape
+      end
+    end
+  end
+end