parse_oper.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
#include "lib/stringinfo.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for parse_oper.c:

Go to the source code of this file.

Data Structures
struct	OprCacheKey
struct	OprCacheEntry

Macros
#define	MAX_CACHED_PATH_LEN   16

Typedefs
typedef struct OprCacheKey	OprCacheKey
typedef struct OprCacheEntry	OprCacheEntry

Functions
static Oid	binary_oper_exact (List *opname, Oid arg1, Oid arg2)
static FuncDetailCode	oper_select_candidate (int nargs, Oid *input_typeids, FuncCandidateList candidates, Oid *operOid)
static void	op_error (ParseState *pstate, List *op, Oid arg1, Oid arg2, FuncDetailCode fdresult, int fgc_flags, int location)
static int	oper_lookup_failure_details (int fgc_flags, bool is_unary_op)
static bool	make_oper_cache_key (ParseState *pstate, OprCacheKey *key, List *opname, Oid ltypeId, Oid rtypeId, int location)
static Oid	find_oper_cache_entry (OprCacheKey *key)
static void	make_oper_cache_entry (OprCacheKey *key, Oid opr_oid)
static void	InvalidateOprCacheCallBack (Datum arg, SysCacheIdentifier cacheid, uint32 hashvalue)
Oid	LookupOperName (ParseState *pstate, List *opername, Oid oprleft, Oid oprright, bool noError, int location)
Oid	LookupOperWithArgs (ObjectWithArgs *oper, bool noError)
void	get_sort_group_operators (Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
Oid	oprid (Operator op)
Oid	oprfuncid (Operator op)
Operator	oper (ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Operator	compatible_oper (ParseState *pstate, List *op, Oid arg1, Oid arg2, bool noError, int location)
Oid	compatible_oper_opid (List *op, Oid arg1, Oid arg2, bool noError)
Operator	left_oper (ParseState *pstate, List *op, Oid arg, bool noError, int location)
const char *	op_signature_string (List *op, Oid arg1, Oid arg2)
Expr *	make_op (ParseState *pstate, List *opname, Node *ltree, Node *rtree, Node *last_srf, int location)
Expr *	make_scalar_array_op (ParseState *pstate, List *opname, bool useOr, Node *ltree, Node *rtree, int location)

Variables
static HTAB *	OprCacheHash = NULL

Macro Definition Documentation

MAX_CACHED_PATH_LEN

#define MAX_CACHED_PATH_LEN   16

Definition at line 50 of file parse_oper.c.

Typedef Documentation

OprCacheEntry

typedef struct OprCacheEntry OprCacheEntry

OprCacheKey

typedef struct OprCacheKey OprCacheKey

Function Documentation

binary_oper_exact()

static Oid binary_oper_exact ( List *  opname, Oid  arg1, Oid  arg2  )

static

Definition at line 266 of file parse_oper.c.

{
    Oid         result;
    bool        was_unknown = false;
 
    /* Unspecified type for one of the arguments? then use the other */
    if ((arg1 == UNKNOWNOID) && (arg2 != InvalidOid))
    {
        arg1 = arg2;
        was_unknown = true;
    }
    else if ((arg2 == UNKNOWNOID) && (arg1 != InvalidOid))
    {
        arg2 = arg1;
        was_unknown = true;
    }
 
    result = OpernameGetOprid(opname, arg1, arg2);
    if (OidIsValid(result))
        return result;
 
    if (was_unknown)
    {
        /* arg1 and arg2 are the same here, need only look at arg1 */
        Oid         basetype = getBaseType(arg1);
 
        if (basetype != arg1)
        {
            result = OpernameGetOprid(opname, basetype, basetype);
            if (OidIsValid(result))
                return result;
        }
    }
 
    return InvalidOid;
}

References fb(), getBaseType(), InvalidOid, OidIsValid, OpernameGetOprid(), and result.

Referenced by oper().

compatible_oper()

Operator compatible_oper	(	ParseState *	pstate,
		List *	op,
		Oid	arg1,
		Oid	arg2,
		bool	noError,
		int	location
	)

Definition at line 459 of file parse_oper.c.

{
    Operator    optup;
    Form_pg_operator opform;
 
    /* oper() will find the best available match */
    optup = oper(pstate, op, arg1, arg2, noError, location);
    if (optup == (Operator) NULL)
        return (Operator) NULL; /* must be noError case */
 
    /* but is it good enough? */
    opform = (Form_pg_operator) GETSTRUCT(optup);
    if (IsBinaryCoercible(arg1, opform->oprleft) &&
        IsBinaryCoercible(arg2, opform->oprright))
        return optup;
 
    /* nope... */
    ReleaseSysCache(optup);
 
    if (!noError)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator requires run-time type coercion: %s",
                        op_signature_string(op, arg1, arg2)),
                 parser_errposition(pstate, location)));
 
    return (Operator) NULL;
}

