mode 0.0.17 → 0.0.18

data/lib/mode/connector/dataset.rb

@@ -2,7 +2,6 @@ module Mode
   module Connector
     class Dataset
       attr_reader :path
-
       attr_reader :count
       attr_reader :column_types
 

data/lib/mode/connector/dispatcher.rb

@@ -0,0 +1,27 @@
+module Mode
+  module Connector
+    class Dispatcher # Rename to Dispatcher
+      attr_reader :resource
+      attr_reader :data_sources
+
+      Commands = Mode::Connector::Commands
+
+      def initialize(resource, data_sources)
+        @resource = resource
+        @data_sources = data_sources
+      end
+
+      def perform!
+        case resource.command['name']
+        when 'select:table:metadata'
+          Commands::SelectTableMetadata.new(resource, data_sources).perform!
+        when 'select:report_run:dataset'
+          Commands::SelectReportRunDataset.new(resource, data_sources).perform!
+        end
+      rescue => err
+        Mode::Logger.instance.error(
+          self.class.name, err.message, err.backtrace)
+      end
+    end
+  end
+end

data/lib/mode/connector/poller.rb

@@ -7,7 +7,7 @@ module Mode
         if messages.is_a?(Mode::API::Resource)
           messages.embedded('messages').each do |message|
             log_message(message)
-            yield Mode::Connector::Message.new(message)
+            yield message
           end if messages.has_embedded?('messages')
         end
       end
@@ -19,8 +19,7 @@ module Mode
       end
 
       def log_message(message)
-        Mode::Logger.instance.info(
-          "Connector::Poller", message)
+        Mode::Logger.instance.info(self.class.name, message)
       end
     end
   end

data/lib/mode/connector/registrar.rb

@@ -1,33 +1,91 @@
 module Mode
   module Connector
     class Registrar
-      attr_reader :config
+      attr_reader :data_sources
 
-      def initialize(config)
-        @config = config
+      def initialize(data_sources)
+        @data_sources = data_sources
       end
 
       def perform!
