/*-------------------------------------------------------------------------

 *

 * propgraphcmds.c

 *    property graph manipulation

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * src/backend/commands/propgraphcmds.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/genam.h"

#include "access/htup_details.h"

#include "access/nbtree.h"

#include "access/table.h"

#include "access/xact.h"

#include "catalog/catalog.h"

#include "catalog/indexing.h"

#include "catalog/namespace.h"

#include "catalog/pg_class.h"

#include "catalog/pg_collation_d.h"

#include "catalog/pg_operator_d.h"

#include "catalog/pg_propgraph_element.h"

#include "catalog/pg_propgraph_element_label.h"

#include "catalog/pg_propgraph_label.h"

#include "catalog/pg_propgraph_label_property.h"

#include "catalog/pg_propgraph_property.h"

#include "commands/defrem.h"

#include "commands/propgraphcmds.h"

#include "commands/tablecmds.h"

#include "miscadmin.h"

#include "nodes/nodeFuncs.h"

#include "parser/parse_coerce.h"

#include "parser/parse_collate.h"

#include "parser/parse_oper.h"

#include "parser/parse_relation.h"

#include "parser/parse_target.h"

#include "utils/acl.h"

#include "utils/array.h"

#include "utils/builtins.h"

#include "utils/fmgroids.h"

#include "utils/inval.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/ruleutils.h"

#include "utils/syscache.h"

struct element_info

{

  Oid     elementid;

  char    kind;

  Oid     relid;

  char     *aliasname;

  ArrayType  *key;

  char     *srcvertex;

  Oid     srcvertexid;

  Oid     srcrelid;

  ArrayType  *srckey;

  ArrayType  *srcref;

  ArrayType  *srceqop;

  char     *destvertex;

  Oid     destvertexid;

  Oid     destrelid;

  ArrayType  *destkey;

  ArrayType  *destref;

  ArrayType  *desteqop;

  List     *labels;

};

static ArrayType *propgraph_element_get_key(ParseState *pstate, const List *key_clause, Relation element_rel,

                      const char *aliasname, int location);

static void propgraph_edge_get_ref_keys(ParseState *pstate, const List *keycols, const List *refcols,

                    Relation edge_rel, Relation ref_rel,

                    const char *aliasname, int location, const char *type,

                    ArrayType **outkey, ArrayType **outref, ArrayType **outeqop);

static AttrNumber *array_from_column_list(ParseState *pstate, const List *colnames, int location, Relation element_rel);

static ArrayType *array_from_attnums(int numattrs, const AttrNumber *attnums);

static Oid  insert_element_record(ObjectAddress pgaddress, struct element_info *einfo);

static Oid  insert_label_record(Oid graphid, Oid peoid, const char *label);

static void insert_property_records(Oid graphid, Oid ellabeloid, Oid pgerelid, const PropGraphProperties *properties);

static void insert_property_record(Oid graphid, Oid ellabeloid, Oid pgerelid, const char *propname, const Expr *expr);

static void check_element_properties(Oid peoid);

static void check_element_label_properties(Oid ellabeloid);

static void check_all_labels_properties(Oid pgrelid);

static Oid  get_vertex_oid(ParseState *pstate, Oid pgrelid, const char *alias, int location);

static Oid  get_edge_oid(ParseState *pstate, Oid pgrelid, const char *alias, int location);

static Oid  get_element_relid(Oid peid);

static List *get_graph_label_ids(Oid graphid);

static List *get_label_element_label_ids(Oid labelid);

static List *get_element_label_property_names(Oid ellabeloid);

static List *get_graph_property_ids(Oid graphid);

/*

 * CREATE PROPERTY GRAPH

 */

ObjectAddress

CreatePropGraph(ParseState *pstate, const CreatePropGraphStmt *stmt)