References ereport, errcode(), errmsg, ERROR, fb(), Form_pg_operator, GETSTRUCT(), IsBinaryCoercible(), op_signature_string(), oper(), parser_errposition(), and ReleaseSysCache().

Referenced by compatible_oper_opid().

compatible_oper_opid()

Oid compatible_oper_opid	(	List *	op,
		Oid	arg1,
		Oid	arg2,
		bool	noError
	)

Definition at line 497 of file parse_oper.c.

{
    Operator    optup;
    Oid         result;
 
    optup = compatible_oper(NULL, op, arg1, arg2, noError, -1);
    if (optup != NULL)
    {
        result = oprid(optup);
        ReleaseSysCache(optup);
        return result;
    }
    return InvalidOid;
}

References compatible_oper(), fb(), InvalidOid, oprid(), ReleaseSysCache(), and result.

Referenced by addTargetToSortList(), and ComputeIndexAttrs().

find_oper_cache_entry()

static Oid find_oper_cache_entry ( OprCacheKey *  key )

static

Definition at line 1032 of file parse_oper.c.

{
    OprCacheEntry *oprentry;
 
    if (OprCacheHash == NULL)
    {
        /* First time through: initialize the hash table */
        HASHCTL     ctl;
 
        ctl.keysize = sizeof(OprCacheKey);
        ctl.entrysize = sizeof(OprCacheEntry);
        OprCacheHash = hash_create("Operator lookup cache", 256,
                                   &ctl, HASH_ELEM | HASH_BLOBS);
 
        /* Arrange to flush cache on pg_operator and pg_cast changes */
        CacheRegisterSyscacheCallback(OPERNAMENSP,
                                      InvalidateOprCacheCallBack,
                                      (Datum) 0);
        CacheRegisterSyscacheCallback(CASTSOURCETARGET,
                                      InvalidateOprCacheCallBack,
                                      (Datum) 0);
    }
 
    /* Look for an existing entry */
    oprentry = (OprCacheEntry *) hash_search(OprCacheHash,
                                             key,
                                             HASH_FIND, NULL);
    if (oprentry == NULL)
        return InvalidOid;
 
    return oprentry->opr_oid;
}

References CacheRegisterSyscacheCallback(), ctl, fb(), HASH_BLOBS, hash_create(), HASH_ELEM, HASH_FIND, hash_search(), InvalidateOprCacheCallBack(), InvalidOid, HASHCTL::keysize, and OprCacheHash.

Referenced by left_oper(), and oper().

get_sort_group_operators()

void get_sort_group_operators	(	Oid	argtype,
		bool	needLT,
		bool	needEQ,
		bool	needGT,
		Oid *	ltOpr,
		Oid *	eqOpr,
		Oid *	gtOpr,
		bool *	isHashable
	)

Definition at line 183 of file parse_oper.c.

{
    TypeCacheEntry *typentry;
    int         cache_flags;
    Oid         lt_opr;
    Oid         eq_opr;
    Oid         gt_opr;
    bool        hashable;
 
    /*
     * Look up the operators using the type cache.
     *
     * Note: the search algorithm used by typcache.c ensures that the results
     * are consistent, ie all from matching opclasses.
     */
    if (isHashable != NULL)
        cache_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR |
            TYPECACHE_HASH_PROC;
    else
        cache_flags = TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR;
 
    typentry = lookup_type_cache(argtype, cache_flags);
    lt_opr = typentry->lt_opr;
    eq_opr = typentry->eq_opr;
    gt_opr = typentry->gt_opr;
    hashable = OidIsValid(typentry->hash_proc);
 
    /* Report errors if needed */
    if ((needLT && !OidIsValid(lt_opr)) ||
        (needGT && !OidIsValid(gt_opr)))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("could not identify an ordering operator for type %s",
                        format_type_be(argtype)),
                 errhint("Use an explicit ordering operator or modify the query.")));
    if (needEQ && !OidIsValid(eq_opr))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("could not identify an equality operator for type %s",
                        format_type_be(argtype))));
 
    /* Return results as needed */
    if (ltOpr)
        *ltOpr = lt_opr;
    if (eqOpr)
        *eqOpr = eq_opr;
    if (gtOpr)
        *gtOpr = gt_opr;
    if (isHashable)
        *isHashable = hashable;
}

