datalanche 0.9.2

data/lib/datalanche.rb

@@ -0,0 +1,3 @@
+require "datalanche/client"
+require "datalanche/query"
+require "datalanche/exception"

data/lib/datalanche/client.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+
+require "rubygems"
+require "json"
+require "net/http"
+require "net/https"
+require "zlib"
+require "uri"
+require_relative "./query"
+require_relative "./exception"
+
+class DLClient
+    def initialize(key, secret, host = nil, port = nil, verify_ssl = true)
+
+        @auth_key = key
+        @auth_secret = secret
+        @url = 'https://api.datalanche.com'
+        @verify_ssl = verify_ssl
+        @verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        if host != nil
+            @url = 'https://' + host
+        end
+
+        if port != nil
+            @url = @url + ':' + port.to_s()
+        end
+
+        if verify_ssl != true
+            @verify_mode = OpenSSL::SSL::VERIFY_NONE            
+        end
+
+    end
+
+    def key(key)
+        @auth_key = key
+    end
+
+    def secret(secret)
+        @auth_secret = secret
+    end
+
+    def get_debug_info(res,req)
+        info = Hash.new
+
+        info['request'] = Hash.new
+        info['request']['method'] = req['method']
+        info['request']['url'] = req['url']
+        info['request']['headers'] = req['headers']
+        info['request']['body'] = req['body']
+
+        info['response'] = Hash.new
+        info['response']['http_status'] = res.code # r.status_code
+        info['response']['message'] = res.message
+        info['response']['http_version'] = res.http_version
+
+        return info
+    end
+
+    def query(q = nil)
+        if q == nil
+            raise Exception('query == nil')
+        end
+
+        url = @url
+
+        if q.params.has_key?('database')
+            url = url + '/' + q.params['database']
+            q.params.delete('database')
+        end
+
+        url = URI.parse(url + '/query')
+
+        header = {
+                   # 'Accept-Encoding'=>'gzip', # will be resumed after method of decompression of gzip found
+                    'Content-Type'=>'application/json',
+                    'User-Agent'=>'Datalanche Ruby Client'
+                }
+        
+        req = Net::HTTP::Post.new(url.path, header)
+        req.basic_auth @auth_key, @auth_secret
+
+        https = Net::HTTP.new(url.host,url.port)
+        https.use_ssl = true 
+        https.verify_mode = @verify_mode
+        https.ssl_version = "SSLv3"
+
+        req.body = "#{q.params.to_json}"
+        res = https.request(req)
+
+        result = Hash.new
+        req_info = Hash.new
+
+        req_info['headers'] = header
+        req_info['url'] = url
+        req_info['method'] = req.method
+        req_info['body'] = JSON.parse(req.body)
+
+        debug_info = self.get_debug_info(res,req_info)
+
+        begin
+            result['data'] = JSON.parse(res.body)
+        rescue  # in case the server does not return a body
+            result['data'] = nil
+        end
+
+        result['response'] = debug_info['response']
+        result['request'] = debug_info['request']
+
+
+        status_code = res.code.to_i 
+        if not (200 <= status_code and status_code < 300)
+            raise DLException.new(res.code, result['data'], debug_info),"Http request error: "
+        end
+        return result
+
+    end
+end

data/lib/datalanche/exception.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+class DLException < Exception
+
+    attr_accessor :detail, :status_code
+
+    def initialize(status_code, body, debug_info)
+
+        @request = debug_info['request']
+        @response = debug_info['response']
+        @response['body'] = body
+        @error_message = debug_info['response']['message']
+        @error_type = body
+        @status_code = status_code
+
+        @detail = {
+            'status_code' => @status_code,
+            'error_message' => @error_message,
+            'error_type' => @error_type,
+            'request' => @request,
+            'response' => @response
+        }
+    end
+
+end
+
+

data/lib/datalanche/query.rb

