qreport 0.0.2

data/lib/qreport/initialization.rb

@@ -0,0 +1,14 @@
+require 'qreport'
+
+module Qreport
+  module Initialization
+    def initialize opts = nil
+      opts ||= EMPTY_Hash
+      initialize_before_opts if respond_to? :initialize_before_opts
+      opts.each do | k, v |
+        send(:"#{k}=", v)
+      end
+      initialize_after_opts if respond_to? :initialize_after_opts
+    end
+  end
+end

data/lib/qreport/main.rb

@@ -0,0 +1,9 @@
+require 'qreport/report_run'
+require 'qreport/report_runner'
+require 'pp'
+
+module Qreport
+  class Main
+  end
+end
+

data/lib/qreport/model.rb

@@ -0,0 +1,8 @@
+module Qreport
+  module Model
+    attr_accessor :conn
+    def conn
+      @conn || Qreport::Connection.current
+    end
+  end
+end

data/lib/qreport/report_run.rb

@@ -0,0 +1,191 @@
+require 'qreport'
+require 'qreport/model'
+require 'qreport/initialization'
+
+module Qreport
+  class ReportRun
+    include Model, Initialization
+
+    attr_accessor :id
+    attr_accessor :name, :sql, :additional_columns
+    attr_accessor :description
+    attr_accessor :arguments
+    attr_accessor :report_id
+    attr_accessor :report_sql
+    attr_accessor :columns, :base_columns, :column_signature
+    attr_accessor :report_table
+    attr_accessor :nrows
+    attr_accessor :created_at, :started_at, :finished_at
+
+    # Construct report_table name from column names and types.
+    def report_table
+      @report_table ||=
+        "#{name}_#{column_signature}".
+        gsub(/[^a-z0-9_]/i, '_').freeze
+    end
+
+    def column_signature
+      @column_signature ||=
+        begin
+          return @column_signature = "ERROR" if base_columns.empty?
+          column_signature_string = columns.to_json
+          @column_signature_hash = Digest::MD5.hexdigest(column_signature_string)
+          Base64.strict_encode64(Digest::MD5.digest(column_signature_string)).
+            sub(/=+$/, '').
+            gsub(/[^a-z0-9]/i, '_').
+            downcase.
+            freeze
+        end
+    end
+
+    def base_columns
+      @base_columns ||= EMPTY_Array
+    end
+
+    def additional_columns
+      @additional_columns ||= EMPTY_Array
+    end
+
+    def columns
+      @columns ||=
+        base_columns +
+        additional_columns.map{|x| x.map(&:to_s)}
+    end
+
+    def run! conn
+      runner = Qreport::ReportRunner.new
+      runner.connection = conn
+      runner.run!(self)
+      self
+    end
+
+    def error
+      self.error = @error if String === @error
+      @error
+    end
+
+    def error= x
+      case x
+      when nil, Hash
+        @error = x
+      when String
+        @error = JSON.parse(x)
+      when Exception
+        @error = { :error_class => x.class.name, :error_message => x.message }
+      else
+        raise TypeError
+      end
+    end
+
+    def self.schema! conn, options = { }
+      result = conn.run <<"END", options.merge(:capture_error => true) # , :verbose => true
+CREATE SEQUENCE qr_report_runs_pkey;
+CREATE TABLE -- IF NOT EXISTS
+qr_report_runs (
+    id           INTEGER PRIMARY KEY DEFAULT nextval('qr_report_runs_pkey')
+  , name         VARCHAR(255) NOT NULL
+  , sql          TEXT NOT NULL
+  , description  TEXT NOT NULL
+  , arguments    TEXT NOT NULL
+  , base_columns TEXT NOT NULL
+  , additional_columns TEXT NOT NULL
+  , report_table VARCHAR(255) NOT NULL
+  , error        TEXT
+  , created_at   TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+  , started_at   TIMESTAMP WITH TIME ZONE
+  , finished_at  TIMESTAMP WITH TIME ZONE
+  , nrows        INTEGER
+);
+CREATE INDEX qr_report_runs__name ON qr_report_runs (name);
+CREATE INDEX qr_report_runs__report_table ON qr_report_runs (report_table);
+CREATE INDEX qr_report_runs__created_at ON qr_report_runs (created_at);
+END
+    end
+
+    def insert!
+      values = {
+        :name => name,
+        :sql => sql,
+        :description => description,
+        :arguments => (arguments || { }),
+        :base_columns => base_columns,
+        :additional_columns => additional_columns,
+        :report_table => report_table,
+        :error => error,
+        :created_at => created_at,
+        :started_at => started_at,
+        :finished_at => finished_at,
+        :nrows => nrows,
+      }
+
+      result = conn.run 'INSERT INTO qr_report_runs ( :NAMES ) VALUES ( :VALUES ) RETURNING id',
+      :arguments => { :names_and_values => values } # , :verbose => true, :verbose_arguments => true
+      self.id = result.rows[0]["id"] or raise "no id"
+
+      self
+    end
+
+    def _options options
+      options ||= EMPTY_Hash
+      arguments = options[:arguments] || EMPTY_Hash
+      arguments = arguments.merge(:qr_run_id => id)
+      options.merge(:arguments => arguments)
+    end
+
+    def update! options = nil
+      options = _options options
+      values = options[:values] || EMPTY_Hash
+      if Array === values
+        h = { }
+        values.each { | k | h[k] = send(k) }
+        values = h
+      end
+      options[:arguments].update(:names_and_values => values)
+      # options.update :verbose => true, :verbose_result => true # , :dry_run => true
+      conn.run <<"END", options
+UPDATE qr_report_runs
+SET :SET_VALUES
+WHERE id = :qr_run_id
+:WHERE?
+END
+    end
+
+    def select options = nil
+      options = _options options
+      _select({:order_by => 'ORDER BY qr_run_row'}.merge(options))
+    end
+
+    def _select options = nil
+      options = _options options
+      columns = options[:COLUMNS] || '*'
+      columns = conn.safe_sql(columns)
+      order_by = conn.safe_sql(options[:order_by] || '')
+      options[:arguments].update(
+                          :COLUMNS => columns,
+                          :ORDER_BY => order_by)
+      conn.run "SELECT :COLUMNS FROM #{report_table} WHERE qr_run_id = :qr_run_id :WHERE? :ORDER_BY?", options
+    end
+
+    # Deletes this report and its rows.
+    def delete! options = nil
+      truncate!
+      options = _options options
+      options.update(:capture_error => true)
+      conn.run "DELETE FROM qr_report_runs WHERE id = :qr_run_id", options # .merge(:verbose => true)
+      result =
+      conn.run "SELECT COUNT(*) AS \"count\" from qr_report_runs WHERE report_table = :report_table",
+      :arguments => { :report_table => report_table }, :capture_error => true # , :verbose => true
+      if result.rows[0]["count"] <= 0
+        conn.run "-- DROP TABLE #{report_table}", :capture_error => true  # , :verbose => true
+      end
+    end
+
+    # Deletes the actual rows for this report run.
+    def truncate! options = nil
+      options = _options options
+      options.update(:capture_error => true)
+      conn.run "DELETE FROM #{report_table} WHERE qr_run_id = :qr_run_id :WHERE?", options
+      self
+    end
+  end
+end