{

  CreateStmt *cstmt = makeNode(CreateStmt);

  char    components_persistence;

  ListCell   *lc;

  ObjectAddress pgaddress;

  List     *vertex_infos = NIL;

  List     *edge_infos = NIL;

  List     *element_aliases = NIL;

  List     *element_oids = NIL;

  if (stmt->pgname->relpersistence == RELPERSISTENCE_UNLOGGED)

    ereport(ERROR,

        (errcode(ERRCODE_SYNTAX_ERROR),

         errmsg("property graphs cannot be unlogged because they do not have storage")));

  components_persistence = RELPERSISTENCE_PERMANENT;

  foreach(lc, stmt->vertex_tables)

  {

    PropGraphVertex *vertex = lfirst_node(PropGraphVertex, lc);

    struct element_info *vinfo;

    Relation  rel;

    vinfo = palloc0_object(struct element_info);

    vinfo->kind = PGEKIND_VERTEX;

    vinfo->relid = RangeVarGetRelidExtended(vertex->vtable, AccessShareLock, 0, RangeVarCallbackOwnsRelation, NULL);

    rel = table_open(vinfo->relid, NoLock);

    if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)

      components_persistence = RELPERSISTENCE_TEMP;

    if (vertex->vtable->alias)

      vinfo->aliasname = vertex->vtable->alias->aliasname;

    else

      vinfo->aliasname = vertex->vtable->relname;

    if (list_member(element_aliases, makeString(vinfo->aliasname)))

      ereport(ERROR,

          (errcode(ERRCODE_DUPLICATE_TABLE),

           errmsg("alias \"%s\" used more than once as element table", vinfo->aliasname),

           parser_errposition(pstate, vertex->location)));

    vinfo->key = propgraph_element_get_key(pstate, vertex->vkey, rel, vinfo->aliasname, vertex->location);

    vinfo->labels = vertex->labels;

    table_close(rel, NoLock);

    vertex_infos = lappend(vertex_infos, vinfo);

    element_aliases = lappend(element_aliases, makeString(vinfo->aliasname));

  }

  foreach(lc, stmt->edge_tables)

  {

    PropGraphEdge *edge = lfirst_node(PropGraphEdge, lc);

    struct element_info *einfo;

    Relation  rel;

    ListCell   *lc2;

    Oid     srcrelid;

    Oid     destrelid;

    Relation  srcrel;

    Relation  destrel;

    einfo = palloc0_object(struct element_info);

    einfo->kind = PGEKIND_EDGE;

    einfo->relid = RangeVarGetRelidExtended(edge->etable, AccessShareLock, 0, RangeVarCallbackOwnsRelation, NULL);

    rel = table_open(einfo->relid, NoLock);

    if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)

      components_persistence = RELPERSISTENCE_TEMP;

    if (edge->etable->alias)

      einfo->aliasname = edge->etable->alias->aliasname;

    else

      einfo->aliasname = edge->etable->relname;

    if (list_member(element_aliases, makeString(einfo->aliasname)))

      ereport(ERROR,

          (errcode(ERRCODE_DUPLICATE_TABLE),

           errmsg("alias \"%s\" used more than once as element table", einfo->aliasname),

           parser_errposition(pstate, edge->location)));

    einfo->key = propgraph_element_get_key(pstate, edge->ekey, rel, einfo->aliasname, edge->location);

    einfo->srcvertex = edge->esrcvertex;

    einfo->destvertex = edge->edestvertex;

    srcrelid = 0;

    destrelid = 0;

    foreach(lc2, vertex_infos)

    {

      struct element_info *vinfo = lfirst(lc2);

      if (strcmp(vinfo->aliasname, edge->esrcvertex) == 0)

        srcrelid = vinfo->relid;

      if (strcmp(vinfo->aliasname, edge->edestvertex) == 0)

        destrelid = vinfo->relid;

      if (srcrelid && destrelid)

        break;

    }

    if (!srcrelid)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

           errmsg("source vertex \"%s\" of edge \"%s\" does not exist",

              edge->esrcvertex, einfo->aliasname),

           parser_errposition(pstate, edge->location)));

    if (!destrelid)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

           errmsg("destination vertex \"%s\" of edge \"%s\" does not exist",

              edge->edestvertex, einfo->aliasname),

           parser_errposition(pstate, edge->location)));

    srcrel = table_open(srcrelid, NoLock);

    destrel = table_open(destrelid, NoLock);

    propgraph_edge_get_ref_keys(pstate, edge->esrckey, edge->esrcvertexcols, rel, srcrel,

                  einfo->aliasname, edge->location, "SOURCE",

                  &einfo->srckey, &einfo->srcref, &einfo->srceqop);

    propgraph_edge_get_ref_keys(pstate, edge->edestkey, edge->edestvertexcols, rel, destrel,

                  einfo->aliasname, edge->location, "DESTINATION",

                  &einfo->destkey, &einfo->destref, &einfo->desteqop);

    einfo->labels = edge->labels;

    table_close(destrel, NoLock);

    table_close(srcrel, NoLock);

    table_close(rel, NoLock);

    edge_infos = lappend(edge_infos, einfo);

    element_aliases = lappend(element_aliases, makeString(einfo->aliasname));

  }

  cstmt->relation = stmt->pgname;

  cstmt->oncommit = ONCOMMIT_NOOP;

  /*

   * Automatically make it temporary if any component tables are temporary

   * (see also DefineView()).

   */

  if (stmt->pgname->relpersistence == RELPERSISTENCE_PERMANENT

    && components_persistence == RELPERSISTENCE_TEMP)

  {

    cstmt->relation = copyObject(cstmt->relation);

    cstmt->relation->relpersistence = RELPERSISTENCE_TEMP;

    ereport(NOTICE,

        (errmsg("property graph \"%s\" will be temporary",

            stmt->pgname->relname)));

  }

  pgaddress = DefineRelation(cstmt, RELKIND_PROPGRAPH, InvalidOid, NULL, NULL);

  foreach(lc, vertex_infos)

  {

    struct element_info *vinfo = lfirst(lc);

    Oid     peoid;

    peoid = insert_element_record(pgaddress, vinfo);

    element_oids = lappend_oid(element_oids, peoid);

  }

  foreach(lc, edge_infos)

  {

    struct element_info *einfo = lfirst(lc);

    Oid     peoid;

    ListCell   *lc2;

    /*

     * Look up the vertices again.  Now the vertices have OIDs assigned,

     * which we need.

     */

    foreach(lc2, vertex_infos)

    {

      struct element_info *vinfo = lfirst(lc2);

      if (strcmp(vinfo->aliasname, einfo->srcvertex) == 0)

      {

        einfo->srcvertexid = vinfo->elementid;

        einfo->srcrelid = vinfo->relid;

      }

      if (strcmp(vinfo->aliasname, einfo->destvertex) == 0)

      {

        einfo->destvertexid = vinfo->elementid;

        einfo->destrelid = vinfo->relid;

      }

      if (einfo->srcvertexid && einfo->destvertexid)

        break;

    }

    Assert(einfo->srcvertexid);

    Assert(einfo->destvertexid);

    Assert(einfo->srcrelid);

    Assert(einfo->destrelid);

    peoid = insert_element_record(pgaddress, einfo);

    element_oids = lappend_oid(element_oids, peoid);

  }

  CommandCounterIncrement();

  foreach_oid(peoid, element_oids)

    check_element_properties(peoid);

  check_all_labels_properties(pgaddress.objectId);

  return pgaddress;

}

