hallelujah-cassandra-cql 1.0.4

data/lib/cassandra-cql.rb

@@ -0,0 +1,49 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module CassandraCQL; end;
+unless CassandraCQL.respond_to?(:CASSANDRA_VERSION)
+  require "cassandra-cql/1.1"
+end
+
+here = File.expand_path(File.dirname(__FILE__))
+require "#{here}/../vendor/#{CassandraCQL.CASSANDRA_VERSION}/gen-rb/cassandra"
+
+require 'bigdecimal'
+require 'date'
+require 'thrift_client'
+require 'cassandra-cql/types/abstract_type'
+require 'cassandra-cql/types/ascii_type'
+require 'cassandra-cql/types/boolean_type'
+require 'cassandra-cql/types/bytes_type'
+require 'cassandra-cql/types/date_type'
+require 'cassandra-cql/types/decimal_type'
+require 'cassandra-cql/types/double_type'
+require 'cassandra-cql/types/float_type'
+require 'cassandra-cql/types/integer_type'
+require 'cassandra-cql/types/long_type'
+require 'cassandra-cql/types/utf8_type'
+require 'cassandra-cql/types/uuid_type'
+require 'cassandra-cql/utility'
+require 'cassandra-cql/uuid'
+require 'cassandra-cql/database'
+require 'cassandra-cql/schema'
+require 'cassandra-cql/statement'
+require 'cassandra-cql/result'
+require 'cassandra-cql/row'
+
+require "cassandra-cql/#{CassandraCQL.CASSANDRA_VERSION}/result"
+require "cassandra-cql/#{CassandraCQL.CASSANDRA_VERSION}/statement"

data/lib/cassandra-cql/0.8.rb

@@ -0,0 +1,7 @@
+module CassandraCQL
+  def self.CASSANDRA_VERSION
+    "0.8"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra-cql"

data/lib/cassandra-cql/0.8/result.rb

@@ -0,0 +1,23 @@
+module CassandraCQL
+  module V08
+    class ResultSchema < CassandraCQL::ResultSchema
+      def initialize(column_family)
+        type_slice = lambda {|type| type[type.rindex('.')+1..-1] }
+
+        @names = Hash.new(type_slice.call(column_family.comparator_type))
+        @values = Hash.new(type_slice.call(column_family.default_validation_class))
+        column_family.columns.each_pair do |name, type|
+          @values[name] = type_slice.call(type)
+        end
+      end
+    end
+
+    class Result < CassandraCQL::Result
+      def initialize(result, column_family)
+        @result = result
+        @schema = ResultSchema.new(column_family) if rows?
+        @cursor = 0
+      end
+    end
+  end
+end

data/lib/cassandra-cql/0.8/statement.rb

@@ -0,0 +1,38 @@
+module CassandraCQL
+  module V08
+    class Statement < CassandraCQL::Statement
+      SCHEMA_CHANGE_RE = /\s*(create|drop|alter)\s+(\w+)/i
+      COLFAM_RE = /\s*select.*from\s+'?(\w+)/i
+
+      def execute(bind_vars=[], options={})
+        column_family = nil
+        if @statement =~ COLFAM_RE
+          column_family = @handle.schema.column_families[$1].dup
+        end
+
+        sanitized_query = self.class.sanitize(@statement, bind_vars)
+        compression_type = CassandraCQL::Thrift::Compression::NONE
+        if options[:compression]
+          compression_type = CassandraCQL::Thrift::Compression::GZIP
+          sanitized_query = Utility.compress(sanitized_query)
+        end
+
+        res = V08::Result.new(@handle.execute_cql_query(sanitized_query, compression_type), column_family)
+
+        # Change our keyspace if required
+        if @statement =~ KS_CHANGE_RE
+          @handle.keyspace = $1
+        elsif @statement =~ KS_DROP_RE
+          @handle.keyspace = nil
+        end
+
+        # We let ints be fetched for now because they'll probably be deprecated later
+        if res.void?
+          nil
+        else
+          res
+        end
+      end
+    end
+  end
+end

data/lib/cassandra-cql/1.0.rb

@@ -0,0 +1,7 @@
+module CassandraCQL
+  def self.CASSANDRA_VERSION
+    "1.0"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra-cql"