data/lib/qreport/report_runner.rb

@@ -0,0 +1,123 @@
+require 'qreport/report_run'
+require 'qreport/connection'
+require 'digest/md5'
+require 'base64'
+require 'json'
+require 'pp'
+
+module Qreport
+  class ReportRunner
+    attr_accessor :connection, :verbose
+
+    def run! report_run
+      report_run.created_at ||=
+        report_run.started_at = Time.now.utc
+      name = report_run.name
+      sql  = report_run.sql.strip
+
+      arguments = report_run.arguments || { }
+      error = error_1 = error_2 = nrows = nil
+
+      Connection.current = connection
+
+      begin
+        conn.transaction do
+
+          # Create a report row sequence:
+          run "CREATE TEMPORARY SEQUENCE qr_row_seq"
+
+          # Rewrite query to create result table rows:
+          arguments = arguments.merge(:qr_run_id => conn.safe_sql("nextval('qr_row_seq')"))
+          report_run.report_sql = report_sql(sql)
+
+          # Proof query to infer base columns:
+          result = run report_run.report_sql, :limit => 0, :arguments => arguments, :verbose => @verbose
+          report_run.base_columns = result.columns
+          result = nil
+        end # transaction
+      rescue ::Exception => exc
+        error = error_1 = exc
+      end
+
+      # Construct report_table name from column names and types:
+      report_table = report_run.report_table
+
+      conn.transaction do
+        # Create new ReportRun row:
+        report_run.insert!
+        report_run_id = report_run.id
+        arguments[:qr_run_id] = report_run_id
+        report_run.report_sql = report_sql(sql)
+      end # transaction
+
+      unless error
+        # Run query into report table:
+        begin
+          conn.transaction do
+            unless conn.table_exists? report_table
+              run "CREATE TABLE #{report_table} AS #{report_run.report_sql}", :arguments => arguments, :verbose => @verbose
+              run "CREATE INDEX #{report_table}_i1 ON #{report_table} (qr_run_id)"
+              run "CREATE INDEX #{report_table}_i2 ON #{report_table} (qr_run_row)"
+              run "CREATE UNIQUE INDEX #{report_table}_i3 ON #{report_table} (qr_run_id, qr_run_row)"
+              report_run.additional_columns.each do | n, t, d |
+                run "ALTER TABLE #{report_table} ADD COLUMN #{conn.escape_identifier(n)} #{t} DEFAULT :d", :arguments => { :d => d || nil }
+              end
+            else
+              result =
+              run "INSERT INTO #{report_table} #{report_run.report_sql}", :arguments => arguments, :verbose => @verbose
+
+              # Get the number of report run rows from cmd_status:
+              unless cs = result.cmd_status and cs[0] == 'INSERT' and cs[1] == 0 and nrows = cs[2]
+                raise Error, "cannot determine nrows"
+              end
+            end
+            # Get the number of report run rows:
+            unless nrows || error
+              result = report_run._select :COLUMNS => 'COUNT(*) AS "nrows"' #, :verbose => true
+              nrows = result.rows[0]["nrows"] || (raise Error, "cannot determine nrows")
+            end
+            # pp result
+            result = nil
+          end # transaction
+        rescue ::Exception => exc
+          error = error_2 = exc
+        end # transaction
+      end
+
+      conn.transaction do
+        run "DROP SEQUENCE qr_row_seq" unless error_1
+
+        # Update stats:
+        report_run.finished_at = Time.now.utc
+        report_run.nrows = nrows.to_i
+        report_run.error = error
+        report_run.update! :values => [ :nrows, :finished_at, :error ] # , :verbose_result => true
+      end # transaction
+
+      report_run
+    end
+
+    def report_sql sql
+      sql = sql.sub(/\ASELECT\s+/im, <<"END"
+SELECT
+    :qr_run_id
+       AS "qr_run_id"
+  , nextval('qr_row_seq')
+       AS "qr_run_row"
+  , 
+END
+          )
+      sql
+    end
+
+    def run *args
+      # conn.verbose = true
+      conn.run *args
+    end
+
+    def connection
+      @connection ||= Connection.new
+    end
+    alias :conn :connection
+  end
+end