/*

 * Process the key clause specified for an element.  If key_clause is non-NIL,

 * then it is a list of column names.  Otherwise, the primary key of the

 * relation is used.  The return value is an array of column numbers.

 */

static ArrayType *

propgraph_element_get_key(ParseState *pstate, const List *key_clause, Relation element_rel, const char *aliasname, int location)

{

  ArrayType  *a;

  if (key_clause == NIL)

  {

    Oid     pkidx = RelationGetPrimaryKeyIndex(element_rel, false);

    if (!pkidx)

      ereport(ERROR,

          errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

          errmsg("no key specified and no suitable primary key exists for definition of element \"%s\"", aliasname),

          parser_errposition(pstate, location));

    else

    {

      Relation  indexDesc;

      indexDesc = index_open(pkidx, AccessShareLock);

      a = array_from_attnums(indexDesc->rd_index->indkey.dim1, indexDesc->rd_index->indkey.values);

      index_close(indexDesc, NoLock);

    }

  }

  else

  {

    a = array_from_attnums(list_length(key_clause),

                 array_from_column_list(pstate, key_clause, location, element_rel));

  }

  return a;

}

/*

 * Process the source or destination link of an edge.

 *

 * keycols and refcols are column names representing the local and referenced

 * (vertex) columns.  If they are both NIL, a matching foreign key is looked

 * up.

 *

 * edge_rel and ref_rel are the local and referenced element tables.

 *

 * aliasname, location, and type are for error messages.  type is either

 * "SOURCE" or "DESTINATION".

 *

 * The outputs are arrays of column numbers in outkey and outref.

 */