-        Mode::API::Request.put(path,
-          :data_source_connection => {
-            :data_sources => data_sources
+        connection = register_connection
+        register_data_sources(connection)
+      end
+
+      private
+
+      def register_connection
+        Mode::API::Request.put(:data_source_connection, connection_params)
+      end
+
+      def register_data_sources(connection)
+        connection.embedded('data_sources').each do |resource|
+          data_source = data_sources.find{|l| l.name == resource.name }
+
+          if data_source && data_source.has_information_schema?
+            update_data_source_tables(data_source, resource)
+          end
+        end
+      end
+
+      def update_data_source_tables(data_source, resource)
+        resource.forms('edit').submit!(
+          :data_source => {
+            :tables => data_source_tables_params(data_source)
           }
         )
       end
 
-      private
+      def connection_params
+        {
+          :data_source_connection => {
+            :data_sources => data_sources_params
+          }
+        }
+      end
+
+      def data_sources_params
+        data_sources.map { |source| data_source_params(source) }
+      end
+
+      def data_source_params(source)
+        { :name => source.name, :adapter => source.adapter }
+      end
+
+      def data_source_tables_params(source)
+        tables = []
+
+        current_table = nil
+        source.database.columns.each do |column|
+          table_schema = column[:table_schema]
+          table_name   = column[:table_name]
 
-      def data_sources
-        config.data_sources.map do |source|
-          {
-            :name => source.name,
-            :adapter => source.adapter
+          if current_table.nil?
+            current_table = { :columns => [] }
+          elsif current_table[:schema] != table_schema \
+             || current_table[:name]   != table_name
+
+            tables << current_table.dup
+            current_table = { :columns => [] }
+          end
+
+          # Ensure Name
+          current_table[:schema] ||= table_schema
+          current_table[:name]   ||= table_name
+
+          # Insert Column
+          current_table[:columns] << {
+            :name        => column[:column_name],
+            :data_type   => column[:data_type],
+            :is_nullable => column[:is_nullable],
+            :primary_key => column[:primary_key]
           }
         end
-      end
-      
-      def path
-        Mode::API::Request.data_source_connection_path
+
+        # Gotta catch 'em all!
+        tables << current_table.dup
+
+        tables
       end
     end
   end

data/lib/mode/connector/scheduler.rb

@@ -14,8 +14,17 @@ module Mode
       end
 
       def start!
-        data_sources.each(&:connection) # Keep outside the scheduler loop
-        scheduler.interval('5s') { tick }
+        begin
+          register
+          data_sources.each(&:connection)
+          # Make sure to leave this outside the scheduler intervals
+        rescue => err
+          Mode::Logger.instance.error(
+            self.class.name, err.message, err.backtrace)
+        end
+
+        scheduler.interval('15m') { register }
+        scheduler.interval('5s')  { process_messages }
         scheduler.join
       end
 
@@ -24,7 +33,7 @@ module Mode
           scheduler.stop # Stop polling
         }
         
-        stopper.join # wait for threads to finish
+        stopper.join # wait for jobs to finish
       end
 
       def processors
@@ -37,30 +46,30 @@ module Mode
         max_jobs - processors.length
       end
 
-      def tick
-        if available_slots > 0
-          poll_messages(:num_messages => available_slots) do |message|
-            scheduler.in(0, :tag => 'processor') { tock(message) }
-          end
-        end
+      def register
+        Mode::Connector::Registrar.new(data_sources).perform!
       rescue => err
         Mode::Logger.instance.error(
-          "Connector::Scheduler", err.message, err.backtrace)
+          self.class.name, err.message, err.backtrace)
       end
 
-      def tock(message)
-        process_message(message)
+      def process_messages
+        if available_slots > 0
+          poll_messages(:num_messages => available_slots) do |message|
+            scheduler.in(0, :tag => 'processor') { dispatch_message(message) }
+          end
+        end
       rescue => err
         Mode::Logger.instance.error(
-          "Connector::Scheduler", err.message, err.backtrace)
+          self.class.name, err.message, err.backtrace)
       end
 
       def poll_messages(options = {}, &block)
         Mode::Connector::Poller.new.perform!(options, &block)
       end
 
-      def process_message(message)
-        Mode::Connector::Processor.new(message, data_sources).perform!
+      def dispatch_message(message)
+        Mode::Connector::Dispatcher.new(message, data_sources).perform!
       end
     end
   end

data/lib/mode/connector/selector.rb

@@ -1,4 +1,5 @@
 require 'sequel'
+require 'tmpdir'
 
 module Mode
   module Connector

data/lib/mode/connector/tables/rdbms.rb