References TypeCacheEntry::eq_opr, ereport, errcode(), errhint(), errmsg, ERROR, fb(), format_type_be(), TypeCacheEntry::gt_opr, TypeCacheEntry::hash_proc, lookup_type_cache(), TypeCacheEntry::lt_opr, OidIsValid, TYPECACHE_EQ_OPR, TYPECACHE_GT_OPR, TYPECACHE_HASH_PROC, and TYPECACHE_LT_OPR.

Referenced by addTargetToGroupList(), addTargetToSortList(), init_grouping_targets(), makeSortGroupClauseForSetOp(), and std_typanalyze().

InvalidateOprCacheCallBack()

static void InvalidateOprCacheCallBack ( Datum  arg, SysCacheIdentifier  cacheid, uint32  hashvalue  )

static

Definition at line 1087 of file parse_oper.c.

{
    HASH_SEQ_STATUS status;
    OprCacheEntry *hentry;
 
    Assert(OprCacheHash != NULL);
 
    /* Currently we just flush all entries; hard to be smarter ... */
    hash_seq_init(&status, OprCacheHash);
 
    while ((hentry = (OprCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        if (hash_search(OprCacheHash,
                        &hentry->key,
                        HASH_REMOVE, NULL) == NULL)
            elog(ERROR, "hash table corrupted");
    }
}

References Assert, elog, ERROR, fb(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), and OprCacheHash.

Referenced by find_oper_cache_entry().

left_oper()

Operator left_oper	(	ParseState *	pstate,
		List *	op,
		Oid	arg,
		bool	noError,
		int	location
	)

Definition at line 529 of file parse_oper.c.

{
    Oid         operOid;
    OprCacheKey key;
    bool        key_ok;
    int         fgc_flags = 0;
    FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;
    HeapTuple   tup = NULL;
 
    /*
     * Try to find the mapping in the lookaside cache.
     */
    key_ok = make_oper_cache_key(pstate, &key, op, InvalidOid, arg, location);
 
    if (key_ok)
    {
        operOid = find_oper_cache_entry(&key);
        if (OidIsValid(operOid))
        {
            tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
            if (HeapTupleIsValid(tup))
                return (Operator) tup;
        }
    }
 
    /*
     * First try for an "exact" match.
     */
    operOid = OpernameGetOprid(op, InvalidOid, arg);
    if (!OidIsValid(operOid))
    {
        /*
         * Otherwise, search for the most suitable candidate.
         */
        FuncCandidateList clist;
 
        /* Get prefix operators of given name */
        clist = OpernameGetCandidates(op, 'l', false, &fgc_flags);
 
        /* No operators found? Then fail... */
        if (clist != NULL)
        {
            /*
             * The returned list has args in the form (0, oprright). Move the
             * useful data into args[0] to keep oper_select_candidate simple.
             * XXX we are assuming here that we may scribble on the list!
             */
            FuncCandidateList clisti;
 
            for (clisti = clist; clisti != NULL; clisti = clisti->next)
            {
                clisti->args[0] = clisti->args[1];
            }
 
            /*
             * We must run oper_select_candidate even if only one candidate,
             * otherwise we may falsely return a non-type-compatible operator.
             */
            fdresult = oper_select_candidate(1, &arg, clist, &operOid);
        }
    }
 
    if (OidIsValid(operOid))
        tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
 
    if (HeapTupleIsValid(tup))
    {
        if (key_ok)
            make_oper_cache_entry(&key, operOid);
    }
    else if (!noError)
        op_error(pstate, op, InvalidOid, arg,
                 fdresult, fgc_flags, location);
 
    return (Operator) tup;
}

References arg, _FuncCandidateList::args, fb(), find_oper_cache_entry(), FUNCDETAIL_NOTFOUND, HeapTupleIsValid, InvalidOid, make_oper_cache_entry(), make_oper_cache_key(), ObjectIdGetDatum(), OidIsValid, op_error(), oper_select_candidate(), OpernameGetCandidates(), OpernameGetOprid(), and SearchSysCache1().

Referenced by generate_operator_name(), and make_op().

LookupOperName()

Oid LookupOperName	(	ParseState *	pstate,
		List *	opername,
		Oid	oprleft,
		Oid	oprright,
		bool	noError,
		int	location
	)

Definition at line 102 of file parse_oper.c.

{
    Oid         result;
 
    result = OpernameGetOprid(opername, oprleft, oprright);
    if (OidIsValid(result))
        return result;
 
    /* we don't use op_error here because only an exact match is wanted */
    if (!noError)
    {
        if (!OidIsValid(oprright))
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("postfix operators are not supported"),
                     parser_errposition(pstate, location)));
 
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator does not exist: %s",
                        op_signature_string(opername, oprleft, oprright)),
                 parser_errposition(pstate, location)));
    }
 
    return InvalidOid;
}

