Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions

parse_node.c

/*-------------------------------------------------------------------------
 *
 * parse_node.c
 *      various routines that make nodes for querytrees
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/parser/parse_node.c,v 1.104 2009/01/01 17:23:45 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/heapam.h"
#include "catalog/pg_type.h"
#include "mb/pg_wchar.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parsetree.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "utils/builtins.h"
#include "utils/int8.h"
#include "utils/syscache.h"
#include "utils/varbit.h"


static void pcb_error_callback(void *arg);


/*
 * make_parsestate
 *          Allocate and initialize a new ParseState.
 *
 * Caller should eventually release the ParseState via free_parsestate().
 */
ParseState *
make_parsestate(ParseState *parentParseState)
{
      ParseState *pstate;

      pstate = palloc0(sizeof(ParseState));

      pstate->parentParseState = parentParseState;

      /* Fill in fields that don't start at null/false/zero */
      pstate->p_next_resno = 1;

      if (parentParseState)
      {
            pstate->p_sourcetext = parentParseState->p_sourcetext;
            pstate->p_variableparams = parentParseState->p_variableparams;
      }

      return pstate;
}

/*
 * free_parsestate
 *          Release a ParseState and any subsidiary resources.
 */
void
free_parsestate(ParseState *pstate)
{
      /*
       * Check that we did not produce too many resnos; at the very least we
       * cannot allow more than 2^16, since that would exceed the range of a
       * AttrNumber. It seems safest to use MaxTupleAttributeNumber.
       */
      if (pstate->p_next_resno - 1 > MaxTupleAttributeNumber)
            ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("target lists can have at most %d entries",
                                    MaxTupleAttributeNumber)));

      if (pstate->p_target_relation != NULL)
            heap_close(pstate->p_target_relation, NoLock);

      pfree(pstate);
}


/*
 * parser_errposition
 *          Report a parse-analysis-time cursor position, if possible.
 *
 * This is expected to be used within an ereport() call.  The return value
 * is a dummy (always 0, in fact).
 *
 * The locations stored in raw parsetrees are byte offsets into the source
 * string.  We have to convert them to 1-based character indexes for reporting
 * to clients.    (We do things this way to avoid unnecessary overhead in the
 * normal non-error case: computing character indexes would be much more
 * expensive than storing token offsets.)
 */
int
parser_errposition(ParseState *pstate, int location)
{
      int               pos;

      /* No-op if location was not provided */
      if (location < 0)
            return 0;
      /* Can't do anything if source text is not available */
      if (pstate == NULL || pstate->p_sourcetext == NULL)
            return 0;
      /* Convert offset to character number */
      pos = pg_mbstrlen_with_len(pstate->p_sourcetext, location) + 1;
      /* And pass it to the ereport mechanism */
      return errposition(pos);
}


/*
 * setup_parser_errposition_callback
 *          Arrange for non-parser errors to report an error position
 *
 * Sometimes the parser calls functions that aren't part of the parser
 * subsystem and can't reasonably be passed a ParseState; yet we would
 * like any errors thrown in those functions to be tagged with a parse
 * error location.  Use this function to set up an error context stack
 * entry that will accomplish that.  Usage pattern:
 *
 *          declare a local variable "ParseCallbackState pcbstate"
 *          ...
 *          setup_parser_errposition_callback(&pcbstate, pstate, location);
 *          call function that might throw error;
 *          cancel_parser_errposition_callback(&pcbstate);
 */
void
setup_parser_errposition_callback(ParseCallbackState *pcbstate,
                                                  ParseState *pstate, int location)
{
      /* Setup error traceback support for ereport() */
      pcbstate->pstate = pstate;
      pcbstate->location = location;
      pcbstate->errcontext.callback = pcb_error_callback;
      pcbstate->errcontext.arg = (void *) pcbstate;
      pcbstate->errcontext.previous = error_context_stack;
      error_context_stack = &pcbstate->errcontext;
}

