clickhouse 0.1.0

data/test/unit/connection/query/test_table.rb

@@ -0,0 +1,39 @@
+require_relative "../../../test_helper"
+
+module Unit
+  module Connection
+    module Query
+      class TestTable < MiniTest::Test
+
+        describe Clickhouse::Connection::Query::Table do
+          it "generates a 'CREATE TABLE' statement" do
+            table = Clickhouse::Connection::Query::Table.new("logs_test") do |t|
+              t.uint8        :id
+              t.float32      :price
+              t.string       :name
+              t.date         :date
+              t.date_time    :time
+              t.fixed_string :hex_id, 8
+              t.engine       "MergeTree(date, 8192)"
+            end
+
+            sql = <<-SQL
+CREATE TABLE logs_test (
+  id     UInt8,
+  price  Float32,
+  name   String,
+  date   Date,
+  time   DateTime,
+  hex_id FixedString(8)
+)
+ENGINE = MergeTree(date, 8192)
+            SQL
+
+            assert_equal sql.strip, table.to_sql.strip
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/unit/connection/test_client.rb

@@ -0,0 +1,131 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestClient < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include Clickhouse::Connection::Client
+      end
+
+      describe Clickhouse::Connection::Client do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#connect!" do
+          describe "when failed to connect" do
+            it "returns true" do
+              Faraday::Connection.any_instance.expects(:get).raises(Faraday::ConnectionFailed.new("Failed to connect"))
+              assert_raises Clickhouse::ConnectionError do
+                @connection.connect!
+              end
+            end
+          end
+
+          describe "when receiving 200" do
+            it "returns true" do
+              Faraday::Connection.any_instance.expects(:get).returns(stub(:status => 200))
+              assert_equal true, @connection.connect!
+            end
+          end
+
+          describe "when receiving 500" do
+            it "raises a Clickhouse::ConnectionError" do
+              Faraday::Connection.any_instance.expects(:get).returns(stub(:status => 500))
+              assert_raises Clickhouse::ConnectionError do
+                @connection.connect!
+              end
+            end
+          end
+
+          describe "when already connected" do
+            it "returns nil" do
+              @connection.instance_variable_set :@client, mock
+              assert_nil @connection.connect!
+            end
+          end
+        end
+
+        describe "#connected?" do
+          it "returns whether it has an connected socket" do
+            assert_equal false, @connection.connected?
+            @connection.instance_variable_set :@client, mock
+            assert_equal true, @connection.connected?
+            @connection.instance_variable_set :@client, nil
+            assert_equal false, @connection.connected?
+          end
+        end
+
+        describe "#get" do
+          it "sends a GET request the server" do
+            @connection.instance_variable_set :@client, (client = mock)
+            client.expects(:get).with("/?query=foo", nil).returns(stub(:status => 200, :body => ""))
+            @connection.stubs(:log)
+            @connection.get(:foo)
+          end
+        end
+
+        describe "#post" do
+          it "sends a POST request the server" do
+            @connection.instance_variable_set :@client, (client = mock)
+            client.expects(:post).with("/?query=foo", "body").returns(stub(:status => 200, :body => ""))
+            @connection.stubs(:log)
+            @connection.post(:foo, "body")
+          end
+        end
+
+        describe "#request" do
+          before do
+            @connection.expects(:log)
+          end
+
+          it "connects to the server first" do
+            @connection.instance_variable_set :@client, (client = mock)
+            @connection.expects(:connect!)
+            client.stubs(:get).returns(stub(:status => 200, :body => ""))
+            @connection.send :request, :get, "/", "query"
+          end
+
+          it "queries the server returning the response" do
+            @connection.instance_variable_set :@client, (client = mock)
+            client.expects(:get).with("/?query=SELECT+1", nil).returns(response = stub(:status => 200, :body => ""))
+            assert_equal response, @connection.send(:request, :get, "SELECT 1")
+          end
+
+          describe "when not receiving status 200" do
+            it "raises a Clickhouse::QueryError" do
+              @connection.instance_variable_set :@client, (client = mock)
+              client.expects(:get).with("/?query=SELECT+1", nil).returns(stub(:status => 500, :body => ""))
+              assert_raises Clickhouse::QueryError do
+                @connection.send(:request, :get, "SELECT 1")
+              end
+            end
+          end
+        end
+
+        describe "configuration" do
+          describe "database" do
+            it "includes the database in the querystring" do
+              @connection.expects(:log)
+              @connection.instance_variable_get(:@config)[:database] = "system"
+              @connection.instance_variable_set(:@client, (client = mock))
+              client.expects(:get).with("/?database=system&query=SELECT+1", nil).returns(response = stub(:status => 200, :body => ""))
+              assert_equal response, @connection.send(:request, :get, "SELECT 1")
+            end
+          end
+
+          describe "authentication" do
+            it "includes the credentials in the request headers" do
+              connection = Clickhouse::Connection.new :password => "awesomepassword"
+              connection.expects(:ping!)
+              connection.connect!
+              assert_equal "Basic ZGVmYXVsdDphd2Vzb21lcGFzc3dvcmQ=", connection.send(:client).headers["Authorization"].force_encoding("UTF-8")
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/connection/test_logger.rb