static void

propgraph_edge_get_ref_keys(ParseState *pstate, const List *keycols, const List *refcols,

              Relation edge_rel, Relation ref_rel,

              const char *aliasname, int location, const char *type,

              ArrayType **outkey, ArrayType **outref, ArrayType **outeqop)

{

  int     nkeys;

  AttrNumber *keyattnums;

  AttrNumber *refattnums;

  Oid      *keyeqops;

  Datum    *datums;

  Assert((keycols && refcols) || (!keycols && !refcols));

  if (keycols)

  {

    if (list_length(keycols) != list_length(refcols))

      ereport(ERROR,

          errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

          errmsg("mismatching number of columns in %s vertex definition of edge \"%s\"", type, aliasname),

          parser_errposition(pstate, location));

    nkeys = list_length(keycols);

    keyattnums = array_from_column_list(pstate, keycols, location, edge_rel);

    refattnums = array_from_column_list(pstate, refcols, location, ref_rel);

    keyeqops = palloc_array(Oid, nkeys);

    for (int i = 0; i < nkeys; i++)

    {

      Oid     keytype;

      int32   keytypmod;

      Oid     keycoll;

      Oid     reftype;

      int32   reftypmod;

      Oid     refcoll;

      Oid     opc;

      Oid     opf;

      StrategyNumber strategy;

      /*

       * Lookup equality operator to be used for edge and vertex key.

       * Vertex key is equivalent to primary key and edge key is similar

       * to foreign key since edge key references vertex key. Hence

       * vertex key is used as left operand and edge key is used as

       * right operand. The method used to find the equality operators

       * is similar to the method used to find equality operators for

       * FK/PK comparison in ATAddForeignKeyConstraint() except that

       * opclass of the vertex key type is used as a starting point.

       * Since we need only equality operators we use both BT and HASH

       * strategies.

       *

       * If the required operators do not exist, we can not construct

       * quals linking an edge to its adjacent vertices.

       */

      get_atttypetypmodcoll(RelationGetRelid(edge_rel), keyattnums[i], &keytype, &keytypmod, &keycoll);

      get_atttypetypmodcoll(RelationGetRelid(ref_rel), refattnums[i], &reftype, &reftypmod, &refcoll);

      keyeqops[i] = InvalidOid;

      strategy = BTEqualStrategyNumber;

      opc = GetDefaultOpClass(reftype, BTREE_AM_OID);

      if (!OidIsValid(opc))

      {

        opc = GetDefaultOpClass(reftype, HASH_AM_OID);

        strategy = HTEqualStrategyNumber;

      }

      if (OidIsValid(opc))

      {

        opf = get_opclass_family(opc);

        if (OidIsValid(opf))

        {

          keyeqops[i] = get_opfamily_member(opf, reftype, keytype, strategy);

          if (!OidIsValid(keyeqops[i]))

          {

            /* Last resort, implicit cast. */

            if (can_coerce_type(1, &keytype, &reftype, COERCION_IMPLICIT))

              keyeqops[i] = get_opfamily_member(opf, reftype, reftype, strategy);

          }

        }

      }

      if (!OidIsValid(keyeqops[i]))

        ereport(ERROR,

            errcode(ERRCODE_SYNTAX_ERROR),

            errmsg("no equality operator exists for %s key comparison of edge \"%s\"",

                 type, aliasname),

            parser_errposition(pstate, location));

      /*

       * If collations of key attribute and referenced attribute are

       * different, an edge may end up being adjacent to undesired

       * vertices.  Prohibit such a case.

       *

       * PK/FK allows different collations as long as they are

       * deterministic for backward compatibility. But we can be a bit

       * stricter here and follow SQL standard.

       */

      if (keycoll != refcoll &&

        keycoll != DEFAULT_COLLATION_OID && refcoll != DEFAULT_COLLATION_OID &&

        OidIsValid(keycoll) && OidIsValid(refcoll))

        ereport(ERROR,

            errcode(ERRCODE_SYNTAX_ERROR),

            errmsg("collation mismatch in %s key of edge \"%s\": %s vs. %s",

                 type, aliasname,

                 get_collation_name(keycoll), get_collation_name(refcoll)),

            parser_errposition(pstate, location));

    }

  }

  else

  {

    ForeignKeyCacheInfo *fk = NULL;

    foreach_node(ForeignKeyCacheInfo, tmp, RelationGetFKeyList(edge_rel))

    {

      if (tmp->confrelid == RelationGetRelid(ref_rel))

      {

        if (fk)

          ereport(ERROR,

              errcode(ERRCODE_SYNTAX_ERROR),

              errmsg("more than one suitable foreign key exists for %s key of edge \"%s\"", type, aliasname),

              parser_errposition(pstate, location));

        fk = tmp;

      }

    }

    if (!fk)

      ereport(ERROR,

          errcode(ERRCODE_SYNTAX_ERROR),

          errmsg("no %s key specified and no suitable foreign key exists for definition of edge \"%s\"", type, aliasname),

          parser_errposition(pstate, location));

    nkeys = fk->nkeys;

    keyattnums = fk->conkey;

    refattnums = fk->confkey;

    keyeqops = fk->conpfeqop;

  }

  *outkey = array_from_attnums(nkeys, keyattnums);

  *outref = array_from_attnums(nkeys, refattnums);

  datums = palloc_array(Datum, nkeys);

  for (int i = 0; i < nkeys; i++)

    datums[i] = ObjectIdGetDatum(keyeqops[i]);

  *outeqop = construct_array_builtin(datums, nkeys, OIDOID);

}