References ereport, errcode(), errmsg, ERROR, fb(), InvalidOid, OidIsValid, op_signature_string(), OpernameGetOprid(), parser_errposition(), and result.

Referenced by AggregateCreate(), DefineOpClass(), LookupOperWithArgs(), and OperatorLookup().

LookupOperWithArgs()

Oid LookupOperWithArgs	(	ObjectWithArgs *	oper,
		bool	noError
	)

Definition at line 136 of file parse_oper.c.

{
    TypeName   *oprleft,
               *oprright;
    Oid         leftoid,
                rightoid;
 
    Assert(list_length(oper->objargs) == 2);
    oprleft = linitial_node(TypeName, oper->objargs);
    oprright = lsecond_node(TypeName, oper->objargs);
 
    if (oprleft == NULL)
        leftoid = InvalidOid;
    else
        leftoid = LookupTypeNameOid(NULL, oprleft, noError);
 
    if (oprright == NULL)
        rightoid = InvalidOid;
    else
        rightoid = LookupTypeNameOid(NULL, oprright, noError);
 
    return LookupOperName(NULL, oper->objname, leftoid, rightoid,
                          noError, -1);
}

References Assert, fb(), InvalidOid, linitial_node, list_length(), LookupOperName(), LookupTypeNameOid(), lsecond_node, and oper().

Referenced by AlterOperator(), AlterOpFamilyAdd(), DefineOpClass(), and get_object_address().

make_op()

Expr * make_op	(	ParseState *	pstate,
		List *	opname,
		Node *	ltree,
		Node *	rtree,
		Node *	last_srf,
		int	location
	)

Definition at line 711 of file parse_oper.c.

{
    Oid         ltypeId,
                rtypeId;
    Operator    tup;
    Form_pg_operator opform;
    Oid         actual_arg_types[2];
    Oid         declared_arg_types[2];
    int         nargs;
    List       *args;
    Oid         rettype;
    OpExpr     *result;
 
    /* Check it's not a postfix operator */
    if (rtree == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("postfix operators are not supported")));
 
    /* Select the operator */
    if (ltree == NULL)
    {
        /* prefix operator */
        rtypeId = exprType(rtree);
        ltypeId = InvalidOid;
        tup = left_oper(pstate, opname, rtypeId, false, location);
    }
    else
    {
        /* otherwise, binary operator */
        ltypeId = exprType(ltree);
        rtypeId = exprType(rtree);
        tup = oper(pstate, opname, ltypeId, rtypeId, false, location);
    }
 
    opform = (Form_pg_operator) GETSTRUCT(tup);
 
    /* Check it's not a shell */
    if (!RegProcedureIsValid(opform->oprcode))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator is only a shell: %s",
                        op_signature_string(opname,
                                            opform->oprleft,
                                            opform->oprright)),
                 parser_errposition(pstate, location)));
 
    /* Do typecasting and build the expression tree */
    if (ltree == NULL)
    {
        /* prefix operator */
        args = list_make1(rtree);
        actual_arg_types[0] = rtypeId;
        declared_arg_types[0] = opform->oprright;
        nargs = 1;
    }
    else
    {
        /* otherwise, binary operator */
        args = list_make2(ltree, rtree);
        actual_arg_types[0] = ltypeId;
        actual_arg_types[1] = rtypeId;
        declared_arg_types[0] = opform->oprleft;
        declared_arg_types[1] = opform->oprright;
        nargs = 2;
    }
 
    /*
     * enforce consistency with polymorphic argument and return types,
     * possibly adjusting return type or declared_arg_types (which will be
     * used as the cast destination by make_fn_arguments)
     */
    rettype = enforce_generic_type_consistency(actual_arg_types,
                                               declared_arg_types,
                                               nargs,
                                               opform->oprresult,
                                               false);
 
    /* perform the necessary typecasting of arguments */
    make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
 
    /* and build the expression node */
    result = makeNode(OpExpr);
    result->opno = oprid(tup);
    result->opfuncid = opform->oprcode;
    result->opresulttype = rettype;
    result->opretset = get_func_retset(opform->oprcode);
    /* opcollid and inputcollid will be set by parse_collate.c */
    result->args = args;
    result->location = location;
 
    /* if it returns a set, check that's OK */
    if (result->opretset)
    {
        check_srf_call_placement(pstate, last_srf, location);
        /* ... and remember it for error checks at higher levels */
        pstate->p_last_srf = (Node *) result;
    }
 
    ReleaseSysCache(tup);
 
    return (Expr *) result;
}

