i_dig_sql 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ae4c695ed603413f388c21a16a29f566900b39b
-  data.tar.gz: 25cb2010433d132f33a3139a33d0e37469dd121a
+  metadata.gz: 5c3f4ef668f82b48eec51d0df59388fd5e8fa98d
+  data.tar.gz: 25e21fb88208f4d9fdadf7a7cead463d2a0fb17a
 SHA512:
-  metadata.gz: 7461f1a40db3b2ade971005bf6295efa1957c5c955aced4574d0854cf36fdbb56da6456c0bbfa658b61ded80c15ef57c3d665642590cd0dd1273d71eb18095b5
-  data.tar.gz: ba10c377579ed13fd6d9e4a525f8b324f824b23e5e6120e4a166afa9ef5943833e6e096f088e896d9ae6401b9b68c69e8c650b00a19bb9b552571418981dfe49
+  metadata.gz: e889e9ec8ccb723c62f3cd8cecbe2450bc228336763c6eb27b13ae8acb4c8bb788cbf5a4cbf7fbd00654c14dfdd073aeb84aa2453a839479f613c1f464e5a3ef
+  data.tar.gz: 76929d84b06a279b22572a0f0a056c6ebb509eb5224000ead47d60b27303d6393241d2c27d10f76be19cd9dd462f57bac3fc54d60f0536f5f21aa8d79863b55e

data/README.md

@@ -1,23 +1,55 @@
 # I\_Dig\_Sql
 
-My way of generating SQL using Ruby.
+My way of managing SQL fragments using Ruby.
 
 # Warning:
 
-Don't use this. Instead, use [Arel](http://github.com/rails/arel).
+You will hate using this.
+Instead, use:
 