/*

 * Convert list of column names in the specified relation into an array of

 * column numbers.

 */

static AttrNumber *

array_from_column_list(ParseState *pstate, const List *colnames, int location, Relation element_rel)

{

  int     numattrs;

  AttrNumber *attnums;

  int     i;

  ListCell   *lc;

  numattrs = list_length(colnames);

  attnums = palloc_array(AttrNumber, numattrs);

  i = 0;

  foreach(lc, colnames)

  {

    char     *colname = strVal(lfirst(lc));

    Oid     relid = RelationGetRelid(element_rel);

    AttrNumber  attnum;

    attnum = get_attnum(relid, colname);

    if (!attnum)

      ereport(ERROR,

          (errcode(ERRCODE_UNDEFINED_COLUMN),

           errmsg("column \"%s\" of relation \"%s\" does not exist",

              colname, get_rel_name(relid)),

           parser_errposition(pstate, location)));

    attnums[i++] = attnum;

  }

  for (int j = 0; j < numattrs; j++)

  {

    for (int k = j + 1; k < numattrs; k++)

    {

      if (attnums[j] == attnums[k])

        ereport(ERROR,

            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

             errmsg("graph key columns list must not contain duplicates"),

             parser_errposition(pstate, location)));

    }

  }

  return attnums;

}

static ArrayType *

array_from_attnums(int numattrs, const AttrNumber *attnums)

{

  Datum    *attnumsd;

  attnumsd = palloc_array(Datum, numattrs);

  for (int i = 0; i < numattrs; i++)

    attnumsd[i] = Int16GetDatum(attnums[i]);

  return construct_array_builtin(attnumsd, numattrs, INT2OID);

}

static void

array_of_attnums_to_objectaddrs(Oid relid, ArrayType *arr, ObjectAddresses *addrs)