References check_srf_call_placement(), enforce_generic_type_consistency(), ereport, errcode(), errmsg, ERROR, exprType(), fb(), Form_pg_operator, get_func_retset(), GETSTRUCT(), InvalidOid, left_oper(), list_make1, list_make2, make_fn_arguments(), makeNode, op_signature_string(), oper(), oprid(), ParseState::p_last_srf, parser_errposition(), RegProcedureIsValid, ReleaseSysCache(), and result.

Referenced by make_distinct_op(), make_row_comparison_op(), transformAExprIn(), transformAExprNullIf(), and transformAExprOp().

make_oper_cache_entry()

static void make_oper_cache_entry ( OprCacheKey *  key, Oid  opr_oid  )

static

Definition at line 1071 of file parse_oper.c.

{
    OprCacheEntry *oprentry;
 
    Assert(OprCacheHash != NULL);
 
    oprentry = (OprCacheEntry *) hash_search(OprCacheHash,
                                             key,
                                             HASH_ENTER, NULL);
    oprentry->opr_oid = opr_oid;
}

References Assert, fb(), HASH_ENTER, hash_search(), and OprCacheHash.

Referenced by left_oper(), and oper().

make_oper_cache_key()

static bool make_oper_cache_key ( ParseState *  pstate, OprCacheKey *  key, List *  opname, Oid  ltypeId, Oid  rtypeId, int  location  )

static

Definition at line 988 of file parse_oper.c.

{
    char       *schemaname;
    char       *opername;
 
    /* deconstruct the name list */
    DeconstructQualifiedName(opname, &schemaname, &opername);
 
    /* ensure zero-fill for stable hashing */
    MemSet(key, 0, sizeof(OprCacheKey));
 
    /* save operator name and input types into key */
    strlcpy(key->oprname, opername, NAMEDATALEN);
    key->left_arg = ltypeId;
    key->right_arg = rtypeId;
 
    if (schemaname)
    {
        ParseCallbackState pcbstate;
 
        /* search only in exact schema given */
        setup_parser_errposition_callback(&pcbstate, pstate, location);
        key->search_path[0] = LookupExplicitNamespace(schemaname, false);
        cancel_parser_errposition_callback(&pcbstate);
    }
    else
    {
        /* get the active search path */
        if (fetch_search_path_array(key->search_path,
                                    MAX_CACHED_PATH_LEN) > MAX_CACHED_PATH_LEN)
            return false;       /* oops, didn't fit */
    }
 
    return true;
}

References cancel_parser_errposition_callback(), DeconstructQualifiedName(), fb(), fetch_search_path_array(), LookupExplicitNamespace(), MAX_CACHED_PATH_LEN, MemSet, NAMEDATALEN, setup_parser_errposition_callback(), and strlcpy().

Referenced by left_oper(), and oper().

make_scalar_array_op()

Expr * make_scalar_array_op	(	ParseState *	pstate,
		List *	opname,
		bool	useOr,
		Node *	ltree,
		Node *	rtree,
		int	location
	)

Definition at line 821 of file parse_oper.c.

