parse_graphtable.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/pg_propgraph_label.h"
#include "catalog/pg_propgraph_property.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_graphtable.h"
#include "parser/parse_node.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/relcache.h"
#include "utils/syscache.h"

Include dependency graph for parse_graphtable.c:

Go to the source code of this file.

Functions
static const char *	get_gep_kind_name (GraphElementPatternKind gepkind)
Node *	transformGraphTablePropertyRef (ParseState *pstate, ColumnRef *cref)
static Node *	transformLabelExpr (GraphTableParseState *gpstate, Node *labelexpr)
static Node *	transformGraphElementPattern (ParseState *pstate, GraphElementPattern *gep)
static Node *	transformPathTerm (ParseState *pstate, List *path_term)
static Node *	transformPathPatternList (ParseState *pstate, List *path_pattern)
Node *	transformGraphPattern (ParseState *pstate, GraphPattern *graph_pattern)

Function Documentation

get_gep_kind_name()

static const char * get_gep_kind_name ( GraphElementPatternKind  gepkind )

static

Definition at line 40 of file parse_graphtable.c.

{
    switch (gepkind)
    {
        case VERTEX_PATTERN:
            return "vertex";
        case EDGE_PATTERN_LEFT:
            return "edge pointing left";
        case EDGE_PATTERN_RIGHT:
            return "edge pointing right";
        case EDGE_PATTERN_ANY:
            return "edge pointing any direction";
        case PAREN_EXPR:
            return "nested path pattern";
    }
 
    /*
     * When a GraphElementPattern is constructed by the parser, it will set a
     * value from the GraphElementPatternKind enum. But we may get here if the
     * GraphElementPatternKind value stored in a catalog is corrupted.
     */
    return "unknown";
}

References EDGE_PATTERN_ANY, EDGE_PATTERN_LEFT, EDGE_PATTERN_RIGHT, fb(), PAREN_EXPR, and VERTEX_PATTERN.

Referenced by transformPathTerm().

transformGraphElementPattern()

static Node * transformGraphElementPattern ( ParseState *  pstate, GraphElementPattern *  gep  )

static

Definition at line 239 of file parse_graphtable.c.

{
    GraphTableParseState *gpstate = pstate->p_graph_table_pstate;
 
    if (gep->quantifier)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("element pattern quantifier is not supported")));
 
    Assert(!gpstate->cur_gep);
 
    gpstate->cur_gep = gep;
 
    gep->labelexpr = transformLabelExpr(gpstate, gep->labelexpr);
 
    gep->whereClause = transformExpr(pstate, gep->whereClause, EXPR_KIND_WHERE);
    assign_expr_collations(pstate, gep->whereClause);
 
    gpstate->cur_gep = NULL;
 
    return (Node *) gep;
}

References Assert, assign_expr_collations(), ereport, errcode(), errmsg, ERROR, EXPR_KIND_WHERE, fb(), ParseState::p_graph_table_pstate, transformExpr(), and transformLabelExpr().

Referenced by transformPathTerm().

transformGraphPattern()

Node * transformGraphPattern	(	ParseState *	pstate,
		GraphPattern *	graph_pattern
	)

Definition at line 374 of file parse_graphtable.c.

{
    List       *path_pattern_list = castNode(List,
                                             transformPathPatternList(pstate, graph_pattern->path_pattern_list));
 
    graph_pattern->path_pattern_list = path_pattern_list;
    graph_pattern->whereClause = transformExpr(pstate, graph_pattern->whereClause, EXPR_KIND_WHERE);
    assign_expr_collations(pstate, graph_pattern->whereClause);
 
    return (Node *) graph_pattern;
}

References assign_expr_collations(), castNode, EXPR_KIND_WHERE, GraphPattern::path_pattern_list, transformExpr(), transformPathPatternList(), and GraphPattern::whereClause.

Referenced by transformRangeGraphTable().

transformGraphTablePropertyRef()

Node * transformGraphTablePropertyRef	(	ParseState *	pstate,
		ColumnRef *	cref
	)

Definition at line 79 of file parse_graphtable.c.