{

  Datum    *attnumsd;

  int     numattrs;

  deconstruct_array_builtin(arr, INT2OID, &attnumsd, NULL, &numattrs);

  for (int i = 0; i < numattrs; i++)

  {

    ObjectAddress referenced;

    ObjectAddressSubSet(referenced, RelationRelationId, relid, DatumGetInt16(attnumsd[i]));

    add_exact_object_address(&referenced, addrs);

  }

}

static void

array_of_opers_to_objectaddrs(ArrayType *arr, ObjectAddresses *addrs)

{

  Datum    *opersd;

  int     numopers;

  deconstruct_array_builtin(arr, OIDOID, &opersd, NULL, &numopers);

  for (int i = 0; i < numopers; i++)

  {

    ObjectAddress referenced;

    ObjectAddressSet(referenced, OperatorRelationId, DatumGetObjectId(opersd[i]));

    add_exact_object_address(&referenced, addrs);

  }

}

/*

 * Insert a record for an element into the pg_propgraph_element catalog.  Also

 * inserts labels and properties into their respective catalogs.

 */

static Oid

insert_element_record(ObjectAddress pgaddress, struct element_info *einfo)

{

  Oid     graphid = pgaddress.objectId;

  Relation  rel;

  NameData  aliasname;

  Oid     peoid;

  Datum   values[Natts_pg_propgraph_element] = {0};

  bool    nulls[Natts_pg_propgraph_element] = {0};

  HeapTuple tup;

  ObjectAddress myself;

  ObjectAddress referenced;

  ObjectAddresses *addrs;

  rel = table_open(PropgraphElementRelationId, RowExclusiveLock);

  peoid = GetNewOidWithIndex(rel, PropgraphElementObjectIndexId, Anum_pg_propgraph_element_oid);

  einfo->elementid = peoid;

  values[Anum_pg_propgraph_element_oid - 1] = ObjectIdGetDatum(peoid);

  values[Anum_pg_propgraph_element_pgepgid - 1] = ObjectIdGetDatum(graphid);

  values[Anum_pg_propgraph_element_pgerelid - 1] = ObjectIdGetDatum(einfo->relid);

  namestrcpy(&aliasname, einfo->aliasname);

  values[Anum_pg_propgraph_element_pgealias - 1] = NameGetDatum(&aliasname);

  values[Anum_pg_propgraph_element_pgekind - 1] = CharGetDatum(einfo->kind);

  values[Anum_pg_propgraph_element_pgesrcvertexid - 1] = ObjectIdGetDatum(einfo->srcvertexid);

  values[Anum_pg_propgraph_element_pgedestvertexid - 1] = ObjectIdGetDatum(einfo->destvertexid);

  values[Anum_pg_propgraph_element_pgekey - 1] = PointerGetDatum(einfo->key);

  if (einfo->srckey)

    values[Anum_pg_propgraph_element_pgesrckey - 1] = PointerGetDatum(einfo->srckey);

  else

    nulls[Anum_pg_propgraph_element_pgesrckey - 1] = true;

  if (einfo->srcref)

    values[Anum_pg_propgraph_element_pgesrcref - 1] = PointerGetDatum(einfo->srcref);

  else

    nulls[Anum_pg_propgraph_element_pgesrcref - 1] = true;

  if (einfo->srceqop)

    values[Anum_pg_propgraph_element_pgesrceqop - 1] = PointerGetDatum(einfo->srceqop);

  else

    nulls[Anum_pg_propgraph_element_pgesrceqop - 1] = true;

  if (einfo->destkey)

    values[Anum_pg_propgraph_element_pgedestkey - 1] = PointerGetDatum(einfo->destkey);

  else

    nulls[Anum_pg_propgraph_element_pgedestkey - 1] = true;

  if (einfo->destref)

    values[Anum_pg_propgraph_element_pgedestref - 1] = PointerGetDatum(einfo->destref);

  else

    nulls[Anum_pg_propgraph_element_pgedestref - 1] = true;

  if (einfo->desteqop)

    values[Anum_pg_propgraph_element_pgedesteqop - 1] = PointerGetDatum(einfo->desteqop);

  else

    nulls[Anum_pg_propgraph_element_pgedesteqop - 1] = true;

  tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);

  CatalogTupleInsert(rel, tup);

  heap_freetuple(tup);

  ObjectAddressSet(myself, PropgraphElementRelationId, peoid);

  /* Add dependency on the property graph */

  recordDependencyOn(&myself, &pgaddress, DEPENDENCY_AUTO);

  addrs = new_object_addresses();

  /* Add dependency on the relation */

  ObjectAddressSet(referenced, RelationRelationId, einfo->relid);

  add_exact_object_address(&referenced, addrs);

  array_of_attnums_to_objectaddrs(einfo->relid, einfo->key, addrs);

  /*

   * Add dependencies on vertices and equality operators used for key

   * comparison.

   */

  if (einfo->srcvertexid)

  {

    ObjectAddressSet(referenced, PropgraphElementRelationId, einfo->srcvertexid);

    add_exact_object_address(&referenced, addrs);

    array_of_attnums_to_objectaddrs(einfo->relid, einfo->srckey, addrs);

    array_of_attnums_to_objectaddrs(einfo->srcrelid, einfo->srcref, addrs);

    array_of_opers_to_objectaddrs(einfo->srceqop, addrs);

  }

  if (einfo->destvertexid)

  {

    ObjectAddressSet(referenced, PropgraphElementRelationId, einfo->destvertexid);

    add_exact_object_address(&referenced, addrs);

    array_of_attnums_to_objectaddrs(einfo->relid, einfo->destkey, addrs);

    array_of_attnums_to_objectaddrs(einfo->destrelid, einfo->destref, addrs);

    array_of_opers_to_objectaddrs(einfo->desteqop, addrs);

  }

  record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);

  table_close(rel, NoLock);

  if (einfo->labels)

  {

    ListCell   *lc;

    foreach(lc, einfo->labels)

    {

      PropGraphLabelAndProperties *lp = lfirst_node(PropGraphLabelAndProperties, lc);

      Oid     ellabeloid;

      if (lp->label)

        ellabeloid = insert_label_record(graphid, peoid, lp->label);

      else

        ellabeloid = insert_label_record(graphid, peoid, einfo->aliasname);

      insert_property_records(graphid, ellabeloid, einfo->relid, lp->properties);

      CommandCounterIncrement();

    }

  }

  else

  {

    Oid     ellabeloid;

    PropGraphProperties *pr = makeNode(PropGraphProperties);

    pr->all = true;

    pr->location = -1;

    ellabeloid = insert_label_record(graphid, peoid, einfo->aliasname);

    insert_property_records(graphid, ellabeloid, einfo->relid, pr);

  }

  return peoid;

}

