piggly 1.2.0

data/spec/fixtures/snippets.sql

@@ -0,0 +1,158 @@
+CREATE OR REPLACE FUNCTION piggly_coverage_prog(a integer, b boolean) RETURNS void AS $$
+DECLARE
+  x   varchar(20);
+  y   integer[] := '{}';
+BEGIN
+
+  -- IF-THEN
+  IF v_user_id <> 0
+  THEN
+    UPDATE users SET email = v_email WHERE user_id = v_user_id;
+  END IF;
+
+  -- IF-THEN-ELSE
+  IF parentid IS NULL OR parentid = ''
+  THEN
+    RETURN fullname;
+  ELSE
+    RETURN hp_true_filename(parentid) || '/' || fullname;
+  END IF;
+
+  -- IF-THEN-ELSE
+  IF v_count > 0 THEN
+      INSERT INTO users_count(count) VALUES (v_count);
+      RETURN 't';
+  ELSE
+      RETURN 'f';
+  END IF;
+
+  -- IF-THEN-ELSIF
+  IF number = 0 THEN
+      result := 'zero';
+  ELSIF number > 0 THEN
+      result := 'positive';
+  ELSIF number < 0 THEN
+      result := 'negative';
+  ELSE
+      -- hmm, the only other possibility is that the number is null
+      result := 'NULL';
+  END IF;
+
+  -- nest IF-THEN-ELSE statements
+  IF demo_row.sex = 'm' THEN
+      pretty_sex := 'man';
+  ELSE
+      IF demo_row.sex = 'f' THEN
+          pretty_sex := 'woman';
+      END IF;
+  END IF;
+
+  -- simple CASE with search-expression
+  CASE x
+    WHEN 1, 2 THEN
+      msg := 'one or two';
+    ELSE
+      msg := 'other value than one or two';
+  END CASE;
+
+  -- searched CASE with boolean-expression
+  CASE
+    WHEN x BETWEEN 0 and 10 THEN
+      msg := 'value is between zero and ten';
+    WHEN x BETWEEN 11 and 20 THEN
+      msg := 'value is between eleven and twenty';
+  END CASE;
+
+  << labelA >>
+  LOOP
+    a := a + 1;
+    EXIT labelA WHEN a > 10;
+  END LOOP labelA;
+
+  LOOP
+    b := b + 1
+    EXIT WHEN b > 10;
+  END LOOP;
+
+  LOOP
+      c := c + 1;
+      IF c > 10 THEN
+          EXIT;
+      END IF;
+  END LOOP;
+
+  << labelB >>
+  BEGIN
+    -- some computations
+    IF stocks > 100000 THEN
+      EXIT labelB; -- causes exit from BEGIN block
+    END IF;
+    -- computations here will be skipped when stocks > 100000
+  END;
+
+  LOOP
+      -- some computations
+      EXIT WHEN count > 100;
+      CONTINUE WHEN count < 50;
+      -- some computations for count IN [50 .. 100]
+  END LOOP;
+
+  WHILE amount_owed > 0 AND gift_certificate_balance > 0
+  LOOP
+    -- some computations here
+    a := 10;
+  END LOOP;
+
+  << labelC >>
+  WHILE NOT done LOOP
+    -- some computations here
+    a := 10;
+  END LOOP labelC;
+
+  << labelD >>
+  WHILE x NOT IN (1,2,3) LOOP
+    CONTINUE labelD WHEN x < 10;
+  END LOOP;
+
+  FOR i IN 1..10 LOOP
+    --
+  END LOOP;
+
+  << labelD >>
+  FOR i IN REVERSE 10..1 LOOP
+    --
+    EXIT labelD WHEN i = 5;
+  END LOOP labelD;
+
+  << labelE >>
+  FOR i IN REVERSE 10..1 BY 2 LOOP
+    --
+    CONTINUE labelE;
+  END LOOP;
+
+  FOR f IN SELECT *
+           FROM foo
+           WHERE id > 100
+  LOOP
+    -- can do some processing home
+    RETURN NEXT f; -- return current row of SELECT
+  END LOOP;
+
+  FOR t IN EXECUTE 'SELECT * FROM foo' LOOP
+    CONTINUE;
+  END LOOP;
+
+  BEGIN
+    UPDATE tab SET fname = 'J' WHERE lname = 'J';
+    x := x + 1;
+    y := x / 0;
+  EXCEPTION
+    WHEN SQLSTATE '22012' THEN
+      -- relax, don't do it
+    WHEN division_by_zero OR unique_violation THEN
+      RAISE NOTICE 'caught a fool';
+      RETURN x;
+  END;
+
+END $$
+  LANGUAGE 'plpgsql' IMMUTABLE;

data/spec/grammar/expression_spec.rb

