diff --git a/sql/001-ore.sql b/sql/001-ore.sql
index 8473575..e0f4991 100644
--- a/sql/001-ore.sql
+++ b/sql/001-ore.sql
@@ -1,16 +1,16 @@
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 
-CREATE TYPE ore_64_8_v1_term AS (
+CREATE TYPE eql_v1.ore_64_8_v1_term AS (
   bytes bytea
 );
 
-CREATE TYPE ore_64_8_v1 AS (
-  terms ore_64_8_v1_term[]
+CREATE TYPE eql_v1.ore_64_8_v1 AS (
+  terms eql_v1.ore_64_8_v1_term[]
 );
 
-DROP FUNCTION IF EXISTS compare_ore_64_8_v1_term(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.compare_ore_64_8_v1_term(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION compare_ore_64_8_v1_term(a ore_64_8_v1_term, b ore_64_8_v1_term) returns integer AS $$
+CREATE FUNCTION eql_v1.compare_ore_64_8_v1_term(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term) returns integer AS $$
   DECLARE
     eq boolean := true;
     unequal_block smallint := 0;
@@ -87,60 +87,60 @@ CREATE FUNCTION compare_ore_64_8_v1_term(a ore_64_8_v1_term, b ore_64_8_v1_term)
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_eq(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_eq(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_eq(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_eq(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) = 0
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) = 0
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_neq(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_neq(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_neq(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_neq(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) <> 0
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) <> 0
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_lt(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_lt(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_lt(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_lt(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) = -1
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) = -1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_lte(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_lte(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_lte(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_lte(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) != 1
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) != 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_gt(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_gt(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_gt(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_gt(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) = 1
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) = 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_term_gte(a ore_64_8_v1_term, b ore_64_8_v1_term);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_term_gte(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
-CREATE FUNCTION ore_64_8_v1_term_gte(a ore_64_8_v1_term, b ore_64_8_v1_term)
+CREATE FUNCTION eql_v1.ore_64_8_v1_term_gte(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1_term(a, b) != -1
+  SELECT eql_v1.compare_ore_64_8_v1_term(a, b) != -1
 $$ LANGUAGE SQL;
 
 
-DROP OPERATOR IF EXISTS = (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR = (
-  PROCEDURE="ore_64_8_v1_term_eq",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_eq,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -149,12 +149,12 @@ CREATE OPERATOR = (
 );
 
 
-DROP OPERATOR IF EXISTS <> (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR <> (
-  PROCEDURE="ore_64_8_v1_term_neq",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_neq,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -162,68 +162,68 @@ CREATE OPERATOR <> (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS > (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS > (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR > (
-  PROCEDURE="ore_64_8_v1_term_gt",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_gt,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel
 );
 
-DROP OPERATOR IF EXISTS < (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS < (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR < (
-  PROCEDURE="ore_64_8_v1_term_lt",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_lt,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel
 );
 
-DROP OPERATOR IF EXISTS <= (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR <= (
-  PROCEDURE="ore_64_8_v1_term_lte",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_lte,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
   JOIN = scalarlejoinsel
 );
 
-DROP OPERATOR IF EXISTS >= (ore_64_8_v1_term, ore_64_8_v1_term);
+DROP OPERATOR IF EXISTS >= (eql_v1.ore_64_8_v1_term, eql_v1.ore_64_8_v1_term);
 
 CREATE OPERATOR >= (
-  PROCEDURE="ore_64_8_v1_term_gte",
-  LEFTARG=ore_64_8_v1_term,
-  RIGHTARG=ore_64_8_v1_term,
+  FUNCTION=eql_v1.ore_64_8_v1_term_gte,
+  LEFTARG=eql_v1.ore_64_8_v1_term,
+  RIGHTARG=eql_v1.ore_64_8_v1_term,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
   JOIN = scalarlejoinsel
 );
 
-DROP OPERATOR FAMILY IF EXISTS ore_64_8_v1_term_btree_ops USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ore_64_8_v1_term_btree_ops USING btree;
 
-CREATE OPERATOR FAMILY ore_64_8_v1_term_btree_ops USING btree;
+CREATE OPERATOR FAMILY eql_v1.ore_64_8_v1_term_btree_ops USING btree;
 
 
-DROP OPERATOR CLASS IF EXISTS ore_64_8_v1_term_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ore_64_8_v1_term_btree_ops USING btree;
 
-CREATE OPERATOR CLASS ore_64_8_v1_term_btree_ops DEFAULT FOR TYPE ore_64_8_v1_term USING btree FAMILY ore_64_8_v1_term_btree_ops  AS
+CREATE OPERATOR CLASS eql_v1.ore_64_8_v1_term_btree_ops DEFAULT FOR TYPE eql_v1.ore_64_8_v1_term USING btree FAMILY eql_v1.ore_64_8_v1_term_btree_ops  AS
         OPERATOR 1 <,
         OPERATOR 2 <=,
         OPERATOR 3 =,
         OPERATOR 4 >=,
         OPERATOR 5 >,
-        FUNCTION 1 compare_ore_64_8_v1_term(a ore_64_8_v1_term, b ore_64_8_v1_term);
+        FUNCTION 1 eql_v1.compare_ore_64_8_v1_term(a eql_v1.ore_64_8_v1_term, b eql_v1.ore_64_8_v1_term);
 
 -- Compare the "head" of each array and recurse if necessary
 -- This function assumes an empty string is "less than" everything else
@@ -232,9 +232,9 @@ CREATE OPERATOR CLASS ore_64_8_v1_term_btree_ops DEFAULT FOR TYPE ore_64_8_v1_te
 -- doesn't always make sense but it's here for completeness.
 -- If both are non-empty, we compare the first element. If they are equal
 -- we need to consider the next block so we recurse, otherwise we return the comparison result.
-DROP FUNCTION IF EXISTS compare_ore_array(a ore_64_8_v1_term[], b ore_64_8_v1_term[]);
+DROP FUNCTION IF EXISTS eql_v1.compare_ore_array(a eql_v1.ore_64_8_v1_term[], b eql_v1.ore_64_8_v1_term[]);
 
-CREATE FUNCTION compare_ore_array(a ore_64_8_v1_term[], b ore_64_8_v1_term[])
+CREATE FUNCTION eql_v1.compare_ore_array(a eql_v1.ore_64_8_v1_term[], b eql_v1.ore_64_8_v1_term[])
 RETURNS integer AS $$
   DECLARE
     cmp_result integer;
@@ -260,10 +260,10 @@ RETURNS integer AS $$
       RETURN 1;
     END IF;
 
-    cmp_result := compare_ore_64_8_v1_term(a[1], b[1]);
+    cmp_result := eql_v1.compare_ore_64_8_v1_term(a[1], b[1]);
     IF cmp_result = 0 THEN
     -- Removes the first element in the array, and calls this fn again to compare the next element/s in the array.
-      RETURN compare_ore_array(a[2:array_length(a,1)], b[2:array_length(b,1)]);
+      RETURN eql_v1.compare_ore_array(a[2:array_length(a,1)], b[2:array_length(b,1)]);
     END IF;
 
     RETURN cmp_result;
@@ -271,73 +271,73 @@ RETURNS integer AS $$
 $$ LANGUAGE plpgsql;
 
 -- This function uses lexicographic comparison
-DROP FUNCTION IF EXISTS compare_ore_64_8_v1(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.compare_ore_64_8_v1(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION compare_ore_64_8_v1(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.compare_ore_64_8_v1(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS integer AS $$
   DECLARE
     cmp_result integer;
   BEGIN
     -- Recursively compare blocks bailing as soon as we can make a decision
-    RETURN compare_ore_array(a.terms, b.terms);
+    RETURN eql_v1.compare_ore_array(a.terms, b.terms);
   END
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_eq(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_eq(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_eq(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_eq(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) = 0
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) = 0
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_neq(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_neq(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_neq(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_neq(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) <> 0
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) <> 0
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_lt(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_lt(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_lt(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_lt(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) = -1
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) = -1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_lte(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_lte(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_lte(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_lte(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) != 1
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) != 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_gt(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_gt(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_gt(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_gt(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) = 1
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) = 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_64_8_v1_gte(a ore_64_8_v1, b ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1_gte(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION ore_64_8_v1_gte(a ore_64_8_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.ore_64_8_v1_gte(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_64_8_v1(a, b) != -1
+  SELECT eql_v1.compare_ore_64_8_v1(a, b) != -1
 $$ LANGUAGE SQL;
 
 
-DROP OPERATOR IF EXISTS = (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR = (
-  PROCEDURE="ore_64_8_v1_eq",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_eq,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -346,12 +346,12 @@ CREATE OPERATOR = (
 );
 
 
-DROP OPERATOR IF EXISTS <> (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR <> (
-  PROCEDURE="ore_64_8_v1_neq",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_neq,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -359,12 +359,12 @@ CREATE OPERATOR <> (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS > (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS > (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR > (
-  PROCEDURE="ore_64_8_v1_gt",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_gt,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
@@ -372,12 +372,12 @@ CREATE OPERATOR > (
 );
 
 
-DROP OPERATOR IF EXISTS < (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS < (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR < (
-  PROCEDURE="ore_64_8_v1_lt",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_lt,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
@@ -385,12 +385,12 @@ CREATE OPERATOR < (
 );
 
 
-DROP OPERATOR IF EXISTS <= (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR <= (
-  PROCEDURE="ore_64_8_v1_lte",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_lte,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
@@ -398,12 +398,12 @@ CREATE OPERATOR <= (
 );
 
 
-DROP OPERATOR IF EXISTS >= (ore_64_8_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1.ore_64_8_v1, eql_v1.ore_64_8_v1);
 
 CREATE OPERATOR >= (
-  PROCEDURE="ore_64_8_v1_gte",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.ore_64_8_v1_gte,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
@@ -411,17 +411,17 @@ CREATE OPERATOR >= (
 );
 
 
-DROP OPERATOR FAMILY IF EXISTS ore_64_8_v1_btree_ops USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ore_64_8_v1_btree_ops USING btree;
 
-CREATE OPERATOR FAMILY ore_64_8_v1_btree_ops USING btree;
+CREATE OPERATOR FAMILY eql_v1.ore_64_8_v1_btree_ops USING btree;
 
 
-DROP OPERATOR CLASS IF EXISTS ore_64_8_v1_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ore_64_8_v1_btree_ops USING btree;
 
-CREATE OPERATOR CLASS ore_64_8_v1_btree_ops DEFAULT FOR TYPE ore_64_8_v1 USING btree FAMILY ore_64_8_v1_btree_ops  AS
+CREATE OPERATOR CLASS eql_v1.ore_64_8_v1_btree_ops DEFAULT FOR TYPE eql_v1.ore_64_8_v1 USING btree FAMILY eql_v1.ore_64_8_v1_btree_ops  AS
         OPERATOR 1 <,
         OPERATOR 2 <=,
         OPERATOR 3 =,
         OPERATOR 4 >=,
         OPERATOR 5 >,
-        FUNCTION 1 compare_ore_64_8_v1(a ore_64_8_v1, b ore_64_8_v1);
+        FUNCTION 1 eql_v1.compare_ore_64_8_v1(a eql_v1.ore_64_8_v1, b eql_v1.ore_64_8_v1);
diff --git a/sql/002-ore-cllw.sql b/sql/002-ore-cllw.sql
index 4330b14..ce2acf4 100644
--- a/sql/002-ore-cllw.sql
+++ b/sql/002-ore-cllw.sql
@@ -5,20 +5,20 @@
 
 -- Represents a ciphertext encrypted with the CLLW ORE scheme for a fixed output size
 -- Each output block is 8-bits
-CREATE TYPE ore_cllw_8_v1 AS (
+CREATE TYPE eql_v1.ore_cllw_8_v1 AS (
   bytes bytea
 );
 
 -- Represents a ciphertext encrypted with the CLLW ORE scheme for a variable output size
 -- Each output block is 8-bits
-CREATE TYPE ore_cllw_8_variable_v1 AS (
+CREATE TYPE eql_v1.ore_cllw_8_variable_v1 AS (
   bytes bytea
 );
 
-DROP FUNCTION IF EXISTS __bytea_ct_eq(a bytea, b bytea);
+DROP FUNCTION IF EXISTS eql_v1.__bytea_ct_eq(a bytea, b bytea);
 
 -- Constant time comparison of 2 bytea values
-CREATE FUNCTION __bytea_ct_eq(a bytea, b bytea) RETURNS boolean AS $$
+CREATE FUNCTION eql_v1.__bytea_ct_eq(a bytea, b bytea) RETURNS boolean AS $$
 DECLARE
     result boolean;
     differing bytea;
@@ -40,9 +40,9 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS __compare_inner_ore_cllw_8_v1(a bytea, b bytea);
+DROP FUNCTION IF EXISTS eql_v1.__compare_inner_ore_cllw_8_v1(a bytea, b bytea);
 
-CREATE FUNCTION __compare_inner_ore_cllw_8_v1(a bytea, b bytea)
+CREATE FUNCTION eql_v1.__compare_inner_ore_cllw_8_v1(a bytea, b bytea)
 RETURNS int AS $$
 DECLARE
     len_a INT;
@@ -79,9 +79,9 @@ END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS compare_ore_cllw_8_v1(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.compare_ore_cllw_8_v1(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION compare_ore_cllw_8_v1(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.compare_ore_cllw_8_v1(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS int AS $$
 DECLARE
     len_a INT;
@@ -99,14 +99,14 @@ BEGIN
       RAISE EXCEPTION 'Numeric ORE comparison requires bytea values of the same length';
     END IF;
 
-    RETURN __compare_inner_ore_cllw_8_v1(a.bytes, b.bytes);
+    RETURN eql_v1.__compare_inner_ore_cllw_8_v1(a.bytes, b.bytes);
 END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS compare_lex_ore_cllw_8_v1(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.compare_lex_ore_cllw_8_v1(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE FUNCTION compare_lex_ore_cllw_8_v1(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1)
+CREATE FUNCTION eql_v1.compare_lex_ore_cllw_8_v1(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1)
 RETURNS int AS $$
 DECLARE
     len_a INT;
@@ -136,7 +136,7 @@ BEGIN
     END IF;
 
     -- Use the compare_bytea function to compare byte by byte
-    cmp_result := __compare_inner_ore_cllw_8_v1(
+    cmp_result := eql_v1.__compare_inner_ore_cllw_8_v1(
       SUBSTRING(a.bytes FROM 1 FOR common_len),
       SUBSTRING(b.bytes FROM 1 FOR common_len)
     );
@@ -160,60 +160,60 @@ END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_eq(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_eq(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_eq(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_eq(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT __bytea_ct_eq(a.bytes, b.bytes)
+  SELECT eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_neq(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_neq(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_neq(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_neq(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT not __bytea_ct_eq(a.bytes, b.bytes)
+  SELECT not eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_lt(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_lt(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_lt(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_lt(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_cllw_8_v1(a, b) = -1
+  SELECT eql_v1.compare_ore_cllw_8_v1(a, b) = -1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_lte(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_lte(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_lte(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_lte(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_cllw_8_v1(a, b) != 1
+  SELECT eql_v1.compare_ore_cllw_8_v1(a, b) != 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_gt(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_gt(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_gt(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_gt(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_cllw_8_v1(a, b) = 1
+  SELECT eql_v1.compare_ore_cllw_8_v1(a, b) = 1
 $$ LANGUAGE SQL;
 
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_gte(a ore_cllw_8_v1, b ore_cllw_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_gte(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
-CREATE FUNCTION ore_cllw_8_v1_gte(a ore_cllw_8_v1, b ore_cllw_8_v1)
+CREATE FUNCTION eql_v1.ore_cllw_8_v1_gte(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1)
 RETURNS boolean AS $$
-  SELECT compare_ore_cllw_8_v1(a, b) != -1
+  SELECT eql_v1.compare_ore_cllw_8_v1(a, b) != -1
 $$ LANGUAGE SQL;
 
 
-DROP OPERATOR IF EXISTS = (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR = (
-  PROCEDURE="ore_cllw_8_v1_eq",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_eq,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -222,12 +222,12 @@ CREATE OPERATOR = (
 );
 
 
-DROP OPERATOR IF EXISTS <> (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR <> (
-  PROCEDURE="ore_cllw_8_v1_neq",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_neq,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -236,12 +236,12 @@ CREATE OPERATOR <> (
 );
 
 
-DROP OPERATOR IF EXISTS > (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS > (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR > (
-  PROCEDURE="ore_cllw_8_v1_gt",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_gt,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = <=,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -250,12 +250,12 @@ CREATE OPERATOR > (
 );
 
 
-DROP OPERATOR IF EXISTS < (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS < (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR < (
-  PROCEDURE="ore_cllw_8_v1_lt",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_lt,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = >=,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -264,12 +264,12 @@ CREATE OPERATOR < (
 );
 
 
-DROP OPERATOR IF EXISTS >= (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR >= (
-  PROCEDURE="ore_cllw_8_v1_gte",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_gte,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = <,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -278,12 +278,12 @@ CREATE OPERATOR >= (
 );
 
 
-DROP OPERATOR IF EXISTS <= (ore_cllw_8_v1, ore_cllw_8_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_cllw_8_v1, eql_v1.ore_cllw_8_v1);
 
 CREATE OPERATOR <= (
-  PROCEDURE="ore_cllw_8_v1_lte",
-  LEFTARG=ore_cllw_8_v1,
-  RIGHTARG=ore_cllw_8_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_lte,
+  LEFTARG=eql_v1.ore_cllw_8_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_v1,
   NEGATOR = >,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -293,48 +293,48 @@ CREATE OPERATOR <= (
 
 -- Lexical comparison operators
 
-DROP FUNCTION IF EXISTS ore_cllw_8_variable_v1_eq(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_variable_v1_eq(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_variable_v1_eq(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT __bytea_ct_eq(a.bytes, b.bytes)
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_variable_v1_eq(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS ore_cllw_8_variable_v1_neq(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_variable_v1_neq(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_variable_v1_neq(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT not __bytea_ct_eq(a.bytes, b.bytes)
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_variable_v1_neq(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT not eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_lt_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_lt_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_v1_lt_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT compare_lex_ore_cllw_8_v1(a, b) = -1
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_v1_lt_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT eql_v1.compare_lex_ore_cllw_8_v1(a, b) = -1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_lte_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_lte_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_v1_lte_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT compare_lex_ore_cllw_8_v1(a, b) != 1
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_v1_lte_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT eql_v1.compare_lex_ore_cllw_8_v1(a, b) != 1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_gt_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_gt_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_v1_gt_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT compare_lex_ore_cllw_8_v1(a, b) = 1
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_v1_gt_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT eql_v1.compare_lex_ore_cllw_8_v1(a, b) = 1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS ore_cllw_8_v1_gte_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+DROP FUNCTION IF EXISTS eql_v1.ore_cllw_8_v1_gte_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
 
-CREATE OR REPLACE FUNCTION ore_cllw_8_v1_gte_lex(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1) RETURNS boolean AS $$
-  SELECT compare_lex_ore_cllw_8_v1(a, b) != -1
+CREATE OR REPLACE FUNCTION eql_v1.ore_cllw_8_v1_gte_lex(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1) RETURNS boolean AS $$
+  SELECT eql_v1.compare_lex_ore_cllw_8_v1(a, b) != -1
 $$ LANGUAGE SQL;
 
-DROP OPERATOR IF EXISTS = (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR = (
-  PROCEDURE="ore_cllw_8_variable_v1_eq",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_variable_v1_eq,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -342,12 +342,12 @@ CREATE OPERATOR = (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS <> (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR <> (
-  PROCEDURE="ore_cllw_8_variable_v1_neq",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_variable_v1_neq,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -355,12 +355,12 @@ CREATE OPERATOR <> (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS > (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS > (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR > (
-  PROCEDURE="ore_cllw_8_v1_gt_lex",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_gt_lex,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = <=,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -368,12 +368,12 @@ CREATE OPERATOR > (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS < (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS < (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR < (
-  PROCEDURE="ore_cllw_8_v1_lt_lex",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_lt_lex,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = >=,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -381,12 +381,12 @@ CREATE OPERATOR < (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS >= (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR >= (
-  PROCEDURE="ore_cllw_8_v1_gte_lex",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_gte_lex,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = <,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -394,12 +394,12 @@ CREATE OPERATOR >= (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS <= (ore_cllw_8_variable_v1, ore_cllw_8_variable_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_cllw_8_variable_v1, eql_v1.ore_cllw_8_variable_v1);
 
 CREATE OPERATOR <= (
-  PROCEDURE="ore_cllw_8_v1_lte_lex",
-  LEFTARG=ore_cllw_8_variable_v1,
-  RIGHTARG=ore_cllw_8_variable_v1,
+  FUNCTION=eql_v1.ore_cllw_8_v1_lte_lex,
+  LEFTARG=eql_v1.ore_cllw_8_variable_v1,
+  RIGHTARG=eql_v1.ore_cllw_8_variable_v1,
   NEGATOR = >,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -408,32 +408,32 @@ CREATE OPERATOR <= (
 );
 
 
-DROP OPERATOR FAMILY IF EXISTS ore_cllw_8_v1_btree_ops USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ore_cllw_8_v1_btree_ops USING btree;
 
-CREATE OPERATOR FAMILY ore_cllw_8_v1_btree_ops USING btree;
+CREATE OPERATOR FAMILY eql_v1.ore_cllw_8_v1_btree_ops USING btree;
 
-DROP OPERATOR CLASS IF EXISTS ore_cllw_8_v1_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ore_cllw_8_v1_btree_ops USING btree;
 
-CREATE OPERATOR CLASS ore_cllw_8_v1_btree_ops DEFAULT FOR TYPE ore_cllw_8_v1 USING btree FAMILY ore_cllw_8_v1_btree_ops  AS
+CREATE OPERATOR CLASS eql_v1.ore_cllw_8_v1_btree_ops DEFAULT FOR TYPE eql_v1.ore_cllw_8_v1 USING btree FAMILY eql_v1.ore_cllw_8_v1_btree_ops  AS
         OPERATOR 1 <,
         OPERATOR 2 <=,
         OPERATOR 3 =,
         OPERATOR 4 >=,
         OPERATOR 5 >,
-        FUNCTION 1 compare_ore_cllw_8_v1(a ore_cllw_8_v1, b ore_cllw_8_v1);
+        FUNCTION 1 eql_v1.compare_ore_cllw_8_v1(a eql_v1.ore_cllw_8_v1, b eql_v1.ore_cllw_8_v1);
 
 -- Lexical comparison operator class
 
-DROP OPERATOR FAMILY IF EXISTS ore_cllw_8_v1_variable_btree_ops USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ore_cllw_8_v1_variable_btree_ops USING btree;
 
-CREATE OPERATOR FAMILY ore_cllw_8_v1_variable_btree_ops USING btree;
+CREATE OPERATOR FAMILY eql_v1.ore_cllw_8_v1_variable_btree_ops USING btree;
 
-DROP OPERATOR CLASS IF EXISTS ore_cllw_8_v1_variable_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ore_cllw_8_v1_variable_btree_ops USING btree;
 
-CREATE OPERATOR CLASS ore_cllw_8_v1_variable_btree_ops DEFAULT FOR TYPE ore_cllw_8_variable_v1 USING btree FAMILY ore_cllw_8_v1_variable_btree_ops  AS
+CREATE OPERATOR CLASS eql_v1.ore_cllw_8_v1_variable_btree_ops DEFAULT FOR TYPE eql_v1.ore_cllw_8_variable_v1 USING btree FAMILY eql_v1.ore_cllw_8_v1_variable_btree_ops  AS
         OPERATOR 1 <,
         OPERATOR 2 <=,
         OPERATOR 3 =,
         OPERATOR 4 >=,
         OPERATOR 5 >,
-        FUNCTION 1 compare_lex_ore_cllw_8_v1(a ore_cllw_8_variable_v1, b ore_cllw_8_variable_v1);
+        FUNCTION 1 eql_v1.compare_lex_ore_cllw_8_v1(a eql_v1.ore_cllw_8_variable_v1, b eql_v1.ore_cllw_8_variable_v1);
diff --git a/sql/003-ste-vec.sql b/sql/003-ste-vec.sql
index bbe8c47..0d12d29 100644
--- a/sql/003-ste-vec.sql
+++ b/sql/003-ste-vec.sql
@@ -3,13 +3,13 @@
 --- SteVec types, functions, and operators
 ---
 
-CREATE TYPE cs_ste_vec_encrypted_term_v1 AS (
+CREATE TYPE eql_v1.ste_vec_encrypted_term AS (
   bytes bytea
 );
 
-DROP FUNCTION IF EXISTS compare_ste_vec_encrypted_term_v1(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.compare_ste_vec_encrypted_term(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION compare_ste_vec_encrypted_term_v1(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1)
+CREATE FUNCTION eql_v1.compare_ste_vec_encrypted_term(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term)
 RETURNS INT AS $$
 DECLARE
   header_a INT;
@@ -22,7 +22,7 @@ BEGIN
   header_b := get_byte(b.bytes, 0);
 
   IF header_a != header_b THEN
-    RAISE EXCEPTION 'compare_ste_vec_encrypted_term_v1: expected equal header bytes';
+    RAISE EXCEPTION 'eql_v1.compare_ste_vec_encrypted_term: expected equal header bytes';
   END IF;
 
   -- `substr` is 1-indexed (yes, `subtr` starts at 1 and `get_byte` starts at 0).
@@ -31,59 +31,59 @@ BEGIN
 
   CASE header_a
     WHEN 0 THEN
-      RAISE EXCEPTION 'compare_ste_vec_encrypted_term_v1: can not compare MAC terms';
+      RAISE EXCEPTION 'eql_v1.compare_ste_vec_encrypted_term: can not compare MAC terms';
     WHEN 1 THEN
-      RETURN compare_ore_cllw_8_v1(ROW(body_a)::ore_cllw_8_v1, ROW(body_b)::ore_cllw_8_v1);
+      RETURN eql_v1.compare_ore_cllw_8_v1(ROW(body_a)::eql_v1.ore_cllw_8_v1, ROW(body_b)::eql_v1.ore_cllw_8_v1);
     WHEN 2 THEN
-      RETURN compare_lex_ore_cllw_8_v1(ROW(body_a)::ore_cllw_8_variable_v1, ROW(body_b)::ore_cllw_8_variable_v1);
+      RETURN eql_v1.compare_lex_ore_cllw_8_v1(ROW(body_a)::eql_v1.ore_cllw_8_variable_v1, ROW(body_b)::eql_v1.ore_cllw_8_variable_v1);
     ELSE
-      RAISE EXCEPTION 'compare_ste_vec_encrypted_term_v1: invalid header for cs_ste_vec_encrypted_term_v1: header "%", body "%', header_a, body_a;
+      RAISE EXCEPTION 'eql_v1.compare_ste_vec_encrypted_term: invalid header for ste_vec_encrypted_term: header "%", body "%', header_a, body_a;
   END CASE;
 END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_eq(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_encrypted_term_eq(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_eq(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT __bytea_ct_eq(a.bytes, b.bytes)
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_eq(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_neq(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_encrypted_term_neq(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_neq(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT not __bytea_ct_eq(a.bytes, b.bytes)
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_neq(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT not eql_v1.__bytea_ct_eq(a.bytes, b.bytes)
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_lt(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_encrypted_term_lt(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_lt(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT compare_ste_vec_encrypted_term_v1(a, b) = -1
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_lt(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT eql_v1.compare_ste_vec_encrypted_term(a, b) = -1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_lte(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_encrypted_term_lte(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_lte(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT compare_ste_vec_encrypted_term_v1(a, b) != 1
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_lte(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT eql_v1.compare_ste_vec_encrypted_term(a, b) != 1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_gt(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.cs_ste_vec_encrypted_term_gt(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_gt(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT compare_ste_vec_encrypted_term_v1(a, b) = 1
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_gt(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT eql_v1.compare_ste_vec_encrypted_term(a, b) = 1
 $$ LANGUAGE SQL;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_encrypted_term_gte(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_encrypted_term_gte(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE FUNCTION cs_ste_vec_encrypted_term_gte(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1) RETURNS boolean AS $$
-  SELECT compare_ste_vec_encrypted_term_v1(a, b) != -1
+CREATE FUNCTION eql_v1.ste_vec_encrypted_term_gte(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term) RETURNS boolean AS $$
+  SELECT eql_v1.compare_ste_vec_encrypted_term(a, b) != -1
 $$ LANGUAGE SQL;
 
-DROP OPERATOR IF EXISTS = (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_ste_vec_encrypted_term_eq",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_eq,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -91,12 +91,12 @@ CREATE OPERATOR = (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS <> (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_ste_vec_encrypted_term_neq",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_neq,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -104,12 +104,12 @@ CREATE OPERATOR <> (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS > (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS > (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
 
 CREATE OPERATOR > (
-  PROCEDURE="cs_ste_vec_encrypted_term_gt",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_gt,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = <=,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -117,12 +117,12 @@ CREATE OPERATOR > (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS < (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS < (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
 
 CREATE OPERATOR < (
-  PROCEDURE="cs_ste_vec_encrypted_term_lt",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_lt,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = >=,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -130,12 +130,12 @@ CREATE OPERATOR < (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS >= (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
 
 CREATE OPERATOR >= (
-  PROCEDURE="cs_ste_vec_encrypted_term_gte",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_gte,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = <,
   RESTRICT = scalarltsel,
   JOIN = scalarltjoinsel,
@@ -143,12 +143,12 @@ CREATE OPERATOR >= (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS <= (cs_ste_vec_encrypted_term_v1, cs_ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
 
 CREATE OPERATOR <= (
-  PROCEDURE="cs_ste_vec_encrypted_term_lte",
-  LEFTARG=cs_ste_vec_encrypted_term_v1,
-  RIGHTARG=cs_ste_vec_encrypted_term_v1,
+  FUNCTION=eql_v1.ste_vec_encrypted_term_lte,
+  LEFTARG=eql_v1.ste_vec_encrypted_term,
+  RIGHTARG=eql_v1.ste_vec_encrypted_term,
   NEGATOR = >,
   RESTRICT = scalargtsel,
   JOIN = scalargtjoinsel,
@@ -156,45 +156,45 @@ CREATE OPERATOR <= (
   MERGES
 );
 
-DROP OPERATOR FAMILY IF EXISTS cs_ste_vec_encrypted_term_v1_btree_ops USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ste_vec_encrypted_term_btree_ops USING btree;
 
-CREATE OPERATOR FAMILY cs_ste_vec_encrypted_term_v1_btree_ops USING btree;
+CREATE OPERATOR FAMILY eql_v1.ste_vec_encrypted_term_btree_ops USING btree;
 
-DROP OPERATOR CLASS IF EXISTS cs_ste_vec_encrypted_term_v1_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ste_vec_encrypted_term_btree_ops USING btree;
 
-CREATE OPERATOR CLASS cs_ste_vec_encrypted_term_v1_btree_ops DEFAULT FOR TYPE cs_ste_vec_encrypted_term_v1 USING btree FAMILY cs_ste_vec_encrypted_term_v1_btree_ops  AS
+CREATE OPERATOR CLASS eql_v1.ste_vec_encrypted_term_btree_ops DEFAULT FOR TYPE eql_v1.ste_vec_encrypted_term USING btree FAMILY eql_v1.ste_vec_encrypted_term_btree_ops  AS
         OPERATOR 1 <,
         OPERATOR 2 <=,
         OPERATOR 3 =,
         OPERATOR 4 >=,
         OPERATOR 5 >,
-        FUNCTION 1 compare_ste_vec_encrypted_term_v1(a cs_ste_vec_encrypted_term_v1, b cs_ste_vec_encrypted_term_v1);
+        FUNCTION 1 eql_v1.compare_ste_vec_encrypted_term(a eql_v1.ste_vec_encrypted_term, b eql_v1.ste_vec_encrypted_term);
 
-CREATE TYPE cs_ste_vec_v1_entry AS (
+CREATE TYPE eql_v1.ste_vec_entry AS (
     tokenized_selector text,
-    term cs_ste_vec_encrypted_term_v1,
+    term eql_v1.ste_vec_encrypted_term,
     ciphertext text
 );
 
-CREATE TYPE cs_ste_vec_index_v1 AS (
-    entries cs_ste_vec_v1_entry[]
+CREATE TYPE eql_v1.ste_vec_index AS (
+    entries eql_v1.ste_vec_entry[]
 );
 
-DROP FUNCTION IF EXISTS cs_ste_vec_value_v1(col jsonb, selector jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_value(col jsonb, selector jsonb);
 
 -- col: already encrypted payload
 -- selector: already encrypted payload
 -- returns a value in the format of our custom jsonb schema that will be decrypted
-CREATE FUNCTION cs_ste_vec_value_v1(col jsonb, selector jsonb)
+CREATE FUNCTION eql_v1.cs_ste_vec_value(col jsonb, selector jsonb)
 RETURNS jsonb AS $$
 DECLARE
-  ste_vec_index cs_ste_vec_index_v1;
+  ste_vec_index eql_v1.ste_vec_index;
   target_selector text;
   found text;
   ignored text;
   i integer;
 BEGIN
-  ste_vec_index := cs_ste_vec_v1(col);
+  ste_vec_index := eql_v1.ste_vec(col);
 
   IF ste_vec_index IS NULL THEN
     RETURN NULL;
@@ -228,19 +228,19 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_terms_v1(col jsonb, selector jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_terms(col jsonb, selector jsonb);
 
-CREATE FUNCTION cs_ste_vec_terms_v1(col jsonb, selector jsonb)
-RETURNS cs_ste_vec_encrypted_term_v1[] AS $$
+CREATE FUNCTION eql_v1.ste_vec_terms(col jsonb, selector jsonb)
+RETURNS eql_v1.ste_vec_encrypted_term[] AS $$
 DECLARE
-  ste_vec_index cs_ste_vec_index_v1;
+  ste_vec_index eql_v1.ste_vec_index;
   target_selector text;
-  found cs_ste_vec_encrypted_term_v1;
-  ignored cs_ste_vec_encrypted_term_v1;
+  found eql_v1.ste_vec_encrypted_term;
+  ignored eql_v1.ste_vec_encrypted_term;
   i integer;
-  term_array cs_ste_vec_encrypted_term_v1[];
+  term_array eql_v1.ste_vec_encrypted_term[];
 BEGIN
-  ste_vec_index := cs_ste_vec_v1(col);
+  ste_vec_index := eql_v1.ste_vec(col);
 
   IF ste_vec_index IS NULL THEN
     RETURN NULL;
@@ -263,21 +263,21 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_term_v1(col jsonb, selector jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_term(col jsonb, selector jsonb);
 
 -- col: already encrypted payload
 -- selector: already encrypted payload
 -- returns a value that can be used for comparison operations
-CREATE OR REPLACE FUNCTION cs_ste_vec_term_v1(col jsonb, selector jsonb)
-RETURNS cs_ste_vec_encrypted_term_v1 AS $$
+CREATE OR REPLACE FUNCTION eql_v1._ste_vec_term(col jsonb, selector jsonb)
+RETURNS eql_v1.ste_vec_encrypted_term AS $$
 DECLARE
-  ste_vec_index cs_ste_vec_index_v1;
+  ste_vec_index eql_v1.ste_vec_index;
   target_selector text;
-  found cs_ste_vec_encrypted_term_v1;
-  ignored cs_ste_vec_encrypted_term_v1;
+  found eql_v1.ste_vec_encrypted_term;
+  ignored eql_v1.ste_vec_encrypted_term;
   i integer;
 BEGIN
-  ste_vec_index := cs_ste_vec_v1(col);
+  ste_vec_index := eql_v1.ste_vec(col);
 
   IF ste_vec_index IS NULL THEN
     RETURN NULL;
@@ -299,14 +299,14 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS cs_ste_vec_term_v1(col jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_term(col jsonb);
 
-CREATE FUNCTION cs_ste_vec_term_v1(col jsonb)
-RETURNS cs_ste_vec_encrypted_term_v1 AS $$
+CREATE FUNCTION eql_v1.ste_vec_term(col jsonb)
+RETURNS eql_v1.ste_vec_encrypted_term AS $$
 DECLARE
-  ste_vec_index cs_ste_vec_index_v1;
+  ste_vec_index eql_v1.ste_vec_index;
 BEGIN
-  ste_vec_index := cs_ste_vec_v1(col);
+  ste_vec_index := eql_v1.ste_vec(col);
 
   IF ste_vec_index IS NULL THEN
     RETURN NULL;
@@ -317,9 +317,9 @@ END;
 $$ LANGUAGE plpgsql;
 
 -- Determine if a == b (ignoring ciphertext values)
-DROP FUNCTION IF EXISTS cs_ste_vec_v1_entry_eq(a cs_ste_vec_v1_entry, b cs_ste_vec_v1_entry);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_entry_eq(a eql_v1.ste_vec_entry, b eql_v1.ste_vec_entry);
 
-CREATE FUNCTION cs_ste_vec_v1_entry_eq(a cs_ste_vec_v1_entry, b cs_ste_vec_v1_entry)
+CREATE FUNCTION eql_v1.ste_vec_entry_eq(a eql_v1.ste_vec_entry, b eql_v1.ste_vec_entry)
 RETURNS boolean AS $$
 DECLARE
     sel_cmp int;
@@ -341,9 +341,9 @@ END;
 $$ LANGUAGE plpgsql;
 
 -- Determine if a contains b (ignoring ciphertext values)
-DROP FUNCTION IF EXISTS ste_vec_v1_logical_contains(a cs_ste_vec_index_v1, b cs_ste_vec_index_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_logical_contains(a eql_v1.ste_vec_index, b eql_v1.ste_vec_index);
 
-CREATE FUNCTION ste_vec_v1_logical_contains(a cs_ste_vec_index_v1, b cs_ste_vec_index_v1)
+CREATE FUNCTION eql_v1.ste_vec_logical_contains(a eql_v1.ste_vec_index, b eql_v1.ste_vec_index)
 RETURNS boolean AS $$
 DECLARE
     result boolean;
@@ -354,7 +354,7 @@ BEGIN
         RETURN result;
     END IF;
     FOR i IN 1..array_length(b.entries, 1) LOOP
-        intermediate_result := cs_ste_vec_v1_entry_array_contains_entry(a.entries, b.entries[i]);
+        intermediate_result := eql_v1.ste_vec_entry_array_contains_entry(a.entries, b.entries[i]);
         result := result AND intermediate_result;
     END LOOP;
     RETURN result;
@@ -362,9 +362,9 @@ END;
 $$ LANGUAGE plpgsql;
 
 -- Determine if a contains b (ignoring ciphertext values)
-DROP FUNCTION IF EXISTS cs_ste_vec_v1_entry_array_contains_entry(a cs_ste_vec_v1_entry[], b cs_ste_vec_v1_entry);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_entry_array_contains_entry(a eql_v1.ste_vec_entry[], b eql_v1.ste_vec_entry);
 
-CREATE FUNCTION cs_ste_vec_v1_entry_array_contains_entry(a cs_ste_vec_v1_entry[], b cs_ste_vec_v1_entry)
+CREATE FUNCTION eql_v1.ste_vec_entry_array_contains_entry(a eql_v1.ste_vec_entry[], b eql_v1.ste_vec_entry)
 RETURNS boolean AS $$
 DECLARE
     result boolean;
@@ -384,61 +384,57 @@ END;
 $$ LANGUAGE plpgsql;
 
 -- Determine if a is contained by b (ignoring ciphertext values)
-DROP FUNCTION IF EXISTS ste_vec_v1_logical_is_contained(a cs_ste_vec_index_v1, b cs_ste_vec_index_v1);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec_logical_is_contained(a eql_v1.ste_vec_index, b eql_v1.ste_vec_index);
 
-CREATE FUNCTION ste_vec_v1_logical_is_contained(a cs_ste_vec_index_v1, b cs_ste_vec_index_v1)
+CREATE FUNCTION eql_v1.ste_vec_logical_is_contained(a eql_v1.ste_vec_index, b eql_v1.ste_vec_index)
 RETURNS boolean AS $$
 BEGIN
-    RETURN ste_vec_v1_logical_contains(b, a);
+    RETURN eql_v1.ste_vec_logical_contains(b, a);
 END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS jsonb_to_cs_ste_vec_index_v1(input jsonb);
+DROP FUNCTION IF EXISTS eql_v1.jsonb_to_ste_vec_index(input jsonb);
 
-CREATE FUNCTION jsonb_to_cs_ste_vec_index_v1(input jsonb)
-RETURNS cs_ste_vec_index_v1 AS $$
+CREATE FUNCTION eql_v1.jsonb_to_ste_vec_index(input jsonb)
+RETURNS eql_v1.ste_vec_index AS $$
 DECLARE
-    vec_entry cs_ste_vec_v1_entry;
-    entry_array cs_ste_vec_v1_entry[];
+    vec_entry eql_v1.ste_vec_entry;
+    entry_array eql_v1.ste_vec_entry[];
     entry_json jsonb;
-    entry_json_array jsonb[];
-    entry_array_length int;
-    i int;
 BEGIN
     FOR entry_json IN SELECT * FROM jsonb_array_elements(input)
     LOOP
         vec_entry := ROW(
            entry_json->>0,
-           ROW(decode(entry_json->>1, 'hex'))::cs_ste_vec_encrypted_term_v1,
+           ROW(decode(entry_json->>1, 'hex'))::eql_v1.ste_vec_encrypted_term,
            entry_json->>2
-        )::cs_ste_vec_v1_entry;
+        )::eql_v1.ste_vec_entry;
         entry_array := array_append(entry_array, vec_entry);
     END LOOP;
-
-    RETURN ROW(entry_array)::cs_ste_vec_index_v1;
+    RETURN ROW(entry_array)::eql_v1.ste_vec_index;
 END;
 $$ LANGUAGE plpgsql;
 
-DROP CAST IF EXISTS (jsonb AS cs_ste_vec_index_v1);
+DROP CAST IF EXISTS (jsonb AS eql_v1.ste_vec_index);
 
-CREATE CAST (jsonb AS cs_ste_vec_index_v1)
-	WITH FUNCTION jsonb_to_cs_ste_vec_index_v1(jsonb) AS IMPLICIT;
+CREATE CAST (jsonb AS eql_v1.ste_vec_index)
+	WITH FUNCTION eql_v1.jsonb_to_ste_vec_index(jsonb) AS IMPLICIT;
 
-DROP OPERATOR IF EXISTS @> (cs_ste_vec_index_v1, cs_ste_vec_index_v1);
+DROP OPERATOR IF EXISTS @> (eql_v1.ste_vec_index, eql_v1.ste_vec_index);
 
 CREATE OPERATOR @> (
-  PROCEDURE="ste_vec_v1_logical_contains",
-  LEFTARG=cs_ste_vec_index_v1,
-  RIGHTARG=cs_ste_vec_index_v1,
+  FUNCTION=eql_v1.ste_vec_logical_contains,
+  LEFTARG=eql_v1.ste_vec_index,
+  RIGHTARG=eql_v1.ste_vec_index,
   COMMUTATOR = <@
 );
 
-DROP OPERATOR IF EXISTS <@ (cs_ste_vec_index_v1, cs_ste_vec_index_v1);
+DROP OPERATOR IF EXISTS <@ (eql_v1.ste_vec_index, eql_v1.ste_vec_index);
 
 CREATE OPERATOR <@ (
-  PROCEDURE="ste_vec_v1_logical_is_contained",
-  LEFTARG=cs_ste_vec_index_v1,
-  RIGHTARG=cs_ste_vec_index_v1,
+  FUNCTION=eql_v1.ste_vec_logical_is_contained,
+  LEFTARG=eql_v1.ste_vec_index,
+  RIGHTARG=eql_v1.ste_vec_index,
   COMMUTATOR = @>
 );
diff --git a/sql/010-core-domain-types.sql b/sql/010-core-domain-types.sql
index 8d9ba78..f6c62cc 100644
--- a/sql/010-core-domain-types.sql
+++ b/sql/010-core-domain-types.sql
@@ -1,23 +1,23 @@
-DROP DOMAIN IF EXISTS cs_match_index_v1;
-CREATE DOMAIN cs_match_index_v1 AS smallint[];
+DROP DOMAIN IF EXISTS eql_v1.match_index;
+CREATE DOMAIN eql_v1.match_index AS smallint[];
 
-DROP DOMAIN IF EXISTS cs_unique_index_v1;
-CREATE DOMAIN cs_unique_index_v1 AS text;
+DROP DOMAIN IF EXISTS eql_v1.unique_index;
+CREATE DOMAIN eql_v1.unique_index AS text;
 
 
--- cs_encrypted_v1 is a column type and cannot be dropped if in use
+-- eql_v1_encrypted is a column type and cannot be dropped if in use
 DO $$
 BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'cs_encrypted_v1') THEN
-      CREATE DOMAIN cs_encrypted_v1 AS JSONB;
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'eql_v1_encrypted') THEN
+      CREATE DOMAIN eql_v1_encrypted AS JSONB;
 	  END IF;
 END
 $$;
 
 
 -- Should include a kind field
-DROP FUNCTION IF EXISTS _cs_encrypted_check_k(jsonb);
-CREATE FUNCTION _cs_encrypted_check_k(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_k(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_k(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -32,8 +32,8 @@ $$ LANGUAGE plpgsql;
 --
 -- CT payload should include a c field
 --
-DROP FUNCTION IF EXISTS _cs_encrypted_check_k_ct(jsonb);
-CREATE FUNCTION _cs_encrypted_check_k_ct(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_k_ct(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_k_ct(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -51,8 +51,8 @@ $$ LANGUAGE plpgsql;
 --
 -- SV payload should include an sv field
 --
-DROP FUNCTION IF EXISTS _cs_encrypted_check_k_sv(jsonb);
-CREATE FUNCTION _cs_encrypted_check_k_sv(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_k_sv(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_k_sv(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -68,8 +68,8 @@ $$ LANGUAGE plpgsql;
 
 
 -- Plaintext field should never be present in an encrypted column
-DROP FUNCTION IF EXISTS _cs_encrypted_check_p(jsonb);
-CREATE FUNCTION _cs_encrypted_check_p(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_p(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_p(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -81,8 +81,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 -- Should include an ident field
-DROP FUNCTION IF EXISTS _cs_encrypted_check_i(jsonb);
-CREATE FUNCTION _cs_encrypted_check_i(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_i(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_i(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -94,8 +94,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 -- Query field should never be present in an encrypted column
-DROP FUNCTION IF EXISTS _cs_encrypted_check_q(jsonb);
-CREATE FUNCTION _cs_encrypted_check_q(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_q(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_q(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -107,8 +107,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 -- Ident field should include table and column
-DROP FUNCTION IF EXISTS _cs_encrypted_check_i_ct(jsonb);
-CREATE FUNCTION _cs_encrypted_check_i_ct(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_i_ct(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_i_ct(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -120,8 +120,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 -- Should include a version field
-DROP FUNCTION IF EXISTS _cs_encrypted_check_v(jsonb);
-CREATE FUNCTION _cs_encrypted_check_v(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1._encrypted_check_v(jsonb);
+CREATE FUNCTION eql_v1._encrypted_check_v(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -133,27 +133,27 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_check_encrypted_v1(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.check_encrypted(val jsonb);
 
-CREATE FUNCTION cs_check_encrypted_v1(val jsonb)
+CREATE FUNCTION eql_v1.check_encrypted(val jsonb)
   RETURNS BOOLEAN
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 BEGIN ATOMIC
     RETURN (
-      _cs_encrypted_check_v(val) AND
-      _cs_encrypted_check_i(val) AND
-      _cs_encrypted_check_k(val) AND
-      _cs_encrypted_check_k_ct(val) AND
-      _cs_encrypted_check_k_sv(val) AND
-      _cs_encrypted_check_q(val) AND
-      _cs_encrypted_check_p(val)
+      eql_v1._encrypted_check_v(val) AND
+      eql_v1._encrypted_check_i(val) AND
+      eql_v1._encrypted_check_k(val) AND
+      eql_v1._encrypted_check_k_ct(val) AND
+      eql_v1._encrypted_check_k_sv(val) AND
+      eql_v1._encrypted_check_q(val) AND
+      eql_v1._encrypted_check_p(val)
     );
 END;
 
-ALTER DOMAIN cs_encrypted_v1 DROP CONSTRAINT IF EXISTS cs_encrypted_v1_check;
+ALTER DOMAIN eql_v1_encrypted DROP CONSTRAINT IF EXISTS eql_v1_encrypted_check;
 
-ALTER DOMAIN cs_encrypted_v1
-  ADD CONSTRAINT cs_encrypted_v1_check CHECK (
-   cs_check_encrypted_v1(VALUE)
+ALTER DOMAIN eql_v1_encrypted
+  ADD CONSTRAINT eql_v1_encrypted_check CHECK (
+   eql_v1.check_encrypted(VALUE)
 );
 
diff --git a/sql/011-core-functions.sql b/sql/011-core-functions.sql
index 48d3695..fb40637 100644
--- a/sql/011-core-functions.sql
+++ b/sql/011-core-functions.sql
@@ -1,6 +1,6 @@
-DROP FUNCTION IF EXISTS cs_ciphertext_v1_v0_0(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ciphertext(val jsonb);
 
-CREATE FUNCTION cs_ciphertext_v1_v0_0(val jsonb)
+CREATE FUNCTION eql_v1.ciphertext(val jsonb)
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -13,67 +13,28 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_ciphertext_v1_v0(val jsonb);
-
-CREATE FUNCTION cs_ciphertext_v1_v0(val jsonb)
-    RETURNS text
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ciphertext_v1_v0_0(val);
-END;
-
-
-DROP FUNCTION IF EXISTS cs_ciphertext_v1(val jsonb);
-
-CREATE FUNCTION cs_ciphertext_v1(val jsonb)
-    RETURNS text
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ciphertext_v1_v0_0(val);
-END;
-
-
 -- extracts match index from an emcrypted column
-DROP FUNCTION IF EXISTS cs_match_v1_v0_0(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.match(val jsonb);
 
-CREATE FUNCTION cs_match_v1_v0_0(val jsonb)
-  RETURNS cs_match_index_v1
+CREATE FUNCTION eql_v1.match(val jsonb)
+  RETURNS eql_v1.match_index
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
 	BEGIN
     IF val ? 'm' THEN
-      RETURN ARRAY(SELECT jsonb_array_elements(val->'m'))::cs_match_index_v1;
+      RETURN ARRAY(SELECT jsonb_array_elements(val->'m'))::eql_v1.match_index;
     END IF;
     RAISE 'Expected a match index (m) value in json: %', val;
   END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_match_v1_v0(val jsonb);
-
-CREATE FUNCTION cs_match_v1_v0(val jsonb)
-  RETURNS cs_match_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_match_v1_v0_0(val);
-END;
-
-
-DROP FUNCTION IF EXISTS cs_match_v1(val jsonb);
-
-CREATE FUNCTION cs_match_v1(val jsonb)
-  RETURNS cs_match_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_match_v1_v0_0(val);
-END;
-
 
 -- extracts unique index from an encrypted column
-DROP FUNCTION IF EXISTS  cs_unique_v1_v0_0(val jsonb);
+DROP FUNCTION IF EXISTS  eql_v1.unique(val jsonb);
 
-CREATE FUNCTION cs_unique_v1_v0_0(val jsonb)
-  RETURNS cs_unique_index_v1
+CREATE FUNCTION eql_v1.unique(val jsonb)
+  RETURNS eql_v1.unique_index
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
 	BEGIN
@@ -85,144 +46,88 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS  cs_unique_v1_v0(val jsonb);
-
-CREATE FUNCTION cs_unique_v1_v0(val jsonb)
-  RETURNS cs_unique_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_unique_v1_v0_0(val);
-END;
-
-
-DROP FUNCTION IF EXISTS cs_unique_v1(val jsonb);
-
-CREATE FUNCTION cs_unique_v1(val jsonb)
-  RETURNS cs_unique_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_unique_v1_v0_0(val);
-END;
-
 -- extracts json ste_vec index from an encrypted column
-DROP FUNCTION IF EXISTS cs_ste_vec_v1_v0_0(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ste_vec(val jsonb);
 
-CREATE FUNCTION cs_ste_vec_v1_v0_0(val jsonb)
-  RETURNS cs_ste_vec_index_v1
+CREATE FUNCTION eql_v1.ste_vec(val jsonb)
+  RETURNS eql_v1.ste_vec_index
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
 	BEGIN
     IF val ? 'sv' THEN
-      RETURN (val->'sv')::cs_ste_vec_index_v1;
+      RETURN (val->'sv')::eql_v1.ste_vec_index;
     END IF;
     RAISE 'Expected a structured vector index (sv) value in json: %', val;
   END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_ste_vec_v1_v0(val jsonb);
-
-CREATE FUNCTION cs_ste_vec_v1_v0(val jsonb)
-  RETURNS cs_ste_vec_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ste_vec_v1_v0_0(val);
-END;
-
-
-DROP FUNCTION IF EXISTS cs_ste_vec_v1(val jsonb);
-
-CREATE FUNCTION cs_ste_vec_v1(val jsonb)
-  RETURNS cs_ste_vec_index_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ste_vec_v1_v0_0(val);
-END;
-
-
 -- casts text to ore_64_8_v1_term (bytea)
-DROP FUNCTION IF EXISTS _cs_text_to_ore_64_8_v1_term_v1_0(t text);
+DROP FUNCTION IF EXISTS eql_v1.text_to_ore_64_8_v1_term(t text);
 
-CREATE FUNCTION _cs_text_to_ore_64_8_v1_term_v1_0(t text)
-  RETURNS ore_64_8_v1_term
+CREATE FUNCTION eql_v1.text_to_ore_64_8_v1_term(t text)
+  RETURNS eql_v1.ore_64_8_v1_term
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 BEGIN ATOMIC
 	RETURN t::bytea;
 END;
 
 -- cast to cleanup ore_64_8_v1 extraction
-DROP CAST IF EXISTS (text AS ore_64_8_v1_term);
+DROP CAST IF EXISTS (text AS eql_v1.ore_64_8_v1_term);
 
-CREATE CAST (text AS ore_64_8_v1_term)
-	WITH FUNCTION _cs_text_to_ore_64_8_v1_term_v1_0(text) AS IMPLICIT;
+CREATE CAST (text AS eql_v1.ore_64_8_v1_term)
+	WITH FUNCTION eql_v1.text_to_ore_64_8_v1_term(text) AS IMPLICIT;
 
-DROP FUNCTION IF EXISTS jsonb_array_to_ore_64_8_v1(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.jsonb_array_to_ore_64_8_v1(val jsonb);
 
 -- Casts a jsonb array of hex-encoded strings to the `ore_64_8_v1` composite type.
 -- In other words, this function takes the ORE index format sent through in the
 -- EQL payload from Proxy and decodes it as the composite type that we use for
 -- ORE operations on the Postgres side.
-CREATE FUNCTION jsonb_array_to_ore_64_8_v1(val jsonb)
-RETURNS ore_64_8_v1 AS $$
+CREATE FUNCTION eql_v1.jsonb_array_to_ore_64_8_v1(val jsonb)
+RETURNS eql_v1.ore_64_8_v1 AS $$
 DECLARE
-  terms_arr ore_64_8_v1_term[];
+  terms_arr eql_v1.ore_64_8_v1_term[];
 BEGIN
   IF jsonb_typeof(val) = 'null' THEN
     RETURN NULL;
   END IF;
 
-  SELECT array_agg(ROW(decode(value::text, 'hex'))::ore_64_8_v1_term)
+  SELECT array_agg(ROW(decode(value::text, 'hex'))::eql_v1.ore_64_8_v1_term)
     INTO terms_arr
   FROM jsonb_array_elements_text(val) AS value;
 
-  RETURN ROW(terms_arr)::ore_64_8_v1;
+  RETURN ROW(terms_arr)::eql_v1.ore_64_8_v1;
 END;
 $$ LANGUAGE plpgsql;
 
 -- extracts ore index from an encrypted column
-DROP FUNCTION IF EXISTS cs_ore_64_8_v1_v0_0(val jsonb);
+DROP FUNCTION IF EXISTS eql_v1.ore_64_8_v1(val jsonb);
 
-CREATE FUNCTION cs_ore_64_8_v1_v0_0(val jsonb)
-  RETURNS ore_64_8_v1
+CREATE FUNCTION eql_v1.ore_64_8_v1(val jsonb)
+  RETURNS eql_v1.ore_64_8_v1
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
 	BEGIN
     IF val ? 'o' THEN
-      RETURN jsonb_array_to_ore_64_8_v1(val->'o');
+      RETURN eql_v1.jsonb_array_to_ore_64_8_v1(val->'o');
     END IF;
     RAISE 'Expected an ore index (o) value in json: %', val;
   END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_ore_64_8_v1_v0(val jsonb);
-
-CREATE FUNCTION cs_ore_64_8_v1_v0(val jsonb)
-  RETURNS ore_64_8_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ore_64_8_v1_v0_0(val);
-END;
-
-DROP FUNCTION IF EXISTS cs_ore_64_8_v1(val jsonb);
-
-CREATE FUNCTION cs_ore_64_8_v1(val jsonb)
-  RETURNS ore_64_8_v1
-  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-BEGIN ATOMIC
-	RETURN cs_ore_64_8_v1_v0_0(val);
-END;
 
-DROP FUNCTION IF EXISTS _cs_first_grouped_value(jsonb, jsonb);
+DROP FUNCTION IF EXISTS eql_v1._first_grouped_value(jsonb, jsonb);
 
-CREATE FUNCTION _cs_first_grouped_value(jsonb, jsonb)
+CREATE FUNCTION eql_v1._first_grouped_value(jsonb, jsonb)
 RETURNS jsonb AS $$
   SELECT COALESCE($1, $2);
 $$ LANGUAGE sql IMMUTABLE;
 
-DROP AGGREGATE IF EXISTS cs_grouped_value_v1(jsonb);
+DROP AGGREGATE IF EXISTS eql_v1.cs_grouped_value(jsonb);
 
-CREATE AGGREGATE cs_grouped_value_v1(jsonb) (
-  SFUNC = _cs_first_grouped_value,
+CREATE AGGREGATE eql_v1.cs_grouped_value(jsonb) (
+  SFUNC = eql_v1._first_grouped_value,
   STYPE = jsonb
 );
diff --git a/sql/015-operators-eq.sql b/sql/015-operators-eq.sql
index 5b79543..1b4b67d 100644
--- a/sql/015-operators-eq.sql
+++ b/sql/015-operators-eq.sql
@@ -1,19 +1,19 @@
--- Operators for unique comparisons of cs_encrypted_v1 types
+-- Operators for unique comparisons of eql_v1_encrypted types
 --
 -- Support for the following comparisons:
 --
---      cs_encrypted_v1 = cs_encrypted_v1
---      cs_encrypted_v1 <> cs_encrypted_v1
---      cs_encrypted_v1 = jsonb
---      cs_encrypted_v1 <> jsonb
---      cs_encrypted_v1 = text
---      cs_encrypted_v1 <> text
+--      eql_v1_encrypted = eql_v1_encrypted
+--      eql_v1_encrypted <> eql_v1_encrypted
+--      eql_v1_encrypted = jsonb
+--      eql_v1_encrypted <> jsonb
+--      eql_v1_encrypted = text
+--      eql_v1_encrypted <> text
 --
 
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -22,13 +22,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) = cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) = eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) = cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.ore_64_8_v1(a) = eql_v1.ore_64_8_v1(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -39,9 +39,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -49,10 +49,10 @@ CREATE OPERATOR = (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1_encrypted, b jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -61,13 +61,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) = cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) = eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) = cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.cs_ore_64_8(a) = eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -77,8 +77,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   NEGATOR = <>,
   RESTRICT = eqsel,
@@ -88,10 +88,10 @@ CREATE OPERATOR = (
 );
 
 
-DROP OPERATOR IF EXISTS = (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS = (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a jsonb, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -100,13 +100,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) = cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) = eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) = cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.cs_ore_64_8(a) = eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -117,9 +117,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_encrypted_eq_v1",
+  FUNCTION=eql_v1.encrypted_eq,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -128,10 +128,10 @@ CREATE OPERATOR = (
 );
 
 
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, cs_unique_index_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a cs_encrypted_v1, b cs_unique_index_v1);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1.unique_index);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1.unique_index);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a cs_encrypted_v1, b cs_unique_index_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1.unique_index)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -139,7 +139,7 @@ AS $$
     u boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) = b);
+      u := (SELECT eql_v1.unique(a) = b);
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
@@ -150,9 +150,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_unique_index_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.unique_index,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -160,10 +160,10 @@ CREATE OPERATOR = (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS = (cs_unique_index_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a cs_unique_index_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.unique_index, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1.unique_index, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a cs_unique_index_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1.unique_index, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -171,7 +171,7 @@ AS $$
     u boolean;
   BEGIN
     BEGIN
-      u := (SELECT a = cs_unique_v1(b));
+      u := (SELECT a = eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
@@ -182,9 +182,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR =(
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=cs_unique_index_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1.unique_index,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -194,10 +194,10 @@ CREATE OPERATOR =(
 
 
 
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -206,7 +206,7 @@ AS $$
   BEGIN
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) = b);
+      o := (SELECT eql_v1.cs_ore_64_8(a) = b);
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -217,9 +217,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR = (
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -227,10 +227,10 @@ CREATE OPERATOR = (
   MERGES
 );
 
-DROP OPERATOR IF EXISTS = (ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_eq_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_eq(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_eq_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_eq(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -239,7 +239,7 @@ AS $$
   BEGIN
 
     BEGIN
-      o := (SELECT a = cs_ore_64_8_v1(b));
+      o := (SELECT a = eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -250,9 +250,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR =(
-  PROCEDURE="cs_encrypted_eq_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_eq,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = <>,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -264,10 +264,10 @@ CREATE OPERATOR =(
 
 --- ------------------------------------------------------------
 
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -276,13 +276,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) <> cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) <> eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) <> cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.cs_ore_64_8(a) <> eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -292,9 +292,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -303,10 +303,10 @@ CREATE OPERATOR <> (
 );
 
 
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1_encrypted, b jsonb)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -315,13 +315,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) <> cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) <> eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) <> cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.cs_ore_64_8(a) <> eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -331,8 +331,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   NEGATOR = =,
   RESTRICT = eqsel,
@@ -342,10 +342,10 @@ CREATE OPERATOR <> (
 );
 
 
-DROP OPERATOR IF EXISTS <> (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <> (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a jsonb, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -354,13 +354,13 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) <> cs_unique_v1(b));
+      u := (SELECT eql_v1.unique(a) <> eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
 
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) <> cs_ore_64_8_v1(b));
+      o := (SELECT eql_v1.cs_ore_64_8(a) <> eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -370,9 +370,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
+  FUNCTION=eql_v1.encrypted_neq,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -381,14 +381,14 @@ CREATE OPERATOR <> (
 );
 
 
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, cs_unique_index_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a cs_encrypted_v1, b cs_unique_index_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1.unique_index);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1.unique_index);
 
 --
--- Compare the cs_unique_index_v1 or return FALSE
--- cs_unique_index_v1 cannot be ore_64_8_v1
+-- Compare the eql_v1.unique_index or return FALSE
+-- eql_v1.unique_index cannot be eql_v1.ore_64_8_v1
 --
-CREATE FUNCTION cs_encrypted_neq_v1(a cs_encrypted_v1, b cs_unique_index_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1.unique_index)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -396,7 +396,7 @@ AS $$
     u boolean;
   BEGIN
     BEGIN
-      u := (SELECT cs_unique_v1(a) <> b);
+      u := (SELECT eql_v1.unique(a) <> b);
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
@@ -407,9 +407,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_unique_index_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.unique_index,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -419,13 +419,13 @@ CREATE OPERATOR <> (
 
 
 --
--- Compare the cs_unique_index_v1 or return FALSE
--- cs_unique_index_v1 cannot be ore_64_8_v1
+-- Compare the eql_v1.unique_index or return FALSE
+-- eql_v1.unique_index cannot be eql_v1.ore_64_8_v1
 --
-DROP OPERATOR IF EXISTS <> (cs_unique_index_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a cs_unique_index_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.unique_index, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1.unique_index, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a cs_unique_index_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1.unique_index, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -433,7 +433,7 @@ AS $$
     u boolean;
   BEGIN
     BEGIN
-      u := (SELECT a <> cs_unique_v1(b));
+      u := (SELECT a <> eql_v1.unique(b));
     EXCEPTION WHEN OTHERS THEN
       u := false;
     END;
@@ -444,9 +444,9 @@ $$ LANGUAGE plpgsql;
 
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=cs_unique_index_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1.unique_index,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -457,10 +457,10 @@ CREATE OPERATOR <> (
 
 
 
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -468,7 +468,7 @@ AS $$
     o boolean;
   BEGIN
     BEGIN
-      o := (SELECT cs_ore_64_8_v1(a) <> b);
+      o := (SELECT eql_v1.cs_ore_64_8(a) <> b);
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -478,9 +478,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -489,10 +489,10 @@ CREATE OPERATOR <> (
 );
 
 
-DROP OPERATOR IF EXISTS <> (ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_neq_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_neq(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_neq_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_neq(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
   RETURNS boolean
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -501,7 +501,7 @@ AS $$
   BEGIN
 
     BEGIN
-      o := (SELECT a <> cs_ore_64_8_v1(b));
+      o := (SELECT a <> eql_v1.cs_ore_64_8(b));
     EXCEPTION WHEN OTHERS THEN
       o := false;
     END;
@@ -511,9 +511,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 CREATE OPERATOR <> (
-  PROCEDURE="cs_encrypted_neq_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_neq,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   NEGATOR = =,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
diff --git a/sql/016-operators-match.sql b/sql/016-operators-match.sql
index 4c3b8b5..1458c7d 100644
--- a/sql/016-operators-match.sql
+++ b/sql/016-operators-match.sql
@@ -1,24 +1,26 @@
--- Operators for match comparisons of cs_encrypted_v1 types
+-- Operators for match comparisons of eql_v1_encrypted types
 --
 -- Support for the following comparisons:
 --
---      cs_encrypted_v1 ~~ cs_encrypted_v1
---      cs_encrypted_v1 ~~ jsonb
---      cs_encrypted_v1 ~~ cs_match_index_v1
+--      eql_v1_encrypted ~~ eql_v1_encrypted
+--      eql_v1_encrypted ~~ jsonb
+--      eql_v1_encrypted ~~ eql_v1.match_index
 --
 
-DROP OPERATOR IF EXISTS ~~ (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS ~~* (eql_v1_encrypted, eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_match_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a eql_v1_encrypted, b eql_v1_encrypted);
+
+CREATE FUNCTION eql_v1.encrypted_match(a eql_v1_encrypted, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_match_v1(a) @> cs_match_v1(b);
+  SELECT eql_v1.match(a) @> eql_v1.match(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -26,9 +28,9 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -36,18 +38,18 @@ CREATE OPERATOR ~~*(
 );
 
 
-DROP OPERATOR IF EXISTS ~~ (cs_encrypted_v1, cs_match_index_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a cs_encrypted_v1, b cs_match_index_v1);
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, eql_v1.match_index);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a eql_v1_encrypted, b eql_v1.match_index);
 
-CREATE FUNCTION cs_encrypted_match_v1(a cs_encrypted_v1, b cs_match_index_v1)
+CREATE FUNCTION eql_v1.encrypted_match(a eql_v1_encrypted, b eql_v1.match_index)
 RETURNS boolean AS $$
-  SELECT cs_match_v1(a) @> b;
+  SELECT eql_v1.match(a) @> b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_match_index_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.match_index,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -55,9 +57,9 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_match_index_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.match_index,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -66,18 +68,18 @@ CREATE OPERATOR ~~*(
 
 
 
-DROP OPERATOR IF EXISTS ~~ (cs_match_index_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a cs_match_index_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS ~~ (eql_v1.match_index, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a eql_v1.match_index, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_match_v1(a cs_match_index_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_match(a eql_v1.match_index, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT a @> cs_match_v1(b);
+  SELECT a @> eql_v1.match(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_match_index_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1.match_index,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -85,9 +87,9 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_match_index_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1.match_index,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -95,18 +97,18 @@ CREATE OPERATOR ~~*(
 );
 
 
-DROP OPERATOR IF EXISTS ~~ (cs_match_index_v1, cs_match_index_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a cs_match_index_v1, b cs_match_index_v1);
+DROP OPERATOR IF EXISTS ~~ (eql_v1.match_index, eql_v1.match_index);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a eql_v1.match_index, b eql_v1.match_index);
 
-CREATE FUNCTION cs_encrypted_match_v1(a cs_match_index_v1, b cs_match_index_v1)
+CREATE FUNCTION eql_v1.encrypted_match(a eql_v1.match_index, b eql_v1.match_index)
 RETURNS boolean AS $$
   SELECT a @> b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_match_index_v1,
-  RIGHTARG=cs_match_index_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1.match_index,
+  RIGHTARG=eql_v1.match_index,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -114,9 +116,9 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_match_index_v1,
-  RIGHTARG=cs_match_index_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1.match_index,
+  RIGHTARG=eql_v1.match_index,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -124,17 +126,17 @@ CREATE OPERATOR ~~*(
 );
 
 
-DROP OPERATOR IF EXISTS ~~ (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_match_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_match(a eql_v1_encrypted, b jsonb)
 RETURNS boolean AS $$
-  SELECT cs_match_v1(a) @> cs_match_v1(b);
+  SELECT eql_v1.match(a) @> eql_v1.match(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -143,8 +145,8 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_match,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
@@ -154,18 +156,18 @@ CREATE OPERATOR ~~*(
 
 
 
-DROP OPERATOR IF EXISTS ~~ (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_match_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS ~~ (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_match(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_match_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_match(a jsonb, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_match_v1(a) @> cs_match_v1(b);
+  SELECT eql_v1.match(a) @> eql_v1.match(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR ~~(
-  PROCEDURE="cs_encrypted_match_v1",
+  FUNCTION=eql_v1.encrypted_match,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
@@ -173,9 +175,9 @@ CREATE OPERATOR ~~(
 );
 
 CREATE OPERATOR ~~*(
-  PROCEDURE="cs_encrypted_match_v1",
+  FUNCTION=eql_v1.encrypted_match,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   RESTRICT = eqsel,
   JOIN = eqjoinsel,
   HASHES,
diff --git a/sql/017-operators-ore.sql b/sql/017-operators-ore.sql
index 15f306a..c0cec54 100644
--- a/sql/017-operators-ore.sql
+++ b/sql/017-operators-ore.sql
@@ -1,24 +1,24 @@
--- Operators for match comparisons of cs_encrypted_v1 types
+-- Operators for match comparisons of eql_v1_encrypted types
 --
 -- Support for the following comparisons:
 --
---      cs_encrypted_v1 > >= < <=  cs_encrypted_v1
---      cs_encrypted_v1 > jsonb
---      cs_encrypted_v1 > ore_64_8_v1
+--      eql_v1_encrypted > >= < <=  eql_v1_encrypted
+--      eql_v1_encrypted > jsonb
+--      eql_v1_encrypted > ore_64_8_v1
 --
 
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) > cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) > eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gt_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gt,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
@@ -26,17 +26,17 @@ CREATE OPERATOR >(
 );
 
 
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b jsonb)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) > cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) > eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gt_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gt,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   COMMUTATOR = <,
   NEGATOR = <=,
@@ -45,18 +45,18 @@ CREATE OPERATOR >(
 );
 
 
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gt_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) > b;
+  SELECT eql_v1.ore_64_8_v1(a) > b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gt_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gt,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
@@ -65,18 +65,18 @@ CREATE OPERATOR >(
 
 
 
-DROP OPERATOR IF EXISTS > (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gt_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS > (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gt(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gt_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gt(a jsonb, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) > cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) > eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gt_v1",
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gt,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
@@ -84,18 +84,18 @@ CREATE OPERATOR >(
 );
 
 
-DROP OPERATOR IF EXISTS > (ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gt_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS > (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gt_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gt(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT a > cs_ore_64_8_v1(b);
+  SELECT a > eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gt_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gt,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <,
   NEGATOR = <=,
   RESTRICT = scalargtsel,
@@ -107,18 +107,18 @@ CREATE OPERATOR >(
 -- LT
 
 
-DROP OPERATOR IF EXISTS < (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS < (eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) < cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) < eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lt_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lt,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
@@ -126,17 +126,17 @@ CREATE OPERATOR <(
 );
 
 
-DROP OPERATOR IF EXISTS < (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS < (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b jsonb)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) < cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) < eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lt_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lt,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   COMMUTATOR = >,
   NEGATOR = >=,
@@ -145,18 +145,18 @@ CREATE OPERATOR <(
 );
 
 
-DROP OPERATOR IF EXISTS < (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lt_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS < (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lt(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lt_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lt(a jsonb, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) < cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) < eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lt_v1",
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lt,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
@@ -165,18 +165,18 @@ CREATE OPERATOR <(
 
 
 
-DROP OPERATOR IF EXISTS <(cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS <(eql_v1_encrypted, ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lt_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) < b;
+  SELECT eql_v1.ore_64_8_v1(a) < b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lt_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lt,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
@@ -184,18 +184,18 @@ CREATE OPERATOR <(
 );
 
 
-DROP OPERATOR IF EXISTS <(ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lt_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <(eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lt_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lt(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT a < cs_ore_64_8_v1(b);
+  SELECT a < eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lt_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lt,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >,
   NEGATOR = >=,
   RESTRICT = scalarltsel,
@@ -206,18 +206,18 @@ CREATE OPERATOR <(
 -----------------------------------------------------------------------------------------
 
 
-DROP OPERATOR IF EXISTS >=(cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS >=(eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) >= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) >= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gte_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gte,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
@@ -225,17 +225,17 @@ CREATE OPERATOR >=(
 );
 
 
-DROP OPERATOR IF EXISTS >= (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS >= (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b jsonb)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) >= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) >= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gte_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gte,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   COMMUTATOR = <=,
   NEGATOR = <,
@@ -244,18 +244,18 @@ CREATE OPERATOR >=(
 );
 
 
-DROP OPERATOR IF EXISTS >= (cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gte_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) >= b;
+  SELECT eql_v1.ore_64_8_v1(a) >= b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gte_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gte,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
@@ -263,18 +263,18 @@ CREATE OPERATOR >=(
 );
 
 
-DROP OPERATOR IF EXISTS >= (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gte_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS >= (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gte(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gte_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gte(a jsonb, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) >= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) >= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gte_v1",
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gte,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
@@ -282,18 +282,18 @@ CREATE OPERATOR >=(
 );
 
 
-DROP OPERATOR IF EXISTS >=(ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_gte_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS >=(eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_gte_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_gte(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT a >= cs_ore_64_8_v1(b);
+  SELECT a >= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR >=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_gte_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_gte,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = <=,
   NEGATOR = <,
   RESTRICT = scalarlesel,
@@ -304,18 +304,18 @@ CREATE OPERATOR >=(
 -----------------------------------------------------------------------------------------
 
 
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) <= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) <= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lte_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lte,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
@@ -323,17 +323,17 @@ CREATE OPERATOR <=(
 );
 
 
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, jsonb);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b jsonb);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b jsonb)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) <= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) <= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lte_v1",
-  LEFTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lte,
+  LEFTARG=eql_v1_encrypted,
   RIGHTARG=jsonb,
   COMMUTATOR = >=,
   NEGATOR = >,
@@ -342,18 +342,18 @@ CREATE OPERATOR <=(
 );
 
 
-DROP OPERATOR IF EXISTS <= (jsonb, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lte_v1(a jsonb, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <= (jsonb, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lte(a jsonb, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lte_v1(a jsonb, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lte(a jsonb, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) <= cs_ore_64_8_v1(b);
+  SELECT eql_v1.ore_64_8_v1(a) <= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lte_v1",
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lte,
   LEFTARG=jsonb,
-  RIGHTARG=cs_encrypted_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
@@ -361,18 +361,18 @@ CREATE OPERATOR <=(
 );
 
 
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, ore_64_8_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b ore_64_8_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, ore_64_8_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b eql_v1.ore_64_8_v1);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lte_v1(a cs_encrypted_v1, b ore_64_8_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1_encrypted, b eql_v1.ore_64_8_v1)
 RETURNS boolean AS $$
-  SELECT cs_ore_64_8_v1(a) <= b;
+  SELECT eql_v1.ore_64_8_v1(a) <= b;
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lte_v1",
-  LEFTARG=cs_encrypted_v1,
-  RIGHTARG=ore_64_8_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lte,
+  LEFTARG=eql_v1_encrypted,
+  RIGHTARG=eql_v1.ore_64_8_v1,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
@@ -380,18 +380,18 @@ CREATE OPERATOR <=(
 );
 
 
-DROP OPERATOR IF EXISTS <= (ore_64_8_v1, cs_encrypted_v1);
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_v1_lte_v1(a ore_64_8_v1, b cs_encrypted_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1.ore_64_8_v1, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_v1_lte_v1(a ore_64_8_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_v1_lte(a eql_v1.ore_64_8_v1, b eql_v1_encrypted)
 RETURNS boolean AS $$
-  SELECT a <= cs_ore_64_8_v1(b);
+  SELECT a <= eql_v1.ore_64_8_v1(b);
 $$ LANGUAGE SQL;
 
 CREATE OPERATOR <=(
-  PROCEDURE="cs_encrypted_ore_64_8_v1_lte_v1",
-  LEFTARG=ore_64_8_v1,
-  RIGHTARG=cs_encrypted_v1,
+  FUNCTION=eql_v1.encrypted_ore_64_8_v1_lte,
+  LEFTARG=eql_v1.ore_64_8_v1,
+  RIGHTARG=eql_v1_encrypted,
   COMMUTATOR = >=,
   NEGATOR = >,
   RESTRICT = scalarlesel,
@@ -402,48 +402,49 @@ CREATE OPERATOR <=(
 -----------------------------------------------------------------------------------------
 
 
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b cs_encrypted_v1);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_compare(a eql_v1_encrypted, b eql_v1_encrypted);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b cs_encrypted_v1)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_compare(a eql_v1_encrypted, b eql_v1_encrypted)
   RETURNS integer AS $$
   BEGIN
-    RETURN compare_ore_64_8_v1(cs_ore_64_8_v1(a), cs_ore_64_8_v1(b));
+    RETURN eql_v1.compare_ore_64_8_v1(eql_v1.ore_64_8_v1(a), eql_v1.ore_64_8_v1(b));
   END;
 $$ LANGUAGE plpgsql;
 
-DROP FUNCTION IF EXISTS cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b jsonb);
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_compare(a eql_v1_encrypted, b jsonb);
 
-CREATE FUNCTION cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b jsonb)
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_compare(a eql_v1_encrypted, b jsonb)
   RETURNS integer AS $$
   BEGIN
-    RETURN compare_ore_64_8_v1(cs_ore_64_8_v1(a), cs_ore_64_8_v1(b));
+    RETURN eql_v1.compare_ore_64_8_v1(eql_v1.ore_64_8_v1(a), eql_v1.ore_64_8_v1(b));
   END;
 $$ LANGUAGE plpgsql;
 
 
-CREATE FUNCTION cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b jsonb)
+DROP FUNCTION IF EXISTS eql_v1.encrypted_ore_64_8_compare(a jsonb, b eql_v1_encrypted);
+CREATE FUNCTION eql_v1.encrypted_ore_64_8_compare(a jsonb, b eql_v1_encrypted)
   RETURNS integer AS $$
   BEGIN
-    RETURN compare_ore_64_8_v1(cs_ore_64_8_v1(a), cs_ore_64_8_v1(b));
+    RETURN eql_v1.compare_ore_64_8_v1(eql_v1.ore_64_8_v1(a), eql_v1.ore_64_8_v1(b));
   END;
 $$ LANGUAGE plpgsql;
 
 -----------------------------------------------------------------------------------------
 
 
-DROP OPERATOR FAMILY IF EXISTS cs_encrypted_ore_64_8_v1_btree_ops_v1 USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.encrypted_ore_64_8_v1_btree_op USING btree;
 
-CREATE OPERATOR FAMILY cs_encrypted_ore_64_8_v1_btree_ops_v1 USING btree;
+CREATE OPERATOR FAMILY eql_v1.encrypted_ore_64_8_v1_btree_op USING btree;
 
 
-DROP OPERATOR CLASS IF EXISTS ore_64_8_v1_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ore_64_8_v1_btree_ops USING btree;
 
-CREATE OPERATOR CLASS cs_encrypted_ore_64_8_v1_btree_ops_v1 DEFAULT
-FOR TYPE cs_encrypted_v1 USING btree
-  FAMILY cs_encrypted_ore_64_8_v1_btree_ops_v1 AS
+CREATE OPERATOR CLASS eql_v1.cs_encrypted_ore_64_8_v1_btree_ops_v1 DEFAULT
+FOR TYPE eql_v1_encrypted USING btree
+  FAMILY eql_v1.cs_encrypted_ore_64_8_v1_btree_ops_v1 AS
   OPERATOR 1 <,
   OPERATOR 2 <=,
   OPERATOR 3 =,
   OPERATOR 4 >=,
   OPERATOR 5 >,
-  FUNCTION 1 cs_encrypted_ore_64_8_compare(a cs_encrypted_v1, b cs_encrypted_v1);
+  FUNCTION 1 eql_v1.encrypted_ore_64_8_compare(a eql_v1_encrypted, b eql_v1_encrypted);
diff --git a/sql/020-config-schema.sql b/sql/020-config-schema.sql
index a54b3dc..98f4b1c 100644
--- a/sql/020-config-schema.sql
+++ b/sql/020-config-schema.sql
@@ -16,8 +16,8 @@
 --
 DO $$
   BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'cs_configuration_data_v1') THEN
-      CREATE DOMAIN cs_configuration_data_v1 AS JSONB;
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'eql_v1_configuration_data') THEN
+      CREATE DOMAIN public.eql_v1_configuration_data AS JSONB;
     END IF;
   END
 $$;
@@ -27,8 +27,8 @@ $$;
 --
 DO $$
   BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'cs_configuration_state_v1') THEN
-      CREATE TYPE cs_configuration_state_v1 AS ENUM ('active', 'inactive', 'encrypting', 'pending');
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'eql_v1_configuration_state') THEN
+      CREATE TYPE public.eql_v1_configuration_state AS ENUM ('active', 'inactive', 'encrypting', 'pending');
     END IF;
   END
 $$;
@@ -38,10 +38,10 @@ $$;
 --
 -- Extracts index keys/names from configuration json
 --
--- Used by the _cs_config_check_indexes as part of the  cs_configuration_data_v1_check constraint
+-- Used by the eql_v1.config_check_indexes as part of the  cs_configuration_data_v1_check constraint
 --
-DROP FUNCTION IF EXISTS _cs_extract_indexes(jsonb);
-CREATE FUNCTION _cs_extract_indexes(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1.extract_indexes(jsonb);
+CREATE FUNCTION eql_v1.extract_indexes(val jsonb)
     RETURNS SETOF text
     LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 BEGIN ATOMIC
@@ -53,13 +53,13 @@ END;
 --
 -- Used by the cs_configuration_data_v1_check constraint
 --
-DROP FUNCTION IF EXISTS _cs_config_check_indexes(jsonb);
-CREATE FUNCTION _cs_config_check_indexes(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1.config_check_indexes(jsonb);
+CREATE FUNCTION eql_v1.config_check_indexes(val jsonb)
   RETURNS BOOLEAN
 AS $$
 	BEGIN
-    IF (SELECT EXISTS (SELECT _cs_extract_indexes(val)))  THEN
-      IF (SELECT bool_and(index = ANY('{match, ore, unique, ste_vec}')) FROM _cs_extract_indexes(val) AS index) THEN
+    IF (SELECT EXISTS (SELECT eql_v1.extract_indexes(val)))  THEN
+      IF (SELECT bool_and(index = ANY('{match, ore, unique, ste_vec}')) FROM eql_v1.extract_indexes(val) AS index) THEN
         RETURN true;
       END IF;
       RAISE 'Configuration has an invalid index (%). Index should be one of {match, ore, unique, ste_vec}', val;
@@ -69,9 +69,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS _cs_config_check_cast(jsonb);
+DROP FUNCTION IF EXISTS eql_v1.config_check_cast(jsonb);
 
-CREATE FUNCTION _cs_config_check_cast(val jsonb)
+CREATE FUNCTION eql_v1.config_check_cast(val jsonb)
   RETURNS BOOLEAN
 AS $$
 	BEGIN
@@ -85,8 +85,8 @@ $$ LANGUAGE plpgsql;
 --
 -- Should include a tables field
 -- Tables should not be empty
-DROP FUNCTION IF EXISTS _cs_config_check_tables(jsonb);
-CREATE FUNCTION _cs_config_check_tables(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1.config_check_tables(jsonb);
+CREATE FUNCTION eql_v1.config_check_tables(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -98,8 +98,8 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 -- Should include a version field
-DROP FUNCTION IF EXISTS _cs_config_check_v(jsonb);
-CREATE FUNCTION _cs_config_check_v(val jsonb)
+DROP FUNCTION IF EXISTS eql_v1.config_check_v(jsonb);
+CREATE FUNCTION eql_v1.config_check_v(val jsonb)
   RETURNS boolean
 AS $$
 	BEGIN
@@ -111,25 +111,25 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-ALTER DOMAIN cs_configuration_data_v1 DROP CONSTRAINT IF EXISTS cs_configuration_data_v1_check;
+ALTER DOMAIN eql_v1_configuration_data DROP CONSTRAINT IF EXISTS eql_v1_configuration_data_check;
 
-ALTER DOMAIN cs_configuration_data_v1
-  ADD CONSTRAINT cs_configuration_data_v1_check CHECK (
-    _cs_config_check_v(VALUE) AND
-    _cs_config_check_tables(VALUE) AND
-    _cs_config_check_cast(VALUE) AND
-    _cs_config_check_indexes(VALUE)
+ALTER DOMAIN eql_v1_configuration_data
+  ADD CONSTRAINT eql_v1_configuration_data_check CHECK (
+    eql_v1.config_check_v(VALUE) AND
+    eql_v1.config_check_tables(VALUE) AND
+    eql_v1.config_check_cast(VALUE) AND
+    eql_v1.config_check_indexes(VALUE)
 );
 
 
 --
 -- CREATE the cs_configuration_v1 TABLE
 --
-CREATE TABLE IF NOT EXISTS cs_configuration_v1
+CREATE TABLE IF NOT EXISTS eql_v1_configuration
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
-    state cs_configuration_state_v1 NOT NULL DEFAULT 'pending',
-    data cs_configuration_data_v1,
+    state eql_v1_configuration_state NOT NULL DEFAULT 'pending',
+    data eql_v1_configuration_data,
     created_at timestamptz not null default current_timestamp,
     PRIMARY KEY(id)
 );
@@ -137,6 +137,6 @@ CREATE TABLE IF NOT EXISTS cs_configuration_v1
 --
 -- Define partial indexes to ensure that there is only one active, pending and encrypting config at a time
 --
-CREATE UNIQUE INDEX IF NOT EXISTS cs_configuration_v1_index_active ON cs_configuration_v1 (state) WHERE state = 'active';
-CREATE UNIQUE INDEX IF NOT EXISTS cs_configuration_v1_index_pending ON cs_configuration_v1 (state) WHERE state = 'pending';
-CREATE UNIQUE INDEX IF NOT EXISTS cs_configuration_v1_index_encrypting ON cs_configuration_v1 (state) WHERE state = 'encrypting';
+CREATE UNIQUE INDEX IF NOT EXISTS eql_v1_configuration_index_active ON eql_v1_configuration (state) WHERE state = 'active';
+CREATE UNIQUE INDEX IF NOT EXISTS eql_v1_configuration_index_pending ON eql_v1_configuration (state) WHERE state = 'pending';
+CREATE UNIQUE INDEX IF NOT EXISTS eql_v1_configuration_index_encrypting ON eql_v1_configuration (state) WHERE state = 'encrypting';
diff --git a/sql/021-config-functions.sql b/sql/021-config-functions.sql
index dd7ddc3..1498f13 100644
--- a/sql/021-config-functions.sql
+++ b/sql/021-config-functions.sql
@@ -3,9 +3,9 @@
 --
 --
 
-DROP FUNCTION IF EXISTS  _cs_config_default(config jsonb);
+DROP FUNCTION IF EXISTS  eql_v1.config_default(config jsonb);
 
-CREATE FUNCTION _cs_config_default(config jsonb)
+CREATE FUNCTION eql_v1.config_default(config jsonb)
   RETURNS jsonb
   IMMUTABLE PARALLEL SAFE
 AS $$
@@ -18,9 +18,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS _cs_config_add_table(table_name text, config jsonb);
+DROP FUNCTION IF EXISTS eql_v1.config_add_table(table_name text, config jsonb);
 
-CREATE FUNCTION _cs_config_add_table(table_name text, config jsonb)
+CREATE FUNCTION eql_v1.config_add_table(table_name text, config jsonb)
   RETURNS jsonb
   -- IMMUTABLE PARALLEL SAFE
 AS $$
@@ -36,9 +36,9 @@ $$ LANGUAGE plpgsql;
 
 
 -- Add the column if it doesn't exist
-DROP FUNCTION IF EXISTS _cs_config_add_column(table_name text, column_name text, config jsonb);
+DROP FUNCTION IF EXISTS eql_v1.config_add_column(table_name text, column_name text, config jsonb);
 
-CREATE FUNCTION _cs_config_add_column(table_name text, column_name text, config jsonb)
+CREATE FUNCTION eql_v1.config_add_column(table_name text, column_name text, config jsonb)
   RETURNS jsonb
   IMMUTABLE PARALLEL SAFE
 AS $$
@@ -55,9 +55,9 @@ $$ LANGUAGE plpgsql;
 
 
 -- Set the cast
-DROP FUNCTION IF EXISTS _cs_config_add_cast(table_name text, column_name text, cast_as text, config jsonb);
+DROP FUNCTION IF EXISTS eql_v1.config_add_cast(table_name text, column_name text, cast_as text, config jsonb);
 
-CREATE FUNCTION _cs_config_add_cast(table_name text, column_name text, cast_as text, config jsonb)
+CREATE FUNCTION eql_v1.config_add_cast(table_name text, column_name text, cast_as text, config jsonb)
   RETURNS jsonb
   IMMUTABLE PARALLEL SAFE
 AS $$
@@ -69,9 +69,9 @@ $$ LANGUAGE plpgsql;
 
 
 -- Add the column if it doesn't exist
-DROP FUNCTION IF EXISTS _cs_config_add_index(table_name text, column_name text, index_name text, opts jsonb, config jsonb);
+DROP FUNCTION IF EXISTS eql_v1.config_add_index(table_name text, column_name text, index_name text, opts jsonb, config jsonb);
 
-CREATE FUNCTION _cs_config_add_index(table_name text, column_name text, index_name text, opts jsonb, config jsonb)
+CREATE FUNCTION eql_v1.config_add_index(table_name text, column_name text, index_name text, opts jsonb, config jsonb)
   RETURNS jsonb
   IMMUTABLE PARALLEL SAFE
 AS $$
@@ -85,9 +85,9 @@ $$ LANGUAGE plpgsql;
 --
 -- Default options for match index
 --
-DROP FUNCTION IF EXISTS _cs_config_match_default();
+DROP FUNCTION IF EXISTS eql_v1.config_match_default();
 
-CREATE FUNCTION _cs_config_match_default()
+CREATE FUNCTION eql_v1.config_match_default()
   RETURNS jsonb
 LANGUAGE sql STRICT PARALLEL SAFE
 BEGIN ATOMIC
@@ -102,9 +102,9 @@ END;
 --
 --
 --
-DROP FUNCTION IF EXISTS cs_add_index_v1(table_name text, column_name text, index_name text, cast_as text, opts jsonb);
+DROP FUNCTION IF EXISTS eql_v1.add_index(table_name text, column_name text, index_name text, cast_as text, opts jsonb);
 
-CREATE FUNCTION cs_add_index_v1(table_name text, column_name text, index_name text, cast_as text DEFAULT 'text', opts jsonb DEFAULT '{}')
+CREATE FUNCTION eql_v1.add_index(table_name text, column_name text, index_name text, cast_as text DEFAULT 'text', opts jsonb DEFAULT '{}')
   RETURNS jsonb
 AS $$
   DECLARE
@@ -113,7 +113,7 @@ AS $$
   BEGIN
 
     -- set the active config
-    SELECT data INTO _config FROM cs_configuration_v1 WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
+    SELECT data INTO _config FROM eql_v1_configuration WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
 
     -- if index exists
     IF _config #> array['tables', table_name, column_name, 'indexes'] ?  index_name THEN
@@ -125,23 +125,23 @@ AS $$
     END IF;
 
     -- set default config
-    SELECT _cs_config_default(_config) INTO _config;
+    SELECT eql_v1.config_default(_config) INTO _config;
 
-    SELECT _cs_config_add_table(table_name, _config) INTO _config;
+    SELECT eql_v1.config_add_table(table_name, _config) INTO _config;
 
-    SELECT _cs_config_add_column(table_name, column_name, _config) INTO _config;
+    SELECT eql_v1.config_add_column(table_name, column_name, _config) INTO _config;
 
-    SELECT _cs_config_add_cast(table_name, column_name, cast_as, _config) INTO _config;
+    SELECT eql_v1.config_add_cast(table_name, column_name, cast_as, _config) INTO _config;
 
     -- set default options for index if opts empty
     IF index_name = 'match' AND opts = '{}' THEN
-      SELECT _cs_config_match_default() INTO opts;
+      SELECT eql_v1.config_match_default() INTO opts;
     END IF;
 
-    SELECT _cs_config_add_index(table_name, column_name, index_name, opts, _config) INTO _config;
+    SELECT eql_v1.config_add_index(table_name, column_name, index_name, opts, _config) INTO _config;
 
     --  create a new pending record if we don't have one
-    INSERT INTO cs_configuration_v1 (state, data) VALUES ('pending', _config)
+    INSERT INTO eql_v1_configuration (state, data) VALUES ('pending', _config)
     ON CONFLICT (state)
       WHERE state = 'pending'
     DO UPDATE
@@ -153,9 +153,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_remove_index_v1(table_name text, column_name text, index_name text);
+DROP FUNCTION IF EXISTS eql_v1.remove_index(table_name text, column_name text, index_name text);
 
-CREATE FUNCTION cs_remove_index_v1(table_name text, column_name text, index_name text)
+CREATE FUNCTION eql_v1.remove_index(table_name text, column_name text, index_name text)
   RETURNS jsonb
 AS $$
   DECLARE
@@ -163,7 +163,7 @@ AS $$
   BEGIN
 
     -- set the active config
-    SELECT data INTO _config FROM cs_configuration_v1 WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
+    SELECT data INTO _config FROM eql_v1_configuration WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
 
     -- if no config
     IF _config IS NULL THEN
@@ -182,7 +182,7 @@ AS $$
     END IF;
 
     --  create a new pending record if we don't have one
-    INSERT INTO cs_configuration_v1 (state, data) VALUES ('pending', _config)
+    INSERT INTO eql_v1_configuration (state, data) VALUES ('pending', _config)
     ON CONFLICT (state)
       WHERE state = 'pending'
     DO NOTHING;
@@ -203,9 +203,9 @@ AS $$
     -- if config empty delete
     -- or update the config
     IF _config #> array['tables'] = '{}' THEN
-      DELETE FROM cs_configuration_v1 WHERE state = 'pending';
+      DELETE FROM eql_v1_configuration WHERE state = 'pending';
     ELSE
-      UPDATE cs_configuration_v1 SET data = _config WHERE state = 'pending';
+      UPDATE eql_v1_configuration SET data = _config WHERE state = 'pending';
     END IF;
 
     -- exeunt
@@ -214,14 +214,14 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_modify_index_v1(table_name text, column_name text, index_name text, cast_as text, opts jsonb);
+DROP FUNCTION IF EXISTS eql_v1.modify_index(table_name text, column_name text, index_name text, cast_as text, opts jsonb);
 
-CREATE FUNCTION cs_modify_index_v1(table_name text, column_name text, index_name text, cast_as text DEFAULT 'text', opts jsonb DEFAULT '{}')
+CREATE FUNCTION eql_v1.modify_index(table_name text, column_name text, index_name text, cast_as text DEFAULT 'text', opts jsonb DEFAULT '{}')
   RETURNS jsonb
 AS $$
   BEGIN
-    PERFORM cs_remove_index_v1(table_name, column_name, index_name);
-    RETURN cs_add_index_v1(table_name, column_name, index_name, cast_as, opts);
+    PERFORM eql_v1.remove_index(table_name, column_name, index_name);
+    RETURN eql_v1.add_index(table_name, column_name, index_name, cast_as, opts);
   END;
 $$ LANGUAGE plpgsql;
 
@@ -231,50 +231,50 @@ $$ LANGUAGE plpgsql;
 --
 -- Marks the currently `pending` configuration as `encrypting`.
 --
--- Validates the database schema and raises an exception if the configured columns are not of `jsonb` or `cs_encrypted_v1` type.
+-- Validates the database schema and raises an exception if the configured columns are not of `jsonb` or `eql_v1_encrypted` type.
 --
 -- Accepts an optional `force` parameter.
 -- If `force` is `true`, the schema validation is skipped.
 --
 -- Raises an exception if the configuration is already `encrypting` or if there is no `pending` configuration to encrypt.
 --
-DROP FUNCTION IF EXISTS cs_encrypt_v1();
+DROP FUNCTION IF EXISTS eql_v1.encrypt();
 
-CREATE FUNCTION cs_encrypt_v1(force boolean DEFAULT false)
+CREATE FUNCTION eql_v1.encrypt(force boolean DEFAULT false)
   RETURNS boolean
 AS $$
 	BEGIN
 
-    IF EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting') THEN
+    IF EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting') THEN
       RAISE EXCEPTION 'An encryption is already in progress';
     END IF;
 
-		IF NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending') THEN
+		IF NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending') THEN
 			RAISE EXCEPTION 'No pending configuration exists to encrypt';
 		END IF;
 
     IF NOT force THEN
-      IF NOT cs_ready_for_encryption_v1() THEN
+      IF NOT eql_v1.ready_for_encryption() THEN
         RAISE EXCEPTION 'Some pending columns do not have an encrypted target';
       END IF;
     END IF;
 
-    UPDATE cs_configuration_v1 SET state = 'encrypting' WHERE state = 'pending';
+    UPDATE eql_v1_configuration SET state = 'encrypting' WHERE state = 'pending';
 		RETURN true;
   END;
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_activate_v1();
+DROP FUNCTION IF EXISTS eql_v1.activate();
 
-CREATE FUNCTION cs_activate_v1()
+CREATE FUNCTION eql_v1.activate()
   RETURNS boolean
 AS $$
 	BEGIN
 
-	  IF EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting') THEN
-	  	UPDATE cs_configuration_v1 SET state = 'inactive' WHERE state = 'active';
-			UPDATE cs_configuration_v1 SET state = 'active' WHERE state = 'encrypting';
+	  IF EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting') THEN
+	  	UPDATE eql_v1_configuration SET state = 'inactive' WHERE state = 'active';
+			UPDATE eql_v1_configuration SET state = 'active' WHERE state = 'encrypting';
 			RETURN true;
 		ELSE
 			RAISE EXCEPTION 'No encrypting configuration exists to activate';
@@ -283,14 +283,14 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_discard_v1();
+DROP FUNCTION IF EXISTS eql_v1.discard();
 
-CREATE FUNCTION cs_discard_v1()
+CREATE FUNCTION eql_v1.discard()
   RETURNS boolean
 AS $$
   BEGIN
-    IF EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending') THEN
-        DELETE FROM cs_configuration_v1 WHERE state = 'pending';
+    IF EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending') THEN
+        DELETE FROM eql_v1_configuration WHERE state = 'pending';
       RETURN true;
     ELSE
       RAISE EXCEPTION 'No pending configuration exists to discard';
@@ -299,9 +299,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_add_column_v1(table_name text, column_name text, cast_as text);
+DROP FUNCTION IF EXISTS eql_v1.add_column(table_name text, column_name text, cast_as text);
 
-CREATE FUNCTION cs_add_column_v1(table_name text, column_name text, cast_as text DEFAULT 'text')
+CREATE FUNCTION eql_v1.add_column(table_name text, column_name text, cast_as text DEFAULT 'text')
   RETURNS jsonb
 AS $$
   DECLARE
@@ -309,24 +309,24 @@ AS $$
     _config jsonb;
   BEGIN
     -- set the active config
-    SELECT data INTO _config FROM cs_configuration_v1 WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
+    SELECT data INTO _config FROM eql_v1_configuration WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
 
     -- set default config
-    SELECT _cs_config_default(_config) INTO _config;
+    SELECT eql_v1.config_default(_config) INTO _config;
 
     -- if index exists
     IF _config #> array['tables', table_name] ?  column_name THEN
       RAISE EXCEPTION 'Config exists for column: % %', table_name, column_name;
     END IF;
 
-    SELECT _cs_config_add_table(table_name, _config) INTO _config;
+    SELECT eql_v1.config_add_table(table_name, _config) INTO _config;
 
-    SELECT _cs_config_add_column(table_name, column_name, _config) INTO _config;
+    SELECT eql_v1.config_add_column(table_name, column_name, _config) INTO _config;
 
-    SELECT _cs_config_add_cast(table_name, column_name, cast_as, _config) INTO _config;
+    SELECT eql_v1.config_add_cast(table_name, column_name, cast_as, _config) INTO _config;
 
     --  create a new pending record if we don't have one
-    INSERT INTO cs_configuration_v1 (state, data) VALUES ('pending', _config)
+    INSERT INTO eql_v1_configuration (state, data) VALUES ('pending', _config)
     ON CONFLICT (state)
       WHERE state = 'pending'
     DO UPDATE
@@ -338,9 +338,9 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_remove_column_v1(table_name text, column_name text);
+DROP FUNCTION IF EXISTS eql_v1.remove_column(table_name text, column_name text);
 
-CREATE FUNCTION cs_remove_column_v1(table_name text, column_name text)
+CREATE FUNCTION eql_v1.remove_column(table_name text, column_name text)
   RETURNS jsonb
 AS $$
   DECLARE
@@ -348,7 +348,7 @@ AS $$
     _config jsonb;
   BEGIN
      -- set the active config
-    SELECT data INTO _config FROM cs_configuration_v1 WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
+    SELECT data INTO _config FROM eql_v1_configuration WHERE state = 'active' OR state = 'pending' ORDER BY state DESC;
 
     -- if no config
     IF _config IS NULL THEN
@@ -366,7 +366,7 @@ AS $$
     END IF;
 
     --  create a new pending record if we don't have one
-    INSERT INTO cs_configuration_v1 (state, data) VALUES ('pending', _config)
+    INSERT INTO eql_v1_configuration (state, data) VALUES ('pending', _config)
     ON CONFLICT (state)
       WHERE state = 'pending'
     DO NOTHING;
@@ -382,9 +382,9 @@ AS $$
     -- if config empty delete
     -- or update the config
     IF _config #> array['tables'] = '{}' THEN
-      DELETE FROM cs_configuration_v1 WHERE state = 'pending';
+      DELETE FROM eql_v1_configuration WHERE state = 'pending';
     ELSE
-      UPDATE cs_configuration_v1 SET data = _config WHERE state = 'pending';
+      UPDATE eql_v1_configuration SET data = _config WHERE state = 'pending';
     END IF;
 
     -- exeunt
@@ -394,23 +394,23 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_refresh_encrypt_config();
+DROP FUNCTION IF EXISTS eql_v1.refresh_encrypt_config();
 
-CREATE FUNCTION cs_refresh_encrypt_config()
+CREATE FUNCTION eql_v1.refresh_encrypt_config()
   RETURNS void
 LANGUAGE sql STRICT PARALLEL SAFE
 BEGIN ATOMIC
   RETURN NULL;
 END;
 
-DROP FUNCTION IF EXISTS cs_config();
+DROP FUNCTION IF EXISTS eql_v1.config();
 
 --
 -- A convenience function to return the configuration in a tabular format, allowing for easier filtering, and querying.
 -- Query using `SELECT * FROM cs_config();`
 --
-CREATE FUNCTION cs_config() RETURNS TABLE (
-    state cs_configuration_state_v1,
+CREATE FUNCTION eql_v1.config() RETURNS TABLE (
+    state eql_v1_configuration_state,
     relation text,
     col_name text,
     decrypts_as text,
@@ -421,7 +421,7 @@ BEGIN
     RETURN QUERY
       WITH tables AS (
           SELECT config.state, tables.key AS table, tables.value AS config
-          FROM cs_configuration_v1 config, jsonb_each(data->'tables') tables
+          FROM eql_v1_configuration config, jsonb_each(data->'tables') tables
           WHERE config.data->>'v' = '1'
       )
       SELECT
diff --git a/sql/030-encryptindex.sql b/sql/030-encryptindex.sql
index 95ae358..f2e024e 100644
--- a/sql/030-encryptindex.sql
+++ b/sql/030-encryptindex.sql
@@ -1,9 +1,9 @@
 -- Return the diff of two configurations
 -- Returns the set of keys in a that have different values to b
 -- The json comparison is on object values held by the key
-DROP FUNCTION IF EXISTS _cs_diff_config_v1(a JSONB, b JSONB);
+DROP FUNCTION IF EXISTS eql_v1.diff_config(a JSONB, b JSONB);
 
-CREATE FUNCTION _cs_diff_config_v1(a JSONB, b JSONB)
+CREATE FUNCTION eql_v1.diff_config(a JSONB, b JSONB)
 	RETURNS TABLE(table_name TEXT, column_name TEXT)
 IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -34,9 +34,9 @@ $$ LANGUAGE plpgsql;
 
 -- Returns the set of columns with pending configuration changes
 -- Compares the columns in pending configuration that do not match the active config
-DROP FUNCTION IF EXISTS cs_select_pending_columns_v1();
+DROP FUNCTION IF EXISTS eql_v1.select_pending_columns();
 
-CREATE FUNCTION cs_select_pending_columns_v1()
+CREATE FUNCTION eql_v1.select_pending_columns()
 	RETURNS TABLE(table_name TEXT, column_name TEXT)
 AS $$
 	DECLARE
@@ -44,14 +44,14 @@ AS $$
 		pending JSONB;
 		config_id BIGINT;
 	BEGIN
-		SELECT data INTO active FROM cs_configuration_v1 WHERE state = 'active';
+		SELECT data INTO active FROM eql_v1_configuration WHERE state = 'active';
 
 		-- set default config
     IF active IS NULL THEN
       active := '{}';
     END IF;
 
-		SELECT id, data INTO config_id, pending FROM cs_configuration_v1 WHERE state = 'pending';
+		SELECT id, data INTO config_id, pending FROM eql_v1_configuration WHERE state = 'pending';
 
 		-- set default config
 		IF config_id IS NULL THEN
@@ -59,22 +59,22 @@ AS $$
 		END IF;
 
 		RETURN QUERY
-		SELECT d.table_name, d.column_name FROM _cs_diff_config_v1(active, pending) as d;
+		SELECT d.table_name, d.column_name FROM eql_v1.diff_config(active, pending) as d;
 	END;
 $$ LANGUAGE plpgsql;
 
 --
 -- Returns the target columns with pending configuration
 --
--- A `pending` column may be either a plaintext variant or cs_encrypted_v1.
--- A `target` column is always of type cs_encrypted_v1
+-- A `pending` column may be either a plaintext variant or eql_v1_encrypted.
+-- A `target` column is always of type eql_v1_encrypted
 --
 -- On initial encryption from plaintext the target column will be `{column_name}_encrypted `
 -- OR NULL if the column does not exist
 --
-DROP FUNCTION IF EXISTS cs_select_target_columns_v1();
+DROP FUNCTION IF EXISTS eql_v1.select_target_columns();
 
-CREATE FUNCTION cs_select_target_columns_v1()
+CREATE FUNCTION eql_v1.select_target_columns()
 	RETURNS TABLE(table_name TEXT, column_name TEXT, target_column TEXT)
 	STABLE STRICT PARALLEL SAFE
 AS $$
@@ -83,46 +83,46 @@ AS $$
     c.column_name,
     s.column_name as target_column
   FROM
-    cs_select_pending_columns_v1() c
+    eql_v1.select_pending_columns() c
   LEFT JOIN information_schema.columns s ON
     s.table_name = c.table_name AND
     (s.column_name = c.column_name OR s.column_name = c.column_name || '_encrypted') AND
-    (s.domain_name = 'cs_encrypted_v1' OR s.data_type = 'jsonb');
+    (s.domain_name = 'eql_v1_encrypted' OR s.data_type = 'jsonb');
 $$ LANGUAGE sql;
 
 
 --
 -- Returns true if all pending columns have a target (encrypted) column
-DROP FUNCTION IF EXISTS cs_ready_for_encryption_v1();
+DROP FUNCTION IF EXISTS eql_v1.ready_for_encryption();
 
-CREATE FUNCTION cs_ready_for_encryption_v1()
+CREATE FUNCTION eql_v1.ready_for_encryption()
 	RETURNS BOOLEAN
 	STABLE STRICT PARALLEL SAFE
 AS $$
 	SELECT EXISTS (
 	  SELECT *
-	  FROM cs_select_target_columns_v1() AS c
+	  FROM eql_v1.select_target_columns() AS c
 	  WHERE c.target_column IS NOT NULL);
 $$ LANGUAGE sql;
 
 
 --
--- Creates cs_encrypted_v1 columns for any plaintext columns with pending configuration
+-- Creates eql_v1_encrypted columns for any plaintext columns with pending configuration
 -- The new column name is `{column_name}_encrypted`
 --
 -- Executes the ALTER TABLE statement
---   `ALTER TABLE {target_table} ADD COLUMN {column_name}_encrypted cs_encrypted_v1;`
+--   `ALTER TABLE {target_table} ADD COLUMN {column_name}_encrypted eql_v1_encrypted;`
 --
-DROP FUNCTION IF EXISTS cs_create_encrypted_columns_v1();
+DROP FUNCTION IF EXISTS eql_v1.create_encrypted_columns();
 
-CREATE FUNCTION cs_create_encrypted_columns_v1()
+CREATE FUNCTION eql_v1.create_encrypted_columns()
 	RETURNS TABLE(table_name TEXT, column_name TEXT)
 AS $$
 	BEGIN
     FOR table_name, column_name IN
-      SELECT c.table_name, (c.column_name || '_encrypted') FROM cs_select_target_columns_v1() AS c WHERE c.target_column IS NULL
+      SELECT c.table_name, (c.column_name || '_encrypted') FROM eql_v1.select_target_columns() AS c WHERE c.target_column IS NULL
     LOOP
-		  EXECUTE format('ALTER TABLE %I ADD column %I cs_encrypted_v1', table_name, column_name);
+		  EXECUTE format('ALTER TABLE %I ADD column %I eql_v1_encrypted', table_name, column_name);
       RETURN NEXT;
     END LOOP;
 	END;
@@ -130,7 +130,7 @@ $$ LANGUAGE plpgsql;
 
 
 --
--- Renames plaintext and cs_encrypted_v1 columns created for the initial encryption.
+-- Renames plaintext and eql_v1_encrypted columns created for the initial encryption.
 -- The source plaintext column is renamed to `{column_name}_plaintext`
 -- The target encrypted column is renamed from `{column_name}_encrypted` to `{column_name}`
 --
@@ -138,14 +138,14 @@ $$ LANGUAGE plpgsql;
 --   `ALTER TABLE {target_table} RENAME COLUMN {column_name} TO {column_name}_plaintext;
 --   `ALTER TABLE {target_table} RENAME COLUMN {column_name}_encrypted TO {column_name};`
 --
-DROP FUNCTION IF EXISTS cs_rename_encrypted_columns_v1();
+DROP FUNCTION IF EXISTS eql_v1.rename_encrypted_columns();
 
-CREATE FUNCTION cs_rename_encrypted_columns_v1()
+CREATE FUNCTION eql_v1.rename_encrypted_columns()
 	RETURNS TABLE(table_name TEXT, column_name TEXT, target_column TEXT)
 AS $$
 	BEGIN
     FOR table_name, column_name, target_column IN
-      SELECT * FROM cs_select_target_columns_v1() as c WHERE c.target_column = c.column_name || '_encrypted'
+      SELECT * FROM eql_v1.select_target_columns() as c WHERE c.target_column = c.column_name || '_encrypted'
     LOOP
 		  EXECUTE format('ALTER TABLE %I RENAME %I TO %I;', table_name, column_name, column_name || '_plaintext');
 		  EXECUTE format('ALTER TABLE %I RENAME %I TO %I;', table_name, target_column, column_name);
@@ -155,16 +155,16 @@ AS $$
 $$ LANGUAGE plpgsql;
 
 
-DROP FUNCTION IF EXISTS cs_count_encrypted_with_active_config_v1(table_name TEXT, column_name TEXT);
+DROP FUNCTION IF EXISTS eql_v1.count_encrypted_with_active_config(table_name TEXT, column_name TEXT);
 
-CREATE FUNCTION cs_count_encrypted_with_active_config_v1(table_name TEXT, column_name TEXT)
+CREATE FUNCTION eql_v1.count_encrypted_with_active_config(table_name TEXT, column_name TEXT)
   RETURNS BIGINT
 AS $$
 DECLARE
   result BIGINT;
 BEGIN
 	EXECUTE format(
-        'SELECT COUNT(%I) FROM %s t WHERE %I->>%L = (SELECT id::TEXT FROM cs_configuration_v1 WHERE state = %L)',
+        'SELECT COUNT(%I) FROM %s t WHERE %I->>%L = (SELECT id::TEXT FROM eql_v1_configuration WHERE state = %L)',
         column_name, table_name, column_name, 'v', 'active'
     )
 	INTO result;
diff --git a/sql/040-aggregate-ore.sql b/sql/040-aggregate-ore.sql
index d6afade..e8fa421 100644
--- a/sql/040-aggregate-ore.sql
+++ b/sql/040-aggregate-ore.sql
@@ -1,12 +1,13 @@
 -- Aggregate functions for ORE
-DROP FUNCTION IF EXISTS cs_min_encrypted_v1;
-CREATE FUNCTION cs_min_encrypted_v1(a cs_encrypted_v1, b cs_encrypted_v1)
-RETURNS cs_encrypted_v1
+DROP FUNCTION IF EXISTS eql_v1.min_encrypted;
+
+CREATE FUNCTION eql_v1.min_encrypted(a eql_v1_encrypted, b eql_v1_encrypted)
+RETURNS eql_v1_encrypted
 LANGUAGE plpgsql
 STRICT
 AS $$
   BEGIN
-    IF cs_ore_64_8_v1(a) < cs_ore_64_8_v1(b) THEN
+    IF eql_v1.ore_64_8_v1(a) < eql_v1.ore_64_8_v1(b) THEN
       RETURN  a;
     ELSE
       RETURN b;
@@ -14,20 +15,24 @@ AS $$
   END;
 $$;
 
-CREATE AGGREGATE cs_min_v1(cs_encrypted_v1)
+DROP AGGREGATE IF EXISTS eql_v1.min(eql_v1_encrypted);
+CREATE AGGREGATE eql_v1.min(eql_v1_encrypted)
 (
-  sfunc = cs_min_encrypted_v1,
-  stype = cs_encrypted_v1
+  sfunc = eql_v1.min_encrypted,
+  stype = eql_v1_encrypted
 );
 
-DROP FUNCTION IF EXISTS cs_max_encrypted_v1;
-CREATE FUNCTION cs_max_encrypted_v1(a cs_encrypted_v1, b cs_encrypted_v1)
-RETURNS cs_encrypted_v1
+
+
+DROP FUNCTION IF EXISTS eql_v1.max_encrypted;
+
+CREATE FUNCTION eql_v1.max_encrypted(a eql_v1_encrypted, b eql_v1_encrypted)
+RETURNS eql_v1_encrypted
 LANGUAGE plpgsql
 STRICT
 AS $$
   BEGIN
-    IF cs_ore_64_8_v1(a) > cs_ore_64_8_v1(b) THEN
+    IF eql_v1.ore_64_8_v1(a) > eql_v1.ore_64_8_v1(b) THEN
       RETURN  a;
     ELSE
       RETURN b;
@@ -35,8 +40,9 @@ AS $$
   END;
 $$;
 
-CREATE AGGREGATE cs_max_v1(cs_encrypted_v1)
+DROP AGGREGATE IF EXISTS eql_v1.max(eql_v1_encrypted);
+CREATE AGGREGATE eql_v1.max(eql_v1_encrypted)
 (
-  sfunc = cs_max_encrypted_v1,
-  stype = cs_encrypted_v1
+  sfunc = eql_v1.max_encrypted,
+  stype = eql_v1_encrypted
 );
diff --git a/sql/666-drop-operators.sql b/sql/666-drop-operators.sql
index 8bd9fe3..9715c75 100644
--- a/sql/666-drop-operators.sql
+++ b/sql/666-drop-operators.sql
@@ -1,49 +1,78 @@
-DROP OPERATOR FAMILY IF EXISTS cs_encrypted_ore_64_8_v1_btree_ops_v1 USING btree;
+DROP OPERATOR FAMILY IF EXISTS eql_v1.encrypted_ore_64_8_v1_btree_ops USING btree;
 DROP OPERATOR CLASS IF EXISTS ore_64_8_v1_btree_ops USING btree;
-DROP OPERATOR IF EXISTS @> (cs_encrypted_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS @> (cs_encrypted_v1, cs_match_index_v1);
-DROP OPERATOR IF EXISTS @> (cs_match_index_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS <@ (cs_encrypted_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <@ (cs_encrypted_v1, cs_match_index_v1);
-DROP OPERATOR IF EXISTS <@ (cs_match_index_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS <= (ore_64_8_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, ore_64_8_v1);
-DROP OPERATOR IF EXISTS <= (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS <= (cs_encrypted_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS >= (ore_64_8_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS >= (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS >= (cs_encrypted_v1, ore_64_8_v1);
-DROP OPERATOR IF EXISTS >= (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS >= (cs_encrypted_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS < (ore_64_8_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS < (cs_encrypted_v1, ore_64_8_v1);
-DROP OPERATOR IF EXISTS < (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS < (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS < (cs_encrypted_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS > (ore_64_8_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS > (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, ore_64_8_v1);
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS > (cs_encrypted_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS = (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, cs_unique_index_v1);
-DROP OPERATOR IF EXISTS = (cs_unique_index_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS = (cs_encrypted_v1, ore_64_8_v1);
-DROP OPERATOR IF EXISTS = (ore_64_8_v1, cs_encrypted_v1);
-
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, jsonb);
-DROP OPERATOR IF EXISTS <> (jsonb, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, cs_unique_index_v1);
-DROP OPERATOR IF EXISTS <> (cs_unique_index_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <> (ore_64_8_v1, cs_encrypted_v1);
-DROP OPERATOR IF EXISTS <> (cs_encrypted_v1, ore_64_8_v1);
+DROP OPERATOR IF EXISTS @> (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS @> (eql_v1_encrypted, eql_v1.match_index);
+DROP OPERATOR IF EXISTS @> (eql_v1.match_index, eql_v1_encrypted);
+
+
+DROP OPERATOR IF EXISTS <@ (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <@ (eql_v1_encrypted, eql_v1.match_index);
+DROP OPERATOR IF EXISTS <@ (eql_v1.match_index, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS <= (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP OPERATOR IF EXISTS <= (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS <= (eql_v1_encrypted, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS >= (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS >= (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS >= (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS >= (eql_v1_encrypted, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS < (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS < (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP OPERATOR IF EXISTS < (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS < (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS < (eql_v1_encrypted, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS > (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS > (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS > (eql_v1_encrypted, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS = (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1.unique_index);
+DROP OPERATOR IF EXISTS = (eql_v1.unique_index, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS = (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+DROP OPERATOR IF EXISTS = (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS <> (jsonb, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1.unique_index);
+DROP OPERATOR IF EXISTS <> (eql_v1.unique_index, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <> (eql_v1.ore_64_8_v1, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS <> (eql_v1_encrypted, eql_v1.ore_64_8_v1);
+
+
+
+DROP OPERATOR FAMILY IF EXISTS eql_v1.ste_vec_encrypted_term_btree_ops USING btree;
+DROP OPERATOR CLASS IF EXISTS eql_v1.ste_vec_encrypted_term_btree_ops USING btree;
+
+DROP OPERATOR IF EXISTS = (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
+DROP OPERATOR IF EXISTS <> (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
+DROP OPERATOR IF EXISTS > (eql_v1.ste_vec_encrypted_term, eql_v1.ste_vec_encrypted_term);
+DROP OPERATOR IF EXISTS < (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS >= (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
+DROP OPERATOR IF EXISTS <= (eql_v1.ste_vec_encrypted_term_v1, eql_v1.ste_vec_encrypted_term_v1);
+
+
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, eql_v1.match_index);
+DROP OPERATOR IF EXISTS ~~ (eql_v1.match_index, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS ~~ (eql_v1.match_index, eql_v1.match_index);
+DROP OPERATOR IF EXISTS ~~ (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS ~~ (jsonb, eql_v1_encrypted);
+
+DROP OPERATOR IF EXISTS ~~* (eql_v1_encrypted, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS ~~* (eql_v1_encrypted, eql_v1.match_index);
+DROP OPERATOR IF EXISTS ~~* (eql_v1.match_index, eql_v1_encrypted);
+DROP OPERATOR IF EXISTS ~~* (eql_v1.match_index, eql_v1.match_index);
+DROP OPERATOR IF EXISTS ~~* (eql_v1_encrypted, jsonb);
+DROP OPERATOR IF EXISTS ~~* (jsonb, eql_v1_encrypted);
+
diff --git a/sql/666-drop_types.sql b/sql/666-drop_types.sql
index 8de0cb6..8f751f9 100644
--- a/sql/666-drop_types.sql
+++ b/sql/666-drop_types.sql
@@ -1,8 +1,8 @@
 -- ANYTHING THAT NEEDS TO BE DROPPED LAST
-DROP TYPE IF EXISTS ore_64_8_v1;
-DROP TYPE IF EXISTS ore_64_8_v1_term;
-DROP TYPE IF EXISTS cs_ste_vec_index_v1;
-DROP TYPE IF EXISTS cs_ste_vec_v1_entry;
-DROP TYPE IF EXISTS ore_cllw_8_v1;
-DROP TYPE IF EXISTS ore_cllw_8_variable_v1;
-DROP TYPE IF EXISTS cs_ste_vec_encrypted_term_v1;
+DROP TYPE IF EXISTS eql_v1.ore_64_8_v1;
+DROP TYPE IF EXISTS eql_v1.ore_64_8_v1_term;
+DROP TYPE IF EXISTS eql_v1.ste_vec_index;
+DROP TYPE IF EXISTS eql_v1.ste_vec_entry;
+DROP TYPE IF EXISTS eql_v1.ore_cllw_8_v1;
+DROP TYPE IF EXISTS eql_v1.ore_cllw_8_variable_v1;
+DROP TYPE IF EXISTS eql_v1.ste_vec_encrypted_term_v1;
diff --git a/sql/666-rename_configuration_table.sql b/sql/666-rename_configuration_table.sql
index 00b1bbe..87d89c9 100644
--- a/sql/666-rename_configuration_table.sql
+++ b/sql/666-rename_configuration_table.sql
@@ -1,10 +1,10 @@
 -- DANGEROUS
--- DROP TABLE IF EXISTS cs_configuration_v1 CASCADE;
--- ALTER TABLE cs_configuration_v1 RENAME TO cs_configuration_v1_;
+-- DROP TABLE IF EXISTS eql_v1_configuration CASCADE;
+-- ALTER TABLE eql_v1_configuration RENAME TO eql_v1_configuration_;
 
 DO $$
 BEGIN
- EXECUTE format('ALTER TABLE IF EXISTS %I RENAME TO %I_%s', 'cs_configuration_v1','cs_configuration_v1_', to_char(current_date,'YYYYMMDD')::TEXT);
+ EXECUTE format('ALTER TABLE IF EXISTS %I RENAME TO %I_%s', 'eql_v1_configuration','eql_v1_configuration_', to_char(current_date,'YYYYMMDD')::TEXT);
 END
 $$;
 
diff --git a/tasks/000-version-template.sql b/tasks/000-version-template.sql
index dba8e9e..5941a58 100644
--- a/tasks/000-version-template.sql
+++ b/tasks/000-version-template.sql
@@ -1,6 +1,8 @@
-DROP FUNCTION IF EXISTS cs_eql_version();
+CREATE SCHEMA IF NOT EXISTS eql_v1;
 
-CREATE FUNCTION cs_eql_version()
+DROP FUNCTION IF EXISTS eql_v1.version();
+
+CREATE FUNCTION eql_v1.version()
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
diff --git a/tests/999-wipe-test-data.sql b/tests/999-wipe-test-data.sql
index 3fdf700..6944196 100644
--- a/tests/999-wipe-test-data.sql
+++ b/tests/999-wipe-test-data.sql
@@ -5,3 +5,8 @@ DROP SCHEMA public CASCADE;
 CREATE SCHEMA public;
 GRANT ALL ON SCHEMA public TO postgres;
 GRANT ALL ON SCHEMA public TO public;
+
+DROP SCHEMA eql_v1 CASCADE;
+CREATE SCHEMA eql_v1;
+GRANT ALL ON SCHEMA eql_v1 TO postgres;
+GRANT ALL ON SCHEMA eql_v1 TO public;
diff --git a/tests/aggregate-ore.sql b/tests/aggregate-ore.sql
index 631deae..1d732ef 100644
--- a/tests/aggregate-ore.sql
+++ b/tests/aggregate-ore.sql
@@ -5,7 +5,7 @@ DROP TABLE IF EXISTS agg_test;
 CREATE TABLE agg_test
 (
     plain_int integer,
-    enc_int cs_encrypted_v1
+    enc_int eql_v1_encrypted
 );
 
 -- Add data. These are saved from the psql query output connected to Proxy.
@@ -17,19 +17,19 @@ INSERT INTO agg_test (plain_int, enc_int) VALUES
 ),
 (
   3,
-  '{"c": "mBbJyWl%QyVQT_N?b~OpQj!$J7B7H2CK@gB#`36H312|)kY;SeM7R*dAl5{R*U)AI+$~k7(JPvj;hmQK^F_}g^7Zs^WuYa^B(7y{V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb06565ebd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384e9e378f4f5890c31ca9d115965a0e8fbf13ad8d1d33f88d360d5e2f9680fb158f98158443ffc769cd9aac94380f05e3226b785f58006e5b9da6b8d86a7441a88fd848099a2400ef59b494b0c30013568dc1be9bba560565fccb49309ba2ec3edcff6f9d7a67b519b3754b37b0025dff7592a6117949a04043c100353289628884fe06cb2099e7b4b49abea9797a73ee0b85283a5b6f69bcf45f87e6cd6d45ecfd1633903270781173ed9d31a682bba0e54ff355f456bf0c468e378e41cb54fcc074ad40fb4448f6fec892c1ecda15a5efffb8dde3a3b282865ac436d7e43d48d4327c439956733697d3f5b02ead4805a7f905bdae24c1b35252e34939676a07ddb5454c3580c7d76d792a97988e35142f43667112432623eda5126e9af2592dd"], "v": 1}'::cs_encrypted_v1
+  '{"c": "mBbJyWl%QyVQT_N?b~OpQj!$J7B7H2CK@gB#`36H312|)kY;SeM7R*dAl5{R*U)AI+$~k7(JPvj;hmQK^F_}g^7Zs^WuYa^B(7y{V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb06565ebd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384e9e378f4f5890c31ca9d115965a0e8fbf13ad8d1d33f88d360d5e2f9680fb158f98158443ffc769cd9aac94380f05e3226b785f58006e5b9da6b8d86a7441a88fd848099a2400ef59b494b0c30013568dc1be9bba560565fccb49309ba2ec3edcff6f9d7a67b519b3754b37b0025dff7592a6117949a04043c100353289628884fe06cb2099e7b4b49abea9797a73ee0b85283a5b6f69bcf45f87e6cd6d45ecfd1633903270781173ed9d31a682bba0e54ff355f456bf0c468e378e41cb54fcc074ad40fb4448f6fec892c1ecda15a5efffb8dde3a3b282865ac436d7e43d48d4327c439956733697d3f5b02ead4805a7f905bdae24c1b35252e34939676a07ddb5454c3580c7d76d792a97988e35142f43667112432623eda5126e9af2592dd"], "v": 1}'::eql_v1_encrypted
 ),
 (
   5,
-  '{"c": "mBbKSqWLK6yl>o%G%&x+2$jdg7F`-R(^>R1Q^wGod8-FZ5C$xFI4dN?Ap114=77xPZ9!cKxE}qmyXrhx#K`4ztbUrysQrOFqON6bV{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb065659dd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384bec7bfb23290d7559fd8637b85ca7510cca465570029734ef0319c77177913ad84f54852bed2e2a67b6dafcab3eb70d3a2592414a43acc03703083cf1fa1984dfc0719337d5de4eefd0d137588641a0d38c771b77ab07ebab3fc9bfd7469c4222e1a8edee71188eeb24bfffcd82f711156381d8068223e3d75f5ba8a958182bc46a0ab58c29872cd17e559ed0b935a445249dbac5b51438cebaf9d28d5c8b67cd99f990d5295c1e37470ce5b33fe01eaf31d84c9a08b267c0e9e1aadfcce7f9e2253ababa71eaf1fec309dc988e454717a3c2e3bffb1c546a7195ecf274eb7d691abcf46a61e34d4c63c45d48831dc23aa11f981de692926cd1d1d77a340c9e54baf62da61d5f88960a93e120d3828f4053577b93b536cc9b05c889dcf171865"], "v": 1}'::cs_encrypted_v1
+  '{"c": "mBbKSqWLK6yl>o%G%&x+2$jdg7F`-R(^>R1Q^wGod8-FZ5C$xFI4dN?Ap114=77xPZ9!cKxE}qmyXrhx#K`4ztbUrysQrOFqON6bV{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb065659dd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384bec7bfb23290d7559fd8637b85ca7510cca465570029734ef0319c77177913ad84f54852bed2e2a67b6dafcab3eb70d3a2592414a43acc03703083cf1fa1984dfc0719337d5de4eefd0d137588641a0d38c771b77ab07ebab3fc9bfd7469c4222e1a8edee71188eeb24bfffcd82f711156381d8068223e3d75f5ba8a958182bc46a0ab58c29872cd17e559ed0b935a445249dbac5b51438cebaf9d28d5c8b67cd99f990d5295c1e37470ce5b33fe01eaf31d84c9a08b267c0e9e1aadfcce7f9e2253ababa71eaf1fec309dc988e454717a3c2e3bffb1c546a7195ecf274eb7d691abcf46a61e34d4c63c45d48831dc23aa11f981de692926cd1d1d77a340c9e54baf62da61d5f88960a93e120d3828f4053577b93b536cc9b05c889dcf171865"], "v": 1}'::eql_v1_encrypted
 ),
 (
   1,
-  '{"c": "mBbJSy$p0fHEK%aOAOYi4PTJN7B@a-j{+xl7tffjGTN<-Znt3Zge#lGAX^WHzU`7ml<4vRHLKxoB%}N<H3?J~gR*ISwBlJ)X0By!V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb0656502d23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384250ca116ef329616ddb341917699b9ea48901124a15a4547be1ff7c672c0c1bc6bb17e2a141f46138fc314f4bf8a55068bf031bc48f038c379e54cfbb1c64eb223c18c87cd68a91fb031905e11d9478f158b561399b527038efc594bfd9fb19c963a2778b75215e1d8933b08df04d1c62742fd48a4de310792031a70ca4b157bc218ab3fbadc6dc14b939422023331c03bcf4b673c5d261a19c3d13155cbaa1b84e9e90e389fa6973dde07fba08c13847006707488e288ce780d59700197452ebc68d22032ab03f7b445e45ed7abb1af34955199440f7db2c969c60b1eb49cdcd75d5e8f7de37848ddebb40df8e14d4b92910e15fedac3f61f22ef430805ba1bbf5fccc9fe792e4c0353beee48ca03ef23c7d3fab19e9aa218aefb44e6c26d70"], "v": 1}'::cs_encrypted_v1
+  '{"c": "mBbJSy$p0fHEK%aOAOYi4PTJN7B@a-j{+xl7tffjGTN<-Znt3Zge#lGAX^WHzU`7ml<4vRHLKxoB%}N<H3?J~gR*ISwBlJ)X0By!V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb0656502d23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384250ca116ef329616ddb341917699b9ea48901124a15a4547be1ff7c672c0c1bc6bb17e2a141f46138fc314f4bf8a55068bf031bc48f038c379e54cfbb1c64eb223c18c87cd68a91fb031905e11d9478f158b561399b527038efc594bfd9fb19c963a2778b75215e1d8933b08df04d1c62742fd48a4de310792031a70ca4b157bc218ab3fbadc6dc14b939422023331c03bcf4b673c5d261a19c3d13155cbaa1b84e9e90e389fa6973dde07fba08c13847006707488e288ce780d59700197452ebc68d22032ab03f7b445e45ed7abb1af34955199440f7db2c969c60b1eb49cdcd75d5e8f7de37848ddebb40df8e14d4b92910e15fedac3f61f22ef430805ba1bbf5fccc9fe792e4c0353beee48ca03ef23c7d3fab19e9aa218aefb44e6c26d70"], "v": 1}'::eql_v1_encrypted
 ),
 (
   3,
-  '{"c": "mBbLa7Cm?&jvpfcv1d3hep>s)76qzUbwUky&M&C<M-e2q^@e798gqWcAb{9a>3mjDG_os-_y0MRaMGl@&p#AOuusN|3Lu=mBCcg_V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb06565ebd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384e9e378f4f5890c31ca9d115965a0e8fb2c3c60ccce84ffc03bddb22b27a1ce278eec118496fd23f083ebb21bb4b83b89eda8c0bdea50debc5ec4f2b2d91b63a80d39386194ad9d129bee2f5168341cb41ed26dc03466cac5e2dbe7336fdb74c0d37d63b396033ce60002c9950f5ac2970dacf4caace2eef5b81544df88a7ef2a8d69550d25d39c678c8e43a3dcc2857018a2c979b45c6b19dabd28ae7388d62916e6742763d6484d1b45154e6c8e6a66e02b03f64b67ddef24747dded32e226e3a93d5d1a92d11e760403cad04a0dd07c14da336a409739e8bbeb3b3d6b92117fa2d2c941da4996ea61b29ca3fffb4594ddbeab7105a1b4c5e422ec5ab8154db545103d8c2889be2e4591198912446d8b33b8708a4cc959a1e0957dcae6a50c3"], "v": 1}'::cs_encrypted_v1
+  '{"c": "mBbLa7Cm?&jvpfcv1d3hep>s)76qzUbwUky&M&C<M-e2q^@e798gqWcAb{9a>3mjDG_os-_y0MRaMGl@&p#AOuusN|3Lu=mBCcg_V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "o": ["ccccccccb06565ebd23d6a4c3eee512713175e673c6d995ff5d9b1d3492fe8eb289c3eb95029025f5b71fc6e06632b4a1302980e433361c7999724dbdd052739258d9444b0fbd43cc61368e60f4b0d5aeca2aa85c1c89933b53afffcc4eb0632dca75f632bb9bc792d1dbd6bced6253291f0db134552d384e9e378f4f5890c31ca9d115965a0e8fb2c3c60ccce84ffc03bddb22b27a1ce278eec118496fd23f083ebb21bb4b83b89eda8c0bdea50debc5ec4f2b2d91b63a80d39386194ad9d129bee2f5168341cb41ed26dc03466cac5e2dbe7336fdb74c0d37d63b396033ce60002c9950f5ac2970dacf4caace2eef5b81544df88a7ef2a8d69550d25d39c678c8e43a3dcc2857018a2c979b45c6b19dabd28ae7388d62916e6742763d6484d1b45154e6c8e6a66e02b03f64b67ddef24747dded32e226e3a93d5d1a92d11e760403cad04a0dd07c14da336a409739e8bbeb3b3d6b92117fa2d2c941da4996ea61b29ca3fffb4594ddbeab7105a1b4c5e422ec5ab8154db545103d8c2889be2e4591198912446d8b33b8708a4cc959a1e0957dcae6a50c3"], "v": 1}'::eql_v1_encrypted
 )
 ;
 
@@ -37,16 +37,16 @@ INSERT INTO agg_test (plain_int, enc_int) VALUES
 DO $$
   BEGIN
   -- min null finds null
-  ASSERT ((SELECT cs_min_v1(enc_int) FROM agg_test where enc_int IS NULL) IS NULL);
+  ASSERT ((SELECT eql_v1.min(enc_int) FROM agg_test where enc_int IS NULL) IS NULL);
 
   -- min enc_int finds the minimum (1)
-  ASSERT ((SELECT enc_int FROM agg_test WHERE plain_int = 1) = (SELECT cs_min_v1(enc_int) FROM agg_test));
+  ASSERT ((SELECT enc_int FROM agg_test WHERE plain_int = 1) = (SELECT eql_v1.min(enc_int) FROM agg_test));
 
   -- max null finds null
-  ASSERT ((SELECT cs_max_v1(enc_int) FROM agg_test where enc_int IS NULL) IS NULL);
+  ASSERT ((SELECT eql_v1.max(enc_int) FROM agg_test where enc_int IS NULL) IS NULL);
 
   -- max enc_int finds the maximum (5)
-  ASSERT ((SELECT enc_int FROM agg_test WHERE plain_int = 5) = (SELECT cs_max_v1(enc_int) FROM agg_test));
+  ASSERT ((SELECT enc_int FROM agg_test WHERE plain_int = 5) = (SELECT eql_v1.max(enc_int) FROM agg_test));
   END;
 $$ LANGUAGE plpgsql;
 
@@ -54,7 +54,7 @@ $$ LANGUAGE plpgsql;
 INSERT INTO agg_test (plain_int, enc_int) VALUES
 (
   3,
-  '{"c": "mBbLa7Cm?&jvpfcv1d3hep>s)76qzUbwUky&M&C<M-e2q^@e798gqWcAb{9a>3mjDG_os-_y0MRaMGl@&p#AOuusN|3Lu=mBCcg_V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "v": 1}'::cs_encrypted_v1
+  '{"c": "mBbLa7Cm?&jvpfcv1d3hep>s)76qzUbwUky&M&C<M-e2q^@e798gqWcAb{9a>3mjDG_os-_y0MRaMGl@&p#AOuusN|3Lu=mBCcg_V{&<LbY)~;X>N2hzy", "i": {"c": "encrypted_int4", "t": "encrypted"}, "k": "ct", "m": null, "v": 1}'::eql_v1_encrypted
 );
 
 -- run exceptional case
@@ -63,7 +63,7 @@ DO $$
     error_message text;
   BEGIN
     -- min enc_int raises exception
-    SELECT cs_min_v1(enc_int) FROM agg_test;
+    SELECT eql_v1.min(enc_int) FROM agg_test;
   EXCEPTION
     WHEN others THEN
       error_message := SQLERRM;
@@ -82,7 +82,7 @@ DO $$
     error_message text;
   BEGIN
     -- max enc_int raises exception
-    SELECT cs_max_v1(enc_int) FROM agg_test;
+    SELECT eql_v1.max(enc_int) FROM agg_test;
   EXCEPTION
     WHEN others THEN
       error_message := SQLERRM;
diff --git a/tests/config.sql b/tests/config.sql
index e165c76..b2ac15e 100644
--- a/tests/config.sql
+++ b/tests/config.sql
@@ -11,7 +11,7 @@ CREATE FUNCTION _index_exists(table_name text, column_name text, index_name text
   RETURNS boolean
 LANGUAGE sql STRICT PARALLEL SAFE
 BEGIN ATOMIC
-  SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+  SELECT EXISTS (SELECT id FROM eql_v1_configuration c
     WHERE c.state = state AND
     c.data #> array['tables', table_name, column_name, 'indexes'] ? index_name);
 END;
@@ -21,31 +21,31 @@ END;
 -- Add and remove multiple indexes
 --
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 
 DO $$
   BEGIN
 
     -- Add indexes
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
     ASSERT (SELECT _index_exists('users', 'name', 'match'));
 
     -- Add index with cast
-    PERFORM cs_add_index_v1('users', 'name', 'unique', 'int');
+    PERFORM eql_v1.add_index('users', 'name', 'unique', 'int');
     ASSERT (SELECT _index_exists('users', 'name', 'unique'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'users', 'name'] ? 'cast_as'));
 
     -- Match index removed
-    PERFORM cs_remove_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.remove_index('users', 'name', 'match');
     ASSERT NOT (SELECT _index_exists('users', 'name', 'match'));
 
     -- All indexes removed, delete the emtpty pending config
-    PERFORM cs_remove_index_v1('users', 'name', 'unique');
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    PERFORM eql_v1.remove_index('users', 'name', 'unique');
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -56,78 +56,78 @@ $$ LANGUAGE plpgsql;
 -- Add and remove multiple indexes from multiple tables
 --
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 
 DO $$
   BEGIN
 
     -- Add indexes
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
     ASSERT (SELECT _index_exists('users', 'name', 'match'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'users', 'name', 'indexes'] ? 'match'));
 
     -- Add index with cast
-    PERFORM cs_add_index_v1('blah', 'vtha', 'unique', 'int');
+    PERFORM eql_v1.add_index('blah', 'vtha', 'unique', 'int');
     ASSERT (SELECT _index_exists('blah', 'vtha', 'unique'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'users', 'name', 'indexes'] ? 'match'));
 
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'blah', 'vtha', 'indexes'] ? 'unique'));
 
 
     -- Match index removed
-    PERFORM cs_remove_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.remove_index('users', 'name', 'match');
     ASSERT NOT (SELECT _index_exists('users', 'name', 'match'));
 
     -- Match index removed
-    PERFORM cs_remove_index_v1('blah', 'vtha', 'unique');
+    PERFORM eql_v1.remove_index('blah', 'vtha', 'unique');
     ASSERT NOT (SELECT _index_exists('users', 'vtha', 'unique'));
 
     -- All indexes removed, delete the emtpty pending config
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
 
   END;
 $$ LANGUAGE plpgsql;
 
-SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending';
+SELECT FROM eql_v1_configuration c WHERE c.state = 'pending';
 
 
 -- -----------------------------------------------
 -- Add & modify index
 -- Pending configuration created and contains the path `user/name.match.option`
 -- -----------------------------------------------
--- TRUNCATE TABLE cs_configuration_v1;
+-- TRUNCATE TABLE eql_v1_configuration;
 
 
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
     ASSERT (SELECT _index_exists('users', 'name', 'match'));
 
     -- Pending configuration contains the path `user/name.match.option`
-    PERFORM cs_modify_index_v1('users', 'name', 'match', 'int', '{"option": "value"}'::jsonb);
+    PERFORM eql_v1.modify_index('users', 'name', 'match', 'int', '{"option": "value"}'::jsonb);
     ASSERT (SELECT _index_exists('users', 'name', 'match'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'users', 'name', 'indexes', 'match'] ? 'option'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM cs_configuration_v1 c
+    ASSERT (SELECT EXISTS (SELECT id FROM eql_v1_configuration c
             WHERE c.state = 'pending' AND
             c.data #> array['tables', 'users', 'name'] ? 'cast_as'));
 
     -- All indexes removed, delete the emtpty pending config
-    PERFORM cs_remove_index_v1('users', 'name', 'match');
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    PERFORM eql_v1.remove_index('users', 'name', 'match');
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
   END;
 $$ LANGUAGE plpgsql;
 
@@ -136,10 +136,10 @@ $$ LANGUAGE plpgsql;
 -- -- With existing active config
 -- -- Adding an index creates a new pending configuration
 -- -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- create an active configuration
-INSERT INTO cs_configuration_v1 (state, data) VALUES (
+INSERT INTO eql_v1_configuration (state, data) VALUES (
   'active',
   '{
     "v": 1,
@@ -165,7 +165,7 @@ DO $$
   BEGIN
     ASSERT (SELECT _index_exists('users', 'blah', 'match', 'active'));
 
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
 
     -- index added to name
     ASSERT (SELECT _index_exists('users', 'name', 'match' ));
@@ -182,41 +182,41 @@ $$ LANGUAGE plpgsql;
 -- -- Add and remove column
 -- --
 -- -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 DO $$
   BEGIN
     -- Create pending configuration
-    PERFORM cs_add_column_v1('user', 'name');
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    PERFORM eql_v1.add_column('user', 'name');
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
 
-    PERFORM cs_remove_column_v1('user', 'name');
+    PERFORM eql_v1.remove_column('user', 'name');
 
     -- Config now empty and removed
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
   END;
 $$ LANGUAGE plpgsql;
 
 -- -----------------------------------------------
 ---
--- cs_configuration_v1 tyoe
+-- eql_v1_configuration tyoe
 -- Validate configuration schema
 -- Try and insert many invalid configurations
 -- None should exist
 --
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 \set ON_ERROR_STOP off
 \set ON_ERROR_ROLLBACK on
 
 DO $$
   BEGIN
-    RAISE NOTICE 'cs_configuration_v1 constraint tests: 4 errors expected here';
+    RAISE NOTICE 'eql_v1_configuration constraint tests: 4 errors expected here';
   END;
 $$ LANGUAGE plpgsql;
 --
 -- No schema version
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "tables": {
       "users": {
@@ -231,7 +231,7 @@ INSERT INTO cs_configuration_v1 (data) VALUES (
 
 --
 -- Empty tables
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "v": 1,
     "tables": {}
@@ -241,7 +241,7 @@ INSERT INTO cs_configuration_v1 (data) VALUES (
 
 --
 -- invalid cast
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "v": 1,
     "tables": {
@@ -256,7 +256,7 @@ INSERT INTO cs_configuration_v1 (data) VALUES (
 
 --
 -- invalid index
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "v": 1,
     "tables": {
@@ -276,7 +276,7 @@ INSERT INTO cs_configuration_v1 (data) VALUES (
 -- Pending configuration should not be created;
 DO $$
   BEGIN
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
   END;
 $$ LANGUAGE plpgsql;
 
diff --git a/tests/core-functions.sql b/tests/core-functions.sql
index 0318740..46ffdd0 100644
--- a/tests/core-functions.sql
+++ b/tests/core-functions.sql
@@ -3,10 +3,10 @@
 
 DO $$
   BEGIN
-    ASSERT (SELECT EXISTS (SELECT cs_unique_v1('{"u": "u"}'::jsonb)));
-    ASSERT (SELECT EXISTS (SELECT cs_match_v1('{"m": []}'::jsonb)));
-    ASSERT (SELECT EXISTS (SELECT cs_ste_vec_v1('{"sv": [[]]}'::jsonb)));
-    ASSERT (SELECT EXISTS (SELECT cs_ore_64_8_v1('{"o": []}'::jsonb)));
+    ASSERT (SELECT EXISTS (SELECT eql_v1.unique('{"u": "u"}'::jsonb)));
+    ASSERT (SELECT EXISTS (SELECT eql_v1.match('{"m": []}'::jsonb)));
+    ASSERT (SELECT EXISTS (SELECT eql_v1.ste_vec('{"sv": [[]]}'::jsonb)));
+    ASSERT (SELECT EXISTS (SELECT eql_v1.ore_64_8_v1('{"o": []}'::jsonb)));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -14,10 +14,10 @@ $$ LANGUAGE plpgsql;
 DO $$
   BEGIN
     -- sanity check
-    PERFORM cs_ore_64_8_v1('{"o": []}'::jsonb);
+    PERFORM eql_v1.ore_64_8_v1('{"o": []}'::jsonb);
 
     BEGIN
-      PERFORM cs_ore_64_8_v1('{}'::jsonb);
+      PERFORM eql_v1.ore_64_8_v1('{}'::jsonb);
       RAISE NOTICE 'Missing index. Function call should have failed.';
       ASSERT false;
     EXCEPTION
@@ -30,10 +30,10 @@ $$ LANGUAGE plpgsql;
 DO $$
   BEGIN
     -- sanity check
-    PERFORM cs_ste_vec_v1('{"sv": [[]]}'::jsonb);
+    PERFORM eql_v1.ste_vec('{"sv": [[]] }'::jsonb);
 
     BEGIN
-      PERFORM cs_ste_vec_v1('{}'::jsonb);
+      PERFORM eql_v1.ste_vec('{}'::jsonb);
       RAISE NOTICE 'Missing index. Function call should have failed.';
       ASSERT false;
     EXCEPTION
@@ -44,35 +44,35 @@ DO $$
 $$ LANGUAGE plpgsql;
 
 
-DO $$
-  BEGIN
-    -- sanity check
-    PERFORM cs_unique_v1('{"u": "u"}'::jsonb);
+-- DO $$
+--   BEGIN
+--     -- sanity check
+--     PERFORM eql_v1.unique('{"u": "u"}'::jsonb);
 
-    BEGIN
-      PERFORM cs_unique_v1_v0('{}'::jsonb);
-      RAISE NOTICE 'Missing index. Function call should have failed.';
-      ASSERT false;
-    EXCEPTION
-      WHEN OTHERS THEN
-        ASSERT true;
-    END;
-  END;
-$$ LANGUAGE plpgsql;
+--     BEGIN
+--       PERFORM eql_v1.unique_v1('{}'::jsonb);
+--       RAISE NOTICE 'Missing index. Function call should have failed.';
+--       ASSERT false;
+--     EXCEPTION
+--       WHEN OTHERS THEN
+--         ASSERT true;
+--     END;
+--   END;
+-- $$ LANGUAGE plpgsql;
 
 
-DO $$
-  BEGIN
-    -- sanity check
-    PERFORM cs_match_v1('{"m": []}'::jsonb);
+-- DO $$
+--   BEGIN
+--     -- sanity check
+--     PERFORM eql_v1.match('{"m": []}'::jsonb);
 
-    BEGIN
-      PERFORM cs_match_v1('{}'::jsonb);
-      RAISE NOTICE 'Missing index. Function call should have failed.';
-      ASSERT false;
-    EXCEPTION
-      WHEN OTHERS THEN
-        ASSERT true;
-    END;
-  END;
-$$ LANGUAGE plpgsql;
+--     BEGIN
+--       PERFORM eql_v1.match('{}'::jsonb);
+--       RAISE NOTICE 'Missing index. Function call should have failed.';
+--       ASSERT false;
+--     EXCEPTION
+--       WHEN OTHERS THEN
+--         ASSERT true;
+--     END;
+--   END;
+-- $$ LANGUAGE plpgsql;
diff --git a/tests/core.sql b/tests/core.sql
index 5a02fcd..04a5e2c 100644
--- a/tests/core.sql
+++ b/tests/core.sql
@@ -5,7 +5,7 @@ DROP TABLE IF EXISTS users;
 CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
@@ -31,14 +31,14 @@ INSERT INTO users (name_encrypted) VALUES (
 DO $$
   BEGIN
 
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ciphertext_v1(name_encrypted) = 'ciphertext'));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ciphertext(name_encrypted) = 'ciphertext'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_match_v1(name_encrypted) = '{1,1}'));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.match(name_encrypted) = '{1,1}'));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_unique_v1(name_encrypted) = 'text'));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.unique(name_encrypted) = 'text'));
 
     -- ORE PAYLOAD ABOUT TO CHANGE
-    -- ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) = '{a}'));
+    -- ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) = '{a}'));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -59,7 +59,7 @@ $$ LANGUAGE plpgsql;
 
 -- -----------------------------------------------
 ---
--- cs_encrypted_v1 type
+-- eql_v1_encrypted type
 -- Validate configuration schema
 -- Try and insert many invalid configurations
 -- None should exist
@@ -72,7 +72,7 @@ TRUNCATE TABLE users;
 
 DO $$
   BEGIN
-    RAISE NOTICE 'cs_encrypted_v1 constraint tests: 10 errors expected here';
+    RAISE NOTICE 'eql_v1_encrypted constraint tests: 10 errors expected here';
   END;
 $$ LANGUAGE plpgsql;
 
diff --git a/tests/encryptindex.sql b/tests/encryptindex.sql
index 26d3e42..8ae15c5 100644
--- a/tests/encryptindex.sql
+++ b/tests/encryptindex.sql
@@ -5,7 +5,7 @@
 -- Alter table from config
 --
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- Create a table with a plaintext column
 DROP TABLE IF EXISTS users;
@@ -16,7 +16,7 @@ CREATE TABLE users
     PRIMARY KEY(id)
 );
 
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "v": 1,
     "tables": {
@@ -36,21 +36,21 @@ DO $$
   BEGIN
 
     -- the column is pending encryptindexing
-    ASSERT (SELECT EXISTS (SELECT * FROM cs_select_pending_columns_v1() AS c WHERE c.column_name = 'name'));
+    ASSERT (SELECT EXISTS (SELECT * FROM eql_v1.select_pending_columns() AS c WHERE c.column_name = 'name'));
 
     -- the target column does not exist
-    ASSERT (SELECT EXISTS (SELECT * FROM cs_select_target_columns_v1() AS c WHERE c.target_column IS NULL));
+    ASSERT (SELECT EXISTS (SELECT * FROM eql_v1.select_target_columns() AS c WHERE c.target_column IS NULL));
 
     -- Add the vtha_encrypted column to the table
-    PERFORM cs_create_encrypted_columns_v1();
+    PERFORM eql_v1.create_encrypted_columns();
 
     ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name_encrypted'));
 
     -- rename columns
-    PERFORM cs_rename_encrypted_columns_v1();
+    PERFORM eql_v1.rename_encrypted_columns();
 
     ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name_plaintext'));
-    ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name' and s.domain_name = 'cs_encrypted_v1'));
+    ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name' and s.domain_name = 'eql_v1_encrypted'));
     ASSERT (SELECT NOT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name_encrypted'));
   END;
 $$ LANGUAGE plpgsql;
@@ -60,7 +60,7 @@ $$ LANGUAGE plpgsql;
 -- Create multiple columns
 --
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- Create a table with multiple plaintext columns
 DROP TABLE IF EXISTS users;
@@ -72,7 +72,7 @@ CREATE TABLE users
     PRIMARY KEY(id)
 );
 
-INSERT INTO cs_configuration_v1 (data) VALUES (
+INSERT INTO eql_v1_configuration (data) VALUES (
   '{
     "v": 1,
     "tables": {
@@ -99,13 +99,13 @@ DO $$
   BEGIN
 
     -- the column is pending encryptindexing
-    ASSERT (SELECT EXISTS (SELECT * FROM cs_select_pending_columns_v1() AS c WHERE c.column_name = 'name'));
+    ASSERT (SELECT EXISTS (SELECT * FROM eql_v1.select_pending_columns() AS c WHERE c.column_name = 'name'));
 
     -- the target column does not exisgt
-    ASSERT (SELECT EXISTS (SELECT * FROM cs_select_target_columns_v1() AS c WHERE c.target_column IS NULL));
+    ASSERT (SELECT EXISTS (SELECT * FROM eql_v1.select_target_columns() AS c WHERE c.target_column IS NULL));
 
     -- create column
-    PERFORM cs_create_encrypted_columns_v1();
+    PERFORM eql_v1.create_encrypted_columns();
 
     ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'name_encrypted'));
     ASSERT (SELECT EXISTS (SELECT * FROM information_schema.columns s WHERE s.column_name = 'email_encrypted'));
@@ -120,15 +120,15 @@ $$ LANGUAGE plpgsql;
 -- Users table does not exist, so should fail.
 -- -----------------------------------------------
 DROP TABLE IF EXISTS users;
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
 
     BEGIN
-      PERFORM cs_encrypt_v1();
+      PERFORM eql_v1.encrypt();
       RAISE NOTICE 'Missing users table. Encrypt should have failed.';
       ASSERT false; -- skipped by exception
     EXCEPTION
@@ -136,8 +136,8 @@ DO $$
         ASSERT true;
     END;
     -- configuration state should not be changed
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting'));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -149,19 +149,19 @@ $$ LANGUAGE plpgsql;
 -- Schema validation is skipped
 -- -----------------------------------------------
 DROP TABLE IF EXISTS users;
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
 
-    PERFORM cs_encrypt_v1(true);
+    PERFORM eql_v1.encrypt(true);
     RAISE NOTICE 'Missing users table. Encrypt should have failed.';
 
     -- configuration state should be changed
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting'));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -174,10 +174,10 @@ $$ LANGUAGE plpgsql;
 -- The active config is unchanged
 -- The pending config should now be encrypting
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- create an active configuration
-INSERT INTO cs_configuration_v1 (state, data) VALUES (
+INSERT INTO eql_v1_configuration (state, data) VALUES (
   'active',
   '{
     "v": 1,
@@ -200,7 +200,7 @@ CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
     name TEXT,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
@@ -208,12 +208,12 @@ CREATE TABLE users
 -- An encrypting config should exist
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
-    PERFORM cs_encrypt_v1();
+    PERFORM eql_v1.add_index('users', 'name', 'match');
+    PERFORM eql_v1.encrypt();
 
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'active'));
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting'));
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'active'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
   END;
 $$ LANGUAGE plpgsql;
 
@@ -224,10 +224,10 @@ $$ LANGUAGE plpgsql;
 -- The active config is unchanged
 -- The pending config should now be encrypting
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- create an active configuration
-INSERT INTO cs_configuration_v1 (state, data) VALUES (
+INSERT INTO eql_v1_configuration (state, data) VALUES (
   'active',
   '{
     "v": 1,
@@ -258,12 +258,12 @@ CREATE TABLE users
 -- An encrypting config should exist
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
-    PERFORM cs_encrypt_v1();
+    PERFORM eql_v1.add_index('users', 'name', 'match');
+    PERFORM eql_v1.encrypt();
 
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'active'));
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting'));
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'active'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
   END;
 $$ LANGUAGE plpgsql;
 
@@ -274,10 +274,10 @@ $$ LANGUAGE plpgsql;
 -- The active config is now inactive
 -- The encrypting config should now be active
 -- -----------------------------------------------
-TRUNCATE TABLE cs_configuration_v1;
+TRUNCATE TABLE eql_v1_configuration;
 
 -- create an active configuration
-INSERT INTO cs_configuration_v1 (state, data) VALUES (
+INSERT INTO eql_v1_configuration (state, data) VALUES (
   'active',
   '{
     "v": 1,
@@ -301,22 +301,22 @@ CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
     name TEXT,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
 -- An encrypting config should exist
 DO $$
   BEGIN
-    PERFORM cs_add_index_v1('users', 'name', 'match');
+    PERFORM eql_v1.add_index('users', 'name', 'match');
 
-    PERFORM cs_encrypt_v1(); -- need to encrypt first
-    PERFORM cs_activate_v1();
+    PERFORM eql_v1.encrypt(); -- need to encrypt first
+    PERFORM eql_v1.activate();
 
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'active'));
-    ASSERT (SELECT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'inactive'));
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'encrypting'));
-    ASSERT (SELECT NOT EXISTS (SELECT FROM cs_configuration_v1 c WHERE c.state = 'pending'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'active'));
+    ASSERT (SELECT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'inactive'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'encrypting'));
+    ASSERT (SELECT NOT EXISTS (SELECT FROM eql_v1_configuration c WHERE c.state = 'pending'));
 
   END;
 $$ LANGUAGE plpgsql;
diff --git a/tests/operators-eq.sql b/tests/operators-eq.sql
index ad51ee5..92ee95a 100644
--- a/tests/operators-eq.sql
+++ b/tests/operators-eq.sql
@@ -3,7 +3,7 @@ DROP TABLE IF EXISTS users;
 CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
@@ -28,7 +28,7 @@ INSERT INTO users (name_encrypted) VALUES (
 DO $$
   BEGIN
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_unique_v1(name_encrypted) = cs_unique_v1('{"u":"unique-text"}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.unique(name_encrypted) = eql_v1.unique('{"u":"unique-text"}')));
 
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted = '{
@@ -43,24 +43,24 @@ DO $$
       }'::jsonb
     ));
 
-    -- cs_encrypted_v1 = jsonb
+    -- eql_v1_encrypted = jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted = '{"u": "unique-text"}'::jsonb
     ));
 
-    -- jsonb = cs_encrypted_v1
+    -- jsonb = eql_v1_encrypted
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE  '{"u": "unique-text"}'::jsonb = name_encrypted
     ));
 
-    -- cs_encrypted_v1 = text
+    -- eql_v1_encrypted = text
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = 'unique-text'::text));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = 'unique-text'::cs_unique_index_v1));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = 'unique-text'::eql_v1.unique_index));
 
-    -- text = cs_encrypted_v1
+    -- text = eql_v1_encrypted
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE 'unique-text'::text = name_encrypted));
 
-    -- cs_encrypted_v1 = cs_encrypted_v1
+    -- eql_v1_encrypted = eql_v1_encrypted
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = '{
             "v": 1,
             "k": "ct",
@@ -70,7 +70,7 @@ DO $$
             "c": "name"
             },
             "u": "unique-text"
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -80,18 +80,18 @@ $$ LANGUAGE plpgsql;
 DO $$
   BEGIN
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_unique_v1(name_encrypted) != cs_unique_v1('{"u":"random-text"}')));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_unique_v1(name_encrypted) <> cs_unique_v1('{"u":"random-text"}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.unique(name_encrypted) != eql_v1.unique('{"u":"random-text"}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.unique(name_encrypted) <> eql_v1.unique('{"u":"random-text"}')));
 
-    -- cs_encrypted_v1 = jsonb
+    -- eql_v1_encrypted = jsonb
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted != '{"u":"random-text"}'::jsonb));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> '{"u":"random-text"}'::jsonb));
 
-    -- cs_encrypted_v1 = text
+    -- eql_v1_encrypted = text
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted != 'random-text'::text));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> 'random-text'::text));
 
-    -- cs_encrypted_v1 = cs_encrypted_v1
+    -- eql_v1_encrypted = eql_v1_encrypted
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted != '{
             "v": 1,
             "k": "ct",
@@ -101,7 +101,7 @@ DO $$
             "c": "name"
             },
             "u": "random-text"
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> '{
             "v": 1,
@@ -112,7 +112,7 @@ DO $$
             "c": "name"
             },
             "u": "random-text"
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
 
   END;
@@ -146,11 +146,11 @@ INSERT INTO users (name_encrypted) VALUES (
 -- ORE eq = OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
-    ore_cs_encrypted :=  '{
+    ore_encrypted :=  '{
         "v": 1,
         "k": "ct",
         "c": "ciphertext",
@@ -168,30 +168,30 @@ DO $$
     ore_record = '("{""(\\""\\\\\\\\x12121212121259bfe28282d03415e7714fccd69eb7eb476c70743e485e20331f59cbc1c848dcdeda716f351eb20588c406a7df5fb8917ebf816739aa1414ac3b8498e493bf0badea5c9fdb3cc34da8b152b995957591880c523beb1d3f12487c38d18f62dd26209a727674e5a5fe3a3e3037860839afd801ff4a28b714e4cde8df10625dce72602fdbdcc53d515857f1119f5912804ce09c6cf6c2d37393a27a465134523b512664582f834e15003b7216cb668480bc3e7d1c069f2572ece7c848b9eb9a28b4e62bfc2b97c93e61b2054154e621c5bbb7bed37de3d7c343bd3dbcf7b4af20128c961351bf55910a855f08a8587c2059a5f05ca8d7a082e695b3dd4ff3ce86694d4fe98972220eea1ab90f5de493ef3a502b74a569f103ee2897ebc9ae9b16a17e7be67415ee830519beb3058ffc1c1eb0e574d66c8b365919f27eb00aa7bce475d7bdaad4ed800f8fc3d626e0eb842e312b0cc22a1ccf89847ebb2cd0a6e18aec21bd2deeec1c47301fc687f7f764bb882b50f553c246a6da5816b78b3530119ea68b08a8403a90e063e58502670563bd4d\\"")""}")';
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) = cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) = eql_v1.ore_64_8_v1(ore_json)));
 
     ASSERT (SELECT EXISTS (
-      SELECT id FROM users WHERE name_encrypted = ore_cs_encrypted::jsonb
+      SELECT id FROM users WHERE name_encrypted = ore_encrypted::jsonb
     ));
 
-    -- -- cs_encrypted_v1 = jsonb
+    -- -- eql_v1_encrypted = jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted = ore_json::jsonb
     ));
 
-    -- -- jsonb = cs_encrypted_v1
+    -- -- jsonb = eql_v1_encrypted
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE ore_json::jsonb = name_encrypted
     ));
 
-    -- -- cs_encrypted_v1 = ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = ore_record::ore_64_8_v1));
+    -- -- eql_v1_encrypted = ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- ore_64_8_v1 = cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE ore_record::ore_64_8_v1 = name_encrypted));
+    -- -- -- ore_64_8_v1 = eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE ore_record::eql_v1.ore_64_8_v1 = name_encrypted));
 
-    -- -- -- cs_encrypted_v1 = cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- eql_v1_encrypted = eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted = ore_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -215,11 +215,11 @@ INSERT INTO users (name_encrypted) VALUES (
 -- ORE eq = OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
-    ore_cs_encrypted :=  '{
+    ore_encrypted :=  '{
         "v": 1,
         "k": "ct",
         "c": "ciphertext",
@@ -237,30 +237,30 @@ DO $$
     ore_record = '("{""(\\""\\\\\\\\x1212121212125932e28282d03415e7714fccd69eb7eb476c70743e485e20331f59cbc1c848dcdeda716f351eb20588c406a7df5fb8917ebf816739aa1414ac3b8498e493bf0badea5c9fdb3cc34da8b152b995957591880c523beb1d3f12487c38d18f62dd26209a727674e5a5fe3a3e3037860839afd8011f94b49eaa5fa5a60e1e2adccde4185a7d6c7f83088500b677f897d4ffc276016d614708488f407c01bd3ccf2be653269062cb97f8945a621d049277d19b1c248611f25d047038928d2efeb4323c402af4c19288c7b36911dc06639af5bb34367519b66c1f525bbd3828c12067c9c579aeeb4fb3ae0918125dc1dad5fd518019a5ae67894ce1a7f7bed1a591ba8edda2fdf4cd403761fd981fb1ea5eb0bf806f919350ee60cac16d0a39a491a4d79301781f95ea3870aea82e9946053537360b2fb415b18b61aed0af81d461ad6b923f10c0df79daddc4e279ff543a282bb3a37f9fa03238348b3dac51a453b04bced1f5bd318ddd829bdfe5f37abdbeda730e21441b818302f3c5c2c4d5657accfca4c53d7a80eb3db43946d38965be5f796b\\"")""}")';
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) <> cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) <> eql_v1.ore_64_8_v1(ore_json)));
 
     ASSERT (SELECT EXISTS (
-      SELECT id FROM users WHERE name_encrypted <> ore_cs_encrypted::jsonb
+      SELECT id FROM users WHERE name_encrypted <> ore_encrypted::jsonb
     ));
 
-    -- -- -- cs_encrypted_v1 <> jsonb
+    -- -- -- eql_v1_encrypted <> jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted <> ore_json::jsonb
     ));
 
-    -- -- -- jsonb <> cs_encrypted_v1
+    -- -- -- jsonb <> eql_v1_encrypted
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE ore_json::jsonb <> name_encrypted
     ));
 
-    -- -- -- cs_encrypted_v1 <> ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> ore_record::ore_64_8_v1));
+    -- -- -- eql_v1_encrypted <> ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- -- ore_64_8_v1 <> cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE ore_record::ore_64_8_v1 <> name_encrypted));
+    -- -- -- -- ore_64_8_v1 <> eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE ore_record::eql_v1.ore_64_8_v1 <> name_encrypted));
 
-    -- -- -- -- cs_encrypted_v1 <> cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- -- eql_v1_encrypted <> eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <> ore_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
diff --git a/tests/operators-match.sql b/tests/operators-match.sql
index 58743d4..de8041c 100644
--- a/tests/operators-match.sql
+++ b/tests/operators-match.sql
@@ -6,7 +6,7 @@ DROP TABLE IF EXISTS users;
 CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
@@ -33,24 +33,24 @@ INSERT INTO users (name_encrypted) VALUES (
 DO $$
   BEGIN
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_match_v1(name_encrypted) ~~ cs_match_v1('{"m":[1,2]}')));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_match_v1(name_encrypted) ~~* cs_match_v1('{"m":[1,2]}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.match(name_encrypted) ~~ eql_v1.match('{"m":[1,2]}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.match(name_encrypted) ~~* eql_v1.match('{"m":[1,2]}')));
 
-    -- cs_encrypted_v1 = jsonb
+    -- eql_v1_encrypted = jsonb
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~ '{"m":[1,2]}'::jsonb));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~* '{"m":[1,2]}'::jsonb));
 
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{"m":[1,2,3,6,7,8,9]}'::jsonb ~~ name_encrypted));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{"m":[1,2,3,6,7,8,9]}'::jsonb ~~* name_encrypted));
 
-    -- cs_encrypted_v1 = text
+    -- eql_v1_encrypted = text
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~ ARRAY[1,2]::smallint[]));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~* ARRAY[1,2]::smallint[]));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~ ARRAY[1,2]::cs_match_index_v1));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~* ARRAY[1,2]::cs_match_index_v1));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~ ARRAY[1,2]::eql_v1.match_index));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~* ARRAY[1,2]::eql_v1.match_index));
 
-    -- cs_encrypted_v1 = cs_encrypted_v1
+    -- eql_v1_encrypted = eql_v1_encrypted
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~ '{
             "v": 1,
             "k": "ct",
@@ -60,7 +60,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2]
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ~~* '{
             "v": 1,
@@ -71,7 +71,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2]
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
       ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{
             "v": 1,
@@ -82,7 +82,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2, 3, 4, 5]
-        }'::cs_encrypted_v1 ~~ name_encrypted));
+        }'::eql_v1_encrypted ~~ name_encrypted));
 
 
       ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{
@@ -94,7 +94,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2, 3, 4, 5]
-        }'::cs_encrypted_v1 ~~* name_encrypted));
+        }'::eql_v1_encrypted ~~* name_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -106,24 +106,24 @@ $$ LANGUAGE plpgsql;
 DO $$
   BEGIN
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_match_v1(name_encrypted) LIKE cs_match_v1('{"m":[1,2]}')));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_match_v1(name_encrypted) ILIKE cs_match_v1('{"m":[1,2]}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.match(name_encrypted) LIKE eql_v1.match('{"m":[1,2]}')));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.match(name_encrypted) ILIKE eql_v1.match('{"m":[1,2]}')));
 
-    -- cs_encrypted_v1 = jsonb
+    -- eql_v1_encrypted = jsonb
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted LIKE '{"m":[1,2]}'::jsonb));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ILIKE '{"m":[1,2]}'::jsonb));
 
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{"m":[1,2,3,6,7,8,9]}'::jsonb LIKE name_encrypted));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{"m":[1,2,3,6,7,8,9]}'::jsonb ILIKE name_encrypted));
 
-    -- cs_encrypted_v1 = text
+    -- eql_v1_encrypted = text
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted LIKE ARRAY[1,2]::smallint[]));
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ILIKE ARRAY[1,2]::smallint[]));
 
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted LIKE ARRAY[1,2]::cs_match_index_v1));
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ILIKE ARRAY[1,2]::cs_match_index_v1));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted LIKE ARRAY[1,2]::eql_v1.match_index));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ILIKE ARRAY[1,2]::eql_v1.match_index));
 
-    -- cs_encrypted_v1 = cs_encrypted_v1
+    -- eql_v1_encrypted = eql_v1_encrypted
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted LIKE '{
             "v": 1,
             "k": "ct",
@@ -133,7 +133,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2]
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
     ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted ILIKE '{
             "v": 1,
@@ -144,7 +144,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2]
-        }'::cs_encrypted_v1));
+        }'::eql_v1_encrypted));
 
       ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{
             "v": 1,
@@ -155,7 +155,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2, 3, 4, 5]
-        }'::cs_encrypted_v1 LIKE name_encrypted));
+        }'::eql_v1_encrypted LIKE name_encrypted));
 
 
       ASSERT (SELECT EXISTS (SELECT id FROM users WHERE '{
@@ -167,7 +167,7 @@ DO $$
             "c": "name"
             },
             "m": [1, 2, 3, 4, 5]
-        }'::cs_encrypted_v1 ILIKE name_encrypted));
+        }'::eql_v1_encrypted ILIKE name_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
\ No newline at end of file
diff --git a/tests/operators-ore.sql b/tests/operators-ore.sql
index 553157e..ad71e27 100644
--- a/tests/operators-ore.sql
+++ b/tests/operators-ore.sql
@@ -6,7 +6,7 @@ DROP TABLE IF EXISTS users;
 CREATE TABLE users
 (
     id bigint GENERATED ALWAYS AS IDENTITY,
-    name_encrypted cs_encrypted_v1,
+    name_encrypted eql_v1_encrypted,
     PRIMARY KEY(id)
 );
 
@@ -32,7 +32,7 @@ INSERT INTO users (name_encrypted) VALUES (
 -- ORE eq < OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_cs_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
@@ -54,34 +54,34 @@ DO $$
 
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) < cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) < eql_v1.ore_64_8_v1(ore_json)));
 
     -- NULL VALUES SHOULD BE IGNORED
-    ASSERT (SELECT (SELECT COUNT(*) FROM (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) < cs_ore_64_8_v1(ore_json)) as count) = 1);
+    ASSERT (SELECT (SELECT COUNT(*) FROM (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) < eql_v1.ore_64_8_v1(ore_json)) as count) = 1);
 
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted < ore_cs_encrypted::jsonb
     ));
 
-    -- -- -- cs_encrypted_v1 < jsonb
+    -- -- -- eql_v1_encrypted < jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted < ore_json::jsonb
     ));
 
-    -- -- -- jsonb < cs_encrypted_v1
+    -- -- -- jsonb < eql_v1_encrypted
     -- genrating ORE data for tests is fiddly, hence the IS FALSE here
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE (ore_json::jsonb < name_encrypted) IS FALSE
     ));
 
-    -- -- -- -- cs_encrypted_v1 < ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted < ore_record::ore_64_8_v1));
+    -- -- -- -- eql_v1_encrypted < ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted < ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- -- -- ore_64_8_v1 < cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::ore_64_8_v1 < name_encrypted) IS FALSE));
+    -- -- -- -- -- ore_64_8_v1 < eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::eql_v1.ore_64_8_v1 < name_encrypted) IS FALSE));
 
-    -- -- -- -- cs_encrypted_v1 <> cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted < ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- -- eql_v1_encrypted <> eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted < ore_cs_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -91,7 +91,7 @@ $$ LANGUAGE plpgsql;
 -- ORE eq <= OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_cs_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
@@ -113,31 +113,31 @@ DO $$
 
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) <= cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) <= eql_v1.ore_64_8_v1(ore_json)));
 
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted <= ore_cs_encrypted::jsonb
     ));
 
-    -- -- -- cs_encrypted_v1 <= jsonb
+    -- -- -- eql_v1_encrypted <= jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted <= ore_json::jsonb
     ));
 
-    -- -- -- jsonb <= cs_encrypted_v1
+    -- -- -- jsonb <= eql_v1_encrypted
     -- genrating ORE data for tests is fiddly, hence the IS FALSE here
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE (ore_json::jsonb <= name_encrypted) IS FALSE
     ));
 
-    -- -- -- -- cs_encrypted_v1 <= ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <= ore_record::ore_64_8_v1));
+    -- -- -- -- eql_v1_encrypted <= ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <= ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- -- -- ore_64_8_v1 <= cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::ore_64_8_v1 <= name_encrypted) IS FALSE));
+    -- -- -- -- -- ore_64_8_v1 <= eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::eql_v1.ore_64_8_v1 <= name_encrypted) IS FALSE));
 
-    -- -- -- -- cs_encrypted_v1 <= cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <= ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- -- eql_v1_encrypted <= eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted <= ore_cs_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -164,7 +164,7 @@ INSERT INTO users (name_encrypted) VALUES (
 -- ORE eq < OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_cs_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
@@ -186,31 +186,31 @@ DO $$
     ore_record = '("{""(\\""\\\\\\\\x12121212121259bfe28282d03415e7714fccd69eb7eb476c70743e485e20331f59cbc1c848dcdeda716f351eb20588c406a7df5fb8917ebf816739aa1414ac3b8498e493bf0badea5c9fdb3cc34da8b152b995957591880c523beb1d3f12487c38d18f62dd26209a727674e5a5fe3a3e3037860839afd801ff4a28b714e4cde8df10625dce72602fdbdcc53d515857f1119f5912804ce09c6cf6c2d37393a27a465134523b512664582f834e15003b7216cb668480bc3e7d1c069f2572ece7c848b9eb9a28b4e62bfc2b97c93e61b2054154e621c5bbb7bed37de3d7c343bd3dbcf7b4af20128c961351bf55910a855f08a8587c2059a5f05ca8d7a082e695b3dd4ff3ce86694d4fe98972220eea1ab90f5de493ef3a502b74a569f103ee2897ebc9ae9b16a17e7be67415ee830519beb3058ffc1c1eb0e574d66c8b365919f27eb00aa7bce475d7bdaad4ed800f8fc3d626e0eb842e312b0cc22a1ccf89847ebb2cd0a6e18aec21bd2deeec1c47301fc687f7f764bb882b50f553c246a6da5816b78b3530119ea68b08a8403a90e063e58502670563bd4d\\"")""}")';
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) > cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) > eql_v1.ore_64_8_v1(ore_json)));
 
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted > ore_cs_encrypted::jsonb
     ));
 
-    -- -- -- cs_encrypted_v1 > jsonb
+    -- -- -- eql_v1_encrypted > jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted > ore_json::jsonb
     ));
 
-    -- -- -- jsonb > cs_encrypted_v1
+    -- -- -- jsonb > eql_v1_encrypted
     -- genrating ORE data for tests is fiddly, hence the IS FALSE here
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE (ore_json::jsonb > name_encrypted) IS FALSE
     ));
 
-    -- -- -- -- cs_encrypted_v1 > ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted > ore_record::ore_64_8_v1));
+    -- -- -- -- eql_v1_encrypted > ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted > ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- -- -- ore_64_8_v1 > cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::ore_64_8_v1 > name_encrypted) IS FALSE));
+    -- -- -- -- -- ore_64_8_v1 > eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::eql_v1.ore_64_8_v1 > name_encrypted) IS FALSE));
 
-    -- -- -- -- cs_encrypted_v1 >> cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted > ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- -- eql_v1_encrypted >> eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted > ore_cs_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
@@ -238,7 +238,7 @@ INSERT INTO users (name_encrypted) VALUES (
 -- ORE eq >= OPERATORS
 DO $$
   DECLARE
-    ore_cs_encrypted cs_encrypted_v1;
+    ore_cs_encrypted eql_v1_encrypted;
     ore_json jsonb;
     ore_record text;
   BEGIN
@@ -260,31 +260,31 @@ DO $$
     ore_record = '("{""(\\""\\\\\\\\x12121212121259bfe28282d03415e7714fccd69eb7eb476c70743e485e20331f59cbc1c848dcdeda716f351eb20588c406a7df5fb8917ebf816739aa1414ac3b8498e493bf0badea5c9fdb3cc34da8b152b995957591880c523beb1d3f12487c38d18f62dd26209a727674e5a5fe3a3e3037860839afd801ff4a28b714e4cde8df10625dce72602fdbdcc53d515857f1119f5912804ce09c6cf6c2d37393a27a465134523b512664582f834e15003b7216cb668480bc3e7d1c069f2572ece7c848b9eb9a28b4e62bfc2b97c93e61b2054154e621c5bbb7bed37de3d7c343bd3dbcf7b4af20128c961351bf55910a855f08a8587c2059a5f05ca8d7a082e695b3dd4ff3ce86694d4fe98972220eea1ab90f5de493ef3a502b74a569f103ee2897ebc9ae9b16a17e7be67415ee830519beb3058ffc1c1eb0e574d66c8b365919f27eb00aa7bce475d7bdaad4ed800f8fc3d626e0eb842e312b0cc22a1ccf89847ebb2cd0a6e18aec21bd2deeec1c47301fc687f7f764bb882b50f553c246a6da5816b78b3530119ea68b08a8403a90e063e58502670563bd4d\\"")""}")';
 
     -- SANITY CHECK
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE cs_ore_64_8_v1(name_encrypted) >= cs_ore_64_8_v1(ore_json)));
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE eql_v1.ore_64_8_v1(name_encrypted) >= eql_v1.ore_64_8_v1(ore_json)));
 
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted >= ore_cs_encrypted::jsonb
     ));
 
-    -- -- -- cs_encrypted_v1 >= jsonb
+    -- -- -- eql_v1_encrypted >= jsonb
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE name_encrypted >= ore_json::jsonb
     ));
 
-    -- -- -- jsonb >= cs_encrypted_v1
+    -- -- -- jsonb >= eql_v1_encrypted
     -- genrating ORE data for tests is fiddly, hence the IS FALSE here
     ASSERT (SELECT EXISTS (
       SELECT id FROM users WHERE (ore_json::jsonb >= name_encrypted) IS FALSE
     ));
 
-    -- -- -- -- cs_encrypted_v1 >= ore_64_8_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted >= ore_record::ore_64_8_v1));
+    -- -- -- -- eql_v1_encrypted >= ore_64_8_v1
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted >= ore_record::eql_v1.ore_64_8_v1));
 
-    -- -- -- -- -- ore_64_8_v1 >= cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::ore_64_8_v1 >= name_encrypted) IS FALSE));
+    -- -- -- -- -- ore_64_8_v1 >= eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE (ore_record::eql_v1.ore_64_8_v1 >= name_encrypted) IS FALSE));
 
-    -- -- -- -- cs_encrypted_v1 >= cs_encrypted_v1
-    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted >= ore_cs_encrypted::cs_encrypted_v1));
+    -- -- -- -- eql_v1_encrypted >= eql_v1_encrypted
+    ASSERT (SELECT EXISTS (SELECT id FROM users WHERE name_encrypted >= ore_cs_encrypted::eql_v1_encrypted));
 
   END;
 $$ LANGUAGE plpgsql;
diff --git a/tests/version.sql b/tests/version.sql
index 5330ad1..0bdd32f 100644
--- a/tests/version.sql
+++ b/tests/version.sql
@@ -2,7 +2,7 @@
 
 DO $$
   BEGIN
-    ASSERT (SELECT true WHERE cs_eql_version() = 'DEV');
+    ASSERT (SELECT true WHERE eql_v1.version() = 'DEV');
 
   END;
 $$ LANGUAGE plpgsql;