visual_query 0.3.0

data/app/views/queries/new.html.erb

@@ -0,0 +1,27 @@
+<%= render 'url_root' %>
+<span class="strong"><%=_('Таблици:')%></span>
+<div id="relations_container">
+    <%= render :partial => 'list_all_relations' %>
+</div>
+<%= form_tag(visual_query.results_queries_path(''), :method=> "post", :id => "query") do -%>
+    <div id="joined_relations_container">
+        <span class="strong"><%=_('Таблици в справката:') %></span>
+        <ul class="relation_path">
+            <li>
+                <input type="hidden" name="rows[]" value="0"/>
+                <input type="button" name="add_balanced_query" value="<%= _("Б") %>" onclick="Tutuf.VisualQuery.add_balanced_query()" />
+            </li>
+        </ul>
+    </div>
+    <%= render :partial => 'sort' %>
+    <%= render :partial => 'command' %>
+<span class="strong"><%=_('Колони:')%></span>
+<table id="results">
+    <thead>
+        <tr id="hide"></tr>
+        <tr id="filter"></tr>
+        <tr id="relation_column"></tr>
+    </thead>
+    <tbody/>
+</table>
+<% end %>

data/app/views/queries/not_found.html.erb

@@ -0,0 +1 @@
+Няма справка с име <strong><%= params[:name] %></strong>

data/app/views/queries/show.html.erb

@@ -0,0 +1,40 @@
+<%= render 'url_root' %>
+<%= form_tag(visual_query.results_queries_path(@query.name), :method=> "post", :id => "query") do -%>
+<div id="command">
+  <h1><%= @query.name %></h1>
+  <input id="name" type="hidden" name="name" value="<%= @query.name %>"/>
+  <%= render :partial => 'sort' %>
+  <%= render :partial => 'commands_results' %>
+</div>
+<input type="hidden" name="relations[][schema]" value="<%= @query.schema %>"/>
+<input type="hidden" name="relations[][rel_name]" value="<%= @query.name %>"/>
+<span class="strong"><%=_('Колони:')%></span>
+<table id="results">
+    <thead>
+        <tr id="hide">
+          <%- for column in @query.columns do -%>
+            <%= render :partial => 'results_column_hide' %>
+          <%- end -%>
+        </tr>
+        <tr id="filter">
+          <%- for column in @query.columns do -%>
+            <%= render :partial => 'results_column_filter', :locals => {:column => {:schema => @query.schema,
+                                                                                    :rel_name => @query.name,
+                                                                                    :col_name => column[:col_name] }} %>
+          <%- end -%>
+        </tr>
+        <tr id="relation_column">
+          <%- for column in @query.columns do -%>
+            <th class="relation_column">
+              <%= _(column[:col_name]) %>
+              <%- for param_name in ['columns', 'all_columns'] do-%>
+                <input type="hidden" name="<%= param_name %>[][rel_name]" value="<%= column[:rel_name] %>"/>
+                <input type="hidden" name="<%= param_name %>[][col_name]" value="<%= column[:col_name] %>"/>
+              <%- end -%>
+            </th>
+          <%- end -%>
+        </tr>
+    </thead>
+    <tbody/>
+</table>
+<% end %>

data/app/views/queries/sql_form.html.erb

@@ -0,0 +1,16 @@
+<%= render 'url_root' %>
+<%= form_tag(visual_query.results_queries_path(@query.nil? ? '' : @query.name), :method=> "get", :id => "query") do -%>
+  <%= text_area_tag :sql, @sql, :rows => 20, :cols => 120  %>
+  <%= render :partial => 'command_results_browser' %>
+  <% if controller.action_name == "edit_sql" -%>
+    <%= hidden_field_tag 'name', @query.name %>
+    <input type="button" name="update" value="<%= _("Запис") %>" onclick="Tutuf.VisualQuery.update_sql()" />
+  <% else -%>
+    <%= render :partial => 'name' %>
+    <%= render :partial => 'command_save' %>
+  <% end -%>
+  <span class="notice"></span>
+  <table id="results">
+    <tbody/>
+  </table>
+<% end %>

