anchor.diff:  (defun get-author-id (author atype)
     (case atype
       (:id (when (exists (select (colm 'author 'id)
  -				:where (sql-= (colm 'author 'id)
  -					      (parse-integer author))))
  -	    (parse-integer author)))
  +                               :where (sql-= (colm 'author 'id)
  +                                             (parse-integer author))))
  +           (parse-integer author)))
       (:string
        (get-local-user-id author))
       ((or :homepage :email)
        (awhen (select (colm 'id) :from 'author
  -		    :where (sql-and (sql-= (colm 'type) atype)
  -				    (sql-= (colm 'value) author)) :flatp t)
  -       (car it)))))
  +                               :where (sql-and (sql-= (colm 'type) atype)
  +                                               (sql-= (colm 'value) author))
  +                               :flatp t)
  +            (car it)))))
   
   (defun insert-new-author (atype value)
     (let ((aid (next-val "author_id_seq"))
  -	(atype (kebab:to-snake-case (mkstr atype))))
  +        (atype (kebab:to-snake-case (mkstr atype))))
       (insert-records :into 'author
  -		    :attributes '(:id :type :value)
  -		    :values (list aid atype value))
  +                    :attributes '(:id :type :value)
  +                    :values (list aid atype value))
       aid))
  +
  +(def-query user-lister (&key limit offset order-by)
  +  (mapcar #'car
  +          (query-marker
  +           (merge-query
  +            (select (colm 'value) :from (tabl 'author)
  +                                  :where (sql-= (colm 'type) "wf_user"))
  +            (order-by-mixin order-by)
  +            (limit-mixin limit offset)))))
   
   (defun make-user-url (username)
     (strcat *base-url* "u/" username "/"))
  
positive.code: (defun opinion-from-db-row (row)
    (let ((res (alist->hash row)))
      (with-keys (:id :author :flag :votevalue :target :datestamp :url
  		    :comment :reference)
  	res
        (let ((authdata (get-author-data author)))
  	(setf author (cdr (or (assoc :wf-user authdata) 
  			      (assoc :homepage authdata)
  			      (assoc :email authdata) 
  			      (error "Can't find author")))))
        (setf flag
  	    (mapcar #'keywordize-foreign (split-sequence #\  flag)))
        (setf comment (car (col-from-pkey (colm 'comment 'comment) id)))
        (setf reference (car (col-from-pkey (colm 'reference 'reference) id))))
      (concatenate 'list
  		 (get-excerpt-data (gethash :id res))
  		 (hash->alist res))))
  
  (defun opinion-from-id (oid)
    (opinion-from-db-row (get-assoc-by-pkey 'opinion oid)))
  
  (def-query get-opinion-peers (o-url)
    (mapcar 
     #'car
     (query-marker
      (select (colm 'id) :from 'opinion
  	    :where
  	    (sql-= (colm 'target) 
  		   (sql-query (colm 'target) :from (tabl 'opinion)
  			      :where (sql-= (colm 'url) o-url)))))))
  
  
  (defun get-local-user-id (user)
    (let ((res (select (colm 'author 'id) :from (tabl 'author)
  		     :where (sql-and
  			     (sql-= (colm 'author 'type) "wf_user")
  			     (sql-= (colm 'author 'value) user)) :flatp t)))
      (when (< 1 (length res))
        (error "Integrity Breach in the author table!"))
      (car res)))
      
  (defun author-type (author)
    (cond 
      ((integerp author) :id)
      ((starts-with "http" author) :homepage)
      ((starts-with "mailto" author) :email)
  
negative.code: (defun opinion-tree-for-target (turl)
    (if (rooturl-p turl)
        (opinion-tree-for-rooturl turl)
        (tree-by-feature
         (merge-query
          (opinion-ids-for-rooturl (get-rooturl-for-url turl))
          (select (colm 'opinion 'target)
                  (colm 'opinion 'url)))
         #'second
         :root turl
         :format #'car
  