blazer 2.2.6

data/lib/blazer/adapters/presto_adapter.rb

@@ -0,0 +1,45 @@
+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
+
+      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,45 @@
+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
+
+      protected
+
+      def client
+        @client ||= Restforce.new
+      end
+    end
+  end
+end

data/lib/blazer/adapters/snowflake_adapter.rb

@@ -0,0 +1,73 @@
+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
+    end
+  end
+end

data/lib/blazer/adapters/soda_adapter.rb

@@ -0,0 +1,96 @@
+module Blazer
+  module Adapters
+    class SodaAdapter < 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/, "")
+
+        # 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
+    end
+  end
+end

data/lib/blazer/adapters/sql_adapter.rb

@@ -0,0 +1,221 @@
+module Blazer
+  module Adapters
+    class SqlAdapter < BaseAdapter
+      attr_reader :connection_model
+
+      def initialize(data_source)
+        super
+
+        @connection_model =
+          Class.new(Blazer::Connection) do
+            def self.name
+              "Blazer::Connection::Adapter#{object_id}"
+            end
+            establish_connection(data_source.settings["url"]) if data_source.settings["url"]
+          end
+      end
+
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          in_transaction do
+            set_timeout(data_source.timeout) if data_source.timeout
+
+            result = select_all("#{statement} /*#{comment}*/")
+            columns = result.columns
+            result.rows.each do |untyped_row|
+              rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] ? result.column_types[c].send(:cast_value, untyped_row[i]) : untyped_row[i] })
+            end
+          end
+        rescue => e
+          error = e.message.sub(/.+ERROR: /, "")
+          error = Blazer::TIMEOUT_MESSAGE if Blazer::TIMEOUT_ERRORS.any? { |e| error.include?(e) }
+          reconnect if error.include?("PG::ConnectionBad")
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        sql = add_schemas("SELECT table_schema, table_name FROM information_schema.tables")
+        result = data_source.run_statement(sql, refresh_cache: true)
+        if postgresql? || redshift? || snowflake?
+          result.rows.sort_by { |r| [r[0] == default_schema ? "" : r[0], r[1]] }.map do |row|
+            table =
+              if row[0] == default_schema
+                row[1]
+              else
+                "#{row[0]}.#{row[1]}"
+              end
+
+            table = table.downcase if snowflake?
+
+            {
+              table: table,
+              value: connection_model.connection.quote_table_name(table)
+            }
+          end
+        else
+          result.rows.map(&:second).sort
+        end
+      end
+
+      def schema
+        sql = add_schemas("SELECT table_schema, table_name, column_name, data_type, ordinal_position FROM information_schema.columns")
+        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 preview_statement
+        if sqlserver?
+          "SELECT TOP (10) * FROM {table}"
+        else
+          "SELECT * FROM {table} LIMIT 10"
+        end
+      end
+
+      def reconnect
+        connection_model.establish_connection(settings["url"])
+      end
+
+      def cost(statement)
+        result = explain(statement)
+        if sqlserver?
+          result["TotalSubtreeCost"]
+        else
+          match = /cost=\d+\.\d+..(\d+\.\d+) /.match(result)
+          match[1] if match
+        end
+      end
+
+      def explain(statement)
+        if postgresql? || redshift?
+          select_all("EXPLAIN #{statement}").rows.first.first
+        elsif sqlserver?
+          begin
+            execute("SET SHOWPLAN_ALL ON")
+            result = select_all(statement).each.first
+          ensure
+            execute("SET SHOWPLAN_ALL OFF")
+          end
+          result
+        end
+      rescue
+        nil
+      end
+
+      def cancel(run_id)
+        if postgresql?
+          select_all("SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE pid <> pg_backend_pid() AND query LIKE ?", ["%,run_id:#{run_id}%"])
+        elsif redshift?
+          first_row = select_all("SELECT pid FROM stv_recents WHERE status = 'Running' AND query LIKE ?", ["%,run_id:#{run_id}%"]).first
+          if first_row
+            select_all("CANCEL #{first_row["pid"].to_i}")
+          end
+        end
+      end
+
+      def cachable?(statement)
+        !%w[CREATE ALTER UPDATE INSERT DELETE].include?(statement.split.first.to_s.upcase)
+      end
+
+      protected
+
+      def select_all(statement, params = [])
+        statement = connection_model.send(:sanitize_sql_array, [statement] + params) if params.any?
+        connection_model.connection.select_all(statement)
+      end
+
+      # seperate from select_all to prevent mysql error
+      def execute(statement)
+        connection_model.connection.execute(statement)
+      end
+
+      def postgresql?
+        ["PostgreSQL", "PostGIS"].include?(adapter_name)
+      end
+
+      def redshift?
+        ["Redshift"].include?(adapter_name)
+      end
+
+      def mysql?
+        ["MySQL", "Mysql2", "Mysql2Spatial"].include?(adapter_name)
+      end
+
+      def sqlserver?
+        ["SQLServer", "tinytds", "mssql"].include?(adapter_name)
+      end
+
+      def snowflake?
+        data_source.adapter == "snowflake"
+      end
+
+      def adapter_name
+        # prevent bad data source from taking down queries/new
+        connection_model.connection.adapter_name rescue nil
+      end
+
+      def default_schema
+        @default_schema ||= begin
+          if postgresql? || redshift?
+            "public"
+          elsif sqlserver?
+            "dbo"
+          else
+            connection_model.connection_config[:database]
+          end
+        end
+      end
+
+      def add_schemas(query)
+        if settings["schemas"]
+          where = "table_schema IN (?)"
+          schemas = settings["schemas"]
+        else
+          where = "table_schema NOT IN (?)"
+          schemas = ["information_schema"]
+          schemas.map!(&:upcase) if snowflake?
+          schemas << "pg_catalog" if postgresql? || redshift?
+        end
+        connection_model.send(:sanitize_sql_array, ["#{query} WHERE #{where}", schemas])
+      end
+
+      def set_timeout(timeout)
+        if postgresql? || redshift?
+          execute("SET #{use_transaction? ? "LOCAL " : ""}statement_timeout = #{timeout.to_i * 1000}")
+        elsif mysql?
+          # use send as this method is private in Rails 4.2
+          mariadb = connection_model.connection.send(:mariadb?) rescue false
+          if mariadb
+            execute("SET max_statement_time = #{timeout.to_i * 1000}")
+          else
+            execute("SET max_execution_time = #{timeout.to_i * 1000}")
+          end
+        else
+          raise Blazer::TimeoutNotSupported, "Timeout not supported for #{adapter_name} adapter"
+        end
+      end
+
+      def use_transaction?
+        settings.key?("use_transaction") ? settings["use_transaction"] : true
+      end
+
+      def in_transaction
+        connection_model.connection_pool.with_connection do
+          if use_transaction?
+            connection_model.transaction do
+              yield
+              raise ActiveRecord::Rollback
+            end
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end