/*
 * Cancel a previously-set-up errposition callback.
 */
void
cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
{
      /* Pop the error context stack */
      error_context_stack = pcbstate->errcontext.previous;
}

/*
 * Error context callback for inserting parser error location.
 *
 * Note that this will be called for *any* error occurring while the
 * callback is installed.  We avoid inserting an irrelevant error location
 * if the error is a query cancel --- are there any other important cases?
 */
static void
pcb_error_callback(void *arg)
{
      ParseCallbackState *pcbstate = (ParseCallbackState *) arg;

      if (geterrcode() != ERRCODE_QUERY_CANCELED)
            (void) parser_errposition(pcbstate->pstate, pcbstate->location);
}


/*
 * make_var
 *          Build a Var node for an attribute identified by RTE and attrno
 */
Var *
make_var(ParseState *pstate, RangeTblEntry *rte, int attrno, int location)
{
      Var            *result;
      int               vnum,
                        sublevels_up;
      Oid               vartypeid;
      int32       type_mod;

      vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
      get_rte_attribute_type(rte, attrno, &vartypeid, &type_mod);
      result = makeVar(vnum, attrno, vartypeid, type_mod, sublevels_up);
      result->location = location;
      return result;
}

/*
 * transformArrayType()
 *          Get the element type of an array type in preparation for subscripting
 */
Oid
transformArrayType(Oid arrayType)
{
      Oid               elementType;
      HeapTuple   type_tuple_array;
      Form_pg_type type_struct_array;

      /* Get the type tuple for the array */
      type_tuple_array = SearchSysCache(TYPEOID,
                                                        ObjectIdGetDatum(arrayType),
                                                        0, 0, 0);
      if (!HeapTupleIsValid(type_tuple_array))
            elog(ERROR, "cache lookup failed for type %u", arrayType);
      type_struct_array = (Form_pg_type) GETSTRUCT(type_tuple_array);

      /* needn't check typisdefined since this will fail anyway */

      elementType = type_struct_array->typelem;
      if (elementType == InvalidOid)
            ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("cannot subscript type %s because it is not an array",
                                    format_type_be(arrayType))));

      ReleaseSysCache(type_tuple_array);

      return elementType;
}

/*
 * transformArraySubscripts()
 *          Transform array subscripting.  This is used for both
 *          array fetch and array assignment.
 *
 * In an array fetch, we are given a source array value and we produce an
 * expression that represents the result of extracting a single array element
 * or an array slice.
 *
 * In an array assignment, we are given a destination array value plus a
 * source value that is to be assigned to a single element or a slice of
 * that array.    We produce an expression that represents the new array value
 * with the source data inserted into the right part of the array.
 *
 * pstate         Parse state
 * arrayBase      Already-transformed expression for the array as a whole
 * arrayType      OID of array's datatype (should match type of arrayBase)
 * elementType    OID of array's element type (fetch with transformArrayType,
 *                      or pass InvalidOid to do it here)
 * elementTypMod typmod to be applied to array elements (if storing) or of
 *                      the source array (if fetching)
 * indirection    Untransformed list of subscripts (must not be NIL)
 * assignFrom     NULL for array fetch, else transformed expression for source.
 */
