i_dig_sql 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc217b63c8a06244155e7007377bca783c611b36
-  data.tar.gz: c284841ef57010e523b15405072726c7d5f6125f
+  metadata.gz: 5a72cee2c11ff760fcb5227b539fa976a39dfb56
+  data.tar.gz: a418aba79878b9361f980f137c7be1b108e3ee74
 SHA512:
-  metadata.gz: afd3204cc8130e91f844b192641cd44829ba544d92cec68fd6b7766d688f11564de76ecaa3ae16aa5472515234f6c1962d06447e0b448d69869c0ef01a54e1fd
-  data.tar.gz: e403fe4f10c7b8ec7e9b323fa8c3907f216682ac4fd5159af99505e92f0cf5ee0140df7acb42896e7148c1e4aee99efca0785f6964f155efa74b96f5647a224b
+  metadata.gz: 1e7ef6053d12c991ab562da0c882bc510babae4c315e108e7bb34c67855e998106ea51ccc1f5c4384a88d9f5c0fdbaf8b2f183539d1c3a40b208b4be73431de5
+  data.tar.gz: 43c7bca10bbb494ab492e7ad1852ecbd992ba80b96832056bf6760b7f8c2a533023faeb8df91ab595bf30e04c38081d927367ad522f269245b1f6b5c8f113aae

data/README.md

@@ -1,29 +1,19 @@
 # I\_Dig\_Sql
 
-My way of managing SQL fragments using Ruby.
 
-# Warning:
+I'm still learning how to write decent SQL queries
+in Postgresql 9.4.  I'm using this to manage
+sub-queries in complicated SQL queries.
 