data/lib/cassandra-cql/1.0/result.rb

@@ -0,0 +1,6 @@
+module CassandraCQL
+  module V10
+    class Result < CassandraCQL::Result
+    end
+  end
+end

data/lib/cassandra-cql/1.0/statement.rb

@@ -0,0 +1,6 @@
+module CassandraCQL
+  module V10
+    class Statement < CassandraCQL::Statement
+    end
+  end
+end

data/lib/cassandra-cql/1.1.rb

@@ -0,0 +1,7 @@
+module CassandraCQL
+  def self.CASSANDRA_VERSION
+    "1.1"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra-cql"

data/lib/cassandra-cql/1.1/result.rb

@@ -0,0 +1,6 @@
+module CassandraCQL
+  module V11
+    class Result < CassandraCQL::Result
+    end
+  end
+end

data/lib/cassandra-cql/1.1/statement.rb

@@ -0,0 +1,6 @@
+module CassandraCQL
+  module V11
+    class Statement < CassandraCQL::Statement
+    end
+  end
+end

data/lib/cassandra-cql/database.rb

@@ -0,0 +1,127 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module CassandraCQL
+  module Error
+    class InvalidRequestException < Exception; end
+  end
+
+  class Database
+    attr_reader :connection, :schema, :keyspace
+  
+    def initialize(servers, options={}, thrift_client_options={})
+      @options = {
+        :keyspace => 'system'
+      }.merge(options)
+
+      @thrift_client_options = {
+        :exception_class_overrides => CassandraCQL::Thrift::InvalidRequestException
+      }.merge(thrift_client_options)
+
+      @keyspace = @options[:keyspace]
+      @cql_version = @options[:cql_version]
+      @servers = servers
+      connect!
+      execute("USE #{@keyspace}")
+    end
+
+    def connect!
+      @connection = ThriftClient.new(CassandraCQL::Thrift::Client, @servers, @thrift_client_options)
+      obj = self
+      @connection.add_callback(:post_connect) do
+        @connection.set_cql_version(@cql_version) if @cql_version
+        execute("USE #{@keyspace}")
+        @connection.login(@auth_request) if @auth_request
+      end
+    end
+  
+    def disconnect!
+      @connection.disconnect! if active?
+    end
+
+    def active?
+      # TODO: This should be replaced with a CQL call that doesn't exist yet
+      @connection.describe_version 
+      true
+    rescue Exception
+      false
+    end
+    alias_method :ping, :active?
+
+    def reset!
+      disconnect!
+      connect!
+    end
+    alias_method :reconnect!, :reset!
+
+    def statement_class
+      return @statement_class if @statement_class
+
+      version_module = 'V' + CassandraCQL.CASSANDRA_VERSION.gsub('.', '')
+      return @statement_class = CassandraCQL.const_get(version_module).const_get(:Statement)
+    end
+
+    def prepare(statement, options={}, &block)
+      stmt = statement_class.new(self, statement)
+      if block_given?
+        yield stmt
+      else
+        stmt
+      end
+    end
+
+    def execute(statement, *bind_vars)
+      result = statement_class.new(self, statement).execute(bind_vars)
+      if block_given?
+        yield result
+      else
+        result
+      end
+    rescue CassandraCQL::Thrift::InvalidRequestException
+      raise Error::InvalidRequestException.new($!.why)
+    end
+
+    def execute_cql_query(cql, compression=CassandraCQL::Thrift::Compression::NONE)
+      @connection.execute_cql_query(cql, compression)
+    rescue CassandraCQL::Thrift::InvalidRequestException
+      raise Error::InvalidRequestException.new($!.why)
+    end
+    
+    def keyspace=(ks)
+      @keyspace = (ks.nil? ? nil : ks.to_s)
+    end
+  
+    def keyspaces
+      # TODO: This should be replaced with a CQL call that doesn't exist yet
+      @connection.describe_keyspaces.map { |keyspace| Schema.new(keyspace) }
+    end
+    
+    def schema
+      # TODO: This should be replaced with a CQL call that doesn't exist yet
+      Schema.new(@connection.describe_keyspace(@keyspace))
+    end
+
+    def login!(username, password)
+      request = CassandraCQL::Thrift::AuthenticationRequest.new
+      request.credentials = {'username' => username, 'password' => password}
+      ret = @connection.login(request)
+      # To avoid a double login on the initial connect, we set
+      # @auth_request after the first successful login.
+      @auth_request = request
+      ret
+    end
+  end
+end