ArrayRef *
transformArraySubscripts(ParseState *pstate,
                                     Node *arrayBase,
                                     Oid arrayType,
                                     Oid elementType,
                                     int32 elementTypMod,
                                     List *indirection,
                                     Node *assignFrom)
{
      bool        isSlice = false;
      List     *upperIndexpr = NIL;
      List     *lowerIndexpr = NIL;
      ListCell   *idx;
      ArrayRef   *aref;

      /* Caller may or may not have bothered to determine elementType */
      if (!OidIsValid(elementType))
            elementType = transformArrayType(arrayType);

      /*
       * A list containing only single subscripts refers to a single array
       * element.  If any of the items are double subscripts (lower:upper), then
       * the subscript expression means an array slice operation. In this case,
       * we supply a default lower bound of 1 for any items that contain only a
       * single subscript.  We have to prescan the indirection list to see if
       * there are any double subscripts.
       */
      foreach(idx, indirection)
      {
            A_Indices  *ai = (A_Indices *) lfirst(idx);

            if (ai->lidx != NULL)
            {
                  isSlice = true;
                  break;
            }
      }

      /*
       * Transform the subscript expressions.
       */
      foreach(idx, indirection)
      {
            A_Indices  *ai = (A_Indices *) lfirst(idx);
            Node     *subexpr;

            Assert(IsA(ai, A_Indices));
            if (isSlice)
            {
                  if (ai->lidx)
                  {
                        subexpr = transformExpr(pstate, ai->lidx);
                        /* If it's not int4 already, try to coerce */
                        subexpr = coerce_to_target_type(pstate,
                                                                        subexpr, exprType(subexpr),
                                                                        INT4OID, -1,
                                                                        COERCION_ASSIGNMENT,
                                                                        COERCE_IMPLICIT_CAST,
                                                                        -1);
                        if (subexpr == NULL)
                              ereport(ERROR,
                                          (errcode(ERRCODE_DATATYPE_MISMATCH),
                                           errmsg("array subscript must have type integer"),
                                           parser_errposition(pstate, exprLocation(ai->lidx))));
                  }
                  else
                  {
                        /* Make a constant 1 */
                        subexpr = (Node *) makeConst(INT4OID,
                                                                   -1,
                                                                   sizeof(int32),
                                                                   Int32GetDatum(1),
                                                                   false,
                                                                   true);           /* pass by value */
                  }
                  lowerIndexpr = lappend(lowerIndexpr, subexpr);
            }
            subexpr = transformExpr(pstate, ai->uidx);
            /* If it's not int4 already, try to coerce */
            subexpr = coerce_to_target_type(pstate,
                                                            subexpr, exprType(subexpr),
                                                            INT4OID, -1,
                                                            COERCION_ASSIGNMENT,
                                                            COERCE_IMPLICIT_CAST,
                                                            -1);
            if (subexpr == NULL)
                  ereport(ERROR,
                              (errcode(ERRCODE_DATATYPE_MISMATCH),
                               errmsg("array subscript must have type integer"),
                               parser_errposition(pstate, exprLocation(ai->uidx))));
            upperIndexpr = lappend(upperIndexpr, subexpr);
      }

      /*
       * If doing an array store, coerce the source value to the right type.
       * (This should agree with the coercion done by transformAssignedExpr.)
       */
      if (assignFrom != NULL)
      {
            Oid               typesource = exprType(assignFrom);
            Oid               typeneeded = isSlice ? arrayType : elementType;
            Node     *newFrom;

            newFrom = coerce_to_target_type(pstate,
                                                            assignFrom, typesource,
                                                            typeneeded, elementTypMod,
                                                            COERCION_ASSIGNMENT,
                                                            COERCE_IMPLICIT_CAST,
                                                            -1);
            if (newFrom == NULL)
                  ereport(ERROR,
                              (errcode(ERRCODE_DATATYPE_MISMATCH),
                               errmsg("array assignment requires type %s"
                                          " but expression is of type %s",
                                          format_type_be(typeneeded),
                                          format_type_be(typesource)),
                     errhint("You will need to rewrite or cast the expression."),
                               parser_errposition(pstate, exprLocation(assignFrom))));
            assignFrom = newFrom;
      }

      /*
       * Ready to build the ArrayRef node.
       */
      aref = makeNode(ArrayRef);
      aref->refarraytype = arrayType;
      aref->refelemtype = elementType;
      aref->reftypmod = elementTypMod;
      aref->refupperindexpr = upperIndexpr;
      aref->reflowerindexpr = lowerIndexpr;
      aref->refexpr = (Expr *) arrayBase;
      aref->refassgnexpr = (Expr *) assignFrom;

      return aref;
}