data/lib/qreport/version.rb

@@ -0,0 +1,3 @@
+module Qreport
+  VERSION = "0.0.2"
+end

data/qreport.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qreport/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "qreport"
+  gem.version       = Qreport::VERSION
+  gem.authors       = ["Kurt Stephens"]
+  gem.email         = ["ks.github@kurtstephens.com"]
+  gem.description   = %q{Automatically creates materialized report tables from a SQL query.}
+  gem.summary       = %q{Automatically creates materialized report tables from a SQL query.}
+  gem.homepage      = "http://github.com/kstephens/qreport"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake', '>= 0.9.0'
+  gem.add_development_dependency 'rspec', '~> 2.12.0'
+  gem.add_development_dependency 'simplecov', '~> 0.7.1'
+
+  gem.add_dependency 'pg', '~> 0.14'
+end

data/spec/connection_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'qreport/connection'
+
+describe Qreport::Connection do
+  QREPORT_TEST_CONN = [ nil ]
+  def conn
+    QREPORT_TEST_CONN[0] ||= Qreport::Connection.new
+  end
+
+  it "can to connect to a test database." do
+    conn.conn.class.should == PG::Connection
+  end
+
+  it "can manage transaction state." do
+    conn.should_receive(:_transaction_begin).once
+    conn.should_receive(:_transaction_commit).once
+    conn.should_receive(:_transaction_abort).exactly(0).times
+    conn.in_transaction?.should == false
+    conn.transaction do
+      conn.in_transaction?.should == true
+    end
+    conn.in_transaction?.should == false
+  end
+
+  it "can manage nested transactions." do
+    conn.should_receive(:_transaction_begin).once
+    conn.should_receive(:_transaction_commit).once
+    conn.should_receive(:_transaction_abort).exactly(0).times
+    conn.in_transaction?.should == false
+    conn.transaction do
+      conn.in_transaction?.should == true
+      conn.transaction do
+        conn.in_transaction?.should == true
+      end
+      conn.in_transaction?.should == true
+    end
+    conn.in_transaction?.should == false
+  end
+
+  it "can manage transaction state during raised exceptions" do
+    conn.should_receive(:_transaction_begin).once
+    conn.should_receive(:_transaction_commit).exactly(0).times
+    conn.should_receive(:_transaction_abort).once
+    lambda do
+      conn.transaction do
+        raise Qreport::Error, "#{__LINE__}"
+      end
+    end.should raise_error(Qreport::Error)
+    conn.in_transaction?.should == false
+  end
+
+  it "can dup to create another connection." do
+    conn1 = Qreport::Connection.new
+    conn1.fd.should == nil
+    conn1.conn
+    conn1.fd.class.should == Fixnum
+    conn2 = nil
+    conn1.transaction do
+      conn1.in_transaction?.should == true
+      conn2 = conn1.dup
+      conn2.in_transaction?.should == false
+    end
+    conn1.in_transaction?.should == false
+    conn2.fd.should == nil
+    conn2.conn
+    conn2.fd.class.should == Fixnum
+    conn2.fd.should_not == conn1.fd
+    conn2.in_transaction?.should == false
+  end
+
+  it 'can set conn.' do
+    conn1 = conn
+    conn1.conn.class.should == PG::Connection
+    conn2 = Qreport::Connection.new(:conn => conn1.conn)
+    conn2.conn.object_id.should == conn1.conn.object_id
+    conn2.conn_owned.should be_false
+  end
+
+  it 'can close conn.' do
+    conn.conn.class.should == PG::Connection
+    conn.conn_owned.should_not be_false
+    conn.close
+    conn.instance_variable_get('@conn').should == nil
+    conn.conn_owned.should be_false
+    conn.close
+    conn.instance_variable_get('@conn').should == nil
+  end
+
+  describe "#escape_value, #unescape_value" do
+  [
+    [ nil, 'NULL' ],
+    [ true, "'t'::boolean" ],
+    [ false, "'f'::boolean" ],
+    [ 1234, '1234' ],
+    [ -1234, '-1234' ],
+    [ 1234.45, '1234.45' ],
+    [ "string with \", \\, and \'", "'string with \", \\, and '''" ],
+    [ :a_symbol!, "'a_symbol!'", :a_symbol!.to_s ],
+    [ Time.parse('2011-04-27T13:23:00.000000Z'), "'2011-04-27T13:23:00.000000Z'::timestamp", Time.parse('2011-04-27T13:23:00.000000') ],
+  ].each do | value, sql, return_value |
+    it "can handle encoding #{value.class.name} value #{value.inspect} as #{sql.inspect}." do
+      conn.escape_value(value).should == sql
+    end
+    it "can handle decoding #{value.class.name} value #{value.inspect}." do
+      sql_x = conn.escape_value(value)
+      r = conn.run "SELECT #{sql_x}"
+      r = r.rows.first.values.first
+      r.should == (return_value || value)
+    end
+  end
+    it "raises TypeError for other values." do
+      lambda do
+        conn.escape_value(Object.new)
+      end.should raise_error(TypeError)
+    end
+  end
+
+end