{
    GraphTableParseState *gpstate = pstate->p_graph_table_pstate;
 
    if (!gpstate)
        return NULL;
 
    if (list_length(cref->fields) == 2)
    {
        Node       *field1 = linitial(cref->fields);
        Node       *field2 = lsecond(cref->fields);
        char       *elvarname;
        char       *propname;
 
        if (IsA(field1, A_Star) || IsA(field2, A_Star))
        {
            if (pstate->p_expr_kind == EXPR_KIND_SELECT_TARGET)
                ereport(ERROR,
                        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                        errmsg("\"*\" is not supported here"),
                        parser_errposition(pstate, cref->location));
            else
                ereport(ERROR,
                        errcode(ERRCODE_SYNTAX_ERROR),
                        errmsg("\"*\" not allowed here"),
                        parser_errposition(pstate, cref->location));
        }
 
        elvarname = strVal(field1);
        propname = strVal(field2);
 
        if (list_member(gpstate->variables, field1))
        {
            GraphPropertyRef *gpr;
            HeapTuple   pgptup;
            Form_pg_propgraph_property pgpform;
 
            /*
             * If we are transforming expression in an element pattern,
             * property references containing only that variable are allowed.
             */
            if (gpstate->cur_gep)
            {
                if (!gpstate->cur_gep->variable ||
                    strcmp(elvarname, gpstate->cur_gep->variable) != 0)
                    ereport(ERROR,
                            errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            errmsg("non-local element variable reference is not supported"),
                            parser_errposition(pstate, cref->location));
            }
 
            gpr = makeNode(GraphPropertyRef);
            pgptup = SearchSysCache2(PROPGRAPHPROPNAME, ObjectIdGetDatum(gpstate->graphid), CStringGetDatum(propname));
            if (!HeapTupleIsValid(pgptup))
                ereport(ERROR,
                        errcode(ERRCODE_SYNTAX_ERROR),
                        errmsg("property \"%s\" does not exist", propname));
            pgpform = (Form_pg_propgraph_property) GETSTRUCT(pgptup);
 
            gpr->location = cref->location;
            gpr->elvarname = elvarname;
            gpr->propid = pgpform->oid;
            gpr->typeId = pgpform->pgptypid;
            gpr->typmod = pgpform->pgptypmod;
            gpr->collation = pgpform->pgpcollation;
 
            ReleaseSysCache(pgptup);
 
            return (Node *) gpr;
        }
    }
 
    return NULL;
}

References CStringGetDatum(), ereport, errcode(), errmsg, ERROR, EXPR_KIND_SELECT_TARGET, fb(), Form_pg_propgraph_property, GETSTRUCT(), HeapTupleIsValid, IsA, linitial, list_length(), list_member(), lsecond, makeNode, ObjectIdGetDatum(), ParseState::p_expr_kind, ParseState::p_graph_table_pstate, parser_errposition(), ReleaseSysCache(), SearchSysCache2(), and strVal.

Referenced by transformColumnRef().

transformLabelExpr()

static Node * transformLabelExpr ( GraphTableParseState *  gpstate, Node *  labelexpr  )

static

Definition at line 166 of file parse_graphtable.c.

{
    Node       *result;
 
    if (labelexpr == NULL)
        return NULL;
 
    check_stack_depth();
 
    switch (nodeTag(labelexpr))
    {
        case T_ColumnRef:
            {
                ColumnRef  *cref = (ColumnRef *) labelexpr;
                const char *labelname;
                Oid         labelid;
                GraphLabelRef *lref;
 
                Assert(list_length(cref->fields) == 1);
                labelname = strVal(linitial(cref->fields));
 
                labelid = GetSysCacheOid2(PROPGRAPHLABELNAME, Anum_pg_propgraph_label_oid, ObjectIdGetDatum(gpstate->graphid), CStringGetDatum(labelname));
                if (!labelid)
                    ereport(ERROR,
                            errcode(ERRCODE_UNDEFINED_OBJECT),
                            errmsg("label \"%s\" does not exist in property graph \"%s\"", labelname, get_rel_name(gpstate->graphid)));
 
                lref = makeNode(GraphLabelRef);
                lref->labelid = labelid;
                lref->location = cref->location;
 
                result = (Node *) lref;
                break;
            }
 
        case T_BoolExpr:
            {
                BoolExpr   *be = (BoolExpr *) labelexpr;
                ListCell   *lc;
                List       *args = NIL;
 
                foreach(lc, be->args)
                {
                    Node       *arg = (Node *) lfirst(lc);
 
                    arg = transformLabelExpr(gpstate, arg);
                    args = lappend(args, arg);
                }
 
                result = (Node *) makeBoolExpr(be->boolop, args, be->location);
                break;
            }
 
        default:
            /* should not reach here */
            elog(ERROR, "unsupported label expression node: %d", (int) nodeTag(labelexpr));
            result = NULL;      /* keep compiler quiet */
            break;
    }
 
    return result;
}

