anchor.diff:  (define-op (:not unary-op))
   (define-op (:is-null unary-op))
   (define-op (:not-null unary-op))
  -(define-op (:desc unary-postfix-op))
  -(define-op (:asc unary-postfix-op))
  +(defstruct (order-op (:include unary-postfix-op (name)))
  +  (nulls nil :type (or null (member :last :first))))
  +(defstruct (desc-op (:include order-op (name "DESC"))
  +                    (:constructor make-desc-op (var &key nulls))))
  +(defstruct (asc-op (:include order-op (name "ASC"))
  +                   (:constructor make-asc-op (var &key nulls))))
   (define-op (:distinct unary-splicing-op))
   (defstruct (on-op (:include sql-op (name "ON"))
                     (:constructor make-on-op (var)))
  
positive.code:           (apply #'make-function-op (symbol-name op-name) expressions))))
  
  @export
  (defun make-op (op-name &rest args)
    (apply (find-make-op op-name #.*package*)
           (mapcar #'detect-and-convert args)))
  
  (defun has-lower-case-letters-p (symbol)
    "Take in a symbol, convert to string, look for presences of lower
  
negative.code:                   (not-null-op-var op)
                    (make-sql-keyword "NULL"))))
  
  (defmethod yield ((op order-op))
    (multiple-value-bind (sql binds)
        (call-next-method)
      (values
        (format nil "~A~@[ NULLS ~A~]" sql (order-op-nulls op))
        binds)))
  
  (defmethod yield ((raw raw-op))
    (values
     (format nil "(~A)"
  