{
    Oid         ltypeId,
                rtypeId,
                atypeId,
                res_atypeId;
    Operator    tup;
    Form_pg_operator opform;
    Oid         actual_arg_types[2];
    Oid         declared_arg_types[2];
    List       *args;
    Oid         rettype;
    ScalarArrayOpExpr *result;
 
    ltypeId = exprType(ltree);
    atypeId = exprType(rtree);
 
    /*
     * The right-hand input of the operator will be the element type of the
     * array.  However, if we currently have just an untyped literal on the
     * right, stay with that and hope we can resolve the operator.
     */
    if (atypeId == UNKNOWNOID)
        rtypeId = UNKNOWNOID;
    else
    {
        rtypeId = get_base_element_type(atypeId);
        if (!OidIsValid(rtypeId))
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("op ANY/ALL (array) requires array on right side"),
                     parser_errposition(pstate, location)));
    }
 
    /* Now resolve the operator */
    tup = oper(pstate, opname, ltypeId, rtypeId, false, location);
    opform = (Form_pg_operator) GETSTRUCT(tup);
 
    /* Check it's not a shell */
    if (!RegProcedureIsValid(opform->oprcode))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator is only a shell: %s",
                        op_signature_string(opname,
                                            opform->oprleft,
                                            opform->oprright)),
                 parser_errposition(pstate, location)));
 
    args = list_make2(ltree, rtree);
    actual_arg_types[0] = ltypeId;
    actual_arg_types[1] = rtypeId;
    declared_arg_types[0] = opform->oprleft;
    declared_arg_types[1] = opform->oprright;
 
    /*
     * enforce consistency with polymorphic argument and return types,
     * possibly adjusting return type or declared_arg_types (which will be
     * used as the cast destination by make_fn_arguments)
     */
    rettype = enforce_generic_type_consistency(actual_arg_types,
                                               declared_arg_types,
                                               2,
                                               opform->oprresult,
                                               false);
 
    /*
     * Check that operator result is boolean
     */
    if (rettype != BOOLOID)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("op ANY/ALL (array) requires operator to yield boolean"),
                 parser_errposition(pstate, location)));
    if (get_func_retset(opform->oprcode))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("op ANY/ALL (array) requires operator not to return a set"),
                 parser_errposition(pstate, location)));
 
    /*
     * Now switch back to the array type on the right, arranging for any
     * needed cast to be applied.  Beware of polymorphic operators here;
     * enforce_generic_type_consistency may or may not have replaced a
     * polymorphic type with a real one.
     */
    if (IsPolymorphicType(declared_arg_types[1]))
    {
        /* assume the actual array type is OK */
        res_atypeId = atypeId;
    }
    else
    {
        res_atypeId = get_array_type(declared_arg_types[1]);
        if (!OidIsValid(res_atypeId))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("could not find array type for data type %s",
                            format_type_be(declared_arg_types[1])),
                     parser_errposition(pstate, location)));
    }
    actual_arg_types[1] = atypeId;
    declared_arg_types[1] = res_atypeId;
 
    /* perform the necessary typecasting of arguments */
    make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
 
    /* and build the expression node */
    result = makeNode(ScalarArrayOpExpr);
    result->opno = oprid(tup);
    result->opfuncid = opform->oprcode;
    result->hashfuncid = InvalidOid;
    result->negfuncid = InvalidOid;
    result->useOr = useOr;
    /* inputcollid will be set by parse_collate.c */
    result->args = args;
    result->location = location;
 
    ReleaseSysCache(tup);
 
    return (Expr *) result;
}

References enforce_generic_type_consistency(), ereport, errcode(), errmsg, ERROR, exprType(), fb(), Form_pg_operator, format_type_be(), get_array_type(), get_base_element_type(), get_func_retset(), GETSTRUCT(), InvalidOid, list_make2, make_fn_arguments(), makeNode, OidIsValid, op_signature_string(), oper(), oprid(), parser_errposition(), RegProcedureIsValid, ReleaseSysCache(), and result.

Referenced by transformAExprIn(), transformAExprOpAll(), and transformAExprOpAny().

op_error()

static void op_error ( ParseState *  pstate, List *  op, Oid  arg1, Oid  arg2, FuncDetailCode  fdresult, int  fgc_flags, int  location  )

static

Definition at line 635 of file parse_oper.c.