data/config/initializers/visual_query.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+module VisualQuery::PseudoGettext
+  def _(text) text end
+  def n_(singular,plural,arity) singular end
+end
+
+Object.class_eval do
+  include VisualQuery::PseudoGettext unless defined?(_) || defined?(n_)
+end
+
+require 'tutuf/visual_query'

data/config/routes.rb

@@ -0,0 +1,26 @@
+# encode: UTF-8
+VisualQuery::Engine.routes.draw do
+  resources :queries, path: '', only: [:index, :create] do
+    collection do
+      get    '/new'                  => 'queries#new'
+
+      get    '/columns/:klass'       => 'queries#columns'
+      get    '/list_joinable/:klass' => 'queries#list_joinable'
+      get    '/join_data/:klass'     => 'queries#join_data'
+
+      get    :filter
+      get    :remove_filter
+      get    :sort_condition
+
+      get    :new_sql
+      get    '/edit_sql/:name'       => 'queries#edit_sql',       as: 'edit_sql'
+      put    '/update_sql/:name'     => 'queries#update_sql'
+
+      # some queries have too many params to fit in the server's meagre buffer for GETs
+      match  '/results/:name'        => 'queries#results',        as: 'results', via: ['get','post']
+
+      get    '/:name'                => 'queries#show',           as: 'show'
+      delete '/:name'                => 'queries#destroy'
+    end
+  end
+end

data/db/migrate/20130927090319_create_visual_query_schema.rb

@@ -0,0 +1,9 @@
+class CreateVisualQuerySchema < ActiveRecord::Migration
+  def up
+    execute %{CREATE SCHEMA "tutuf::visual_query"}
+  end
+
+  def down
+    execute %{DROP SCHEMA "tutuf::visual_query" CASCADE}
+  end
+end

data/db/migrate/20130927090400_create_visual_query_metadata_table.rb

@@ -0,0 +1,16 @@
+class CreateVisualQueryMetadataTable < ActiveRecord::Migration
+  def up
+    create_table :tutuf_visual_query_metadata do |t|
+      t.string :name, :limit => 63, :null => false
+      t.text :params
+      t.text :order_by
+      t.timestamp :created_at
+    end
+
+    add_index :tutuf_visual_query_metadata, :name, :unique => true
+  end
+
+  def down
+    drop_table :tutuf_visual_query_metadata
+  end
+end

data/lib/tasks/visual_query_tasks.rake

@@ -0,0 +1,12 @@
+# encoding: utf-8
+namespace :visual_query do
+  desc "Drops all query views, but leaves metadata"
+  task :disable => :environment do
+    Tutuf::VisualQuery::Base.disable
+  end
+
+  desc "Recreates all query views from metadata"
+  task :enable => :environment do
+    Tutuf::VisualQuery::Base.enable
+  end
+end

data/lib/tutuf/visual_query.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+require 'tutuf/visual_query/common'
+require 'tutuf/visual_query/single'
+require 'tutuf/visual_query/base'
+require 'tutuf/visual_query/metadata'
+require 'tutuf/visual_query/sql'

data/lib/tutuf/visual_query/base.rb