/*

 * Insert records for a label into the pg_propgraph_label and

 * pg_propgraph_element_label catalogs, and register dependencies.

 *

 * Returns the OID of the new pg_propgraph_element_label record.

 */

static Oid

insert_label_record(Oid graphid, Oid peoid, const char *label)

{

  Oid     labeloid;

  Oid     ellabeloid;

  /*

   * Insert into pg_propgraph_label if not already existing.

   */

  labeloid = GetSysCacheOid2(PROPGRAPHLABELNAME, Anum_pg_propgraph_label_oid, ObjectIdGetDatum(graphid), CStringGetDatum(label));

  if (!labeloid)

  {

    Relation  rel;

    Datum   values[Natts_pg_propgraph_label] = {0};

    bool    nulls[Natts_pg_propgraph_label] = {0};

    NameData  labelname;

    HeapTuple tup;

    ObjectAddress myself;

    ObjectAddress referenced;

    rel = table_open(PropgraphLabelRelationId, RowExclusiveLock);

    labeloid = GetNewOidWithIndex(rel, PropgraphLabelObjectIndexId, Anum_pg_propgraph_label_oid);

    values[Anum_pg_propgraph_label_oid - 1] = ObjectIdGetDatum(labeloid);

    values[Anum_pg_propgraph_label_pglpgid - 1] = ObjectIdGetDatum(graphid);

    namestrcpy(&labelname, label);

    values[Anum_pg_propgraph_label_pgllabel - 1] = NameGetDatum(&labelname);

    tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);

    CatalogTupleInsert(rel, tup);

    heap_freetuple(tup);

    ObjectAddressSet(myself, PropgraphLabelRelationId, labeloid);

    ObjectAddressSet(referenced, RelationRelationId, graphid);

    recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);

    table_close(rel, NoLock);

  }

  /*

   * Insert into pg_propgraph_element_label

   */

  if (SearchSysCacheExists2(PROPGRAPHELEMENTLABELELEMENTLABEL,

                ObjectIdGetDatum(peoid),

                ObjectIdGetDatum(labeloid)))

    ereport(ERROR,

        errcode(ERRCODE_DUPLICATE_OBJECT),

        errmsg("label \"%s\" already exists", label));

  else

  {

    Relation  rel;

    Datum   values[Natts_pg_propgraph_element_label] = {0};

    bool    nulls[Natts_pg_propgraph_element_label] = {0};

    HeapTuple tup;

    ObjectAddress myself;

    ObjectAddress referenced;

    rel = table_open(PropgraphElementLabelRelationId, RowExclusiveLock);

    ellabeloid = GetNewOidWithIndex(rel, PropgraphElementLabelObjectIndexId, Anum_pg_propgraph_element_label_oid);

    values[Anum_pg_propgraph_element_label_oid - 1] = ObjectIdGetDatum(ellabeloid);

    values[Anum_pg_propgraph_element_label_pgellabelid - 1] = ObjectIdGetDatum(labeloid);

    values[Anum_pg_propgraph_element_label_pgelelid - 1] = ObjectIdGetDatum(peoid);

    tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);

    CatalogTupleInsert(rel, tup);

    heap_freetuple(tup);

    ObjectAddressSet(myself, PropgraphElementLabelRelationId, ellabeloid);

    ObjectAddressSet(referenced, PropgraphLabelRelationId, labeloid);

    recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);

    ObjectAddressSet(referenced, PropgraphElementRelationId, peoid);

    recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);

    table_close(rel, NoLock);

  }

  return ellabeloid;

}