data/lib/cassandra-cql/result.rb

@@ -0,0 +1,133 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module CassandraCQL
+  module Error
+    class InvalidResultType < Exception; end
+    class InvalidCursor < Exception; end
+  end
+
+  class ResultSchema
+    attr_reader :names, :values
+
+    def initialize(schema)
+      # When https://issues.apache.org/jira/browse/CASSANDRA-3436 is resolve, no more need to split/last
+      @names = Hash.new(schema.default_name_type.split(".").last)
+      schema.name_types.each_pair { |key, type|
+        @names[key] = type.split(".").last
+      }
+      @values = Hash.new(schema.default_value_type.split(".").last)
+      schema.value_types.each_pair { |key, type|
+        @values[key] = type.split(".").last
+      }
+    end
+  end
+  
+  class Result
+    attr_reader :result, :schema, :cursor
+
+    def initialize(result)
+      @result = result
+      @schema = ResultSchema.new(result.schema) if rows?
+      @cursor = 0
+    end
+  
+    def void?
+      @result.type == CassandraCQL::Thrift::CqlResultType::VOID
+    end
+    
+    def int?
+      @result.type == CassandraCQL::Thrift::CqlResultType::INT
+    end
+
+    def rows?
+      @result.type == CassandraCQL::Thrift::CqlResultType::ROWS
+    end
+
+    def rows
+      @result.rows.size
+    end
+
+    def cursor=(cursor)
+      @cursor = cursor.to_i
+    rescue Exception => e
+      raise Error::InvalidCursor, e.to_s
+    end
+    
+    def fetch_row
+      case @result.type
+      when CassandraCQL::Thrift::CqlResultType::ROWS
+        return nil if @cursor >= rows
+
+        row = Row.new(@result.rows[@cursor], @schema)
+        @cursor += 1
+        return row
+      when CassandraCQL::Thrift::CqlResultType::VOID
+        return nil
+      when CassandraCQL::Thrift::CqlResultType::INT
+        return @result.num
+      else
+        raise Error::InvalidResultType, "Expects one of 0, 1, 2; was #{@result.type} "
+      end
+    end
+
+    def fetch
+      if block_given?
+        while row = fetch_row
+          yield row
+        end
+      else
+        fetch_row
+      end
+    end
+
+    def fetch_hash
+      if block_given?
+        while row = fetch_row
+          if row.kind_of?(Fixnum)
+            yield({row => row})
+          else
+            yield row.to_hash
+          end
+        end
+      else
+        if (row = fetch_row).kind_of?(Fixnum)
+          {row => row}
+        else
+          row.to_hash
+        end
+      end
+    end
+  
+    def fetch_array
+      if block_given?
+        while row = fetch_row
+          if row.kind_of?(Fixnum)
+            yield [row]
+          else
+            yield row.to_a
+          end
+        end
+      else
+        if (row = fetch_row).kind_of?(Fixnum)
+          [row]
+        else
+          row.to_a
+        end
+      end
+    end
+  end
+end

data/lib/cassandra-cql/row.rb

@@ -0,0 +1,54 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module CassandraCQL
+  class Row
+    attr_reader :row
+    
+    def initialize(row, schema)
+      @row, @schema = row, schema
+    end
+  
+    def [](obj)
+      column_index = obj.kind_of?(Fixnum) ? obj : column_names.index(obj)
+      return nil if column_index.nil?
+      column_values[column_index]
+    end
+
+    def column_names
+      @names ||= @row.columns.map do |column|
+        ColumnFamily.cast(column.name, @schema.names[column.name])
+      end
+    end
+  
+    def column_values
+      @values ||= @row.columns.map { |column| ColumnFamily.cast(column.value, @schema.values[column.name]) }
+    end
+  
+    def columns
+      @row.columns.size
+    end
+  
+    def to_a
+      column_values
+    end
+  
+    # TODO: This should be an ordered hash
+    def to_hash
+      Hash[([column_names, column_values]).transpose]
+    end
+  end
+end