@@ -0,0 +1,268 @@
+# -*- encoding : utf-8 -*-
+module Tutuf
+  module VisualQuery
+    class Base < Common
+      class << self
+
+        # PostgreSQL schema in which the saved queries live
+        def schema
+          "tutuf::visual_query"
+        end
+
+        # All direct ascendants of ActiveRecord::Base
+        def klasses
+          return @@klasses if defined?(@@klasses)
+          @@klasses = []
+          all_classes = model_filenames.map do |model_filename|
+            klass = model_filename.gsub(/\.rb$/, '').split(%r{/}).map { |c| c.camelize }.join('::')
+            klass.constantize
+          end
+          all_classes.each do |klass|
+            @@klasses << klass if klass.respond_to?(:superclass) && klass.superclass == ActiveRecord::Base
+          end
+          @@klasses.uniq
+        end
+
+        # List of all relations that the +klass+ can be joined with. Currently self joins are not supported.
+        def joinable_relations(klass)
+          klass.reflections.values.reject{ |reflection| reflection.options[:polymorphic] || reflection.klass == klass }
+        end
+
+        def columns(klass)
+          inheritance_column = klass.columns.detect{|c|c.name == klass.inheritance_column}
+          col_names = (klass.primary_key.is_a?(Array) ? klass.primary_key : [klass.primary_key]) + klass.content_columns.collect{ |col| col.name} + (inheritance_column ? [inheritance_column.name] : [])
+          col_names.map(&:to_s)
+        end
+
+        # Array of relations to be joinded
+        def join_relations(reflection)
+          if reflection.macro == :has_and_belongs_to_many
+            [reflection.join_table, reflection.table_name]
+          else
+            [reflection.klass.table_name]
+          end
+        end
+
+        # Join condition between +reflection+ (ActiveRecord::Reflection::MacroReflection) and its +klass+ in format
+        # [[{'rel_name' => reflection relation, 'col_name' => reflection column},
+        #   {'rel_name' => klass relation, 'col_name' => klass column}, ... ]]
+        # The order of relations in the array is important for parsing afterwards
+        def join_condition(reflection)
+          case reflection.macro
+          when :belongs_to
+            [[{'rel_name' => reflection.active_record.table_name, 'col_name' => reflection.foreign_key},
+              {'rel_name' => reflection.table_name,               'col_name' => reflection.klass.primary_key}]]
+          when :has_many, :has_one
+            [[{'rel_name' => reflection.active_record.table_name, 'col_name' => reflection.active_record.primary_key},
+              {'rel_name' => reflection.table_name,               'col_name' => reflection.foreign_key}]]
+          when :has_and_belongs_to_many
+            [[ {'rel_name' => reflection.active_record.table_name, 'col_name' => reflection.active_record.primary_key},
+               {'rel_name' => reflection.join_table,               'col_name' => reflection.foreign_key}],
+             [ {'rel_name' => reflection.join_table,               'col_name' => reflection.association_foreign_key},
+               {'rel_name' => reflection.klass.table_name,         'col_name' => reflection.klass.primary_key}]]
+          end
+        end
+
+        def data_type(params)
+          qualified_relation_name = quote_relation_name('schema' => params['schema'], 'rel_name' => params['rel_name'])
+          res = connection.columns(qualified_relation_name).find{|c| c.name == params['col_name']}
+          if res
+            res.type
+          else
+            nil
+          end
+        end
+
+        # Returns array of metadata for all queries (Tutuf::VisualQuery::Metadata)
+        def find_all
+          Metadata.all
+        end
+
+        def find_by_name(name)
+          if metadata = Metadata.find_by_name(name)
+            object = new(metadata.params)
+            object.instance_variable_set("@metadata", metadata)
+            object
+          end
+        end
+
+        def disable
+          connection.execute "DROP SCHEMA IF EXISTS #{quote_ident(schema)} CASCADE"
+        end
+
+        def enable
+          connection.execute "CREATE SCHEMA #{quote_ident(schema)}"
+          find_all.each do |metadata|
+            vq = new(metadata.params.merge('metadata' => metadata))
+            vq.save
+          end
+        end
+
+        private
+          def model_filenames
+            Dir.chdir("#{Rails.root.to_s}/app/models"){ Dir["**/*.rb"] }
+          end
+      end #end class methods
+
+      def initialize(params)
+        # params were kept in array in an older version
+        params = {} if params.blank? || Array === params
+        @relations = params['relations']
+        rows = (params['rows'].blank? ? [0] : params['rows'])
+        if balanced = (rows.size > 1)
+          @single_queries = rows.map do |row|
+                              relations = params['relations'].select{|h| h['row'] == row} if params['relations']
+                              join_conditions = params['join_conditions'].select{|jc| jc['row'] == row} if params['join_conditions']
+                              Tutuf::VisualQuery::Single.new({'action' => params['action'],
+                                                              'relations' => relations,
+                                                              'join_conditions' => join_conditions,
+                                                              'all_columns' => params['all_columns'],
+                                                              'all_selected_columns' => params['columns'],
+                                                              'sort_conditions' => params['sort_conditions'],
+                                                              'balanced' => balanced}.merge(%w[columns filters].inject({}){|res,key| res[key] = select(relations,params[key]); res}))
+                          end
+        elsif params['sql']
+          @single_queries = [Tutuf::VisualQuery::Sql.new(params)]
+        else
+          @single_queries = [Tutuf::VisualQuery::Single.new(params)]
+        end
+
+        name = params['query']['name'] if params['query']
+        @metadata = params.delete('metadata') || Metadata.new(:name => name, :params => params)
+      end
+
+      attr_reader :single_queries, :relations
+
+      def sql?
+        single_queries.size == 1 && Tutuf::VisualQuery::Sql === single_queries.first
+      end
+
+      def filters
+        single_queries.map{|sq| sq.filters.nil? ? [] : sq.filters}.flatten
+      end
+
+      def query
+        single_queries.size > 1 ? single_queries.map{|sq| "(#{sq.query})"}.join(" UNION ALL ") : single_queries.first.query
+      end
+
+      private
+        def select(relations,arr)
+          return if relations.blank? || arr.blank?
+          relations = relations.map{|h| h['rel_name']}
+          arr.select{|h| relations.member?(h['rel_name'])}
+        end
+
+        def results(headers=false)
+          return [] if(!sql? && (relations.nil? || relations == ""))
+          @results = []
+          res = connection.execute(query)
+          @results << res.fields if headers
+          @results += res.values
+          res.clear
+          @results
+        end
+
+      public
+
+      def to_a(headers=false)
+        results(headers)
+      end
+
+      def to_csv
+        data = results(true)
+        CSV.generate { |csv| data.each { |row| csv << row } }
+      end
+
+      def to_json
+        return [] if(!sql? && (relations.nil? || relations == ""))
+        JSON.generate(connection.select_all(query))
+      end
+
+      def schema
+        Tutuf::VisualQuery::Base.schema
+      end
+
+      def name
+        @metadata.name
+      end
+
+      def errors
+        @metadata.errors
+      end
+
+      def valid?
+        @metadata.valid?
+      end
+
+      def new?
+        @metadata.new_record?
+      end
+
+      def max_result_length
+        20000
+      end
+
+      def large_result_set?
+        @results && !@results.empty? && (@results.length * @results[0].length > max_result_length)
+      end
+
+      # Array of hashes representing qualified column names that look like { 'rel_name' => "some relation", 'col_name' => "some column"}.
+      # Raises an exception if the query has a name and is not saved yet. Returns nil if it does not have a name and is not saved.
+      def columns
+        if name
+          connection.columns(quote_relation_name('schema' => schema, 'rel_name' => name)).map{|c| {'rel_name' => name, 'col_name' => c.name}.with_indifferent_access}
+        end
+      end
+
+      def save
+        if @metadata.valid?
+          begin
+            Metadata.transaction do
+              @metadata.save
+              connection.execute("CREATE VIEW #{view_name.to_s.force_encoding('UTF-8')} AS #{query.to_s.force_encoding('UTF-8')}")
+              return true
+            end
+          rescue ActiveRecord::StatementInvalid => e
+            raise e
+          end
+        else
+          return false
+        end
+      end
+
+      def update_sql(params)
+        @metadata.params = params
+        @single_queries = [Tutuf::VisualQuery::Sql.new('sql' => params['sql'])]
+        if @metadata.valid?
+          begin
+            Metadata.transaction do
+              @metadata.save
+              connection.execute("DROP VIEW #{view_name}")
+              connection.execute("CREATE VIEW #{view_name} AS #{query}")
+              return true
+            end
+          rescue ActiveRecord::StatementInvalid => e
+            @metadata.errors.add(:base, e.to_s)
+            return false
+          end
+        else
+          return false
+        end
+      end
+
+      def view_name
+        "#{quote_ident(self.class.schema)}.#{quote_ident(name)}"
+      end
+
+      def destroy
+        begin
+          Metadata.transaction do
+            @metadata.destroy
+            connection.execute("DROP VIEW #{quote_ident(self.class.schema)}.#{quote_ident(name)}")
+          end
+          return true
+        end
+      end
+    end
+  end
+end