Put everything into a 'wiki' schema

Author: singingwolfboy

diff.sql

@@ -1,7 +1,8 @@
-create or replace function update_page(page_id int, new_content text, 
-    editor_id int, new_comment text DEFAULT '', context_len int DEFAULT 3) returns int as $$
+create or replace function wiki.update_page(page_id int, new_content text, 
+    editor_id int, new_comment text DEFAULT '', context_len int DEFAULT 3)
+    returns int as $$
 declare
-    latest page_latest;
+    latest wiki.page_latest;
     new_revision int;
     hunk text[];
     context text[]; -- only contains consecutive lines in LCS
@@ -18,14 +19,14 @@ declare
     i int;
     j int;
 begin
-    SELECT * INTO latest FROM page_latest WHERE id = page_id;
+    SELECT * INTO latest FROM wiki.page_latest WHERE id = page_id;
     IF NOT FOUND THEN
         RAISE 'Page % not found', id;
     END IF;
     new_revision := latest.revision + 1;
     --raise notice 'new revision: %', new_revision;
     -- write out new diff object
-    INSERT INTO page_diff (page_id, revision, editor, comment)
+    INSERT INTO wiki.page_diff (page_id, revision, editor, comment)
         VALUES (page_id, latest.revision, latest.editor, latest.comment);
     -- make hunks
     X := string_to_array(latest.content, E'\n');
@@ -55,14 +56,14 @@ begin
                     hunk_lines_context := hunk_lines_context + context_length;
                 END IF;
                 -- write out the last hunk