-# Another warning:
+  * [Arel](http://github.com/rails/arel).
+  * K'bam [https://github.com/vilnius-leopold/kbam](https://github.com/vilnius-leopold/kbam)
 
-This is not yet usable.
+# History
 
-## Usage
+I had trouble maintaining BIG sql queries.
 
-Not coming anytime soon.
+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.
 
-## Alternatives:
+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.
 
-  * K'bam [https://github.com/vilnius-leopold/kbam](https://github.com/vilnius-leopold/kbam)
+So this gem is for lazy, stupid people like me.
+
+# Usage
+
+Please note that none of this is ready yet.
+
+```ruby
+
+  require 'i_dig_sql'
+
+  sql = I_Dig_Sql.new
+  sql[:HEROES]   = "SELECT id FROM hero    WHERE id = :PERSON_ID"
+  sql[:VILLIANS] = "SELECT id FROM villian WHERE id = :PERSON_ID"
+  sql << %^
+    SELECT *
+    FROM people
+    WHERE
+      id IN ( {{{ HEROES }}} AND status = :ALIVE)
+      OR
+      id IN (SELECT ID FROM {{ HEROES }} AND status = :ALIVE)
+      OR
+      id IN ( {{ * HEROES }} )
+      OR
+      id IN ( {{ ! VILLIANS }} )
+  ^
 
+  sql.to_sql
+```
 
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+1.0.0

data/bin/test

@@ -5,6 +5,6 @@
 set -u -e -o pipefail
 
 
-bundle exec bacon specs/*
+bundle exec bacon -rpry -ri_dig_sql specs/i_dig_sql.rb "$@"
 
 

data/englishy_sql.rb

@@ -0,0 +1,95 @@
+
+require 'pry'
+require 'sequel'
+DB = Sequel.mock
+
+class Englishy_Sql
+
+  Duplicate = Class.new RuntimeError
+
+  def initialize
+    @sql  = {}
+    @vals = {}
+    instance_eval(&(Proc.new))
+  end # === def initialize
+
+  def val name, v
+    if @vals.has_key?(name) && @vals[name] != v
+      fail Duplicate, "Already set w/different value: #{name.inspect}"
+    end
+  end
+
+  def screen_name name
+    val :SCREEN_NAME, name.to_s.strip.upcase
+    sql(:SCREEN_NAME) {
+
+      any! {
+        owner_id.==(:AUDIENCE_ID)
+        all {
+          no_block
+          any! {
+            WORLD!
+            allowed
+          }
+        }
+      } # === any
+
+      one!
+    } # === sql
+  end
+
+  def post
+    @sql = @sql.where(:id=> DB[:post].select(:id) )
+  end # === def post
+
+  def comments
+    @sql = @sql.or(:parent_id=>DB[:comment].select(:id))
+  end
+
+  def sql *args
+    case
+    when args.empty?
+      @sql.sql
+
+    when args.size == 2
+      name, v = args
+      is_dup  = @sql.has_key?(name) && @sql[name] != v
+      fail Duplicate, "Already set w/different value: #{name.inspect}" if is_dup
+
+    else
+      fail ArgumentError, "Unknown args: #{args.inspect}"
+
+    end # === case
+  end
+
+end # === Englishy_Sql
+
+
+puts(Englishy_Sql.new {
+  table(:computer) {
+    as(:comments)
+    any! {
+      is_owner
+    }
+  }
+}.sql)
+
+SELECT *
+FROM screen_name
+WHERE
+  owner_id = :AUDIENCE_ID
+  OR
+  (
+    :AUDIENCE_ID NOT IN  (BLOCKED)
+    AND
+    ( privacy = :WORLD
+      OR
+      (
+        privacy = :PROTECTED
+        AND
+        :AUDIENCE_ID IN (
+          ALLOWED
+        )
+      )
+    )
+  )

data/i_dig_sql.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep("bin/#{spec.name}")
+  spec.executables   = spec.files.grep("bin/#{spec.name}") { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

data/lib/i_dig_sql.rb

@@ -1,136 +1,113 @@
 
 class I_Dig_Sql
 
-  Only_One_Where = Class.new(RuntimeError)
+  include Enumerable
+
+  Duplicate = Class.new RuntimeError
 
   class << self
   end # === class self ===
 
-  def initialize sql = nil, *args
-    @withs   = []
-    @tags_for_withs = {}
-    @select  = nil
-    @as      = nil
-    @unions  = []
-    @sql     = sql
-    @args    = args
-    yield self if block_given?
-  end
-
-  def args
-    @args
-  end
-  protected :args
+  class H < Hash
 
-  def AS o = :return
-    if o == :return
-      return @as if @as
-      raise "@as not set"
+    def [] name
+      fail ArgumentError, "Unknown key: #{k.inspect}" unless has_key?(name)
+      super
     end
 
-    @as = o
-    self
-  end
+    def []= name, val
+      if has_key?(name) && self[name] != val
+        fail ArgumentError, "Key already set: #{name.inspect}"
+      end
 
-  def WITH o, *args
-    @withs << o
-    @tags_for_withs[o] = []
-    @args.concat(o.args) if o.is_a?(I_Dig_Sql)
-    @args.concat args
-    self
-  end
+      super
+    end
 
-  alias_method :comma, :WITH
+    def merge_these *args
+      args.each { |h|
+        h.each { |k,v|
+          self[k] = v
+        }
+      }
+      self
+    end
 
-  def tag_as name
-    list = @tags_for_withs[@withs.last]
-    raise "Last query was not a WITH/cte query" unless list
-    list.push name
-    self
-  end
+  end # === class H
 
-  def find_tagged name
-    @tags_for_withs.inject([]) { |memo, (k,v)|
-      if v.include?(name)
-        memo << k
-      end
-      memo
+  attr_reader :sqls, :vars
+  def initialize *args
+    @digs = args.select { |a|
+      a.is_a? I_Dig_Sql
     }
-  end
 
-  def SELECT str, *args
-    @select = {:select=>str, :args=>args, :from=>nil, :where=>nil}
+    @sqls = H.new
+    @vars = H.new
 
-    self
-  end
-
-  def FROM o
-    @select[:from] = o
+    @sqls.merge_these *(@digs.map(&:sqls))
+    @vars.merge_these *(@digs.map(&:vars))
 
-    self
+    @string = args.select { |s| s.is_a? String }.join("\n")
   end
 
-  def WHERE o, *args
+  def [] name
+    @sqls[name]
+  end
 
-    if @select[:where]
-      raise Only_One_Where.new("Multiple use of WHERE: #{@select[:where]} |--| #{o}")
-    end
+  def []= name, val
+    @sqls[name] = val
+  end
 
-    if args.size == 1 && args.first.is_a?(I_Dig_Sql)
-      sql = args.first.to_sql
-      o = "#{o} ( #{sql[:sql]} )"
-      @args.concat sql[:args]
+  def each
+    if block_given?
+      @sqls.each { |k, v| yield k, v }
     else
-      @args.concat args
+      @sqls.each
     end
-
-    @select[:where] = o
-    self
   end
 
-  def UNION o
-    @unions << o
+  def << str
+    @string << (
+      if @string.empty?
+        str
+      else
+        "\n" << str
+      end
+    )
+  end
 
-    self
+  def to_pair
+    [to_sql, vars]
   end
 
   def to_sql
-
-    if @sql
-      s = "\n  "
-      s << @sql
-    else
-
-      s = ""
-      unless @withs.empty?
-        s << "\n  WITH"
-        s << @withs.map { |w|
-          case w
-          when String
-            " #{w} "
-          else
-            " #{w.AS} AS (#{w.to_sql[:sql]}) "
-          end
-        }.join("\n,\n")
-      end
-
-      s << "\n"
-
-      if @select
-        s << "\n  SELECT #{@select[:select]}"
-        s << "\n  FROM   #{@select[:from]}"   if @select[:from]
-        s << "\n  WHERE  #{@select[:where]}"  if @select[:where]
+    s    = @string.dup
+    ctes = []
+
+    s.gsub!(/\{\{\s?(\!|\*)?\s?([a-zA-Z0-9\_]+)\s?\}\}/) do |match|
+      key = $2.to_sym
+      case $1
+      when "!"
+        self[key]
+      when "*"
+        ctes << key
+        "SELECT * FROM #{key}"
+      else
+        ctes << key
+        key
       end
-
-    end # === if @sql
-
-    if not @unions.empty?
-      s << "\n  UNION  #{@unions.map { |sql| sql.to_sql[:sql] }.join "\nUNION\n" }"
     end
 
-    s << "\n"
-
-    {:sql=>s, :args=>@args}
+    return s if ctes.empty?
+
+    %^
+      WITH
+      #{ctes.map { |k| "#{k} AS (
+        #{self[k]}
+      )" }.join "
+      ,
+      "}
+      #{s}
+    ^
   end
 
 end # === class I_Dig_Sql ===

data/specs/i_dig_sql.rb

@@ -1,14 +1,11 @@
 
-require "pry"
 require "Bacon_Colored"
-require "i_dig_sql"
-require "i_dig_sql/String"
 
 def sql o
   if o.is_a? String
     return o.split.join(" ")
   else
-    sql(o.to_sql[:sql])
+    sql(o.to_sql)
   end
 end
 
@@ -16,218 +13,143 @@ def args o
   o.to_sql[:args]
 end
 
-describe ".new" do
-
-  it "returns a I_Dig_Sql if passed a String" do
-    o = I_Dig_Sql.new("SELECT * FROM some_table")
-    o.class.should == I_Dig_Sql
-  end
-
-end # === describe it runs ===
-
-describe "#WITH()" do
-
-  it "includes passed String" do
-    o = I_Dig_Sql.new
-    o.WITH("some_table AS (SELECT * FROM other_table)")
-    sql(o).should == sql("WITH some_table AS (SELECT * FROM other_table)")
-  end
-
-  it "accepts another I_Dig_Sql object" do
-    other = I_Dig_Sql.new("SELECT * FROM main_table")
-    .AS('cte1')
-
-    o = I_Dig_Sql.new
-    .WITH(other)
-    sql(o).should == sql(%^
-      WITH cte1 AS ( SELECT * FROM main_table )
+describe :I_Dig_Sql do
+
+  it "runs the code from README.md" do
+    readme = File.read(File.expand_path(File.dirname(__FILE__) + '/../README.md'))
+    code   = readme[/```ruby([^`]+)```/] && $1
+    line   = 0
+    readme.split("\n").detect { |l| line = line + 1; l['```ruby'] }
+    result = eval(code, nil, 'README.md', line)
+    sql(result)['WITH HEROES'].should == 'WITH HEROES'
+  end # === it
+
+  it "adds WITH: {{MY_NAME}}" do
+    sql = I_Dig_Sql.new
+    sql[:MY_HERO] = "SELECT * FROM hero"
+    sql[:MY_NAME] = "SELECT * FROM name"
+    sql << %^
+      {{MY_HERO}}
+      {{MY_NAME}}
+    ^
+    sql(sql).should == sql(%^
+      WITH 
+      MY_HERO AS (
+        SELECT * FROM hero
+      )
+      ,
+      MY_NAME AS (
+        SELECT * FROM name
+      )
+      MY_HERO
+      MY_NAME
     ^)
   end
 
-  it "accepts args" do
-    o = I_Dig_Sql.new
-    .WITH(" some_table AS (SELECT * FROM other_table WHERE id = ?) ", 1)
-    args(o).should == [1]
-  end
-
-  it "merges args from other I_Dig_Sql objects" do
-    other = I_Dig_Sql.new("SELECT * FROM main_table WHERE i = ?", 1).AS('cte1')
-
-    o = I_Dig_Sql.new
-    .WITH(other)
-    args(o).should == [1]  end
-
-end # === describe #WITH() ===
-
-describe "#comma" do
-
-  it "acts like a WITH statement" do
-    o = I_Dig_Sql.new
-    .WITH('cte1 AS ( SELECT * FROM table_1 ) ')
-    .comma('cte2 AS ( SELECT * FROM table_2 )')
-
-    sql(o).should == sql(%^
-                         WITH
-                           cte1 AS ( SELECT * FROM table_1 )
-                         , cte2 AS ( SELECT * FROM table_2 )
-                         ^)
-  end
-
-  it "saves args" do
-    o = I_Dig_Sql.new
-    .WITH('cte1 AS ( SELECT * FROM table_1 ) ')
-    .comma('cte2 AS ( SELECT * FROM table_2 WHERE id = ?)', 2)
-
-    args(o).should == [2]
-  end
-
-end # === describe #comma ===
-
-describe "#to_sql" do
-
-  describe ":sql" do
-
-    it "includes both WITH and SELECT statements" do
-      o = I_Dig_Sql.new
-      o.WITH("cte AS (SELECT * FROM other_table)")
-      o.SELECT(" parent_id ")
-      .FROM("main_table")
-      sql(o).should == sql(%^
-                           WITH cte AS (SELECT * FROM other_table)
-                           SELECT parent_id
-                           FROM main_table
-                           ^)
-    end
-
-  end # === describe :sql ===
-
-  describe ":args" do
-
-    it "returns an array of arguments" do
-      o = I_Dig_Sql.new
-      .SELECT(" parent_id ")
-      .FROM("main_table")
-      .WHERE(" ? = ? AND b = ? ", 1, 2, 3)
-      args(o).should == [1,2,3]
-    end
-
-  end # === describe :args ===
-  
-
-end # === describe #to_sql ===
-
-describe "#WHERE" do
-
-  it "merges sql into string if arg is a I_Dig_Sql" do
-    other = I_Dig_Sql.new.SELECT("*").FROM("other")
-
-    o = I_Dig_Sql.new.SELECT("parent_id")
-    .FROM("main")
-    .WHERE("id IN", other)
-
-    sql(o).should == sql(%~
-      SELECT parent_id
-      FROM main
-      WHERE id IN (
-        SELECT * FROM other
+  it "adds WITH: {{ * MY_NAME }}" do
+    sql = I_Dig_Sql.new
+    sql[:MY_HERO] = "SELECT * FROM hero"
+    sql[:MY_NAME] = "SELECT * FROM name"
+    sql << %^
+      {{ * MY_NAME }}
+      {{ * MY_HERO }}
+    ^
+    sql(sql).should == sql(%^
+      WITH
+      MY_NAME AS (
+        SELECT * FROM name
+      ) ,
+      MY_HERO AS (
+        SELECT * FROM hero
       )
-    ~)
-  end
-
-  it "merges args if arg is a I_Dig_Sql" do
-    other = I_Dig_Sql.new.SELECT("*").FROM("other")
-    .WHERE("id = ", 1)
-
-    o = I_Dig_Sql.new.SELECT("parent_id")
-    .FROM("main")
-    .WHERE("id IN", other)
-
-    args(o).should == [1]
-  end
-
-  it "raises exception if used more than once" do
-    lambda {
-      I_Dig_Sql.new
-      .SELECT('*')
-      .FROM('main')
-      .WHERE("id = 1")
-      .WHERE("id = 2")
-    }.should.raise(I_Dig_Sql::Only_One_Where)
-    .message.should.match(/Multiple use of WHERE:/)
-  end
-
-end # === describe #WHERE ===
-
-
-describe "String#i_dig_sql" do
-
-  it "returns an I_Dig_Sql instance set to String" do
-    o = "SELECT id FROM my_table".i_dig_sql
-    sql(o.to_sql[:sql]).should == sql(%^SELECT id FROM my_table^)
-  end
-
-end # === describe String ===
-
-
-describe ".tag_as" do
-
-  it "adds tag to tag list of last query" do
-    o = "SELECT *".i_dig_sql
-    o.WITH("cte1 AS (SELECT * FROM table_1)")
-    .tag_as('group 1')
-    o.WITH("cte2 AS (SELECT * FROM table_2)")
-    .tag_as('group 1')
-
-    list = o.find_tagged('group 1')
-    list.size.should == 2
-    sql(list.first).should == sql("cte1 AS (SELECT * FROM table_1)")
-    sql(list.last).should  == sql("cte2 AS (SELECT * FROM table_2)")
-  end
-
-  it "raises error if last query was not a WITH/cte" do
-    o = "SELECT *".i_dig_sql
-    should.raise(RuntimeError) {
-      o.tag_as('group 1')
-    }.message.should.match /Last query was not a WITH\/cte/i
-  end
-
-end # === describe .tag_as ===
+      SELECT * FROM MY_NAME
+      SELECT * FROM MY_HERO
+    ^)
+  end # === it
+
+  it "replaces text with content: {{ ! MY_NAME }}" do
+    sql = I_Dig_Sql.new
+    sql[:MY_HERO] = "SELECT * FROM hero"
+    sql << %^
+      {{ ! MY_HERO }}
+    ^
+    sql(sql).should == "SELECT * FROM hero"
+  end # === it
+
+end # === describe :I_Dig_Sql
+
+describe '.new' do
+
+  it "merges sql values: .new(i_dig_sql)" do
+    first = I_Dig_Sql.new
+    first[:hero] = "SELECT * FROM hero"
+    second = I_Dig_Sql.new(first)
+    second[:name] = "SELECT * FROM name"
+    second << %^
+      {{ ! hero }}
+      {{ ! name }}
+    ^
+    sql(second).should == sql(%^
+      SELECT * FROM hero
+      SELECT * FROM name
+    ^)
+  end # === it
 
-describe ".find_tagged" do
+  it "combines all Strings" do
+    i = I_Dig_Sql.new "SELECT ", " * ", " FROM ", " NAME "
+    sql(i).should == sql("SELECT * FROM NAME")
+  end # === it
 
-  it "returns all WITH/cte querys with tag" do
-    o = "SELECT *".i_dig_sql
-    o.WITH("cte1 AS (SELECT * FROM table_1)")
-    .tag_as('group 1')
-    o.WITH("cte2 AS (SELECT * FROM table_2)")
-    .tag_as('group 1')
+end # === describe '.new'
 
-    list = o.find_tagged('group 1')
-    list.size.should == 2
-    sql(list.first).should == sql("cte1 AS (SELECT * FROM table_1)")
-    sql(list.last).should  == sql("cte2 AS (SELECT * FROM table_2)")
-  end
 
-  it "only returns WITH/cte querys with tags, and no others" do
-    o = "SELECT *".i_dig_sql
-    o.WITH("cte1 AS (SELECT * FROM table_1)").tag_as('group 1')
-    o.WITH("cte2 AS (SELECT * FROM table_2)").tag_as('group 1')
-    o.WITH("cte3 AS (SELECT * FROM table_3)").tag_as('group 2')
+describe :vars do
 
-    list = o.find_tagged('group 1')
-    list.size.should == 2
-    sql(list.first).should == sql("cte1 AS (SELECT * FROM table_1)")
-    sql(list.last).should  == sql("cte2 AS (SELECT * FROM table_2)")
-  end
+  it "combines vars from other digs" do
+    one   = I_Dig_Sql.new
+    one.vars[:one] = 1
 
-end # === describe find_tagged ===
+    two   = I_Dig_Sql.new
+    one.vars[:two] = 2
 
+    three = I_Dig_Sql.new
+    one.vars[:three] = 3
 
+    dig = I_Dig_Sql.new one, two, three
+    dig.vars[:four] = 4
 
+    dig.vars.should == {
+      four:  4,
+      three: 3,
+      two:   2,
+      one:   1
+    }
+  end # === it
 
+  it "fails w/Duplicate if other digs have the same var name" do
+    should.raise(ArgumentError) {
+      one = I_Dig_Sql.new
+      one.vars[:two] = 2
 
+      i = I_Dig_Sql.new one
+      i.vars[:two] = 3
+      i.vars
+    }.message.should.match /Key already set: :two/
+  end # === it
 
+end # === describe :vars
 
 
+describe :to_pair do
 
+  it "returns an Array: [String, Hash]" do
+    i = I_Dig_Sql.new <<-EOF
+      SELECT * FROM new
+    EOF
+    i.vars[:one] = 2
+    sql, vars = i.to_pair
+    sql(sql).should == sql("SELECT * FROM new")
+    vars.should == {one: 2}
+  end # === it
 
+end # === describe :to_pair

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i_dig_sql
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - da99
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-22 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,6 +82,7 @@ files:
 - Rakefile
 - VERSION
 - bin/test
+- englishy_sql.rb
 - i_dig_sql.gemspec
 - lib/i_dig_sql.rb
 - lib/i_dig_sql/String.rb