clickhouse 0.1.0

data/lib/clickhouse/connection/query/result_row.rb

@@ -0,0 +1,18 @@
+module Clickhouse
+  class Connection
+    module Query
+      class ResultRow < Array
+
+        def initialize(values = [], keys = nil)
+          super values
+          @keys = keys || (0..(values.size - 1)).collect{|i| "column#{i}"}
+        end
+
+        def to_hash
+          @hash ||= Hash[@keys.zip(self)]
+        end
+
+      end
+    end
+  end
+end

data/lib/clickhouse/connection/query/result_set.rb

@@ -0,0 +1,101 @@
+module Clickhouse
+  class Connection
+    module Query
+      class ResultSet
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :@rows, :size, :empty?
+        def_delegators :to_a, :first, :last, :flatten
+
+        def initialize(rows = [], names = nil, types = nil)
+          @rows = rows
+          @names = names
+          @types = types
+        end
+
+        def each
+          (0..(size - 1)).collect do |index|
+            yield self[index]
+            self[index]
+          end
+        end
+
+        def [](index)
+          row = @rows[index]
+          row = @rows[index] = parse_row(row) if row.class == Array
+          row
+        end
+
+        def present?
+          !empty?
+        end
+
+        def to_hashes
+          collect(&:to_hash)
+        end
+
+      private
+
+        def parse_row(array)
+          values = array.each_with_index.to_a.collect do |value, i|
+            parse_value(@types[i], value) if @types
+          end
+          ResultRow.new values, @names
+        end
+
+        def parse_value(type, value)
+          if value
+            case type
+            when "UInt8", "UInt16", "UInt32", "UInt64", "Int8", "Int16", "Int32", "Int64"
+              parse_int_value value
+            when "Float32", "Float64"
+              parse_float_value value
+            when "String", "Enum8", "Enum16"
+              parse_string_value value
+            when /FixedString\(\d+\)/
+              parse_fixed_string_value value
+            when "Date"
+              parse_date_value value
+            when "DateTime"
+              parse_date_time_value value
+            when /Array\(/
+              parse_array_value value
+            else
+              raise NotImplementedError, "Cannot parse value of type #{type.inspect}"
+            end
+          end
+        end
+
+        def parse_int_value(value)
+          value.to_i
+        end
+
+        def parse_float_value(value)
+          value.to_f
+        end
+
+        def parse_string_value(value)
+          value.force_encoding("UTF-8")
+        end
+
+        def parse_fixed_string_value(value)
+          value.delete("\000").force_encoding("UTF-8")
+        end
+
+        def parse_date_value(value)
+          Date.parse(value)
+        end
+
+        def parse_date_time_value(value)
+          Time.parse(value)
+        end
+
+        def parse_array_value(value)
+          JSON.parse(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/clickhouse/connection/query/table.rb

@@ -0,0 +1,50 @@
+module Clickhouse
+  class Connection
+    module Query
+      class Table
+
+        def initialize(name)
+          @name = name
+          @columns = []
+          yield self
+        end
+
+        def engine(value)
+          @engine = value
+        end
+
+        def to_sql
+          raise Clickhouse::InvalidQueryError, "Missing table engine" unless @engine
+          length = @columns.collect{|x| x[0].to_s.size}.max
+
+          sql = []
+          sql << "CREATE TABLE #{@name} ("
+
+          @columns.each_with_index do |(name, type), index|
+            sql << "  #{name.ljust(length, " ")} #{type}#{"," unless index == @columns.size - 1}"
+          end
+
+          sql << ")"
+          sql << "ENGINE = #{@engine}"
+
+          sql.join("\n")
+        end
+
+      private
+
+        def method_missing(name, *args)
+          type = name.to_s
+                  .gsub(/(^.|_\w)/) {
+                    $1.upcase
+                  }
+                  .gsub("Uint", "UInt")
+                  .delete("_")
+
+          type << "(#{args[1]})" if args[1]
+          @columns << [args[0].to_s, type]
+        end
+
+      end
+    end
+  end
+end

data/lib/clickhouse/error.rb

@@ -0,0 +1,18 @@
+module Clickhouse
+
+  class Error < StandardError
+  end
+
+  class InvalidConnectionError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
+  class InvalidQueryError < Error
+  end
+
+  class QueryError < Error
+  end
+
+end

data/lib/clickhouse/version.rb

@@ -0,0 +1,7 @@
+module Clickhouse
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 0
+
+  VERSION = [MAJOR, MINOR, TINY].join(".")
+end

data/script/console

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require "logger"
+require "bundler"
+Bundler.require :default, :development
+
+def connect!(config = {})
+  Clickhouse.logger = Logger.new(STDOUT)
+  Clickhouse.establish_connection(config)
+end
+
+def conn(config = {})
+  connect!(config) unless Clickhouse.connection
+  Clickhouse.connection
+end
+
+def events
+  "events"
+end
+
+def create_table
+  conn.create_table(events) do |t|
+    t.fixed_string :id, 16
+    t.uint16       :year
+    t.date         :date
+    t.date_time    :time
+    t.string       :event
+    t.uint32       :user_id
+    t.float32      :revenue
+    t.engine       "MergeTree(date, (year, date), 8192)"
+  end
+end
+
+def insert_rows
+  conn.insert_rows(events, :names => %w(id year date time event user_id revenue)) do |rows|
+    rows << [
+      "d91d1c90",
+      2016,
+      "2016-10-17",
+      "2016-10-17 23:14:28",
+      "click",
+      1982,
+      0.18
+    ]
+    rows << [
+      "d91d2294",
+      2016,
+      "2016-10-17",
+      "2016-10-17 23:14:41",
+      "click",
+      1947,
+      0.203
+    ]
+  end
+end
+
+puts "Loading Clickhouse development environment (#{Clickhouse::VERSION})"
+Pry.start

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require_relative "test_helper/coverage"
+
+require "minitest"
+require "minitest/autorun"
+require "mocha/setup"
+
+def path(path)
+  File.expand_path "../../#{path}", __FILE__
+end
+
+require "bundler"
+Bundler.require :default, :development, :test
+
+require_relative "test_helper/minitest"
+require_relative "test_helper/simple_connection"

data/test/test_helper/coverage.rb

@@ -0,0 +1,16 @@
+if Dir.pwd == File.expand_path("../../..", __FILE__)
+  if ENV["REPORT"].to_i == 1
+    require "dotenv"
+    Dotenv.load
+
+    require "codeclimate-test-reporter"
+    CodeClimate::TestReporter.start
+  end
+
+  require "simplecov"
+  SimpleCov.coverage_dir "test/coverage"
+  SimpleCov.start do
+    add_group "Clickhouse", "lib"
+    add_group "Test suite", "test"
+  end
+end

data/test/test_helper/minitest.rb

@@ -0,0 +1,13 @@
+class MiniTest::Test
+  def teardown
+    Clickhouse.instance_variables.each do |name|
+      Clickhouse.instance_variable_set name, nil
+    end
+  end
+end
+
+class MiniTest::Spec
+  def assert_query(expected, actual)
+    assert_equal(expected.strip.gsub(/^\s+/, ""), actual)
+  end
+end

data/test/test_helper/simple_connection.rb

@@ -0,0 +1,12 @@
+class SimpleConnection
+  attr_reader :config
+
+  def initialize
+    @config = {
+      :scheme => "http",
+      :host => "localhost",
+      :port => 8123
+    }
+  end
+
+end

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

@@ -0,0 +1,36 @@
+require_relative "../../../test_helper"
+
+module Unit
+  module Connection
+    module Query
+      class TestResultRow < MiniTest::Test
+
+        describe Clickhouse::Connection::Query::ResultRow do
+          describe "#to_hash" do
+            describe "when passing names" do
+              it "uses the names as hash keys" do
+                result_row = Clickhouse::Connection::Query::ResultRow.new([1, 2, 3], [:a, :b, :c])
+                assert_equal({:a => 1, :b => 2, :c => 3}, result_row.to_hash)
+              end
+            end
+
+            describe "when not passing names" do
+              it "uses 'column<i>' as hash keys" do
+                result_row = Clickhouse::Connection::Query::ResultRow.new([1, 2, 3])
+                assert_equal({"column0" => 1, "column1" => 2, "column2" => 3}, result_row.to_hash)
+              end
+            end
+
+            describe "memoization" do
+              it "memoizes the resulting hash" do
+                result_row = Clickhouse::Connection::Query::ResultRow.new([1, 2, 3])
+                assert_equal result_row.to_hash.object_id, result_row.to_hash.object_id
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+require_relative "../../../test_helper"
+
+module Unit
+  module Connection
+    module Query
+      class TestResultSet < MiniTest::Test
+
+        describe Clickhouse::Connection::Query::ResultSet do
+          before do
+            @empty_set = Clickhouse::Connection::Query::ResultSet.new
+            @result_set = Clickhouse::Connection::Query::ResultSet.new(
+              [
+                [
+                  "1072649",
+                  "142.94",
+                  "badrequest.io",
+                  "d91d1c90\u0000\u0000\u0000",
+                  "2016-03-20",
+                  "2016-03-20 23:49:11",
+                  "[4,2,5,7]"
+                ], [
+                  "12948140",
+                  "9320.11",
+                  "engel.pm",
+                  "d91d217c\u0000\u0000",
+                  "2016-03-20",
+                  "2016-03-20 23:58:34",
+                  "[6,2,9,8,1]"
+                ], [
+                  "319384",
+                  "101.02",
+                  "archan937.com",
+                  "d91d2294\u0000\u0000\u0000",
+                  "2016-03-20",
+                  "2016-03-20 22:55:39",
+                  "[3,1,2]"
+                ]
+              ],
+              %w(
+                SUM(clicks)
+                AVG(price)
+                domain
+                id
+                date
+                MAX(time)
+                groupUniqArray(code)
+              ),
+              %w(
+                UInt32
+                Float32
+                String
+                FixedString(16)
+                Date
+                DateTime
+                Array(8)
+              )
+            )
+          end
+
+          describe "#size" do
+            it "returns the size of the result set" do
+              assert_equal 3, @result_set.size
+            end
+          end
+
+          describe "#empty?" do
+            it "returns whether the result set is empty or not" do
+              assert_equal true, @empty_set.empty?
+              assert_equal false, @result_set.empty?
+            end
+          end
+
+          describe "#present?" do
+            it "returns whether the result set contains rows or not" do
+              assert_equal false, @empty_set.present?
+              assert_equal true, @result_set.present?
+            end
+          end
+
+          describe "#first" do
+            it "returns the first row of the result set" do
+              assert_equal [
+                1072649,
+                142.94,
+                "badrequest.io",
+                "d91d1c90",
+                Date.new(2016, 3, 20),
+                Time.new(2016, 3, 20, 23, 49, 11),
+                [4, 2, 5, 7]
+              ], @result_set.first
+            end
+          end
+
+          describe "#last" do
+            it "returns the size of the result set" do
+              assert_equal [
+                319384,
+                101.02,
+                "archan937.com",
+                "d91d2294",
+                Date.new(2016, 3, 20),
+                Time.new(2016, 3, 20, 22, 55, 39),
+                [3, 1, 2]
+              ], @result_set.last
+            end
+          end
+
+          describe "#flatten" do
+            it "returns the size of the result set" do
+              assert_equal [
+                1072649,
+                142.94,
+                "badrequest.io",
+                "d91d1c90",
+                Date.new(2016, 3, 20),
+                Time.new(2016, 3, 20, 23, 49, 11),
+                4,
+                2,
+                5,
+                7,
+                12948140,
+                9320.11,
+                "engel.pm",
+                "d91d217c",
+                Date.new(2016, 3, 20),
+                Time.new(2016, 3, 20, 23, 58, 34),
+                6,
+                2,
+                9,
+                8,
+                1,
+                319384,
+                101.02,
+                "archan937.com",
+                "d91d2294",
+                Date.new(2016, 3, 20),
+                Time.new(2016, 3, 20, 22, 55, 39),
+                3,
+                1,
+                2
+              ], @result_set.flatten
+            end
+          end
+
+          describe "#to_hashes" do
+            it "returns an array containing the rows as hashes" do
+              assert_equal [
+                {
+                  "SUM(clicks)" => 1072649,
+                  "AVG(price)" => 142.94,
+                  "domain" => "badrequest.io",
+                  "id" => "d91d1c90",
+                  "date" => Date.new(2016, 3, 20),
+                  "MAX(time)" => Time.new(2016, 3, 20, 23, 49, 11),
+                  "groupUniqArray(code)" => [4, 2, 5, 7]
+                }, {
+                  "SUM(clicks)" => 12948140,
+                  "AVG(price)" => 9320.11,
+                  "domain" => "engel.pm",
+                  "id" => "d91d217c",
+                  "date" => Date.new(2016, 3, 20),
+                  "MAX(time)" => Time.new(2016, 3, 20, 23, 58, 34),
+                  "groupUniqArray(code)" => [6, 2, 9, 8, 1]
+                }, {
+                  "SUM(clicks)" => 319384,
+                  "AVG(price)" => 101.02,
+                  "domain" => "archan937.com",
+                  "id" => "d91d2294",
+                  "date" => Date.new(2016, 3, 20),
+                  "MAX(time)" => Time.new(2016, 3, 20, 22, 55, 39),
+                  "groupUniqArray(code)" => [3, 1, 2]
+                }
+              ], @result_set.to_hashes
+            end
+          end
+
+          describe "memoization" do
+            it "memoizes the parsed rows" do
+              assert_equal @result_set.to_a[-1].object_id, @result_set.each{}[-1].object_id
+              assert_equal @result_set.first.object_id, @result_set[0].object_id
+            end
+          end
+
+          describe "non-supported data types" do
+            it "raises a NotImplementedError error" do
+              assert_raises NotImplementedError do
+                Clickhouse::Connection::Query::ResultSet.new([[1]], ["Foo"], ["Bar"])[0]
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end