{
    if (fdresult == FUNCDETAIL_MULTIPLE)
        ereport(ERROR,
                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                 errmsg("operator is not unique: %s",
                        op_signature_string(op, arg1, arg2)),
                 errdetail("Could not choose a best candidate operator."),
                 errhint("You might need to add explicit type casts."),
                 parser_errposition(pstate, location)));
    else
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator does not exist: %s",
                        op_signature_string(op, arg1, arg2)),
                 oper_lookup_failure_details(fgc_flags, (!arg1 || !arg2)),
                 parser_errposition(pstate, location)));
}

References ereport, errcode(), errdetail(), errhint(), errmsg, ERROR, fb(), FUNCDETAIL_MULTIPLE, op_signature_string(), oper_lookup_failure_details(), and parser_errposition().

Referenced by left_oper(), and oper().

op_signature_string()

const char * op_signature_string	(	List *	op,
		Oid	arg1,
		Oid	arg2
	)

Definition at line 615 of file parse_oper.c.

{
    StringInfoData argbuf;
 
    initStringInfo(&argbuf);
 
    if (OidIsValid(arg1))
        appendStringInfo(&argbuf, "%s ", format_type_be(arg1));
 
    appendStringInfoString(&argbuf, NameListToString(op));
 
    appendStringInfo(&argbuf, " %s", format_type_be(arg2));
 
    return argbuf.data;         /* return palloc'd string buffer */
}

References appendStringInfo(), appendStringInfoString(), fb(), format_type_be(), initStringInfo(), NameListToString(), and OidIsValid.

Referenced by compatible_oper(), LookupOperName(), make_op(), make_scalar_array_op(), op_error(), and ValidateOperatorReference().

oper()

Operator oper	(	ParseState *	pstate,
		List *	opname,
		Oid	ltypeId,
		Oid	rtypeId,
		bool	noError,
		int	location
	)

Definition at line 376 of file parse_oper.c.

{
    Oid         operOid;
    OprCacheKey key;
    bool        key_ok;
    int         fgc_flags = 0;
    FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;
    HeapTuple   tup = NULL;
 
    /*
     * Try to find the mapping in the lookaside cache.
     */
    key_ok = make_oper_cache_key(pstate, &key, opname, ltypeId, rtypeId, location);
 
    if (key_ok)
    {
        operOid = find_oper_cache_entry(&key);
        if (OidIsValid(operOid))
        {
            tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
            if (HeapTupleIsValid(tup))
                return (Operator) tup;
        }
    }
 
    /*
     * First try for an "exact" match.
     */
    operOid = binary_oper_exact(opname, ltypeId, rtypeId);
    if (!OidIsValid(operOid))
    {
        /*
         * Otherwise, search for the most suitable candidate.
         */
        FuncCandidateList clist;
 
        /* Get binary operators of given name */
        clist = OpernameGetCandidates(opname, 'b', false, &fgc_flags);
 
        /* No operators found? Then fail... */
        if (clist != NULL)
        {
            /*
             * Unspecified type for one of the arguments? then use the other
             * (XXX this is probably dead code?)
             */
            Oid         inputOids[2];
 
            if (rtypeId == InvalidOid)
                rtypeId = ltypeId;
            else if (ltypeId == InvalidOid)
                ltypeId = rtypeId;
            inputOids[0] = ltypeId;
            inputOids[1] = rtypeId;
            fdresult = oper_select_candidate(2, inputOids, clist, &operOid);
        }
    }
 
    if (OidIsValid(operOid))
        tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
 
    if (HeapTupleIsValid(tup))
    {
        if (key_ok)
            make_oper_cache_entry(&key, operOid);
    }
    else if (!noError)
        op_error(pstate, opname, ltypeId, rtypeId,
                 fdresult, fgc_flags, location);
 
    return (Operator) tup;
}

References binary_oper_exact(), fb(), find_oper_cache_entry(), FUNCDETAIL_NOTFOUND, HeapTupleIsValid, InvalidOid, make_oper_cache_entry(), make_oper_cache_key(), ObjectIdGetDatum(), OidIsValid, op_error(), oper_select_candidate(), OpernameGetCandidates(), and SearchSysCache1().

Referenced by compatible_oper(), Do_MultiXactIdWait(), generate_operator_name(), LookupOperWithArgs(), make_op(), make_SAOP_expr(), make_scalar_array_op(), makeOperatorDependencies(), multi_sort_add_dimension(), MultiXactIdWait(), pushOperator(), tsquery_opr_selec(), tsqueryrecv(), and XactLockTableWait().

