开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
tgRecipe.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：20k
源码类别：

数据库系统

开发平台：

Unix_Linux

tgRecipe.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * tgRecipe.c
  4.  * Tioga recipe-related definitions
  5.  * these functions can be used in both the frontend and the
  6.  * backend
  7.  *
  8.  * this file must be kept current with recipe-schema.sql
  9.  *
  10.  * Copyright (c) 1994, Regents of the University of California
  11.  *
  12.  *
  13.  * IDENTIFICATION
  14.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/tioga/tgRecipe.c,v 1.12 1999/05/10 00:45:49 momjian Exp $
  15.  *
  16.  *-------------------------------------------------------------------------
  17.  */
  19. #include <stdlib.h>
  20. #include "postgres.h"
  21. #include "tioga/tgRecipe.h"
  23. #include "catalog/catalog.h" /* for newoid() */
  25. static Arr_TgString *TextArray2ArrTgString(char *str);
  27. #define ARRAY_LEFT_DELIM '{'
  28. #define ARRAY_RIGHT_DELIM '}'
  29. #define ARRAY_ELEM_LEFT '"'
  30. #define ARRAY_ELEM_RIGHT '"'
  31. #define ARRAY_ELEM_SEPARATOR ','
  33. /* maximum length of query string */
  34. #define MAX_QBUF_LENGTH 2048
  36. /**** the queries being used ********/
  37. #define Q_RETRIEVE_RECIPE_BYNAME 
  38.   "select * from Recipes where Recipes.elemName = '%s';"
  39. #define Q_RETRIEVE_ELEMENTS_IN_RECIPE 
  40.   "select e.* from Element e, Node n where n.belongsTo = '%s' and n.nodeElem = e.elemName;"
  41. #define Q_RETRIEVE_NODES_IN_RECIPE 
  42.   "select * from Node n where n.belongsTo = '%s'"
  43. #define Q_LOOKUP_EDGES_IN_RECIPE 
  44.   "select * from Edge e where e.belongsTo = '%s'"
  46. /* static functions only used here */
  47. static void fillTgElement(TgElement * elem, PortalBuffer *pbuf, int tupno);
  48. static void fillTgNode(TgRecipe * r, TgNode * node, PortalBuffer *pbuf, int tupno);
  49. static TgRecipe *fillTgRecipe(PortalBuffer *pbuf, int tupno);
  50. static void lookupEdges(TgRecipe * r, char *name);
  51. static void fillAllNodes(TgRecipe * r, char *name);
  52. static void fillAllElements(TgRecipe * r, char *name);
  53. static TgNode *connectTee(TgRecipe * r, TgNodePtr fromNode, TgNodePtr toNode,
  54.    int fromPort, int toPort);
  56. /*
  57.  * TextArray2ArrTgString --  take a string of the form:
  58.  * {"fooo", "bar", "xxxxx"} (for postgres)
  59.  * and parse it into a Array of TgString's
  60.  *
  61.  * always returns a valid Arr_TgString.  It could be a newly initialized one with
  62.  * zero elements
  63.  */
  64. Arr_TgString *
  65. TextArray2ArrTgString(char *str)
  66. {
  67. Arr_TgString *result;
  69. char    *beginQuote;
  70. char    *endQuote;
  71. int nextlen;
  72. char    *word;
  74. result = newArr_TgString();
  76. if ((str == NULL) || (str[0] == ''))
  77. return result;
  79. if (*str != ARRAY_LEFT_DELIM)
  80. {
  81. elog(NOTICE, "TextArray2ArrTgString: badly formed string, must have %c as 
  82. first charactern", ARRAY_LEFT_DELIM);
  83. return result;
  84. }
  86. str++; /* skip the first { */
  87. while (*str != '}')
  88. {
  89. if (*str == '')
  90. {
  91. elog(NOTICE, "TextArray2ArrTgString: text string ended prematurelyn");
  92. return result;
  93. }
  95. if ((beginQuote = index(str, ARRAY_ELEM_LEFT)) == NULL)
  96. {
  97. elog(NOTICE, "textArray2ArrTgString:  missing a begin quoten");
  98. return result;
  99. }
  100. if ((endQuote = index(beginQuote + 1, '"')) == NULL)
  101. {
  102. elog(NOTICE, "textArray2ArrTgString:  missing an end quoten");
  103. return result;
  104. }
  105. nextlen = endQuote - beginQuote; /* don't subtract one here
  106.  * because we need the
  107.  * extra character for 
  108.  * anyway */
  109. word = (char *) malloc(nextlen);
  110. StrNCpy(word, beginQuote + 1, nextlen);
  111. addArr_TgString(result, (TgString *) & word);
  112. free(word);
  113. str = endQuote + 1;
  114. }
  115. return result;
  116. }
  118. /* -------------------------------------
  119. findElemInRecipe()
  120.    given an element name, find that element in the TgRecipe structure and return it.
  122.    XXX Currently, this is done by linear search.  Change to using a hash table.
  123. -------------------------------------- */
  125. TgElement  *
  126. findElemInRecipe(TgRecipe * r, char *elemName)
  127. {
  128. int i;
  129. Arr_TgElementPtr *arr = r->elements;
  130. TgElement  *e;
  132. for (i = 0; i < arr->num; i++)
  133. {
  134. e = (TgElement *) arr->val[i];
  135. if (strcmp(e->elemName, elemName) == 0)
  136. return e;
  137. }
  138. elog(NOTICE, "Element named %s not found in recipe named %s", elemName, r->elmValue.elemName);
  139. return NULL;
  140. }
  142. /* -------------------------------------
  143. findNodeInRecipe()
  144.    given an node name, find that node in the TgRecipe structure and return it.
  146.    XXX Currently, this is done by linear search.  Change to using a hash table.
  147. -------------------------------------- */
  149. TgNode *
  150. findNodeInRecipe(TgRecipe * r, char *nodeName)
  151. {
  152. int i;
  153. Arr_TgNodePtr *arr = r->allNodes;
  154. TgNode    *n;
  156. for (i = 0; i < arr->num; i++)
  157. {
  158. n = (TgNode *) arr->val[i];
  159. if (strcmp(n->nodeName, nodeName) == 0)
  160. return n;
  161. }
  162. elog(NOTICE, "Node named %s not found in recipe named %s", nodeName, r->elmValue.elemName);
  163. return NULL;
  164. }
  167. /* -------------------------------------
  168. fillTgNode
  169. takes a query result in the PortalBuffer containing a Node
  170. and converts it to a C Node strcture.
  171. The Node structure passed in is 'filled' appropriately
  173. -------------------------------------- */
  175. void
  176. fillTgNode(TgRecipe * r, TgNode * node, PortalBuffer *pbuf, int tupno)
  177. {
  178. char    *nodeType;
  179. char    *nodeElem;
  180. char    *locString; /* ascii string rep of the point */
  181. static int attnums_initialized = 0;
  182. static int nodeName_attnum;
  183. static int nodeElem_attnum;
  184. static int nodeType_attnum;
  185. static int loc_attnum;
  186. TgNodePtr BlankNodePtr;
  187. int i;
  189. if (!attnums_initialized)
  190. {
  192. /*
  193.  * the first time fillTgNode is called, we find out all the
  194.  * relevant attribute numbers in a TgNode so subsequent calls are
  195.  * speeded up, the assumption is that the schema won't change
  196.  * between calls
  197.  */
  198. nodeName_attnum = PQfnumber(pbuf, tupno, "nodeName");
  199. nodeElem_attnum = PQfnumber(pbuf, tupno, "nodeElem");
  200. nodeType_attnum = PQfnumber(pbuf, tupno, "nodeType");
  201. loc_attnum = PQfnumber(pbuf, tupno, "loc");
  202. attnums_initialized = 1;
  203. }
  204. node->nodeName = PQgetAttr(pbuf, tupno, nodeName_attnum);
  205. locString = PQgetvalue(pbuf, tupno, loc_attnum);
  206. if (locString == NULL || locString[0] == '')
  207. {
  208. node->loc.x = 0;
  209. node->loc.y = 0; /* assign to zero for default */
  210. }
  211. else
  212. {
  213. float x,
  214. y;
  216. sscanf(locString, "(%f, %f)", &x, &y);
  217. node->loc.x = x;
  218. node->loc.y = y;
  219. }
  220. nodeElem = PQgetvalue(pbuf, tupno, nodeElem_attnum);
  221. node->nodeElem = findElemInRecipe(r, nodeElem);
  222. node->inNodes = newArr_TgNodePtr();
  223. node->outNodes = newArr_TgNodePtr();
  225. /*
  226.  * fill the inNodes array with as many NULL's are there are inPorts in
  227.  * the underlying element
  228.  */
  229. BlankNodePtr = (TgNodePtr) NULL;
  230. for (i = 0; i < node->nodeElem->inPorts->num; i++)
  231. addArr_TgNodePtr(node->inNodes, &BlankNodePtr);
  233. /*
  234.  * fill the outNodes array with as many NULL's are there are inPorts
  235.  * in the underlying element
  236.  */
  237. for (i = 0; i < node->nodeElem->outPorts->num; i++)
  238. addArr_TgNodePtr(node->outNodes, &BlankNodePtr);
  240. nodeType = PQgetvalue(pbuf, tupno, nodeType_attnum);
  242. if (strcmp(nodeType, "Ingred") == 0)
  243. node->nodeType = TG_INGRED_NODE;
  244. else if (strcmp(nodeType, "Eye") == 0)
  245. node->nodeType = TG_EYE_NODE;
  246. else if (strcmp(nodeType, "Recipe") == 0)
  247. node->nodeType = TG_RECIPE_NODE;
  248. else
  249. elog(NOTICE, "fillTgNode: unknown nodeType field value : %sn", nodeType);
  251. }
  253. /* -------------------------------------
  254. fillTgElement
  255. takes a query result in the PortalBuffer containing a Element
  256. and converts it to a C TgElement strcture.
  257. The TgElement structure passed in is 'filled' appropriately
  258.   ------------------------------------ */
  260. void
  261. fillTgElement(TgElement * elem, PortalBuffer *pbuf, int tupno)
  262. {
  263. char    *srcLang,
  264.    *elemType;
  265. static int attnums_initialized = 0;
  266. static int elemName_attnum;
  267. static int elemType_attnum;
  268. static int inPorts_attnum;
  269. static int inTypes_attnum;
  270. static int outPorts_attnum;
  271. static int outTypes_attnum;
  272. static int doc_attnum;
  273. static int keywords_attnum;
  274. static int icon_attnum;
  275. static int srcLang_attnum;
  276. static int src_attnum;
  277. static int owner_attnum;
  279. if (!attnums_initialized)
  280. {
  282. /*
  283.  * the first time fillTgElement is called, we find out all the
  284.  * relevant attribute numbers in a TgElement so subsequent calls
  285.  * are speeded up, the assumption is that the schema won't change
  286.  * between calls
  287.  */
  288. elemName_attnum = PQfnumber(pbuf, tupno, "elemName");
  289. elemType_attnum = PQfnumber(pbuf, tupno, "elemType");
  290. inPorts_attnum = PQfnumber(pbuf, tupno, "inPorts");
  291. inTypes_attnum = PQfnumber(pbuf, tupno, "inTypes");
  292. outPorts_attnum = PQfnumber(pbuf, tupno, "outPorts");
  293. outTypes_attnum = PQfnumber(pbuf, tupno, "outTypes");
  294. doc_attnum = PQfnumber(pbuf, tupno, "doc");
  295. keywords_attnum = PQfnumber(pbuf, tupno, "keywords");
  296. icon_attnum = PQfnumber(pbuf, tupno, "icon");
  297. srcLang_attnum = PQfnumber(pbuf, tupno, "srcLang");
  298. src_attnum = PQfnumber(pbuf, tupno, "src");
  299. attnums_initialized = 1;
  300. }
  302. elem->elemName = PQgetAttr(pbuf, tupno, elemName_attnum);
  303. elem->inPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inPorts_attnum));
  304. elem->inTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inTypes_attnum));
  305. elem->outPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outPorts_attnum));
  306. elem->outTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outTypes_attnum));
  307. elem->doc = PQgetAttr(pbuf, tupno, doc_attnum);
  308. elem->keywords = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, keywords_attnum));
  309. elem->icon = PQgetAttr(pbuf, tupno, icon_attnum);
  310. elem->src = PQgetAttr(pbuf, tupno, src_attnum);
  311. elem->owner = PQgetAttr(pbuf, tupno, owner_attnum);
  313. /*
  314.  * we don't need to keep the value returned so use PQgetvalue()
  315.  * instead of PQgetAttr()
  316.  */
  317. srcLang = PQgetvalue(pbuf, tupno, srcLang_attnum);
  319. if (strcmp(srcLang, "SQL") == 0)
  320. elem->srcLang = TG_SQL;
  321. else if (strcmp(srcLang, "C") == 0)
  322. elem->srcLang = TG_C;
  323. else if (strcmp(srcLang, "RecipeGraph") == 0)
  324. elem->srcLang = TG_RECIPE_GRAPH;
  325. else if (strcmp(srcLang, "Compiled") == 0)
  326. elem->srcLang = TG_COMPILED;
  327. else
  328. elog(NOTICE, "fillTgElement(): unknown srcLang field value : %sn", srcLang);
  330. elemType = PQgetvalue(pbuf, tupno, elemType_attnum);
  331. if (strcmp(elemType, "Ingred") == 0)
  332. elem->elemType = TG_INGRED;
  333. else if (strcmp(elemType, "Eye") == 0)
  334. elem->elemType = TG_EYE;
  335. else if (strcmp(elemType, "Recipe") == 0)
  336. elem->elemType = TG_RECIPE;
  337. else
  338. elog(NOTICE, "fillTgElement(): unknown elemType field value : %sn", elemType);
  341. }
  343. /* -------------------------------------
  344. lookupEdges -
  345. look up the edges of a recipe and fill in the inNodes
  346. and outNodes of each node.
  347. In the process of connecting edges, we detect tee's and create
  348. teeNodes.  We add the teeNodes to the allNodes field of r as well
  349. ------------------------------------ */
  350. void
  351. lookupEdges(TgRecipe * r, char *name)
  352. {
  353. char qbuf[MAX_QBUF_LENGTH];
  354. int i;
  355. char    *pqres;
  356. char    *pbufname;
  357. PortalBuffer *pbuf;
  358. int ntups;
  359. int fromNode_attnum;
  360. int fromPort_attnum;
  361. int toPort_attnum;
  362. int toNode_attnum;
  363. char    *toNode,
  364.    *fromNode;
  365. char    *toPortStr,
  366.    *fromPortStr;
  367. int toPort,
  368. fromPort;
  370. TgNodePtr fromNodePtr,
  371. toNodePtr;
  373. sprintf(qbuf, Q_LOOKUP_EDGES_IN_RECIPE, name);
  374. pqres = PQexec(qbuf);
  375. pqres = PQexec(qbuf);
  376. if (*pqres == 'R' || *pqres == 'E')
  377. {
  378. elog(NOTICE, "lookupEdges(): Error while executing query : %sn", qbuf);
  379. elog(NOTICE, "result = %s, error is %sn", pqres, PQerrormsg);
  380. return;
  381. }
  382. pbufname = ++pqres;
  383. pbuf = PQparray(pbufname);
  384. ntups = PQntuplesGroup(pbuf, 0);
  386. if (ntups == 0)
  387. return;
  389. fromNode_attnum = PQfnumber(pbuf, 0, "fromNode");
  390. fromPort_attnum = PQfnumber(pbuf, 0, "fromPort");
  391. toNode_attnum = PQfnumber(pbuf, 0, "toNode");
  392. toPort_attnum = PQfnumber(pbuf, 0, "toPort");
  394. for (i = 0; i < ntups; i++)
  395. {
  397. fromNode = PQgetvalue(pbuf, i, fromNode_attnum);
  398. toNode = PQgetvalue(pbuf, i, toNode_attnum);
  399. fromPortStr = PQgetvalue(pbuf, i, fromPort_attnum);
  400. toPortStr = PQgetvalue(pbuf, i, toPort_attnum);
  402. if (!fromPortStr || fromPortStr[0] == '')
  403. {
  404. elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with invalid fromPort value!");
  405. return;
  406. }
  407. if (!toPortStr || toPortStr[0] == '')
  408. {
  409. elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with invalid toPort value!!");
  410. return;
  411. }
  412. fromPort = atoi(fromPortStr);
  413. toPort = atoi(toPortStr);
  415. fromNodePtr = findNodeInRecipe(r, fromNode);
  416. if (!fromNodePtr)
  417. {
  418. elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with bad fromNode value!");
  419. return;
  420. }
  421. toNodePtr = findNodeInRecipe(r, toNode);
  422. if (!toNodePtr)
  423. {
  424. elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with bad toNode value!");
  425. return;
  426. }
  428. /*
  429.  * check to see if the from port is already connected. if it is,
  430.  * then this means we should construct a Tee node
  431.  */
  432. if (fromNodePtr->outNodes->val[fromPort - 1] != NULL)
  433. {
  434. TgNodePtr tn;
  436. tn = connectTee(r, fromNodePtr, toNodePtr, fromPort, toPort);
  437. addArr_TgNodePtr(r->allNodes, &tn);
  438. }
  439. else
  440. {
  441. fromNodePtr->outNodes->val[fromPort - 1] = toNodePtr;
  442. toNodePtr->inNodes->val[toPort - 1] = fromNodePtr;
  443. }
  444. }
  446. PQclear(pbufname);
  447. }
  449. /*
  450.    handle tee connections here
  451.    Everytime an output port is connected multiply,
  452.    we explicitly insert TgTeeNode
  454.    returns the teeNode created
  455. */
  456. static TgNode *
  457. connectTee(TgRecipe * r, TgNodePtr fromNode, TgNodePtr toNode,
  458.    int fromPort, int toPort)
  459. {
  460. TgNodePtr origToNode;
  461. TgNodePtr tn;
  462. TgNodePtr BlankNodePtr;
  463. int origToPort;
  464. int i;
  466. /* the toNode formerly pointed to */
  467. origToNode = fromNode->outNodes->val[fromPort - 1];
  469. if (origToNode == NULL)
  470. {
  471. elog(NOTICE, "Internal Error: connectTee() called with a null origToNode");
  472. return;
  473. }
  475. for (i = 0; i < origToNode->inNodes->num; i++)
  476. {
  477. if (origToNode->inNodes->val[i] == fromNode)
  478. break;
  479. }
  481. /* the inport of the former toNode */
  482. /* ports start with 1, array indices start from 0 */
  483. origToPort = i + 1;
  485. /* add a tee node now. */
  486. tn = malloc(sizeof(TgNode));
  487. /* generate a name for the tee node table */
  488. tn->nodeName = malloc(50);
  489. sprintf(tn->nodeName, "tee_%u", newoid());
  490. /*   tn->nodeName = NULL; */
  492. tn->nodeType = TG_TEE_NODE;
  493. tn->nodeElem = NULL;
  494. tn->inNodes = newArr_TgNodePtr();
  495. tn->outNodes = newArr_TgNodePtr();
  497. BlankNodePtr = (TgNodePtr) NULL;
  498. /* each TgTeeNode has one input and two outputs, NULL them initiallly */
  499. addArr_TgNodePtr(tn->inNodes, &BlankNodePtr);
  500. addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
  501. addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
  503. /*
  504.  * make the old toNode the left parent of the tee node add the new
  505.  * toNode as the right parent of the tee node
  506.  */
  507. tn->outNodes->val[0] = origToNode;
  508. origToNode->inNodes->val[origToPort - 1] = tn;
  510. tn->outNodes->val[1] = toNode;
  511. toNode->inNodes->val[toPort - 1] = tn;
  513. /* connect the fromNode to the new tee node */
  514. fromNode->outNodes->val[fromPort - 1] = tn;
  515. tn->inNodes->val[0] = fromNode;
  517. return tn;
  518. }
  520. /* -------------------------------------
  521. fillAllNodes
  522. fill out the nodes of a recipe
  523.   ------------------------------------ */
  524. void
  525. fillAllNodes(TgRecipe * r, char *name)
  526. {
  527. char qbuf[MAX_QBUF_LENGTH];
  528. int i;
  529. char    *pqres;
  530. char    *pbufname;
  531. PortalBuffer *pbuf;
  532. int ntups;
  533. TgElement  *elem;
  534. TgNode    *node;
  536. /* 1) fill out the elements that are in the recipe */
  537. sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
  538. pqres = PQexec(qbuf);
  539. if (*pqres == 'R' || *pqres == 'E')
  540. {
  541. elog(NOTICE, "fillAllNodes(): Error while executing query : %sn", qbuf);
  542. elog(NOTICE, "result = %s, error is %sn", pqres, PQerrormsg);
  543. return;
  544. }
  545. pbufname = ++pqres;
  546. pbuf = PQparray(pbufname);
  547. ntups = PQntuplesGroup(pbuf, 0);
  548. for (i = 0; i < ntups; i++)
  549. {
  550. elem = malloc(sizeof(TgElement));
  551. fillTgElement(elem, pbuf, i);
  552. addArr_TgElementPtr(r->elements, &elem);
  553. }
  554. PQclear(pbufname);
  556. sprintf(qbuf, Q_RETRIEVE_NODES_IN_RECIPE, name);
  557. pqres = PQexec(qbuf);
  558. if (*pqres == 'R' || *pqres == 'E')
  559. {
  560. elog(NOTICE, "fillAllNodes(): Error while executing query : %sn", qbuf);
  561. elog(NOTICE, "result = %s, error is %sn", pqres, PQerrormsg);
  562. return;
  563. }
  564. pbufname = ++pqres;
  565. pbuf = PQparray(pbufname);
  566. ntups = PQntuplesGroup(pbuf, 0);
  567. for (i = 0; i < ntups; i++)
  568. {
  569. node = malloc(sizeof(TgNode));
  570. fillTgNode(r, node, pbuf, i);
  571. addArr_TgNodePtr(r->allNodes, &node);
  572. }
  573. PQclear(pbufname);
  575. }
  578. /* -------------------------------------
  579. fillAllElements
  580. fill out the elements of a recipe
  581.   ------------------------------------ */
  582. void
  583. fillAllElements(TgRecipe * r, char *name)
  584. {
  585. char qbuf[MAX_QBUF_LENGTH];
  586. int i;
  587. char    *pqres;
  588. char    *pbufname;
  589. PortalBuffer *pbuf;
  590. int ntups;
  591. TgElement  *elem;
  593. sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
  594. pqres = PQexec(qbuf);
  595. if (*pqres == 'R' || *pqres == 'E')
  596. {
  597. elog(NOTICE, "fillAllElements(): Error while executing query : %sn", qbuf);
  598. elog(NOTICE, "result = %s, error is %sn", pqres, PQerrormsg);
  599. return;
  600. }
  601. pbufname = ++pqres;
  602. pbuf = PQparray(pbufname);
  603. ntups = PQntuplesGroup(pbuf, 0);
  604. for (i = 0; i < ntups; i++)
  605. {
  606. elem = malloc(sizeof(TgElement));
  607. fillTgElement(elem, pbuf, i);
  608. addArr_TgElementPtr(r->elements, &elem);
  609. }
  610. PQclear(pbufname);
  612. }
  615. /* -------------------------------------
  616. fillTgRecipe
  617. takes a query result in the PortalBuffer containing a Recipe
  618. and converts it to a C TgRecipe strcture
  619.   ------------------------------------ */
  620. TgRecipe   *
  621. fillTgRecipe(PortalBuffer *pbuf, int tupno)
  622. {
  623. TgRecipe   *r;
  624. int i,
  625. j;
  627. /* 1) set up the recipe structure */
  628. r = (TgRecipe *) malloc(sizeof(TgRecipe));
  629. fillTgElement(&r->elmValue, pbuf, 0);
  630. r->elmValue.elemType = TG_RECIPE;
  631. r->allNodes = newArr_TgNodePtr();
  632. r->rootNodes = newArr_TgNodePtr();
  633. r->eyes = newArr_TgNodePtr();
  634. r->tees = newArr_TgNodePtr();
  635. r->elements = newArr_TgElementPtr();
  637. /*
  638.  * 2) find all the elements. There may be less elements than nodes
  639.  * because you can have multiple instantiations of an element in a
  640.  * recipe
  641.  */
  642. fillAllElements(r, r->elmValue.elemName);
  644. /* 3) find all the nodes in the recipe */
  645. fillAllNodes(r, r->elmValue.elemName);
  647. /*
  648.  * 4) find all the edges, and connect the nodes, may also add tee
  649.  * nodes to the allNodes field
  650.  */
  651. lookupEdges(r, r->elmValue.elemName);
  653. /* 5) find all the rootNodes in the recipe */
  655. /*
  656.  * root nodes are nodes with no incoming nodes or whose incoming nodes
  657.  * are all null
  658.  */
  659. /* 6) find all the eyes in the recipe */
  660. /* eye nodes are nodes with the node type TG_EYE_NODE */
  661. /* 7) find all the tee nodes in the recipe */
  662. /* tee nodes are nodes with the node type TG_TEE_NODE */
  663. for (i = 0; i < r->allNodes->num; i++)
  664. {
  665. TgNode    *nptr = r->allNodes->val[i];
  667. if (nptr->nodeType == TG_EYE_NODE)
  668. addArr_TgNodePtr(r->eyes, &nptr);
  669. else if (nptr->nodeType == TG_TEE_NODE)
  670. addArr_TgNodePtr(r->tees, &nptr);
  672. if (nptr->inNodes->num == 0)
  673. addArr_TgNodePtr(r->rootNodes, &nptr);
  674. else
  675. {
  676. for (j = 0;
  677.    j < nptr->inNodes->num && (nptr->inNodes->val[j] == NULL);
  678.  j++);
  679. if (j == nptr->inNodes->num)
  680. addArr_TgNodePtr(r->rootNodes, &nptr);
  681. }
  682. }
  684. return r;
  686. }
  689. /* -------------------------------------
  690. retrieveRecipe
  691.    find the recipe with the given name
  692.   ------------------------------------ */
  693. TgRecipe   *
  694. retrieveRecipe(char *name)
  695. {
  696. char qbuf[MAX_QBUF_LENGTH];
  697. TgRecipe   *recipe;
  698. char    *pqres;
  699. char    *pbufname;
  700. PortalBuffer *pbuf;
  701. int ntups;
  703. sprintf(qbuf, Q_RETRIEVE_RECIPE_BYNAME, name);
  705. pqres = PQexec(qbuf);
  706. if (*pqres == 'R' || *pqres == 'E')
  707. {
  708. elog(NOTICE, "retrieveRecipe: Error while executing query : %sn", qbuf);
  709. elog(NOTICE, "result = %s, error is %sn", pqres, PQerrormsg);
  710. return NULL;
  711. }
  712. pbufname = ++pqres;
  713. pbuf = PQparray(pbufname);
  714. ntups = PQntuplesGroup(pbuf, 0);
  715. if (ntups == 0)
  716. {
  717. elog(NOTICE, "retrieveRecipe():  No recipe named %s existsn", name);
  718. return NULL;
  719. }
  720. if (ntups != 1)
  721. {
  722. elog(NOTICE, "retrieveRecipe():  Multiple (%d) recipes named %s existsn", ntups, name);
  723. return NULL;
  724. }
  726. recipe = fillTgRecipe(pbuf, 0);
  728. PQclear(pbufname);
  729. return recipe;
  731. }
  733. /* -------------------- copyXXX functions ----------------------- */
  734. void
  735. copyTgElementPtr(TgElementPtr * from, TgElementPtr * to)
  736. {
  737. *to = *from;
  738. }
  740. void
  741. copyTgNodePtr(TgNodePtr * from, TgNodePtr * to)
  742. {
  743. *to = *from;
  744. }
  746. void
  747. copyTgRecipePtr(TgRecipePtr * from, TgRecipePtr * to)
  748. {
  749. *to = *from;
  750. }
  752. void
  753. copyTgString(TgString * from, TgString * to)
  754. {
  755. TgString fromTgString = *from;
  756. TgString toTgString;
  758. toTgString = (TgString) malloc(strlen(fromTgString) + 1);
  759. strcpy(toTgString, fromTgString);
  760. *to = toTgString;
  761. }