@@ -0,0 +1,302 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "expressions" do
+    include GrammarHelper
+
+    describe "expressionUntilSemiColon" do
+      it "does not consume semicolon" do
+        # parser stops in front of THEN and dies
+        lambda{ parse(:expressionUntilSemiColon, 'abc;') }.should raise_error
+
+        node, rest = parse_some(:expressionUntilSemiColon, 'abc; xyz')
+        rest.should == '; xyz'
+      end
+
+      it "can be a blank expression" do
+        node, rest = parse_some(:expressionUntilSemiColon, ';')
+        node.should be_a(Expression)
+        node.source_text.should == ''
+        rest.should == ';'
+      end
+
+      it "can be a comment" do
+        node, rest = parse_some(:expressionUntilSemiColon, "/* comment */;")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 1
+
+        node, rest = parse_some(:expressionUntilSemiColon, "-- comment\n;")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 1
+      end
+
+      it "can be a string" do
+        node, rest = parse_some(:expressionUntilSemiColon, "'string';")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+
+        node, rest = parse_some(:expressionUntilSemiColon, "$$ string $$;")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an arithmetic expression" do
+        node, rest = parse_some(:expressionUntilSemiColon, "10 * (3 + x);")
+        node.should be_a(Expression)
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilSemiColon, "SELECT id FROM dataset;")
+        node.should be_a(Expression)
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id                    -- primary key ;
+          FROM "dataset" /* ; */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL;
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */;
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an expression with strings embedded" do
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> '; this should not terminate expression'
+            AND created_at = '2001-01-01';
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 2
+      end
+
+      it "should combine trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilSemiColon, "a := x + y  \t;")
+        node.should be_a(Expression)
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "should combine trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilSemiColon, "a := x + y /* note -- comment */;")
+        node.should be_a(Expression)
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */;
+        SQL
+        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+      end
+    end
+
+    describe "expressionUntilThen" do
+      it "does not consume THEN token" do
+        # parser stops in front of THEN and dies
+        lambda{ parse(:expressionUntilThen, 'abc THEN') }.should raise_error
+
+        node, rest = parse_some(:expressionUntilThen, 'abc THEN xyz')
+        rest.should == 'THEN xyz'
+      end
+
+      it "cannot be a blank expression" do
+        lambda{ parse_some(:expressionUntilThen, ' THEN') }.should raise_error
+      end
+
+      it "cannot be a comment" do
+        lambda{ parse_some(:expressionUntilThen, "/* comment */ THEN") }.should raise_error
+        lambda{ parse_some(:expressionUntilThen, "-- comment\n THEN") }.should raise_error
+      end
+
+      it "can be a string" do
+        node, rest = parse_some(:expressionUntilThen, "'string' THEN")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+
+        node, rest = parse_some(:expressionUntilThen, "$$ string $$ THEN")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an arithmetic expression" do
+        node, rest = parse_some(:expressionUntilThen, "10 * (3 + x) THEN")
+        node.should be_a(Expression)
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilThen, "SELECT id FROM dataset THEN")
+        node.should be_a(Expression)
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id                    -- primary key  THEN
+          FROM "dataset" /*  THEN */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL THEN
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */ THEN
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an expression with strings embedded" do
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> ' THEN this should not terminate expression'
+            AND created_at = '2001-01-01' THEN
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 2
+      end
+
+      it "should combine trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilThen, "a := x + y  \tTHEN")
+        node.should be_a(Expression)
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "should combine trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilThen, "a := x + y /* note -- comment */THEN")
+        node.should be_a(Expression)
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */THEN
+        SQL
+        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+      end
+    end
+
+    describe "expressionUntilLoop" do
+      it "does not consume LOOP token" do
+        # parser stops in front of LOOP and dies
+        lambda{ parse(:expressionUntilLoop, 'abc LOOP') }.should raise_error
+
+        node, rest = parse_some(:expressionUntilLoop, 'abc LOOP xyz')
+        rest.should == 'LOOP xyz'
+      end
+
+      it "cannot be a blank expression" do
+        lambda{ parse_some(:expressionUntilLoop, ' LOOP') }.should raise_error
+      end
+
+      it "cannot be a comment" do
+        lambda{ parse_some(:expressionUntilLoop, "/* comment */ LOOP") }.should raise_error
+        lambda{ parse_some(:expressionUntilLoop, "-- comment\n LOOP") }.should raise_error
+      end
+
+      it "can be a string" do
+        node, rest = parse_some(:expressionUntilLoop, "'string' LOOP")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+
+        node, rest = parse_some(:expressionUntilLoop, "$$ string $$ LOOP")
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an arithmetic expression" do
+        node, rest = parse_some(:expressionUntilLoop, "10 * (3 + x) LOOP")
+        node.should be_a(Expression)
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilLoop, "SELECT id FROM dataset LOOP")
+        node.should be_a(Expression)
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id                    -- primary key  LOOP
+          FROM "dataset" /*  LOOP */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL LOOP
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */ LOOP
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.count{|e| e.is_a?(TString) }.should == 1
+      end
+
+      it "can be an expression with strings embedded" do
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> ' LOOP this should not terminate expression'
+            AND created_at = '2001-01-01' LOOP
+        SQL
+        node.should be_a(Expression)
+        node.count{|e| e.is_a?(TString) }.should == 2
+      end
+
+      it "should combine trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilLoop, "a := x + y  \tLOOP")
+        node.should be_a(Expression)
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "should combine trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilLoop, "a := x + y /* note -- comment */LOOP")
+        node.should be_a(Expression)
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */LOOP
+        SQL
+        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+      end
+    end
+
+  end
+
+end

