Skip to content

P
Postgres FD Implementation
Commit 03d39ce0 authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

Remove TIOGA files from CVS current; they remain in repositiry.

parent fbb1966c
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 1152 deletions
src/backend/tioga/Arr_TgRecipe.h deleted 100644 → 0
View file @ fbb1966c
#include "tioga/Varray.h"
/* Modify the following size macros to suit your need. */
#ifndef Arr_TgString_INITIAL_SIZE
#define Arr_TgString_INITIAL_SIZE 32
#endif
#ifndef Arr_TgElementPtr_INITIAL_SIZE
#define Arr_TgElementPtr_INITIAL_SIZE 32
#endif
#ifndef Arr_TgNodePtr_INITIAL_SIZE
#define Arr_TgNodePtr_INITIAL_SIZE 32
#endif
/***************************************************************/
/* Do not modify anything below this line. */
/***************************************************************/
/* -- Defining types and function for Arr_TgString type -- */
/* -- the following must be supplied by the user:
void copyTgString(TgString* from, TgString* to); - make a copy of TgString.
*/
#ifndef _ARR_TgString_
#define _ARR_TgString_
#ifndef ARR_TgString_INITIAL_SIZE
#define ARR_TgString_INITIAL_SIZE 32 /* change this size to suit your
* need */
#endif /* ARR_TgString_INITIAL_SIZE */
typedef struct Arr_TgString
{
size_t num;
size_t size;
size_t valSize;
TgString *val;
} Arr_TgString;
#define newArr_TgString() \
(Arr_TgString *) NewVarray(ARR_TgString_INITIAL_SIZE, sizeof(TgString))
#define enlargeArr_TgString(A, I) \
( \
(A)->size += (I), \
(A)->val = (TgString *) realloc((A)->val, (A)->valSize * (A)->size) \
)
#define addArr_TgString(A, V) \
AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgString)
#define deleteArr_TgString(A) FreeVarray(A)
#endif /* _ARR_TgString_ */
/* -- Defining types and function for Arr_TgElementPtr type -- */
/* -- the following must be supplied by the user:
void copyTgElementPtr(TgElementPtr* from, TgElementPtr* to); - make a copy of TgElementPtr.
*/
#ifndef _ARR_TgElementPtr_
#define _ARR_TgElementPtr_
#ifndef ARR_TgElementPtr_INITIAL_SIZE
#define ARR_TgElementPtr_INITIAL_SIZE 32 /* change this size to
* suit your need */
#endif /* ARR_TgElementPtr_INITIAL_SIZE */
typedef struct Arr_TgElementPtr
{
size_t num;
size_t size;
size_t valSize;
TgElementPtr *val;
} Arr_TgElementPtr;
#define newArr_TgElementPtr() \
(Arr_TgElementPtr *) NewVarray(ARR_TgElementPtr_INITIAL_SIZE, sizeof(TgElementPtr))
#define enlargeArr_TgElementPtr(A, I) \
( \
(A)->size += (I), \
(A)->val = (TgElementPtr *) realloc((A)->val, (A)->valSize * (A)->size) \
)
#define addArr_TgElementPtr(A, V) \
AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgElementPtr)
#define deleteArr_TgElementPtr(A) FreeVarray(A)
#endif /* _ARR_TgElementPtr_ */
/* -- Defining types and function for Arr_TgNodePtr type -- */
/* -- the following must be supplied by the user:
void copyTgNodePtr(TgNodePtr* from, TgNodePtr* to); - make a copy of TgNodePtr.
*/
#ifndef _ARR_TgNodePtr_
#define _ARR_TgNodePtr_
#ifndef ARR_TgNodePtr_INITIAL_SIZE
#define ARR_TgNodePtr_INITIAL_SIZE 32 /* change this size to suit your
* need */
#endif /* ARR_TgNodePtr_INITIAL_SIZE */
typedef struct Arr_TgNodePtr
{
size_t num;
size_t size;
size_t valSize;
TgNodePtr *val;
} Arr_TgNodePtr;
#define newArr_TgNodePtr() \
(Arr_TgNodePtr *) NewVarray(ARR_TgNodePtr_INITIAL_SIZE, sizeof(TgNodePtr))
#define enlargeArr_TgNodePtr(A, I) \
( \
(A)->size += (I), \
(A)->val = (TgNodePtr *) realloc((A)->val, (A)->valSize * (A)->size) \
)
#define addArr_TgNodePtr(A, V) \
AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgNodePtr)
#define deleteArr_TgNodePtr(A) FreeVarray(A)
#endif /* _ARR_TgNodePtr_ */
src/backend/tioga/Makefile deleted 100644 → 0
View file @ fbb1966c
#-------------------------------------------------------------------------
#
# Makefile--
# Makefile for tioga
#
# IDENTIFICATION
# $Header: /cvsroot/pgsql/src/backend/tioga/Attic/Makefile,v 1.10 2001/02/20 19:20:28 petere Exp $
#
#-------------------------------------------------------------------------
subdir = src/backend/tioga
top_builddir = ../../..
include $(top_builddir)/src/Makefile.global
OBJS = tgRecipe.o Varray.o
override CPPFLAGS := -I$(srcdir) $(CPPFLAGS)
all: SUBSYS.o
SUBSYS.o: $(OBJS)
$(LD) $(LDREL) $(LDOUT) SUBSYS.o $(OBJS)
depend dep:
$(CC) -MM $(CFLAGS) *.c >depend
clean:
rm -f SUBSYS.o $(OBJS)
ifeq (depend,$(wildcard depend))
include depend
endif
src/backend/tioga/Varray.c deleted 100644 → 0
View file @ fbb1966c
/* ************************************************************************
*
* Varray.c
*
* routines to provide a generic set of functions to handle variable sized
* arrays. originally by Jiang Wu
* ************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "Varray.h"
Varray *
NewVarray(size_t nobj, size_t size)
/*
* NewVarray -- allocate a Varray to contain an array of val each of which
* is size valSize. Returns the Varray if successful,
* returns NULL otherwise.
*/
{
Varray *result;
if (nobj == 0)
nobj = VARRAY_INITIAL_SIZE;
result = (Varray *) malloc(sizeof(Varray));
result->val = (void *) calloc(nobj, size);
if (result == NULL)
return NULL;
result->size = size;
result->nobj = 0;
result->maxObj = nobj;
return result;
}
int
AppendVarray(Varray * array, void *value, CopyingFunct copy)
/*
* AppendVarray -- append value to the end of array. This function
* returns the size of the array after the addition of
* the new element.
*/
{
copy(value, VARRAY_NTH(array->val, array->size, array->nobj));
array->nobj++;
if (array->nobj >= array->maxObj)
ENLARGE_VARRAY(array, array->maxObj / 2);
return array->nobj;
}
src/backend/tioga/Varray.h deleted 100644 → 0
View file @ fbb1966c
/* ********************************************************************
*
* Varray.h -- header file for varray.c which provides a generic
* set of functions to handle variable sized arrays.
*
* originally by Jiang Wu
* ********************************************************************/
#ifndef _VARRAY_H_
#define _VARRAY_H_
typedef struct _varray
{
size_t nobj; /* number of objects in this array */
size_t maxObj; /* max. number of objects in this array */
size_t size; /* size of each element in the array */
void *val; /* array of elements */
} Varray;
/* type for custom copying function */
typedef void (*CopyingFunct) (void *from, void *to);
#define VARRAY_INITIAL_SIZE 32
#define ENLARGE_VARRAY(ARRAY, INC) \
( \
(ARRAY)->maxObj += (INC), \
(ARRAY)->val = (void *) realloc((ARRAY)->val, \
(ARRAY)->size * (ARRAY)->maxObj) \
)
#define VARRAY_NTH(VAL, SIZE, N) (((char *) (VAL)) + (SIZE) * (N))
#define FreeVarray(ARRAY) \
if ((ARRAY) != NULL) { free((ARRAY)->val); free((ARRAY)); (ARRAY) = NULL ; }
#define ModifyVarray(ARRAY, N, NEW, COPY) \
if ((N) < (ARRAY)->nobj) \
(COPY)(VARRAY_NTH((ARRAY)->val, (ARRAY)->size, (N)), (NEW))
#define GetVarray(ARRAY, N) \
((N) < (ARRAY)->nobj ? VARRAY_NTH((ARRAY)->val, (ARRAY)->size, (N)) \
: NULL)
extern Varray *NewVarray(size_t nobj, size_t size);
extern int AppendVarray(Varray * array, void *value, CopyingFunct copy);
#endif /* _VARRAY_H_ */
src/backend/tioga/tgRecipe.c deleted 100644 → 0
View file @ fbb1966c
/*-------------------------------------------------------------------------
*
* tgRecipe.c
* Tioga recipe-related definitions
* these functions can be used in both the frontend and the
* backend
*
* this file must be kept current with recipe-schema.sql
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.22 2002/06/20 20:29:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "catalog/catalog.h"
#include "tioga/tgRecipe.h"
static Arr_TgString *TextArray2ArrTgString(char *str);
#define ARRAY_LEFT_DELIM '{'
#define ARRAY_RIGHT_DELIM '}'
#define ARRAY_ELEM_LEFT '"'
#define ARRAY_ELEM_RIGHT '"'
#define ARRAY_ELEM_SEPARATOR ','
/* maximum length of query string */
#define MAX_QBUF_LENGTH 2048
/**** the queries being used ********/
#define Q_RETRIEVE_RECIPE_BYNAME \
"select * from Recipes where Recipes.elemName = '%s';"
#define Q_RETRIEVE_ELEMENTS_IN_RECIPE \
"select e.* from Element e, Node n where n.belongsTo = '%s' and n.nodeElem = e.elemName;"
#define Q_RETRIEVE_NODES_IN_RECIPE \
"select * from Node n where n.belongsTo = '%s'"
#define Q_LOOKUP_EDGES_IN_RECIPE \
"select * from Edge e where e.belongsTo = '%s'"
/* static functions only used here */
static void fillTgElement(TgElement * elem, PortalBuffer * pbuf, int tupno);
static void fillTgNode(TgRecipe * r, TgNode * node, PortalBuffer * pbuf, int tupno);
static TgRecipe *fillTgRecipe(PortalBuffer * pbuf, int tupno);
static void lookupEdges(TgRecipe * r, char *name);
static void fillAllNodes(TgRecipe * r, char *name);
static void fillAllElements(TgRecipe * r, char *name);
static TgNode *connectTee(TgRecipe * r, TgNodePtr fromNode, TgNodePtr toNode,
int fromPort, int toPort);
/*
* TextArray2ArrTgString -- take a string of the form:
* {"fooo", "bar", "xxxxx"} (for postgres)
* and parse it into a Array of TgString's
*
* always returns a valid Arr_TgString. It could be a newly initialized one with
* zero elements
*/
Arr_TgString *
TextArray2ArrTgString(char *str)
{
Arr_TgString *result;
char *beginQuote;
char *endQuote;
int nextlen;
char *word;
result = newArr_TgString();
if ((str == NULL) || (str[0] == '\0'))
return result;
if (*str != ARRAY_LEFT_DELIM)
{
elog(WARNING, "TextArray2ArrTgString: badly formed string, must have %c as \
first character\n", ARRAY_LEFT_DELIM);
return result;
}
str++; /* skip the first { */
while (*str != '}')
{
if (*str == '\0')
{
elog(WARNING, "TextArray2ArrTgString: text string ended prematurely\n");
return result;
}
if ((beginQuote = strchr(str, ARRAY_ELEM_LEFT)) == NULL)
{
elog(WARNING, "textArray2ArrTgString: missing a begin quote\n");
return result;
}
if ((endQuote = strchr(beginQuote + 1, '"')) == NULL)
{
elog(WARNING, "textArray2ArrTgString: missing an end quote\n");
return result;
}
nextlen = endQuote - beginQuote; /* don't subtract one here
* because we need the
* extra character for \0
* anyway */
word = (char *) malloc(nextlen);
StrNCpy(word, beginQuote + 1, nextlen);
addArr_TgString(result, (TgString *) & word);
free(word);
str = endQuote + 1;
}
return result;
}
/* -------------------------------------
findElemInRecipe()
given an element name, find that element in the TgRecipe structure and return it.
XXX Currently, this is done by linear search. Change to using a hash table.
-------------------------------------- */
TgElement *
findElemInRecipe(TgRecipe * r, char *elemName)
{
int i;
Arr_TgElementPtr *arr = r->elements;
TgElement *e;
for (i = 0; i < arr->num; i++)
{
e = (TgElement *) arr->val[i];
if (strcmp(e->elemName, elemName) == 0)
return e;
}
elog(WARNING, "Element named %s not found in recipe named %s", elemName, r->elmValue.elemName);
return NULL;
}
/* -------------------------------------
findNodeInRecipe()
given an node name, find that node in the TgRecipe structure and return it.
XXX Currently, this is done by linear search. Change to using a hash table.
-------------------------------------- */
TgNode *
findNodeInRecipe(TgRecipe * r, char *nodeName)
{
int i;
Arr_TgNodePtr *arr = r->allNodes;
TgNode *n;
for (i = 0; i < arr->num; i++)
{
n = (TgNode *) arr->val[i];
if (strcmp(n->nodeName, nodeName) == 0)
return n;
}
elog(WARNING, "Node named %s not found in recipe named %s", nodeName, r->elmValue.elemName);
return NULL;
}
/* -------------------------------------
fillTgNode
takes a query result in the PortalBuffer containing a Node
and converts it to a C Node strcture.
The Node structure passed in is 'filled' appropriately
-------------------------------------- */
void
fillTgNode(TgRecipe * r, TgNode * node, PortalBuffer * pbuf, int tupno)
{
char *nodeType;
char *nodeElem;
char *locString; /* ascii string rep of the point */
static int attnums_initialized = 0;
static int nodeName_attnum;
static int nodeElem_attnum;
static int nodeType_attnum;
static int loc_attnum;
TgNodePtr BlankNodePtr;
int i;
if (!attnums_initialized)
{
/*
* the first time fillTgNode is called, we find out all the
* relevant attribute numbers in a TgNode so subsequent calls are
* speeded up, the assumption is that the schema won't change
* between calls
*/
nodeName_attnum = PQfnumber(pbuf, tupno, "nodeName");
nodeElem_attnum = PQfnumber(pbuf, tupno, "nodeElem");
nodeType_attnum = PQfnumber(pbuf, tupno, "nodeType");
loc_attnum = PQfnumber(pbuf, tupno, "loc");
attnums_initialized = 1;
}
node->nodeName = PQgetAttr(pbuf, tupno, nodeName_attnum);
locString = PQgetvalue(pbuf, tupno, loc_attnum);
if (locString == NULL || locString[0] == '\0')
{
node->loc.x = 0;
node->loc.y = 0; /* assign to zero for default */
}
else
{
float x,
y;
sscanf(locString, "(%f, %f)", &x, &y);
node->loc.x = x;
node->loc.y = y;
}
nodeElem = PQgetvalue(pbuf, tupno, nodeElem_attnum);
node->nodeElem = findElemInRecipe(r, nodeElem);
node->inNodes = newArr_TgNodePtr();
node->outNodes = newArr_TgNodePtr();
/*
* fill the inNodes array with as many NULL's are there are inPorts in
* the underlying element
*/
BlankNodePtr = (TgNodePtr) NULL;
for (i = 0; i < node->nodeElem->inPorts->num; i++)
addArr_TgNodePtr(node->inNodes, &BlankNodePtr);
/*
* fill the outNodes array with as many NULL's are there are inPorts
* in the underlying element
*/
for (i = 0; i < node->nodeElem->outPorts->num; i++)
addArr_TgNodePtr(node->outNodes, &BlankNodePtr);
nodeType = PQgetvalue(pbuf, tupno, nodeType_attnum);
if (strcmp(nodeType, "Ingred") == 0)
node->nodeType = TG_INGRED_NODE;
else if (strcmp(nodeType, "Eye") == 0)
node->nodeType = TG_EYE_NODE;
else if (strcmp(nodeType, "Recipe") == 0)
node->nodeType = TG_RECIPE_NODE;
else
elog(WARNING, "fillTgNode: unknown nodeType field value : %s\n", nodeType);
}
/* -------------------------------------
fillTgElement
takes a query result in the PortalBuffer containing a Element
and converts it to a C TgElement strcture.
The TgElement structure passed in is 'filled' appropriately
------------------------------------ */
void
fillTgElement(TgElement * elem, PortalBuffer * pbuf, int tupno)
{
char *srcLang,
*elemType;
static int attnums_initialized = 0;
static int elemName_attnum;
static int elemType_attnum;
static int inPorts_attnum;
static int inTypes_attnum;
static int outPorts_attnum;
static int outTypes_attnum;
static int doc_attnum;
static int keywords_attnum;
static int icon_attnum;
static int srcLang_attnum;
static int src_attnum;
static int owner_attnum;
if (!attnums_initialized)
{
/*
* the first time fillTgElement is called, we find out all the
* relevant attribute numbers in a TgElement so subsequent calls
* are speeded up, the assumption is that the schema won't change
* between calls
*/
elemName_attnum = PQfnumber(pbuf, tupno, "elemName");
elemType_attnum = PQfnumber(pbuf, tupno, "elemType");
inPorts_attnum = PQfnumber(pbuf, tupno, "inPorts");
inTypes_attnum = PQfnumber(pbuf, tupno, "inTypes");
outPorts_attnum = PQfnumber(pbuf, tupno, "outPorts");
outTypes_attnum = PQfnumber(pbuf, tupno, "outTypes");
doc_attnum = PQfnumber(pbuf, tupno, "doc");
keywords_attnum = PQfnumber(pbuf, tupno, "keywords");
icon_attnum = PQfnumber(pbuf, tupno, "icon");
srcLang_attnum = PQfnumber(pbuf, tupno, "srcLang");
src_attnum = PQfnumber(pbuf, tupno, "src");
attnums_initialized = 1;
}
elem->elemName = PQgetAttr(pbuf, tupno, elemName_attnum);
elem->inPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inPorts_attnum));
elem->inTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inTypes_attnum));
elem->outPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outPorts_attnum));
elem->outTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outTypes_attnum));
elem->doc = PQgetAttr(pbuf, tupno, doc_attnum);
elem->keywords = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, keywords_attnum));
elem->icon = PQgetAttr(pbuf, tupno, icon_attnum);
elem->src = PQgetAttr(pbuf, tupno, src_attnum);
elem->owner = PQgetAttr(pbuf, tupno, owner_attnum);
/*
* we don't need to keep the value returned so use PQgetvalue()
* instead of PQgetAttr()
*/
srcLang = PQgetvalue(pbuf, tupno, srcLang_attnum);
if (strcmp(srcLang, "SQL") == 0)
elem->srcLang = TG_SQL;
else if (strcmp(srcLang, "C") == 0)
elem->srcLang = TG_C;
else if (strcmp(srcLang, "RecipeGraph") == 0)
elem->srcLang = TG_RECIPE_GRAPH;
else if (strcmp(srcLang, "Compiled") == 0)
elem->srcLang = TG_COMPILED;
else
elog(WARNING, "fillTgElement(): unknown srcLang field value : %s\n", srcLang);
elemType = PQgetvalue(pbuf, tupno, elemType_attnum);
if (strcmp(elemType, "Ingred") == 0)
elem->elemType = TG_INGRED;
else if (strcmp(elemType, "Eye") == 0)
elem->elemType = TG_EYE;
else if (strcmp(elemType, "Recipe") == 0)
elem->elemType = TG_RECIPE;
else
elog(WARNING, "fillTgElement(): unknown elemType field value : %s\n", elemType);
}
/* -------------------------------------
lookupEdges -
look up the edges of a recipe and fill in the inNodes
and outNodes of each node.
In the process of connecting edges, we detect tee's and create
teeNodes. We add the teeNodes to the allNodes field of r as well
------------------------------------ */
void
lookupEdges(TgRecipe * r, char *name)
{
char qbuf[MAX_QBUF_LENGTH];
int i;
char *pqres;
char *pbufname;
PortalBuffer *pbuf;
int ntups;
int fromNode_attnum;
int fromPort_attnum;
int toPort_attnum;
int toNode_attnum;
char *toNode,
*fromNode;
char *toPortStr,
*fromPortStr;
int toPort,
fromPort;
TgNodePtr fromNodePtr,
toNodePtr;
sprintf(qbuf, Q_LOOKUP_EDGES_IN_RECIPE, name);
pqres = PQexec(qbuf);
pqres = PQexec(qbuf);
if (*pqres == 'R' || *pqres == 'E')
{
elog(WARNING, "lookupEdges(): Error while executing query : %s\n", qbuf);
elog(WARNING, "result = %s, error is %s\n", pqres, PQerrormsg);
return;
}
pbufname = ++pqres;
pbuf = PQparray(pbufname);
ntups = PQntuplesGroup(pbuf, 0);
if (ntups == 0)
return;
fromNode_attnum = PQfnumber(pbuf, 0, "fromNode");
fromPort_attnum = PQfnumber(pbuf, 0, "fromPort");
toNode_attnum = PQfnumber(pbuf, 0, "toNode");
toPort_attnum = PQfnumber(pbuf, 0, "toPort");
for (i = 0; i < ntups; i++)
{
fromNode = PQgetvalue(pbuf, i, fromNode_attnum);
toNode = PQgetvalue(pbuf, i, toNode_attnum);
fromPortStr = PQgetvalue(pbuf, i, fromPort_attnum);
toPortStr = PQgetvalue(pbuf, i, toPort_attnum);
if (!fromPortStr || fromPortStr[0] == '\0')
{
elog(WARNING, "lookupEdges(): SANITY CHECK failed. Edge with invalid fromPort value!");
return;
}
if (!toPortStr || toPortStr[0] == '\0')
{
elog(WARNING, "lookupEdges(): SANITY CHECK failed. Edge with invalid toPort value!!");
return;
}
fromPort = atoi(fromPortStr);
toPort = atoi(toPortStr);
fromNodePtr = findNodeInRecipe(r, fromNode);
if (!fromNodePtr)
{
elog(WARNING, "lookupEdges(): SANITY CHECK failed. Edge with bad fromNode value!");
return;
}
toNodePtr = findNodeInRecipe(r, toNode);
if (!toNodePtr)
{
elog(WARNING, "lookupEdges(): SANITY CHECK failed. Edge with bad toNode value!");
return;
}
/*
* check to see if the from port is already connected. if it is,
* then this means we should construct a Tee node
*/
if (fromNodePtr->outNodes->val[fromPort - 1] != NULL)
{
TgNodePtr tn;
tn = connectTee(r, fromNodePtr, toNodePtr, fromPort, toPort);
addArr_TgNodePtr(r->allNodes, &tn);
}
else
{
fromNodePtr->outNodes->val[fromPort - 1] = toNodePtr;
toNodePtr->inNodes->val[toPort - 1] = fromNodePtr;
}
}
PQclear(pbufname);
}
/*
handle tee connections here
Everytime an output port is connected multiply,
we explicitly insert TgTeeNode
returns the teeNode created
*/
static TgNode *
connectTee(TgRecipe * r, TgNodePtr fromNode, TgNodePtr toNode,
int fromPort, int toPort)
{
TgNodePtr origToNode;
TgNodePtr tn;
TgNodePtr BlankNodePtr;
int origToPort;
int i;
/* the toNode formerly pointed to */
origToNode = fromNode->outNodes->val[fromPort - 1];
if (origToNode == NULL)
{
elog(WARNING, "Internal Error: connectTee() called with a null origToNode");
return;
}
for (i = 0; i < origToNode->inNodes->num; i++)
{
if (origToNode->inNodes->val[i] == fromNode)
break;
}
/* the inport of the former toNode */
/* ports start with 1, array indices start from 0 */
origToPort = i + 1;
/* add a tee node now. */
tn = malloc(sizeof(TgNode));
/* generate a name for the tee node table */
tn->nodeName = malloc(50);
sprintf(tn->nodeName, "tee_%u", newoid());
/* tn->nodeName = NULL; */
tn->nodeType = TG_TEE_NODE;
tn->nodeElem = NULL;
tn->inNodes = newArr_TgNodePtr();
tn->outNodes = newArr_TgNodePtr();
BlankNodePtr = (TgNodePtr) NULL;
/* each TgTeeNode has one input and two outputs, NULL them initiallly */
addArr_TgNodePtr(tn->inNodes, &BlankNodePtr);
addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
/*
* make the old toNode the left parent of the tee node add the new
* toNode as the right parent of the tee node
*/
tn->outNodes->val[0] = origToNode;
origToNode->inNodes->val[origToPort - 1] = tn;
tn->outNodes->val[1] = toNode;
toNode->inNodes->val[toPort - 1] = tn;
/* connect the fromNode to the new tee node */
fromNode->outNodes->val[fromPort - 1] = tn;
tn->inNodes->val[0] = fromNode;
return tn;
}
/* -------------------------------------
fillAllNodes
fill out the nodes of a recipe
------------------------------------ */
void
fillAllNodes(TgRecipe * r, char *name)
{
char qbuf[MAX_QBUF_LENGTH];
int i;
char *pqres;
char *pbufname;
PortalBuffer *pbuf;
int ntups;
TgElement *elem;
TgNode *node;
/* 1) fill out the elements that are in the recipe */
sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
pqres = PQexec(qbuf);
if (*pqres == 'R' || *pqres == 'E')
{
elog(WARNING, "fillAllNodes(): Error while executing query : %s\n", qbuf);
elog(WARNING, "result = %s, error is %s\n", pqres, PQerrormsg);
return;
}
pbufname = ++pqres;
pbuf = PQparray(pbufname);
ntups = PQntuplesGroup(pbuf, 0);
for (i = 0; i < ntups; i++)
{
elem = malloc(sizeof(TgElement));
fillTgElement(elem, pbuf, i);
addArr_TgElementPtr(r->elements, &elem);
}
PQclear(pbufname);
sprintf(qbuf, Q_RETRIEVE_NODES_IN_RECIPE, name);
pqres = PQexec(qbuf);
if (*pqres == 'R' || *pqres == 'E')
{
elog(WARNING, "fillAllNodes(): Error while executing query : %s\n", qbuf);
elog(WARNING, "result = %s, error is %s\n", pqres, PQerrormsg);
return;
}
pbufname = ++pqres;
pbuf = PQparray(pbufname);
ntups = PQntuplesGroup(pbuf, 0);
for (i = 0; i < ntups; i++)
{
node = malloc(sizeof(TgNode));
fillTgNode(r, node, pbuf, i);
addArr_TgNodePtr(r->allNodes, &node);
}
PQclear(pbufname);
}
/* -------------------------------------
fillAllElements
fill out the elements of a recipe
------------------------------------ */
void
fillAllElements(TgRecipe * r, char *name)
{
char qbuf[MAX_QBUF_LENGTH];
int i;
char *pqres;
char *pbufname;
PortalBuffer *pbuf;
int ntups;
TgElement *elem;
sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
pqres = PQexec(qbuf);
if (*pqres == 'R' || *pqres == 'E')
{
elog(WARNING, "fillAllElements(): Error while executing query : %s\n", qbuf);
elog(WARNING, "result = %s, error is %s\n", pqres, PQerrormsg);
return;
}
pbufname = ++pqres;
pbuf = PQparray(pbufname);
ntups = PQntuplesGroup(pbuf, 0);
for (i = 0; i < ntups; i++)
{
elem = malloc(sizeof(TgElement));
fillTgElement(elem, pbuf, i);
addArr_TgElementPtr(r->elements, &elem);
}
PQclear(pbufname);
}
/* -------------------------------------
fillTgRecipe
takes a query result in the PortalBuffer containing a Recipe
and converts it to a C TgRecipe strcture
------------------------------------ */
TgRecipe *
fillTgRecipe(PortalBuffer * pbuf, int tupno)
{
TgRecipe *r;
int i,
j;
/* 1) set up the recipe structure */
r = (TgRecipe *) malloc(sizeof(TgRecipe));
fillTgElement(&r->elmValue, pbuf, 0);
r->elmValue.elemType = TG_RECIPE;
r->allNodes = newArr_TgNodePtr();
r->rootNodes = newArr_TgNodePtr();
r->eyes = newArr_TgNodePtr();
r->tees = newArr_TgNodePtr();
r->elements = newArr_TgElementPtr();
/*
* 2) find all the elements. There may be less elements than nodes
* because you can have multiple instantiations of an element in a
* recipe
*/
fillAllElements(r, r->elmValue.elemName);
/* 3) find all the nodes in the recipe */
fillAllNodes(r, r->elmValue.elemName);
/*
* 4) find all the edges, and connect the nodes, may also add tee
* nodes to the allNodes field
*/
lookupEdges(r, r->elmValue.elemName);
/* 5) find all the rootNodes in the recipe */
/*
* root nodes are nodes with no incoming nodes or whose incoming nodes
* are all null
*/
/* 6) find all the eyes in the recipe */
/* eye nodes are nodes with the node type TG_EYE_NODE */
/* 7) find all the tee nodes in the recipe */
/* tee nodes are nodes with the node type TG_TEE_NODE */
for (i = 0; i < r->allNodes->num; i++)
{
TgNode *nptr = r->allNodes->val[i];
if (nptr->nodeType == TG_EYE_NODE)
addArr_TgNodePtr(r->eyes, &nptr);
else if (nptr->nodeType == TG_TEE_NODE)
addArr_TgNodePtr(r->tees, &nptr);
if (nptr->inNodes->num == 0)
addArr_TgNodePtr(r->rootNodes, &nptr);
else
{
for (j = 0;
j < nptr->inNodes->num && (nptr->inNodes->val[j] == NULL);
j++);
if (j == nptr->inNodes->num)
addArr_TgNodePtr(r->rootNodes, &nptr);
}
}
return r;
}
/* -------------------------------------
retrieveRecipe
find the recipe with the given name
------------------------------------ */
TgRecipe *
retrieveRecipe(char *name)
{
char qbuf[MAX_QBUF_LENGTH];
TgRecipe *recipe;
char *pqres;
char *pbufname;
PortalBuffer *pbuf;
int ntups;
sprintf(qbuf, Q_RETRIEVE_RECIPE_BYNAME, name);
pqres = PQexec(qbuf);
if (*pqres == 'R' || *pqres == 'E')
{
elog(WARNING, "retrieveRecipe: Error while executing query : %s\n", qbuf);
elog(WARNING, "result = %s, error is %s\n", pqres, PQerrormsg);
return NULL;
}
pbufname = ++pqres;
pbuf = PQparray(pbufname);
ntups = PQntuplesGroup(pbuf, 0);
if (ntups == 0)
{
elog(WARNING, "retrieveRecipe(): No recipe named %s exists\n", name);
return NULL;
}
if (ntups != 1)
{
elog(WARNING, "retrieveRecipe(): Multiple (%d) recipes named %s exists\n", ntups, name);
return NULL;
}
recipe = fillTgRecipe(pbuf, 0);
PQclear(pbufname);
return recipe;
}
/* -------------------- copyXXX functions ----------------------- */
void
copyTgElementPtr(TgElementPtr * from, TgElementPtr * to)
{
*to = *from;
}
void
copyTgNodePtr(TgNodePtr * from, TgNodePtr * to)
{
*to = *from;
}
void
copyTgRecipePtr(TgRecipePtr * from, TgRecipePtr * to)
{
*to = *from;
}
void
copyTgString(TgString * from, TgString * to)
{
TgString fromTgString = *from;
TgString toTgString;
toTgString = (TgString) malloc(strlen(fromTgString) + 1);
strcpy(toTgString, fromTgString);
*to = toTgString;
}
src/backend/tioga/tgRecipe.h deleted 100644 → 0
View file @ fbb1966c
/*-------------------------------------------------------------------------
*
* tgRecipe.h
* Tioga recipe-related definitions and declarations
* these functions can be used in both the frontend and the
* backend
*
* to use this header, you must also include
* "utils/geo-decls.h"
* and "libpq/libpq.h"
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: tgRecipe.h,v 1.23 2002/06/20 20:29:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "libpq/libpq.h"
#ifndef TIOGA_FRONTEND
#include "libpq/libpq-be.h"
#include "utils/geo-decls.h"
#else
#include "libpq-fe.h"
typedef struct
{
double x,
y;
} Point; /* this should match whatever is in
*
*
*
* geo-decls.h */
#endif /* TIOGA_FRONTEND */
typedef enum
{
TG_INGRED,
TG_EYE,
TG_RECIPE
} TgElemType;
typedef enum
{
TG_SQL,
TG_C,
TG_RECIPE_GRAPH,
TG_COMPILED
} TgSrcLangType;
typedef enum
{
TG_INGRED_NODE,
TG_EYE_NODE,
TG_RECIPE_NODE,
TG_TEE_NODE /* tee nodes are not stored in the db we
* create them when we read the recipe
* back */
} TgNodeType;
/* -- type definition for setting up in memory Tioga recipe structure -- */
/* -- see 'recipe-schema.sql' for their corresponding database types -- */
typedef char *TgString;
typedef struct _tgelement *TgElementPtr;
typedef struct _tgnode *TgNodePtr;
typedef struct _tgrecipe *TgRecipePtr;
/* auto-generated header containing Arr_TgString, Arr_TgElementPtr,
and Arr_TgNodePtr */
#include "tioga/Arr_TgRecipe.h"
/* C structure representation of a Tioga Element */
typedef struct _tgelement
{
char *elemName; /* name of function this element represent */
TgElemType elemType; /* type of this element */
Arr_TgString *inPorts; /* names of inputs */
Arr_TgString *inTypes; /* name of input types */
Arr_TgString *outPorts; /* type of output */
Arr_TgString *outTypes; /* name of output types */
char *doc; /* description of this element */
Arr_TgString *keywords; /* keywords used to search for this
* element */
char *icon; /* iconic representation */
char *src; /* source code for this element */
TgSrcLangType srcLang; /* source language */
char *owner; /* owner recipe name */
} TgElement;
/* C structure representation of a Tioga Node */
typedef struct _tgnode
{
char *nodeName; /* name of this node */
TgNodeType nodeType; /* type of this node */
Point loc; /* screen location of the node. */
TgElement *nodeElem; /* the underlying element of this node */
Arr_TgNodePtr *inNodes; /* variable array of in node pointers a
* NULL TgNodePtr indicates a run-time
* parameter */
Arr_TgNodePtr *outNodes; /* variable array of out node pointers. */
} TgNode;
/* C structure representation of a Tioga Recipe */
typedef struct _tgrecipe
{
TgElement elmValue; /* "inherits" TgElement attributes. */
Arr_TgNodePtr *allNodes; /* array of all nodes for this recipe. */
Arr_TgNodePtr *rootNodes; /* array of root nodes for this recipe.
* root nodes are nodes with no parents */
Arr_TgNodePtr *eyes; /* array of pointers for the browser nodes
* recipe, execution of recipe starts by
* traversing the recipe C structure from
* the eye nodes pointed by these
* pointers. */
Arr_TgNodePtr *tees; /* array of pointers of all the tee nodes */
Arr_TgElementPtr *elements; /* array of all the elements in this
* recipe, elements may be shared by
* multiple nodes */
} TgRecipe;
/* functions defined in tgRecipe.c */
extern TgRecipe *retrieveRecipe(char *name);
extern TgElement *findElemInRecipe(TgRecipe * r, char *elemName);
extern TgNode *findNodeInRecipe(TgRecipe * r, char *nodeName);
/* ---- copyXXX functions ---- */
extern void copyTgElementPtr(TgElementPtr *, TgElementPtr *);
extern void copyTgNodePtr(TgNodePtr *, TgNodePtr *);
extern void copyTgRecipePtr(TgRecipePtr *, TgRecipePtr *);
extern void copyTgString(TgString *, TgString *);
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment