repertoire-faceting 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d3aadcd08762f8d0eb82f1b0a0a91f5866836f2
-  data.tar.gz: 3261f97f7058932bd1e0a1a424b2c869903b8c8f
+  metadata.gz: 9f33047f3e67ebe050a869ec98d8f90042c284de
+  data.tar.gz: 66d4aa841d23714ede620a6ea56f2947f107a97c
 SHA512:
-  metadata.gz: 1a6e1019f798bc2356afab1e5a2eec80b8dd289591a27095da38e296f86ea5c771008fb367be4869bab1ef2c1c2d009052c5a5c1cab55c93a4811dc35da1f705
-  data.tar.gz: d897d8d5aa4ba04e747d46b81a2fb1dc05451991f6c0222a8cdae1fefa1269cea2b8575c4b90b690c1543fbea5e014b18746d8fb0ed9bb3664b4bd7c9228a721
+  metadata.gz: 5d86d643b9c881419b6dfe4f3608a56160193775057fc4f645f4b4367f10416cc5968e7f85a0f8059acc9a6c0f5cdc7ebf01a571d1bdc74e6661aa253f6a15e3
+  data.tar.gz: 890a6a07e726450554e058065f0e1fd2471805b8b4e6a751d87d564b5bc3dee58567176b56e8c445fc3df7f12009a9882d7eb2f854966d7facd0c82dce447675

data/FAQ

@@ -95,6 +95,7 @@
 
 *A* See the syntax for defining jquery plugins - you can alter the defaults for all widgets by reassigning them in your view code.
 
+
 *Q* How do I make one-time, minor changes to the behaviour of a widget?  For example, I want to add a control.
 
 *A* Use the inject option, which is part of the base functionality.  Your injector function receives a reference to the widget's jquery element and to the widget javascript object.  Use jquery to add your control's markup, then register an event handler to add its behaviour.  For example, this injector adds a clear-all button in the title:
@@ -106,7 +107,7 @@
       handlers: {
         'click!.clear_control' : function(self) {
           self.refinements('genre').length = 0;
-          self.state_changed();
+          self.trigger('changed');
           return false;
         }
       }
@@ -127,7 +128,7 @@ In injectors and handlers, you have access to the complete faceting widget API (
    $('#genre').facet({
      injectors:  { ... },
      handlers:   { ... },
-     pre_update: function(state) { state.minimum = genre_min; }
+     state: function(state) { state.minimum = genre_min; }
    }
 
 

data/ext/Makefile

@@ -8,7 +8,7 @@
 #
 #-------------------------------------------------------------------------
 
-API_VERSION = 0.7.2
+API_VERSION = 0.7.3
 
 MODULES = signature/signature
 EXTENSION = signature/faceting \

data/ext/bytea/faceting_bytea.control

@@ -2,5 +2,5 @@
  
 comment = 'API for faceted indexing and queries (based on plv8 + bytea bitmaps)'
 requires = 'plv8, plpgsql'
-default_version = '0.7.2'
+default_version = '0.7.3'
 schema = 'facet'

data/ext/faceting--0.7.2.sql

@@ -0,0 +1,251 @@
+-- ============================================================================
+-- Faceting API implementing bitmap indices using a custom C datatype and
+-- associated functions.
+--
+-- This API is to be preferred in all situations where it is possible to
+-- build and install the datatype (requires superuser access to PostgreSQL)
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION faceting" to load this the default faceting API.\quit
+
+-- functions for bitmap indices using datatype written in C
+
+CREATE TYPE @extschema@.signature;
+
+-- basic i/o functions for signatures
+
+CREATE FUNCTION @extschema@.sig_in( cstring )
+  RETURNS signature
+  AS 'signature.so', 'sig_in'
+  LANGUAGE C STRICT;
+
+CREATE FUNCTION @extschema@.sig_out( signature )
+  RETURNS cstring
+  AS 'signature.so', 'sig_out'
+  LANGUAGE C STRICT;
+
+-- signature postgresql type
+
+CREATE TYPE @extschema@.signature (
+	INTERNALLENGTH = VARIABLE,
+	INPUT = sig_in,
+	OUTPUT = sig_out,
+	STORAGE = extended
+);
+
+-- functions for signatures
+
+CREATE FUNCTION @extschema@.sig_resize( signature, INT )
+  RETURNS signature
+  AS 'signature.so', 'sig_resize'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( signature, INT, INT )
+  RETURNS signature
+  AS 'signature.so', 'sig_set'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( signature, INT )
+  RETURNS signature
+  AS 'signature.so', 'sig_set'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_get( signature, INT )
+  RETURNS INT
+  AS 'signature.so', 'sig_get'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_length( signature )
+	RETURNS INT
+	AS 'signature.so', 'sig_length'
+	LANGUAGE C STRICT IMMUTABLE;
+	
+CREATE FUNCTION @extschema@.sig_min( signature )
+	RETURNS INT
+	AS 'signature.so', 'sig_min'
+	LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_and( signature, signature )
+  RETURNS signature
+  AS 'signature.so', 'sig_and'
+  LANGUAGE C STRICT IMMUTABLE;	
+
+CREATE FUNCTION @extschema@.sig_or( signature, signature )
+  RETURNS signature
+  AS 'signature.so', 'sig_or'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_xor( signature )
+  RETURNS signature
+  AS 'signature.so', 'sig_xor'
+  LANGUAGE C STRICT IMMUTABLE;
+ 
+CREATE FUNCTION @extschema@.count( signature )
+	RETURNS INT
+	AS 'signature.so', 'count'
+	LANGUAGE C STRICT IMMUTABLE;
+	
+CREATE FUNCTION @extschema@.contains( signature, INT )
+  RETURNS BOOL
+  AS 'signature.so', 'contains'
+  LANGUAGE C STRICT IMMUTABLE;	
+	
+CREATE FUNCTION @extschema@.members( signature )
+  RETURNS SETOF INT
+  AS 'signature.so', 'members'
+  LANGUAGE C STRICT IMMUTABLE;
+  
+CREATE FUNCTION @extschema@.sig_cmp( signature, signature )
+  RETURNS INT
+  AS 'signature.so', 'sig_cmp'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_lt( signature, signature )
+  RETURNS BOOL
+  AS 'signature.so', 'sig_lt'
+  LANGUAGE C STRICT IMMUTABLE;
+ 
+CREATE FUNCTION @extschema@.sig_lte( signature, signature )
+  RETURNS BOOL
+  AS 'signature.so', 'sig_lte'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_eq( signature, signature )
+  RETURNS BOOL
+  AS 'signature.so', 'sig_eq'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_gt( signature, signature )
+  RETURNS BOOL
+  AS 'signature.so', 'sig_gt'
+  LANGUAGE C STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_gte( signature, signature )
+  RETURNS BOOL
+  AS 'signature.so', 'sig_gte'
+  LANGUAGE C STRICT IMMUTABLE;
+
+
+-- operators for signatures
+
+CREATE OPERATOR @extschema@.& (
+    leftarg = signature,
+    rightarg = signature,
+    procedure = @extschema@.sig_and,
+    commutator = &
+);
+
+CREATE OPERATOR @extschema@.| (
+    leftarg = signature,
+    rightarg = signature,
+    procedure = @extschema@.sig_or,
+    commutator = |
+);
+
+CREATE OPERATOR @extschema@.+ (
+    leftarg = signature,
+    rightarg = int,
+    procedure = @extschema@.sig_set
+);
+ 
+CREATE OPERATOR @extschema@.< (
+   leftarg = signature, rightarg = signature, procedure = sig_lt,
+   commutator = > , negator = >= ,
+   restrict = scalarltsel, join = scalarltjoinsel
+);
+
+CREATE OPERATOR @extschema@.<= (
+   leftarg = signature, rightarg = signature, procedure = sig_lte,
+   commutator = >= , negator = > ,
+   restrict = scalarltsel, join = scalarltjoinsel
+);
+
+CREATE OPERATOR @extschema@.= (
+   leftarg = signature, rightarg = signature, procedure = sig_eq,
+   commutator = = , negator = <> ,
+   restrict = eqsel, join = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+   leftarg = signature, rightarg = signature, procedure = sig_gte,
+   commutator = <= , negator = < ,
+   restrict = scalargtsel, join = scalargtjoinsel
+);
+
+CREATE OPERATOR @extschema@.> (
+   leftarg = signature, rightarg = signature, procedure = sig_gt,
+   commutator = < , negator = <= ,
+   restrict = scalargtsel, join = scalargtjoinsel
+);
+
+-- index operator classes for signatures
+
+CREATE OPERATOR CLASS @extschema@.signature_ops
+    DEFAULT FOR TYPE signature USING btree AS
+        OPERATOR        1       < ,
+        OPERATOR        2       <= ,
+        OPERATOR        3       = ,
+        OPERATOR        4       >= ,
+        OPERATOR        5       > ,
+        FUNCTION        1       sig_cmp(signature, signature);
+
+
+-- aggregate functions for faceting
+
+CREATE AGGREGATE @extschema@.collect( signature )
+(
+	sfunc = @extschema@.sig_or,
+	stype = signature
+);
+
+CREATE AGGREGATE @extschema@.filter( signature )
+(
+   sfunc = @extschema@.sig_and,
+   stype = signature
+);
+
+CREATE AGGREGATE @extschema@.signature( INT )
+(
+	sfunc = @extschema@.sig_set,
+	stype = signature,
+  initcond = '0'
+);-- ============================================================================
+-- These functions are common to all bindings of the Repertoire faceting API
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+
+-- Aggregator to measure how many bits from a loosely-packed id column would be wasted, if
+-- they were all collected into a bitset signature. Returns a float between 0 (no waste)
+-- and 1.0 (all waste). An example of its use:
+--
+-- SELECT wastage(id) FROM nobelists
+--  =# 0.999999
+--
+-- ALTER TABLE nobelists ADD COLUMN _packed_id SERIAL
+-- SELECT wastage(_packed_id) FROM nobelists
+--  =# 0.015625
+--
+CREATE FUNCTION @extschema@.wastage_proportion( state INT[] ) RETURNS double precision AS $$
+  SELECT (1.0 - (state[1]::double precision / (COALESCE(state[2], 0.0) + 1.0)))
+$$ LANGUAGE sql;
+
+CREATE FUNCTION @extschema@.wastage_accum( state INT[], val INT ) RETURNS INT[] AS $$
+  SELECT ARRAY[ state[1]+1, GREATEST(state[2], val) ];
+$$ LANGUAGE sql;
+
+CREATE AGGREGATE @extschema@.wastage( INT )
+(
+	sfunc = @extschema@.wastage_accum,
+	stype = INT[],
+	finalfunc = @extschema@.wastage_proportion,
+	initcond = '{0,0}'
+);

data/ext/faceting_bytea--0.7.2.sql

@@ -0,0 +1,207 @@
+-- ============================================================================
+-- Faceting API implementing bitmap indices using PostgreSQL's built-in BYTEA
+-- type, processed using plv8 typed arrays.
+--
+-- This API is suitable for deployment on Heroku, where plv8 is installed by
+-- default. Performance is many times better than the VARBIT-based faceting
+-- API, primarily because of optimisations in memory handling in the count
+-- function.
+--
+-- See https://code.google.com/p/plv8js/wiki/PLV8
+--     https://postgres.heroku.com/blog/past/2013/6/5/javascript_in_your_postgres/
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+CREATE EXTENSION IF NOT EXISTS plv8;
+
+SET bytea_output TO hex;
+
+-- these functions are in pl/pgsql, because they involve appending bytea values,
+-- which is easier done with direct access to the || operator
+
+CREATE FUNCTION @extschema@.sig_resize( sig BYTEA, bits INT ) RETURNS BYTEA AS $$
+DECLARE
+  len INT;
+  bytes INT;
+BEGIN
+  bytes := ceil(bits / 8.0)::INT;
+  len := length(sig);
+  IF bytes > len THEN
+    -- RAISE NOTICE 'Extending signature from % to % bytes', len, bytes;
+    RETURN sig || ('\x' || repeat('00', bytes - len))::BYTEA;
+  ELSIF bits < len THEN
+    -- no provision in PostgreSQL for truncating a BYTEA
+    RETURN sig;
+  END IF;
+  RETURN sig;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( sig BYTEA, pos INT, val INT ) RETURNS BYTEA AS $$
+BEGIN
+  RETURN set_bit(@extschema@.sig_resize(sig, pos+1), pos, val);
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( sig BYTEA, pos INT ) RETURNS BYTEA AS $$
+BEGIN
+  RETURN @extschema@.sig_set(sig, pos, 1);
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+-- these functions are in javascript, because (1) pl/pgsql is close
+-- to the worst language in the world; (2) plv8's typed arrays make 
+-- the count function much faster
+
+CREATE FUNCTION @extschema@.sig_get( sig BYTEA, pos INT ) RETURNS INT AS $$
+  if (pos <= sig.length * 8) {
+    return sig[ Math.floor(pos / 8) ] >> (pos % 8) & 1;
+  } else {
+    return 0;
+  }
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_length( sig BYTEA ) RETURNS INT AS $$
+  return sig.length;
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_and(sig1 BYTEA, sig2 BYTEA) RETURNS BYTEA AS $$
+  if (sig2.length < sig1.length) {
+    var tmp = sig1;
+    sig1 = sig2;
+    sig2 = tmp;
+  }
+  for (var i = 0; i < sig1.length; i++) {
+    sig1[i] = sig1[i] & sig2[i];
+  }
+  return sig1;
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_or(sig1 BYTEA, sig2 BYTEA) RETURNS BYTEA AS $$
+  if (sig2.length > sig1.length) {
+    var tmp = sig1;
+    sig1 = sig2;
+    sig2 = tmp;
+  }
+  for (var i = 0; i < sig2.length; i++) {
+    sig1[i] = sig1[i] | sig2[i];
+  }
+  return sig1;
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.count( sig BYTEA ) RETURNS int4 AS $$
+  var count_table = [
+    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
+  ];
+  var count = 0; 
+  for (var i = 0; i < sig.length; i++) { count += count_table[ sig[i] ]; } 
+  return count;
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.contains( sig BYTEA, pos INT ) RETURNS BOOL AS $$
+  return (pos <= sig.length * 8) && (sig[ Math.floor(pos / 8) ] >> (pos % 8) & 1);
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.members( sig BYTEA ) RETURNS SETOF INT AS $$
+  for (var i = 0; i < sig.length; i++) {
+    for (var j = 0; j < 8; j++) {
+      if (sig[i] >> j & 1) {
+        plv8.return_next(i * 8 + j);
+      }
+    }
+  }
+$$ LANGUAGE plv8 STRICT IMMUTABLE;
+
+
+-- operators for faceting
+
+CREATE OPERATOR @extschema@.& (
+    leftarg = BYTEA,
+    rightarg = BYTEA,
+    procedure = @extschema@.sig_and,
+    commutator = &
+);
+
+CREATE OPERATOR @extschema@.| (
+    leftarg = BYTEA,
+    rightarg = BYTEA,
+    procedure = @extschema@.sig_or,
+    commutator = |
+);
+
+CREATE OPERATOR @extschema@.+ (
+    leftarg = BYTEA,
+    rightarg = int,
+    procedure = @extschema@.sig_set
+);
+
+
+-- aggregate functions for faceting
+
+CREATE AGGREGATE @extschema@.collect( BYTEA )
+(
+	sfunc = @extschema@.sig_or,
+	stype = BYTEA
+);
+
+CREATE AGGREGATE @extschema@.filter( BYTEA )
+(
+   sfunc = @extschema@.sig_and,
+   stype = BYTEA
+);
+
+CREATE AGGREGATE @extschema@.signature( INT )
+(
+	sfunc = @extschema@.sig_set,
+  stype = BYTEA,
+  initcond = ''
+);-- ============================================================================
+-- These functions are common to all bindings of the Repertoire faceting API
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+
+-- Aggregator to measure how many bits from a loosely-packed id column would be wasted, if
+-- they were all collected into a bitset signature. Returns a float between 0 (no waste)
+-- and 1.0 (all waste). An example of its use:
+--
+-- SELECT wastage(id) FROM nobelists
+--  =# 0.999999
+--
+-- ALTER TABLE nobelists ADD COLUMN _packed_id SERIAL
+-- SELECT wastage(_packed_id) FROM nobelists
+--  =# 0.015625
+--
+CREATE FUNCTION @extschema@.wastage_proportion( state INT[] ) RETURNS double precision AS $$
+  SELECT (1.0 - (state[1]::double precision / (COALESCE(state[2], 0.0) + 1.0)))
+$$ LANGUAGE sql;
+
+CREATE FUNCTION @extschema@.wastage_accum( state INT[], val INT ) RETURNS INT[] AS $$
+  SELECT ARRAY[ state[1]+1, GREATEST(state[2], val) ];
+$$ LANGUAGE sql;
+
+CREATE AGGREGATE @extschema@.wastage( INT )
+(
+	sfunc = @extschema@.wastage_accum,
+	stype = INT[],
+	finalfunc = @extschema@.wastage_proportion,
+	initcond = '{0,0}'
+);

data/ext/faceting_varbit--0.7.2.sql

@@ -0,0 +1,198 @@
+-- ============================================================================
+-- Faceting API implementing bitmap indices using PostgreSQL's built-in VARBIT
+-- type, processed using the built-in language pl/pgsql.
+--
+-- This API is suitable for deployment on any host, since it requires no
+-- PostgreSQL extensions outside the default install.
+--
+-- However, performance is limited to around 30,000 items in practice (in part
+-- because of unnecessary duplication of varbit values when pl/pgsql evaluates
+-- the count function.)
+--
+-- The 'signature' C-based faceting API is preferable for any install where
+-- you have superuser access to the database.
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+CREATE FUNCTION @extschema@.sig_resize( sig VARBIT, bits INT ) RETURNS VARBIT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := length(sig);
+  IF bits > len THEN
+    RETURN sig || repeat('0', bits - len)::VARBIT;
+  ELSIF bits < len THEN
+    RETURN substring(sig FROM 1 FOR bits);
+  END IF;
+  RETURN sig;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( sig VARBIT, pos INT, val INT ) RETURNS VARBIT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := length(sig);
+  IF pos >= len THEN
+    IF val > 0 THEN
+      RETURN set_bit(@extschema@.sig_resize(sig, pos+1), pos, 1);
+    ELSE
+      RETURN sig;
+    END IF;
+  ELSE
+    RETURN set_bit(sig, pos, val);
+  END IF;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_set( sig VARBIT, pos INT ) RETURNS VARBIT AS $$
+BEGIN
+  RETURN @extschema@.sig_set(sig, pos, 1);
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_get( sig VARBIT, pos INT ) RETURNS INT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := length(sig);
+  IF pos >= len THEN
+    RETURN 0;
+  ELSE
+    RETURN get_bit(sig, pos);
+  END IF;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_length( sig VARBIT ) RETURNS INT AS $$
+BEGIN
+  RETURN length(sig);
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_min( sig VARBIT ) RETURNS INT AS $$
+BEGIN
+  RETURN position('1' in sig) - 1;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_and( sig1 VARBIT, sig2 VARBIT ) RETURNS VARBIT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := GREATEST(length(sig1), length(sig2));
+  RETURN bitand(@extschema@.sig_resize(sig1, len), @extschema@.sig_resize(sig2, len)) ;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_or( sig1 VARBIT, sig2 VARBIT ) RETURNS VARBIT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := GREATEST(length(sig1), length(sig2));
+  RETURN bitor(@extschema@.sig_resize(sig1, len), @extschema@.sig_resize(sig2, len)) ;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.sig_xor( sig1 VARBIT, sig2 VARBIT ) RETURNS VARBIT AS $$
+DECLARE
+  len INT;
+BEGIN
+  len := GREATEST(length(sig1), length(sig2));
+  RETURN bitxor(@extschema@.sig_resize(sig1, len), @extschema@.sig_resize(sig2, len)) ;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.count( sig VARBIT ) RETURNS INT AS $$
+BEGIN
+  -- This is, by any measure, horrific. However, it appears to be the only 
+  -- way to use PostgreSQL built in functions to count bits in a bit string.
+  RETURN length(replace(sig::TEXT, '0', ''));
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.contains( sig VARBIT, pos INT ) RETURNS BOOL AS $$
+BEGIN
+  RETURN @extschema@.sig_get(sig, pos) = 1;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+CREATE FUNCTION @extschema@.members( sig VARBIT ) RETURNS SETOF INT AS $$
+BEGIN
+  FOR i IN 0 .. length(sig) - 1 LOOP
+    IF @extschema@.contains(sig, i) THEN
+      RETURN NEXT i;
+    END IF;
+  END LOOP;
+END $$ LANGUAGE plpgsql STRICT IMMUTABLE;
+
+
+-- operators for faceting
+
+CREATE OPERATOR @extschema@.& (
+    leftarg = VARBIT,
+    rightarg = VARBIT,
+    procedure = @extschema@.sig_and,
+    commutator = &
+);
+
+CREATE OPERATOR @extschema@.| (
+    leftarg = VARBIT,
+    rightarg = VARBIT,
+    procedure = @extschema@.sig_or,
+    commutator = |
+);
+
+CREATE OPERATOR @extschema@.+ (
+    leftarg = VARBIT,
+    rightarg = int,
+    procedure = @extschema@.sig_set
+);
+
+
+-- aggregate functions for faceting
+
+CREATE AGGREGATE @extschema@.collect( VARBIT )
+(
+	sfunc = @extschema@.sig_or,
+	stype = VARBIT
+);
+
+CREATE AGGREGATE @extschema@.filter( VARBIT )
+(
+   sfunc = @extschema@.sig_and,
+   stype = VARBIT
+);
+
+CREATE AGGREGATE @extschema@.signature( INT )
+(
+	sfunc = @extschema@.sig_set,
+  stype = VARBIT,
+  initcond = '0'
+);-- ============================================================================
+-- These functions are common to all bindings of the Repertoire faceting API
+--
+-- Christopher York
+-- MIT Hyperstudio
+-- February 2014
+-- ============================================================================
+
+
+-- Aggregator to measure how many bits from a loosely-packed id column would be wasted, if
+-- they were all collected into a bitset signature. Returns a float between 0 (no waste)
+-- and 1.0 (all waste). An example of its use:
+--
+-- SELECT wastage(id) FROM nobelists
+--  =# 0.999999
+--
+-- ALTER TABLE nobelists ADD COLUMN _packed_id SERIAL
+-- SELECT wastage(_packed_id) FROM nobelists
+--  =# 0.015625
+--
+CREATE FUNCTION @extschema@.wastage_proportion( state INT[] ) RETURNS double precision AS $$
+  SELECT (1.0 - (state[1]::double precision / (COALESCE(state[2], 0.0) + 1.0)))
+$$ LANGUAGE sql;
+
+CREATE FUNCTION @extschema@.wastage_accum( state INT[], val INT ) RETURNS INT[] AS $$
+  SELECT ARRAY[ state[1]+1, GREATEST(state[2], val) ];
+$$ LANGUAGE sql;
+
+CREATE AGGREGATE @extschema@.wastage( INT )
+(
+	sfunc = @extschema@.wastage_accum,
+	stype = INT[],
+	finalfunc = @extschema@.wastage_proportion,
+	initcond = '{0,0}'
+);

data/ext/signature/faceting.control

@@ -2,5 +2,5 @@
  
 comment = 'API for faceted indexing and queries (based on custom C bitmap type)'
 requires = plpgsql
-default_version = '0.7.2'
+default_version = '0.7.3'
 schema = 'facet'

data/ext/varbit/faceting_varbit.control

@@ -3,5 +3,5 @@
 comment = 'API for faceted indexing and queries (based on builtin VARBIT bit strings)'
 requires = plpgsql
 superuser = false
-default_version = '0.7.2'
+default_version = '0.7.3'
 schema = 'facet'

data/lib/assets/javascripts/rep.faceting/context.js

@@ -74,28 +74,6 @@ repertoire.facet_context = function(context_name, state_fn, options) {
     filter[facet] = filter[facet] || [];
   }
 
-  //
-  // Calculate facet value counts from webservice
-  //
-  // By default, the url is '/<context>/counts/<facet>'
-  //
-  self.counts = function(facet_name, callback, $elem) {
-    var url = self.facet_url('counts', facet_name);
-    // package up the faceting state and send back to results rendering service
-    self.fetch(self.params(), url, 'json', callback, $elem);
-  };
-
-  //
-  // Update query results from webservice
-  //
-  // By default, the url is '/<context>/counts/<facet>'
-  //
-  self.results = function(type, callback, $elem) {
-    var url = self.facet_url('results');
-    // package up the faceting state and send back to results rendering service
-    self.fetch(self.params(), url, type, callback, $elem);
-  };
-
   //
   // Convenience function for constructing faceting urls
   //

data/lib/assets/javascripts/rep.faceting/facet.js

@@ -46,13 +46,24 @@ repertoire.facet = function($facet, options) {
     // do not bubble event
     return false;
   });
+
+  //
+  // Calculate facet value counts from webservice
+  //
+  // By default, the url is '/<context>/counts/<facet>'
+  //
+  self.fetch = function(facet_name, callback, $elem) {
+    var context  = self.context();
+    var url = context.facet_url('counts', facet_name);
+    // package up the faceting state and send back to results rendering service
+    context.fetch(self.params(), url, 'json', callback, $elem);
+  };
   
   //
   // Ajax callback for facet value counts
   //
   self.reload = function(callback) {
-    var context  = self.context();
-    context.counts(self.facet_name(), callback, $facet);
+    self.fetch(self.facet_name(), callback, $facet);
   }
 
   //

data/lib/assets/javascripts/rep.faceting/facet_widget.js

@@ -58,6 +58,22 @@ repertoire.facet_widget = function($widget, options) {
     return options.context || self.context().name();
   };
 
+  self.state = function() {
+    if (options.state)
+      return options.state();
+    else return {};
+  }
+
+  //
+  // Return any extra params to send to the web-server.
+  //
+  // By default, params encompass all context state, plus any widget state.
+  //
+  self.params = function() {
+    var context = self.context();
+    return $.extend({}, context.params(), self.state());
+  };
+
   //
   // Capitalize and return a string
   //

data/lib/assets/javascripts/rep.faceting/results.js

@@ -25,14 +25,24 @@
 repertoire.results = function($results, options) {
   // inherit basic facet widget behaviour
   var self = repertoire.facet_widget($results, options);
-  
+
+  //
+  // Update query results from webservice
+  //
+  // By default, the url is '/<context>/counts/<facet>'
+  //
+  self.fetch = function(type, callback, $elem) {
+    var context  = self.context();
+    var url = context.facet_url('results');
+    // package up the faceting state and send back to results rendering service
+    context.fetch(self.params(), url, type, callback, $elem);
+  };
   
   //
   // Ajax callback for results
   //
   self.reload = function(callback) {
-    var context  = self.context();
-    context.results(options.type, callback, $results);
+    self.fetch(options.type, callback, $results);
   }
   
   //

data/lib/assets/javascripts/rep.widgets/model.js

@@ -70,7 +70,7 @@ repertoire.model = function(options) {
     if ($elem)
       $elem.addClass(spinnerClass);
 
-    $.ajax({
+    return $.ajax({
       async:    async,
       url:      url,
       data:     self.to_query_string(params),
@@ -80,8 +80,9 @@ repertoire.model = function(options) {
       /* beforeSend: function(xhr) { xhr.setRequestHeader("Accept", "application/json") } */
       success:  callback,
       error:    function(request, textStatus, errorThrown) {
-          if ($elem)
-            $elem.html(options.error || 'Could not load');
+        if ($elem) {
+          $elem.html(options.error || 'Could not load');
+        };
       },
       complete: function () {
           if ($elem)

data/lib/assets/javascripts/rep.widgets/widget.js

@@ -24,7 +24,7 @@
 //   error       - text to display if ajax load fails
 //   injectors   - additional jquery markup to inject into widget (see FAQ)
 //   handlers    - additional jquery event handlers to add to widget (see FAQ)
-//   state  - additional pre-processing for params sent to webservice (see FAQ)
+//   state       - additional pre-processing for params sent to webservice (see FAQ)
 //
 // Sub-classes are required to over-ride one method: self.render().  If you wish to
 // use a data model, store a subclass of rep.wigets/model in your widget.
@@ -32,11 +32,11 @@
 repertoire.widget = function(selector, options) {
   // this object is an abstract class
   var self    = {};
-  
+
   // private variables
   var $widget = $(selector);
   options     = options || {};
-  
+
   // mix in event handling functionality
   repertoire.events(self, $widget);
 
@@ -47,7 +47,9 @@ repertoire.widget = function(selector, options) {
       register_handlers(options.handlers);
 
     // load once at beginning
-    self.refresh();
+    if (! options.delay_loading) {
+      self.refresh();
+    };
   }
 
   //
@@ -64,21 +66,21 @@ repertoire.widget = function(selector, options) {
   self.refresh = function() {
     var callback,
         callbackStamp;
-    
+
     // pass to custom state processor
     if (options.state !== undefined)
       options.state(self);
 
     // adjust timestamp to most recent ajax call
     ajaxStamp = callbackStamp = Date.now();
-      
+
     callback = function() {
       // reject if this is an old ajax request
       if (callbackStamp < ajaxStamp) return;
 
       // render the widget
       var markup = self.render.apply(self, arguments);
-      
+
       // inject any custom markup
       if (options.injectors !== undefined)
         // TODO.  figure out how to send all args to injectors
@@ -105,7 +107,7 @@ repertoire.widget = function(selector, options) {
   //     };
   //
   // (2) If you just want to tweak the superclass' view:
-  // 
+  //
   //     var template_fn = self.render;            // idiom to access super.render()
   //     self.render = function() {
   //       var markup = template_fn();
@@ -118,8 +120,8 @@ repertoire.widget = function(selector, options) {
   self.render = function() {
     return $('<div class="rep"/>');      // namespace for all other widget css is 'rep'
   };
-  
-  
+
+
   //
   // A hook for use when your widget must render the results of an ajax callback.  Put
   // the ajax call in self.reload().  Its results will be passed to self.render().
@@ -155,7 +157,7 @@ repertoire.widget = function(selector, options) {
     event_selector = parse_event_selector(event_selector);
     var event    = event_selector[0],
         selector = event_selector[1];  // why doesn't JS support array decomposition?!?
-      
+
     // bind new handler
     $widget.bind(event, function (e) {
       var $el = $(e.target);
@@ -172,9 +174,9 @@ repertoire.widget = function(selector, options) {
       }
     });
   }
-  
+
   // PRIVATE
-  
+
   // register a collection of event handlers
   function register_handlers(handlers) {
     $.each(handlers, function(selector, handler) {
@@ -198,7 +200,7 @@ repertoire.widget = function(selector, options) {
       }
     });
   }
-  
+
   // parse an event name and selector spec
   function parse_event_selector(event_selector) {
     var s = event_selector.split('!');

data/lib/repertoire-faceting/version.rb

@@ -1,5 +1,5 @@
 module Repertoire
   module Faceting #:nodoc:
-    VERSION = "0.7.2"
+    VERSION = "0.7.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: repertoire-faceting
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Christopher York
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -83,8 +83,13 @@ files:
 - ext/bytea/faceting_bytea.control
 - ext/common/util.sql
 - ext/extconf.rb
+- ext/faceting--0.7.2.sql
+- ext/faceting_bytea--0.7.2.sql
+- ext/faceting_varbit--0.7.2.sql
 - ext/signature/faceting.control
 - ext/signature/signature.c
+- ext/signature/signature.o
+- ext/signature/signature.so
 - ext/signature/signature.sql
 - ext/varbit/faceting_varbit.control
 - ext/varbit/varbit.sql