-You will hate using this.
-Instead, use:
+You won't find this useful and I am too lazy/busy
+to write decent documentation for something
+no one but me will use for esoteric purposes.
+
+Instead, this to for SQL + Ruby:
 
   * [Arel](http://github.com/rails/arel).
   * K'bam [https://github.com/vilnius-leopold/kbam](https://github.com/vilnius-leopold/kbam)
-
-# History
-
-I had trouble maintaining BIG sql queries.
-
-I tried many things.
-
-The best way (within my preferences)
-was to use sub-queries, CTEs, avoid joins as much as possible,
-and this gem to manage SQL fragments and CTEs.
-
-Naturally, you would want to use prepared statements, compiled wat-cha-me-call-its,
-  functions, views, thing-ma-jig-ers, and other tools available in your RDBMS.
-
-So this gem is for lazy, stupid people like me.
+  * Sequel [http://sequel.jeremyevans.net/rdoc/files/doc/querying_rdoc.html](http://sequel.jeremyevans.net/rdoc/files/doc/querying_rdoc.html)
 
 # Usage
 
@@ -52,6 +42,7 @@ Please note that none of this is ready yet.
   ^
 
   sql.to_sql
+
 ```
 
 

data/VERSION

@@ -1 +1 @@
-2.0.0
+3.0.0

data/bin/test

@@ -2,9 +2,46 @@
 # -*- bash -*-
 #
 #
+x="$1"
 set -u -e -o pipefail
 
+if [[ "$x" == "watch" ]]; then
+  shift
 
-bundle exec bacon -rpry -ri_dig_sql specs/i_dig_sql.rb "$@"
+  echo ""
+  echo "=== Watching: $@"
+
+  echo -e "\n=== Running test:"
+  bin/test "$@" || echo ""
+
+  inotifywait -q -m -e close_write,close --exclude .git/ -r .  | while read CHANGE
+  do
+
+    dir=$(echo "$CHANGE" | cut -d' ' -f 1)
+    op=$(echo "$CHANGE" | cut -d' ' -f 2)
+    file=$(echo "$CHANGE" | cut -d' ' -f 3)
+    path="${dir}$file"
+
+    if [[ "$op" == *CLOSE_WRITE* && $file == *.rb*  ]]; then
+      echo -e "\n=== Running test:"
+      bin/test "$@" || echo ""
+    fi
+
+  done # === do
+
+  echo ""
+  exit 0
+fi # === if watch
+
+files="$(echo specs/*-$x.rb)"
+if [[ -f "$files" ]]; then
+  shift
+else
+  files="$(echo specs/*-*.rb)"
+fi
+
+
+
+bundle exec bacon -rpry -ri_dig_sql specs/helpers.rb $files "$@"
 
 

data/i_dig_sql.gemspec

@@ -21,8 +21,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler" , "~> 1.5"
-  spec.add_development_dependency "bacon"   , '~> 1.0'
-  spec.add_development_dependency "Bacon_Colored"   , '~> 0'
-  spec.add_development_dependency "pry"     , '~> 0'
+  spec.add_development_dependency "bundler"            , "> 1.5"
+  spec.add_development_dependency "bacon"              , '> 1.0'
+  spec.add_development_dependency "Bacon_Colored"      , '> 0'
+  spec.add_development_dependency "pry"                , '> 0'
+  spec.add_development_dependency "awesome_print"      , '> 0'
+  spec.add_development_dependency "anbt-sql-formatter" , '> 0'
+  spec.add_development_dependency "rouge" , '> 0.0.0'
+  spec.add_development_dependency "unindent" , '> 0.0.0'
 end

data/lib/i_dig_sql.rb

@@ -1,124 +1,447 @@
 
+require "i_dig_sql/H"
+
 class I_Dig_Sql
 
   include Enumerable
+
   HAS_VAR = /(\{\{|\<\<)[^\}\>]+(\}\}|\>\>)/
+  SELECT_FROM_REG = /SELECT.+FROM.+/
+
+
+  ALL_UNDERSCORE   = /\A[_]+\Z/
+  COMBO_LEFT_RIGHT = [:left, :left, :right, :right]
+  COMBO_OUT_IN     = [:out, :in, :out, :in]
 
   Duplicate = Class.new RuntimeError
 
   class << self
   end # === class self ===
 
-  class H < Hash
+  attr_reader :digs, :WITHS, :data
+  def initialize *args
+    @WITH     = nil
+    @FRAGMENT = nil
+    @SQL      = nil
+    @WITHS    = []
 
-    def [] name
-      fail ArgumentError, "Unknown key: #{name.inspect}" unless has_key?(name)
-      super
-    end
+    @digs  = []
+    @data  = H.new(:allow_update)
+    .merge!(
+      :name  => nil,
+      :raw   => nil,
+      :vars  => H.new,
+      :procs => H.new
+    )
 
-    def []= name, val
-      if has_key?(name) && self[name] != val
-        fail ArgumentError, "Key already set: #{name.inspect}"
-      end
+    args.each { |a|
 
-      super
-    end
+      case a
 
-    def merge_these *args
-      args.each { |h|
-        h.each { |k,v|
-          self[k] = v
-        }
-      }
-      self
-    end
+      when Symbol
+        @data[:name] = a
 
-  end # === class H
+      when I_Dig_Sql
+        @digs << a
+
+      when String
+        @data.merge!(:raw=>a)
+
+      when Hash, H
+        if a.has_key?(:raw)
+          @data.merge! a
+        else
+          @data[:vars].merge! a
+        end
+
+      else
+        fail ArgumentError, "Unknown arg: #{a.inspect}"
+
+      end  # === case
 
-  attr_reader :sqls, :vars
-  def initialize *args
-    @digs = args.select { |a|
-      a.is_a? I_Dig_Sql
     }
 
-    @sqls = H.new
-    @vars = H.new
+  end # === def initialize
+
+  %w{name raw vars}.each { |k|
+    eval <<-EOF.strip, nil, __FILE__, __LINE__
+      def #{k}
+        @data[:#{k}]
+      end
+    EOF
+  }
+
+  def vars!
+    vars = H.new.merge!(@data[:vars])
+
+    @digs.reverse.inject(vars) { |memo, dig|
+      if dig != self
+        memo.merge! dig.vars
+      end
+      memo
+    }
+  end
+
+  def has_key? name
+    !!(search name)
+  end
 
-    @sqls.merge_these *(@digs.map(&:sqls))
-    @vars.merge_these *(@digs.map(&:vars))
+  def search name
+    fail ArgumentError, "No name specified: #{name.inspect}" if !name
+    return self if self.name == name
+    found = false
+    if @data[:procs].has_key?(name)
+      return @data[:procs][name]
+    end
 
-    @string = args.select { |s| s.is_a? String }.join("\n")
+    @digs.reverse.detect { |d|
+      found = if d.name == name
+                d
+              elsif d.data[:procs].has_key?(name)
+                d.data[:procs][name]
+              else
+                d.digs.detect { |deep|
+                  found = deep if deep.name == name
+                  found = deep.data[:procs][name] if deep.data[:procs].has_key?(name)
+                  found
+                }
+              end
+    }
+    found
   end
 
   def [] name
-    @sqls[name]
+    found = search(name)
+    fail ArgumentError, "SQL not found for: #{name.inspect}" unless found
+    found
   end
 
   def []= name, val
-    @sqls[name] = val
+    fail ArgumentError, "Name already taken: #{name.inspect}" if has_key?(name)
+
+    case val
+    when String
+      @digs << I_Dig_Sql.new(self, name, val)
+
+    when Hash, H
+      case
+      when val[:name] == :DEFAULT
+        @digs << I_Dig_Sql.new(:DEFAULT, val)
+      when val[:raw]
+        @data.merge! val
+      else
+        @digs << I_Dig_Sql.new(self, name, val)
+      end
+
+    when I_Dig_Sql
+      @digs << val
+
+    when Proc
+      @data[:procs][name] = val
+
+    else
+      fail ArgumentError, "Unknown class: #{name.inspect} -> #{val.class}"
+
+    end # === case
   end
 
   def each
+    digs = @digs.reverse
+    digs.unshift self
     if block_given?
-      @sqls.each { |k, v| yield k, v }
+      digs.each { |d| yield d.name, d }
     else
-      @sqls.each
+      digs.each
     end
   end
 
+
   def << str
-    @string << (
-      if @string.empty?
-        str
-      else
-        "\n" << str
-      end
-    )
+    (@data[:raw] ||= "") << str
+  end
+
+  def has_raw?
+    !!(@data[:raw] && !@data[:raw].strip.empty?)
   end
 
   def to_pair
-    [to_sql, vars]
+    [to_sql, vars!]
+  end
+
+  def to_meta *args
+    compile *args
+  end
+
+  def to_sql *args
+    compile(*args)[:SQL]
+  end
+
+  %w{ FRAGMENT SQL }.each { |k|
+    eval <<-EOF.strip, nil, __FILE__, __LINE__ + 1
+      def #{k}
+        return @#{k} if @SQL
+        to_meta[:#{k}]
+      end
+    EOF
+  }
+
+  private # ==========================================
+
+  def prefix_raw sym
+    "raw_#{sym.to_s.split('_').first}".to_sym
   end
 
-  def to_sql
-    s    = @string.dup
-    ctes = []
+  def prefix sym
+    sym.to_s.split('_').first.to_sym
+  end
+
+  protected(
+    def table_name one, two = nil
+      if two
+        k = two
+        link_name = one
+      else
+        k = one
+        link_name = nil
+      end
+
+      case
+      when [:out_ftable, :in_ftable].include?(k)
+        "#{real_table}_#{ meta[prefix(k)] }_#{meta[k]}"
+
+      when link? && link_name && @data[link_name][:inner_join].include?(k)
+        "#{self.name}_#{@data[link_name][:name]}_#{k}"
+
+      else
+        fail ArgumentError, "Unknown key for table name: #{k.inspect}"
+      end
+    end
+  ) # === protected
+
+  #
+  # Examples:
+  #
+  #   field :in, :owner_id
+  #   field :screen_name, :screen_name
+  #   field :in
+  #   field :raw_in
+  #
+  protected(
+    def field *args
+
+      case args
+      when [:out], [:in]
+        "#{name}.#{data[args.last][:name]}"
+      when [:raw, :out], [:raw, :in]
+        "#{name}.#{self[:DEFAULT].data[args.last]}"
+      when [:owner_id], [:type_id]
+        "#{name}.#{args.first}"
+      else
+        fail ArgumentError, "Unknown args: #{args.inspect}"
+      end # === case
+
+    end # === def field
+  )
 
-    while s[HAS_VAR]
+  protected def compile target = nil
+    return(self[target].compile) if target && target != name
+
+    if !@SQL
+      compile_raw
+    end
+
+    {FRAGMENT: @FRAGMENT, SQL: @SQL, WITH: @WITH, VARS: vars!}
+  end # === def to_sql
+
+  def compile_raw
+    @data[:raw].freeze
+
+    s = @FRAGMENT = @data[:raw].dup
+
+    while s[HAS_VAR] 
       s.gsub!(/\{\{\s?([a-zA-Z0-9\_]+)\s?\}\}/) do |match|
         key = $1.to_sym
-        ctes << key
+        @WITHS << key
         key
       end
 
       s.gsub!(/\<\<\s?([a-zA-Z0-9\_\-\ \*]+)\s?\>\>/) do |match|
         tokens = $1.split
-        key    = tokens.pop.to_sym
-        field  = tokens.empty? ? nil : tokens.join(' ')
 
-        case
-        when field
-          ctes << key
-          "SELECT #{field} FROM #{key}"
+        key = tokens.last.to_sym
+
+        if has_key?(key)
+
+          tokens.pop
+          target = self[key]
+
+          if target.is_a?(Proc)
+            target.call self, *tokens
+          else
+            field  = tokens.empty? ? nil : tokens.join(' ')
+
+            if field
+              @WITHS << key
+              tokens.pop
+              "SELECT #{field} FROM #{key}"
+            else
+              target.to_sql
+            end
+          end
+
+        elsif has_key?(tokens.first.to_sym)
+          self[tokens.shift.to_sym].call self, *tokens
+
         else
-          self[key]
-        end
+          fail ArgumentError, "Not found: #{$1}"
+
+        end # === if has_key?
       end
+    end # === while s HAS_VAR
+
+    @WITH = if @WITHS.empty?
+              ""
+            else
+              %^WITH\n  #{WITH()}\n\n^
+            end
+
+    @SQL = (@WITH + @FRAGMENT).strip
+  end # === fragments_to_raw
+
+  def WITH
+    withs = @WITHS.dup
+    maps  = []
+    done  = {}
+    while name = withs.shift
+      next if done[name]
+      if name == :DEFAULT || !self.has_key?(name)
+        done[name] = true
+        next
+      end
+
+      fragment = self[name].FRAGMENT
+      fragment.gsub!(/^/, "    ") if ENV['IS_DEV']
+      maps << "#{name} AS (\n#{fragment}\n  )"
+      withs.concat self[name].WITHS
+      done[name] = true
+    end # === while name
+
+    maps.join ",\n  "
+  end
+
+  def WHERE
+    wheres = @data[:WHERE].dup
+
+    if link? && name != :block
+      wheres << "#{field :type_id} = :#{name.to_s.upcase}_TYPE_ID"
+
+      pattern = [ data[:out][:inner_join], data[:in][:inner_join] ]
+      left, mid = data[:out][:inner_join]
+      right, _  = *data[:in][:inner_join]
+
+
+      case
+      when [[:screen_name], [:screen_name]], [[:screen_name, :computer],[:screen_name]]
+        # do nothing
+      else
+        fail "Programmer Error: Permissions not implemented for: #{pattern.inspect}"
+      end # === case
+
+      if left == :screen_name && right == :screen_name
+        default = self[:DEFAULT]
+        block   = self[:block]
+        blocked = block.table_name(:out, :screen_name)
+        victim  = block.table_name(:in, :screen_name)
+        f_in    = table_name :in, :screen_name
+        f_out   = table_name :out, :screen_name
+
+        wheres << %^
+        NOT EXISTS (
+          SELECT 1
+          FROM #{block.real_table} AS block
+          WHERE
+            (
+              block.type_id = :BLOCK_SCREEN_TYPE_ID
+              AND (
+                (
+                  #{f_out}.owner_id = #{block.field :out}
+                  AND
+                  #{f_in}.owner_id = #{victim}.owner_id
+                )
+                OR
+                (
+                  #{field :raw, :in} = #{block.field :out}
+                  AND
+                  #{blocked}.owner_id = #{victim}.owner_id
+                )
+              )
+            )
+            OR
+            (
+              block.type_id = :BLOCK_OWNER_TYPE_ID
+              AND (
+                (
+                  #{f_out}.owner_id = #{blocked}.owner_id
+                  AND
+                  #{f_in}.owner_id = #{victim}.owner_id
+                )
+                OR
+                (
+                  #{f_in}.owner_id = #{blocked}.owner_id
+                  AND
+                  #{f_out}.owner_id = #{victim}.owner_id
+                )
+              ) -- AND
+            )
+        ) -- NOT EXISTS
+        ^
+      end # === if :screen_name, :screen_name
+
+      if mid == :computer
+        asql(wheres.last)
+        fail "COMPUTER not ready"
+      end
+
+    end # === if link?
+
+    if @data.has_key?(:OF)
+      table = self[@data[:FROM].first]
+      wheres << "#{table.field(:out)} = #{@data[:OF].first}"
     end
 
-    return s if ctes.empty?
-
-    %^
-      WITH
-      #{ctes.uniq.map { |k| "#{k} AS (
-        #{self[k]}
-      )" }.join "
-      ,
-      "}
-      #{s}
-    ^
+    if false && @data[:NOT_EXISTS]
+      block = self[meta[:not_exists]]
+      w = ""
+      w << %^  NOT EXISTS (\n^
+      w << %^    SELECT 1\n^
+      w << %^    FROM #{meta[:not_exists]}\n^
+      w << %^    WHERE\n^
+
+      conds = []
+      block[:where].each { |block_meta|
+        type_id = block_meta.first
+        c = ""
+        c << %^    (\n^
+        c << "      #{field meta, block_meta[1][1], block_meta[1][2]} = #{field block, block_meta[2][1], block_meta[2][2]}\n"
+        c << "      AND\n"
+        c << "      #{meta[:not_exists]}.type_id = :#{type_id}_TYPE_ID\n"
+        c << "      AND\n"
+        c << "      #{field meta, block_meta[3][1], block_meta[3][2]} = #{field block, block_meta[4][1], block_meta[4][2]}\n"
+        c << %^    )\n^
+        conds << c
+      }
+
+      w << conds.join("    OR\n")
+      sql[:WHERE] << w
+    end
+
+
+    return nil if wheres.empty?
+    wheres.join " AND "
   end
 
+  # === END: Rendering DSL ==========================================
+
 end # === class I_Dig_Sql ===