data/spec/grammar/statements/assignment_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+
+  describe Parser, "statements" do
+    include GrammarHelper
+
+    describe "assignment statements" do
+      it "parses successfully" do
+        node = parse(:statement, "a := 10;")
+        node.should be_a(Statement)
+        node.count{|e| e.is_a? Assignment }.should == 1
+        node.count{|e| e.is_a? Assignable }.should == 1
+        node.find{|e| e.named? :lval }.should be_a(Assignable)
+        node.find{|e| e.named? :rval }.should be_a(Expression)
+      end
+
+      it "must end with a semicolon" do
+        lambda { parse_some(:statement, 'a := 10') }.should raise_error
+        lambda { parse(:statement, 'a := 10') }.should raise_error
+      end
+
+      it "can use := or =" do
+        a = parse(:statement, "a := 10;")
+        a.should be_a(Statement)
+        a.count{|e| e.is_a? Assignment }.should == 1
+
+        b = parse(:statement, "a = 10;")
+        b.should be_a(Statement)
+        b.count{|e| e.is_a? Assignment }.should == 1
+      end
+
+      it "can assign strings" do
+        node = parse(:statement, "a := 'string';")
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.is_a? TString }.should == 1
+      end
+
+      it "can assign value expressions containing comments" do
+        ['a := /* comment */ 100;',
+         'a := 100 /* comment */;',
+         'a := 10 /* comment */ + 10;'].test_each do |s|
+          node = parse(:statement, s)
+          rval = node.find{|e| e.named? :rval }
+          rval.count{|e| e.is_a? TComment }.should == 1
+        end
+      end
+
+      it "can assign value expressions containing strings" do
+        node = parse(:statement, "a := 'Hello,' || space || 'world';")
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.is_a? TString }.should == 2
+      end
+
+      it "can assign value expressions containing comments and strings" do
+        node = parse(:statement, <<-SQL.strip)
+          a := (SELECT fk, count(*), 'not a statement;'
+                FROM dataset
+                WHERE id > 100 /* filter out 'reserved' range */
+                  AND id < 900 -- shouldn't be a string
+                   OR value <> 'alpha /* no comment */;'
+                GROUP BY /* pk ; 'abc' */ fk);
+        SQL
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.is_a? TString }.should == 2
+      end
+    end
+
+  end
+end

data/spec/grammar/statements/exception_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "control structures" do
+    include GrammarHelper
+
+    describe "exceptions" do
+      describe "raise" do
+        it "parses successfully" do
+          node, rest = parse_some(:statement, "RAISE EXCEPTION 'message';")
+          node.should be_a(Statement)
+          rest.should == ''
+        end
+
+        it "handles exception" do
+          node = parse(:statement, "RAISE EXCEPTION 'message';")
+          node.count{|e| e.is_a?(Throw) }.should == 1
+          node.count{|e| e.is_a?(Raise) }.should == 0
+        end
+
+        it "handles events" do
+          %w(WARNING LOG INFO NOTICE DEBUG).each do |event|
+            node = parse(:statement, "RAISE #{event} 'message';")
+            node.count{|e| e.is_a?(Throw) }.should == 0
+            node.count{|e| e.is_a?(Raise) }.should == 1
+          end
+        end
+      end
+
+      describe "catch" do
+        before do
+          @text = 'BEGIN a := 10; EXCEPTION WHEN cond THEN b := 10; WHEN cond THEN b := 20; END;'
+        end
+
+        it "parses successfully" do
+          node, rest = parse_some(:statement, @text)
+          node.should be_a(Statement)
+          rest.should == ''
+        end
+
+        it "has Catch node" do
+          node = parse(:statement, @text)
+          catches = node.select{|e| e.is_a?(Catch) }
+          catches.size.should == 2
+
+          catches[0].count{|e| e.named?(:cond) and e.is_a?(Expression) }.should == 1
+          catches[1].count{|e| e.named?(:cond) and e.is_a?(Expression) }.should == 1
+        end
+      end
+    end
+  end
+end