oper_lookup_failure_details()

static int oper_lookup_failure_details ( int  fgc_flags, bool  is_unary_op  )

static

Definition at line 660 of file parse_oper.c.

{
    /*
     * If not FGC_NAME_VISIBLE, we shouldn't raise the question of whether the
     * arguments are wrong.  If the operator name was not schema-qualified,
     * it's helpful to distinguish between doesn't-exist-anywhere and
     * not-in-search-path; but if it was, there's really nothing to add to the
     * basic "operator does not exist" message.
     *
     * Note: we passed missing_ok = false to OpernameGetCandidates, so there's
     * no need to consider FGC_SCHEMA_EXISTS here: we'd have already thrown an
     * error if an explicitly-given schema doesn't exist.
     */
    if (!(fgc_flags & FGC_NAME_VISIBLE))
    {
        if (fgc_flags & FGC_SCHEMA_GIVEN)
            return 0;           /* schema-qualified name */
        else if (!(fgc_flags & FGC_NAME_EXISTS))
            return errdetail("There is no operator of that name.");
        else
            return errdetail("An operator of that name exists, but it is not in the search_path.");
    }
 
    /*
     * Otherwise, the problem must be incorrect argument type(s).
     */
    if (is_unary_op)
    {
        (void) errdetail("No operator of that name accepts the given argument type.");
        return errhint("You might need to add an explicit type cast.");
    }
    else
    {
        (void) errdetail("No operator of that name accepts the given argument types.");
        return errhint("You might need to add explicit type casts.");
    }
}

References errdetail(), errhint(), fb(), FGC_NAME_EXISTS, FGC_NAME_VISIBLE, and FGC_SCHEMA_GIVEN.

Referenced by op_error().

oper_select_candidate()

static FuncDetailCode oper_select_candidate ( int  nargs, Oid *  input_typeids, FuncCandidateList  candidates, Oid *  operOid  )

static

Definition at line 317 of file parse_oper.c.

{
    int         ncandidates;
 
    /*
     * Delete any candidates that cannot actually accept the given input
     * types, whether directly or by coercion.
     */
    ncandidates = func_match_argtypes(nargs, input_typeids,
                                      candidates, &candidates);
 
    /* Done if no candidate or only one candidate survives */
    if (ncandidates == 0)
    {
        *operOid = InvalidOid;
        return FUNCDETAIL_NOTFOUND;
    }
    if (ncandidates == 1)
    {
        *operOid = candidates->oid;
        return FUNCDETAIL_NORMAL;
    }
 
    /*
     * Use the same heuristics as for ambiguous functions to resolve the
     * conflict.
     */
    candidates = func_select_candidate(nargs, input_typeids, candidates);
 
    if (candidates)
    {
        *operOid = candidates->oid;
        return FUNCDETAIL_NORMAL;
    }
 
    *operOid = InvalidOid;
    return FUNCDETAIL_MULTIPLE; /* failed to select a best candidate */
}

References fb(), func_match_argtypes(), func_select_candidate(), FUNCDETAIL_MULTIPLE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, and InvalidOid.

Referenced by left_oper(), and oper().

oprfuncid()

Oid oprfuncid

(

Operator

op

)

Definition at line 248 of file parse_oper.c.

{
    Form_pg_operator pgopform = (Form_pg_operator) GETSTRUCT(op);
 
    return pgopform->oprcode;
}

References fb(), Form_pg_operator, and GETSTRUCT().

oprid()

Oid oprid

(

Operator

op

)

Definition at line 241 of file parse_oper.c.

{
    return ((Form_pg_operator) GETSTRUCT(op))->oid;
}

References Form_pg_operator, and GETSTRUCT().

Referenced by appendOrderByClause(), compatible_oper_opid(), dumpOpr(), generate_operator_name(), inclusion_get_strategy_procinfo(), make_op(), make_scalar_array_op(), minmax_get_strategy_procinfo(), minmax_multi_get_strategy_procinfo(), OperatorIsVisible(), OperatorIsVisibleExt(), patternsel_common(), regoperatorout(), and regoperout().

Variable Documentation

OprCacheHash

HTAB* OprCacheHash = NULL

static

Definition at line 974 of file parse_oper.c.

Referenced by find_oper_cache_entry(), InvalidateOprCacheCallBack(), and make_oper_cache_entry().