/*

 * Insert records for properties into the pg_propgraph_property catalog.

 */

static void

insert_property_records(Oid graphid, Oid ellabeloid, Oid pgerelid, const PropGraphProperties *properties)

{

  List     *proplist = NIL;

  ParseState *pstate;

  ParseNamespaceItem *nsitem;

  List     *tp;

  Relation  rel;

  ListCell   *lc;

  if (properties->all)

  {

    Relation  attRelation;

    SysScanDesc scan;

    ScanKeyData key[1];

    HeapTuple attributeTuple;

    attRelation = table_open(AttributeRelationId, RowShareLock);

    ScanKeyInit(&key[0],

          Anum_pg_attribute_attrelid,

          BTEqualStrategyNumber, F_OIDEQ,

          ObjectIdGetDatum(pgerelid));

    scan = systable_beginscan(attRelation, AttributeRelidNumIndexId,

                  true, NULL, 1, key);

    while (HeapTupleIsValid(attributeTuple = systable_getnext(scan)))

    {

      Form_pg_attribute att = (Form_pg_attribute) GETSTRUCT(attributeTuple);

      ColumnRef  *cr;

      ResTarget  *rt;

      if (att->attnum <= 0 || att->attisdropped)

        continue;

      cr = makeNode(ColumnRef);

      rt = makeNode(ResTarget);

      cr->fields = list_make1(makeString(pstrdup(NameStr(att->attname))));

      cr->location = -1;

      rt->name = pstrdup(NameStr(att->attname));

      rt->val = (Node *) cr;

      rt->location = -1;

      proplist = lappend(proplist, rt);

    }

    systable_endscan(scan);

    table_close(attRelation, RowShareLock);

  }

  else

  {

    proplist = properties->properties;

    foreach(lc, proplist)

    {