@@ -0,0 +1,35 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestLogger < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include Clickhouse::Connection::Logger
+      end
+
+      describe Clickhouse::Connection::Logger do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#log" do
+          describe "when having specified a logger" do
+            it "delegates to logger" do
+              (logger = mock).expects(:info, "Hello world!")
+              Clickhouse.expects(:logger).returns(logger).twice
+              @connection.send(:log, :info, "Hello world!")
+            end
+          end
+
+          describe "when not having specified a logger" do
+            it "does nothing" do
+              assert_nil @connection.send(:log, :info, "Boo!")
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/connection/test_query.rb

@@ -0,0 +1,391 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestQuery < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include Clickhouse::Connection::Query
+        include Clickhouse::Connection::Logger
+      end
+
+      describe Clickhouse::Connection::Query do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#execute" do
+          it "sends a POST request" do
+            @connection.expects(:post).with("sql", nil).returns(stub(:status => 200, :body => ""))
+            assert_equal true, @connection.execute("sql")
+          end
+
+          describe "when server returns a non-empty body" do
+            it "returns the body of the response" do
+              @connection.expects(:post).with("sql", "body").returns(stub(:status => 200, :body => "Ok."))
+              assert_equal "Ok.", @connection.execute("sql", "body")
+            end
+          end
+        end
+
+        describe "#query" do
+          it "sends a GET request requesting a TSV response including names and types" do
+            @connection.expects(:get).with("sql FORMAT TabSeparatedWithNamesAndTypes").returns(stub(:status => 200, :body => ""))
+            assert_equal [], @connection.query("sql").to_a
+          end
+        end
+
+        describe "#databases" do
+          it "sends a 'SHOW DATABASES' query" do
+            @connection.expects(:get).with("SHOW DATABASES FORMAT TabSeparatedWithNamesAndTypes").returns(stub(:status => 200, :body => ""))
+            @connection.databases
+          end
+        end
+
+        describe "#tables" do
+          it "sends a 'SHOW TABLES' query" do
+            @connection.expects(:get).with("SHOW TABLES FORMAT TabSeparatedWithNamesAndTypes").returns(stub(:status => 200, :body => ""))
+            @connection.tables
+          end
+        end
+
+        describe "#create_table" do
+          it "sends a 'CREATE TABLE' query" do
+            sql = <<-SQL
+CREATE TABLE logs_test (
+  id     UInt8,
+  price  Float32,
+  name   String,
+  date   Date,
+  time   DateTime,
+  hex_id FixedString(8)
+)
+ENGINE = MergeTree(date, 8192)
+            SQL
+            @connection.expects(:post).with(sql.strip, nil).returns(stub(:status => 200, :body => ""))
+            @connection.create_table("logs_test") do |t|
+              t.uint8        :id
+              t.float32      :price
+              t.string       :name
+              t.date         :date
+              t.date_time    :time
+              t.fixed_string :hex_id, 8
+              t.engine       "MergeTree(date, 8192)"
+            end
+          end
+        end
+
+        describe "#describe_table" do
+          it "sends a 'DESCRIBE TABLE <name>' query" do
+            @connection.expects(:get).with("DESCRIBE TABLE logs FORMAT TabSeparatedWithNamesAndTypes").returns(stub(:status => 200, :body => ""))
+            @connection.describe_table("logs")
+          end
+        end
+
+        describe "#rename_table" do
+          describe "when passing an array with an even number of names" do
+            it "sends a POST request containing a RENAME TABLE statement" do
+              @connection.expects(:post).with("RENAME TABLE foo TO bar, baz TO qux", nil).returns(stub(:status => 200, :body => "")).twice
+              assert_equal true, @connection.rename_table("foo", "bar", "baz", "qux")
+              assert_equal true, @connection.rename_table(["foo", "bar"], ["baz", "qux"])
+            end
+          end
+
+          describe "when passing an array with an odd number of names" do
+            it "raises an Clickhouse::InvalidQueryError" do
+              assert_raises Clickhouse::InvalidQueryError do
+                @connection.rename_table "foo"
+              end
+              assert_raises Clickhouse::InvalidQueryError do
+                @connection.rename_table ["foo"]
+              end
+            end
+          end
+
+          describe "when passing a hash" do
+            it "sends a POST request containing a RENAME TABLE statement" do
+              @connection.expects(:post).with("RENAME TABLE foo TO bar, baz TO qux", nil).returns(stub(:status => 200, :body => ""))
+              assert_equal true, @connection.rename_table(:foo => "bar", :baz => "qux")
+            end
+          end
+        end
+
+        describe "#drop_table" do
+          it "sends a POST request containing a 'DROP TABLE' statement" do
+            @connection.expects(:post).with("DROP TABLE logs", nil).returns(stub(:status => 200, :body => ""))
+            assert_equal true, @connection.drop_table("logs")
+          end
+        end
+
+        describe "#insert_rows" do
+          before do
+            @csv = <<-CSV
+              id,first_name,last_name
+              12345,Paul,Engel
+              67890,Bruce,Wayne
+            CSV
+            @csv.gsub!(/^\s+/, "")
+          end
+
+          describe "when using hashes" do
+            it "sends a POST request containing a 'INSERT INTO' statement using CSV" do
+              @connection.expects(:post).with("INSERT INTO logs FORMAT CSVWithNames", @csv).returns(stub(:status => 200, :body => ""))
+              assert_equal true, @connection.insert_rows("logs") { |rows|
+                rows << {:id => 12345, :first_name => "Paul", :last_name => "Engel"}
+                rows << {:id => 67890, :first_name => "Bruce", :last_name => "Wayne"}
+              }
+            end
+          end
+
+          describe "when using arrays" do
+            it "sends a POST request containing a 'INSERT INTO' statement using CSV" do
+              @connection.expects(:post).with("INSERT INTO logs FORMAT CSVWithNames", @csv).returns(stub(:status => 200, :body => ""))
+              assert_equal true, @connection.insert_rows("logs", :names => %w(id first_name last_name)) { |rows|
+                rows << [12345, "Paul", "Engel"]
+                rows << [67890, "Bruce", "Wayne"]
+              }
+            end
+          end
+        end
+
+        describe "#select_rows" do
+          it "sends a GET request and parses the result set" do
+            body = <<-TSV
+              year\tname
+              UInt16\tString
+              1982\tPaul
+              1947\tAnna
+            TSV
+
+            @connection.expects(:to_select_query).with(options = {:from => "logs"})
+            @connection.expects(:get).returns(stub(:body => body.gsub(/^\s+/, "")))
+
+            assert_equal [
+              [1982, "Paul"],
+              [1947, "Anna"]
+            ], @connection.select_rows(options).to_a
+          end
+        end
+
+        describe "#select_row" do
+          it "returns an empty array" do
+            @connection.expects(:select_rows).returns([["Paul", "Engel"], ["Bruce", "Wayne"]])
+            assert_equal ["Paul", "Engel"], @connection.select_row({})
+          end
+        end
+
+        describe "#select_values" do
+          describe "when empty result set" do
+            it "returns an empty array" do
+              @connection.expects(:to_select_query)
+              @connection.expects(:get).returns(stub(:body => ""))
+              assert_equal [], @connection.select_values({})
+            end
+          end
+
+          describe "when getting data" do
+            it "returns every first value of every row" do
+              body = <<-TSV
+                year\tname
+                UInt16\tString
+                1982\tPaul
+                1947\tAnna
+              TSV
+
+              @connection.expects(:to_select_query)
+              @connection.expects(:get).returns(stub(:body => body.gsub(/^\s+/, "")))
+              assert_equal [
+                1982,
+                1947
+              ], @connection.select_values({})
+            end
+          end
+        end
+
+        describe "#select_value" do
+          describe "when empty result set" do
+            it "returns nil" do
+              @connection.expects(:select_values).with(options = {:foo => "bar"}).returns([])
+              assert_nil @connection.select_value(options)
+            end
+          end
+
+          describe "when getting data" do
+            it "returns the first value of the first row" do
+              @connection.expects(:select_values).with(options = {:foo => "bar"}).returns([1982])
+              assert_equal 1982, @connection.select_value(options)
+            end
+          end
+        end
+
+        describe "#count" do
+          it "returns the first value of the first row" do
+            @connection.expects(:select_value).with(:select => "COUNT(*)", :from => "logs").returns(1982)
+            assert_equal 1982, @connection.count(:from => "logs")
+          end
+        end
+
+        describe "#to_select_query" do
+          describe "when passing :from option" do
+            it "generates a simple 'SELECT * FROM <table>' query" do
+              query = <<-SQL
+                SELECT *
+                FROM logs
+              SQL
+              options = {
+                :from => "logs"
+              }
+              assert_query(query, @connection.send(:to_select_query, options))
+            end
+          end
+
+          describe "when passing :from and :select option" do
+            describe "when passing a single column" do
+              it "respects the single column in the SELECT statement" do
+                query = <<-SQL
+                  SELECT MIN(date)
+                  FROM logs
+                SQL
+                options = {
+                  :select => "MIN(date)",
+                  :from => "logs"
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when passing multiple columns" do
+              it "only includes the passed columns in the SELECT statement" do
+                query = <<-SQL
+                  SELECT MIN(date), MAX(date)
+                  FROM logs
+                SQL
+                options = {
+                  :select => ["MIN(date)", "MAX(date)"],
+                  :from => "logs"
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when filtering on value is empty" do
+              it "uses the empty() function in the WHERE statement" do
+                query = <<-SQL
+                  SELECT *
+                  FROM logs
+                  WHERE empty(parent_id)
+                SQL
+                options = {
+                  :from => "logs",
+                  :where => {
+                    :parent_id => :empty
+                  }
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when filtering on value is within a certain range" do
+              it "includes the range in the WHERE statement" do
+                query = <<-SQL
+                  SELECT *
+                  FROM logs
+                  WHERE code >= 6 AND code <= 10
+                SQL
+                options = {
+                  :from => "logs",
+                  :where => {
+                    :code => 6..10
+                  }
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when filtering on value in array" do
+              it "uses an IN operator in the WHERE statement" do
+                query = <<-SQL
+                  SELECT *
+                  FROM logs
+                  WHERE code IN (6, 7, 8, 9, 10)
+                SQL
+                options = {
+                  :from => "logs",
+                  :where => {
+                    :code => [6, 7, 8, 9, 10]
+                  }
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when filtering using backticks" do
+              it "uses the specified SQL as is" do
+                query = <<-SQL
+                  SELECT *
+                  FROM logs
+                  WHERE id != 'cb5a67d2932911e6'
+                SQL
+                options = {
+                  :from => "logs",
+                  :where => {
+                    :id => "`!= 'cb5a67d2932911e6'`"
+                  }
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when filtering on a string" do
+              it "uses a single quoted string" do
+                query = <<-SQL
+                  SELECT *
+                  FROM logs
+                  WHERE id = 'cb5a67d2932911e6'
+                SQL
+                options = {
+                  :from => "logs",
+                  :where => {
+                    :id => "cb5a67d2932911e6"
+                  }
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+
+            describe "when using all options" do
+              it "generates the complex query" do
+                query = <<-SQL
+                  SELECT date, COUNT(id), groupUniqArray(severity), SUM(clicks)
+                  FROM logs
+                  WHERE date >= '2016-08-01' AND hidden = 0
+                  GROUP BY date
+                  HAVING MIN(severity) = 2
+                  ORDER BY MIN(time) DESC
+                  LIMIT 120, 60
+                SQL
+                options = {
+                  :select => ["date", "COUNT(id)", "groupUniqArray(severity)", "SUM(clicks)"],
+                  :from => "logs",
+                  :where => {
+                    :date => "`>= '2016-08-01'`",
+                    :hidden => 0
+                  },
+                  :group => "date",
+                  :having => {
+                    "MIN(severity)" => 2
+                  },
+                  :order => "MIN(time) DESC",
+                  :limit => 60,
+                  :offset => 120
+                }
+                assert_query(query, @connection.send(:to_select_query, options))
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end