/*
 * make_const
 *
 *    Convert a Value node (as returned by the grammar) to a Const node
 *    of the "natural" type for the constant.  Note that this routine is
 *    only used when there is no explicit cast for the constant, so we
 *    have to guess what type is wanted.
 *
 *    For string literals we produce a constant of type UNKNOWN ---- whose
 *    representation is the same as cstring, but it indicates to later type
 *    resolution that we're not sure yet what type it should be considered.
 *    Explicit "NULL" constants are also typed as UNKNOWN.
 *
 *    For integers and floats we produce int4, int8, or numeric depending
 *    on the value of the number.  XXX We should produce int2 as well,
 *    but additional cleanup is needed before we can do that; there are
 *    too many examples that fail if we try.
 */
Const *
make_const(ParseState *pstate, Value *value, int location)
{
      Const    *con;
      Datum       val;
      int64       val64;
      Oid               typeid;
      int               typelen;
      bool        typebyval;
      ParseCallbackState pcbstate;

      switch (nodeTag(value))
      {
            case T_Integer:
                  val = Int32GetDatum(intVal(value));

                  typeid = INT4OID;
                  typelen = sizeof(int32);
                  typebyval = true;
                  break;

            case T_Float:
                  /* could be an oversize integer as well as a float ... */
                  if (scanint8(strVal(value), true, &val64))
                  {
                        /*
                         * It might actually fit in int32. Probably only INT_MIN can
                         * occur, but we'll code the test generally just to be sure.
                         */
                        int32       val32 = (int32) val64;

                        if (val64 == (int64) val32)
                        {
                              val = Int32GetDatum(val32);

                              typeid = INT4OID;
                              typelen = sizeof(int32);
                              typebyval = true;
                        }
                        else
                        {
                              val = Int64GetDatum(val64);

                              typeid = INT8OID;
                              typelen = sizeof(int64);
                              typebyval = FLOAT8PASSBYVAL;  /* int8 and float8 alike */
                        }
                  }
                  else
                  {
                        /* arrange to report location if numeric_in() fails */
                        setup_parser_errposition_callback(&pcbstate, pstate, location);
                        val = DirectFunctionCall3(numeric_in,
                                                              CStringGetDatum(strVal(value)),
                                                              ObjectIdGetDatum(InvalidOid),
                                                              Int32GetDatum(-1));
                        cancel_parser_errposition_callback(&pcbstate);

                        typeid = NUMERICOID;
                        typelen = -1;     /* variable len */
                        typebyval = false;
                  }
                  break;

            case T_String:

                  /*
                   * We assume here that UNKNOWN's internal representation is the
                   * same as CSTRING
                   */
                  val = CStringGetDatum(strVal(value));

                  typeid = UNKNOWNOID;    /* will be coerced later */
                  typelen = -2;           /* cstring-style varwidth type */
                  typebyval = false;
                  break;

            case T_BitString:
                  /* arrange to report location if bit_in() fails */
                  setup_parser_errposition_callback(&pcbstate, pstate, location);
                  val = DirectFunctionCall3(bit_in,
                                                        CStringGetDatum(strVal(value)),
                                                        ObjectIdGetDatum(InvalidOid),
                                                        Int32GetDatum(-1));
                  cancel_parser_errposition_callback(&pcbstate);
                  typeid = BITOID;
                  typelen = -1;
                  typebyval = false;
                  break;

            case T_Null:
                  /* return a null const */
                  con = makeConst(UNKNOWNOID,
                                          -1,
                                          -2,
                                          (Datum) 0,
                                          true,
                                          false);
                  con->location = location;
                  return con;

            default:
                  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(value));
                  return NULL;            /* keep compiler quiet */
      }

      con = makeConst(typeid,
                              -1,               /* typmod -1 is OK for all cases */
                              typelen,
                              val,
                              false,
                              typebyval);
      con->location = location;

      return con;
}

Generated by  Doxygen 1.6.0   Back to index