References arg, Assert, check_stack_depth(), CStringGetDatum(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_rel_name(), GetSysCacheOid2, lappend(), lfirst, linitial, list_length(), makeBoolExpr(), makeNode, NIL, nodeTag, ObjectIdGetDatum(), result, strVal, and transformLabelExpr().

Referenced by transformGraphElementPattern(), and transformLabelExpr().

transformPathPatternList()

static Node * transformPathPatternList ( ParseState *  pstate, List *  path_pattern  )

static

Definition at line 324 of file parse_graphtable.c.

{
    List       *result = NIL;
    GraphTableParseState *gpstate = pstate->p_graph_table_pstate;
 
    Assert(gpstate);
 
    /* Grammar doesn't allow empty path pattern list */
    Assert(list_length(path_pattern) > 0);
 
    /*
     * We do not support multiple path patterns in one GRAPH_TABLE clause
     * right now. But we may do so in future.
     */
    if (list_length(path_pattern) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("multiple path patterns in one GRAPH_TABLE clause not supported")));
 
    /*
     * Collect all the variables in the path pattern into the
     * GraphTableParseState so that we can detect any non-local element
     * variable references. We need to do this before transforming the path
     * pattern so as to detect forward references to element variables in the
     * WHERE clause of an element pattern.
     */
    foreach_node(List, path_term, path_pattern)
    {
        foreach_node(GraphElementPattern, gep, path_term)
        {
            if (gep->variable)
                gpstate->variables = list_append_unique(gpstate->variables, makeString(pstrdup(gep->variable)));
        }
    }
 
    foreach_node(List, path_term, path_pattern)
        result = lappend(result, transformPathTerm(pstate, path_term));
 
    return (Node *) result;
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), foreach_node, lappend(), list_append_unique(), list_length(), makeString(), NIL, ParseState::p_graph_table_pstate, pstrdup(), result, and transformPathTerm().

Referenced by transformGraphPattern().

transformPathTerm()

static Node * transformPathTerm ( ParseState *  pstate, List *  path_term  )

static

Definition at line 266 of file parse_graphtable.c.

{
    List       *result = NIL;
    GraphElementPattern *prev_gep = NULL;
 
    foreach_node(GraphElementPattern, gep, path_term)
    {
        if (gep->kind != VERTEX_PATTERN && !IS_EDGE_PATTERN(gep->kind))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("unsupported element pattern kind: \"%s\"", get_gep_kind_name(gep->kind)),
                     parser_errposition(pstate, gep->location)));
 
        if (IS_EDGE_PATTERN(gep->kind))
        {
            if (!prev_gep)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("path pattern cannot start with an edge pattern"),
                         parser_errposition(pstate, gep->location)));
            else if (prev_gep->kind != VERTEX_PATTERN)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("edge pattern must be preceded by a vertex pattern"),
                         parser_errposition(pstate, gep->location)));
        }
        else
        {
            if (prev_gep && !IS_EDGE_PATTERN(prev_gep->kind))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("adjacent vertex patterns are not supported"),
                         parser_errposition(pstate, gep->location)));
        }
 
        result = lappend(result,
                         transformGraphElementPattern(pstate, gep));
        prev_gep = gep;
    }
 
    /* Path pattern should have at least one element pattern. */
    Assert(prev_gep);
 
    if (IS_EDGE_PATTERN(prev_gep->kind))
    {
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("path pattern cannot end with an edge pattern"),
                 parser_errposition(pstate, prev_gep->location)));
    }
 
    return (Node *) result;
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), foreach_node, get_gep_kind_name(), IS_EDGE_PATTERN, lappend(), NIL, parser_errposition(), result, transformGraphElementPattern(), and VERTEX_PATTERN.

Referenced by transformPathPatternList().