@@ -0,0 +1,130 @@
+module Mode
+  module Connector
+    module Tables
+      class RDBMS
+        attr_reader :data_source
+        attr_reader :table_schema
+        attr_reader :table_name
+
+        def initialize(data_source, table_schema, table_name)
+          @data_source  = data_source
+          @table_schema = table_schema
+          @table_name   = table_name
+        end
+
+        def row_count
+          return @row_count unless @row_count.nil?
+
+          data_source.select(row_count_query) do |row|
+            @row_count = row[:row_count]
+          end
+          @row_count
+        end
+
+        def columns
+          return @columns unless @columns.nil?
+
+          @columns = []
+          data_source.select(columns_query) do |row|
+            column = row.dup
+            column[:primary_key] = is_pkey?(row[:name]) ? true : false
+            column[:is_nullable] = row[:is_nullable] == 'YES' ? true : false
+
+            @columns << column
+          end
+          @columns
+        end
+
+        def preview
+          return @preview unless @preview.nil?
+          @preview = Mode::Connector::Selector.new(preview_query, data_source).perform!
+        end
+
+        #
+        # Primary Key Helpers
+        #
+
+        def pkey_columns
+          return @pkey_columns unless @pkey_columns.nil?
+          
+          @pkey_columns = []
+          data_source.select(pkey_columns_query) do |row|
+            @pkey_columns << row
+          end
+          @pkey_columns
+        end
+
+        def is_pkey?(column_name)
+          pkey_columns.any?{|pkey| pkey[:name] == column_name}
+        end
+
+        def pkey_column_names
+          @pkey_column_names ||= pkey_columns.collect{|col| col[:name]}
+        end
+
+        private
+
+        def table_catalog
+          data_source.database_name
+        end
+
+        def full_table_name
+          "#{table_schema}.#{table_name}"
+        end
+
+        def row_count_query
+          %{
+            SELECT COUNT(1) as row_count
+              FROM #{full_table_name}
+          }
+        end
+
+        def preview_query
+          column_list = pkey_column_names.join(', ')
+          filter_list = pkey_column_names.map do |pkey_name|
+            "#{full_table_name}.#{pkey_name} = tmp.#{pkey_name}"
+          end.join(' AND ')
+
+          %{
+            SELECT *
+              FROM #{full_table_name}, (
+                    SELECT #{column_list}
+                      FROM #{full_table_name}
+                     ORDER BY RANDOM()
+                     LIMIT 50
+                   ) tmp
+             WHERE #{filter_list}
+          }
+        end
+
+        def columns_query
+          %{
+            SELECT column_name AS name,
+                   data_type,
+                   is_nullable
+              FROM information_schema.columns
+             WHERE table_catalog = '#{table_catalog}'
+               AND table_schema  = '#{table_schema}'
+               AND table_name    = '#{table_name}'
+          }
+        end
+
+        def pkey_columns_query
+          %{
+            SELECT key_column_usage.column_name AS name
+              FROM information_schema.table_constraints constraints
+              LEFT JOIN information_schema.key_column_usage key_column_usage
+                ON constraints.table_catalog   = key_column_usage.table_catalog
+               AND constraints.table_schema    = key_column_usage.table_schema
+               AND constraints.table_name      = key_column_usage.table_name
+               AND constraints.constraint_name = key_column_usage.constraint_name
+             WHERE constraints.constraint_type = 'PRIMARY KEY'
+               AND constraints.table_catalog = '#{table_catalog}'
+               AND constraints.table_schema  = '#{table_schema}'
+               AND constraints.table_name    = '#{table_name}'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mode/version.rb

@@ -1,3 +1,3 @@
 module Mode
-  VERSION = "0.0.17"
-end
+  VERSION = "0.0.18"
+end

data/mode.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
 
   # HTTP
   spec.add_runtime_dependency "faraday"
+  spec.add_runtime_dependency "faraday_middleware"
   spec.add_runtime_dependency "uri_template"
 
   # Connectivity
@@ -46,5 +47,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "profile"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "warbler"
 end

data/script/console.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'pry'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'mode'
+
+Config = Mode::Config.new(Mode::Config.default_dir)
+
+binding.pry

data/spec/api/form_spec.rb

@@ -8,10 +8,16 @@ describe Mode::API::Link do
       'input' => {
         'resource' => {
           'name' => {
-            'type' => 'text',
-            'value' => ''
+            'type' => 'text'
+          },
+
+          'widgets[]' => {
+            'name' => {
+              'type' => 'text',
+            }
           },
-          'widgets' => {
+
+          'widget_count' => {
             'type' => 'text',
             'value' => '500'
           }
@@ -33,17 +39,20 @@ describe Mode::API::Link do
 
   it "submits with params" do
     params = {
-      'resource' => {
-        'name' => 'test'
+      :resource => {
+        :name => 'test',
+        :widgets => [{
+          :name => 'widget1'
+        }]
       }
     }
 
     Mode::API::Request.should_receive(:post).with('/resources', {
       'resource' => {
         'name' => 'test',
-        'widgets' => '500'
-      }
-    }).and_return(:response)
+        'widgets' => [{ 'name' => 'widget1' }],
+        'widget_count' => '500' }
+    }, {}).and_return(:response)
 
     form = Mode::API::Form.new(content)
     form.submit!(params).should == :response