@@ -0,0 +1,464 @@
+# -*- coding: utf-8 -*-
+
+class DLQuery
+
+    # return params
+    attr_reader :params
+    
+    # initialize parameters
+    def initialize(database = nil)
+        @params = Hash.new
+        if database != nil
+            @params['database'] = database
+        end
+    end
+    
+    #
+    # COMMON
+    #
+    
+    def cascade(boolean)
+        @params['cascade'] = boolean
+        return self # method chaining
+    end
+    
+    def columns(columns)
+        @params['columns'] = columns
+        return self # method chaining
+    end
+    
+    def description(text)
+        @params['description'] = text
+        return self # method chaining
+    end
+    
+    def rename_to(table_name)
+        @params['rename_to'] = table_name
+        return self # method chaining
+    end
+    
+    def where(expression)
+        @params['where'] = expression
+        return self # method chaining
+    end
+    
+    #
+    # EXPRESSIONS
+    #
+    
+    #
+    # usage examples
+    #
+    # q.expr(2, "+", 2)
+    # q.expr("~", 2)
+    # q.expr(2, "!")
+    # q.expr(q.column("c1"), "$like", "%abc%")
+    # q.expr(q.column("c1"), "$not", "$in", [1, 2, 3, 4])
+    # q.expr(q.column("c1"), "=", 1, "$and", q.column("c2"), "=", 2)
+    #
+    def expr(*args)
+        # *args is a built-in Ruby variable which is a tuple of function args
+        return { '$expr'=> args }
+    end
+    
+    def alias(alias_name)
+        return { '$alias'=>alias_name }
+    end
+    
+    def column(column_name)
+        return { '$column'=>column_name }
+    end
+    
+    def literal(value)
+        return { '$literal'=>value }
+    end
+    
+    def table(table_name)
+        return { '$table'=>table_name }
+    end
+    
+    #
+    # FUNCTIONS
+    #
+    
+    # NOTE: *args is a built-in Ruby variable which is a tuple of function args
+    
+    #
+    # usage examples
+    #
+    # q.count("*")
+    # q.sum(q.column("c1"))
+    #
+    def avg(*args)
+        return { '$avg'=>args }
+    end
+    
+    def count(*args)
+        return { '$count'=>args }
+    end
+    
+    def max(*args)
+        return { '$max'=>args }
+    end
+    
+    def min(*args)
+        return { '$min'=>args }
+    end
+    
+    def sum(*args)
+        return { '$sum'=>args }
+    end
+    
+    #
+    # ALTER DATABASE
+    #
+    
+    def alter_database(database_name)
+        @params['alter_database'] = database_name
+        return self # method chaining
+    end
+    
+    def add_collaborator(username, permission)
+        if @params.has_key?('add_collaborators')
+            @params['add_collaborators'] = Hase.new
+        end
+        
+        @params['add_collaborators'][username] = permission
+        return self # method chaining
+    end
+    
+    def alter_collaborator(username, permission)
+        if @params.has_key?('alter_collaborators')
+            @params['alter_collaborators'] = Hash.new
+        end
+        
+        @params['alter_collaborators'][username] = permission
+        return self # method chaining
+    end
+    
+    def drop_collaborator(username)
+        if @params.has_key?('drop_collaborators')
+            @params['drop_collaborators'] = Array.new
+        end
+        
+        @params['drop_collaborators'].push(username)
+        return self # method chaining
+    end
+    
+    def is_private(boolean)
+        @params['is_private'] = boolean
+        return self # method chaining
+    end
+
+    def max_size_gb(integer)
+        @params['max_size_gb'] = integer
+        return self # method chaining
+    end
+    
+    #
+    # ALTER INDEX
+    #
+    
+    def alter_index(index_name)
+        @params['alter_index'] = index_name
+        return self # method chaining
+    end
+    
+    #
+    # ALTER SCHEMA
+    #
+    
+    def alter_schema(schema_name)
+        @params['alter_schema'] = schema_name
+        return self # method chaining
+    end
+    
+    #
+    # ALTER TABLE
+    #
+    
+    def alter_table(table_name)
+        @params['alter_table'] = table_name
+        return self # method chaining
+    end
+    
+    def add_column(column_name, attributes)
+        if !(@params.has_key?('add_columns'))
+            @params['add_columns'] = Hash.new
+        end
+        
+        @params['add_columns'][column_name] = attributes
+        return self # method chaining
+    end
+    
+    # TODO: add_constraint
+    
+    def alter_column(column_name, attributes)
+        if !(@params.has_key?('alter_columns'))
+            @params['alter_columns'] = Hash.new
+        end
+
+        @params['alter_columns'][column_name] = attributes
+        return self # method chaining
+    end
+    
+    def drop_column(column_name, cascade = false)
+        if !(@params.has_key?('drop_columns'))
+            @params['drop_columns'] = Array.new
+        end
+        
+        column_obj = Hash.new
+        column_obj['name'] = column_name
+        column_obj['cascade'] = cascade
+        self.params['drop_columns'].push(column_obj)
+        return self # method chaining
+    end
+    
+    # TODO: drop_constraint
+
+    def rename_column(column_name, new_name)
+        if !(@params.has_key?('rename_columns'))
+            @params['rename_columns'] = Hash.new
+        end
+        
+        @params['rename_columns'][column_name] = new_name
+        return self # method chaining
+    end
+    
+    # TODO: rename_constraint
+    
+    def set_schema(schema_name)
+        @params['set_schema'] = schema_name
+        return self # method chaining
+    end
+    
+    #
+    # CREATE INDEX
+    #
+    
+    def create_index(index_name)
+        @params['create_index'] = index_name
+        return self # method chaining
+    end
+    
+    def on_table(tableName)
+        @params['on_table'] = tableName
+        return self # method chaining
+    end
+
+    def unique(boolean)
+        @params['unique'] = boolean
+        return self # method chaining
+    end
+    
+    def using_method(text)
+        @params['using_method'] = text
+        return self # method chaining
+    end
+    
+    #
+    # CREATE SCHEMA
+    #
+    
+    def create_schema(schema_name)
+        @params['create_schema'] = schema_name
+        return self # method chaining
+    end
+    
+    #
+    # CREATE TABLE
+    #
+    
+    def create_table(table_name)
+        @params['create_table'] = table_name
+        return self # method chaining
+    end
+    
+    
+    # TODO: constraints
+    
+    #
+    # DELETE
+    #
+    
+    def delete_from(table_name)
+        @params['delete_from'] = table_name
+        return self # method chaining
+    end
+    
+    #
+    # DESCRIBE DATABASE
+    #
+    
+    def describe_database(database_name)
+        @params['describe_database'] = database_name
+        return self # method chaining
+    end
+    
+    #
+    # DESCRIBE SCHEMA
+    #
+    
+    def describe_schema(schema_name)
+        @params['describe_schema'] = schema_name
+        return self # method chaining
+    end
+
+    #
+    # DESCRIBE TABLE
+    #
+    
+    def describe_table(table_name)
+        @params['describe_table'] = table_name
+        return self # method chaining
+    end
+    
+    #
+    # DROP INDEX
+    #
+    
+    def drop_index(index_name)
+        @params['drop_index'] = index_name
+        return self # method chaining
+    end
+
+    #
+    # DROP SCHEMA
+    #
+    
+    def drop_schema(schema_name)
+        @params['drop_schema'] = schema_name
+        return self # method chaining
+    end
+
+    #
+    # DROP TABLE
+    #
+    
+    def drop_table(table_name)
+        @params['drop_table'] = table_name
+        return self # method chaining
+    end
+    
+    #
+    # INSERT
+    #
+    
+    def insert_into(table_name)
+        @params['insert_into'] = table_name
+        return self # method chaining
+    end
+    
+    def values(rows)
+        @params['values'] = rows
+        return self # method chaining
+    end
+
+    #
+    # SEARCH TABLE
+    #
+
+    def search_table(query_text)
+        @params['search_table'] = query_text
+        return self # method chaining
+    end
+
+    def with_query(query_text)
+        @params['with_query'] = query_text
+        return self # method chaining
+    end
+    
+    #
+    # SELECT
+    #
+    
+    def select(columns)
+        if columns == '*'
+            raise Exception('please use select_all() instead of select("*")')
+        end
+        
+        @params['select'] = columns
+        return self # method chaining
+    end
+    
+    def select_all()
+        @params['select'] = true
+        return self # method chaining
+    end
+    
+    def distinct(boolean)
+        @params['distinct'] = boolean
+        return self # method chaining
+    end
+    
+    def from(tables)
+        @params['from'] = tables
+        return self # method chaining
+    end
+    
+    def group_by(columns)
+        @params['group_by'] = columns
+        return self # method chaining
+    end
+    
+    def having(expression)
+        @params['having'] = expression
+        return self # method chaining
+    end
+    
+    def limit(integer)
+        @params['limit'] = integer
+        return self # method chaining
+    end
+    
+    def offset(integer)
+        @params['offset'] = integer
+        return self # method chaining
+    end
+    
+    def order_by(expr_array)
+        @params['order_by'] = expr_array
+        return self # method chaining
+    end
+
+    #
+    # SHOW DATABASES
+    #
+    
+    def show_databases()
+        @params['show_databases'] = true
+        return self # method chaining
+    end
+    
+    #
+    # SHOW SCHEMAS
+    #
+    
+    def show_schemas()
+        @params['show_schemas'] = true
+        return self # method chaining
+    end
+
+    #
+    # SHOW TABLES
+    #
+    
+    def show_tables()
+        @params['show_tables'] = true
+        return self # method chaining
+    end
+    
+    #
+    # UPDATE
+    #
+    
+    def update(table_name)
+        @params['update'] = table_name
+        return self # method chaining
+    end
+    
+    def set(kv_pairs)
+        @params['set'] = kv_pairs
+        return self # method chaining
+    end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: datalanche
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 2
+  version: 0.9.2
+platform: ruby
+authors: 
+- Datalanche Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-04-23 00:00:00 Z
+dependencies: []
+
+description: Official Ruby client for Datalanche.
+email: contact@datalanche.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/datalanche.rb
+- lib/datalanche/client.rb
+- lib/datalanche/query.rb
+- lib/datalanche/exception.rb
+homepage: https://api.datalanche.com
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: datalanche
+test_files: []
+