Provided by: postgresql-client-8.0_8.0.7-2build1_i386 bug


       CREATE OPERATOR CLASS - define a new operator class


       CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type USING index_method AS
         {  OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ RECHECK ]
          | FUNCTION support_number funcname ( argument_type [, ...] )
          | STORAGE storage_type
         } [, ... ]


       CREATE  OPERATOR CLASS creates a new operator class.  An operator class
       defines how a particular data type can  be  used  with  an  index.  The
       operator  class  specifies  that certain operators will fill particular
       roles or ‘‘strategies’’ for this data type and this index  method.  The
       operator  class also specifies the support procedures to be used by the
       index method when the operator class is selected for an  index  column.
       All  the  operators  and  functions  used  by an operator class must be
       defined before the operator class is created.

       If a schema name is given then the operator class  is  created  in  the
       specified  schema.  Otherwise it is created in the current schema.  Two
       operator classes in the same schema can have the same name only if they
       are for different index methods.

       The  user  who  defines an operator class becomes its owner. Presently,
       the creating user must  be  a  superuser.  (This  restriction  is  made
       because  an  erroneous  operator class definition could confuse or even
       crash the server.)

       CREATE OPERATOR CLASS does not presently  check  whether  the  operator
       class  definition  includes all the operators and functions required by
       the index method. It is the user’s responsibility  to  define  a  valid
       operator class.

       Refer to the documentation for further information.


       name   The  name  of  the operator class to be created. The name may be

              If present, the operator class will become the default  operator
              class  for  its data type. At most one operator class can be the
              default for a specific data type and index method.

              The column data type that this operator class is for.

              The name of the index method this operator class is for.

              The index method’s strategy number for  an  operator  associated
              with the operator class.

              The name (optionally schema-qualified) of an operator associated
              with the operator class.

              The operand data type(s) of an operator, or NONE  to  signify  a
              left-unary  or  right-unary operator. The operand data types may
              be omitted in the normal case where they are  the  same  as  the
              operator class’s data type.

              If present, the index is ‘‘lossy’’ for this operator, and so the
              rows retrieved using the index must be rechecked to verify  that
              they  actually  satisfy  the qualification clause involving this

              The index method’s  support  procedure  number  for  a  function
              associated with the operator class.

              The  name (optionally schema-qualified) of a function that is an
              index method support procedure for the operator class.

              The parameter data type(s) of the function.

              The data type actually stored in the index. Normally this is the
              same  as the column data type, but some index methods (only GiST
              at this writing) allow it to be different.  The  STORAGE  clause
              must  be omitted unless the index method allows a different type
              to be used.

       The OPERATOR, FUNCTION, and STORAGE clauses may appear in any order.


       The operators should not be defined by SQL functions. A SQL function is
       likely  to  be  inlined  into the calling query, which will prevent the
       optimizer from recognizing that the query matches an index.


       The following example command defines a GiST index operator  class  for
       the  data  type  _int4  (array  of int4). See contrib/intarray/ for the
       complete example.

       CREATE OPERATOR CLASS gist__int_ops
           DEFAULT FOR TYPE _int4 USING gist AS
               OPERATOR        3       &&,
               OPERATOR        6       =       RECHECK,
               OPERATOR        7       @,
               OPERATOR        8       ~,
               OPERATOR        20      @@ (_int4, query_int),
               FUNCTION        1       g_int_consistent (internal, _int4, int4),
               FUNCTION        2       g_int_union (bytea, internal),
               FUNCTION        3       g_int_compress (internal),
               FUNCTION        4       g_int_decompress (internal),
               FUNCTION        5       g_int_penalty (internal, internal, internal),
               FUNCTION        6       g_int_picksplit (internal, internal),
               FUNCTION        7       g_int_same (_int4, _int4, internal);


       CREATE OPERATOR CLASS is a PostgreSQL extension.  There  is  no  CREATE
       OPERATOR CLASS statement in the SQL standard.


       ALTER  OPERATOR  CLASS  [alter_operator_class(7)],  DROP OPERATOR CLASS