-                INSERT INTO page_diff_hunk (page_id, revision, start, 
+                INSERT INTO wiki.page_diff_hunk (page_id, revision, start, 
                     content, lines_added, lines_deleted, lines_context)
                     VALUES 
                     (page_id, latest.revision, i, array_to_string(hunk, E'\n'),
                     hunk_lines_added, hunk_lines_deleted, hunk_lines_context);
             END IF;
             -- update the page_latest object
-            UPDATE page_latest SET content = new_content, revision = new_revision,
+            UPDATE wiki.page_latest SET content = new_content, revision = new_revision,
                 num_lines = array_length(Y, 1), comment = new_comment,
                 editor = editor_id, edited_on = now()
                 WHERE id = page_id;
@@ -97,7 +98,7 @@ begin
                     hunk := context[context_len+1:2*context_len] || hunk;
                     hunk_lines_context = hunk_lines_context + context_len;
                     -- write out the hunk
-                    INSERT INTO page_diff_hunk (page_id, revision, start, 
+                    INSERT INTO wiki.page_diff_hunk (page_id, revision, start, 
                         content, lines_added, lines_deleted, lines_context)
                         VALUES 
                         (page_id, latest.revision, i-1, array_to_string(hunk, E'\n'),

patch.sql

@@ -1,4 +1,4 @@
-create or replace function apply_hunk(original text[], hunk text[],
+create or replace function wiki.apply_hunk(original text[], hunk text[],
     start int DEFAULT 1, reverse boolean DEFAULT FALSE) returns text[] as $$
 declare
     result text[];
@@ -77,23 +77,22 @@ end;
 $$ language plpgsql
 IMMUTABLE;
 
-create or replace function get_page_at_revision(page_id int, revision int)
---    returns page as $$
-    returns page_latest as $$
+create or replace function wiki.get_page_at_revision(page_id int, revision int)
+    returns wiki.page as $$
 #variable_conflict use_variable
 declare
-    latest page_latest;
-    diff page_diff;
-    hunk page_diff_hunk;
+    latest wiki.page_latest;
+    diff wiki.page_diff;
+    hunk wiki.page_diff_hunk;
     content text[];
     cur_rev int := -1;
     line_offset int := 0;
-    result page_latest;
+    result page;
 begin
     IF revision < 1 THEN
         RAISE 'Revision must be positive (got %)', revision;
     END IF;
-    SELECT * INTO latest FROM page_latest WHERE id = page_id;
+    SELECT * INTO latest FROM wiki.page_latest WHERE id = page_id;
     IF NOT FOUND THEN
         RAISE 'Page % not found', id;
     END IF;
@@ -102,17 +101,17 @@ begin
             latest.revision;
     END IF;
     IF revision = latest.revision THEN
-        result := latest::page_latest;
+        result := latest::page;
         RETURN result;
     END IF;
-    SELECT * INTO diff FROM page_diff AS pd
+    SELECT * INTO diff FROM wiki.page_diff AS pd
         WHERE pd.page_id = page_id
         AND pd.revision = revision;
     IF NOT FOUND THEN
         RAISE 'Revision % for page % not found', revision, page_id;
     END IF;
     content = string_to_array(latest.content, E'\n');
-    FOR hunk IN SELECT * FROM page_diff_hunk AS pdh 
+    FOR hunk IN SELECT * FROM wiki.page_diff_hunk AS pdh 
                 WHERE pdh.page_id = page_id
                 AND pdh.revision >= revision
                 ORDER BY pdh.revision desc, pdh.start asc

tables.sql

@@ -1,5 +1,8 @@
-DROP TABLE IF EXISTS "user";
-CREATE TABLE "user" (
+DROP SCHEMA IF EXISTS wiki;
+CREATE SCHEMA wiki;
+
+DROP TABLE IF EXISTS wiki.editor;
+CREATE TABLE wiki.editor (
     id serial PRIMARY KEY,
     username varchar(256) NOT NULL,
     email varchar(256) NOT NULL,
@@ -8,8 +11,8 @@ CREATE TABLE "user" (
     admin boolean DEFAULT FALSE
 );
 
-DROP TABLE IF EXISTS page_latest CASCADE;
-CREATE TABLE page_latest (
+DROP TABLE IF EXISTS wiki.page_latest CASCADE;
+CREATE TABLE wiki.page_latest (
     id serial PRIMARY KEY,
     title varchar(256) NOT NULL,
     slug varchar(256) NOT NULL,
@@ -18,25 +21,25 @@ CREATE TABLE page_latest (
     comment text DEFAULT '',
     num_lines int NOT NULL,
     revision int DEFAULT 1 CONSTRAINT "revision must be positive" CHECK (revision > 0),
-    editor int REFERENCES "user"(id),
+    editor int REFERENCES wiki.editor(id),
     markup varchar(64) DEFAULT 'plain',
     language varchar(8) NOT NULL,
     edited_on timestamp DEFAULT now() NOT NULL
 );
 
-DROP TABLE IF EXISTS page_diff CASCADE;
-CREATE TABLE page_diff (
+DROP TABLE IF EXISTS wiki.page_diff CASCADE;
+CREATE TABLE wiki.page_diff (
     page_id int, 
     revision int,
-    editor int REFERENCES "user"(id),
+    editor int REFERENCES wiki.editor(id),
     created_on timestamp DEFAULT now() NOT NULL,
     comment text DEFAULT '',
     PRIMARY KEY (page_id, revision),
-    FOREIGN KEY (page_id) REFERENCES page_latest(id) ON DELETE CASCADE
+    FOREIGN KEY (page_id) REFERENCES wiki.page_latest(id) ON DELETE CASCADE
 );
 
-DROP TABLE IF EXISTS page_diff_hunk;
-CREATE TABLE page_diff_hunk (
+DROP TABLE IF EXISTS wiki.page_diff_hunk;
+CREATE TABLE wiki.page_diff_hunk (
     page_id int,
     revision int,
     start int NOT NULL CONSTRAINT "start must be positive" CHECK (start > 0),
@@ -45,17 +48,13 @@ CREATE TABLE page_diff_hunk (
     lines_deleted int NOT NULL DEFAULT 0,
     lines_context int NOT NULL DEFAULT 0,
     PRIMARY KEY (page_id, revision, start),
-    FOREIGN KEY (page_id, revision) REFERENCES page_diff ON DELETE CASCADE
-    -- EXCLUDE USING gist (page_id WITH =, revision WITH =, [overlapping])
-    -- Would need to define a page_diff_hunk_meta type, define the "&&" operation
-    -- over it, and add a "meta" type to this table. Not worth the effort right now.
-    -- See: http://www.pgcon.org/2010/schedule/attachments/136_exclusion_constraints2.pdf
+    FOREIGN KEY (page_id, revision) REFERENCES wiki.page_diff ON DELETE CASCADE
 );
 
-CREATE OR REPLACE FUNCTION hunk_overlap(page_diff_hunk, page_diff_hunk) returns boolean as $$
+CREATE OR REPLACE FUNCTION wiki.hunk_overlap(wiki.page_diff_hunk, wiki.page_diff_hunk) returns boolean as $$
 declare
-    first page_diff_hunk;
-    second page_diff_hunk;
+    first wiki.page_diff_hunk;
+    second wiki.page_diff_hunk;
 begin
     if $1.page_id != $2.page_id or $1.revision != $2.revision then
         RETURN FALSE;
@@ -79,24 +78,26 @@ $$ language plpgsql
 IMMUTABLE STRICT;
 
 CREATE OPERATOR && (
-    leftarg = page_diff_hunk,
-    rightarg = page_diff_hunk,
-    procedure = hunk_overlap,
+    leftarg = wiki.page_diff_hunk,
+    rightarg = wiki.page_diff_hunk,
+    procedure = wiki.hunk_overlap,
     commutator = &&
 );
 
-create function compare() returns boolean as $$
+DROP TABLE IF EXISTS wiki.page;
+CREATE TABLE wiki.page (LIKE page_latest);
+
+CREATE OR REPLACE FUNCTION wiki.page_latest_to_page(wiki.page_latest)
+    returns wiki.page as $$
 declare
-    one page_diff_hunk;
-    two page_diff_hunk;
+    result wiki.page;
 begin
-    SELECT * into one FROM page_diff_hunk WHERE page_id = 1 AND revision = 1
-        AND start = 1;
-    SELECT * into two FROM page_diff_hunk WHERE page_id = 1 AND revision = 1
-        AND start = 2;
-    RETURN one && two;
+    result := ($1.id, $1.title, $1.slug, $1.namespace, $1.content, $1.comment,
+        $1.num_lines, $1.revision, $1.editor, $1.markup, $1.language,
+        $1.edited_on);
+    RETURN result;
 end;
-$$ language plpgsql;
+$$ language plpgsql IMMUTABLE STRICT;
 
-DROP TABLE IF EXISTS page;
-CREATE TABLE page (LIKE page_latest);
+CREATE CAST (wiki.page_latest AS wiki.page)
+    WITH FUNCTION wiki.page_latest_to_page(wiki.page_latest);

test.sql

@@ -1,5 +1,5 @@
 truncate page_latest, page_diff, page_diff_hunk;
-INSERT INTO user(id, username, email) VALUES (1, 'foo', 'foo');
+INSERT INTO "user"(id, username, email) VALUES (1, 'foo', 'foo');
 INSERT INTO page_latest(id, title, slug, num_lines, editor, language, content)
     VALUES (1, 'page', 'page', 3, 1, 'en-us', 
 'a